Changeset 154 for trunk/VUT


Ignore:
Timestamp:
07/04/05 17:57:51 (19 years ago)
Author:
mattausch
Message:

added item buffer queries.

Location:
trunk/VUT
Files:
6 added
23 edited

Legend:

Unmodified
Added
Removed

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

    r130 r154  
    144144 
    145145 
    146         /** Renders geometry. 
     146        /** Renders the given geometry. 
    147147        */ 
    148148        virtual void RenderGeometry(GtpVisibility::Mesh *geom) = 0; 
    149149 
     150        /** Sets node id to specified value.  
     151        */ 
     152        virtual void SetNodeId(HierarchyNode *node, int id) = 0; 
     153        /** Returns id of given node.  
     154        */ 
     155        virtual int GetNodeId(HierarchyNode *node) = 0; 
    150156protected: 
    151157         

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

    r87 r154  
    4343        */ 
    4444        AxisAlignedBox *GetBoundingBox(GtpVisibility::HierarchyNode *node); 
    45          
    46         unsigned int mNumOctreeNodes; 
    4745}; 
    4846} // namespace Ogre 

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

    r153 r154  
    2222                            bool relativeVisibility = false); 
    2323     
    24     /**  
    25         Uses the specified point to execute the visibility query in all directions.  
    26         @sa ComputeCameraVisibility() 
    27     */ 
    28     void ComputeFromPointVisibility(const Vector3 &point, 
    29                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    30                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    31                                bool relativeVisibility = false); 
    32      
    3324        bool ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine = false);   
    3425         
    … …  
    3627        void InitItemBuffer( InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    3728                            InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry); 
    38         bool mWasInitialised; 
     29         
    3930}; 
    4031 

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

    r130 r154  
    2525                See setOption 
    2626        */ 
    27         //bool getOption( const String &, void * ); 
    28         //bool getOptionKeys( StringVector &refKeys ); 
    2927        void PullUpVisibility(GtpVisibility::HierarchyNode *node); 
     28         
    3029        /** Traverses given node. 
    3130                @param node current node 
    … …  
    5049                                                        InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,  
    5150                                                        bool includeChildren = false);*/ 
     51 
    5252        void GetGeometry(GtpVisibility::HierarchyNode *node, 
    5353                                         GtpVisibility::GeometryList *geometryList,  
    5454                                         bool includeChildren); 
     55 
     56        void SetNodeId(GtpVisibility::HierarchyNode *node, int id); 
     57         
     58        int GetNodeId(GtpVisibility::HierarchyNode *node); 
    5559 
    5660protected: 
    … …  
    6569        */ 
    6670        Real GetSquaredViewDepth(const Camera* cam, const AxisAlignedBox* box) const; 
    67         /** number of octree hierarchy nodes */ 
    68         unsigned int mNumOctreeNodes; 
    6971}; 
    7072} // namespace Ogre 

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

    r144 r154  
    2020     
    2121    /**  
    22         Computes restricted visibility from point by using an explicit camera to execute 
    23         the visibility query. 
    24         @param camera The camera to be used 
    25  
    26         @param visibleNodes Pointer to the container where visible nodes should be added. 
    27         This set is formed of visible leafs or fully visible interior nodes. 
    28         If NULL no visible nodes are not evaluated. 
    29  
    30         @param visibleGeometry Pointer to the container where visible meshes should be added. 
    31         If NULL no visible meshes are not evaluated. 
    32  
    33         @param projectedPixels If true the visibility member for 
    34         NodeInfo and MeshInfo represent relative visibility; i.e. the number of visible 
    35         pixels divided by the the number of projected pixels. 
    36  
    37         @return true if the corresponding PVS exists. 
    38     */ 
    39     virtual void 
    40     ComputeCameraVisibility(const Camera &camera, 
    41                             InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    42                             InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    43                             bool relativeVisibility = false 
    44                             ); 
    45      
    46     /**  
    4722        Uses the specified point to execute the visibility query in all directions.  
    4823        @sa ComputeCameraVisibility() 
    4924    */ 
    50     virtual void 
    51     ComputeFromPointVisibility(const Vector3 &point, 
     25    void ComputeFromPointVisibility(const Vector3 &point, 
    5226                               InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    5327                               InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    54                                bool relativeVisibility = false 
    55                                ); 
     28                               bool relativeVisibility = false); 
    5629     
    5730  /**  
    … …  
    7952protected: 
    8053        Viewport *mViewport; 
     54        bool mWasInitialised; 
    8155}; 
    8256 

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

    r130 r154  
    4949                                         GtpVisibility::GeometryList *geometryList,  
    5050                                         bool includeChildren); 
     51 
     52        void SetNodeId(GtpVisibility::HierarchyNode *node, int id); 
     53         
     54        int GetNodeId(GtpVisibility::HierarchyNode *node); 
    5155}; 
    5256 

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

    r150 r154  
    195195                                </File> 
    196196                                <File 
     197                                        RelativePath="..\include\OgreOcclusionQueriesQueryManager.h"> 
     198                                </File> 
     199                                <File 
    197200                                        RelativePath="..\include\OgrePlatformHierarchyInterface.h"> 
    198201                                </File> 
    … …  
    227230                                <File 
    228231                                        RelativePath="..\src\OgreItemBufferQueryManager.cpp"> 
     232                                </File> 
     233                                <File 
     234                                        RelativePath="..\src\OgreOcclusionQueriesQueryManager.cpp"> 
    229235                                </File> 
    230236                                <File 

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

    r153 r154  
    88//-----------------------------------------------------------------------  
    99ItemBufferQueryManager::ItemBufferQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp): 
    10 PlatformQueryManager(hierarchyInterface, vp), mWasInitialised(false) 
     10PlatformQueryManager(hierarchyInterface, vp) 
    1111{ 
    1212} 
    … …  
    2323                            bool relativeVisibility) 
    2424{ 
    25         // initialise item buffer if necessary 
     25        // initialise item buffer (if not already initialised) 
    2626        InitItemBuffer(visibleNodes, visibleGeometry); 
    2727 
    … …  
    4545        sm->setOption("UseItemBuffer", &useItemBuffer); 
    4646         
    47         // clear background with black 
     47        // clear background with black (i.e., not a valid item id) 
    4848        ColourValue bg = mViewport->getBackgroundColour(); 
    4949        mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0)); 
    … …  
    7070        uchar *buf = mViewport->getTarget()->getBufferContents(dimx, dimy); 
    7171 
     72         
    7273        // loop through frame buffer & collect visible pixels 
    7374        for (int idx = 0; idx < dimy * dimx * 3; idx += 3) 
    7475        { 
     76                // -- decode color code to receive id 
    7577                int id = buf[idx] << 16; 
    7678                id += buf[idx + 1] << 8; 
    7779                id += buf[idx + 2]; 
    7880 
    79                 // if valid id <= add visibility 
    80                 if ((id >= 0) && (id < (int)visibleGeometry->size())) 
     81                // if valid id <= add visibility (id values start at 1 
     82                if ((id > 0) && (id < (int)visibleGeometry->size())) 
    8183                { 
    8284                        ((*visibleGeometry)[id]).AddVisibility(1, 1); 
    8385                } 
    84         /*      else 
    85                 {  
    86                         std::stringstream d;  
    87                         d << "id: " << id << ", buf 1: " << (int)buf[idx] << ", buf 2: " << (int)buf[idx + 1] << ", buf 3: " << (int)buf[idx + 2]; 
    88                         LogManager::getSingleton().logMessage(d.str()); 
    89                 }*/ 
     86                /*else {        std::stringstream d;  
     87                        d << "adding pixel to geometry with id: " << id << ", buf 1: " << (int)buf[idx] << ", buf 2: " << (int)buf[idx + 1] << ", buf 3: " << (int)buf[idx + 2]; 
     88                        LogManager::getSingleton().logMessage(d.str()); }*/ 
    9089        } 
    9190 
    … …  
    104103        mWasInitialised = true; 
    105104 
    106         SceneManager::EntityIterator it = dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)-> 
     105        SceneManager::EntityIterator it =  
     106                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)-> 
    107107                GetSceneManager()->getEntityIterator(); 
    108108 
    109109        // TODO: make this more efficient 
    110110        visibleGeometry->clear(); 
     111        visibleNodes->clear(); 
    111112 
    112113        while (it.hasMoreElements()) 
    … …  
    115116        } 
    116117} 
    117 //----------------------------------------------------------------------- 
    118 void ItemBufferQueryManager::ComputeFromPointVisibility(const Vector3 &point, 
    119                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    120                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    121                                bool relativeVisibility) 
    122 { 
    123         SceneManager *sm = dynamic_cast<PlatformHierarchyInterface *> 
    124                 (mHierarchyInterface)->GetSceneManager(); 
    125  
    126         Camera *cam = sm->createCamera("PointQueryCam");         
    127  
    128         //save old camera 
    129         Camera *savedCam = mViewport->getCamera(); 
    130          
    131         // --- initialise new camera 
    132         mViewport->setCamera(cam); 
    133         cam->setPosition(point); 
    134  
    135         cam->setNearClipDistance(savedCam->getNearClipDistance()); 
    136         cam->setFarClipDistance(savedCam->getFarClipDistance()); 
    137  
    138         // set frustum to 45 degrees so all the scene can be captured with 6 shots 
    139         cam->setAspectRatio(1.0); 
    140         cam->setFOVy(Radian(Math::HALF_PI)); 
    141  
    142         int sign = -1; 
    143          
    144         // ---- capture visibility from all 6 directions 
    145         for (int i=0; i < 6; i++)        
    146         { 
    147                 sign *= -1; 
    148                  
    149                 // Print camera details 
    150         std::stringstream d; 
    151                 d << "Point query camera: " + StringConverter::toString(cam->getDerivedPosition()) +  
    152                         " " + "O: " + StringConverter::toString(cam->getDerivedOrientation()); 
    153                 LogManager::getSingleton().logMessage(d.str()); 
    154  
    155                 // prevent from initialising array again 
    156                 if (i > 0) 
    157                         mWasInitialised = true; 
    158                  
    159                 // compute camera visibility for this direction 
    160                 ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, relativeVisibility); 
    161  
    162                 //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("wait"); // HACK: DISPLAY CAMERA VIEW 
    163  
    164                 // --- permute directions 
    165                 Vector3 dir(0,0,0); 
    166                 dir[i/2] = sign; 
    167  
    168                 cam->setDirection(dir); 
    169         } 
    170          
    171         // reset camera 
    172         mViewport->setCamera(savedCam); 
    173 } 
    174  
    175118} // namespace Ogre 

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

    r139 r154  
    5555} 
    5656//----------------------------------------------------------------------- 
    57 void OctreeHierarchyInterface::SetNumOctreeNodes(unsigned int num) 
    58 { 
    59         mNumOctreeNodes = num; 
    60 } 
    61 //----------------------------------------------------------------------- 
    6257float OctreeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const 
    6358{ 
    … …  
    173168                SceneNodeHierarchyInterface::GetGeometry(*nodeIt, geometryList, includeChildren); 
    174169        } 
     170} 
     171//----------------------------------------------------------------------- 
     172void OctreeHierarchyInterface::SetNodeId(GtpVisibility::HierarchyNode *node, int id) 
     173{ 
     174        static_cast<Octree *>(node)->setId(id); 
     175} 
     176//----------------------------------------------------------------------- 
     177int OctreeHierarchyInterface::GetNodeId(GtpVisibility::HierarchyNode *node) 
     178{ 
     179        return static_cast<Octree *>(node)->getId(); 
    175180} 
    176181//----------------------------------------------------------------------- 

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

    r153 r154  
    1010//-----------------------------------------------------------------------  
    1111PlatformQueryManager::PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp): 
    12 QueryManager(hierarchyInterface), mViewport(vp) 
     12QueryManager(hierarchyInterface), mViewport(vp), mWasInitialised(false) 
    1313{ 
    1414} 
    … …  
    1818    // run OGRE ray shooting query 
    1919    return false; 
    20 } 
    21 //----------------------------------------------------------------------- 
    22 void PlatformQueryManager::ComputeCameraVisibility(const Camera &camera, 
    23                             InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    24                             InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    25                             bool relativeVisibility) 
    26 { 
    27         // we need access to the scene manager and the rendersystem 
    28         PlatformHierarchyInterface *pfHierarchyInterface =  
    29                 dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface); 
    30  
    31         //-- Render scene to get conservative visibility and fill depth buffer  
    32  
    33         // const_cast allowed because camera is not changed in renderScene 
    34         Camera *pCam = const_cast<Camera *>(&camera);  
    35  
    36         // disable overlays, reset them later 
    37         bool overlayEnabled = mViewport->getOverlaysEnabled(); 
    38         mViewport->setOverlaysEnabled(false); 
    39  
    40         //-- render the scene once to update depth buffer 
    41         pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
    42  
    43         /*  
    44                 Two query lists for projected pixels and for visibile pixels: 
    45                 We test queries after a rendering pass  
    46                 to get exact visibility with regard to the current camera. 
    47                 We issue all queries at once to avoid starvation & stalls. 
    48         */ 
    49         GtpVisibility::QueryList queryList[2]; 
    50          
    51         // get rendered hierarchy nodes 
    52         GtpVisibility::HierarchyNodeList *nodeList = mHierarchyInterface->GetRenderedNodes(); 
    53         // vector for storing entities of meshes 
    54         GtpVisibility::GeometryList geometryList; 
    55          
    56         GtpVisibility::HierarchyNodeList::iterator nodeIt, nodeIt_end = nodeList->end(); 
    57         // geometry list has still do be built 
    58         GtpVisibility::GeometryList::iterator geometryIt, geometryIt_end; 
    59  
    60         // to obtain the correct number of projected pixels, depth write must be disabled 
    61         bool enableDepthWrite = false; 
    62  
    63         // this option must be provided by the scene manager 
    64         pfHierarchyInterface->GetSceneManager()->setOption("DepthWrite", &enableDepthWrite); 
    65  
    66         /* relative visiblity: 
    67                 1) get visible pixels count of objects 
    68                 2) clear frame buffer 
    69                 3) get projected visible pixels count: 
    70                    test all objects again without depth write (set as option in scene manager) 
    71                 4) calculate ratio between visible vs. projected pixels 
    72         */ 
    73         // for relative visibility we need 2 rendering passes 
    74         int n = relativeVisibility ? 2 : 1; 
    75          
    76         for (int i=0; i<n; ++i) 
    77         { 
    78                 //-- queries for hierarchy nodes 
    79                 for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt)                 
    80                 { 
    81                         // TODO: DELETE QUERIES FROM PREVIOUS RENDER 
    82                         queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*nodeIt, false)); 
    83                          
    84                         // store geometry of the hierarchy node in a geometry list (only once!) 
    85                         if (i == 0) 
    86                         { 
    87                                 mHierarchyInterface->GetGeometry(*nodeIt, &geometryList, false); 
    88                         } 
    89                 } 
    90  
    91                 geometryIt_end = geometryList.end(); 
    92  
    93                 //-- add queries for geometry 
    94                 for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt) 
    95                 { 
    96                         queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*geometryIt)); 
    97                 } 
    98  
    99          
    100                 pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_DEPTH); 
    101         } 
    102  
    103         enableDepthWrite = true; 
    104         // this option must be provided by the scene manager 
    105         pfHierarchyInterface->GetSceneManager()->setOption("DepthWrite", &enableDepthWrite); 
    106         // reset old overlay status 
    107         mViewport->setOverlaysEnabled(overlayEnabled); 
    108  
    109         //---- collect results 
    110         GtpVisibility::QueryList::iterator visQueryIt, projQueryIt; 
    111  
    112         visQueryIt = queryList[0].begin(); 
    113         projQueryIt = queryList[1].begin(); 
    114  
    115          
    116         for (nodeIt = nodeList->begin(); nodeIt != nodeIt_end; ++nodeIt) 
    117         { 
    118                 unsigned int visiblePixels = 0; 
    119                 (*visQueryIt)->GetQueryResult(visiblePixels, true); 
    120          
    121                 unsigned int projectedPixels = 0; 
    122  
    123                 if (relativeVisibility) 
    124                 { 
    125                         (*projQueryIt)->GetQueryResult(projectedPixels, true); 
    126                  
    127                         ++projQueryIt; 
    128                 } 
    129  
    130                 ++visQueryIt; 
    131                  
    132                 // node with visibilty 0 in queue (e.g., if node is intersected by near plane) 
    133                 if (visiblePixels > 0) 
    134                 { 
    135                         visibleNodes->push_back(GtpVisibility::NodeInfo(*nodeIt, visiblePixels, projectedPixels)); 
    136                 } 
    137         } 
    138  
    139         //---- queries for geometry 
    140         geometryIt_end = geometryList.end(); 
    141          
    142         for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt) 
    143         { 
    144                 unsigned int visiblePixels = 0; 
    145                 (*visQueryIt)->GetQueryResult(visiblePixels, true); 
    146                  
    147                 unsigned int projectedPixels = 0; 
    148  
    149                 if (relativeVisibility) 
    150                 { 
    151                         (*projQueryIt)->GetQueryResult(projectedPixels, true); 
    152  
    153                         ++projQueryIt; 
    154                 } 
    155  
    156                 ++visQueryIt; 
    157  
    158                 // approximate depth ordering during rendering =>  
    159                 // geometry maybe occluded 
    160                 if (visiblePixels > 0) 
    161                 {                         
    162                         visibleGeometry->push_back(GtpVisibility::MeshInfo(*geometryIt, visiblePixels,  
    163                                 projectedPixels)); 
    164                 } 
    165         } 
    166  
    167 } 
    168 //----------------------------------------------------------------------- 
    169 inline bool nodeinfo_eq(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2)  
    170 {  
    171         return info1.GetNode() == info2.GetNode();  
    172 } 
    173 //----------------------------------------------------------------------- 
    174 inline bool meshinfo_eq(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2)  
    175 {  
    176         return info1.GetMesh() == info2.GetMesh();  
    177 } 
    178 //----------------------------------------------------------------------- 
    179 inline bool nodeinfo_lower(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2)  
    180 {  
    181         return info1.GetNode() < info2.GetNode();  
    182 } 
    183 //----------------------------------------------------------------------- 
    184 inline bool meshinfo_lower(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2)  
    185 {  
    186         return info1.GetMesh() < info2.GetMesh();  
    18720} 
    18821//----------------------------------------------------------------------- 
    … …  
    22255                LogManager::getSingleton().logMessage(d.str()); 
    22356 
     57                // prevent from initialising geometry / node array again 
     58                if (i > 0) 
     59                        mWasInitialised = true; 
     60 
    22461                ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, relativeVisibility); 
    22562                 
    … …  
    23572        // reset camera 
    23673        mViewport->setCamera(savedCam); 
    237  
    238         // --- remove duplicates (duplicates occur if an object is on the edge of the viewport) 
    239  
    240         // before duplicates can be deleted we have to add up their visibility 
    241  
    242         // --- visible nodes 
    243         sort(visibleNodes->begin(), visibleNodes->end(), nodeinfo_lower); 
    244         InfoContainer<GtpVisibility::NodeInfo>::iterator visibleNodesIt, 
    245                 visibleNodesIt_end = visibleNodes->end(); 
    246          
    247         GtpVisibility::NodeInfo *nodeInfo = NULL; 
    248  
    249         for (visibleNodesIt = visibleNodes->begin(); visibleNodesIt != visibleNodesIt_end;  
    250                 ++visibleNodesIt) 
    251         { 
    252                 if (!nodeInfo || (nodeInfo->GetNode() != (*visibleNodesIt).GetNode())) 
    253                 { 
    254                         nodeInfo = &(*visibleNodesIt); 
    255                 } 
    256                 else // add visibility 
    257                 {                        
    258                         nodeInfo->AddVisibility(*visibleNodesIt); 
    259                 } 
    260  
    261         } 
    262          
    263         // physically delete duplicates 
    264         visibleNodes->erase( std::unique(visibleNodes->begin(),  
    265                 visibleNodes->end(), nodeinfo_eq), visibleNodes->end()); 
    266  
    267         // --- visible geometry 
    268         sort(visibleGeometry->begin(), visibleGeometry->end(), meshinfo_lower); 
    269         InfoContainer<GtpVisibility::MeshInfo>::iterator visibleGeomIt, 
    270                 visibleGeomIt_end = visibleGeometry->end(); 
    271  
    272         GtpVisibility::MeshInfo *geomInfo = NULL; 
    273  
    274         int i=0; 
    275         for (visibleGeomIt = visibleGeometry->begin(); visibleGeomIt != visibleGeomIt_end;  
    276                 ++visibleGeomIt) 
    277         { 
    278                 if (!geomInfo || (geomInfo->GetMesh() != (*visibleGeomIt).GetMesh())) 
    279                 { 
    280                         geomInfo = &(*visibleGeomIt); 
    281                 } 
    282                 else // info points to same mesh, just add visibility 
    283                 { 
    284                         geomInfo->AddVisibility(*visibleGeomIt); 
    285                 } 
    286         } 
    287  
    288         // physically delete duplicates 
    289         visibleGeometry->erase(std::unique(visibleGeometry->begin(), visibleGeometry->end(),  
    290                 meshinfo_eq), visibleGeometry->end()); 
    291          
    29274} 
    29375//----------------------------------------------------------------------- 

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

    r139 r154  
    147147                MovableObject *movable = objIt.getNext(); 
    148148                 
    149                 // we are interested only in the entities, i.e., intances of geometry 
     149                // we are interested only in the entities, i.e., instances of geometry 
    150150                if (movable->getMovableType() == "Entity") 
    151151                { 
    … …  
    156156    } 
    157157} 
     158//----------------------------------------------------------------------- 
     159void SceneNodeHierarchyInterface::SetNodeId(GtpVisibility::HierarchyNode *node, int id) 
     160{ 
     161        static_cast<SceneNode *>(node)->setId(id); 
     162} 
     163//----------------------------------------------------------------------- 
     164int SceneNodeHierarchyInterface::GetNodeId(GtpVisibility::HierarchyNode *node) 
     165{ 
     166        return static_cast<SceneNode *>(node)->getId(); 
     167} 
    158168} // namespace Ogre      

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

    r139 r154  
    259259        mHierarchyInterface->SetRenderSystem(mDestRenderSystem); 
    260260 
    261 #ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    262     mHierarchyInterface->SetNumOctreeNodes(mNumOctreeNodes); 
    263 #endif 
    264261        OctreeSceneManager::_updateSceneGraph(cam); 
    265262} 

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

    r153 r154  
    2424mUseDepthPass(false), 
    2525mRenderDepthPass(false), 
    26 //mUseItemBuffer(false), 
    27 mUseItemBuffer(true), 
     26mUseItemBuffer(false), 
     27//mUseItemBuffer(true), 
    2828mRenderItemBuffer(false), 
    29 mCurrentEntityId(0), 
     29mCurrentEntityId(1), 
    3030mEnableDepthWrite(true), 
    3131mSkipTransparents(false), 
    … …  
    327327                 
    328328        // set the new render level index afterwards => new level in the next frame  
    329         int levelIdx = (TerrainRenderable::getCurrentRenderLevelIndex() + 1) % 10; 
     329        int levelIdx = TerrainRenderable::getCurrentRenderLevelIndex() + 1; 
    330330        TerrainRenderable::setCurrentRenderLevelIndex(levelIdx); 
    331331 
    … …  
    343343        mHierarchyInterface->SetRenderSystem(mDestRenderSystem); 
    344344 
    345 #ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    346     mHierarchyInterface->SetNumOctreeNodes(mNumOctreeNodes); 
    347 #endif 
    348345        TerrainSceneManager::_updateSceneGraph(cam); 
    349346} 
    … …  
    567564        int col[4]; 
    568565         
     566        // -- create color code out of object id 
    569567        col[0] = (rend->getId() >> 16) & 255; 
    570568        col[1] = (rend->getId() >> 8) & 255; 
    … …  
    599597 
    600598        Pass *usedPass = setPass(mItemBufferPass);  
    601         //Pass *usedPass = setPass(pass); 
    602          
    603         if (rend->getId() > 0) 
     599         
     600        /*if (rend->getId() > 0) 
    604601        { 
    605602                std::stringstream d; d << "item buffer id: " << rend->getId() << ", col: " << col[0] << 
    606603                        " " << col[1] << " " << col[2] << " " << col[3]; 
    607604                LogManager::getSingleton().logMessage(d.str()); 
    608         } 
     605        }*/ 
    609606 
    610607        // Render a single object, this will set up auto params if required 
    611608        renderSingleObject(rend, usedPass, false, &nullLightList); 
    612  
    613         // reset colour 
    614         //mDestRenderSystem->setColour(255, 255, 255, 255); 
    615609} 
    616610//----------------------------------------------------------------------- 
    … …  
    630624        } 
    631625 
     626        // increase counter of entity id values 
    632627        ++ mCurrentEntityId; 
    633628 

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

    r153 r154  
    99#include "OgreVisibilityTerrainSceneManager.h" 
    1010#include "VisibilityInfo.h" 
    11 #include "OgreItemBufferQueryManager.h"; 
     11#include "OgreItemBufferQueryManager.h" 
     12#include "OgreOcclusionQueriesQueryManager.h" 
     13 
     14 
     15 
     16 
    1217// output file for frame info 
    1318const char* frames_out_filename = "frame.out"; 
    … …  
    1621 
    1722 
     23// --- captions for overlays 
     24 
    1825String currentAlgorithmCaptions[GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS] =  
    1926{ 
    … …  
    2330}; 
    2431 
    25 String queryTypeCaptions[4] =  
    26 { 
    27         "from camera, visible pixels",  
    28         "from viewpoint, visible pixels",  
    29         "from camera, relative visibility", 
    30         "from viewpoint, relative visibility" 
     32String queryTypeCaptions[] =  
     33{ 
     34        "from camera",  
     35        "from viewpoint" 
     36}; 
     37 
     38String queryRelativeVisCaptions[] =  
     39{ 
     40        "visible pixels",  
     41        "relative visibility" 
     42}; 
     43 
     44String queryMethodCaptions[] =  
     45{ 
     46        "occlusion queries",  
     47        "item buffer" 
    3148}; 
    3249 
    … …  
    360377} 
    361378//----------------------------------------------------------------------- 
    362 void TerrainFrameListener::ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility) 
     379void TerrainFrameListener::ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility,  
     380                                                                                                bool useItemBuffer) 
    363381{ 
    364382        // TODO: change this (does not work with other scene manager plugins) 
    365         VisibilityTerrainSceneManager *sm = dynamic_cast<VisibilityTerrainSceneManager *>(mSceneMgr); 
    366  
    367         mQueryManager = new ItemBufferQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0)); 
    368         //mQueryManager = new PlatformQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0)); 
     383        VisibilityTerrainSceneManager *sm =  
     384                dynamic_cast<VisibilityTerrainSceneManager *>(mSceneMgr); 
     385 
     386        if (useItemBuffer) 
     387        { 
     388                mQueryManager = new ItemBufferQueryManager(sm->GetHierarchyInterface(),  
     389                        mWindow->getViewport(0)); 
     390        } 
     391        else 
     392        { 
     393                mQueryManager = new OcclusionQueriesQueryManager(sm->GetHierarchyInterface(),  
     394                        mWindow->getViewport(0)); 
     395        } 
    369396 
    370397        sm->GetVisibilityManager()->SetQueryManager(mQueryManager); 
    … …  
    403430                        ++geomSize; 
    404431                         
    405                         std::stringstream d; d << "Geometry visibility: " << vis; 
     432                        std::stringstream d; d << "Geometry " << geomSize << " visibility: " << vis; 
    406433                        LogManager::getSingleton().logMessage(d.str()); 
    407434                } 
    … …  
    431458                averageGeometryVis /= (float)geomSize; 
    432459 
    433         char str[100]; 
    434  
    435460        //-- update visibility queries stats 
    436461    try  
    437462        { 
    438                 //-- visibility queries stats 
    439                 int idx = fromPoint ?  1 : 0; 
    440                 idx += relativeVisibility ? 2 : 0; 
    441  
    442                 sprintf(str, ": %s", queryTypeCaptions[idx].c_str());  
     463                char str[100]; 
     464                 
     465                sprintf(str, ": %s, %s, %s",  
     466                                queryTypeCaptions[fromPoint ?  1 : 0].c_str(), 
     467                                queryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str(), 
     468                                queryMethodCaptions[useItemBuffer ? 1 : 0].c_str()); 
     469 
    443470                mQueryTypeInfo->setCaption(str); 
    444471 
    … …  
    912939                break; 
    913940        case KC_F5: 
    914                 ApplyVisibilityQuery(false, mShiftPressed); 
     941                ApplyVisibilityQuery(false, mShiftPressed, false); 
    915942                break; 
    916943        case KC_F6: 
    917                 ApplyVisibilityQuery(true, mShiftPressed); 
    918                 break; 
    919  
     944                ApplyVisibilityQuery(true, mShiftPressed, false); 
     945                break; 
     946        case KC_F7: 
     947                ApplyVisibilityQuery(false, mShiftPressed, true); 
     948                break; 
     949        case KC_F8: 
     950                ApplyVisibilityQuery(true, mShiftPressed, true); 
     951                break; 
    920952        case KC_F11: 
    921953                takeScreenShot(); 

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

    r151 r154  
    117117        /** Applies visibility query. Collects the visible objects  
    118118                and their visibility information. 
    119                 @param fromnPoint if query should be from point or from camera 
    120                 @param projectedPixels if query should return number of visible pixels or the ratio 
    121                 visible pixels / projected pixels. 
     119                @param fromPoint if query should be from point or from camera 
     120                @param relativeVisibility if query should return number of visible pixels or  
     121                the ratio visible / projected pixels. 
     122                @param useItemBuffer if item buffer should be used or occlusion queries 
    122123        */ 
    123         void ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility); 
     124        void ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility, bool useItemBuffer); 
    124125 
    125126        void toggleShowQueryStats(); 

  • trunk/VUT/work/ogre_changes/OgreMain/include/OgreSceneNode.h

    r61 r154  
    444444                void setLastRendered(int frameid); 
    445445 
     446                /** Sets scene node id  
     447                @param the id 
     448                */ 
     449                void setId(int id); 
     450                /** see set */ 
     451                int getId(void); 
     452 
    446453        protected: 
    447454                int mLastVisited; 
    448455                bool mVisible; 
    449456                int mLastRendered; 
    450  
     457                int mId; 
    451458#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    452459 

  • trunk/VUT/work/ogre_changes/OgreMain/src/OgreSceneNode.cpp

    r61 r154  
    4242        mYawFixed(false), mAutoTrackTarget(0), mIsInSceneGraph(false) 
    4343#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    44         , mLastVisited(0), mVisible(false), mLastRendered(-1) 
     44        , mLastVisited(0), mVisible(false), mLastRendered(-1), mId(-1) 
    4545#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    4646    { 
    … …  
    5353        mAutoTrackTarget(0), mIsInSceneGraph(false) 
    5454        #ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    55         , mLastVisited(0), mVisible(false) 
     55        , mLastVisited(0), mVisible(false), mId(-1) 
    5656        #endif //GTP_VISIBILITY_MODIFIED_OGRE 
    5757    { 
    … …  
    641641                mLastRendered = frameid; 
    642642        } 
     643        //----------------------------------------------------------------------- 
     644        void SceneNode::setId(int id) 
     645        { 
     646                mId = id; 
     647        } 
     648        //----------------------------------------------------------------------- 
     649        int SceneNode::getId(void) 
     650        { 
     651                return mId; 
     652        } 
    643653        #endif //GTP_VISIBILITY_MODIFIED_OGRE 
    644654} 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/include/OgreOctree.h

    r135 r154  
    192192        void _updateBounds(); 
    193193 
     194        /** Sets scene node id  
     195        @param the id 
     196        */ 
     197        void setId(int id); 
     198         
     199        /** see set */ 
     200        int getId(void); 
     201 
    194202protected: 
    195203         
    … …  
    201209        bool mVisible; 
    202210        int mDepth; 
     211        int mId; 
    203212 
    204213#endif // GTP_VISIBILITY_MODIFIED_OGRE 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/include/OgreTerrainRenderable.h

    r131 r154  
    4747 
    4848#define MORPH_CUSTOM_PARAM_ID 77 
     49 
     50#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     51#define MAX_RENDERLEVEL_INDEX 15 
     52#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    4953 
    5054namespace Ogre 
    … …  
    293297        /// Get the static list of indexes cached (internal use only) 
    294298        static TerrainBufferCache& _getIndexCache(void) {return msIndexCache;} 
    295                 // index of renderlevel of current pass 
    296                 static int getCurrentRenderLevelIndex() {return msCurrentRenderLevelIndex;} 
    297                 static void setCurrentRenderLevelIndex(int index) {msCurrentRenderLevelIndex = index;} 
     299 
     300#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     301                // index of renderlevel used for current pass 
     302                static int getCurrentRenderLevelIndex(); 
     303                // returns index of renderlevel 
     304                static void setCurrentRenderLevelIndex(int index); 
     305#endif // GTP_VISIBILITY_MODIFIED_OGRE 
     306 
    298307    protected: 
    299308                // index of renderlevel of current pass 
    … …  
    355364        VertexData* mTerrain; 
    356365 
    357         /// The current LOD level: for multiple passes, up to 10 renderlevels can be saved 
    358         int mRenderLevel[10]; 
     366        /// The current LOD level 
     367#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     368        int mRenderLevel[MAX_RENDERLEVEL_INDEX]; 
     369#else 
     370                int mRenderLevel; 
     371#endif // GTP_VISIBILITY_MODIFIED_OGRE 
     372 
    359373        /// The previous 'next' LOD level down, for frame coherency 
    360374        int mLastNextLevel;  

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctree.cpp

    r139 r154  
    8888      mHalfSize( 0, 0, 0 ) 
    8989#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    90         , mLastVisited(0), mVisible(false), mLastRendered(-1) 
     90        , mLastVisited(0), mVisible(false), mLastRendered(-1), mId(-1) 
    9191#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    9292{ 
    … …  
    271271        } 
    272272 } 
     273//----------------------------------------------------------------------- 
     274void Octree::setId(int id) 
     275{ 
     276        mId = id; 
     277} 
     278//----------------------------------------------------------------------- 
     279int Octree::getId() 
     280{ 
     281        return mId; 
     282} 
    273283#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    274284} 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctreeSceneManager.cpp

    r139 r154  
    318318#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    319319        mNumOctreeNodes = 1; 
     320        mOctree->setId(mNumOctreeNodes); 
    320321#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    321322    mMaxDepth = depth; 
    … …  
    468469            octant -> mChildren[ x ][ y ][ z ] = new Octree( octant ); 
    469470#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    470         mNumOctreeNodes ++; 
     471        mOctree->setId(++ mNumOctreeNodes); 
    471472#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    472473 
    … …  
    10321033#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    10331034        mNumOctreeNodes = 1; 
     1035        mOctree->setId(mNumOctreeNodes); 
    10341036#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    10351037    mOctree->mBox = box; 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreTerrainRenderable.cpp

    r139 r154  
    5858    bool TerrainRenderable::mLevelInit = false; 
    5959    const TerrainOptions* TerrainRenderable::msOptions = 0; 
     60 
     61#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    6062        int TerrainRenderable::msCurrentRenderLevelIndex = 0; 
     63#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    6164    //----------------------------------------------------------------------- 
    6265    //----------------------------------------------------------------------- 
    … …  
    177180        mInit = true; 
    178181 
    179 //#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    180                 // for up to 10 passes 
    181                 for (int i = 0; i < 10; ++i) 
     182#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     183                for (int i = 0; i < MAX_RENDERLEVEL_INDEX; ++i) 
    182184                { 
    183185                        mRenderLevel[i] = 1; 
    184186                } 
     187#else 
     188                mRenderLevel = 1; 
     189#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    185190 
    186191        mMinLevelDistSqr = new Real[ msOptions->maxGeoMipMapLevel ]; 
    … …  
    330335        if ( mForcedRenderLevel >= 0 ) 
    331336        { 
     337#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    332338            mRenderLevel[msCurrentRenderLevelIndex] = mForcedRenderLevel; 
     339#else 
     340                        mRenderLevel = mForcedRenderLevel; 
     341#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    333342            return ; 
    334343        } 
    … …  
    339348        Real L = diff.squaredLength(); 
    340349 
    341                 mRenderLevel[msCurrentRenderLevelIndex] = -1; 
     350#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     351            mRenderLevel[msCurrentRenderLevelIndex] = -1;; 
     352#else 
     353                        mRenderLevel = -1; 
     354#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    342355 
    343356        for ( int i = 0; i < msOptions->maxGeoMipMapLevel; i++ ) 
    … …  
    345358            if ( mMinLevelDistSqr[ i ] > L ) 
    346359            { 
     360#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    347361                mRenderLevel[msCurrentRenderLevelIndex] = i - 1; 
     362#else 
     363                        mRenderLevel = i - 1; 
     364#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    348365                break; 
    349366            } 
    350367        } 
    351368 
     369#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    352370        if ( getRenderLevel() < 0 ) 
    353371            mRenderLevel[msCurrentRenderLevelIndex] = msOptions->maxGeoMipMapLevel - 1; 
     372#else 
     373                if ( mRenderLevel < 0 ) 
     374            mRenderLevel = msOptions->maxGeoMipMapLevel - 1; 
     375#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    354376 
    355377        if (msOptions->lodMorph) 
    356378        { 
    357379            // Get the next LOD level down 
     380#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    358381            int nextLevel = mNextLevelDown[getRenderLevel()]; 
     382#else 
     383                        int nextLevel = mNextLevelDown; 
     384#endif // GTP_VISIBILITY_MODIFIED_OGRE 
     385             
    359386            if (nextLevel == 0) 
    360387            { 
    … …  
    668695    void TerrainRenderable::_adjustRenderLevel( int i ) 
    669696    { 
    670  
     697#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    671698        mRenderLevel[msCurrentRenderLevelIndex] = i; 
     699#else 
     700                mRenderLevel = i; 
     701#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    672702    } 
    673703    //----------------------------------------------------------------------- 
    … …  
    14691499 
    14701500    } 
    1471  
     1501#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     1502        //----------------------------------------------------------------------- 
     1503        int TerrainRenderable::getCurrentRenderLevelIndex()  
     1504        { 
     1505                return msCurrentRenderLevelIndex; 
     1506        } 
     1507        //----------------------------------------------------------------------- 
     1508        void TerrainRenderable::setCurrentRenderLevelIndex(int index) 
     1509        { 
     1510                if (index > MAX_RENDERLEVEL_INDEX) 
     1511                        index = 0; 
     1512 
     1513                msCurrentRenderLevelIndex = index; 
     1514        } 
     1515#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    14721516 
    14731517} //namespace 

  • trunk/VUT/work/ogre_changes/RenderSystems/Direct3D9/include/OgreD3D9Texture.h

    r153 r154  
    311311 
    312312#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    313                 uchar *getBufferContents(int &dimx, int &dimy) { return NULL; }; 
     313                uchar *getBufferContents(int &dimx, int &dimy) { dimx = dimy = 0; return NULL; }; 
    314314#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    315315 
Note: See TracChangeset for help on using the changeset viewer.