Changeset 115 for trunk/VUT/work/ogre_changes

Timestamp:

05/30/05 03:20:23 (20 years ago)

Author:

mattausch

Message:

added depth pass algorithm + delayed transparent object rendering (so depth ordering is right)

Location:

trunk/VUT/work/ogre_changes

Files:

• OgreMain/include/OgreHardwareOcclusionQuery.h (modified) (2 diffs)
• OgreMain/include/OgreRenderQueueSortingGrouping.h (added)
• OgreMain/include/OgreSceneManager.h (modified) (1 diff)
• OgreMain/src/OgreRenderQueueSortingGrouping.cpp (added)
• OgreMain/src/OgreSceneManager.cpp (modified) (14 diffs)
• Plugins/OctreeSceneManager/include/OgreOctreeSceneManager.h (modified) (2 diffs)
• Plugins/OctreeSceneManager/src/OgreOctree.cpp (modified) (2 diffs)
• Plugins/OctreeSceneManager/src/OgreOctreeSceneManager.cpp (modified) (5 diffs)
• RenderSystems/Direct3D9/include/OgreD3D9HardwareOcclusionQuery.h (modified) (4 diffs)
• RenderSystems/Direct3D9/src/OgreD3D9HardwareOcclusionQuery.cpp (modified) (5 diffs)
• RenderSystems/GL/include/OgreGLHardwareOcclusionQuery.h (modified) (3 diffs)
• RenderSystems/GL/include/OgreGLPrerequisites.h (modified) (3 diffs)
• RenderSystems/GL/src/OgreGLHardwareOcclusionQuery.cpp (modified) (8 diffs)
• RenderSystems/GL/src/OgreGLRenderSystem.cpp (modified) (10 diffs)
• Samples/Common/include/ExampleFrameListener.h (modified) (1 diff)

trunk/VUT/work/ogre_changes/OgreMain/include/OgreHardwareOcclusionQuery.h

@@ -96 +96 @@
       * Pulls the hardware occlusion query too see if there is a result.
       * @retval NumOfFragments will get the resulting number of fragments.
-          * @param waitForResult if true, the query will wait until a result is available
-      * @return True if success or false if not.
-          * @Remarks Hardware occlusion is an assyncronius process the result may take a frame or so.
-          *                     one idea is to test pass1 and if not visible skip pass2. Also note that objects
-          *                     not visible must be tested evrey frame. Visable objects don't need testing every frame.
-          *                     Testing non visable objects can be don unlit, no texture with low LOD object.
-          *        0 will generate all the levels till 1x1. [default: 0]
-      */
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-          virtual bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult ) = 0;
-#else
-         virtual bool pullOcclusionQuery( unsigned int* NumOfFragments ) = 0;
-#endif
-        /**
-      * Pulls the hardware occlusion query too see if there is a result.
-      * @retval NumOfFragments will get the resulting number of fragments.
-          * @param waitForResult if true, the query will wait until a result is available
       * @return True if success or false if not.
           * @Remarks In DX9 mode specifying OCCLUSIONQUERY_FLUSH as the flag, will case the driver to flush whatever API calls are batched.
           * In OpenGL mode it makes no difference if you specify OCCLUSIONQUERY_FLUSH or OCCLUSIONQUERY_NOFLUSH.
       */
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-        virtual bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult,
-                                                                         const HW_OCCLUSIONQUERY flag  ) = 0; 
-#else
-          virtual bool pullOcclusionQuery( unsigned int* NumOfFragments, 
-                                                                           const HW_OCCLUSIONQUERY flag  ) = 0; 
-#endif
+        virtual bool pullOcclusionQuery(unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag = HWOCCLUSIONQUERY_FLUSH) = 0;
+
         /**
           * Let's you get the last pixel count with out doing the hardware occlusion test
@@ -143 +121 @@
         virtual void    setSkipRate( int skip ) = 0;
         virtual int             getSkipRate() = 0;
+
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+        /**
+                Pulls occlusion query.
+                @param NumOfFragments number of visible fragments if query result was available.
+                Last query result if query result was not yet available.
+
+                @param waitForResult if true, the function waits until the result is available.
+                Otherwise the function returns immediately, not waiting for the result.
+                @returns true if query result was available, false if result was not yet available
+        */
+        virtual bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, 
+                const HW_OCCLUSIONQUERY flag = HWOCCLUSIONQUERY_FLUSH ) = 0; 
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
+
 //----------------------------------------------------------------------
 // Private members

trunk/VUT/work/ogre_changes/OgreMain/include/OgreSceneManager.h

@@ -128 +128 @@
                         @param node scene node to be rendered
                         @param cam current camera
+                        @param leaveTransparentsInQueue if only solid objects should be rendered
                 */
-                void _renderSceneNode( Camera *cam, SceneNode *node );
-                /** deletes all queues which we were currently processing
-                        @remark clears renderqueue after rendering scene node
+                void _renderSceneNode(Camera *cam, SceneNode *node, bool leaveTransparentsInQueue = false);
+                /** deletes all processed queues
+                        @remark clears render queues after rendering scene node
                 */
