Changeset 171 for trunk


Ignore:
Timestamp:
07/13/05 00:47:40 (19 years ago)
Author:
mattausch
Message:

fixed visibilityQueries

Location:
trunk/VUT
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/GtpVisibility/include/HierarchyInterface.h

    r158 r171  
    1212typedef std::vector<HierarchyNode *> HierarchyNodeList; 
    1313typedef std::vector<GtpVisibility::Mesh *> GeometryList; 
     14typedef std::vector<GtpVisibility::Patch *> PatchList; 
    1415typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair; 
    1516typedef std::queue<QueryPair> QueryQueue; 

  • trunk/VUT/GtpVisibility/src/VisibilityInfo.cpp

    r159 r171  
    4848void VisibilityInfo::AddVisibility(const int visiblePixels, const int projectedPixels) 
    4949{ 
    50         mVisiblePixels +=visiblePixels; 
     50        mVisiblePixels += visiblePixels; 
    5151        mProjectedPixels += projectedPixels; 
    5252} 

  • trunk/VUT/Ogre/include/OgreOcclusionQueriesQueryManager.h

    r159 r171  
    77   
    88/** 
    9         Class which implements the QueryManager for Ogre scene queries using occlusion queries. 
     9        Class which implements a query manager for Ogre scene queries using occlusion queries. 
    1010*/ 
    1111class __declspec(dllexport) OcclusionQueriesQueryManager: public PlatformQueryManager 
    … …  
    1515                on different hierarchy types, while reusing the implementation of the query methods. 
    1616    */ 
    17         OcclusionQueriesQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp); 
     17        OcclusionQueriesQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
     18                                         Viewport *vp, 
     19                                                                 bool renderPatches, 
     20                                         bool useItemBufferForGeometry); 
    1821     
    1922    void ComputeCameraVisibility(const Camera &camera, 
    … …  
    3336                               bool relativeVisibility = false); 
    3437     
    35         bool ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine = false);   
     38 
     39protected: 
     40 
     41        void CollectGeometryVisibility(GtpVisibility::QueryList::iterator &visQueryIt,  
     42                                                                   GtpVisibility::QueryList::iterator &projQueryIt, 
     43                                                                   GtpVisibility::GeometryList *geometryList,  
     44                                                                   InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     45                                                                   bool relativeVisibility); 
     46 
     47        void CollectNodeVisibility(GtpVisibility::QueryList::iterator &visQueryIt,  
     48                                                           GtpVisibility::QueryList::iterator &projQueryIt, 
     49                                                           GtpVisibility::HierarchyNodeList *nodeList,  
     50                                                           InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
     51                                                           bool relativeVisibility); 
     52 
     53        void CollectRelativeGeometryVisibilityForItemBuffer(GtpVisibility::QueryList::iterator &projQueryIt, 
     54                                                                                                GtpVisibility::GeometryList *geometryList,  
     55                                                                                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry); 
     56 
     57        void CollectRelativePatchVisibilityForItemBuffer( 
     58                                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
     59                                                                        GtpVisibility::PatchList *patchList,  
     60                                                                        InfoContainer<GtpVisibility::PatchInfo> *visiblePatches); 
     61 
     62        void CollectPatchVisibility(GtpVisibility::QueryList::iterator &visQueryIt,  
     63                                                                GtpVisibility::QueryList::iterator &projQueryIt, 
     64                                                                GtpVisibility::PatchList *patchList,  
     65                                                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     66                                                                bool relativeVisibility); 
     67 
     68        void RemoveDuplicateNodes(InfoContainer<GtpVisibility::NodeInfo> *visibleNodes); 
     69        void RemoveDuplicateGeometry(InfoContainer<GtpVisibility::MeshInfo> *visibleMesh); 
     70 
     71        bool mUseItemBuffer; 
    3672}; 
    3773 

  • trunk/VUT/Ogre/include/OgrePlatformQueryManager.h

    r159 r171  
    1515public: 
    1616    /** Constructor taking a hierarchy interface as an argument. This allows to operate 
    17         onm different hierarchy types, while reusing the implementation of the query methods. 
     17            on different hierarchy types, while reusing the implementation of the query methods. 
    1818    */ 
    19         PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp); 
     19        PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
     20                                 Viewport *vp, 
     21                                                 bool renderPatches); 
    2022     
    2123    /**  
    … …  
    2830                                   InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
    2931                               bool relativeVisibility = false); 
    30      
    31   /**  
    32       Ray shooting interface: finds an intersection with objects in the scene. 
    33  
    34       @param ray The given input ray (assuming the ray direction is normalized) 
    35  
    36       @param visibleMeshes List of meshes intersecting the ray 
    37  
    38       @param isGlobalLine If false only first intersection with opaque object is returned. 
    39       Otherwise all intersections of the ray with the scene are found. 
    40  
    41       @return true if there is any intersection.  
    42         */ 
    43     virtual bool 
    44     ShootRay(const Ray &ray, 
    45              std::vector<Mesh *> *visibleMeshes, 
    46              bool isGlobalLine = false 
    47              );   
     32   
     33        void ComputeCameraVisibility(const Camera &camera, 
     34                               InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
     35                               InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     36                                   InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     37                               bool relativeVisibility = false); 
     38   
     39        bool ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine = false);   
    4840 
    4941        /** Sets a viewport for rendering. 
    … …  
    5244         
    5345protected: 
     46 
     47        void InitItemBuffer(InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     48                                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches); 
     49 
    5450        Viewport *mViewport; 
    5551        bool mWasInitialised; 
     52        bool mRenderPatches; 
    5653}; 
    5754 

  • trunk/VUT/Ogre/scripts/Plugin_VisibilitySceneManager.vcproj

    r154 r171  
    192192                                Filter="h;hpp;hxx;hm;inl;inc"> 
    193193                                <File 
    194                                         RelativePath="..\include\OgreItemBufferQueryManager.h"> 
    195                                 </File> 
    196                                 <File 
    197194                                        RelativePath="..\include\OgreOcclusionQueriesQueryManager.h"> 
    198195                                </File> 
    … …  
    228225                                Name="Source Files" 
    229226                                Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"> 
    230                                 <File 
    231                                         RelativePath="..\src\OgreItemBufferQueryManager.cpp"> 
    232                                 </File> 
    233227                                <File 
    234228                                        RelativePath="..\src\OgreOcclusionQueriesQueryManager.cpp"> 

  • trunk/VUT/Ogre/src/OgreItemBufferQueryManager.cpp

    r166 r171  
    1515} 
    1616//----------------------------------------------------------------------- 
    17 bool ItemBufferQueryManager::ShootRay(const Ray &ray,  
    18                                                                           std::vector<Mesh *> *visibleMeshes,  
    19                                                                           bool isGlobalLine) 
    20 { 
    21     // run OGRE ray shooting query 
    22     return false; 
    23 } 
    24 //----------------------------------------------------------------------- 
    2517void ItemBufferQueryManager::ComputeCameraVisibility(const Camera &camera, 
    2618                            InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    … …  
    2921                            bool relativeVisibility) 
    3022{ 
    31         // initialise item buffer (if not already initialised) 
    32         InitItemBuffer(visibleNodes, visibleGeometry, visiblePatches); 
    33  
    3423        // we need access to the scene manager and the rendersystem 
    3524        PlatformHierarchyInterface *pfHierarchyInterface =  
    … …  
    3827        SceneManager *sm = pfHierarchyInterface->GetSceneManager(); 
    3928 
    40         // --- Render scene with item buffer (i.e., objects with their id as color codes) 
    4129 
    4230        // const_cast allowed because camera is not changed in renderScene 
    … …  
    4634        bool overlayEnabled = mViewport->getOverlaysEnabled(); 
    4735        mViewport->setOverlaysEnabled(false); 
    48  
    49         // set item buffer (must be provided by scene manager) 
    50         bool useItemBuffer = true; 
    51         sm->setOption("UseItemBuffer", &useItemBuffer); 
    5236         
    5337        // clear background with black (i.e., not a valid item id) 
    5438        ColourValue bg = mViewport->getBackgroundColour(); 
    5539        mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0)); 
    56         pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH); 
    57  
    58         //-- render item buffer 
    59         sm->_renderScene(pCam, mViewport, false); 
    60     //mViewport->getTarget()->update(); 
    61  
    62 //for(int j=0; j<10000000; j++) printf("wait"); 
     40        //pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH); 
    6341 
    6442 
    65         //---- collect results 
     43        //-- render scene with item buffer (i.e., objects with their id as color codes) 
     44 
     45        // enable item buffer (must be provided by scene manager) 
     46        bool useItemBuffer = true; 
     47        sm->setOption("UseItemBuffer", &useItemBuffer); 
     48        sm->_renderScene(pCam, mViewport, false); // render item buffer 
     49    
     50 
     51        //-- collect results 
     52         
     53        // initialise item buffer (if not already initialised) 
     54        InitItemBuffer(visibleNodes, visibleGeometry, visiblePatches); 
     55 
    6656        int dimx = 0; 
    6757        int dimy = 0; 
    6858 
    69         // get frame buffer 
     59        // copy frame buffer  
    7060        uchar *buf = mViewport->getTarget()->getBufferContents(dimx, dimy); 
    7161 
    72         int n = mRenderPatchesForItemBuffer ? (int)visiblePatches->size() : (int)visibleGeometry->size(); 
     62        int n = mRenderPatchesForItemBuffer ?  
     63                (int)visiblePatches->size() : (int)visibleGeometry->size(); 
    7364 
    74         std::stringstream d; d << "dimx: " << dimx << ", dimy: " << dimy; 
    75         LogManager::getSingleton().logMessage(d.str()); 
     65        //std::stringstream d; d << "dimx: " << dimx << ", dimy: " << dimy; LogManager::getSingleton().logMessage(d.str()); 
    7666 
    77         // loop through frame buffer & collect visible pixels 
     67        // loop through frame buffer and collect visible pixels 
    7868        for (int idx = 0; idx < dimy * dimx * 3; idx += 3) 
    7969        { 
    … …  
    8373                id += buf[idx + 2]; 
    8474 
    85                 //std::stringstream d; d << "myid: " << (int)buf[idx] << " " << (int)buf[idx + 1] << " " << (int)buf[idx + 2]; 
    86                 //LogManager::getSingleton().logMessage(d.str()); 
     75                //std::stringstream d; d << "myid: " << (int)buf[idx] << " " << (int)buf[idx + 1] << " " << (int)buf[idx + 2]; LogManager::getSingleton().logMessage(d.str()); 
    8776 
    8877                // if valid id <= add visibility (id values start at 1) 
    … …  
    10089        } 
    10190 
     91 
    10292        //-- reset options 
    10393 
    104         // don't need item buffer anymore 
    105         useItemBuffer = false; 
     94        useItemBuffer = false; // don't need item buffer anymore 
    10695        sm->setOption("UseItemBuffer", &useItemBuffer); 
    107         // reset initialised - flag 
    108         mWasInitialised = false; 
    109         // reset old overlay status 
    110         mViewport->setOverlaysEnabled(overlayEnabled); 
    111         // reset background color 
    112         mViewport->setBackgroundColour(bg); 
    11396 
    114         // delete array storing the frame buffer 
    115         delete [] buf; 
     97        mWasInitialised = false; // reset initialised - flag 
     98        mViewport->setOverlaysEnabled(overlayEnabled); // reset old overlay status 
     99        mViewport->setBackgroundColour(bg); // reset background color 
     100 
     101        delete [] buf;  // delete copy of the frame buffer 
    116102} 
    117103//----------------------------------------------------------------------- 

  • trunk/VUT/Ogre/src/OgreOcclusionQueriesQueryManager.cpp

    r159 r171  
    33#include <OgreStringConverter.h> 
    44#include <vector> 
     5#include <OgreSubEntity.h> 
    56 
    67 
    78namespace Ogre { 
     9 
     10/** 
     11   These functions necessary to enable sorting of node / mesh / patch info. 
     12*/ 
     13//----------------------------------------------------------------------- 
     14inline bool nodeinfo_eq(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2)  
     15{  
     16        return info1.GetNode() == info2.GetNode();  
     17} 
     18//----------------------------------------------------------------------- 
     19inline bool meshinfo_eq(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2)  
     20{  
     21        return info1.GetMesh() == info2.GetMesh();  
     22} 
     23//----------------------------------------------------------------------- 
     24inline bool nodeinfo_lower(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2)  
     25{  
     26        return info1.GetNode() < info2.GetNode();  
     27} 
     28//----------------------------------------------------------------------- 
     29inline bool meshinfo_lower(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2)  
     30{  
     31        return info1.GetMesh() < info2.GetMesh();  
     32} 
     33 
     34 
     35 
    836//-----------------------------------------------------------------------  
    9 OcclusionQueriesQueryManager::OcclusionQueriesQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp): 
    10 PlatformQueryManager(hierarchyInterface, vp) 
    11 { 
    12 } 
    13 //----------------------------------------------------------------------- 
    14 bool OcclusionQueriesQueryManager::ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine) 
    15 { 
    16     // run OGRE ray shooting query 
    17     return false; 
     37OcclusionQueriesQueryManager::OcclusionQueriesQueryManager( 
     38                                                        PlatformHierarchyInterface *hierarchyInterface,  
     39                                                        Viewport *vp, 
     40                                                        bool renderPatches, 
     41                                                        bool useItemBufferForGeometry): 
     42PlatformQueryManager(hierarchyInterface, vp, renderPatches), 
     43mUseItemBuffer(useItemBufferForGeometry) 
     44{ 
    1845} 
    1946//----------------------------------------------------------------------- 
    … …  
    2451                            bool relativeVisibility) 
    2552{ 
    26         // we need access to the scene manager and the rendersystem 
     53         // we need access to the scene manager and the rendersystem 
    2754        PlatformHierarchyInterface *pfHierarchyInterface =  
    2855                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    2956 
    30         //-- Render scene to get conservative visibility and fill depth buffer  
    31  
    32         // const_cast allowed because camera is not changed in renderScene 
    33         Camera *pCam = const_cast<Camera *>(&camera);  
    34  
    3557        // disable overlays, reset them later 
    3658        bool overlayEnabled = mViewport->getOverlaysEnabled(); 
    37         mViewport->setOverlaysEnabled(false); 
    38  
    39         //-- render the scene once to update depth buffer 
    40         pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
    41  
    42         /*  
    43                 Two query lists for projected pixels and for visibile pixels: 
     59 
     60        //-- render scene with item buffer (i.e., objects with their id as color codes) 
     61        if (mUseItemBuffer) 
     62        { 
     63                PlatformQueryManager::ComputeCameraVisibility(camera, visibleNodes, 
     64                            visibleGeometry, visiblePatches, relativeVisibility); 
     65 
     66                mViewport->setOverlaysEnabled(false); 
     67        } 
     68        else 
     69        { 
     70                // const_cast allowed because camera is not changed in renderScene 
     71                Camera *pCam = const_cast<Camera *>(&camera);  
     72                mViewport->setOverlaysEnabled(false); 
     73 
     74                //-- Render scene to get conservative visibility and fill depth buffer 
     75                pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
     76        } 
     77 
     78         
     79        /*      Two query lists for projected pixels and for visibile pixels: 
    4480                We test queries after a rendering pass  
    4581                to get exact visibility with regard to the current camera. 
    … …  
    4884        GtpVisibility::QueryList queryList[2]; 
    4985         
    50         // get rendered hierarchy nodes 
     86        // rendered hierarchy nodes from previous render 
    5187        GtpVisibility::HierarchyNodeList *nodeList = mHierarchyInterface->GetRenderedNodes(); 
     88        GtpVisibility::HierarchyNodeList::iterator nodeIt, nodeIt_end = nodeList->end(); 
     89 
    5290        // vector for storing entities of meshes 
    5391        GtpVisibility::GeometryList geometryList; 
    5492         
    55         GtpVisibility::HierarchyNodeList::iterator nodeIt, nodeIt_end = nodeList->end(); 
    56         // geometry list has still do be built 
    57         GtpVisibility::GeometryList::iterator geometryIt, geometryIt_end; 
     93        // store geometry of the hierarchy node in a geometry list (only once!) 
     94        for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt)                 
     95        { 
     96                mHierarchyInterface->GetNodeGeometryList(*nodeIt, &geometryList, false); 
     97        } 
     98 
     99        // geometry list iterator 
     100        GtpVisibility::GeometryList::iterator geometryIt, geometryIt_end = geometryList.end(); 
     101 
    58102 
    59103        // to obtain the correct number of projected pixels, depth write must be disabled 
    60104        bool enableDepthWrite = false; 
    61  
    62105        // this option must be provided by the scene manager 
    63106        pfHierarchyInterface->GetSceneManager()->setOption("DepthWrite", &enableDepthWrite); 
    64107 
     108 
    65109        /* relative visiblity: 
    66                 1) get visible pixels count of objects 
    67                 2) clear frame buffer 
    68                 3) get projected visible pixels count: 
    69                    test all objects again without depth write (set as option in scene manager) 
    70                 4) calculate ratio between visible vs. projected pixels 
     110           1) get visible pixels count of objects 
     111           2) clear frame buffer 
     112           3) get projected visible pixels count: 
     113              test all objects again without depth write (set as option in scene manager) 
     114           4) calculate ratio between visible vs. projected pixels 
    71115        */ 
     116                 
    72117        // for relative visibility we need 2 rendering passes 
    73118        int n = relativeVisibility ? 2 : 1; 
    74119         
    75         for (int i=0; i<n; ++i) 
     120        for (int i = 0; i < n; ++i) 
    76121        { 
    77122                //-- queries for hierarchy nodes 
    … …  
    80125                        // TODO: DELETE QUERIES FROM PREVIOUS RENDER 
    81126                        queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*nodeIt, false)); 
    82                          
    83                         // store geometry of the hierarchy node in a geometry list (only once!) 
    84                         if (i == 0) 
     127                } 
     128 
     129                //-- queries for geometry: if item buffer, capture only projected visibility 
     130                if (!(mUseItemBuffer && (i == 0))) 
     131                { 
     132                        for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt) 
    85133                        { 
    86                                 mHierarchyInterface->GetNodeGeometryList(*nodeIt, &geometryList, false); 
     134                                queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*geometryIt)); 
    87135                        } 
    88136                } 
    89137 
    90                 geometryIt_end = geometryList.end(); 
    91  
    92                 //-- add queries for geometry 
    93                 for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt) 
    94                 { 
    95                         queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*geometryIt)); 
    96                 } 
    97  
    98          
    99138                pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_DEPTH); 
    100139        } 
    101140 
     141         
     142        //-- collect results 
     143        GtpVisibility::QueryList::iterator visQueryIt = queryList[0].begin(); 
     144        GtpVisibility::QueryList::iterator projQueryIt = queryList[1].begin(); 
     145         
     146        CollectNodeVisibility(visQueryIt, projQueryIt, nodeList, visibleNodes, relativeVisibility); 
     147 
     148        if (mUseItemBuffer) 
     149        { 
     150                if (relativeVisibility) 
     151                { 
     152                        CollectRelativeGeometryVisibilityForItemBuffer(projQueryIt, &geometryList, visibleGeometry); 
     153                } 
     154    } 
     155        else 
     156        { 
     157                CollectGeometryVisibility(visQueryIt, projQueryIt, &geometryList,  
     158                        visibleGeometry, relativeVisibility); 
     159            //CollectPatchVisibility(patchList, visiblePatches); 
     160        } 
     161 
     162 
     163        //-- reset options 
    102164        enableDepthWrite = true; 
    103165        // this option must be provided by the scene manager 
    … …  
    106168        mViewport->setOverlaysEnabled(overlayEnabled); 
    107169 
    108         // ---- collect results 
    109         GtpVisibility::QueryList::iterator visQueryIt, projQueryIt; 
    110  
    111         visQueryIt = queryList[0].begin(); 
    112         projQueryIt = queryList[1].begin(); 
    113  
    114          
    115         for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt) 
     170        mWasInitialised = false; 
     171} 
     172//----------------------------------------------------------------------- 
     173void OcclusionQueriesQueryManager::ComputeFromPointVisibility(const Vector3 &point, 
     174                               InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
     175                               InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     176                                   InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     177                               bool relativeVisibility) 
     178{ 
     179        PlatformQueryManager::ComputeFromPointVisibility(point, visibleNodes,  
     180                visibleGeometry, visiblePatches, relativeVisibility); 
     181 
     182        // remove duplicates (duplicates occur if an object is on the edge of the viewport) 
     183        // before duplicates can be deleted we have to add up their visibility 
     184        RemoveDuplicateNodes(visibleNodes); 
     185         
     186        if (!mUseItemBuffer) 
     187        { 
     188                RemoveDuplicateGeometry(visibleGeometry); 
     189        } 
     190} 
     191//----------------------------------------------------------------------- 
     192void  OcclusionQueriesQueryManager::CollectNodeVisibility( 
     193                                                GtpVisibility::QueryList::iterator &visQueryIt,  
     194                                                GtpVisibility::QueryList::iterator &projQueryIt, 
     195                                                GtpVisibility::HierarchyNodeList *nodeList,   
     196                                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
     197                                                bool relativeVisibility) 
     198{ 
     199        GtpVisibility::HierarchyNodeList::iterator nodeIt; 
     200 
     201        //-- queries for nodes 
     202        for (nodeIt = nodeList->begin(); nodeIt != nodeList->end(); ++nodeIt) 
    116203        { 
    117204                unsigned int visiblePixels = 0; 
    … …  
    132219                if (visiblePixels > 0) 
    133220                { 
    134                         visibleNodes->push_back(GtpVisibility::NodeInfo(*nodeIt, visiblePixels, projectedPixels)); 
    135                 } 
    136         } 
    137  
    138         // ---- queries for geometry 
    139         geometryIt_end = geometryList.end(); 
    140          
    141         for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt) 
     221                        visibleNodes->push_back(GtpVisibility::NodeInfo(*nodeIt, visiblePixels,  
     222                                projectedPixels)); 
     223                } 
     224        } 
     225} 
     226//----------------------------------------------------------------------- 
     227void OcclusionQueriesQueryManager::CollectRelativeGeometryVisibilityForItemBuffer( 
     228                                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
     229                                                                        GtpVisibility::GeometryList *geometryList,  
     230                                                                        InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry) 
     231{ 
     232        GtpVisibility::GeometryList::iterator geometryIt; 
     233 
     234        //-- queries for geometry 
     235        for (geometryIt = geometryList->begin(); geometryIt != geometryList->end(); ++ geometryIt) 
     236        { 
     237                unsigned int projectedPixels = 0; 
     238 
     239                (*projQueryIt)->GetQueryResult(projectedPixels, true); 
     240 
     241                ++projQueryIt; 
     242                int id = (*geometryIt)->getSubEntity(0)->getId(); 
     243 
     244                if ((id > 0) && (id < (int)visibleGeometry->size())) 
     245                { 
     246                        (*visibleGeometry)[id].AddVisibility(0, projectedPixels); 
     247                } 
     248        } 
     249} 
     250//----------------------------------------------------------------------- 
     251void OcclusionQueriesQueryManager::CollectRelativePatchVisibilityForItemBuffer( 
     252                                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
     253                                                                        GtpVisibility::PatchList *patchList,  
     254                                                                        InfoContainer<GtpVisibility::PatchInfo> *visiblePatches) 
     255{ 
     256        GtpVisibility::PatchList::iterator patchIt; 
     257 
     258        //-- queries for geometry 
     259        for (patchIt = patchList->begin(); patchIt != patchList->end(); ++ patchIt) 
     260        { 
     261                unsigned int projectedPixels = 0; 
     262 
     263                (*projQueryIt)->GetQueryResult(projectedPixels, true); 
     264 
     265                ++projQueryIt; 
     266                int id = (*patchIt)->getId(); 
     267 
     268                if ((id > 0) && (id < (int)visiblePatches->size())) 
     269                { 
     270                        (*visiblePatches)[id].AddVisibility(0, projectedPixels); 
     271                } 
     272        } 
     273} 
     274//----------------------------------------------------------------------- 
     275void  OcclusionQueriesQueryManager::CollectGeometryVisibility( 
     276                                                        GtpVisibility::QueryList::iterator &visQueryIt,  
     277                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
     278                                                        GtpVisibility::GeometryList *geometryList,  
     279                                                        InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     280                                                        bool relativeVisibility) 
     281{ 
     282        GtpVisibility::GeometryList::iterator geometryIt; 
     283 
     284        //-- queries for geometry 
     285        for (geometryIt = geometryList->begin(); geometryIt != geometryList->end(); ++ geometryIt) 
    142286        { 
    143287                unsigned int visiblePixels = 0; 
    … …  
    149293                { 
    150294                        (*projQueryIt)->GetQueryResult(projectedPixels, true); 
    151  
    152                         ++projQueryIt; 
    153                 } 
    154  
    155                 ++visQueryIt; 
     295                        ++ projQueryIt; 
     296                } 
     297 
     298                ++ visQueryIt; 
    156299 
    157300                // WARNING: approximate depth ordering during rendering =>  
    … …  
    163306                } 
    164307        } 
    165  
    166 } 
    167 //----------------------------------------------------------------------- 
    168 inline bool nodeinfo_eq(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2)  
    169 {  
    170         return info1.GetNode() == info2.GetNode();  
    171 } 
    172 //----------------------------------------------------------------------- 
    173 inline bool meshinfo_eq(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2)  
    174 {  
    175         return info1.GetMesh() == info2.GetMesh();  
    176 } 
    177 //----------------------------------------------------------------------- 
    178 inline bool nodeinfo_lower(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2)  
    179 {  
    180         return info1.GetNode() < info2.GetNode();  
    181 } 
    182 //----------------------------------------------------------------------- 
    183 inline bool meshinfo_lower(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2)  
    184 {  
    185         return info1.GetMesh() < info2.GetMesh();  
    186 } 
    187 //----------------------------------------------------------------------- 
    188 void OcclusionQueriesQueryManager::ComputeFromPointVisibility(const Vector3 &point, 
    189                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    190                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    191                                    InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
    192                                bool relativeVisibility) 
    193 { 
    194         PlatformQueryManager::ComputeFromPointVisibility(point, visibleNodes,  
    195                 visibleGeometry, visiblePatches, relativeVisibility); 
    196  
    197         // --- remove duplicates (duplicates occur if an object is on the edge of the viewport) 
    198  
    199         // before duplicates can be deleted we have to add up their visibility 
    200  
    201         // --- visible nodes 
     308} 
     309//----------------------------------------------------------------------- 
     310void  OcclusionQueriesQueryManager::CollectPatchVisibility( 
     311                                                        GtpVisibility::QueryList::iterator &visQueryIt,  
     312                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
     313                                                        GtpVisibility::PatchList *patchList,  
     314                                                        InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     315                                                        bool relativeVisibility) 
     316{ 
     317        GtpVisibility::PatchList::iterator patchIt; 
     318 
     319        //-- queries for patch 
     320        for (patchIt = patchList->begin(); patchIt != patchList->end(); ++ patchIt) 
     321        { 
     322                unsigned int visiblePixels = 0; 
     323                (*visQueryIt)->GetQueryResult(visiblePixels, true); 
     324                 
     325                unsigned int projectedPixels = 0; 
     326 
     327                if (relativeVisibility) 
     328                { 
     329                        (*projQueryIt)->GetQueryResult(projectedPixels, true); 
     330                        ++ projQueryIt; 
     331                } 
     332 
     333                ++ visQueryIt; 
     334 
     335                // WARNING: approximate depth ordering during rendering =>  
     336                // patch maybe occluded 
     337                if (visiblePixels > 0) 
     338                {                         
     339                        visiblePatches->push_back(GtpVisibility::PatchInfo(*patchIt, visiblePixels,  
     340                                projectedPixels)); 
     341                } 
     342        } 
     343} 
     344//----------------------------------------------------------------------- 
     345void  OcclusionQueriesQueryManager::RemoveDuplicateNodes( 
     346                                        InfoContainer<GtpVisibility::NodeInfo> *visibleNodes) 
     347{ 
    202348        sort(visibleNodes->begin(), visibleNodes->end(), nodeinfo_lower); 
    203349        InfoContainer<GtpVisibility::NodeInfo>::iterator visibleNodesIt, 
    … …  
    217363                        nodeInfo->AddVisibility(*visibleNodesIt); 
    218364                } 
    219  
    220365        } 
    221366         
    … …  
    223368        visibleNodes->erase( std::unique(visibleNodes->begin(),  
    224369                visibleNodes->end(), nodeinfo_eq), visibleNodes->end()); 
    225  
    226         // --- visible geometry 
     370} 
     371//----------------------------------------------------------------------- 
     372void  OcclusionQueriesQueryManager::RemoveDuplicateGeometry( 
     373                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry) 
     374{ 
    227375        sort(visibleGeometry->begin(), visibleGeometry->end(), meshinfo_lower); 
     376         
    228377        InfoContainer<GtpVisibility::MeshInfo>::iterator visibleGeomIt, 
    229                 visibleGeomIt_end = visibleGeometry->end(); 
     378                        visibleGeomIt_end = visibleGeometry->end(); 
    230379 
    231380        GtpVisibility::MeshInfo *geomInfo = NULL; 
    232381 
    233         int i=0; 
    234382        for (visibleGeomIt = visibleGeometry->begin(); visibleGeomIt != visibleGeomIt_end;  
    235383                ++visibleGeomIt) 

  • trunk/VUT/Ogre/src/OgrePlatformQueryManager.cpp

    r164 r171  
    55#include <OgreStringConverter.h> 
    66#include <vector> 
     7#include <OgreSubEntity.h> 
    78 
    89 
    910namespace Ogre { 
     11 
    1012//-----------------------------------------------------------------------  
    11 PlatformQueryManager::PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp): 
    12 QueryManager(hierarchyInterface), mViewport(vp), mWasInitialised(false) 
     13PlatformQueryManager::PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
     14                                                                                   Viewport *vp, bool renderPatches): 
     15QueryManager(hierarchyInterface),  
     16mViewport(vp),  
     17mWasInitialised(false), 
     18mRenderPatches(false) 
    1319{ 
    1420} 
    … …  
    6571                } 
    6672 
    67                 ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, visiblePatches, relativeVisibility); 
    68                  
     73                ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, visiblePatches,  
     74                                            relativeVisibility); 
    6975                //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("wait"); 
    7076 
    … …  
    8086} 
    8187//----------------------------------------------------------------------- 
     88void PlatformQueryManager::ComputeCameraVisibility(const Camera &camera, 
     89                            InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
     90                            InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     91                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     92                            bool relativeVisibility) 
     93{ 
     94        // we need access to the scene manager and the rendersystem 
     95        PlatformHierarchyInterface *pfHierarchyInterface =  
     96                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
     97 
     98        SceneManager *sm = pfHierarchyInterface->GetSceneManager(); 
     99 
     100 
     101        // const_cast allowed because camera is not changed in renderScene 
     102        Camera *pCam = const_cast<Camera *>(&camera);  
     103 
     104        // disable overlays, reset them later 
     105        bool overlayEnabled = mViewport->getOverlaysEnabled(); 
     106        mViewport->setOverlaysEnabled(false); 
     107         
     108        // clear background with black (i.e., not a valid item id) 
     109        ColourValue bg = mViewport->getBackgroundColour(); 
     110        mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0)); 
     111        //pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH); 
     112 
     113        // initialise item buffer (if not already initialised) 
     114        InitItemBuffer(visibleGeometry, visiblePatches); 
     115 
     116        //-- render scene with item buffer (i.e., objects with their id as color codes) 
     117 
     118        // enable item buffer (must be provided by scene manager) 
     119        bool useItemBuffer = true; 
     120        sm->setOption("UseItemBuffer", &useItemBuffer); 
     121 
     122 
     123        sm->_renderScene(pCam, mViewport, false); // render item buffer 
     124    
     125 
     126        //-- collect results 
     127 
     128        int dimx = 0; 
     129        int dimy = 0; 
     130 
     131        // copy frame buffer  
     132        uchar *buf = mViewport->getTarget()->getBufferContents(dimx, dimy); 
     133 
     134        int n = mRenderPatches ?  
     135                (int)visiblePatches->size() : (int)visibleGeometry->size(); 
     136 
     137        //std::stringstream d; d << "dimx: " << dimx << ", dimy: " << dimy; LogManager::getSingleton().logMessage(d.str()); 
     138 
     139        // loop through frame buffer and collect visible pixels 
     140        for (int idx = 0; idx < dimy * dimx * 3; idx += 3) 
     141        { 
     142                //-- decode color code to receive id 
     143                int id = buf[idx] << 16; 
     144                id += buf[idx + 1] << 8; 
     145                id += buf[idx + 2]; 
     146 
     147                //std::stringstream d; d << "myid: " << (int)buf[idx] << " " << (int)buf[idx + 1] << " " << (int)buf[idx + 2]; LogManager::getSingleton().logMessage(d.str()); 
     148 
     149                // if valid id <= add visibility (id values start at 1) 
     150                if ((id > 0) && (id < n)) 
     151                { 
     152                        if (mRenderPatches) 
     153                        { 
     154                                ((*visiblePatches)[id]).AddVisibility(1, 0); 
     155                        } 
     156                        else 
     157                        { 
     158                                ((*visibleGeometry)[id]).AddVisibility(1, 0); 
     159                        } 
     160                } 
     161        } 
     162 
     163 
     164        //-- reset options 
     165 
     166        useItemBuffer = false; // don't need item buffer anymore 
     167        sm->setOption("UseItemBuffer", &useItemBuffer); 
     168 
     169        mWasInitialised = false; // reset initialised - flag 
     170        mViewport->setOverlaysEnabled(overlayEnabled); // reset old overlay status 
     171        mViewport->setBackgroundColour(bg); // reset background color 
     172 
     173        delete [] buf;  // delete copy of the frame buffer 
     174} 
     175//----------------------------------------------------------------------- 
     176void PlatformQueryManager::InitItemBuffer( 
     177                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     178                                InfoContainer<GtpVisibility::PatchInfo> *visiblePatches) 
     179{ 
     180        if (mWasInitialised) 
     181                return; 
     182 
     183        mWasInitialised = true; 
     184 
     185        SceneManager *sm =  
     186                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager(); 
     187 
     188        SceneManager::EntityIterator it = sm->getEntityIterator(); 
     189 
     190        // TODO: make the function more efficient 
     191 
     192        visibleGeometry->clear(); 
     193        visiblePatches->clear(); 
     194 
     195        int id = 0; 
     196 
     197        /* We can either use patches or meshes. If patches are used, an unique id must 
     198           be given each patch. Otherwise the same id must be given to all patches belonging 
     199           to the same mesh. 
     200    */ 
     201        while (it.hasMoreElements()) 
     202        { 
     203                Entity *ent = it.getNext(); 
     204 
     205                for (int i = 0; i < (int)ent->getNumSubEntities(); ++i) 
     206                { 
     207                        SubEntity *subEnt = ent->getSubEntity(i); 
     208 
     209                        if (mRenderPatches) 
     210                        { 
     211                                ++ id; 
     212                                visiblePatches->push_back(GtpVisibility::PatchInfo(subEnt, 0, 0)); 
     213                        } 
     214                                 
     215                        subEnt->setId(id); 
     216                        //subEnt->setId((41 << 16) + (4 << 8) + 60); 
     217                        //subEnt->setId((2 << 16) + (4 << 8) + 60); 
     218                } 
     219                         
     220                if (!mRenderPatches) 
     221                { 
     222                        visibleGeometry->push_back(GtpVisibility::MeshInfo(ent, 0, 0)); 
     223                        ++ id; 
     224                } 
     225        } 
     226} 
     227//----------------------------------------------------------------------- 
    82228void PlatformQueryManager::SetViewport(Viewport *vp) 
    83229{ 

  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp

    r164 r171  
    99#include "OgreVisibilityTerrainSceneManager.h" 
    1010#include "VisibilityInfo.h" 
    11 #include "OgreItemBufferQueryManager.h" 
    1211#include "OgreOcclusionQueriesQueryManager.h" 
    1312#include "TestCullingTerrainApplication.h" 
    … …  
    414413                dynamic_cast<VisibilityTerrainSceneManager *>(mSceneMgr); 
    415414 
    416         if (useItemBuffer) 
    417         { 
    418                 mQueryManager = new ItemBufferQueryManager(sm->GetHierarchyInterface(),  
    419                         mWindow->getViewport(0), mRenderPatchesForItemBuffer); 
    420         } 
    421         else 
    422         { 
    423                 mQueryManager = new OcclusionQueriesQueryManager(sm->GetHierarchyInterface(),  
    424                         mWindow->getViewport(0)); 
    425         } 
    426  
     415        mQueryManager = new OcclusionQueriesQueryManager(sm->GetHierarchyInterface(), 
     416                        mWindow->getViewport(0), false, useItemBuffer); 
     417        //mQueryManager = new PlatformQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0), false); 
     418         
    427419        sm->GetVisibilityManager()->SetQueryManager(mQueryManager); 
    428420 
    … …  
    431423        InfoContainer<GtpVisibility::PatchInfo> visiblePatches; 
    432424 
     425 
    433426        if (fromPoint) 
    434427        { 
    … …  
    442435                            &visibleNodes, &visibleGeometry, &visiblePatches, relativeVisibility); 
    443436        } 
     437                 
     438        std::stringstream d;  
     439        d << queryTypeCaptions[fromPoint ?  1 : 0].c_str() << " " 
     440          << queryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str() << " " 
     441      << queryMethodCaptions[useItemBuffer ? 1 : 0].c_str(); 
     442        LogManager::getSingleton().logMessage(d.str()); 
     443 
    444444 
    445445        float averageNodeVis = 0, averageGeometryVis = 0, averagePatchVis = 0; 
    … …  
    457457         
    458458                        averageGeometryVis += vis; 
    459                         ++geomSize; 
     459                        ++ geomSize; 
    460460                         
    461                         std::stringstream d; d << "Geometry " << geomSize << " visibility: " << vis; 
     461                        std::stringstream d;  
     462                        d << "Geometry " << geomSize << " id: " << (*geomIt).GetMesh()->getSubEntity(0)->getId()  
     463                          << " visibility: "  << (*geomIt).GetVisiblePixels() << ", " << (*geomIt).GetProjectedPixels(); 
    462464                        LogManager::getSingleton().logMessage(d.str()); 
    463465                } 
    … …  
    475477                 
    476478                        averageNodeVis += vis; 
    477                         ++nodesSize; 
     479                        ++ nodesSize; 
    478480 
    479481                        std::stringstream d; d << "Node visibility: " << vis; 
    … …  
    484486        InfoContainer<GtpVisibility::PatchInfo>::iterator patchIt, patchIt_end = visiblePatches.end(); 
    485487 
    486         for (patchIt = visiblePatches.begin(); patchIt != patchIt_end; ++patchIt) 
     488        for (patchIt = visiblePatches.begin(); patchIt != patchIt_end; ++ patchIt) 
    487489        { 
    488490                // add if not 0 
    … …  
    493495                 
    494496                        averagePatchVis += vis; 
    495                         ++patchSize; 
     497                        ++ patchSize; 
    496498 
    497499                        std::stringstream d; d << "Patch visibility: " << vis; 
    … …  
    14101412             
    14111413        initOverlayElement(&mQueryTypeInfo , ext, "QueryType", top,     ": 0"); top += vert_space; 
     1414         
     1415        initOverlayElement(&mQueryVisibleNodesInfo , ext, "VisibleNodes", top,  ": 0"); top += vert_space; 
    14121416        initOverlayElement(&mQueryVisibleGeometryInfo , ext, "VisibleGeometry", top,    ": 0"); top += vert_space; 
    1413         initOverlayElement(&mQueryVisibleNodesInfo , ext, "VisibleNodes", top,  ": 0"); top += vert_space; 
    14141417        initOverlayElement(&mQueryVisiblePatchInfo , ext, "VisiblePatches", top,        ": 0"); top += vert_space; 
     1418         
    14151419        initOverlayElement(&mQueryNodeVisibilityInfo , ext, "NodeVisibility", top,      ": 0"); top += vert_space; 
    14161420        initOverlayElement(&mQueryGeometryVisibilityInfo , ext, "GeometryVisibility", top,      ": 0"); top += vert_space; 

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

    r166 r171  
    928928                HRESULT hr; 
    929929                LPDIRECT3DSURFACE9 pSurf=NULL, pTempSurf=NULL; 
     930                //IDirect3DSurface9 *pTempSurf=NULL; 
    930931                D3DSURFACE_DESC desc; 
    931932                D3DDISPLAYMODE dm; 
    … …  
    953954                } 
    954955 
    955                 //if (FAILED(hr = mpD3DDevice->GetFrontBufferData(0, pTempSurf))) 
    956                 if (FAILED(hr = mpD3DDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pTempSurf))) 
     956                if (FAILED(hr = mpD3DDevice->GetFrontBufferData(0, pTempSurf))) 
     957                //if (FAILED(hr = mpD3DDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pTempSurf))) 
    957958                { 
    958959                        SAFE_RELEASE(pTempSurf); 
    … …  
    10581059                } 
    10591060 
    1060                 pTempSurf->UnlockRect(); 
     1061//pTempSurf->UnlockRect(); 
    10611062                SAFE_RELEASE(pTempSurf); 
    10621063                SAFE_RELEASE(pSurf); 
Note: See TracChangeset for help on using the changeset viewer.