Ignore:
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)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r97 r115  
    2929namespace Ogre { 
    3030 
    31 int D3D9HardwareOcclusionQuery::m_Skip = 0; 
    32  
    3331/** 
    3432  * This is a class that is the DirectX9 implementation of  
    … …  
    3634  * 
    3735  * @author Lee Sandberg 
     36        * 
     37        * Updated on 12/7/2004 by Chris McGuirk 
    3838  */ 
    3939 
    4040/** 
    4141  * Default object constructor 
    42   *  
    4342  */ 
    4443D3D9HardwareOcclusionQuery::D3D9HardwareOcclusionQuery( IDirect3DDevice9* pD3DDevice )  
    4544{  
    46         m_pD3DDevice = pD3DDevice; 
    47         m_uintPixelCount = 0;  
    48         m_SkipCounter = 0; 
    49         m_bHWOcclusionSupport = false; 
     45                mpDevice = pD3DDevice; 
     46                mPixelCount = 0;  
     47                mSkipCounter = 0; 
     48                mSkipInterval = 0; 
     49                mHasOcclusionSupport = false; 
    5050 
    51         HRESULT hr = m_pD3DDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, &m_pD3DQuery); 
     51                // create the occlusion query 
     52                HRESULT hr = mpDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, &mpQuery); 
     53 
    5254        if ( hr != D3D_OK )  
    5355        { 
    54                 //OGRE_EXCEPT(hr, "D3D9HardwareOcclusionQuery couldn't create hardware occlusion query object.",  
    55         //        "D3D9HardwareOcclusionQuery::D3D9HardwareOcclusionQuery"); 
    56                 m_bHWOcclusionSupport = false; 
     56                        mHasOcclusionSupport = false; 
    5757        } 
    5858        else  
    5959        { 
    60                 m_bHWOcclusionSupport = true; 
     60                        mHasOcclusionSupport = true; 
    6161        } 
    6262} 
    63  
    6463 
    6564/** 
    … …  
    6867D3D9HardwareOcclusionQuery::~D3D9HardwareOcclusionQuery()  
    6968{  
    70         SAFE_RELEASE( m_pD3DQuery );  
     69                SAFE_RELEASE(mpQuery);  
    7170} 
    7271 
    73 #ifndef GTP_VISIBILITY_MODIFIED_OGRE 
    7472//------------------------------------------------------------------ 
    7573// Occlusion query functions (see base class documentation for this) 
    … …  
    7775void D3D9HardwareOcclusionQuery::beginOcclusionQuery()  
    7876{  
    79         if( m_bHWOcclusionSupport )             // Make it fail silently if hardware occlusion isn't supported 
     77                // Make it fail silently if hardware occlusion isn't supported 
     78                if(mHasOcclusionSupport) 
    8079        { 
    81                 if  ( m_SkipCounter ==  m_Skip ) { m_SkipCounter = 0; };                // Counter starts at 0 again at m_Skip  
    82                  
    83                 if ( m_SkipCounter == 0 && m_uintPixelCount != 0 )      // New or none visable objects must allways be tested but visable objects can be skiped 
     80#ifndef GTP_VISIBILITY_MODIFIED_OGRE 
     81                        // Counter starts at 0 again at mSkipInterval  
     82                        if(mSkipCounter == mSkipInterval)  
     83#else 
     84                        if (mSkipCounter >= mSkipInterval)  // otherwise no query ever issued if mSkipInterval = 0 ! 
     85#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    8486                { 
    85                         m_pD3DQuery->Issue(D3DISSUE_BEGIN);  
     87                                mSkipCounter = 0;  
     88} 
     89                        //std::stringstream d; d << "count: " << mSkipCounter; 
     90                        //LogManager::getSingleton().logMessage(d.str()); 
     91                        if (mSkipCounter == 0) 
     92                { 
     93                                mpQuery->Issue(D3DISSUE_BEGIN);  
    8694                } 
    8795        } 
     96         
    8897} 
    89          
    90 void D3D9HardwareOcclusionQuery::endOcclusionQuery()  
    91 {  
    92         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported 
     98 
     99        void D3D9HardwareOcclusionQuery::endOcclusionQuery()  
    93100        { 
    94                 if (m_SkipCounter == 0 && m_uintPixelCount != 0 ) // New or none visable objects must allways be tested but visable objects can be skiped 
    95                 { 
    96                         m_pD3DQuery->Issue(D3DISSUE_END);  
    97                 } 
    98                 m_SkipCounter++;                                                                 // The skip counter is increased  
     101                // Make it fail silently if hardware occlusion isn't supported 
     102                if(mHasOcclusionSupport) 
     103                        { 
     104                        if(mSkipCounter == 0) 
     105                        {  
     106                                mpQuery->Issue(D3DISSUE_END);  
     107        } 
     108 
     109                        // The skip counter is increased 
     110                        mSkipCounter++;  
    99111        } 
    100112} 
    101113 
    102114//------------------------------------------------------------------ 
    103 // This version of pullOcclusionQuery cases the DX9 API/Driver to flush all commands to the 3D card 
    104 // to allow a fast result from the query, but at the cost of poorer batching of API calls to the card. 
    105 // Note: OpenGL dosn't use this flag at all so the application running OpenGL won't display any different behaviour. 
    106 //-- 
    107 bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments)  
    108 { 
    109         HRESULT hr; 
    110          
    111         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported 
    112         { 
    113                 hr = m_pD3DQuery->GetData( NumOfFragments, sizeof( NumOfFragments ), D3DGETDATA_FLUSH ); 
    114  
    115                 if ( hr != S_OK )  
    116                         { 
    117                                 return false;  
    118                         } 
    119                         else  
    120                         {  
    121                                 m_uintPixelCount = *NumOfFragments;  
    122                                 return true;  
    123                         } 
    124         } 
    125         else 
    126         { 
    127                 m_uintPixelCount = 100000; // Fails quitlly if hardware occlusion is not supported - every object is visable 
    128                 return true; 
    129         } 
    130 } 
    131  
    132 //------------------------------------------------------------------ 
    133 // This version of pullOcclusionQuery cases the DX9 API/Driver to not flush all commands to the 3D card 
     115        // This version of pullOcclusionQuery causes the DX9 API/Driver to not flush all commands to the 3D card 
    134116// to allow a fast result from the query, but the batching of API calls to the card will be normal.  
    135 // But the query wont be processed until the card recives the query in the nexr batch. 
     117        // But the query wont be processed until the card recives the query in the next batch. 
    136118// Note: OpenGL dosn't use this flag at all so the application running OpenGL won't display any different behaviour. 
    137119//-- 
    … …  
    140122        HRESULT hr; 
    141123 
    142         // TO DO: USE lockOpts= D3D9Mappings::get(options); instead of RS_OCCLUSIONQUERY enum 
     124                // Make it fail silently if hardware occlusion isn't supported 
     125                if(mHasOcclusionSupport) 
     126        { 
     127                        DWORD d3dFlags = (flag == HWOCCLUSIONQUERY_FLUSH) ? D3DGETDATA_FLUSH : 0; 
     128         
     129                        // run until success (http://www.gamedev.net/reference/programming/features/occlusionculling/page2.asp) 
     130                        while(hr = mpQuery->GetData( NumOfFragments, sizeof( NumOfFragments ), d3dFlags) == S_FALSE); 
    143131 
    144         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported 
    145         { 
    146          
    147                 switch( flag ) 
    148                 { 
    149                         case HWOCCLUSIONQUERY_FLUSH :    
    150                                 hr = m_pD3DQuery->GetData( NumOfFragments, sizeof( NumOfFragments ), D3DGETDATA_FLUSH ); 
    151                         break; 
    152  
    153                         case HWOCCLUSIONQUERY_NOFLUSH :  
    154                                 hr = m_pD3DQuery->GetData( NumOfFragments, sizeof( NumOfFragments ), 0 ); 
    155                         break; 
    156                 }; 
    157  
    158  
    159  
    160                 if ( hr != S_OK )  
    161                         { 
    162                                 return false;  
     132                        mPixelCount = *NumOfFragments; 
    163133                        } 
    164134                        else  
    165135                        {  
    166                                 m_uintPixelCount = *NumOfFragments;  
    167                                 return true;  
     136                        // fail silently if not supported, assume visible i suppose 
     137                        mPixelCount = 100000; 
    168138                        } 
    169         } 
    170         else  
    171         { 
    172                 m_uintPixelCount = 100000; // Fails quitlly if hardware occlusion is not supported - every object is visable 
     139 
    173140                return true; 
    174141        } 
    175 } 
    176 #else // GTP_VISIBILITY_MODIFIED_OGRE 
     142 
     143#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    177144//------------------------------------------------------------------ 
    178 void D3D9HardwareOcclusionQuery::beginOcclusionQuery()  
    179 {  
    180         if( m_bHWOcclusionSupport )             // Make it fail silently if hardware occlusion isn't supported 
     145        bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult,  
     146                                                                                                             const HW_OCCLUSIONQUERY flag )  
    181147        { 
    182                 m_pD3DQuery->Issue(D3DISSUE_BEGIN);  
     148                HRESULT hr = S_OK; 
     149                DWORD queryFlag = (flag == HWOCCLUSIONQUERY_FLUSH) ? D3DGETDATA_FLUSH : 0; 
     150 
     151                if (mHasOcclusionSupport)       // In case hardware occlusion isn't supported 
     152                {        
     153                        do 
     154                        { 
     155                                hr = mpQuery->GetData(NumOfFragments, sizeof(NumOfFragments), queryFlag); 
     156                } 
     157                        while(waitForResult && (hr == S_FALSE)); 
     158                 
     159                        mPixelCount = *NumOfFragments; 
     160                } 
     161                else 
     162                { 
     163                        mPixelCount = 100000; // every object is visible 
     164                } 
     165         
     166                return hr == S_OK; 
    183167        } 
    184 } 
    185 //------------------------------------------------------------------ 
    186 void D3D9HardwareOcclusionQuery::endOcclusionQuery()  
    187 {  
    188         if( m_bHWOcclusionSupport )     // Make it fail silently if hardware occlusion isn't supported 
    189         { 
    190                 m_pD3DQuery->Issue(D3DISSUE_END);  
    191         } 
    192 } 
    193 //------------------------------------------------------------------ 
    194 bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult )  
    195 { 
    196         return pullOcclusionQuery(NumOfFragments, waitForResult, HWOCCLUSIONQUERY_FLUSH); 
    197 } 
    198  
    199 //------------------------------------------------------------------ 
    200 bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult,  
    201                                                                                                      const HW_OCCLUSIONQUERY flag  )  
    202 { 
    203         DWORD queryFlag = flag == HWOCCLUSIONQUERY_FLUSH ? D3DGETDATA_FLUSH : 0; 
    204         // TO DO: USE lockOpts= D3D9Mappings::get(options); instead of RS_OCCLUSIONQUERY enum 
    205  
    206         return pullOcclusionQuery(NumOfFragments, waitForResult, queryFlag); 
    207 } 
    208  
    209 //------------------------------------------------------------------ 
    210 bool D3D9HardwareOcclusionQuery::pullOcclusionQuery( unsigned int* NumOfFragments, const bool waitForResult,  
    211                                                                                                      const DWORD queryFlag )  
    212 { 
    213         HRESULT hr = S_OK; 
    214  
    215         if( m_bHWOcclusionSupport )     // In case hardware occlusion isn't supported 
    216         {        
    217                 do 
    218                 { 
    219                         hr = m_pD3DQuery->GetData( NumOfFragments, sizeof( NumOfFragments ), queryFlag ); 
    220                 } 
    221                 while(waitForResult && (hr == S_FALSE)); 
    222                  
    223                 m_uintPixelCount = *NumOfFragments;  
    224         } 
    225         else 
    226         { 
    227                 m_uintPixelCount = 100000; // every object is visible 
    228         } 
    229          
    230         return hr == S_OK; 
    231 } 
    232168 
    233169 
    234170#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    235171 
    236 } // namespace OGre 
     172 
     173} 
Note: See TracChangeset for help on using the changeset viewer.