-                void _deleteRenderedQueueGroups();
+                void _deleteRenderedQueueGroups(bool leaveTransparentsInQueue);
                 /** Internal method used by _renderVisibleObjects to deal with renderables
             which override the camera's own view / projection materices. 

trunk/VUT/work/ogre_changes/OgreMain/src/OgreSceneManager.cpp

@@ -59 +59 @@
 #include "OgreDataStream.h"
 #include "OgreStaticGeometry.h"
-#include <windows.h> //matt: remove later
+
 // This class implements the most basic scene manager
 
@@ -665 +665 @@
         if (lastUsedVertexProgram)
         {
-                        //matt: remove later
-                        //OutputDebugString("unbinding vertex program\n");
-
             mDestRenderSystem->unbindGpuProgram(GPT_VERTEX_PROGRAM);
             lastUsedVertexProgram = false;
@@ -990 +987 @@
                                const String& groupName)
 {
-    mSkyPlaneEnabled = enable;
     if (enable)
     {
@@ -1061 +1057 @@
 
     }
+        mSkyPlaneEnabled = enable;
 }
 //-----------------------------------------------------------------------
@@ -1071 +1068 @@
                              const String& groupName)
 {
-    mSkyBoxEnabled = enable;
     if (enable)
     {
@@ -1143 +1139 @@
 
     }
-
+        mSkyBoxEnabled = enable;
 }
 //-----------------------------------------------------------------------
@@ -1157 +1153 @@
                               const String& groupName)
 {
-    mSkyDomeEnabled = enable;
     if (enable)
     {
@@ -1164 +1159 @@
         {
             OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
-                "Sky dome material '" + materialName + " not found.",
+                "Sky dome material '" + materialName + "' not found.",
                 "SceneManager::setSkyDome");
         }
@@ -1208 +1203 @@
 
     }
+        mSkyDomeEnabled = enable;
 }
 //-----------------------------------------------------------------------
@@ -2658 +2654 @@
     {
         Light* l = i->second;
+                if (l->isVisible())
+                {
         if (l->getType() == Light::LT_DIRECTIONAL)
         {
@@ -2675 +2673 @@
 
         }
+    }
     }
 
@@ -4180 +4179 @@
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
 //-----------------------------------------------------------------------
-void SceneManager::_renderSceneNode( Camera *cam, SceneNode *node )
+void SceneManager::_renderSceneNode(Camera *cam, SceneNode *node, bool leaveTransparentsInQueue)
 {
         node->_findVisibleObjects(cam, getRenderQueue(), false, mDisplayNodes, false);
@@ -4186 +4185 @@
         
         // delete all rendered objects from renderqueue
-        _deleteRenderedQueueGroups();
-}
-//-----------------------------------------------------------------------
-void SceneManager::_deleteRenderedQueueGroups()
+        _deleteRenderedQueueGroups(leaveTransparentsInQueue);
+}
+//-----------------------------------------------------------------------
+void SceneManager::_deleteRenderedQueueGroups(bool leaveTransparentsInQueue)
 {
         RenderQueue::QueueGroupIterator queueIt = getRenderQueue()->_getQueueGroupIterator();
@@ -4200 +4199 @@
 
                 if (isRenderQueueToBeProcessed(qId))
+                {
+                        if (leaveTransparentsInQueue)
+                        {
+                                pGroup->clearSolids();
+                        }
+                        else
+                        {
                         pGroup->clear();
+        }
+                }
         }
         

trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/include/OgreOctreeSceneManager.h

@@ -105 +105 @@
         /** Renders one octant of an octree, i.e., renders current octant
                 node and does not traverse deeper into the tree.
+
                 @remark Note that OctreeNode instances are NOT part of the octree 
                 hierarchy, instead one octant of an Octree contains many OctreeNode instances.
-                @param octree the octree to be rendered
+                
                 @param cam current camera
+                @param octree the octant to be rendered (without children)
+                @param onlyShadowCasters if only shadow casters are rendered
+                @param leaveTransparentsInQueue if transparemt should be left in queue for later processing
         */
-        void _renderOctant(Camera* cam, Octree *octree, bool onlyShadowCasters);
+        void _renderOctant(Camera* cam, Octree *octree, bool onlyShadowCasters, bool leaveTransparentsInQueue = false);
 
         /** Returns stored list of boxes */
@@ -214 +218 @@
     IntersectionSceneQuery* createIntersectionQuery(unsigned long mask);
 
+
 protected:
 

trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctree.cpp

@@ -109 +109 @@
                 mDepth = 0;
 
-        //matt: remove later
-        //char msg[100];
-        //sprintf(msg, "creating new octant in depth %d", mDepth);
-        //OutputDebugString(msg);
-
 #endif //GTP_VISIBILITY_MODIFIED_OGRE
     mNumNodes = 0;
@@ -171 +166 @@
 
         mWireBoundingBox->setupBoundingBox(mBox);
-
-        // matt: change this back
-        //AxisAlignedBox box; _getCullBounds(&box); 
-        //mWireBoundingBox->setupBoundingBox(box);
-
     return mWireBoundingBox;
 }

trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctreeSceneManager.cpp

@@ -39 +39 @@
 #include <OgreOctreeCamera.h>
 #include <OgreRenderSystem.h>
-#include <windows.h>
+
 
 extern "C"
@@ -508 +508 @@
         }
 
-                //matt: remove later
-                //OutputDebugString("adding octree node\n");
-                
-
         _addOctreeNode( n, octant -> mChildren[ x ][ y ][ z ], ++depth );
 
@@ -1173 +1169 @@
 }
 //-----------------------------------------------------------------------
-void OctreeSceneManager::_renderOctant(Camera *cam, Octree *octant, bool onlyShadowCasters)
+void OctreeSceneManager::_renderOctant(Camera *cam, Octree *octant, bool onlyShadowCasters, 
+                                                                           bool leaveTransparentsInQueue)//, bool useZPassQueue)
 {
         //Add stuff to be rendered;
@@ -1188 +1185 @@
                 {
                         sn->_addToRenderQueue(cam, getRenderQueue(), onlyShadowCasters);
-                        //node->_findVisibleObjects(cam, getRenderQueue(), false, mDisplayNodes, false);
                         mVisible.push_back(sn);
 
@@ -1207 +1203 @@
         if (mShowBoxes)
         {
+                octant->getWireBoundingBox()->setMaterial("BaseWhiteNoLighting");
+
                 getRenderQueue()->addRenderable(octant->getWireBoundingBox());
                 mBoxes.push_back(octant->getWireBoundingBox());
         }
 
+        //-- the actual rendering
         SceneManager::_renderVisibleObjects();
-
         // delete all rendered objects from the render queue
-        _deleteRenderedQueueGroups();
+        _deleteRenderedQueueGroups(leaveTransparentsInQueue);
 }
 #endif // GTP_VISIBILITY_MODIFIED_OGRE

trunk/VUT/work/ogre_changes/RenderSystems/Direct3D9/include/OgreD3D9HardwareOcclusionQuery.h

@@ -33 +33 @@
 namespace Ogre {
 
-
-
 // If you use multiple rendering passes you can test only the first pass and all other passes don't have to be rendered 
-// if the first pass resultet has too few pixels visable.
+        // if the first pass resultet has too few pixels visible.
 
 // Be sure to render all occlluder first and whats out so the RenderQue don't switch places on 
@@ -46 +44 @@
   *
   * @author Lee Sandberg, email lee@abcmedia.se
+        *
+        * Updated on 12/7/2004 by Chris McGuirk
   */
 class D3D9HardwareOcclusionQuery : public HardwareOcclusionQuery
@@ -71 +71 @@
         void beginOcclusionQuery();     
         void endOcclusionQuery();
+                bool pullOcclusionQuery( unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag = HWOCCLUSIONQUERY_FLUSH);
+                unsigned int getLastQuerysPixelcount() { return mPixelCount; }
 
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-        bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult,
-                                                         const HW_OCCLUSIONQUERY flag  ); 
-        bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult );
-#else
-        bool pullOcclusionQuery( unsigned int* NumOfFragments );
-        bool pullOcclusionQuery( unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag  ); 
-#endif // GTP_VISIBILITY_MODIFIED_OGRE
-
-        unsigned int getLastQuerysPixelcount() { return m_uintPixelCount; }
-        
-        // This functions are optional, it's a simple filter that simply skips some hardware occlusion tests on visable objects only
-        // It's easy to use if you don't have to keep track on which objects are visable (can be skipped) and what objects arn't visable..
-        // (None visable objects and object you introduce for the first time have allways to be tested allthough the cheepest possible 
-        // LOD (Level Of Detail) mesh and material wize). 
+                // These functions are optional, it's a simple filter that simply skips some hardware occlusion tests on visible objects only
+                // It's easy to use if you don't have to keep track of which objects are visible (can be skipped) and what objects arn't visible..
+                // (None visible objects and object you introduce for the first time have always to be tested although the cheapest possible 
+                // LOD (Level Of Detail) mesh and material-wise). 
 
         /**
           *   
-          * Remarks This function allows you to set how often the hardware occlusion really are sent to the driver
+                * Remarks This function allows you to set how often the hardware occlusion query is sent to the driver
           * if you set it to 0 every hw occlusion test is acctually made. If you set it to 1 only the half of your queries are sent 
-          * for all visable objects. 2 will result in 25% of all queries to acctualy be sent. 
-          * New and none visable objects will be tested all the time.
-          * This functionality is here because this class can keep track on visable and none visable objects for you.
+                * 2 will result in 25% of all queries to acctualy be sent. 
+                * This functionality is here because this class can keep track on visible and none visible objects for you.
           * Once you you set the SkipRate for any hardware occlusion instance it effects all others.
           */
 
