Ignore:
Timestamp:
05/30/05 03:20:23 (19 years ago)
Author:
mattausch
Message:

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

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r99 r115  
    2727#include "OgreException.h" 
    2828 
     29 
    2930namespace Ogre { 
    30  
    31 int GLHardwareOcclusionQuery::m_Skip = 0; 
    3231 
    3332/** 
    … …  
    3635  * 
    3736  * @author Lee Sandberg email: lee@abcmedia.se 
     37  * 
     38  * Updated on 12/7/2004 by Chris McGuirk 
     39  * - Implemented ARB_occlusion_query 
    3840  */ 
    3941 
    40 /* Functions used; 
    41  
    42 glGenOcclusionQueriesNV_ptr( 1, m_uintQuery ); 
    43 glDeleteOcclusionQueriesNV_ptr( 1, &m_uintQuery[0] ); 
    44 glBeginOcclusionQueryNV_ptr( m_uintQuery[0] ); 
    45 glEndOcclusionQueryNV_ptr(); 
    46 glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments ); 
    47  
    48   TO DO: change this to the new ARB functions... 
    49  
    50 */ 
    51  
    52 #ifndef GTP_VISIBILITY_MODIFIED_OGRE 
    5342/** 
    5443  * Default object constructor 
    … …  
    5746GLHardwareOcclusionQuery::GLHardwareOcclusionQuery()  
    5847{  
    59         m_uintPixelCount = 0;  
    60         m_SkipCounter = 0; 
     48        mPixelCount = 0;  
     49        mSkipCounter = 0; 
     50        mSkipInterval = 0; 
    6151 
    6252        // Check for hardware occlusion support 
    63     if( glDeleteOcclusionQueriesNV_ptr != 0 )   // This is a hack to see if hw occlusion is supported. pointer is 0 if it's not supported. 
     53        // This is a hack to see if hw occlusion is supported. pointer is 0 if it's not supported. 
     54        //if (glGenQueriesARB_ptr != 0) 
     55        if (glGenOcclusionQueriesNV_ptr != 0) 
    6456    { 
    65                 m_bHWOcclusionSupport = true; 
     57                mHasOcclusionSupport = true; 
    6658        } 
    6759        else 
    6860        { 
    69                 m_bHWOcclusionSupport = false; 
     61                mHasOcclusionSupport = false; 
    7062        } 
    7163 
    72         if( m_bHWOcclusionSupport ) 
     64        if(mHasOcclusionSupport) 
    7365        { 
    74                 glGenOcclusionQueriesNV_ptr( 1, m_uintQuery );   
     66                //glGenQueriesARB_ptr(1, &mQueryID );    
     67                glGenOcclusionQueriesNV_ptr(1, &mQueryID); 
    7568        } 
    7669} 
    77  
    7870 
    7971/** 
    … …  
    8274GLHardwareOcclusionQuery::~GLHardwareOcclusionQuery()  
    8375{  
    84         if( m_bHWOcclusionSupport ) 
     76        if( mHasOcclusionSupport ) 
    8577        { 
    86                 glDeleteOcclusionQueriesNV_ptr( 1, &m_uintQuery[0] );   
     78                //glDeleteQueriesARB_ptr(1, &mQueryID);   
     79                glDeleteOcclusionQueriesNV_ptr(1, &mQueryID);   
    8780        }        
    8881} 
    … …  
    9386void GLHardwareOcclusionQuery::beginOcclusionQuery()  
    9487{  
    95         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported 
     88        // Make it fail silently if hardware occlusion isn't supported 
     89        if(mHasOcclusionSupport) 
    9690        { 
    97                 if  ( m_SkipCounter ==  m_Skip ) { m_SkipCounter = 0; };                // Counter starts at 0 again at m_Skip  
    98                 if ( m_SkipCounter == 0 && m_uintPixelCount != 0 ) // New or none visable objects must allways be tested but visable objects can be skiped 
     91                // Counter starts at 0 again at mSkipInterval  
     92#ifndef GTP_VISIBILITY_MODIFIED_OGRE 
     93                if(mSkipCounter == mSkipInterval)  
     94#else 
     95                if (mSkipCounter >= mSkipInterval)  // otherwise no query ever issued if mSkipInterval = 0 ! 
     96#endif // GTP_VISIBILITY_MODIFIED_OGRE 
     97        { 
     98                        mSkipCounter = 0;  
     99                } 
     100 
     101                if (mSkipCounter == 0) 
    99102                { 
    100                         glBeginOcclusionQueryNV_ptr( m_uintQuery[0] ); 
     103                        //glBeginQueryARB_ptr(GL_SAMPLES_PASSED_ARB, mQueryID); 
     104                        glBeginOcclusionQueryNV_ptr(mQueryID); 
    101105                } 
    102106        } 
    … …  
    105109void GLHardwareOcclusionQuery::endOcclusionQuery()  
    106110{  
    107         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported 
     111        // Make it fail silently if hardware occlusion isn't supported 
     112        if(mHasOcclusionSupport) 
    108113        { 
    109                 if( m_SkipCounter == 0 && m_uintPixelCount != 0 ) // New or none visable objects must allways be tested but visable objects can be skiped 
     114                if( mSkipCounter == 0) 
    110115                { 
     116                        //glEndQueryARB_ptr(GL_SAMPLES_PASSED_ARB); 
    111117                        glEndOcclusionQueryNV_ptr(); 
    112118                } 
    113                 m_SkipCounter++; 
    114         } 
    115 } 
    116119 
    117 bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int * NumOfFragments)  
    118 { 
    119         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported 
    120         { 
    121                 glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments ); 
     120                mSkipCounter++; 
    122121        }  
    123         else 
    124         { 
    125                 *NumOfFragments = 100000;               // Fails quitlly -> every object tested is visable. 
    126         } 
    127  
    128         m_uintPixelCount = *NumOfFragments;  
    129  
    130         return true; 
    131122} 
    132123 
    133124//------------------------------------------------------------------ 
    134 // OpenGL dosn't use the flag, but to fulfil the abstract interface we need to include this function. 
    135 // Using this function in OpenGL mode simple works the same way as calling the other function without the flag parameter, 
    136 // but in DX9 it works differentlly, see notes in the DX9 implementation. 
    137 //-- 
     125// OpenGL dosn't use the flag paramter. 
     126//------------------------------------------------------------------ 
    138127bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag  )  
    139128{ 
    140         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported 
     129        if( mHasOcclusionSupport )      // Make it fail silently if hardware occlusion isn't supported 
    141130        { 
    142                 glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments ); 
     131                //glGetQueryObjectuivARB_ptr(mQueryID, GL_QUERY_RESULT_ARB, NumOfFragments); 
     132glGetOcclusionQueryuivNV_ptr(mQueryID, GL_PIXEL_COUNT_NV, NumOfFragments); 
    143133        } 
    144134        else 
    … …  
    147137        } 
    148138 
    149         m_uintPixelCount = *NumOfFragments;  
     139        mPixelCount = *NumOfFragments;  
    150140         
    151141        return true; 
    152142} 
    153143 
    154 #else // GTP_VISIBILITY_MODIFIED_OGRE 
    155  
    156 //------------------------------------------------------------------ 
    157 GLHardwareOcclusionQuery::GLHardwareOcclusionQuery()  
    158 {  
    159         m_uintPixelCount = 0;  
    160         m_SkipCounter = 0; 
    161  
    162         // Check for hardware occlusion support 
    163     if ( glDeleteOcclusionQueriesNV_ptr != 0 )  // This is a hack to see if hw occlusion is supported. pointer is 0 if it's not supported. 
    164         //if ( glDeleteQueriesARB_ptr != 0 ) 
    165         { 
    166                 m_bHWOcclusionSupport = true; 
    167         } 
    168         else 
    169         { 
    170                 m_bHWOcclusionSupport = false; 
    171         } 
    172  
    173         if ( m_bHWOcclusionSupport ) 
    174         { 
    175                 glGenOcclusionQueriesNV_ptr( 1, m_uintQuery );   
    176                 //glGenQueriesARB_ptr(1, m_uintQuery); 
    177         } 
    178 } 
    179  
    180  
    181 //------------------------------------------------------------------ 
    182 GLHardwareOcclusionQuery::~GLHardwareOcclusionQuery()  
    183 {  
    184         if ( m_bHWOcclusionSupport ) 
    185         { 
    186                 glDeleteOcclusionQueriesNV_ptr( 1, &m_uintQuery[0] );   
    187                 //glDeleteQueriesARB_ptr(1, &m_uintQuery[0]); 
    188         }        
    189 } 
    190  
    191 //------------------------------------------------------------------ 
    192 void GLHardwareOcclusionQuery::beginOcclusionQuery()  
    193 {  
    194         if ( m_bHWOcclusionSupport )    // Make it fail silently if hardware occlusion isn't supported 
    195         { 
    196                 // do the actual occlusion query for this node 
    197                 glBeginOcclusionQueryNV_ptr( m_uintQuery[0] ); 
    198                 //glBeginQueryARB_ptr(GL_SAMPLES_PASSED_ARB, m_uintQuery[0]); 
    199         } 
    200 } 
    201          
    202 void GLHardwareOcclusionQuery::endOcclusionQuery()  
    203 {  
    204         if ( m_bHWOcclusionSupport )    // Make it fail silently if hardware occlusion isn't supported 
    205         { 
    206                 glEndOcclusionQueryNV_ptr(); 
    207                 //glEndQueryARB_ptr(GL_SAMPLES_PASSED_ARB); 
    208         } 
    209 } 
    210 //------------------------------------------------------------------ 
    211 bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int * NumOfFragments, const bool waitForResult)  
     144#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     145        //------------------------------------------------------------------ 
     146        bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int * NumOfFragments, const bool waitForResult, const HW_OCCLUSIONQUERY flag)  
    212147{ 
    213148        unsigned int isAvailable = GL_TRUE; 
    214         //int isAvailable = GL_TRUE; 
    215149 
    216         if( m_bHWOcclusionSupport )      
     150                if (mHasOcclusionSupport)        
    217151        { 
    218152                if (!waitForResult) 
    219153                { 
    220                         glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_AVAILABLE_NV, &isAvailable ); 
    221                         //glGetQueryivARB_ptr(m_uintQuery[0], GL_QUERY_RESULT_AVAILABLE_ARB, &isAvailable); 
     154                        // use nv queries rather that arb because they are faster (no flush) 
     155                                //glGetQueryivARB_ptr(mQueryID, GL_QUERY_RESULT_AVAILABLE_ARB, &isAvailable); 
     156                                glGetOcclusionQueryuivNV_ptr(mQueryID, GL_PIXEL_COUNT_AVAILABLE_NV, &isAvailable); 
    222157                } 
    223158 
    224159                if (isAvailable == GL_TRUE) 
    225160                { 
    226                         glGetOcclusionQueryuivNV_ptr( m_uintQuery[0], GL_PIXEL_COUNT_NV, NumOfFragments ); 
    227                         //glGetQueryObjectuivARB_ptr( m_uintQuery[0], GL_QUERY_RESULT_ARB, NumOfFragments); 
     161                                //glGetQueryObjectuivARB_ptr(mQueryID, GL_QUERY_RESULT_ARB, NumOfFragments); 
     162                                glGetOcclusionQueryuivNV_ptr(mQueryID, GL_PIXEL_COUNT_NV, NumOfFragments); 
    228163                } 
    229164        }  
    … …  
    234169        } 
    235170 
    236         m_uintPixelCount = *NumOfFragments;  
     171                mPixelCount = *NumOfFragments;  
    237172 
    238173        return isAvailable == GL_TRUE;   
    239174} 
    240175 
    241 //------------------------------------------------------------------ 
    242 bool GLHardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult, const HW_OCCLUSIONQUERY flag  )  
    243 { 
    244         return pullOcclusionQuery(NumOfFragments, waitForResult); 
     176#endif // GTP_VIBILITY_MODIFIED_OGRE 
    245177} 
    246  
    247 #endif // GTP_VISIBILITY_MODIFIED_OGRE 
    248  
    249  
    250 } 
    251  
    252  
Note: See TracChangeset for help on using the changeset viewer.