Changeset 97 for trunk/VUT/work/ogre_changes/RenderSystems/GL/src

Timestamp:

05/13/05 15:14:12 (19 years ago)

Author:

mattausch

Message:

ogre: changed from occlusion_query_nv to occlusion_query_arb (in ogre_changes)

Location:

trunk/VUT/work/ogre_changes/RenderSystems/GL/src

Files:

• OgreGLHardwareOcclusionQuery.cpp (modified) (4 diffs)
• OgreGLRenderSystem.cpp (added)

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

@@ -50 +50 @@
 */
 
-
+#ifndef GTP_VISIBILITY_MODIFIED_OGRE
 /**
   * Default object constructor
@@ -95 +95 @@
         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
         {
-                glBeginOcclusionQueryNV_ptr( m_uintQuery[0] );
+                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
+                {
+                        glBeginOcclusionQueryNV_ptr( m_uintQuery[0] );
+                }
         }
 }
@@ -103 +107 @@
         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
         {
-                glEndOcclusionQueryNV_ptr();
-        }
-}
-
-bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int * NumOfFragments, const bool waitForResult) 
-{
-        unsigned int isAvailable = GL_TRUE;
-
-        if( m_bHWOcclusionSupport )     
-        {
-                if(!waitForResult)
-                {
-                        glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_AVAILABLE_NV, &isAvailable );
-                }
-
-                if(isAvailable == GL_TRUE)
-                {
-                        glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments );
-                }
+                if( m_SkipCounter == 0 && m_uintPixelCount != 0 ) // New or none visable objects must allways be tested but visable objects can be skiped
+                {
+                        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 );
         } 
         else
         {
-                // In case hardware occlusion isn't supported, every object is set visible.
-                *NumOfFragments = 100000;               
+                *NumOfFragments = 100000;               // Fails quitlly -> every object tested is visable.
         }
 
         m_uintPixelCount = *NumOfFragments; 
 
-        return isAvailable == GL_TRUE;  
-}
-
-//------------------------------------------------------------------
-// OpenGL doesn't use the flag, but to implement the abstract interface we need to include this function.
+        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.
 //--
+bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag  ) 
+{
+        if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
+        {
+                glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments );
+        }
+        else
+        {
+                *NumOfFragments = 100000;               // Fails quitlly -> every object tested is visable.
+        }
+
+        m_uintPixelCount = *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) 
+{
+        //unsigned int isAvailable = GL_TRUE;
+        int isAvailable = GL_TRUE;
+
+        if( m_bHWOcclusionSupport )     
+        {
+                if(!waitForResult)
+                {
+                        //glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_AVAILABLE_NV, &isAvailable );
+                        glGetQueryivARB_ptr(m_uintQuery[0], GL_QUERY_RESULT_AVAILABLE_ARB, &isAvailable);
+                }
+
+                if(isAvailable == GL_TRUE)
+                {
+                        glGetQueryObjectuivARB_ptr( m_uintQuery[0], GL_QUERY_RESULT_ARB, NumOfFragments);
+                        //glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments );
+                }
+        } 
+        else
+        {
+                // In case hardware occlusion isn't supported, every object is set visible.
+                *NumOfFragments = 100000;               
+        }
+
+        m_uintPixelCount = *NumOfFragments; 
+
+        return isAvailable == GL_TRUE;  
+}
+
+//------------------------------------------------------------------
 bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, const HW_OCCLUSIONQUERY flag  ) 
 {
@@ -144 +245 @@
 }
 
-}
-
-
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
+
+
+}
+
+