+                void setSkipRate( int skip ) { mSkipInterval = skip; }                  // Using 2 only 50 % of the tests are actully made and 3 results in only 33% of the tests. So on.
+                int      getSkipRate() { return mSkipInterval; } 
 
-        void setSkipRate( int skip ) { m_Skip = skip; }                 // Using 2 only 50 % of the tests are actually made and 3 results in only 33% of the tests. So on.
-        int      getSkipRate() { return m_Skip; } 
-
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+        bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, const HW_OCCLUSIONQUERY flag = HWOCCLUSIONQUERY_FLUSH ); 
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
 //----------------------------------------------------------------------
 // Protected members
@@ -107 +99 @@
 protected:
 
-        bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, 
-                                                     const DWORD queryFlag );
-
-        unsigned int            m_uintPixelCount;               
-        IDirect3DQuery9*        m_pD3DQuery;
-        IDirect3DDevice9*   m_pD3DDevice;       // d3d device
-        bool                            m_bOcclusionQuery;
-        int                                     m_SkipCounter;          // m_SkipConter =  m_SkipConter % m_Skip; if ( m_SkipConter == 0 && m_uintPixelCount !=0 ) TestHWOcclusion else just return 
-        static int                      m_Skip;                         // This is shared by all instancies
-        bool                            m_bHWOcclusionSupport;
+                unsigned int            mPixelCount;            
+                IDirect3DQuery9*        mpQuery;
+                IDirect3DDevice9*   mpDevice;
+                int                                     mSkipCounter;
+                int                                     mSkipInterval;
+                bool                            mHasOcclusionSupport;
 };
 

trunk/VUT/work/ogre_changes/RenderSystems/Direct3D9/src/OgreD3D9HardwareOcclusionQuery.cpp

@@ -29 +29 @@
 namespace Ogre {
 
-int D3D9HardwareOcclusionQuery::m_Skip = 0;
-
 /**
   * This is a class that is the DirectX9 implementation of 
@@ -36 +34 @@
   *
   * @author Lee Sandberg
+        *
+        * Updated on 12/7/2004 by Chris McGuirk
   */
 
 /**
   * Default object constructor
-  * 
   */
 D3D9HardwareOcclusionQuery::D3D9HardwareOcclusionQuery( IDirect3DDevice9* pD3DDevice ) 
 { 
-        m_pD3DDevice = pD3DDevice;
-        m_uintPixelCount = 0; 
-        m_SkipCounter = 0;
-        m_bHWOcclusionSupport = false;
+                mpDevice = pD3DDevice;
+                mPixelCount = 0; 
+                mSkipCounter = 0;
+                mSkipInterval = 0;
+                mHasOcclusionSupport = false;
 
-        HRESULT hr = m_pD3DDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, &m_pD3DQuery);
+                // create the occlusion query
+                HRESULT hr = mpDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, &mpQuery);
+
         if ( hr != D3D_OK ) 
         {
-                //OGRE_EXCEPT(hr, "D3D9HardwareOcclusionQuery couldn't create hardware occlusion query object.", 
-        //        "D3D9HardwareOcclusionQuery::D3D9HardwareOcclusionQuery");
-                m_bHWOcclusionSupport = false;
+                        mHasOcclusionSupport = false;
         }
         else 
         {
-                m_bHWOcclusionSupport = true;
+                        mHasOcclusionSupport = true;
         }
 }
