Changeset 3721


Ignore:
Timestamp:
07/31/11 14:00:54 (7 years ago)
Author:
kozmo
Message:
  • Removed unnecessary alpha value for lighting as well as alpha reference for alpha test [t:557]
  • Removed appropriate fields in light editor
  • Reworked light model to be compatible with new render backend [t:556]
  • Changed layer z offset computation for new render backend to use more precisely part of depth buffer as it's not linear [t:556]
  • Added the ability for guichan to create atlas from its images on runtime - this is only applicable when using its image loader (see engine/python/fife/extensions/pychan/compat.py)
Location:
branches/active/0.3.3dev
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • branches/active/0.3.3dev/demos/rio_de_hola/scripts/world.py

    r3704 r3721  
    387387 
    388388                        if self.lightmodel == 1: 
    389                                 self.cameras['main'].setLightingColor(self.light_intensity, self.light_intensity, self.light_intensity, 1.0) 
    390  
    391                         if self.lightmodel == 2: 
    392                                 self.cameras['main'].setLightingColor(0, 0, 0, 1-self.light_intensity) 
     389                                self.cameras['main'].setLightingColor(self.light_intensity, self.light_intensity, self.light_intensity) 
    393390 
    394391        def lightSourceIntensity(self, value): 
     
    410407                                for beekeeper in self.beekeepers: 
    411408                                        node = fife.RendererNode(beekeeper.agent) 
    412                                         renderer.addSimpleLight("beekeeper_simple_light", node, self.light_sources, 120, 32, 1, 1, 255, 255, 255) 
    413  
    414                         if self.lightmodel == 2: 
    415                                 node = fife.RendererNode(self.hero.agent) 
    416                                 renderer.addSimpleLight("hero_simple_light", node, self.light_sources, 64, 32, 1, 1, 0, 0, 0) 
    417                                 renderer.addStencilTest("hero_simple_light") 
    418  
    419                                 node = fife.RendererNode(self.girl.agent)                
    420                                 renderer.addSimpleLight("girl_simple_light", node, self.light_sources, 64, 32, 1, 1, 0, 0, 0) 
    421                                 renderer.addStencilTest("girl_simple_light") 
    422  
    423                                 for beekeeper in self.beekeepers: 
    424                                         node = fife.RendererNode(beekeeper.agent) 
    425                                         renderer.addSimpleLight("beekeeper_simple_light", node, 255, 120, 32, 1, 1, 0, 0, 0) 
    426                                         renderer.addStencilTest("beekeeper_simple_light")                                
     409                                        renderer.addSimpleLight("beekeeper_simple_light", node, self.light_sources, 120, 32, 1, 1, 255, 255, 255)                
    427410 
    428411        def onConsoleCommand(self, command): 
  • branches/active/0.3.3dev/engine/core/gui/guichan/base/gui_imageloader.cpp

    r3687 r3721  
    3030#include "video/image.h" 
    3131#include "video/imagemanager.h" 
     32#include "video/atlasbook.h" 
     33#include "video/renderbackend.h" 
    3234 
    3335#include "gui_imageloader.h" 
    3436 
     37static const int ATLAS_SIZE = 1024; 
     38 
    3539namespace FIFE { 
    3640        GuiImageLoader::GuiImageLoader() { 
     41                m_atlasbook = new AtlasBook(ATLAS_SIZE, ATLAS_SIZE); 
     42        } 
     43 
     44        GuiImageLoader::~GuiImageLoader() { 
     45                delete m_atlasbook; 
    3746        } 
    3847 
    3948        gcn::Image* GuiImageLoader::load(const std::string& filename, bool convertToDisplayFormat) { 
    40                 ImagePtr img = ImageManager::instance()->create(filename); 
     49                ImageManager* imgManager = ImageManager::instance(); 
     50 
     51                if(imgManager->exists(filename)) { 
     52                        return new GuiImage(imgManager->get(filename)); 
     53                } 
     54                // load demanded image 
     55                ImagePtr tmpimg = imgManager->load(filename); 
     56                if(tmpimg->getWidth() >= ATLAS_SIZE || tmpimg->getHeight() >= ATLAS_SIZE) { 
     57                        return new GuiImage(tmpimg); 
     58                } 
     59                // look for a place for an image of given size 
     60                AtlasBlock* block = m_atlasbook->getBlock(tmpimg->getWidth(), tmpimg->getHeight()); 
     61 
     62                // if it can't fit, we need to add new 'page' 
     63                if(block->page >= m_atlases.size()) { 
     64                        m_atlases.push_back(imgManager->loadBlank(ATLAS_SIZE, ATLAS_SIZE)); 
     65 
     66                        // because we gonna update texture on-the fly (via TexSubImage) 
     67                        // we cant really use compressed texture  
     68                        RenderBackend* rb = RenderBackend::instance(); 
     69                        bool prev = rb->isImageCompressingEnabled(); 
     70                        rb->setImageCompressingEnabled(false); 
     71                        m_atlases[block->page]->forceLoadInternal(); 
     72                        rb->setImageCompressingEnabled(prev); 
     73                } 
     74                 
     75                // update atlas page with given image 
     76                m_atlases[block->page]->copySubimage(block->left, block->top, tmpimg); 
     77         
     78                // we dont really need this image anymore  
     79                tmpimg->free(); 
     80                imgManager->remove(tmpimg); 
     81 
     82                // create shared image and return it 
     83                ImagePtr img = imgManager->create(filename); 
     84                Rect region(block->left, block->top, block->getWidth(), block->getHeight()); 
     85                img->useSharedImage(m_atlases[block->page], region); 
     86 
    4187                return new GuiImage(img); 
    4288        } 
  • branches/active/0.3.3dev/engine/core/gui/guichan/base/gui_imageloader.h

    r3687 r3721  
    3636 
    3737namespace FIFE { 
     38        class AtlasBook; 
    3839 
    3940        /* Image Loader. 
     
    4243        public: 
    4344                GuiImageLoader(); 
    44                 gcn::Image* load(const std::string& filename, bool convertToDisplayFormat = true); 
     45                virtual ~GuiImageLoader(); 
     46        virtual gcn::Image* load(const std::string& filename, bool convertToDisplayFormat = true); 
    4547        private: 
    46  
     48                AtlasBook* m_atlasbook; 
     49                std::vector<ImagePtr> m_atlases; 
    4750        }; 
    4851 
  • branches/active/0.3.3dev/engine/core/video/image.h

    r3715 r3721  
    8282                 */ 
    8383                virtual void render(const Rect& rect, uint8_t alpha = 255, uint8_t const* rgb = 0) = 0; 
    84                 virtual void renderZ(const Rect& rect, float vertexZ, uint8_t alpha = 255, uint8_t const* rgb = 0) {} 
     84                virtual void renderZ(const Rect& rect, float vertexZ, uint8_t alpha = 255, bool forceNewBatch = false, uint8_t const* rgb = 0) {} 
    8585 
    8686                /** Removes underlying SDL_Surface from the image (if exists) and returns this 
     
    149149                /** Copies given image into this one with respect to given offsets 
    150150                 */ 
    151                 void copySubimage(uint32_t xoffset, uint32_t yoffset, const ImagePtr& img); 
     151                virtual void copySubimage(uint32_t xoffset, uint32_t yoffset, const ImagePtr& img); 
    152152 
    153153        protected: 
  • branches/active/0.3.3dev/engine/core/video/opengl/glimage.cpp

    r3716 r3721  
    111111        void GLImage::cleanup() { 
    112112                if (m_texId) { 
    113                         glDeleteTextures(1, &m_texId); 
     113                        if(!m_shared) { 
     114                                glDeleteTextures(1, &m_texId); 
     115                        } 
    114116                        m_texId = 0; 
    115117                        m_compressed = false; 
     
    291293        } 
    292294 
     295        void GLImage::copySubimage(uint32_t xoffset, uint32_t yoffset, const ImagePtr& img) { 
     296                Image::copySubimage(xoffset, yoffset, img); 
     297 
     298                if(m_texId) { 
     299                        static_cast<RenderBackendOpenGL*>(RenderBackend::instance())->bindTexture(m_texId); 
     300                        glTexSubImage2D(GL_TEXTURE_2D, 0, xoffset, yoffset, img->getWidth(), img->getHeight(), 
     301                                GL_RGBA, GL_UNSIGNED_BYTE, img->getSurface()->pixels); 
     302                } 
     303        } 
     304 
    293305        GLuint GLImage::getTexId() const { 
    294306                return m_texId; 
  • branches/active/0.3.3dev/engine/core/video/opengl/glimage.h

    r3715 r3721  
    6666                virtual void useSharedImage(const ImagePtr& shared, const Rect& region); 
    6767                virtual void forceLoadInternal(); 
     68                virtual void copySubimage(uint32_t xoffset, uint32_t yoffset, const ImagePtr& img); 
    6869 
    6970                GLuint getTexId() const; 
  • branches/active/0.3.3dev/engine/core/video/opengl/renderbackendopengl.cpp

    r3720 r3721  
    311311        void RenderBackendOpenGL::setLightingModel(uint32_t lighting) { 
    312312                if (m_state.lightmodel != lighting) { 
    313                         if (m_state.lightmodel == 1) { 
     313                        if (m_state.lightmodel != 0) { 
    314314                                disableLighting(); 
    315315                                glDisable(GL_COLOR_MATERIAL); 
    316                         } else if (lighting == 1) { 
     316                        } else if (lighting != 0) { 
    317317                                enableLighting(); 
    318318                                glEnable(GL_LIGHT0); 
     
    320320                                glEnable(GL_COLOR_MATERIAL); 
    321321                        } 
    322                         m_state.lightmodel = lighting; 
     322                        m_state.lightmodel = lighting;                   
    323323                } 
    324324        } 
     
    380380 
    381381        void RenderBackendOpenGL::enableLighting() { 
    382                 if (m_state.lightmodel == 1 && !m_state.light_enabled) { 
     382                if (m_state.lightmodel != 0 && !m_state.light_enabled) { 
    383383                        glEnable(GL_LIGHTING); 
    384384                        m_state.light_enabled = true; 
     
    387387 
    388388        void RenderBackendOpenGL::disableLighting() { 
    389                 if (m_state.lightmodel == 1 && m_state.light_enabled) { 
     389                if (m_state.lightmodel != 0 && m_state.light_enabled) { 
    390390                        glDisable(GL_LIGHTING); 
    391391                        m_state.light_enabled = false; 
     
    393393        } 
    394394 
    395         void RenderBackendOpenGL::setLighting(float red, float green, float blue, float alpha) { 
    396                 if (m_state.lightmodel == 1) { 
    397                         GLfloat lightDiffuse[] = {red, green, blue, alpha}; 
     395        void RenderBackendOpenGL::setLighting(float red, float green, float blue) { 
     396                if (m_state.lightmodel != 0) { 
     397                        GLfloat lightDiffuse[] = {red, green, blue, 1.0f}; 
    398398                        glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse); 
    399                 } else if(m_state.lightmodel == 2) { 
    400                         m_state.lred = red; 
    401                         m_state.lgreen = green; 
    402                         m_state.lblue = blue; 
    403                         m_state.lalpha = alpha; 
    404399                } 
    405400        } 
    406401 
    407402        void RenderBackendOpenGL::resetLighting() { 
    408                 if (m_state.lightmodel == 1) { 
    409                         setLighting(1.0, 1.0, 1.0, 1.0); 
    410                 } else if (m_state.lightmodel == 2 && m_state.lalpha > 0.01) { 
    411                         uint16_t width = getScreenWidth(); 
    412                         uint16_t height = getScreenHeight(); 
    413                         Point p = Point(0,0); 
    414                         fillRectangle(p, width, height, 
    415                                 static_cast<uint8_t>(m_state.lred*255.0f), 
    416                                 static_cast<uint8_t>(m_state.lgreen*255.0f), 
    417                                 static_cast<uint8_t>(m_state.lblue*255.0f), 
    418                                 static_cast<uint8_t>(m_state.lalpha*255.0f)); 
    419                         changeRenderInfos(1, 4, 5, false, true, 0, KEEP, EQUAL); 
     403                if (m_state.lightmodel != 0) { 
     404                        setLighting(1.0, 1.0, 1.0); 
    420405                } 
    421406        } 
     
    641626                        uint32_t* currentElements = &elements; 
    642627 
    643                         int t=0; 
    644  
    645                         for(std::vector<RenderObject>::iterator ir = m_render_objects.begin(); ir != m_render_objects.end(); ++ir, t++) { 
     628                        for(std::vector<RenderObject>::iterator ir = m_render_objects.begin(); ir != m_render_objects.end(); ++ir) { 
    646629                                RenderObject& ro = (*ir); 
    647630 
     
    660643                                                render = true; 
    661644                                        } 
    662                                         if (ro.light != m_state.light_enabled && m_state.lightmodel == 1) { 
     645                                        if (ro.light != m_state.light_enabled) { 
    663646                                                light = true; 
    664647                                                render = true; 
     
    954937 
    955938        void RenderBackendOpenGL::drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue) { 
    956                 uint8_t alpha = intensity; 
    957                 if (m_state.lightmodel != 2) { 
    958                         alpha = 255; 
    959                 } 
    960939                const float step = Mathf::twoPi()/subdivisions; 
    961940                renderData rd;; 
     
    969948                        m_render_datas.push_back(rd); 
    970949 
    971                         rd.vertex[0] = radius*Mathf::Cos(angle)*xstretch + p.x; 
    972                         rd.vertex[1] = radius*Mathf::Sin(angle)*ystretch + p.y; 
     950                        rd.vertex[0] = radius*Mathf::Cos(angle+step)*xstretch + p.x; 
     951                        rd.vertex[1] = radius*Mathf::Sin(angle+step)*ystretch + p.y; 
    973952                        rd.color[0] = 0; 
    974953                        rd.color[1] = 0; 
    975954                        rd.color[2] = 0; 
    976                         rd.color[3] = alpha; 
     955                        rd.color[3] = 255; 
    977956                        m_render_datas.push_back(rd); 
    978957 
    979                         rd.vertex[0] = radius*Mathf::Cos(angle+step)*xstretch + p.x; 
    980                         rd.vertex[1] = radius*Mathf::Sin(angle+step)*ystretch + p.y; 
     958                        rd.vertex[0] = radius*Mathf::Cos(angle)*xstretch + p.x; 
     959                        rd.vertex[1] = radius*Mathf::Sin(angle)*ystretch + p.y; 
    981960                        m_render_datas.push_back(rd); 
    982961                         
     
    1015994 
    1016995                        RenderObject ro(GL_QUADS, 4, id); 
    1017                 m_render_objects.push_back(ro); 
     996                        m_render_objects.push_back(ro); 
    1018997                } else { 
    1019998                        renderData2T rd; 
     
    10811060                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); 
    10821061                glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE); 
    1083                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);  
     1062                glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);  
    10841063 
    10851064                // Arg0 
  • branches/active/0.3.3dev/engine/core/video/opengl/renderbackendopengl.h

    r3720 r3721  
    5252                virtual void setLightingModel(uint32_t lighting); 
    5353                virtual uint32_t getLightingModel() const; 
    54                 virtual void setLighting(float red, float green, float blue, float alpha); 
     54                virtual void setLighting(float red, float green, float blue); 
    5555                virtual void resetLighting(); 
    5656                virtual void resetStencilBuffer(uint8_t buffer); 
     
    7979                virtual void drawQuad(const Point& p1, const Point& p2, const Point& p3, const Point& p4,  uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255); 
    8080                virtual void drawVertex(const Point& p, const uint8_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255); 
    81                 virtual void drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue); 
     81                void drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue); 
    8282 
    8383                virtual void attachRenderTarget(ImagePtr& img, bool discard); 
     
    150150                        // Light 
    151151                        uint32_t lightmodel; 
    152                         float lred; 
    153                         float lgreen; 
    154                         float lblue; 
    155                         float lalpha; 
    156152                        bool light_enabled; 
    157153 
  • branches/active/0.3.3dev/engine/core/video/opengle/gleimage.cpp

    r3716 r3721  
    110110        void GLeImage::cleanup() { 
    111111                if (m_texId) { 
    112                         glDeleteTextures(1, &m_texId); 
     112                        if (!m_shared) { 
     113                                glDeleteTextures(1, &m_texId); 
     114                        } 
    113115                        m_texId = 0; 
    114116                        m_compressed = false; 
     
    147149        } 
    148150 
    149         void GLeImage::renderZ(const Rect& rect, float vertexZ, uint8_t alpha, uint8_t const* rgb) { 
     151        void GLeImage::renderZ(const Rect& rect, float vertexZ, uint8_t alpha, bool forceNewBatch, uint8_t const* rgb) { 
    150152                if(renderCheck(rect, alpha)) { 
    151153                        static_cast<RenderBackendOpenGLe*>(RenderBackend::instance())->addImageToArrayZ( 
    152                                 m_texId, rect, vertexZ, m_tex_coords, alpha, rgb); 
     154                                m_texId, rect, vertexZ, m_tex_coords, alpha, forceNewBatch, rgb); 
     155                } 
     156        } 
     157 
     158        void GLeImage::renderLightmap(const Rect& rect, const GLRenderState& state) { 
     159                if(renderCheck(rect, 255)) { 
     160                        static_cast<RenderBackendOpenGLe*>(RenderBackend::instance())->drawLightmap( 
     161                                m_texId, rect, m_tex_coords, state); 
    153162                } 
    154163        } 
     
    303312        } 
    304313 
     314        void GLeImage::copySubimage(uint32_t xoffset, uint32_t yoffset, const ImagePtr& img) { 
     315                Image::copySubimage(xoffset, yoffset, img); 
     316 
     317                if(m_texId) { 
     318                        static_cast<RenderBackendOpenGLe*>(RenderBackend::instance())->bindTexture(m_texId); 
     319                        glTexSubImage2D(GL_TEXTURE_2D, 0, xoffset, yoffset, img->getWidth(), img->getHeight(), 
     320                                GL_RGBA, GL_UNSIGNED_BYTE, img->getSurface()->pixels); 
     321                } 
     322        } 
     323 
    305324        GLuint GLeImage::getTexId() const { 
    306325                return m_texId; 
  • branches/active/0.3.3dev/engine/core/video/opengle/gleimage.h

    r3715 r3721  
    4040 
    4141namespace FIFE { 
     42        struct GLRenderState; 
    4243 
    4344        /** Implements an Image using experimental OpenGL. 
     
    6364                virtual void setSurface(SDL_Surface* surface); 
    6465                virtual void render(const Rect& rect, uint8_t alpha = 255, uint8_t const* rgb = 0); 
    65                 virtual void renderZ(const Rect& rect, float vertexZ, uint8_t alpha = 255, uint8_t const* rgb = 0); 
     66                virtual void renderZ(const Rect& rect, float vertexZ, uint8_t alpha = 255, bool forceNewBatch = false, uint8_t const* rgb = 0); 
    6667                virtual void useSharedImage(const ImagePtr& shared, const Rect& region); 
    6768                virtual void forceLoadInternal(); 
     69                virtual void copySubimage(uint32_t xoffset, uint32_t yoffset, const ImagePtr& img); 
     70 
     71                void renderLightmap(const Rect& rect, const GLRenderState& state); 
    6872 
    6973                GLuint getTexId() const; 
  • branches/active/0.3.3dev/engine/core/video/opengle/renderbackendopengle.cpp

    r3720 r3721  
    3636#include "SDL_image.h" 
    3737 
    38 #define ALPHA_REF 0.2f 
     38#define ALPHA_REF 0.3f 
    3939 
    4040 
     
    4747                        mode(m), 
    4848                        size(s), 
    49                         texture_id(t), 
    50                         src(4), 
    51                         dst(5), 
    52                         light(true), 
    53                         stencil_test(false), 
    54                         stencil_ref(0), 
    55                         stencil_op(0), 
    56                         stencil_func(0), 
    57                         multitextured(false) {} 
     49                        texture_id(t) { 
     50                } 
    5851 
    5952                GLenum mode; 
    6053                uint16_t size; 
    6154                uint32_t texture_id; 
    62                 int32_t src; 
    63                 int32_t dst; 
    64                 bool light; 
    65                 bool stencil_test; 
    66                 uint8_t stencil_ref; 
    67                 GLenum stencil_op; 
    68                 GLenum stencil_func; 
    69                 bool multitextured; 
    7055                uint8_t rgb[3]; 
    7156        }; 
    7257 
    73         const float RenderBackendOpenGLe::zfar =   200.0f; 
    74         const float RenderBackendOpenGLe::znear = -200.0f; 
     58        class RenderBackendOpenGLe::RenderObjectLight { 
     59        public: 
     60                RenderObjectLight(GLenum m, uint16_t s, uint32_t t=0): 
     61                        mode(m), 
     62                        size(s), 
     63                        texture_id(t) { 
     64                 } 
     65 
     66                GLenum mode; 
     67                uint16_t size; 
     68                uint32_t texture_id; 
     69                GLRenderState state; 
     70        }; 
     71 
     72        const float RenderBackendOpenGLe::zfar =   100.0f; 
     73        const float RenderBackendOpenGLe::znear = -100.0f; 
     74 
     75        static const int max_quads_per_texbatch = 600; 
     76        static const int max_tex = 400; // TODO: could do this expandable 
     77        static const int buffer_default_size = 4 * max_quads_per_texbatch * max_tex;     
    7578 
    7679        RenderBackendOpenGLe::RenderBackendOpenGLe(const SDL_Color& colorkey) 
     
    8386                m_state.active_tex = 0; 
    8487 
     88                m_state.lightmodel = 0; 
     89                m_state.light_enabled = false; 
     90 
    8591                m_state.sten_enabled = false; 
    8692                m_state.sten_ref = 0; 
     
    8894                m_state.sten_op = 0; 
    8995                m_state.sten_func = 0; 
    90  
    91                 m_state.lightmodel = 0; 
    92                 m_state.light_enabled = false; 
    9396 
    9497                m_state.env_color[0] = 0; 
     
    204207                glClearColor(0.0f, 0.0f, 0.0f, 0.0f); 
    205208                glClearDepth(1.0f); 
     209                glClearStencil(0); 
    206210 
    207211                glEnable(GL_BLEND); 
     
    210214                glAlphaFunc(GL_GREATER, ALPHA_REF); 
    211215                glEnable(GL_DEPTH_TEST); 
    212                 glDepthFunc(GL_LESS); 
     216                glDepthFunc(GL_LEQUAL); 
    213217 
    214218                glEnable(GL_SCISSOR_TEST); 
     
    225229                } 
    226230 
    227                 m_renderZ_datas.resize(4*500*500); 
    228                 m_renderZ_objects.clear(); 
     231                m_renderZ_datas.resize(buffer_default_size); 
    229232        } 
    230233 
     
    319322        void RenderBackendOpenGLe::setLightingModel(uint32_t lighting) { 
    320323                if (m_state.lightmodel != lighting) { 
    321                         if (m_state.lightmodel == 1) { 
     324                        if (m_state.lightmodel != 0) { 
    322325                                disableLighting(); 
    323326                                glDisable(GL_COLOR_MATERIAL); 
    324                         } else if (lighting == 1) { 
     327                        } else if (lighting != 0) { 
     328                                m_state.lightmodel = lighting;   
    325329                                enableLighting(); 
    326330                                glEnable(GL_LIGHT0); 
     
    328332                                glEnable(GL_COLOR_MATERIAL); 
    329333                        } 
    330                         m_state.lightmodel = lighting; 
     334                        m_state.lightmodel = lighting;                   
    331335                } 
    332336        } 
     
    388392 
    389393        void RenderBackendOpenGLe::enableLighting() { 
    390                 if (m_state.lightmodel == 1 && !m_state.light_enabled) { 
     394                if (m_state.lightmodel != 0 && !m_state.light_enabled) { 
    391395                        glEnable(GL_LIGHTING); 
    392396                        m_state.light_enabled = true; 
     
    395399 
    396400        void RenderBackendOpenGLe::disableLighting() { 
    397                 if (m_state.lightmodel == 1 && m_state.light_enabled) { 
     401                if (m_state.lightmodel != 0 && m_state.light_enabled) { 
    398402                        glDisable(GL_LIGHTING); 
    399403                        m_state.light_enabled = false; 
     
    401405        } 
    402406 
    403         void RenderBackendOpenGLe::setLighting(float red, float green, float blue, float alpha) { 
    404                 if (m_state.lightmodel == 1) { 
    405                         GLfloat lightDiffuse[] = {red, green, blue, alpha}; 
     407        void RenderBackendOpenGLe::setLighting(float red, float green, float blue) { 
     408                if (m_state.lightmodel != 0) { 
     409                        GLfloat lightDiffuse[] = {red, green, blue, 1.0f}; 
    406410                        glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse); 
    407                 } else if(m_state.lightmodel == 2) { 
    408                         m_state.lred = red; 
    409                         m_state.lgreen = green; 
    410                         m_state.lblue = blue; 
    411                         m_state.lalpha = alpha; 
    412411                } 
    413412        } 
    414413 
    415414        void RenderBackendOpenGLe::resetLighting() { 
    416                 if (m_state.lightmodel == 1) { 
    417                         setLighting(1.0, 1.0, 1.0, 1.0); 
    418                 } else if (m_state.lightmodel == 2 && m_state.lalpha > 0.01) { 
    419                         uint16_t width = getScreenWidth(); 
    420                         uint16_t height = getScreenHeight(); 
    421                         Point p = Point(0,0); 
    422                         fillRectangle(p, width, height, 
    423                                 static_cast<uint8_t>(m_state.lred*255.0f), 
    424                                 static_cast<uint8_t>(m_state.lgreen*255.0f), 
    425                                 static_cast<uint8_t>(m_state.lblue*255.0f), 
    426                                 static_cast<uint8_t>(m_state.lalpha*255.0f)); 
    427                         changeRenderInfos(1, 4, 5, false, true, 0, KEEP, EQUAL); 
    428                 } 
     415                m_state.light_enabled = false; 
    429416        } 
    430417 
     
    465452                glClear(GL_STENCIL_BUFFER_BIT); 
    466453                enableScissorTest(); 
    467         } 
    468  
    469         uint8_t RenderBackendOpenGLe::getStencilRef() const { 
    470                 return m_state.sten_ref; 
    471454        } 
    472455 
     
    570553        void RenderBackendOpenGLe::changeRenderInfos(uint16_t elements, int32_t src, int32_t dst, bool light, 
    571554                bool stentest, uint8_t stenref, GLConstants stenop, GLConstants stenfunc) { 
    572  
    573                 uint16_t count = 0; 
    574                 uint32_t size = m_render_objects.size(); 
    575                 while (count != elements) { 
    576                         ++count; 
    577                         RenderObject& r = m_render_objects.at(size-count); 
    578  
    579                         r.src = src; 
    580                         r.dst = dst; 
    581                         r.light = light; 
    582                         if (stentest) { 
    583                                 r.stencil_test = stentest; 
    584                                 r.stencil_ref = stenref; 
    585                                 r.stencil_op = stenop; 
    586                                 r.stencil_func = stenfunc; 
    587                         } 
    588                 } 
     555                // In this renderer we use slightly different method 
    589556        } 
    590557 
    591558        void RenderBackendOpenGLe::renderVertexArrays() { 
    592                 if(!m_renderZ_objects.empty()) { 
     559                // Rendering order: 
     560                // * batched ordinary, full opacity textured quads 
     561                // * outlines and unlit with optional stencil test on (write on) if light is enabled 
     562                // * colored overlays - full opacity and (semi)transparent  
     563                // * semi transparent textured quads (sorted by instancerenderer) 
     564                if(!m_renderZ_objects.empty() || !m_renderZ_objects_forced.empty()) { 
    593565                        renderWithZ(); 
    594566                } 
    595567 
     568                // * light primitives (textured quad and light primitives - both from lightrenderer) 
     569                if(!m_render_objects_light.empty()) { 
     570                        renderLights(); 
     571                } 
     572 
     573                // * everything else that doesn't use Z value or features like 
     574                //   stencil test/alpha test/colored overlays/semi transparency: 
     575                //    - different renderers (aside from instance and light ones) 
     576                //    - gui 
    596577                if(!m_render_objects.empty()) { 
    597578                        renderWithoutZ(); 
     
    603584                enableDepthTest(); 
    604585                enableTextures(0); 
    605  
    606                 // ordinary z-valued quads 
    607                 static const uint32_t stride = sizeof(RenderZData); 
    608  
    609                 glVertexPointer(3, GL_FLOAT, stride, &m_renderZ_datas[0].vertex); 
    610                 glTexCoordPointer(2, GL_FLOAT, stride, &m_renderZ_datas[0].texel); 
     586                enableLighting(); 
     587                glDisableClientState(GL_COLOR_ARRAY); 
    611588                 
    612                 std::vector<RenderZObject>::iterator iter = m_renderZ_objects.begin(); 
    613                 for ( ; iter != m_renderZ_objects.end(); ++iter) { 
    614                         bindTexture(iter->texture_id); 
    615                         glDrawArrays(GL_QUADS, iter->index, iter->elements); 
    616                 } 
    617                 m_renderZ_objects.clear(); 
    618  
    619                 // full opacity colored overlays 
     589                /* 1) ordinary z-valued quads */ { 
     590                        static const uint32_t stride = sizeof(RenderZData); 
     591 
     592                        glVertexPointer(3, GL_FLOAT, stride, &m_renderZ_datas[0].vertex); 
     593                        glTexCoordPointer(2, GL_FLOAT, stride, &m_renderZ_datas[0].texel); 
     594 
     595                        std::vector<RenderZObject>::iterator iter = m_renderZ_objects.begin(); 
     596                        for ( ; iter != m_renderZ_objects.end(); ++iter) { 
     597                                bindTexture(iter->texture_id); 
     598                                glDrawArrays(GL_QUADS, iter->index, iter->elements); 
     599                        } 
     600                        m_renderZ_objects.clear(); 
     601                } 
     602 
     603                // 2) forced batches (for unlit quads like outlines and unlit demanded instances) 
     604                if (!m_renderZ_objects_forced.empty()) { 
     605                        static const uint32_t stride = sizeof(RenderZData); 
     606 
     607                         
     608                        glVertexPointer(3, GL_FLOAT, stride, &m_renderZ_datas[0].vertex); 
     609                        glTexCoordPointer(2, GL_FLOAT, stride, &m_renderZ_datas[0].texel); 
     610                        setStencilTest(255, GL_REPLACE, GL_ALWAYS); 
     611                        disableLighting(); 
     612 
     613                        std::vector<RenderZObject>::iterator iter = m_renderZ_objects_forced.begin(); 
     614                        for ( ; iter != m_renderZ_objects_forced.end(); ++iter) { 
     615                                bindTexture(iter->texture_id); 
     616                                glDrawArrays(GL_QUADS, iter->index, iter->elements); 
     617                        } 
     618                        disableStencilTest(); 
     619                        enableLighting(); 
     620                        m_renderZ_objects_forced.clear(); 
     621                } 
     622 
     623                // now we gonna need color values 
     624                glEnableClientState(GL_COLOR_ARRAY); 
     625 
     626                // 3) full opacity and (semi)transparent colored overlays 
    620627                if (!m_render_objects2T.empty()) { 
    621628                        static const uint32_t stride = sizeof(RenderZData2T); 
     
    625632                        glActiveTexture(GL_TEXTURE0); 
    626633 
    627                         glEnableClientState(GL_COLOR_ARRAY); 
    628634                        glVertexPointer(3, GL_FLOAT, stride, &m_render_datas2T[0].vertex); 
    629635                        glColorPointer(4, GL_UNSIGNED_BYTE, stride, &m_render_datas2T[0].color); 
     
    666672                        glActiveTexture(GL_TEXTURE0); 
    667673 
    668                         glDisableClientState(GL_COLOR_ARRAY); 
    669  
    670674                        m_render_objects2T.clear(); 
    671675                        m_render_datas2T.clear(); 
    672676                } 
    673677 
     678                // we should stop using alpha test now 
    674679                disableAlphaTest(); 
    675680 
    676                 // now render (semi)transparent data (they are already sorted by instancerenderer) 
     681                // 4) now render (semi)transparent data (they are already sorted by instancerenderer) 
    677682                if (!m_render_trans_objects.empty()) { 
    678                         static const uint32_t strideTransparent = sizeof(RenderZData2T); 
    679  
    680                         glEnableClientState(GL_COLOR_ARRAY); 
    681                         glVertexPointer(3, GL_FLOAT, strideTransparent, &m_render_trans_datas[0].vertex); 
    682                         glColorPointer(4, GL_UNSIGNED_BYTE, strideTransparent, &m_render_trans_datas[0].color); 
    683  
    684                         //glClientActiveTexture(GL_TEXTURE1); 
    685                         //glTexCoordPointer(2, GL_FLOAT, strideTransparent, &m_render_trans_datas[0].texel2); 
     683                        static const uint32_t stride = sizeof(RenderZData2T); 
     684 
     685                        glVertexPointer(3, GL_FLOAT, stride, &m_render_trans_datas[0].vertex); 
     686                        glColorPointer(4, GL_UNSIGNED_BYTE, stride, &m_render_trans_datas[0].color); 
    686687                        glClientActiveTexture(GL_TEXTURE0); 
    687                         glTexCoordPointer(2, GL_FLOAT, strideTransparent, &m_render_trans_datas[0].texel); 
     688                        glTexCoordPointer(2, GL_FLOAT, stride, &m_render_trans_datas[0].texel); 
    688689                         
    689690                        // array index 
     
    713714                        glDrawArrays(GL_QUADS, index, elements); 
    714715 
    715                         glDisableClientState(GL_COLOR_ARRAY); 
    716  
    717716                        m_render_trans_datas.clear(); 
    718717                        m_render_trans_objects.clear(); 
     
    720719 
    721720                disableTextures(0); 
     721                disableDepthTest(); 
     722                disableLighting(); 
     723        } 
     724 
     725        void RenderBackendOpenGLe::renderLights() { 
     726                if (!m_render_objects_light.empty()) { 
     727                        enableAlphaTest(); 
     728 
     729                        static const uint32_t stride = sizeof(RenderData); 
     730 
     731                        glVertexPointer(2, GL_FLOAT, stride, &m_render_datas_lights[0].vertex); 
     732                        glTexCoordPointer(2, GL_FLOAT, stride, &m_render_datas_lights[0].texel); 
     733                        glColorPointer(4, GL_UNSIGNED_BYTE, stride, &m_render_datas_lights[0].color); 
     734 
     735                        //bools to indicate changes 
     736                        bool type = false; 
     737                        bool texture = false; 
     738                        bool blending = false; 
     739                        bool stencil = false; 
     740                        bool render = false; 
     741 
     742                        // array index 
     743                        int32_t index = 0; 
     744                        // elements to render 
     745                        uint32_t elements = 0; 
     746                        // render mode 
     747                        GLenum mode = GL_QUADS; 
     748                        // texture id 
     749                        uint32_t texture_id = 0; 
     750                        // src blending mode 
     751                        int32_t src = 4; 
     752                        // dst blending mode 
     753                        int32_t dst = 5; 
     754 
     755                        for(std::vector<RenderObjectLight>::iterator ir = m_render_objects_light.begin(); ir != m_render_objects_light.end(); ++ir) { 
     756                                RenderObjectLight& ro = (*ir); 
     757 
     758                                //first we look for changes 
     759                                if (ro.mode != mode) { 
     760                                        type = true; 
     761                                        render = true; 
     762                                } 
     763                                if (ro.texture_id != texture_id) { 
     764                                        texture = true; 
     765                                        render = true; 
     766                                } 
     767                                if (ro.state.src != src || ro.state.dst != dst) { 
     768                                        blending = true; 
     769                                        render = true; 
     770                                } 
     771                                if (ro.state.stencil_ref != m_state.sten_ref ||  
     772                                        ro.state.stencil_op != m_state.sten_op ||  
     773                                        ro.state.stencil_func != m_state.sten_func) { 
     774                                                stencil = true; 
     775                                                render = true; 
     776                                } 
     777                                // if changes then we render all previously elements 
     778                                if (render) { 
     779                                        if (elements > 0) { 
     780                                                //render 
     781                                                glDrawArrays(mode, index, elements); 
     782                                                index += elements; 
     783                                        } 
     784                                        // switch mode 
     785                                        if (type) { 
     786                                                mode = ro.mode; 
     787                                                type = false; 
     788                                        } 
     789 
     790                                        // switch texturing 
     791                                        if (texture) { 
     792                                                if (ro.texture_id != 0) { 
     793                                                        bindTexture(0, ro.texture_id); 
     794                                                        texture_id = ro.texture_id; 
     795                                                } else { 
     796                                                        disableTextures(0); 
     797                                                        texture_id = 0; 
     798                                                } 
     799                                                texture = false; 
     800                                        } 
     801 
     802                                        // set element to current size 
     803                                        elements = ro.size; 
     804 
     805                                        // change blending 
     806                                        if (blending) { 
     807                                                src = ro.state.src; 
     808                                                dst = ro.state.dst; 
     809                                                changeBlending(src, dst); 
     810                                                blending = false; 
     811                                        } 
     812                                        // change stencil 
     813                                        if (stencil) { 
     814                                                setStencilTest(ro.state.stencil_ref, ro.state.stencil_op, ro.state.stencil_func); 
     815                                                stencil = false; 
     816                                        } 
     817                                        render = false; 
     818                                } else { 
     819                                        // else add the element 
     820                                        elements += ro.size; 
     821                                } 
     822                        } 
     823                        // render 
     824                        glDrawArrays(mode, index, elements); 
     825 
     826                        changeBlending(4, 5); 
     827                        disableStencilTest(); 
     828                        disableTextures(0); 
     829 
     830                        m_render_datas_lights.clear(); 
     831                        m_render_objects_light.clear(); 
     832                } 
    722833        } 
    723834 
     
    726837                bool type = false; 
    727838                bool texture = false; 
    728                 bool blending = false; 
    729                 bool light = false; 
    730                 bool stencil = false; 
    731839                bool render = false; 
    732840 
     
    9641072        } 
    9651073 
    966         void RenderBackendOpenGLe::drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue) { 
    967                 uint8_t alpha = intensity; 
    968                 if (m_state.lightmodel != 2) { 
    969                         alpha = 255; 
    970                 } 
     1074        void RenderBackendOpenGLe::drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int32_t subdivisions, 
     1075                float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue, const GLRenderState& state) { 
    9711076                const float step = Mathf::twoPi()/subdivisions; 
    9721077                RenderData rd;; 
     
    9781083                        rd.color[2] = blue; 
    9791084                        rd.color[3] = intensity; 
    980                         m_render_datas.push_back(rd); 
    981  
    982                         rd.vertex[0] = radius*Mathf::Cos(angle)*xstretch + p.x; 
    983                         rd.vertex[1] = radius*Mathf::Sin(angle)*ystretch + p.y; 
     1085                        m_render_datas_lights.push_back(rd); 
     1086 
     1087                        rd.vertex[0] = radius*Mathf::Cos(angle+step)*xstretch + p.x; 
     1088                        rd.vertex[1] = radius*Mathf::Sin(angle+step)*ystretch + p.y; 
    9841089                        rd.color[0] = 0; 
    9851090                        rd.color[1] = 0; 
    9861091                        rd.color[2] = 0; 
    987                         rd.color[3] = alpha; 
    988                         m_render_datas.push_back(rd); 
    989  
    990                         rd.vertex[0] = radius*Mathf::Cos(angle+step)*xstretch + p.x; 
    991                         rd.vertex[1] = radius*Mathf::Sin(angle+step)*ystretch + p.y; 
    992                         m_render_datas.push_back(rd); 
    993  
    994                         RenderObject ro(GL_TRIANGLES, 3); 
    995                         m_render_objects.push_back(ro); 
    996                 } 
     1092                        rd.color[3] = 255; 
     1093                        m_render_datas_lights.push_back(rd); 
     1094 
     1095                        rd.vertex[0] = radius*Mathf::Cos(angle)*xstretch + p.x; 
     1096                        rd.vertex[1] = radius*Mathf::Sin(angle)*ystretch + p.y; 
     1097                        m_render_datas_lights.push_back(rd); 
     1098 
     1099                        RenderObjectLight ro(GL_TRIANGLES, 3); 
     1100                        ro.state = state; 
     1101                        m_render_objects_light.push_back(ro); 
     1102                } 
     1103        } 
     1104 
     1105        void RenderBackendOpenGLe::drawLightmap(uint32_t id, const Rect& rect, float const* st, const GLRenderState& state) { 
     1106                RenderData rd; 
     1107                rd.vertex[0] = static_cast<float>(rect.x); 
     1108                rd.vertex[1] = static_cast<float>(rect.y); 
     1109                rd.texel[0] = st[0]; 
     1110                rd.texel[1] = st[1]; 
     1111                rd.color[0] = 255; 
     1112                rd.color[1] = 255; 
     1113                rd.color[2] = 255; 
     1114                rd.color[3] = 255; 
     1115                m_render_datas_lights.push_back(rd); 
     1116 
     1117                rd.vertex[0] = static_cast<float>(rect.x); 
     1118                rd.vertex[1] = static_cast<float>(rect.y+rect.h); 
     1119                rd.texel[1] = st[3]; 
     1120                m_render_datas_lights.push_back(rd); 
     1121 
     1122                rd.vertex[0] = static_cast<float>(rect.x+rect.w); 
     1123                rd.vertex[1] = static_cast<float>(rect.y+rect.h); 
     1124                rd.texel[0] = st[2]; 
     1125                m_render_datas_lights.push_back(rd); 
     1126 
     1127                rd.vertex[0] = static_cast<float>(rect.x+rect.w); 
     1128                rd.vertex[1] = static_cast<float>(rect.y); 
     1129                rd.texel[1] = st[1]; 
     1130                m_render_datas_lights.push_back(rd); 
     1131 
     1132                RenderObjectLight ro(GL_QUADS, 4, id); 
     1133                ro.state = state; 
     1134                m_render_objects_light.push_back(ro); 
    9971135        } 
    9981136 
     
    10281166        } 
    10291167 
    1030         RenderBackendOpenGLe::RenderZObject* RenderBackendOpenGLe::getRenderBufferObject(GLuint texture_id) { 
    1031                 for (std::vector<RenderZObject>::iterator it = m_renderZ_objects.begin(); it != m_renderZ_objects.end(); ++it) {                 
    1032                         if (it->texture_id == texture_id) { 
    1033                                 if (it->elements < it->max_size - 4) { 
    1034                                         return &(*it);   
     1168        RenderBackendOpenGLe::RenderZObject* RenderBackendOpenGLe::getRenderBufferObject(GLuint texture_id, bool forceNewBatch) { 
     1169                if (!forceNewBatch) { 
     1170                        for (std::vector<RenderZObject>::iterator it = m_renderZ_objects.begin(); it != m_renderZ_objects.end(); ++it) {                 
     1171                                if (it->texture_id == texture_id) { 
     1172                                        if (it->elements < it->max_size - 4) { 
     1173                                                return &(*it);   
     1174                                        } 
    10351175                                } 
    10361176                        } 
    10371177                } 
    1038  
    1039                 // nothing is found, we need to create new one 
     1178                static int last_forced = 0; 
     1179 
     1180                // nothing was found (or we were forced to make new batch), we need to create new one 
    10401181                RenderZObject obj; 
    10411182                if (!m_renderZ_objects.empty()) { 
    10421183                        obj.index = m_renderZ_objects.back().index + m_renderZ_objects.back().max_size; 
     1184                        obj.index += last_forced * 4; 
    10431185                } else { 
    10441186                        obj.index = 0; 
     
    10461188                obj.texture_id = texture_id; 
    10471189                obj.elements = 0; 
    1048                 obj.max_size = 300 * 4; 
    1049                 m_renderZ_objects.push_back(obj); 
    1050                 return &m_renderZ_objects.back(); 
    1051         } 
    1052  
    1053         void RenderBackendOpenGLe::addImageToArrayZ(uint32_t id, const Rect& rect, float vertexZ, float const* st, uint8_t alpha, uint8_t const* rgb) { 
     1190                obj.max_size = forceNewBatch ? 4 : max_quads_per_texbatch * 4; 
     1191 
     1192                if (!forceNewBatch) { 
     1193                        last_forced = 0; 
     1194                        m_renderZ_objects.push_back(obj); 
     1195                        return &m_renderZ_objects.back(); 
     1196                } else { 
     1197                        ++last_forced; 
     1198                        m_renderZ_objects_forced.push_back(obj); 
     1199                        return &m_renderZ_objects_forced.back(); 
     1200                } 
     1201        } 
     1202 
     1203        void RenderBackendOpenGLe::addImageToArrayZ(uint32_t id, const Rect& rect, float vertexZ, float const* st, uint8_t alpha, bool forceNewBatch, uint8_t const* rgb) { 
    10541204                if (alpha == 255) { 
    10551205                        if (rgb == NULL) { 
    10561206                                // ordinary z-valued quad 
    1057                                 RenderZObject* renderObj = getRenderBufferObject(id); 
     1207                                RenderZObject* renderObj = getRenderBufferObject(id, forceNewBatch); 
    10581208                                uint32_t offset = renderObj->index + renderObj->elements; 
    10591209                                renderObj->elements += 4; 
    1060  
    1061                                 RenderZData* rd = &m_renderZ_datas[offset]; 
     1210                                RenderZData* rd; 
     1211 
     1212                                rd = &m_renderZ_datas[offset]; 
    10621213                                rd->vertex[0] = static_cast<float>(rect.x); 
    10631214                                rd->vertex[1] = static_cast<float>(rect.y); 
     
    11211272 
    11221273                                RenderObject ro(GL_QUADS, 4, id); 
    1123                                 ro.multitextured = true; 
    11241274                                ro.rgb[0] = rgb[0]; 
    11251275                                ro.rgb[1] = rgb[1]; 
     
    11581308                        if (rgb != NULL) { 
    11591309                                RenderObject ro(GL_QUADS, 4, id); 
    1160                                 ro.multitextured = true; 
    11611310                                ro.rgb[0] = rgb[0]; 
    11621311                                ro.rgb[1] = rgb[1]; 
     
    11921341                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); 
    11931342                glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE); 
    1194                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);  
     1343                glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);  
    11951344 
    11961345                // Arg0 
  • branches/active/0.3.3dev/engine/core/video/opengle/renderbackendopengle.h

    r3720 r3721  
    3636namespace FIFE { 
    3737        class ScreenMode; 
     38        struct GLRenderState; 
    3839 
    3940        /** The main class of the OpenGL-based experimental renderer. 
     
    5152                virtual void setLightingModel(uint32_t lighting); 
    5253                virtual uint32_t getLightingModel() const; 
    53                 virtual void setLighting(float red, float green, float blue, float alpha); 
     54                virtual void setLighting(float red, float green, float blue); 
    5455                virtual void resetLighting(); 
    5556                virtual void resetStencilBuffer(uint8_t buffer); 
     
    6869                virtual void renderVertexArrays(); 
    6970                virtual void addImageToArray(uint32_t id, const Rect& rec, float const* st, uint8_t alpha, uint8_t const* rgb); 
    70                 virtual void addImageToArrayZ(uint32_t id, const Rect& rec, float vertexZ, float const* st, uint8_t alpha, uint8_t const* rgb); 
     71                virtual void addImageToArrayZ(uint32_t id, const Rect& rec, float vertexZ, float const* st, uint8_t alpha, bool forceNewBatch, uint8_t const* rgb); 
    7172                virtual void changeRenderInfos(uint16_t elements, int32_t src, int32_t dst, bool light, bool stentest, uint8_t stenref, GLConstants stenop, GLConstants stenfunc); 
    7273                virtual void captureScreen(const std::string& filename); 
     
    7980                virtual void drawQuad(const Point& p1, const Point& p2, const Point& p3, const Point& p4,  uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255); 
    8081                virtual void drawVertex(const Point& p, const uint8_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255); 
    81                 virtual void drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue); 
     82 
     83                void drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue, const GLRenderState& state); 
     84                void drawLightmap(uint32_t id, const Rect& rec, float const* st, const GLRenderState& state); 
    8285 
    8386                virtual void attachRenderTarget(ImagePtr& img, bool discard); 
     
    100103                void disableStencilTest(); 
    101104                void setStencilTest(uint8_t stencil_ref, GLenum stencil_op, GLenum stencil_func); 
    102                 uint8_t getStencilRef() const; 
    103105                void enableAlphaTest(); 
    104106                void disableAlphaTest(); 
     
    114116 
    115117                void renderWithZ(); 
     118                void renderLights(); 
    116119                void renderWithoutZ(); 
    117120 
     
    119122                void prepareForOverlays(); 
    120123                 
    121                 class RenderObject; 
    122  
    123                 // only for textures 
     124                // only for textured quads 
    124125                struct RenderZData { 
    125126                        GLfloat vertex[3]; 
    126127                        GLfloat texel[2]; 
    127128                }; 
    128  
    129                 struct RenderZObject { 
    130                         GLuint texture_id; 
    131                         uint32_t elements; 
    132                         uint32_t index; 
    133                         uint32_t max_size; 
    134                 }; 
    135  
    136                 std::vector<RenderZData> m_renderZ_datas; 
    137                 std::vector<RenderZObject> m_renderZ_objects; 
    138  
    139                 RenderZObject* getRenderBufferObject(GLuint texture_id); 
    140129 
    141130                // structure for colored overlay 
     
    154143                }; 
    155144 
     145                // describe chunk of batched (by texture) quads  
     146                struct RenderZObject { 
     147                        GLuint texture_id; 
     148                        uint32_t elements; 
     149                        uint32_t index; 
     150                        uint32_t max_size; 
     151                }; 
     152                class RenderObject; 
     153                class RenderObjectLight; 
     154 
     155                RenderZObject* getRenderBufferObject(GLuint texture_id, bool unlit = false); 
     156 
     157                // main source of vertex data - described by m_renderZ_objects 
     158                std::vector<RenderZData> m_renderZ_datas; 
     159                std::vector<RenderZObject> m_renderZ_objects; 
     160 
     161                // vertex data source for transparent primitives - described by m_render_trans_objects 
     162                std::vector<RenderZData2T> m_render_trans_datas; 
     163                std::vector<RenderObject> m_render_trans_objects; 
     164 
     165                // vertex data source for colored overlays - described by m_render_objects2T 
     166                std::vector<RenderZData2T> m_render_datas2T; 
     167                std::vector<RenderObject> m_render_objects2T; 
     168 
     169                // note: vertex data comes from m_renderZ_datas 
     170                std::vector<RenderZObject> m_renderZ_objects_forced; 
     171 
     172                // vertex data source for primitives that dont use depth buffer - described by m_render_objects 
    156173                std::vector<RenderData> m_render_datas; 
    157                 std::vector<RenderZData2T> m_render_trans_datas; 
    158                 std::vector<RenderZData2T> m_render_datas2T; 
    159  
    160174                std::vector<RenderObject> m_render_objects; 
    161                 std::vector<RenderObject> m_render_trans_objects; 
    162                 std::vector<RenderObject> m_render_objects2T; 
     175                 
     176                // for lighting stuff 
     177                std::vector<RenderData> m_render_datas_lights; 
     178                std::vector<RenderObjectLight> m_render_objects_light; 
    163179 
    164180                struct currentState     { 
     
    169185                        uint32_t active_client_tex; 
    170186 
     187                        // Light 
     188                        uint32_t lightmodel; 
     189                        bool light_enabled; 
     190 
    171191                        // Stencil 
    172192                        bool sten_enabled; 
     
    175195                        GLenum sten_op; 
    176196                        GLenum sten_func; 
    177  
    178                         // Light 
    179                         uint32_t lightmodel; 
    180                         float lred; 
    181                         float lgreen; 
    182                         float lblue; 
    183                         float lalpha; 
    184                         bool light_enabled; 
    185197 
    186198                        // The rest 
     
    198210        }; 
    199211 
     212        struct GLRenderState { 
     213                int32_t src; 
     214                int32_t dst; 
     215                //bool light; // always on 
     216                //bool stencil_test; // always on 
     217                uint8_t stencil_ref; 
     218                GLenum stencil_op; 
     219                GLenum stencil_func; 
     220        }; 
    200221} 
    201222 
  • branches/active/0.3.3dev/engine/core/video/renderbackend.h

    r3712 r3721  
    132132                /** Set colors for lighting 
    133133                 */ 
    134                 virtual void setLighting(float red, float green, float blue, float alpha) = 0; 
     134                virtual void setLighting(float red, float green, float blue) = 0; 
    135135 
    136136                /** Reset lighting with default values. 
     
    252252                 */ 
    253253                virtual void drawVertex(const Point& p, const uint8_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) = 0; 
    254  
    255                 /** Draws a light primitive that based on a triangle fan 
    256                  */ 
    257                 virtual void drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue) = 0; 
    258254 
    259255                /** Enable or disable the alpha 'optimizing' code 
  • branches/active/0.3.3dev/engine/core/video/sdl/renderbackendsdl.cpp

    r3698 r3721  
    173173        } 
    174174 
    175         void RenderBackendSDL::setLighting(float red, float green, float blue, float alpha) { 
     175        void RenderBackendSDL::setLighting(float red, float green, float blue) { 
    176176        } 
    177177 
     
    342342                drawLine(p3, p4, r, g, b, a); 
    343343                drawLine(p4, p1, r, g, b, a); 
    344         } 
    345  
    346         void RenderBackendSDL::drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue){ 
    347344        } 
    348345 
  • branches/active/0.3.3dev/engine/core/video/sdl/renderbackendsdl.h

    r3698 r3721  
    5252                virtual void setLightingModel(uint32_t lighting); 
    5353                virtual uint32_t getLightingModel() const; 
    54                 virtual void setLighting(float red, float green, float blue, float alpha); 
     54                virtual void setLighting(float red, float green, float blue); 
    5555                virtual void resetLighting(); 
    5656                virtual void resetStencilBuffer(uint8_t buffer); 
     
    7979                virtual void drawQuad(const Point& p1, const Point& p2, const Point& p3, const Point& p4,  uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255); 
    8080                virtual void drawVertex(const Point& p, const uint8_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255); 
    81                 virtual void drawLightPrimitive(const Point& p, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t red, uint8_t green, uint8_t blue); 
    8281 
    8382                virtual void attachRenderTarget(ImagePtr& img, bool discard); 
  • branches/active/0.3.3dev/engine/core/view/camera.cpp

    r3720 r3721  
    576576        } 
    577577 
    578         void Camera::setLightingColor(float red, float green, float blue, float alpha) { 
     578        void Camera::setLightingColor(float red, float green, float blue) { 
    579579                m_lighting = true; 
    580580                m_light_colors.clear(); 
     
    582582                m_light_colors.push_back(green); 
    583583                m_light_colors.push_back(blue); 
    584                 m_light_colors.push_back(alpha); 
    585584        } 
    586585 
    587586        std::vector<float> Camera::getLightingColor() { 
    588587                if(m_light_colors.empty()) { 
    589                         for(int32_t colors = 0; colors != 4; ++colors) { 
     588                        for(int32_t colors = 0; colors != 3; ++colors) { 
    590589                                m_light_colors.push_back(1.0f); 
    591590                        } 
     
    751750                } 
    752751 
    753                 if (m_renderbackend->getLightingModel() != 0) { 
     752                uint32_t lm = m_renderbackend->getLightingModel(); 
     753                if (lm != 0) { 
    754754                        m_renderbackend->resetStencilBuffer(0); 
    755755                        if (m_lighting) { 
    756                                 m_renderbackend->setLighting(m_light_colors[0], m_light_colors[1], m_light_colors[2], m_light_colors[3]); 
     756                                m_renderbackend->setLighting(m_light_colors[0], m_light_colors[1], m_light_colors[2]); 
    757757                        } 
    758758                } 
     
    770770                                } 
    771771                        } 
    772                 } 
    773  
    774                 if (m_lighting && m_renderbackend->getLightingModel() == 2) { 
    775                         m_renderbackend->resetLighting(); 
    776                 } 
     772                        if (m_lighting && lm != 0) { 
     773                                m_renderbackend->renderVertexArrays(); 
     774                        } 
     775                } 
     776 
    777777                renderOverlay(); 
    778778                m_renderbackend->renderVertexArrays(); 
    779                 if (m_lighting && m_renderbackend->getLightingModel() == 1) { 
     779                if (m_lighting && lm != 0) { 
    780780                        m_renderbackend->resetLighting(); 
    781781                } 
  • branches/active/0.3.3dev/engine/core/view/camera.h

    r3720 r3721  
    287287                /** Sets lighting color 
    288288                 */ 
    289                 void setLightingColor(float red, float green, float blue, float alpha); 
     289                void setLightingColor(float red, float green, float blue); 
    290290 
    291291                /** Resets lighting color 
  • branches/active/0.3.3dev/engine/core/view/camera.i

    r3712 r3721  
    6565                void resetRenderers(); 
    6666                 
    67                 void setLightingColor(float red, float green, float blue, float alpha); 
     67                void setLightingColor(float red, float green, float blue); 
    6868                void resetLightingColor(); 
    6969                std::vector<float> getLightingColor(); 
  • branches/active/0.3.3dev/engine/core/view/layercache.cpp

    r3720 r3721  
    405405                                double a = static_cast<float>(det_a / det); 
    406406                                double b = static_cast<float>(det_b / det); 
     407                                float estimate = sqrtf(static_cast<float>(renderlist.size())); 
     408                                float stack_delta = fabs(-10.0f - 10.0f) / estimate * 0.1f; 
    407409 
    408410                                RenderList::iterator it = renderlist.begin(); 
     
    410412                                        double& z = (*it)->screenpoint.z; 
    411413                                        z = a * z + b; 
     414                                        InstanceVisual* vis = (*it)->instance->getVisual<InstanceVisual>(); 
     415                                        z += vis->getStackPosition() * stack_delta;                                      
    412416                                } 
    413417                        } 
  • branches/active/0.3.3dev/engine/core/view/renderers/instancerenderer.cpp

    r3720 r3721  
    4646#include "instancerenderer.h" 
    4747 
     48#include "video/opengle/gleimage.h" 
     49 
    4850 
    4951namespace { 
     
    8991 
    9092        InstanceRenderer::ColoringInfo::~ColoringInfo() { 
     93                delete overlay; 
    9194        } 
    9295 
     
    154157        void InstanceRenderer::renderUnsorted(Camera* cam, Layer* layer, RenderList& instances) 
    155158        { 
    156                 // TODO lighting stuff was cut off 
    157159                // TODO transparent area stuff was cut off 
    158160                const bool any_effects = !(m_instance_outlines.empty() && m_instance_colorings.empty()); 
    159                 //const bool unlit = !m_unlit_groups.empty(); 
    160                 //uint32_t lm = m_renderbackend->getLightingModel(); 
     161                const bool unlit = !m_unlit_groups.empty(); 
     162                uint32_t lm = m_renderbackend->getLightingModel(); 
    161163 
    162164                // Get layer index (this is needed for tweaking vertexZ for OpenGL renderbackend) 
     
    173175 
    174176                // This values comes from glOrtho settings 
    175                 double global_z_min = -200.0; 
    176                 double global_z_max = 200.0; 
    177                 double depth_range = fabs(global_z_min - global_z_max); 
     177                static const double global_z_min = -100.0; 
     178                static const double global_z_max = 100.0; 
     179#if 0 
     180                static const double depth_range = fabs(global_z_min - global_z_max); 
    178181 
    179182                // This is how much depth we can sacrifice for given layer 
     
    189192                        layer_depth_range * static_cast<double>(this_layer) -  
    190193                        layer_depth_range * 0.5; 
    191  
     194#else 
     195 
     196                // 2nd version, better usage of depth buffer as values closer to near plane in depth buffer have more precise (1/z) 
     197                double layer_z_offset = global_z_max - (num_layers - (this_layer - 1)) * 20; 
     198#endif 
    192199                // thanks to multimap, we will have transparent instances already sorted by their z value (key) 
    193200                std::multimap<float, RenderItem*> transparentInstances; 
     
    200207                        float vertexZ = static_cast<float>(layer_z_offset + vc.screenpoint.z); 
    201208 
     209                        // if the instance is opacous 
    202210                        if(vc.transparency == 255) { 
    203211                                if (any_effects) { 
    204212                                        InstanceToOutlines_t::iterator outline_it = m_instance_outlines.find(instance); 
    205213                                        if (outline_it != m_instance_outlines.end()) { 
    206                                                 bindOutline(outline_it->second, vc, cam)->renderZ(vc.dimensions, vertexZ, 255); 
     214                                                Image* outline = bindOutline(outline_it->second, vc, cam); 
     215                                                outline->renderZ(vc.dimensions, vertexZ, 255, lm != 0 ? true : false); 
     216                                                vc.image->renderZ(vc.dimensions, vertexZ, 255); 
    207217                                                continue; 
    208218                                        } 
     
    211221                                        if (coloring_it != m_instance_colorings.end()) { 
    212222                                                uint8_t rgb[3] = { coloring_it->second.r, coloring_it->second.g, coloring_it->second.b }; 
    213                                                 vc.image->renderZ(vc.dimensions, vertexZ, 255, rgb); 
    214                                                 continue; 
    215                                         } 
    216                                 } 
     223                                                vc.image->renderZ(vc.dimensions, vertexZ, 255, false, rgb); 
     224                                                continue; 
     225                                        } 
     226                                } 
     227 
     228                                // if we use lighting and appointed some of the instances as unlit 
     229                                if(lm != 0 && unlit) { 
     230                                        bool found = false; 
     231                                        std::string lit_name = instance->getObject()->getNamespace(); 
     232                                        std::list<std::string>::iterator unlit_it = m_unlit_groups.begin(); 
     233                                        for(;unlit_it != m_unlit_groups.end(); ++unlit_it) { 
     234                                                if(lit_name.find(*unlit_it) != std::string::npos) { 
     235                                                        found = true; 
     236                                                        break; 
     237                                                } 
     238                                        } 
     239 
     240                                        vc.image->renderZ(vc.dimensions, vertexZ, 255, found ? true : false); 
     241                                        continue; 
     242                                } 
     243 
    217244                                vc.image->renderZ(vc.dimensions, vertexZ, 255); 
    218245                        } else { 
     
    232259                                        InstanceToOutlines_t::iterator outline_it = m_instance_outlines.find(vc.instance); 
    233260                                        if (outline_it != m_instance_outlines.end()) { 
    234                                                 bindOutline(outline_it->second, vc, cam)->renderZ(vc.dimensions, vertexZ, alpha); 
     261                                                Image* outline = bindOutline(outline_it->second, vc, cam); 
     262                                                outline->renderZ(vc.dimensions, vertexZ, alpha, lm != 0 ? true : false); 
     263                                                vc.image->renderZ(vc.dimensions, vertexZ, alpha); 
    235264                                                continue; 
    236265                                        } 
     
    239268                                        if (coloring_it != m_instance_colorings.end()) { 
    240269                                                uint8_t rgb[3] = { coloring_it->second.r, coloring_it->second.g, coloring_it->second.b }; 
    241                                                 vc.image->renderZ(vc.dimensions, vertexZ, alpha, rgb); 
    242                                                 continue; 
    243                                         } 
    244                                 } 
     270                                                vc.image->renderZ(vc.dimensions, vertexZ, alpha, false, rgb); 
     271                                                continue; 
     272                                        } 
     273                                } 
     274 
     275                                // if we use lighting and appointed some of the instances as unlit 
     276                                if(lm != 0 && unlit) { 
     277                                        bool found = false; 
     278                                        std::string lit_name = vc.instance->getObject()->getNamespace(); 
     279                                        std::list<std::string>::iterator unlit_it = m_unlit_groups.begin(); 
     280                                        for(;unlit_it != m_unlit_groups.end(); ++unlit_it) { 
     281                                                if(lit_name.find(*unlit_it) != std::string::npos) { 
     282                                                        found = true; 
     283                                                        break; 
     284                                                } 
     285                                        } 
     286 
     287                                        vc.image->renderZ(vc.dimensions, vertexZ, alpha, found ? true : false); 
     288                                        continue; 
     289                                } 
     290 
    245291                                vc.image->renderZ(vc.dimensions, vertexZ, alpha); 
    246292                        } 
     
    309355                                if (outline_it != m_instance_outlines.end()) { 
    310356                                        if (lm != 0) { 
     357                                                // first render normal image without stencil and alpha test (0) 
     358                                                // so it wont look aliased and then with alpha test render only outline (its 'binary' image) 
     359                                                vc.image->render(vc.dimensions, vc.transparency); 
    311360                                                bindOutline(outline_it->second, vc, cam)->render(vc.dimensions, vc.transparency); 
    312361                                                m_renderbackend->changeRenderInfos(1, 4, 5, false, true, 255, REPLACE, ALWAYS); 
    313                                                 vc.image->render(vc.dimensions, vc.transparency); 
    314                                                 m_renderbackend->changeRenderInfos(1, 4, 5, true, true, 0, REPLACE, ALWAYS); 
    315362                                                continue; 
    316363                                        } else { 
    317364                                                bindOutline(outline_it->second, vc, cam)->render(vc.dimensions, vc.transparency); 
     365                                                vc.image->render(vc.dimensions, vc.transparency); 
     366                                                continue; 
    318367                                        } 
    319368                                } 
     
    371420                } 
    372421 
     422                // NOTE: Since r3721 outline is just the 'border' so to render everything correctly 
     423                // we need to first render normal image, and then its outline. 
     424                // This helps much with lighting stuff and doesn't require from us to copy image. 
     425 
    373426                SDL_Surface* surface = vc.image->getSurface(); 
    374                 SDL_Surface* outline_surface; 
    375                  
    376                 if(vc.image->isSharedImage()) { 
    377                         outline_surface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_SRCALPHA, 
    378                                 vc.image->getWidth(), vc.image->getHeight(), 32, 
    379                                 RMASK, GMASK, BMASK, AMASK); 
    380                         SDL_SetAlpha(surface, 0, 0); 
    381   
    382                         // can't directly cast Rect to SDL_Rect as int32_t isn't compatible with Sint16 or Uint16 
    383                         const Rect& rect = vc.image->getSubImageRect(); 
    384                         SDL_Rect srcrect = { rect.x, rect.y, rect.w, rect.h }; 
    385                         SDL_BlitSurface(surface, &srcrect, outline_surface, NULL); 
    386                         SDL_SetAlpha(surface, SDL_SRCALPHA, 0); 
    387                 } else { 
    388                         outline_surface = SDL_ConvertSurface(surface, surface->format, surface->flags); 
    389                 } 
     427                SDL_Surface* outline_surface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_SRCALPHA, 
     428                        vc.image->getWidth(), vc.image->getHeight(), 32, 
     429                        RMASK, GMASK, BMASK, AMASK); 
    390430 
    391431                // TODO: optimize... 
     
    433473                // In case of OpenGL backend, SDLImage needs to be converted 
    434474                info.outline = m_renderbackend->createImage(outline_surface); 
    435  
    436                 if (info.outline) { 
    437                         // mark outline as not dirty since we created it here 
    438                         info.dirty = false; 
    439                 } 
     475                // mark outline as not dirty since we created it here 
     476                info.dirty = false; 
    440477 
    441478                return info.outline; 
     
    456493 
    457494                SDL_Surface* surface = vc.image->getSurface(); 
    458                 SDL_Surface* overlay_surface; 
    459  
    460                 if(vc.image->isSharedImage()) { 
    461                         overlay_surface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_SRCALPHA, 
    462                                 vc.image->getWidth(), vc.image->getHeight(), 32, 
    463                                 RMASK, GMASK, BMASK, AMASK); 
    464                         SDL_SetAlpha(surface, 0, 0); 
    465  
    466                         // can't directly cast Rect to SDL_Rect as int32_t isn't compatible with Sint16 or Uint16 
    467                         const Rect& rect = vc.image->getSubImageRect(); 
    468                         SDL_Rect srcrect = { rect.x, rect.y, rect.w, rect.h }; 
    469                         SDL_BlitSurface(surface, &srcrect, overlay_surface, NULL); 
    470                         SDL_SetAlpha(surface, SDL_SRCALPHA, 0); 
    471                 } else { 
    472                         overlay_surface = SDL_ConvertSurface(surface, surface->format, surface->flags); 
    473                 } 
     495                SDL_Surface* overlay_surface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_SRCALPHA, 
     496                        vc.image->getWidth(), vc.image->getHeight(), 32, 
     497                        RMASK, GMASK, BMASK, AMASK); 
    474498 
    475499                uint8_t r, g, b, a = 0; 
     
    486510                // In case of OpenGL backend, SDLImage needs to be converted 
    487511                info.overlay = m_renderbackend->createImage(overlay_surface); 
    488  
    489                 if (info.overlay) { 
    490                         // mark overlay coloring as not dirty since we created it here 
    491                         info.dirty = false; 
    492                 } 
     512                // mark overlay coloring as not dirty since we created it here 
     513                info.dirty = false; 
    493514 
    494515                return info.overlay; 
     
    531552                newinfo.g = g; 
    532553                newinfo.b = b; 
     554                newinfo.dirty = true; 
    533555 
    534556                // attempts to insert the element into the coloring map 
  • branches/active/0.3.3dev/engine/core/view/renderers/lightrenderer.cpp

    r3689 r3721  
    3535#include "video/image.h" 
    3636#include "video/opengl/glimage.h" 
     37#include "video/opengle/gleimage.h" 
     38#include "video/opengl/renderbackendopengl.h" 
     39#include "video/opengle/renderbackendopengle.h" 
    3740#include "util/math/fife_math.h" 
    3841#include "util/log/logger.h" 
     
    5154        static Logger _log(LM_VIEWVIEW); 
    5255 
    53         LightRendererImageInfo::LightRendererImageInfo(RendererNode anchor, ImagePtr image, int32_t src, int32_t dst): 
    54                 LightRendererElementInfo(), 
    55                 m_anchor(anchor), 
    56                 m_image(image), 
     56        LightRendererElementInfo::LightRendererElementInfo(RendererNode n, int32_t src, int32_t dst): 
     57                m_anchor(n), 
    5758                m_src(src), 
    5859                m_dst(dst), 
    5960                m_stencil(false), 
    60                 m_stencil_ref(0), 
    61                 m_alpha_ref(0.0) { 
     61                m_stencil_ref(0) { 
     62        } 
     63        void LightRendererElementInfo::setStencil(uint8_t stencil_ref) { 
     64                m_stencil = true; 
     65                m_stencil_ref = stencil_ref; 
     66        } 
     67        int32_t LightRendererElementInfo::getStencil() { 
     68                if(!m_stencil) { 
     69                        return -1; 
     70                } 
     71                return m_stencil_ref; 
     72        } 
     73        void LightRendererElementInfo::removeStencil() { 
     74                m_stencil = false; 
     75                m_stencil_ref = 0; 
     76        } 
     77        LightRendererImageInfo::LightRendererImageInfo(RendererNode anchor, ImagePtr image, int32_t src, int32_t dst): 
     78                LightRendererElementInfo(anchor, src, dst), 
     79                m_image(image){ 
    6280        } 
    6381        void LightRendererImageInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) { 
     
    7492 
    7593                        if(r.intersects(viewport)) { 
    76                                 m_image->render(r); 
    7794                                uint8_t lm = renderbackend->getLightingModel(); 
    78                                 if (m_stencil) { 
    79                                         renderbackend->changeRenderInfos(1, m_src, m_dst, false, m_stencil, m_stencil_ref, INCR, GEQUAL); 
    80                                 } else if (lm == 1) { 
    81                                         renderbackend->changeRenderInfos(1, m_src, m_dst, false, m_stencil, 255, KEEP, NOTEQUAL); 
    82                                 } else if (lm == 2) { 
    83                                         renderbackend->changeRenderInfos(1, m_src, m_dst, false, m_stencil, 0, REPLACE, GEQUAL); 
    84                                 } 
    85                         } 
    86                 } 
    87         } 
    88         void LightRendererImageInfo::setStencil(uint8_t stencil_ref, float alpha_ref) { 
    89                 m_stencil = true; 
    90                 m_stencil_ref = stencil_ref; 
    91                 m_alpha_ref = alpha_ref; 
    92         } 
    93         int32_t LightRendererImageInfo::getStencil() { 
    94                 if(!m_stencil) { 
    95                         return -1; 
    96                 } 
    97                 return m_stencil_ref; 
    98         } 
    99         float LightRendererImageInfo::getAlpha() { 
    100                 return m_alpha_ref; 
    101         } 
    102         void LightRendererImageInfo::removeStencil() { 
    103                 m_stencil = false; 
    104                 m_stencil_ref = 0; 
    105                 m_alpha_ref = 0.0; 
    106         } 
    107  
     95                                if (renderbackend->getName() == "OpenGL") { 
     96                                        m_image->render(r); 
     97                                        if (m_stencil) { 
     98                                                renderbackend->changeRenderInfos(1, m_src, m_dst, false, true, m_stencil_ref, INCR, GEQUAL); 
     99                                        } else if (lm == 1) { 
     100                                                renderbackend->changeRenderInfos(1, m_src, m_dst, false, true, 255, KEEP, NOTEQUAL); 
     101                                        } 
     102                                } else { 
     103                                        GLRenderState state; 
     104                                        state.src = m_src; 
     105                                        state.dst = m_dst; 
     106                                        if (m_stencil) { 
     107                                                state.stencil_func = GEQUAL; 
     108                                                state.stencil_op = INCR; 
     109                                                state.stencil_ref = m_stencil_ref; 
     110                                        } else if (lm == 1) { 
     111                                                state.stencil_func = NOTEQUAL; 
     112                                                state.stencil_op = KEEP; 
     113                                                state.stencil_ref = 255; 
     114                                        } 
     115                                        static_cast<GLeImage*>(m_image.get())->renderLightmap(r, state); 
     116                                } 
     117                        } 
     118                } 
     119        } 
    108120        LightRendererAnimationInfo::LightRendererAnimationInfo(RendererNode anchor, AnimationPtr animation, int32_t src, int32_t dst): 
    109                 LightRendererElementInfo(), 
    110                 m_anchor(anchor), 
     121                LightRendererElementInfo(anchor, src, dst), 
    111122                m_animation(animation), 
    112                 m_src(src), 
    113                 m_dst(dst), 
    114123                m_start_time(TimeManager::instance()->getTime()), 
    115                 m_time_scale(1.0), 
    116                 m_stencil(false), 
    117                 m_stencil_ref(0), 
    118                 m_alpha_ref(0.0) { 
     124                m_time_scale(1.0){ 
    119125        } 
    120126        void LightRendererAnimationInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) { 
     
    133139 
    134140                        if(r.intersects(viewport)) { 
    135                                 img->render(r); 
    136141                                uint8_t lm = renderbackend->getLightingModel(); 
    137                                 if (m_stencil) { 
    138                                         renderbackend->changeRenderInfos(1, m_src, m_dst, false, m_stencil, m_stencil_ref, INCR, GEQUAL); 
    139                                 } else if (lm == 1) { 
    140                                         renderbackend->changeRenderInfos(1, m_src, m_dst, false, m_stencil, 255, KEEP, NOTEQUAL); 
    141                                 } else if (lm == 2) { 
    142                                         renderbackend->changeRenderInfos(1, m_src, m_dst, false, m_stencil, 0, REPLACE, GEQUAL); 
    143                                 } 
    144                         } 
    145                 } 
    146         } 
    147         void LightRendererAnimationInfo::setStencil(uint8_t stencil_ref, float alpha_ref) { 
    148                 m_stencil = true; 
    149                 m_stencil_ref = stencil_ref; 
    150                 m_alpha_ref = alpha_ref; 
    151         } 
    152         int32_t LightRendererAnimationInfo::getStencil() { 
    153                 if(!m_stencil) { 
    154                         return -1; 
    155                 } 
    156                 return m_stencil_ref; 
    157         } 
    158         float LightRendererAnimationInfo::getAlpha() { 
    159                 return m_alpha_ref; 
    160         } 
    161         void LightRendererAnimationInfo::removeStencil() { 
    162                 m_stencil = false; 
    163                 m_stencil_ref = 0; 
    164                 m_alpha_ref = 0.0; 
    165         } 
    166  
     142                                if (renderbackend->getName() == "OpenGL") { 
     143                                        img->render(r); 
     144                                        if (m_stencil) { 
     145                                                renderbackend->changeRenderInfos(1, m_src, m_dst, false, true, m_stencil_ref, INCR, GEQUAL); 
     146                                        } else if (lm == 1) { 
     147                                                renderbackend->changeRenderInfos(1, m_src, m_dst, false, true, 255, KEEP, NOTEQUAL); 
     148                                        } 
     149                                } else { 
     150                                        GLRenderState state; 
     151                                        state.src = m_src; 
     152                                        state.dst = m_dst; 
     153                                        if (m_stencil) { 
     154                                                state.stencil_func = GEQUAL; 
     155                                                state.stencil_op = INCR; 
     156                                                state.stencil_ref = m_stencil_ref; 
     157                                        } else if (lm == 1) { 
     158                                                state.stencil_func = NOTEQUAL; 
     159                                                state.stencil_op = KEEP; 
     160                                                state.stencil_ref = 255; 
     161                                        } 
     162                                        static_cast<GLeImage*>(img.get())->renderLightmap(r, state); 
     163                                } 
     164                        } 
     165                } 
     166        } 
    167167        LightRendererResizeInfo::LightRendererResizeInfo(RendererNode anchor, ImagePtr image, int32_t width, int32_t height, int32_t src, int32_t dst): 
    168                 LightRendererElementInfo(), 
    169                 m_anchor(anchor), 
     168                LightRendererElementInfo(anchor, src, dst), 
    170169                m_image(image), 
    171170                m_width(width), 
    172                 m_height(height), 
    173                 m_src(src), 
    174                 m_dst(dst), 
    175                 m_stencil(false), 
    176                 m_stencil_ref(0), 
    177                 m_alpha_ref(0.0) { 
     171                m_height(height) { 
    178172        } 
    179173        void LightRendererResizeInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) { 
    180174                Point p = m_anchor.getCalculatedPoint(cam, layer); 
    181175                if(m_anchor.getLayer() == layer) { 
    182 //prock - 504 
    183176                        Rect r; 
    184177                        Rect viewport = cam->getViewPort(); 
     
    191184 
    192185                        if(r.intersects(viewport)) { 
    193                                 m_image->render(r); 
    194186                                uint8_t lm = renderbackend->getLightingModel(); 
    195                                 if (m_stencil) { 
    196                                         renderbackend->changeRenderInfos(1, m_src, m_dst, false, m_stencil, m_stencil_ref, INCR, GEQUAL); 
    197                                 } else if (lm == 1) { 
    198                                         renderbackend->changeRenderInfos(1, m_src, m_dst, false, m_stencil, 255, KEEP, NOTEQUAL); 
    199                                 } else if (lm == 2) { 
    200                                         renderbackend->changeRenderInfos(1, m_src, m_dst, false, m_stencil, 0, REPLACE, GEQUAL); 
    201                                 } 
    202                         } 
    203                 } 
    204         } 
    205         void LightRendererResizeInfo::setStencil(uint8_t stencil_ref, float alpha_ref) { 
    206                 m_stencil = true; 
    207                 m_stencil_ref = stencil_ref; 
    208                 m_alpha_ref = alpha_ref; 
    209         } 
    210         int32_t LightRendererResizeInfo::getStencil() { 
    211                 if(!m_stencil) { 
    212                         return -1; 
    213                 } 
    214                 return m_stencil_ref; 
    215         } 
    216         float LightRendererResizeInfo::getAlpha() { 
    217                 return m_alpha_ref; 
    218         } 
    219         void LightRendererResizeInfo::removeStencil() { 
    220                 m_stencil = false; 
    221                 m_stencil_ref = 0; 
    222                 m_alpha_ref = 0.0; 
    223         } 
    224  
     187                                if (renderbackend->getName() == "OpenGL") { 
     188                                        m_image->render(r); 
     189                                        if (m_stencil) { 
     190                                                renderbackend->changeRenderInfos(1, m_src, m_dst, false, true, m_stencil_ref, INCR, GEQUAL); 
     191                                        } else if (lm == 1) { 
     192                                                renderbackend->changeRenderInfos(1, m_src, m_dst, false, true, 255, KEEP, NOTEQUAL); 
     193                                        } 
     194                                } else { 
     195                                        GLRenderState state; 
     196                                        state.src = m_src; 
     197                                        state.dst = m_dst; 
     198                                        if (m_stencil) { 
     199                                                state.stencil_func = GEQUAL; 
     200                                                state.stencil_op = INCR; 
     201                                                state.stencil_ref = m_stencil_ref; 
     202                                        } else if (lm == 1) { 
     203                                                state.stencil_func = NOTEQUAL; 
     204                                                state.stencil_op = KEEP; 
     205                                                state.stencil_ref = 255; 
     206                                        } 
     207                                        static_cast<GLeImage*>(m_image.get())->renderLightmap(r, state); 
     208                                } 
     209                        } 
     210                } 
     211        } 
    225212        LightRendererSimpleLightInfo::LightRendererSimpleLightInfo(RendererNode anchor, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t r, uint8_t g, uint8_t b, int32_t src, int32_t dst): 
    226                 LightRendererElementInfo(), 
    227                 m_anchor(anchor), 
     213                LightRendererElementInfo(anchor, src, dst), 
    228214                m_intensity(intensity), 
    229215                m_radius(radius), 
     
    233219                m_red(r), 
    234220                m_green(g), 
    235                 m_blue(b), 
    236                 m_src(src), 
    237                 m_dst(dst), 
    238                 m_stencil(false), 
    239                 m_stencil_ref(0), 
    240                 m_alpha_ref(0.0) { 
     221                m_blue(b){ 
    241222        } 
    242223        void LightRendererSimpleLightInfo::render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) { 
     
    244225                if(m_anchor.getLayer() == layer) { 
    245226                        double zoom = cam->getZoom(); 
    246                         renderbackend->drawLightPrimitive(p, m_intensity, m_radius, m_subdivisions, 
    247                                 static_cast<float>(m_xstretch * zoom), static_cast<float>(m_ystretch * zoom), 
    248                                 m_red, m_green, m_blue); 
    249227 
    250228                        uint8_t lm = renderbackend->getLightingModel(); 
    251                         if (m_stencil) { 
    252                                 renderbackend->changeRenderInfos(m_subdivisions, m_src, m_dst, false, m_stencil, m_stencil_ref, INCR, GEQUAL); 
    253                         } else if (lm == 1) { 
    254                                 renderbackend->changeRenderInfos(m_subdivisions, m_src, m_dst, false, m_stencil, 255, KEEP, NOTEQUAL); 
    255                         } else if (lm == 2) { 
    256                                 renderbackend->changeRenderInfos(m_subdivisions, m_src, m_dst, false, m_stencil, 0, REPLACE, GEQUAL); 
    257                         } 
    258                 } 
    259         } 
    260         void LightRendererSimpleLightInfo::setStencil(uint8_t stencil_ref, float alpha_ref) { 
    261                 m_stencil = true; 
    262                 m_stencil_ref = stencil_ref; 
    263                 m_alpha_ref = alpha_ref; 
    264         } 
    265         int32_t LightRendererSimpleLightInfo::getStencil() { 
    266                 if(!m_stencil) { 
    267                         return -1; 
    268                 } 
    269                 return m_stencil_ref; 
    270         } 
    271         float LightRendererSimpleLightInfo::getAlpha() { 
    272                 return m_alpha_ref; 
    273         } 
    274         void LightRendererSimpleLightInfo::removeStencil() { 
    275                 m_stencil = false; 
    276                 m_stencil_ref = 0; 
    277                 m_alpha_ref = 0.0; 
     229                        if (renderbackend->getName() == "OpenGL") { 
     230                                static_cast<RenderBackendOpenGL*>(RenderBackend::instance())->drawLightPrimitive(p, m_intensity, m_radius, m_subdivisions, 
     231                                        static_cast<float>(m_xstretch * zoom), static_cast<float>(m_ystretch * zoom), 
     232                                        m_red, m_green, m_blue); 
     233 
     234                                if (m_stencil) { 
     235                                        renderbackend->changeRenderInfos(m_subdivisions, m_src, m_dst, false, true, m_stencil_ref, INCR, GEQUAL); 
     236                                } else if (lm == 1) { 
     237                                        renderbackend->changeRenderInfos(m_subdivisions, m_src, m_dst, false, true, 255, KEEP, NOTEQUAL); 
     238                                } 
     239                        } else { 
     240                                GLRenderState state; 
     241                                state.src = m_src; 
     242                                state.dst = m_dst; 
     243                                if (m_stencil) { 
     244                                        state.stencil_func = GEQUAL; 
     245                                        state.stencil_op = INCR; 
     246                                        state.stencil_ref = m_stencil_ref; 
     247                                } else if (lm == 1) { 
     248                                        state.stencil_func = NOTEQUAL; 
     249                                        state.stencil_op = KEEP; 
     250                                        state.stencil_ref = 255; 
     251                                } 
     252 
     253                                static_cast<RenderBackendOpenGLe*>(RenderBackend::instance())->drawLightPrimitive(p, m_intensity, m_radius, m_subdivisions, 
     254                                        static_cast<float>(m_xstretch * zoom), static_cast<float>(m_ystretch * zoom), 
     255                                        m_red, m_green, m_blue, state); 
     256                        } 
     257                } 
    278258        } 
    279259        std::vector<uint8_t> LightRendererSimpleLightInfo::getColor() { 
     
    285265                return colors; 
    286266        } 
    287  
    288267        LightRenderer* LightRenderer::getInstance(IRendererContainer* cnt) { 
    289268                return dynamic_cast<LightRenderer*>(cnt->getRenderer("LightRenderer")); 
    290269        } 
    291  
    292270        LightRenderer::LightRenderer(RenderBackend* renderbackend, int32_t position): 
    293271                RendererBase(renderbackend, position), 
     
    295273                setEnabled(false); 
    296274        } 
    297  
    298275        LightRenderer::LightRenderer(const LightRenderer& old): 
    299276                RendererBase(old), 
     
    301278                setEnabled(false); 
    302279        } 
    303  
    304280        RendererBase* LightRenderer::clone() { 
    305281                return new LightRenderer(*this); 
    306282        } 
    307  
    308283        LightRenderer::~LightRenderer() { 
    309284        } 
     
    329304        } 
    330305        // Enable stencil test for the group 
    331         void LightRenderer::addStencilTest(const std::string &group, uint8_t stencil_ref, float alpha_ref) { 
     306        void LightRenderer::addStencilTest(const std::string &group, uint8_t stencil_ref) { 
    332307                std::vector<LightRendererElementInfo*>::const_iterator info_it = m_groups[group].begin(); 
    333308                for (;info_it != m_groups[group].end(); ++info_it) { 
    334                         (*info_it)->setStencil(stencil_ref, alpha_ref); 
     309                        (*info_it)->setStencil(stencil_ref); 
    335310                } 
    336311        } 
     
    394369                                        if ((*info_it)->getStencil() != -1 && (*info_it)->getStencil() < 255) { 
    395370                                                if(info_it != group_it->second.begin()) { 
    396                                                         (*info_it)->setStencil((*info_it)->getStencil()+1, (*info_it)->getAlpha()); 
     371                                                        (*info_it)->setStencil((*info_it)->getStencil()+1); 
    397372                                                } 
    398373                                        } 
  • branches/active/0.3.3dev/engine/core/view/renderers/lightrenderer.h

    r3689 r3721  
    4242        class LightRendererElementInfo { 
    4343        public: 
    44                 virtual void render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) {}; 
    45                 virtual std::string getName() { return 0; }; 
    46                 virtual RendererNode* getNode() { return NULL; }; 
    47                 virtual int32_t getId() { return -1; }; 
    48                 virtual int32_t getSrcBlend() { return -1; }; 
    49                 virtual int32_t getDstBlend() { return -1; }; 
    50                 virtual void setStencil(uint8_t stencil_ref, float alpha_ref) {}; 
    51                 virtual int32_t getStencil() { return 0; }; 
    52                 virtual float getAlpha() { return 0; }; 
    53                 virtual void removeStencil() {}; 
     44                LightRendererElementInfo(RendererNode n, int32_t src, int32_t dst); 
     45                virtual ~LightRendererElementInfo() {}; 
     46 
     47                virtual void render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend) = 0; 
     48                virtual std::string getName() = 0; 
     49 
     50                RendererNode* getNode() { return &m_anchor; }; 
     51                int32_t getSrcBlend() { return m_src; }; 
     52                int32_t getDstBlend() { return m_dst; }; 
     53 
     54                void setStencil(uint8_t stencil_ref); 
     55                int32_t getStencil(); 
     56                void removeStencil(); 
     57 
    5458                virtual std::vector<uint8_t> getColor() { return std::vector<uint8_t>(); }; 
    5559                virtual float getRadius() { return 0; }; 
     
    5761                virtual float getXStretch() { return 0; }; 
    5862                virtual float getYStretch() { return 0; }; 
    59                 virtual ~LightRendererElementInfo() {}; 
     63         
     64        protected: 
     65                RendererNode m_anchor; 
     66                int32_t m_src; 
     67                int32_t m_dst; 
     68                bool m_stencil; 
     69                uint8_t m_stencil_ref; 
    6070        }; 
    6171 
    6272        class LightRendererImageInfo : public LightRendererElementInfo { 
    6373        public: 
    64                 void render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend); 
    65                 std::string getName() { return "image"; }; 
    66                 RendererNode* getNode() { return &m_anchor; }; 
    67                 ImagePtr getImage() { return m_image; }; 
    68                 int32_t getSrcBlend() { return m_src; }; 
    69                 int32_t getDstBlend() { return m_dst; }; 
    70                 void setStencil(uint8_t stencil_ref, float alpha_ref); 
    71                 int32_t getStencil(); 
    72                 float getAlpha(); 
    73                 void removeStencil(); 
    7474                LightRendererImageInfo(RendererNode n, ImagePtr image, int32_t src, int32_t dst); 
    7575                virtual ~LightRendererImageInfo() {}; 
     76 
     77                virtual void render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend); 
     78                virtual std::string getName() { return "image"; }; 
     79                ImagePtr getImage() { return m_image; }; 
     80 
    7681        private: 
    77                 RendererNode m_anchor; 
    7882                ImagePtr m_image; 
    79                 int32_t m_src; 
    80                 int32_t m_dst; 
    81                 bool m_stencil; 
    82                 uint8_t m_stencil_ref; 
    83                 float m_alpha_ref; 
    8483        }; 
     84 
    8585        class LightRendererAnimationInfo : public LightRendererElementInfo { 
    8686        public: 
    87                 void render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend); 
    88                 std::string getName() { return "animation"; }; 
    89                 RendererNode* getNode() { return &m_anchor; }; 
    90                 AnimationPtr getAnimation() { return m_animation; }; 
    91                 int32_t getSrcBlend() { return m_src; }; 
    92                 int32_t getDstBlend() { return m_dst; }; 
    93                 void setStencil(uint8_t stencil_ref, float alpha_ref); 
    94                 int32_t getStencil(); 
    95                 float getAlpha(); 
    96                 void removeStencil(); 
    9787                LightRendererAnimationInfo(RendererNode n, AnimationPtr animation, int32_t src, int32_t dst); 
    9888                virtual ~LightRendererAnimationInfo() {}; 
     89 
     90                virtual void render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend); 
     91                virtual std::string getName() { return "animation"; }; 
     92                AnimationPtr getAnimation() { return m_animation; }; 
     93 
    9994        private: 
    100                 RendererNode m_anchor; 
    10195                AnimationPtr m_animation; 
    102                 int32_t m_src; 
    103                 int32_t m_dst; 
    10496                uint32_t m_start_time; 
    10597                float m_time_scale; 
    106                 bool m_stencil; 
    107                 uint8_t m_stencil_ref; 
    108                 float m_alpha_ref; 
    10998        }; 
     99 
    110100        class LightRendererSimpleLightInfo : public LightRendererElementInfo { 
    111101        public: 
    112                 void render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend); 
    113                 std::string getName() { return "simple"; }; 
    114                 RendererNode* getNode() { return &m_anchor; }; 
    115                 int32_t getSrcBlend() { return m_src; }; 
    116                 int32_t getDstBlend() { return m_dst; }; 
    117                 void setStencil(uint8_t stencil_ref, float alpha_ref); 
    118                 int32_t getStencil(); 
    119                 float getAlpha(); 
    120                 void removeStencil(); 
     102                LightRendererSimpleLightInfo(RendererNode n, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t r, uint8_t g, uint8_t b, int32_t src, int32_t dst); 
     103                virtual ~LightRendererSimpleLightInfo() {}; 
     104 
     105                virtual void render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend); 
     106                virtual std::string getName() { return "simple"; }; 
     107 
    121108                std::vector<uint8_t> getColor(); 
    122109                float getRadius() { return m_radius; }; 
     
    124111                float getXStretch() { return m_xstretch; }; 
    125112                float getYStretch() { return m_ystretch; }; 
    126                 LightRendererSimpleLightInfo(RendererNode n, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t r, uint8_t g, uint8_t b, int32_t src, int32_t dst); 
    127                 virtual ~LightRendererSimpleLightInfo() {}; 
     113 
    128114        private: 
    129                 RendererNode m_anchor; 
    130115                uint8_t m_intensity; 
    131116                float m_radius; 
     
    136121                uint8_t m_green; 
    137122                uint8_t m_blue; 
    138                 int32_t m_src; 
    139                 int32_t m_dst; 
    140                 bool m_stencil; 
    141                 uint8_t m_stencil_ref; 
    142                 float m_alpha_ref; 
    143123        }; 
     124 
    144125        class LightRendererResizeInfo : public LightRendererElementInfo { 
    145126        public: 
    146                 void render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend); 
    147                 std::string getName() { return "resize"; }; 
    148                 RendererNode* getNode() { return &m_anchor; }; 
    149                 ImagePtr getImage() { return m_image; }; 
    150                 int32_t getSrcBlend() { return m_src; }; 
    151                 int32_t getDstBlend() { return m_dst; }; 
    152                 void setStencil(uint8_t stencil_ref, float alpha_ref); 
    153                 int32_t getStencil(); 
    154                 float getAlpha(); 
    155                 void removeStencil(); 
    156127                LightRendererResizeInfo(RendererNode n, ImagePtr image, int32_t width, int32_t height, int32_t src, int32_t dst); 
    157128                virtual ~LightRendererResizeInfo() {}; 
     129 
     130                virtual void render(Camera* cam, Layer* layer, RenderList& instances, RenderBackend* renderbackend); 
     131                virtual std::string getName() { return "resize"; }; 
     132 
     133                ImagePtr getImage() { return m_image; }; 
     134 
    158135        private: 
    159                 RendererNode m_anchor; 
    160136                ImagePtr m_image; 
    161137                int32_t m_width; 
    162138                int32_t m_height; 
    163                 int32_t m_src; 
    164                 int32_t m_dst; 
    165                 bool m_stencil; 
    166                 uint8_t m_stencil_ref; 
    167                 float m_alpha_ref; 
    168139        }; 
     140 
    169141        class LightRenderer: public RendererBase { 
    170142        public: 
     
    193165                void addSimpleLight(const std::string &group, RendererNode n, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t r, uint8_t g, uint8_t b, int32_t src=-1, int32_t dst=-1); 
    194166                void resizeImage(const std::string &group, RendererNode n, ImagePtr image, int32_t width, int32_t height, int32_t src=-1, int32_t dst=-1); 
    195                 void addStencilTest(const std::string &group, uint8_t stencil_ref=0, float alpha_ref=0.0); 
     167                void addStencilTest(const std::string &group, uint8_t stencil_ref=0); 
    196168                void removeStencilTest(const std::string &group); 
    197169                std::list<std::string> getGroups(); 
  • branches/active/0.3.3dev/engine/core/view/renderers/lightrenderer.i

    r3641 r3721  
    3030        class LightRendererElementInfo { 
    3131        public: 
    32                 virtual std::string getName() { return 0; }; 
    33                 virtual RendererNode* getNode() { return NULL; }; 
    34                 virtual int32_t getId() { return -1; }; 
    35                 virtual int32_t getSrcBlend() { return -1; }; 
    36                 virtual int32_t getDstBlend() { return -1; }; 
    37                 virtual void setStencil(uint8_t stencil_ref, float alpha_ref) {}; 
    38                 virtual int32_t getStencil() { return 0; }; 
    39                 virtual float getAlpha() { return 0; }; 
    40                 virtual void removeStencil() {}; 
    41                 virtual std::vector<uint8_t> getColor() {}; 
    42                 virtual float getRadius() { return 0; }; 
    43                 virtual int32_t getSubdivisions() { return 0; }; 
    44                 virtual float getXStretch() { return 0; }; 
    45                 virtual float getYStretch() { return 0; }; 
    46                 virtual ~LightRendererElementInfo() {}; 
     32                LightRendererElementInfo(RendererNode n, int32_t src, int32_t dst); 
     33                virtual ~LightRendererElementInfo(); 
     34                virtual std::string getName() = 0; 
     35                RendererNode* getNode(); 
     36                int32_t getSrcBlend(); 
     37                int32_t getDstBlend(); 
     38                void setStencil(uint8_t stencil_ref); 
     39                int32_t getStencil(); 
     40                void removeStencil(); 
     41                virtual std::vector<uint8_t> getColor(); 
     42                virtual float getRadius(); 
     43                virtual int32_t getSubdivisions(); 
     44                virtual float getXStretch(); 
     45                virtual float getYStretch(); 
    4746        }; 
    4847 
     
    5049        public: 
    5150                LightRendererImageInfo(RendererNode n, ImagePtr image, int32_t src, int32_t dst); 
    52                 virtual ~LightRendererImageInfo() {}; 
     51                virtual ~LightRendererImageInfo(); 
    5352                 
    5453                ImagePtr getImage(); 
    5554        }; 
     55         
    5656        class LightRendererAnimationInfo : public LightRendererElementInfo { 
    5757        public: 
    5858                LightRendererAnimationInfo(RendererNode n, AnimationPtr animation, int32_t src, int32_t dst); 
    59                 virtual ~LightRendererAnimationInfo() {}; 
     59                virtual ~LightRendererAnimationInfo(); 
    6060                 
    6161                AnimationPtr getAnimation(); 
    6262        }; 
     63         
    6364        class LightRendererSimpleLightInfo : public LightRendererElementInfo { 
    6465        public: 
    6566                LightRendererSimpleLightInfo(RendererNode n, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t r, uint8_t g, uint8_t b, int32_t src, int32_t dst); 
    66                 virtual ~LightRendererSimpleLightInfo() {}; 
     67                virtual ~LightRendererSimpleLightInfo(); 
     68                std::vector<uint8_t> getColor(); 
     69                float getRadius(); 
     70                int32_t getSubdivisions(); 
     71                float getXStretch(); 
     72                float getYStretch(); 
    6773        }; 
     74         
    6875        class LightRendererResizeInfo : public LightRendererElementInfo { 
    6976        public: 
    7077                LightRendererResizeInfo(RendererNode n, ImagePtr image, int32_t width, int32_t height, int32_t src, int32_t dst); 
    71                 virtual ~LightRendererResizeInfo() {}; 
     78                virtual ~LightRendererResizeInfo(); 
    7279                 
    7380                ImagePtr getImage(); 
    7481        }; 
     82         
    7583        class LightRenderer: public RendererBase { 
    7684        public: 
     
    8391                void addSimpleLight(const std::string &group, RendererNode n, uint8_t intensity, float radius, int32_t subdivisions, float xstretch, float ystretch, uint8_t r, uint8_t g, uint8_t b, int32_t src=-1, int32_t dst=-1); 
    8492                void resizeImage(const std::string &group, RendererNode n, ImagePtr image, int32_t width, int32_t height, int32_t src=-1, int32_t dst=-1); 
    85                 void addStencilTest(const std::string &group, uint8_t stencil_ref=0, float alpha_ref=0.0); 
     93                void addStencilTest(const std::string &group, uint8_t stencil_ref=0); 
    8694                void removeStencilTest(const std::string &group); 
    8795                std::list<std::string> getGroups(); 
  • branches/active/0.3.3dev/engine/python/fife/extensions/pychan/compat.py

    r3684 r3721  
    8080                img = engine.getImageManager().load(filename) 
    8181                return guichan.GuiImage(img) 
     82                # use below line instead of above ones to let guichan 
     83                # use its image loader that supports  creating/using atlases 
     84                #return guichan.GuiImage().load(filename) 
    8285 
    8386        class hook: 
  • branches/active/0.3.3dev/tools/editor/gui/lightedit.xml

    r3515 r3721  
    2323      <Button name="stencil_up" text="+" max_size="20,20"/> 
    2424      <Button name="stencil_dn" text="-" max_size="20,20"/> 
    25     </HBox> 
    26  
    27     <HBox> 
    28       <Label text="Alpha Test: " min_size="25,20"/> 
    29       <TextBox text="0.0" name="alpha" size="30,20" min_size="30,20" max_size="30,20" /> 
    30       <Button name="alpha_up" text="+" max_size="20,20"/> 
    31       <Button name="alpha_dn" text="-" max_size="20,20"/> 
    3225    </HBox> 
    3326 
     
    167160                <Button text="-" name="decrease_B" /> 
    168161        </HBox> 
    169         <HBox> 
    170                 <Label text="A" /> 
    171         <TextBox text="1.0" name="value_A" min_size="30,20"/> 
    172                 <Button text="+" name="increase_A" /> 
    173                 <Button text="-" name="decrease_A" /> 
    174         </HBox> 
    175162        <VBox> 
    176163                <Button text="Random" name="random_global_light" /> 
  • branches/active/0.3.3dev/tools/editor/plugins/LightEdit.py

    r3697 r3721  
    5656        "R"     :       1.0, 
    5757        "G"     :       1.0, 
    58         "B"     :       1.0, 
    59         "A" :   1.0, 
     58        "B"     :       1.0 
    6059} 
    6160 
     
    8988                self._instances = None 
    9089                self._light["stencil"] = -1 
    91                 self._light["alpha"] = 0.0 
    9290                self._light["src"] = -1 
    9391                self._light["dst"] = -1 
     
    178176                        "stencil_dn"            : cbwa(self.change_light, value=-1, option="stencil"), 
    179177                        "stencil/mouseWheelMovedUp"                     :       cbwa(self.change_light, value=10, option="stencil"), 
    180                         "stencil/mouseWheelMovedDown" : cbwa(self.change_light, value=-10, option="stencil"), 
    181  
    182                         "alpha_up"              : cbwa(self.change_light, value=0.01, option="alpha"), 
    183                         "alpha_dn"              : cbwa(self.change_light, value=-0.01, option="alpha"), 
    184                         "alpha/mouseWheelMovedUp"                       :       cbwa(self.change_light, value=0.1, option="alpha"), 
    185                         "alpha/mouseWheelMovedDown" : cbwa(self.change_light, value=-0.1, option="alpha"),                       
     178                        "stencil/mouseWheelMovedDown" : cbwa(self.change_light, value=-10, option="stencil"),            
    186179 
    187180                        "intensity_up"          : cbwa(self.change_light, value=1, option="intensity"), 
     
    251244                        "decrease_B"                    :       cbwa(self.decrease_color, b=True), 
    252245                        "value_B/mouseWheelMovedUp"                     :       cbwa(self.increase_color, step=0.1, b=True), 
    253                         "value_B/mouseWheelMovedDown"           :       cbwa(self.decrease_color, step=0.1, b=True), 
    254                          
    255                         "increase_A"                    :       cbwa(self.increase_color, a=True), 
    256                         "decrease_A"                    :       cbwa(self.decrease_color, a=True),                       
    257                         "value_A/mouseWheelMovedUp"                     :       cbwa(self.increase_color, step=0.1, a=True), 
    258                         "value_A/mouseWheelMovedDown"           :       cbwa(self.decrease_color, step=0.1, a=True),                     
     246                        "value_B/mouseWheelMovedDown"           :       cbwa(self.decrease_color, step=0.1, b=True)                      
    259247                }) 
    260248 
     
    264252                        "obj_id"                        :       self.container.findChild(name="obj_id"), 
    265253                        "stencil"                       :       self.container.findChild(name="stencil"), 
    266                         "alpha"                         :       self.container.findChild(name="alpha"), 
    267254                         
    268255                        "intensity"                     :       self.container.findChild(name="intensity"), 
     
    282269                        "value_R"                               :       self.container.findChild(name="value_R"), 
    283270                        "value_G"                               :       self.container.findChild(name="value_G"), 
    284                         "value_B"                               :       self.container.findChild(name="value_B"), 
    285                         "value_A"                               :       self.container.findChild(name="value_A"),                        
     271                        "value_B"                               :       self.container.findChild(name="value_B")                 
    286272                } 
    287273 
     
    304290                self._widgets["obj_id"].text = unicode(str(self._instances[0].getObject().getId())) 
    305291                self._widgets["stencil"].text = unicode(str(self._light["stencil"])) 
    306                 self._widgets["alpha"].text = unicode(str(self._light["alpha"])) 
    307292                self._widgets["src"].text = unicode(str(self._light["src"])) 
    308293                self._widgets["dst"].text = unicode(str(self._light["dst"])) 
     
    320305                self._widgets["value_G"].text = unicode(str(self._color["G"])) 
    321306                self._widgets["value_B"].text = unicode(str(self._color["B"])) 
    322                 self._widgets["value_A"].text = unicode(str(self._color["A"]))           
    323307                 
    324308                if self._simple_l: 
     
    402386                self._color["G"] = color[1] 
    403387                self._color["B"] = color[2] 
    404                 self._color["A"] = color[3] 
    405388                 
    406389                groups = self.lightrenderer.getGroups() 
     
    413396                                        self._widgets["group"].text = unicode(str(group)) 
    414397                                        self._light["stencil"] = info.getStencil() 
    415                                         self._light["alpha"] = info.getAlpha() 
    416398                                        self._light["src"] = info.getSrcBlend() 
    417399                                        self._light["dst"] = info.getDstBlend() 
     
    482464        def reset_light(self): 
    483465                self._light["stencil"] = -1 
    484                 self._light["alpha"] = 0.0 
    485466                self._light["src"] = -1 
    486467                self._light["dst"] = -1 
     
    515496                        self._instances[0].setId(insid) 
    516497                 
    517                 if self._light["stencil"] is not -1 and self._light["alpha"] is not 0.0: self.stencil_test() 
     498                if self._light["stencil"] is not -1 : self.stencil_test() 
    518499                if self._simple_l: self.simple_light() 
    519500                if self._image_l: self.image_light() 
     
    538519                                                                                        or option == "blue" 
    539520                                                                                        or option == "stencil"): 
    540                         self._light[option] = 255 
    541                 if self._light[option]+ value > 1 and option == "alpha": 
    542                         self._light[option] = 1.0                        
     521                        self._light[option] = 255        
    543522 
    544523                self.update_gui() 
    545524 
    546525        def stencil_test(self): 
    547                 self.lightrenderer.addStencilTest(str(self._widgets["group"]._getText()), self._light["stencil"], self._light["alpha"]) 
     526                self.lightrenderer.addStencilTest(str(self._widgets["group"]._getText()), self._light["stencil"]) 
    548527 
    549528        def simple_light(self): 
     
    613592                @type   b               bool 
    614593                @param  b               flag to alter blue color value 
    615                 @type   a               bool 
    616                 @type   a               flag to alter alpha channel value (no effect atm)                
    617594                """ 
    618595                if r: 
     
    631608                        else: 
    632609                                self._color["B"] += step 
    633                 if a: 
    634                         if self._color["A"] + step > 1.0: 
    635                                 self._color["A"] = 1.0 
    636                         else: 
    637                                 self._color["A"] += step 
    638610 
    639611                self.update_gui()                                        
     
    651623                @type   b               bool 
    652624                @param  b               flag to alter blue color value 
    653                 @type   a               bool 
    654                 @type   a               flag to alter alpha channel value (no effect atm)                
    655625                """ 
    656626                if r: 
     
    669639                        else: 
    670640                                self._color["B"] -= step 
    671                 if a: 
    672                         if self._color["A"] - step < 0.0: 
    673                                 self._color["A"] = 0.0 
    674                         else: 
    675                                 self._color["A"] -= step 
    676                          
     641 
    677642                self.update_gui()                                        
    678643                self.set_global_light() 
     
    683648                self._color["G"] = random.uniform(0,1) 
    684649                self._color["B"] = random.uniform(0,1) 
    685                 self._color["A"] = random.uniform(0,1) 
    686650 
    687651                self.update_gui()                                        
     
    692656                self._camera.setLightingColor(self._color["R"], 
    693657                                                                          self._color["G"], 
    694                                                                           self._color["B"], 
    695                                                                           self._color["A"] 
    696                                                                           ) 
     658                                                                          self._color["B"]) 
    697659 
    698660        def input(self, instances): 
Note: See TracChangeset for help on using the changeset viewer.