Changeset 97 for trunk/VUT/work/ogre_changes

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

Files:

• Direct3D9/src/OgreD3D9HardwareOcclusionQuery.cpp (modified) (6 diffs)
• GL/include/OgreGLPrerequisites.h (added)
• GL/src/OgreGLHardwareOcclusionQuery.cpp (modified) (4 diffs)
• GL/src/OgreGLRenderSystem.cpp (added)

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

@@ -71 +71 @@
 }
 
+#ifndef GTP_VISIBILITY_MODIFIED_OGRE
 //------------------------------------------------------------------
 // Occlusion query functions (see base class documentation for this)
@@ -78 +79 @@
         if( m_bHWOcclusionSupport )             // Make it fail silently if hardware occlusion isn't supported
         {
-                m_pD3DQuery->Issue(D3DISSUE_BEGIN); 
-        }
-}
-//------------------------------------------------------------------
+                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
+                {
+                        m_pD3DQuery->Issue(D3DISSUE_BEGIN); 
+                }
+        }
+}
+        
 void D3D9HardwareOcclusionQuery::endOcclusionQuery() 
 { 
         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported
         {
-                m_pD3DQuery->Issue(D3DISSUE_END); 
+                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 
         }
 }
@@ -95 +105 @@
 // 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, const bool waitForResult ) 
-{
-        return pullOcclusionQuery(NumOfFragments, waitForResult, HWOCCLUSIONQUERY_FLUSH);
+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;
+        }
 }
 
@@ -106 +136 @@
 // 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, const HW_OCCLUSIONQUERY flag  ) 
+{
+        HRESULT hr;
+
+        // TO DO: USE lockOpts= D3D9Mappings::get(options); instead of RS_OCCLUSIONQUERY enum
+
+        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; 
+                        }
+                        else 
+                        { 
+                                m_uintPixelCount = *NumOfFragments; 
+                                return true; 
+                        }
+        }
+        else 
+        {
+                m_uintPixelCount = 100000; // Fails quitlly if hardware occlusion is not supported - every object is visable
+                return true;
+        }
+}
+#else // GTP_VISIBILITY_MODIFIED_OGRE
+//------------------------------------------------------------------
+void D3D9HardwareOcclusionQuery::beginOcclusionQuery() 
+{ 
+        if( m_bHWOcclusionSupport )             // Make it fail silently if hardware occlusion isn't supported
+        {
+                m_pD3DQuery->Issue(D3DISSUE_BEGIN); 
+        }
+}
+//------------------------------------------------------------------
+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  ) 
@@ -114 +206 @@
         return pullOcclusionQuery(NumOfFragments, waitForResult, queryFlag);
 }
+
 //------------------------------------------------------------------
 bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, 
@@ -137 +230 @@
         return hr == S_OK;
 }
+
+
+#endif // GTP_VISIBILITY_MODIFIED_OGRE
+
 } // namespace OGre

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
+
+
+}
+
+