-
 
 /**
@@ -68 +67 @@
 D3D9HardwareOcclusionQuery::~D3D9HardwareOcclusionQuery() 
 { 
-        SAFE_RELEASE( m_pD3DQuery ); 
+                SAFE_RELEASE(mpQuery); 
 }
 
-#ifndef GTP_VISIBILITY_MODIFIED_OGRE
 //------------------------------------------------------------------
 // Occlusion query functions (see base class documentation for this)
@@ -77 +75 @@
 void D3D9HardwareOcclusionQuery::beginOcclusionQuery() 
 { 
-        if( m_bHWOcclusionSupport )             // Make it fail silently if hardware occlusion isn't supported
+                // Make it fail silently if hardware occlusion isn't supported
+                if(mHasOcclusionSupport)
         {
-                if  ( m_SkipCounter ==  m_Skip ) { m_SkipCounter = 0; };                // Counter starts at 0 again at m_Skip 
-                
-                if ( m_SkipCounter == 0 && m_uintPixelCount != 0 )      // New or none visable objects must allways be tested but visable objects can be skiped
+#ifndef GTP_VISIBILITY_MODIFIED_OGRE
+                        // Counter starts at 0 again at mSkipInterval 
+                        if(mSkipCounter == mSkipInterval) 
+#else
+                        if (mSkipCounter >= mSkipInterval)  // otherwise no query ever issued if mSkipInterval = 0 !
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
                 {
-                        m_pD3DQuery->Issue(D3DISSUE_BEGIN); 
+                                mSkipCounter = 0; 
+}
+                        //std::stringstream d; d << "count: " << mSkipCounter;
+                        //LogManager::getSingleton().logMessage(d.str());
+                        if (mSkipCounter == 0)
+                {
+                                mpQuery->Issue(D3DISSUE_BEGIN); 
                 }
         }
+        
 }
-        
-void D3D9HardwareOcclusionQuery::endOcclusionQuery() 
-{ 
-        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
+
+        void D3D9HardwareOcclusionQuery::endOcclusionQuery() 
         {
-                if (m_SkipCounter == 0 && m_uintPixelCount != 0 ) // New or none visable objects must allways be tested but visable objects can be skiped
-                {
-                        m_pD3DQuery->Issue(D3DISSUE_END); 
-                }
-                m_SkipCounter++;                                                                 // The skip counter is increased 
+                // Make it fail silently if hardware occlusion isn't supported
+                if(mHasOcclusionSupport)
+                        {
+                        if(mSkipCounter == 0)
+                        { 
+                                mpQuery->Issue(D3DISSUE_END); 
+        }
+
+                        // The skip counter is increased
+                        mSkipCounter++; 
         }
 }
 
 //------------------------------------------------------------------
-// This version of pullOcclusionQuery cases the DX9 API/Driver to flush all commands to the 3D card
-// to allow a fast result from the query, but at the cost of poorer batching of API calls to the card.
-// Note: OpenGL dosn't use this flag at all so the application running OpenGL won't display any different behaviour.
-//--
-bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments) 
-{
-        HRESULT hr;
-        
-        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
-        {
-                hr = m_pD3DQuery->GetData( NumOfFragments, sizeof( NumOfFragments ), D3DGETDATA_FLUSH );
-
-                if ( hr != S_OK ) 
-                        {
-                                return false; 
-                        }
-                        else 
-                        { 
-                                m_uintPixelCount = *NumOfFragments; 
-                                return true; 
-                        }
-        }
-        else
-        {
-                m_uintPixelCount = 100000; // Fails quitlly if hardware occlusion is not supported - every object is visable
-                return true;
-        }
-}
-
-//------------------------------------------------------------------
-// This version of pullOcclusionQuery cases the DX9 API/Driver to not flush all commands to the 3D card
+        // This version of pullOcclusionQuery causes the DX9 API/Driver to not flush all commands to the 3D card
 // to allow a fast result from the query, but the batching of API calls to the card will be normal. 
-// But the query wont be processed until the card recives the query in the nexr batch.
+        // But the query wont be processed until the card recives the query in the next batch.
 // Note: OpenGL dosn't use this flag at all so the application running OpenGL won't display any different behaviour.
 //--
@@ -140 +122 @@
         HRESULT hr;
 
-        // TO DO: USE lockOpts= D3D9Mappings::get(options); instead of RS_OCCLUSIONQUERY enum
+                // Make it fail silently if hardware occlusion isn't supported
+                if(mHasOcclusionSupport)
+        {
+                        DWORD d3dFlags = (flag == HWOCCLUSIONQUERY_FLUSH) ? D3DGETDATA_FLUSH : 0;
+        
+                        // run until success (http://www.gamedev.net/reference/programming/features/occlusionculling/page2.asp)
+                        while(hr = mpQuery->GetData( NumOfFragments, sizeof( NumOfFragments ), d3dFlags) == S_FALSE);
 
-        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
-        {
-        
-                switch( flag )
-                {
-                        case HWOCCLUSIONQUERY_FLUSH :   
-                                hr = m_pD3DQuery->GetData( NumOfFragments, sizeof( NumOfFragments ), D3DGETDATA_FLUSH );
-                        break;
-
-                        case HWOCCLUSIONQUERY_NOFLUSH : 
-                                hr = m_pD3DQuery->GetData( NumOfFragments, sizeof( NumOfFragments ), 0 );
-                        break;
-                };
-
-
-
-                if ( hr != S_OK ) 
-                        {
-                                return false; 
+                        mPixelCount = *NumOfFragments;
                         }
                         else 
                         { 
-                                m_uintPixelCount = *NumOfFragments; 
-                                return true; 
+                        // fail silently if not supported, assume visible i suppose
+                        mPixelCount = 100000;
                         }
-        }
-        else 
-        {
-                m_uintPixelCount = 100000; // Fails quitlly if hardware occlusion is not supported - every object is visable
+
                 return true;
         }
-}
-#else // GTP_VISIBILITY_MODIFIED_OGRE
+
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
 //------------------------------------------------------------------
-void D3D9HardwareOcclusionQuery::beginOcclusionQuery() 
-{ 
-        if( m_bHWOcclusionSupport )             // Make it fail silently if hardware occlusion isn't supported
+        bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, 
+                                                                                                             const HW_OCCLUSIONQUERY flag ) 
         {
-                m_pD3DQuery->Issue(D3DISSUE_BEGIN); 
+                HRESULT hr = S_OK;
+                DWORD queryFlag = (flag == HWOCCLUSIONQUERY_FLUSH) ? D3DGETDATA_FLUSH : 0;
+
+                if (mHasOcclusionSupport)       // In case hardware occlusion isn't supported
+                {       
+                        do
+                        {
+                                hr = mpQuery->GetData(NumOfFragments, sizeof(NumOfFragments), queryFlag);
+                }
+                        while(waitForResult && (hr == S_FALSE));
+                
+                        mPixelCount = *NumOfFragments;
+                }
+                else
+                {
+                        mPixelCount = 100000; // every object is visible
+                }
+        
+                return hr == S_OK;
         }
-}
-//------------------------------------------------------------------
-void D3D9HardwareOcclusionQuery::endOcclusionQuery() 
-{ 
-        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
-        {
-                m_pD3DQuery->Issue(D3DISSUE_END); 
-        }
-}
-//------------------------------------------------------------------
-bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult ) 
-{
-        return pullOcclusionQuery(NumOfFragments, waitForResult, HWOCCLUSIONQUERY_FLUSH);
-}
-
-//------------------------------------------------------------------
-bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, 
-                                                                                                     const HW_OCCLUSIONQUERY flag  ) 
-{
-        DWORD queryFlag = flag == HWOCCLUSIONQUERY_FLUSH ? D3DGETDATA_FLUSH : 0;
-        // TO DO: USE lockOpts= D3D9Mappings::get(options); instead of RS_OCCLUSIONQUERY enum
-
-        return pullOcclusionQuery(NumOfFragments, waitForResult, queryFlag);
-}
-
-//------------------------------------------------------------------
-bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, 
-                                                                                                     const DWORD queryFlag ) 
-{
-        HRESULT hr = S_OK;
-
-        if( m_bHWOcclusionSupport )     // In case hardware occlusion isn't supported
-        {       
-                do
-                {
-                        hr = m_pD3DQuery->GetData( NumOfFragments, sizeof( NumOfFragments ), queryFlag );
-                }
-                while(waitForResult && (hr == S_FALSE));
-                
-                m_uintPixelCount = *NumOfFragments; 
-        }
-        else
-        {
-                m_uintPixelCount = 100000; // every object is visible
-        }
-        
-        return hr == S_OK;
-}
 
 
 #endif // GTP_VISIBILITY_MODIFIED_OGRE
 
-} // namespace OGre
+
+}

trunk/VUT/work/ogre_changes/RenderSystems/GL/include/OgreGLHardwareOcclusionQuery.h

@@ -88 +88 @@
         void beginOcclusionQuery();
         void endOcclusionQuery();
-
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-        bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult,
-                                                         const HW_OCCLUSIONQUERY flag  ); 
-        bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult );
-#else
-        bool pullOcclusionQuery( unsigned int* NumOfFragments );
         bool pullOcclusionQuery( unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag  ); 
-#endif // GTP_VISIBILITY_MODIFIED_OGRE
-
-        unsigned int getLastQuerysPixelcount() { return m_uintPixelCount; }
+        unsigned int getLastQuerysPixelcount() { return mPixelCount; }
 
         // This functions are optional, it's a simple filter that simply skipps some hardware occlusion tests on visable objects only
@@ -115 +106 @@
           */
 
