Changeset 175


Ignore:
Timestamp:
07/14/05 20:54:07 (19 years ago)
Author:
mattausch
Message:

added trees

Location:
trunk/VUT
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/VUT/GtpVisibility/include/HierarchyInterface.h

    r174 r175  
    4747                @returns occlusion query for this node 
    4848        */ 
    49         virtual OcclusionQuery *IssueOcclusionQuery(HierarchyNode *node,  
     49        virtual OcclusionQuery *IssueNodeOcclusionQuery(HierarchyNode *node,  
    5050                const bool wasVisible = false) = 0; 
    5151        /** Sets the root of the scene hierarchy. 
     
    124124                CullingType type) = NULL; 
    125125 
    126         /** Returns vector of previously rendered hierarchy nodes. 
     126        /** Returns vector of visible hierarchy nodes from previous render. 
    127127        */ 
    128128        std::vector<HierarchyNode *> *GetVisibleNodes(); 
     
    130130        */ 
    131131         
    132         /** Issue a occlusion query for this mesh. 
    133                 @param node the current mesh 
    134                 @returns occlusion query for this node 
    135         */ 
    136         virtual GtpVisibility::OcclusionQuery *IssueOcclusionQuery(GtpVisibility::Mesh *mesh) = 0; 
    137  
    138132        /** Returns the geometry of a given hierarchy node.  
    139133                @param node the hierarchy node containing the geometry 
     
    144138                                                         GeometryList *geometryList,  
    145139                                                         bool includeChildren) = 0; 
    146  
    147  
    148         /** Renders the given geometry. 
    149         */ 
    150         virtual void RenderGeometry(GtpVisibility::Mesh *geom) = 0; 
    151140 
    152141         
     
    159148        */ 
    160149        void TestGeometryForVisibleLeaves(bool testGeometry); 
    161  
    162150 
    163151 
  • trunk/VUT/GtpVisibility/include/VisibilityEnvironment.h

    r74 r175  
    1313        /** Different types of occlusion culling algorithms  
    1414        */ 
    15         enum CullingManagerType {FRUSTUM_CULLING,  
     15        enum CullingManagerType { 
     16                                                         COHERENT_HIERARCHICAL_CULLING,  
     17                                                         FRUSTUM_CULLING,  
    1618                                                         STOP_AND_WAIT_CULLING,  
    17                                                          COHERENT_HIERARCHICAL_CULLING,  
    1819                                                         NUM_CULLING_MANAGERS}; 
    1920 
  • trunk/VUT/GtpVisibility/src/CoherentHierarchicalCullingManager.cpp

    r158 r175  
    2525        unsigned int visiblePixels = 0; 
    2626        bool isAvailable = false; 
    27          
     27        //Ogre::LogManager::getSingleton().logMessage("Coherent Hierarchical Culling"); 
     28 
    2829        //-- PART 1: process finished occlusion queries 
    2930        while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty()) 
     
    105106                                         
    106107                                        queryQueue.push(QueryPair(node, mHierarchyInterface-> 
    107                                                 IssueOcclusionQuery(node, wasVisible))); 
     108                                                IssueNodeOcclusionQuery(node, wasVisible))); 
    108109                                } 
    109110                                 
  • trunk/VUT/GtpVisibility/src/FrustumCullingManager.cpp

    r158 r175  
    77void FrustumCullingManager::RenderScene() 
    88{ 
     9        //Ogre::LogManager::getSingleton().logMessage("Frustum Culling"); 
    910        while (!mHierarchyInterface->GetQueue()->empty()) 
    1011        { 
  • trunk/VUT/GtpVisibility/src/StopAndWaitCullingManager.cpp

    r158 r175  
    77void StopAndWaitCullingManager::RenderScene() 
    88{ 
     9        //Ogre::LogManager::getSingleton().logMessage("Stop and Wait Culling"); 
    910        while (!mHierarchyInterface->GetQueue()->empty()) 
    1011        { 
     
    4041                        unsigned int visiblePixels = 0; 
    4142 
    42                         mHierarchyInterface->IssueOcclusionQuery(node)->GetQueryResult(visiblePixels, true); 
     43                        mHierarchyInterface->IssueNodeOcclusionQuery(node)->GetQueryResult(visiblePixels, true); 
    4344                         
    4445                        // node visible 
  • trunk/VUT/Ogre/include/OgrePlatformHierarchyInterface.h

    r174 r175  
    7575                @returns occlusion query for this node 
    7676        */ 
    77         GtpVisibility::OcclusionQuery *IssueOcclusionQuery( 
     77        GtpVisibility::OcclusionQuery *IssueNodeOcclusionQuery( 
    7878                GtpVisibility::HierarchyNode *node, const bool wasVisible); 
    7979 
    8080        /** Issue a occlusion query for this mesh. 
    81                 @param node the current mesh 
    82                 @returns occlusion query for this node 
     81                @param mesh the mesh for which an occlusion query is issued. 
     82                @returns occlusion query for this mesh. 
    8383        */ 
    84         GtpVisibility::OcclusionQuery *IssueOcclusionQuery(GtpVisibility::Mesh *mesh); 
     84        GtpVisibility::OcclusionQuery *IssueMeshOcclusionQuery(GtpVisibility::Mesh *mesh); 
    8585 
    8686        /** If true, the interface finds and renders only objects which are marked as shadow casters. 
     
    106106    bool IsBoundingBoxQuery(); 
    107107 
    108         GtpVisibility::OcclusionQuery *IssueOcclusionQuery(GtpVisibility::Patch *patch); 
     108        GtpVisibility::OcclusionQuery *IssuePatchOcclusionQuery(GtpVisibility::Patch *patch); 
    109109 
    110110protected: 
    111         /** Renders geometry  
     111        /** Renders the given geometry  
    112112        */ 
    113113        void RenderGeometry(GtpVisibility::Mesh *geom); 
    114  
    115         /** Renders a patch  
     114         
     115        /** Renders the given patch  
    116116        */ 
    117117        void RenderPatch(GtpVisibility::Patch *patch); 
  • trunk/VUT/Ogre/src/OgreOcclusionQueriesQueryManager.cpp

    r174 r175  
    6868 
    6969        //-- render scene with item buffer (i.e., objects with their id as color codes) 
     70//mItemBufferMode = 0; 
    7071        if ((mItemBufferMode && mQueryModes) != 0) 
    7172        { 
     
    104105    GtpVisibility::HierarchyNodeList nodeList; 
    105106 
    106         if (mQueryModes && NODE_VISIBILITY) 
     107        if (mQueryModes & NODE_VISIBILITY) 
    107108        { 
    108109                for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++visNodesIt) 
     
    118119         
    119120        // store geometry of the hierarchy nodes in a geometry list 
    120         if (mQueryModes && GEOMETRY_VISIBILITY) 
     121        if (mQueryModes & GEOMETRY_VISIBILITY) 
    121122        {        
    122123                for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++visNodesIt)         
     
    133134 
    134135        // store patchges of the geometries in a patch list 
    135         if (mQueryModes && PATCH_VISIBILITY) 
     136        if (mQueryModes & PATCH_VISIBILITY) 
    136137        { 
    137138                for (visNodesIt = visNodes->begin(); visNodesIt != visNodesIt_end; ++visNodesIt)         
     
    159160        // for relative visibility we need 2 rendering passes 
    160161        int n = relativeVisibility ? 2 : 1; 
    161          
     162        if (mItemBufferMode > 0) 
     163                LogManager::getSingleton().logMessage("item buffer"); 
     164 
    162165        for (int i = 0; i < n; ++i) 
    163166        { 
     
    166169                { 
    167170                        // TODO: DELETE QUERIES FROM PREVIOUS RENDER 
    168                         queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*nodeIt, false)); 
     171                        queryList[i].push_back(mHierarchyInterface->IssueNodeOcclusionQuery(*nodeIt, false)); 
    169172                } 
    170173 
    171174                //-- queries for geometry: if item buffer, capture only projected visibility 
    172175                if ((mItemBufferMode != GEOMETRY_VISIBILITY) || (i == 1)) 
    173                 { 
     176                {                        
    174177                        for (geometryIt = geometryList.begin(); geometryIt != geometryIt_end; ++geometryIt) 
    175178                        { 
    176                                 queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*geometryIt)); 
     179                                queryList[i].push_back(pfHierarchyInterface->IssueMeshOcclusionQuery(*geometryIt)); 
    177180                        } 
    178181                } 
     
    183186                        for (patchIt = patchList.begin(); patchIt != patchIt_end; ++patchIt) 
    184187                        { 
    185                                 queryList[i].push_back(mHierarchyInterface->IssueOcclusionQuery(*patchIt)); 
     188                                queryList[i].push_back(pfHierarchyInterface->IssuePatchOcclusionQuery(*patchIt)); 
    186189                        } 
    187190                } 
     
    199202 
    200203 
    201  
    202204        // collect occlusion queries for geometry 
    203205        if ((mItemBufferMode == GEOMETRY_VISIBILITY) && relativeVisibility) 
     
    207209                CollectRelativeGeometryVisibilityForItemBuffer(projQueryIt, &geometryList, visibleGeometry); 
    208210        } 
    209         else 
     211        else if (mItemBufferMode != GEOMETRY_VISIBILITY) 
    210212        { 
    211213                CollectGeometryVisibility(visQueryIt, projQueryIt, &geometryList, visibleGeometry,  
     
    219221                CollectRelativePatchVisibilityForItemBuffer(projQueryIt, &patchList, visiblePatches); 
    220222        } 
    221         else 
     223        else if (mItemBufferMode != PATCH_VISIBILITY) 
    222224        { 
    223225                CollectPatchVisibility(visQueryIt, projQueryIt, &patchList, visiblePatches, relativeVisibility); 
     
    244246                visibleGeometry, visiblePatches, relativeVisibility); 
    245247 
    246         // remove duplicates (duplicates occur if an object is on the edge of the viewport) 
    247         // before duplicates can be deleted we have to add up their visibility 
     248        // adds up their visibility and removes duplicates  
     249        // (duplicates occur if an object is on the edge of the viewport) 
    248250        RemoveDuplicateNodes(visibleNodes); 
    249251         
     
    258260        } 
    259261} 
    260 //----------------------------------------------------------------------- 
     262//------j----------------------------------------------------------------- 
    261263void  OcclusionQueriesQueryManager::CollectNodeVisibility( 
    262264                                                GtpVisibility::QueryList::iterator &visQueryIt,  
  • trunk/VUT/Ogre/src/OgrePlatformHierarchyInterface.cpp

    r174 r175  
    165165} 
    166166//----------------------------------------------------------------------- 
    167 GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery( 
     167GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueNodeOcclusionQuery( 
    168168        GtpVisibility::HierarchyNode *node, const bool wasVisible)  
    169169{ 
     
    200200} 
    201201//----------------------------------------------------------------------- 
    202 GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery( 
     202GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssuePatchOcclusionQuery( 
    203203        GtpVisibility::Patch *patch) 
    204204{ 
     
    216216} 
    217217//----------------------------------------------------------------------- 
    218 GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery( 
     218GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueMeshOcclusionQuery( 
    219219        GtpVisibility::Mesh *mesh) 
    220220{ 
     
    287287void PlatformHierarchyInterface::RenderPatch(GtpVisibility::Patch *patch) 
    288288{ 
    289         Pass *pass = patch->getTechnique()->getPass(0); 
    290         mSceneManager->setPass(pass); 
    291         mSceneManager->renderSingleObject(patch, pass, false); 
     289        mSceneManager->_renderSingleRenderable(patch); 
    292290} 
    293291//----------------------------------------------------------------------- 
  • trunk/VUT/Ogre/src/OgreSceneContentGenerator.cpp

    r160 r175  
    2929void SceneContentGenerator::GenerateScene(int numObjects, const String &objName) 
    3030{ 
    31         // initialise random generator 
    32         srand (time(0)); 
    33          
    34         Vector3 rotationRatio; 
    35         Vector3 translationRatio; 
    36  
    3731        int new_size = GetObjectCount() + numObjects; 
    3832        int failed_attempts = 0; // counter used to avoid invinite loop 
     
    4236                   (failed_attempts < MAX_FAILED_ATTEMPTS)) 
    4337        { 
    44                 rotationRatio.x = rand() / (float) RAND_MAX; 
    45                 rotationRatio.y = rand() / (float) RAND_MAX; 
    46                 rotationRatio.z = rand() / (float) RAND_MAX; 
    47  
    48                 translationRatio.x = rand() / (float) RAND_MAX; 
    49                 translationRatio.y = rand() / (float) RAND_MAX; 
    50                 translationRatio.z = rand() / (float) RAND_MAX; 
    51  
    5238                // Setup the ray scene query 
    53                 Vector3 rotation = mMinAngle + rotationRatio * (mMaxAngle - mMinAngle); 
    54                 Vector3 position = mMinPos + translationRatio * (mMaxPos - mMinPos); 
     39                Vector3 rotation = Vector3(Math::RangeRandom(mMinAngle.x, mMaxAngle.x), 
     40                                                                   Math::RangeRandom(mMinAngle.y, mMaxAngle.y), 
     41                                                                   Math::RangeRandom(mMinAngle.z, mMaxAngle.z)); 
     42 
     43                Vector3 position = Vector3(Math::RangeRandom(mMinPos.x, mMaxPos.x), 
     44                                                                   Math::RangeRandom(mMinPos.y, mMaxPos.y), 
     45                                                                   Math::RangeRandom(mMinPos.z, mMaxPos.z)); 
    5546 
    5647                // failed to generate new object 
    5748                if (!GenerateSceneObject(position, rotation, objName)) 
    58                         ++failed_attempts;  
     49                        ++ failed_attempts;  
    5950        } 
    6051} 
     
    6859                 
    6960        Entity *ent = mSceneMgr->createEntity(name, objName + ".mesh"); 
    70                  
     61        ent->setCastShadows(true); 
     62 
    7163        SceneNode *node = mSceneMgr->getRootSceneNode()-> 
    7264                createChildSceneNode(String(name) + "Node", position); 
     
    8072        mSceneNodes.push_back(node); 
    8173        mEntities.push_back(ent); 
    82  
     74         
    8375        return node; 
    8476} 
  • trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp

    r174 r175  
    237237void VisibilityOctreeSceneManager::_renderVisibleObjects() 
    238238{ 
     239        InitDepthPass();          // create material for depth pass 
     240        InitItemBufferPass(); // create material for item buffer pass 
     241 
    239242        // save ambient light to reset later 
    240243        ColourValue savedAmbient = mAmbientLight; 
     
    629632void VisibilityOctreeSceneManager::InitVisibilityCulling(Camera *cam) 
    630633{ 
    631         InitDepthPass();          // create material for depth pass 
    632         InitItemBufferPass(); // create material for item buffer pass 
    633  
    634634        // reset culling manager stats 
    635635        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
  • trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

    r174 r175  
    240240void VisibilityTerrainSceneManager::_renderVisibleObjects() 
    241241{ 
     242        InitDepthPass();          // create material for depth pass 
     243        InitItemBufferPass(); // create material for item buffer pass 
     244 
    242245        // save ambient light to reset later 
    243246        ColourValue savedAmbient = mAmbientLight; 
     
    629632void VisibilityTerrainSceneManager::InitVisibilityCulling(Camera *cam) 
    630633{ 
    631         InitDepthPass();          // create material for depth pass 
    632         InitItemBufferPass(); // create material for item buffer pass 
    633  
    634634        // reset culling manager stats 
    635635        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp

    r174 r175  
    1616String TerrainFrameListener::msAlgorithmCaptions[] =  
    1717{ 
     18        "Coherent Hierarchical Culling", 
    1819        "View Frustum Culling",  
    19         "Stop and Wait Culling",  
    20         "Coherent Hierarchical Culling" 
     20        "Stop and Wait Culling" 
    2121}; 
    2222 
     
    4242{ 
    4343        0, 
    44         7, 
     44        0, 
     45        //7, 
    4546        0 
    4647}; 
     
    4950{ 
    5051        0.1, 
    51         0.6, 
    52         0.07 
     52        0.03, 
     53        //0.1, 
     54        0.04 
    5355}; 
    5456 
     
    5658{ 
    5759        "robot", 
    58         "athene", 
     60        //"athene", 
     61        "natFX_Tree1_LOD2", 
    5962        //"tree2", 
    6063        //"HongKong_Tower", 
     
    111114mShowOctree(false), 
    112115mUseDepthPass(false), 
    113 mTestGeometryForVisibleLeaves(true), 
     116mTestGeometryForVisibleLeaves(false), 
    114117mShowVisualization(false), 
    115118mCullCamera(false), 
     
    426429        int itemBufferMode = useItemBuffer ? mItemBufferMode : 0; 
    427430         
    428         int queryModes = GtpVisibility::QueryManager::PATCH_VISIBILITY;  
     431        int queryModes = 0; 
     432        queryModes |= GtpVisibility::QueryManager::PATCH_VISIBILITY;  
    429433        queryModes |= GtpVisibility::QueryManager::GEOMETRY_VISIBILITY; 
    430434        queryModes |= GtpVisibility::QueryManager::NODE_VISIBILITY; 
    431  
     435         
    432436        mQueryManager = new OcclusionQueriesQueryManager(sm->GetHierarchyInterface(), 
    433                         mWindow->getViewport(0), queryModes, useItemBuffer); 
     437                        mWindow->getViewport(0), queryModes, itemBufferMode); 
    434438 
    435439        //mQueryManager = new PlatformQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0), false); 
     
    455459                 
    456460        std::stringstream d;  
    457         d << msQueryTypeCaptions[fromPoint ?  1 : 0].c_str() << " " 
     461        d << "Query mode: " << queryModes << ", " 
     462          << msQueryTypeCaptions[fromPoint ?  1 : 0].c_str() << " " 
    458463          << msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str() << " " 
    459464      << msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str(); 
     
    744749{ 
    745750        mCurrentAlgorithm = (mCurrentAlgorithm + 1) %  
    746                 GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS, 
    747  
     751                (GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS - 1); 
    748752        setAlgorithm(mCurrentAlgorithm); 
    749753} 
  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp

    r173 r175  
    228228{ 
    229229        // Set ambient light 
    230         mAmbientLight = ColourValue(0.5, 0.5, 0.5); 
     230        mAmbientLight = ColourValue(0.5 , 0.5, 0.5); 
    231231        mSceneMgr->setAmbientLight(mAmbientLight); 
    232232         
     
    256256         
    257257        // Create a skybox 
    258         mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", 5000, false); 
     258        mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox", 5000, true); 
    259259         
    260260        std::string terrain_cfg("terrain.cfg"); 
     
    301301        if (!mTerrainContentGenerator->LoadObjects("objects.out")) 
    302302        { 
    303                 // to provide much occlusion, 
    304                 // height is restricted to 50 => no objects are created on peaks 
    305                 mTerrainContentGenerator->SetMinPos(Vector3(mTerrainMinPos)); 
    306                 mTerrainContentGenerator->SetMaxPos(Vector3(mTerrainMaxPos.x, 50.0f, mTerrainMaxPos.z)); 
    307                 mTerrainContentGenerator->SetOffset(0); 
    308  
    309303                // the objects are generated randomly distributed over the terrain 
    310                 generateScene(1500, 0); 
     304                generateScene(900, 0); 
     305                generateScene(500, 1); 
     306                generateScene(100, 2); 
     307        } 
     308 
     309        // no limitations on height => it is possible for the user to put single  
     310        // objects on peaks of the terrain (only few, not relevant for occlusion) 
     311        mTerrainContentGenerator->SetMaxPos(mTerrainMaxPos); 
     312} 
     313//----------------------------------------------------------------------- 
     314void  TestCullingTerrainApplication::generateScene(int num, int objectType) 
     315{ 
     316        Vector3 scale(TerrainFrameListener::msObjectScales[objectType],  
     317                                  TerrainFrameListener::msObjectScales[objectType], 
     318                                  TerrainFrameListener::msObjectScales[objectType]); 
     319 
     320        // to provide much occlusion, 
     321        // height is restricted to 50 => no objects are created on peaks 
     322        mTerrainContentGenerator->SetMinPos(Vector3(mTerrainMinPos)); 
     323        mTerrainContentGenerator->SetMaxPos(Vector3(mTerrainMaxPos.x, 75.0f, mTerrainMaxPos.z)); 
     324         
     325        mTerrainContentGenerator->SetScale(scale); 
     326        mTerrainContentGenerator->SetOffset(TerrainFrameListener::msObjectTerrainOffsets[objectType]); 
     327        mTerrainContentGenerator->GenerateScene(num, TerrainFrameListener::msObjectCaptions[objectType]); 
     328 
     329        if (objectType != 0) // from our objects, only robot has animation phases 
     330                return; 
     331 
     332        EntityList *entList = mTerrainContentGenerator->GetGeneratedEntities(); 
     333 
     334        //-- add animation state for new robots (located at the end of the list) 
     335        for (int i = (int)entList->size() - num; i < (int)entList->size(); ++i) 
     336        { 
     337                mEntityStates.push_back(new EntityState((*entList)[i],  
     338                        EntityState::WAITING, Math::RangeRandom(0.5, 1.5))); 
    311339        } 
    312340 
     
    314342        // objects on peaks of the terrain (only few, not relevant for occlusion) 
    315343        mTerrainContentGenerator->SetMaxPos(mTerrainMaxPos); 
    316 } 
    317 //----------------------------------------------------------------------- 
    318 void  TestCullingTerrainApplication::generateScene(int num, int objectType) 
    319 { 
    320         Vector3 scale(TerrainFrameListener::msObjectScales[objectType],  
    321                                   TerrainFrameListener::msObjectScales[objectType], 
    322                                   TerrainFrameListener::msObjectScales[objectType]); 
    323  
    324         mTerrainContentGenerator->SetScale(scale); 
    325         mTerrainContentGenerator->SetOffset(TerrainFrameListener::msObjectTerrainOffsets[objectType]); 
    326         mTerrainContentGenerator->GenerateScene(num, TerrainFrameListener::msObjectCaptions[objectType]); 
    327  
    328         if (objectType != 0) // from our objects, only robot has animation phases 
    329                 return; 
    330  
    331         EntityList *entList = mTerrainContentGenerator->GetGeneratedEntities(); 
    332  
    333         //-- add animation state for new robots (located at the end of the list) 
    334         for (int i = entList->size() - num; i < (int)entList->size(); ++i) 
    335         { 
    336                 mEntityStates.push_back(new EntityState((*entList)[i],  
    337                         EntityState::WAITING, Math::RangeRandom(0.5, 1.5))); 
    338         } 
    339344} 
    340345//----------------------------------------------------------------------- 
Note: See TracChangeset for help on using the changeset viewer.