-        void setSkipRate( int skip ) { m_Skip = skip; }         // Using 2 only 50 % of the tests are actully made and 3 results in only 33% of the tests. So on.
-        int      getSkipRate() { return m_Skip; } 
+        void setSkipRate( int skip ) { mSkipInterval = skip; }          // Using 2 only 50 % of the tests are actully made and 3 results in only 33% of the tests. So on.
+        int      getSkipRate() { return mSkipInterval; } 
 
-
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+        bool pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, const HW_OCCLUSIONQUERY flag = HWOCCLUSIONQUERY_FLUSH ); 
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
 //----------------------------------------------------------------------
 // Protected members
@@ -124 +117 @@
 protected:
 
-        unsigned int    m_uintPixelCount;
-        unsigned int    m_uintQuery[1];
+        unsigned int    mPixelCount;
+        GLuint                  mQueryID;
         bool                    m_bOcclusionQuery;
-        int                             m_SkipCounter;          // m_SkipConter =  m_SkipConter % m_Skip; if ( m_SkipConter == 0 && m_uintPixelCount !=0 ) TestHWOcclusion else just return 
-        static int              m_Skip;                         // This is shared by all instancies
-        bool                    m_bHWOcclusionSupport;
+        int                             mSkipCounter;
+        int                             mSkipInterval;
+        bool                    mHasOcclusionSupport;
 };
-
 
 }

trunk/VUT/work/ogre_changes/RenderSystems/GL/include/OgreGLPrerequisites.h

@@ -70 +70 @@
 extern GL_SecondaryColorPointerEXT_Func glSecondaryColorPointerEXT_ptr;
 
+// Pointer to glSecondaryColor3fEXT function
+typedef void (APIENTRY *GL_SecondaryColor3fEXT_Func)(GLfloat, GLfloat, GLfloat);
+extern GL_SecondaryColor3fEXT_Func glSecondaryColor3fEXT_ptr;
+
 // Pointer to glGenBuffersARB function
 typedef void (APIENTRY *GL_GenBuffersARB_Func)(GLsizei, GLuint*);
@@ -208 +212 @@
 extern GL_GetOcclusionQueryuivNV_Func glGetOcclusionQueryuivNV_ptr;
 
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-// Pointer to glGenQueriesARB function
-typedef void (APIENTRY *GL_GenQueriesARB_Func) (GLsizei n, GLuint *ids);
-extern GL_GenQueriesARB_Func glGenQueriesARB_ptr;
-
-// Pointer to glDeleteQueriesARB function
-typedef void (APIENTRY *GL_DeleteQueriesARB_Func) (GLsizei n, const GLuint *ids);
-extern GL_DeleteQueriesARB_Func glDeleteQueriesARB_ptr;
-
-// Pointer to glIsQueryARB function
-typedef GLboolean (APIENTRY *GL_IsQueryARB_Func) (GLuint id);
-extern GL_IsQueryARB_Func glIsQueryARB_ptr;
-
-// Pointer to glBeginQueryARB function
-typedef void (APIENTRY *GL_BeginQueryARB_Func) (GLenum target, GLuint id);
-extern GL_BeginQueryARB_Func glBeginQueryARB_ptr;
-
-// Pointer to glEndQueryARB function
-typedef void (APIENTRY *GL_EndQueryARB_Func) (GLenum target);
-extern GL_EndQueryARB_Func glEndQueryARB_ptr;
-
-// Pointer to glGetQueryivARB function
-typedef void (APIENTRY *GL_GetQueryivARB_Func) (GLuint id, GLenum pname, GLint *params);
-extern GL_GetQueryivARB_Func glGetQueryivARB_ptr;
-
-// Pointer to glGetQueryObjectivARB function
-typedef void (APIENTRY *GL_GetQueryObjectivARB_Func) (GLuint id, GLenum pname, GLint *params);
-extern GL_GetQueryObjectivARB_Func glGetQueryObjectivARB_ptr;
-
-// Pointer to glGetQueryObjectuivARB function
-typedef void (APIENTRY *GL_GetQueryObjectuivARB_Func) (GLuint id, GLenum pname, GLuint *params);
-extern GL_GetQueryObjectuivARB_Func glGetQueryObjectuivARB_ptr;
-
-#endif // GTP_VISIBILITY_MODIFIED_OGRE
-
 extern PFNGLCOMPRESSEDTEXIMAGE1DARBPROC glCompressedTexImage1DARB_ptr;
 extern PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB_ptr;
@@ -253 +222 @@
 };
 
+// Pointer to glGenQueriesARB function
+typedef void (APIENTRY *GL_GenQueriesARB_Func) (GLuint n, GLuint *ids);
+extern GL_GenQueriesARB_Func glGenQueriesARB_ptr;
+
+// Pointer to glDeleteQueriesARB function
+typedef void (APIENTRY *GL_DeleteQueriesARB_Func) (GLuint n, const GLuint *ids);
+extern GL_DeleteQueriesARB_Func glDeleteQueriesARB_ptr;
+
+// Pointer to glBeginQueryARB function
+typedef void (APIENTRY *GL_BeginQueryARB_Func) (GLenum target, GLuint id);
+extern GL_BeginQueryARB_Func glBeginQueryARB_ptr;
+
+// Pointer to glEndQueryARB function
+typedef void (APIENTRY *GL_EndQueryARB_Func) (GLenum target);
+extern GL_EndQueryARB_Func glEndQueryARB_ptr;
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+// Pointer to glGetQueryivARB function
+typedef void (APIENTRY *GL_GetQueryivARB_Func) (GLuint id, GLenum pname, GLint *params);
+extern GL_GetQueryivARB_Func glGetQueryivARB_ptr;
+
+// Pointer to glGetQueryObjectivARB function
+typedef void (APIENTRY *GL_GetQueryObjectivARB_Func) (GLuint id, GLenum pname, GLint *params);
+extern GL_GetQueryObjectivARB_Func glGetQueryObjectivARB_ptr;
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
+// Pointer to glGetQueryObjectuivARB function
+typedef void (APIENTRY *GL_GetQueryObjectuivARB_Func) (GLuint id, GLenum pname, GLuint *params);
+extern GL_GetQueryObjectuivARB_Func glGetQueryObjectuivARB_ptr;
 
 

trunk/VUT/work/ogre_changes/RenderSystems/GL/src/OgreGLHardwareOcclusionQuery.cpp

@@ -27 +27 @@
 #include "OgreException.h"
 
+
 namespace Ogre {
-
-int GLHardwareOcclusionQuery::m_Skip = 0;
 
 /**
@@ -36 +35 @@
   *
   * @author Lee Sandberg email: lee@abcmedia.se
+  *
+  * Updated on 12/7/2004 by Chris McGuirk
+  * - Implemented ARB_occlusion_query
   */
 
-/* Functions used;
-
-glGenOcclusionQueriesNV_ptr( 1, m_uintQuery );
-glDeleteOcclusionQueriesNV_ptr( 1, &m_uintQuery[0] );
-glBeginOcclusionQueryNV_ptr( m_uintQuery[0] );
-glEndOcclusionQueryNV_ptr();
-glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments );
-
-  TO DO: change this to the new ARB functions...
-
-*/
-
-#ifndef GTP_VISIBILITY_MODIFIED_OGRE
 /**
   * Default object constructor
@@ -57 +46 @@
 GLHardwareOcclusionQuery::GLHardwareOcclusionQuery() 
 { 
-        m_uintPixelCount = 0; 
-        m_SkipCounter = 0;
+        mPixelCount = 0; 
+        mSkipCounter = 0;
+        mSkipInterval = 0;
 
         // Check for hardware occlusion support
-    if( glDeleteOcclusionQueriesNV_ptr != 0 )   // This is a hack to see if hw occlusion is supported. pointer is 0 if it's not supported.
+        // This is a hack to see if hw occlusion is supported. pointer is 0 if it's not supported.
+        //if (glGenQueriesARB_ptr != 0)
+        if (glGenOcclusionQueriesNV_ptr != 0)
     {
-                m_bHWOcclusionSupport = true;
+                mHasOcclusionSupport = true;
         }
         else
         {
-                m_bHWOcclusionSupport = false;
+                mHasOcclusionSupport = false;
         }
 
-        if( m_bHWOcclusionSupport )
+        if(mHasOcclusionSupport)
         {
-                glGenOcclusionQueriesNV_ptr( 1, m_uintQuery );  
+                //glGenQueriesARB_ptr(1, &mQueryID );   
+                glGenOcclusionQueriesNV_ptr(1, &mQueryID);
         }
 }
-
 
 /**
@@ -82 +74 @@
 GLHardwareOcclusionQuery::~GLHardwareOcclusionQuery() 
 { 
-        if( m_bHWOcclusionSupport )
+        if( mHasOcclusionSupport )
         {
-                glDeleteOcclusionQueriesNV_ptr( 1, &m_uintQuery[0] );  
+                //glDeleteQueriesARB_ptr(1, &mQueryID);  
+                glDeleteOcclusionQueriesNV_ptr(1, &mQueryID);  
         }       
 }
@@ -93 +86 @@
 void GLHardwareOcclusionQuery::beginOcclusionQuery() 
 { 
-        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
+        // Make it fail silently if hardware occlusion isn't supported
+        if(mHasOcclusionSupport)
         {
-                if  ( m_SkipCounter ==  m_Skip ) { m_SkipCounter = 0; };                // Counter starts at 0 again at m_Skip 
-                if ( m_SkipCounter == 0 && m_uintPixelCount != 0 ) // New or none visable objects must allways be tested but visable objects can be skiped
+                // Counter starts at 0 again at mSkipInterval 
+#ifndef GTP_VISIBILITY_MODIFIED_OGRE
+                if(mSkipCounter == mSkipInterval) 
+#else
+                if (mSkipCounter >= mSkipInterval)  // otherwise no query ever issued if mSkipInterval = 0 !
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
+        {
+                        mSkipCounter = 0; 
+                }
+
+                if (mSkipCounter == 0)
                 {
-                        glBeginOcclusionQueryNV_ptr( m_uintQuery[0] );
+                        //glBeginQueryARB_ptr(GL_SAMPLES_PASSED_ARB, mQueryID);
+                        glBeginOcclusionQueryNV_ptr(mQueryID);
                 }
         }
@@ -105 +109 @@
 void GLHardwareOcclusionQuery::endOcclusionQuery() 
 { 
-        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
+        // Make it fail silently if hardware occlusion isn't supported
+        if(mHasOcclusionSupport)
         {
-                if( m_SkipCounter == 0 && m_uintPixelCount != 0 ) // New or none visable objects must allways be tested but visable objects can be skiped
+                if( mSkipCounter == 0)
                 {
+                        //glEndQueryARB_ptr(GL_SAMPLES_PASSED_ARB);
                         glEndOcclusionQueryNV_ptr();
                 }
-                m_SkipCounter++;
-        }
-}
 
-bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int * NumOfFragments) 
-{
-        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
-        {
-                glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments );
+                mSkipCounter++;
         } 
-        else
-        {
-                *NumOfFragments = 100000;               // Fails quitlly -> every object tested is visable.
-        }
-
-        m_uintPixelCount = *NumOfFragments; 
-
-        return true;
 }
 
 //------------------------------------------------------------------
-// OpenGL dosn't use the flag, but to fulfil the abstract interface we need to include this function.
-// Using this function in OpenGL mode simple works the same way as calling the other function without the flag parameter,
-// but in DX9 it works differentlly, see notes in the DX9 implementation.
-//--
+// OpenGL dosn't use the flag paramter.
+//------------------------------------------------------------------
 bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag  ) 
 {
-        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
+        if( mHasOcclusionSupport )      // Make it fail silently if hardware occlusion isn't supported
         {
-                glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments );
+                //glGetQueryObjectuivARB_ptr(mQueryID, GL_QUERY_RESULT_ARB, NumOfFragments);
+glGetOcclusionQueryuivNV_ptr(mQueryID, GL_PIXEL_COUNT_NV, NumOfFragments);
         }
         else
@@ -147 +137 @@
         }
 
-        m_uintPixelCount = *NumOfFragments; 
+        mPixelCount = *NumOfFragments; 
         
         return true;
 }
 
-#else // GTP_VISIBILITY_MODIFIED_OGRE
-
-//------------------------------------------------------------------
-GLHardwareOcclusionQuery::GLHardwareOcclusionQuery() 
-{ 
-        m_uintPixelCount = 0; 
-        m_SkipCounter = 0;
-
-        // Check for hardware occlusion support
-    if ( glDeleteOcclusionQueriesNV_ptr != 0 )  // This is a hack to see if hw occlusion is supported. pointer is 0 if it's not supported.
-        //if ( glDeleteQueriesARB_ptr != 0 )
-        {
-                m_bHWOcclusionSupport = true;
-        }
-        else
-        {
-                m_bHWOcclusionSupport = false;
-        }
-
-        if ( m_bHWOcclusionSupport )
-        {
-                glGenOcclusionQueriesNV_ptr( 1, m_uintQuery );  
-                //glGenQueriesARB_ptr(1, m_uintQuery);
-        }
-}
-
-
-//------------------------------------------------------------------
-GLHardwareOcclusionQuery::~GLHardwareOcclusionQuery() 
-{ 
-        if ( m_bHWOcclusionSupport )
-        {
-                glDeleteOcclusionQueriesNV_ptr( 1, &m_uintQuery[0] );  
-                //glDeleteQueriesARB_ptr(1, &m_uintQuery[0]);
-        }       
-}
-
-//------------------------------------------------------------------
-void GLHardwareOcclusionQuery::beginOcclusionQuery() 
-{ 
-        if ( m_bHWOcclusionSupport )    // Make it fail silently if hardware occlusion isn't supported
-        {
-                // do the actual occlusion query for this node
-                glBeginOcclusionQueryNV_ptr( m_uintQuery[0] );
-                //glBeginQueryARB_ptr(GL_SAMPLES_PASSED_ARB, m_uintQuery[0]);
-        }
-}
-        
-void GLHardwareOcclusionQuery::endOcclusionQuery() 
-{ 
-        if ( m_bHWOcclusionSupport )    // Make it fail silently if hardware occlusion isn't supported
-        {
-                glEndOcclusionQueryNV_ptr();
-                //glEndQueryARB_ptr(GL_SAMPLES_PASSED_ARB);
-        }
-}
-//------------------------------------------------------------------
-bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int * NumOfFragments, const bool waitForResult) 
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+        //------------------------------------------------------------------
+        bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int * NumOfFragments, const bool waitForResult, const HW_OCCLUSIONQUERY flag) 
 {
         unsigned int isAvailable = GL_TRUE;
-        //int isAvailable = GL_TRUE;
 
-        if( m_bHWOcclusionSupport )     
+                if (mHasOcclusionSupport)       
         {
                 if (!waitForResult)
                 {
-                        glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_AVAILABLE_NV, &isAvailable );
-                        //glGetQueryivARB_ptr(m_uintQuery[0], GL_QUERY_RESULT_AVAILABLE_ARB, &isAvailable);
+                        // use nv queries rather that arb because they are faster (no flush)
+                                //glGetQueryivARB_ptr(mQueryID, GL_QUERY_RESULT_AVAILABLE_ARB, &isAvailable);
+                                glGetOcclusionQueryuivNV_ptr(mQueryID, GL_PIXEL_COUNT_AVAILABLE_NV, &isAvailable);
                 }
 
                 if (isAvailable == GL_TRUE)
                 {
-                        glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments );
-                        //glGetQueryObjectuivARB_ptr( m_uintQuery[0], GL_QUERY_RESULT_ARB, NumOfFragments);
+                                //glGetQueryObjectuivARB_ptr(mQueryID, GL_QUERY_RESULT_ARB, NumOfFragments);
+                                glGetOcclusionQueryuivNV_ptr(mQueryID, GL_PIXEL_COUNT_NV, NumOfFragments);
                 }
         } 
@@ -234 +169 @@
         }
 
-        m_uintPixelCount = *NumOfFragments; 
+                mPixelCount = *NumOfFragments; 
 
         return isAvailable == GL_TRUE;  
 }
 
-//------------------------------------------------------------------
-bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, const HW_OCCLUSIONQUERY flag  ) 
-{
-        return pullOcclusionQuery(NumOfFragments, waitForResult);
+#endif // GTP_VIBILITY_MODIFIED_OGRE
 }
-
-#endif // GTP_VISIBILITY_MODIFIED_OGRE
-
-
-}
-
-

trunk/VUT/work/ogre_changes/RenderSystems/GL/src/OgreGLRenderSystem.cpp

@@ -58 +58 @@
 GL_ClientActiveTextureARB_Func glClientActiveTextureARB_ptr;
 GL_SecondaryColorPointerEXT_Func glSecondaryColorPointerEXT_ptr;
+GL_SecondaryColor3fEXT_Func glSecondaryColor3fEXT_ptr;
 GL_GenBuffersARB_Func glGenBuffersARB_ptr;
 GL_BindBufferARB_Func glBindBufferARB_ptr;
@@ -97 +98 @@
 GL_EndOcclusionQueryNV_Func glEndOcclusionQueryNV_ptr;
 GL_GetOcclusionQueryuivNV_Func glGetOcclusionQueryuivNV_ptr;
- 
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
 GL_GenQueriesARB_Func glGenQueriesARB_ptr;
 GL_DeleteQueriesARB_Func glDeleteQueriesARB_ptr;
-GL_IsQueryARB_Func glIsQueryARB_ptr;
 GL_BeginQueryARB_Func glBeginQueryARB_ptr;
 GL_EndQueryARB_Func glEndQueryARB_ptr;
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
 GL_GetQueryivARB_Func glGetQueryivARB_ptr;
 GL_GetQueryObjectivARB_Func glGetQueryObjectivARB_ptr;
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
 GL_GetQueryObjectuivARB_Func glGetQueryObjectuivARB_ptr;
-#endif // GTP_VISIBILITY_MODIFIED_OGRE
 
 namespace Ogre {
@@ -191 +190 @@
         glClientActiveTextureARB_ptr = 0;
         glSecondaryColorPointerEXT_ptr = 0;
+        glSecondaryColor3fEXT_ptr = 0;
         glGenBuffersARB_ptr = 0;
         glBindBufferARB_ptr = 0;
@@ -220 +220 @@
         glEndOcclusionQueryNV_ptr = 0;
         glGetOcclusionQueryuivNV_ptr = 0;
-
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
                 glGenQueriesARB_ptr = 0;
                 glDeleteQueriesARB_ptr = 0;
-                glIsQueryARB_ptr = 0;
                 glBeginQueryARB_ptr = 0;
                 glEndQueryARB_ptr = 0;
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
                 glGetQueryivARB_ptr = 0;
                 glGetQueryObjectivARB_ptr = 0;
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
                 glGetQueryObjectuivARB_ptr = 0;
-#endif // GTP_VISIBILITY_MODIFIED_OGRE
 
         mCurrentLights = 0;
@@ -543 +541 @@
         glSecondaryColorPointerEXT_ptr = 
             (GL_SecondaryColorPointerEXT_Func)mGLSupport->getProcAddress("glSecondaryColorPointerEXT");
+        glSecondaryColor3fEXT_ptr = 
+            (GL_SecondaryColor3fEXT_Func)mGLSupport->getProcAddress("glSecondaryColor3fEXT");
         glGenBuffersARB_ptr = 
             (GL_GenBuffersARB_Func)mGLSupport->getProcAddress("glGenBuffersARB");
@@ -622 +622 @@
         glGetOcclusionQueryuivNV_ptr =
             (GL_GetOcclusionQueryuivNV_Func)mGLSupport->getProcAddress("glGetOcclusionQueryuivNV");
-                glGetQueryObjectivARB_ptr = 
-                         (GL_GetQueryObjectivARB_Func)mGLSupport->getProcAddress("glGetQueryObjectivARB");
-                glGetQueryObjectuivARB_ptr = 
-                         (GL_GetQueryObjectuivARB_Func)mGLSupport->getProcAddress("glGetQueryObjectuivARB");
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+
                 glGenQueriesARB_ptr = 
                          (GL_GenQueriesARB_Func)mGLSupport->getProcAddress("glGenQueriesARB");
                 glDeleteQueriesARB_ptr =
                         (GL_DeleteQueriesARB_Func)mGLSupport->getProcAddress("glDeleteQueriesARB");
-                glIsQueryARB_ptr =
-                        (GL_IsQueryARB_Func)mGLSupport->getProcAddress("glIsQueryARB");
                 glBeginQueryARB_ptr =
                          (GL_BeginQueryARB_Func)mGLSupport->getProcAddress("glBeginQueryARB");
                 glEndQueryARB_ptr =
                          (GL_EndQueryARB_Func)mGLSupport->getProcAddress("glEndQueryARB");
+        #ifdef GTP_VISIBILITY_MODIFIED_OGRE
                 glGetQueryivARB_ptr = 
                         (GL_GetQueryivARB_Func)mGLSupport->getProcAddress("glGetQueryivARB");
                 glGetQueryObjectivARB_ptr = 
                          (GL_GetQueryObjectivARB_Func)mGLSupport->getProcAddress("glGetQueryObjectivARB");
+        #endif // GTP_VISIBILITY_MODIFIED_OGRE
                 glGetQueryObjectuivARB_ptr = 
                          (GL_GetQueryObjectuivARB_Func)mGLSupport->getProcAddress("glGetQueryObjectuivARB");
-#endif // GTP_VISIBILITY_MODIFIED_OGRE
 
         mCapabilities->log(LogManager::getSingleton().getDefaultLog());
@@ -1857 +1852 @@
                     cv1[2] = bm.colourArg1.b;
                     cv1[3] = bm.colourArg1.a;
+                        mManualBlendColours[stage][0] = bm.colourArg1;
+
 
                     cv2[0] = bm.colourArg2.r;
@@ -1862 +1859 @@
                     cv2[2] = bm.colourArg2.b;
                     cv2[3] = bm.colourArg2.a;
+                        mManualBlendColours[stage][1] = bm.colourArg2;
         }
 
                 if (bm.blendType == LBT_ALPHA)
         {
-                    cv1[0] = 0;
-                    cv1[1] = 0;
-                    cv1[2] = 0;
+                    cv1[0] = mManualBlendColours[stage][0].r;
+                    cv1[1] = mManualBlendColours[stage][0].g;
+                    cv1[2] = mManualBlendColours[stage][0].b;
                     cv1[3] = bm.alphaArg1;
 
-                    cv2[0] = 0;
-                    cv2[1] = 0;
-                    cv2[2] = 0;
+                    cv2[0] = mManualBlendColours[stage][1].r;
+                    cv2[1] = mManualBlendColours[stage][1].g;
+                    cv2[2] = mManualBlendColours[stage][1].b;
                     cv2[3] = bm.alphaArg2;
         }
@@ -2249 +2247 @@
         }
         glColor4f(1,1,1,1);
+        glSecondaryColor3fEXT_ptr(0.0f, 0.0f, 0.0f);
 
         // UnGuard
@@ -2537 +2536 @@
         glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
         glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);        
+        glEnable(GL_COLOR_SUM);
+
         // Check for FSAA
         // Enable the extension if it was enabled by the GLSupport

trunk/VUT/work/ogre_changes/Samples/Common/include/ExampleFrameListener.h

@@ -300 +300 @@
                 return true;
         }
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-        virtual void moveCamera() // made virtual by matt (16.05.05)
-#else
+
         void moveCamera()
-#endif // GTP_VISIBILTIY_MODIFIED_OGRE
         {