Changeset 1296 for GTP/trunk/App/Demos


Ignore:
Timestamp:
08/29/06 18:28:00 (18 years ago)
Author:
szydlowski
Message:

Implemented PVS support in kdtree scene manager - not complete, defunct
modified BoundingBoxConverter? to work with KdTreeSceneManager?

Location:
GTP/trunk/App/Demos/Vis/KdTreeDemo
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/KdTreeDemo/OGRE/include/TestKdTree.h

    r1285 r1296  
    4848        // save entities to ascii file 
    4949        bool saveSceneASCII(const String& filename, SceneNode *entityroot); 
     50        void createTerrainScene(Real max_x, Real max_y, Real max_z); 
     51        Vector3 clampToGround(const Vector3& vect, Real offset, Real cap); 
    5052protected: 
    5153        KdTreeAppListener *mFrameListener; 
    … …  
    5759 
    5860        // scene options 
    59         //String  mSceneFiles; 
     61        String  mSceneFiles; 
     62        String  mViewCells; 
    6063        Real    mRotationRadius; 
    6164        int             mModelSpacing; 
    … …  
    9699        void createMaterials(void); 
    97100        void createSimpleScene(void); 
    98         void createTerrainScene(Real max_x, Real max_y, Real max_z); 
    99         Vector3 clampToGround(const Vector3& vect, Real offset, Real cap); 
    100101 
    101102        RaySceneQuery* mRaySceneQuery; 

  • GTP/trunk/App/Demos/Vis/KdTreeDemo/OGRE/include/TestKdTreeAppListener.h

    r1285 r1296  
    8181        }; 
    8282 
     83        enum SceneType 
     84        { 
     85                ST_SIMPLE, 
     86                ST_TERRAIN, 
     87                ST_GEOMETRY 
     88        }; 
     89 
    8390        enum SceneMgr 
    8491        { 
    … …  
    120127                mRenderMethod(KdTree::KDRM_GTP_CHC), 
    121128                mBuildMethod(KdTree::KDBM_PRIORITYQUEUE), 
     129                mSceneType(ST_SIMPLE), 
     130                mFastStart(false), 
     131                mBurnIn(false), 
    122132                mDemoMode(false), 
    123133                mEnhancedVisibility(false), 
    … …  
    128138                } 
    129139 
    130                 String mSceneFiles; 
    131140                String mSceneOutfileName; 
    132141                String mDemoInfileName; 
    … …  
    143152                int mRenderMethod; 
    144153                int mBuildMethod; 
     154                int mSceneType; 
     155                bool mFastStart; 
     156                bool mBurnIn; 
    145157                bool mDemoMode; 
    146158                bool mEnhancedVisibility; 
    … …  
    171183 
    172184        void showDebugOverlay(bool show); 
     185 
     186        void toggleUseViewCells(void); 
     187 
     188        void toggleUseVisibilityFilter(void); 
    173189 
    174190        void toggleVizCamera(void); 
    … …  
    231247        int mShowTree; 
    232248 
     249        // view cells 
     250        bool mUseViewCells; 
     251        bool mUseVisibilityFilter; 
     252 
    233253        // counters 
    234254        int mSeqNum; 
    … …  
    252272        TextAreaOverlayElement *mDemoTime; 
    253273        TextAreaOverlayElement *mDemoFPSDisp; 
    254  
    255274 
    256275        OverlayElement *mRenderMethodInfo; 
    … …  
    263282        OverlayElement *mMovementInfo; 
    264283        OverlayElement *mTopCamInfo; 
     284        OverlayElement *mViewCellsInfo; 
     285        OverlayElement *mViewFilterInfo; 
    265286 
    266287        OverlayElement *mFrustumCulledNodesInfo; 

  • GTP/trunk/App/Demos/Vis/KdTreeDemo/OGRE/src/TestKdTree.cpp

    r1285 r1296  
    3939                                .addOpt("","comment", ARGUMENT_REQUIRED) 
    4040                                .addOpt("e","enhancevis", ARGUMENT_NONE) 
    41                                 .addOpt("","savesceneto", ARGUMENT_REQUIRED); 
     41                                .addOpt("","savesceneto", ARGUMENT_REQUIRED) 
     42                                .addOpt("f","faststart", ARGUMENT_NONE) 
     43                                .addOpt("b","burnin", ARGUMENT_NONE); 
    4244 
    4345 
    … …  
    4648                        cmdparser.getOpt("l", options.mDemoLogfileName); 
    4749                        cmdparser.getOpt("comment", options.mComment); 
     50                        options.mFastStart = cmdparser.getOpt("f"); 
     51                        options.mBurnIn = cmdparser.getOpt("b"); 
    4852                        options.mDemoMode = cmdparser.getOpt("d"); 
    4953                        options.mEnhancedVisibility = cmdparser.getOpt("e"); 
    … …  
    184188        cfDeath.load("testKdTree.cfg"); 
    185189 
    186         mOptions.mSceneFiles = cfDeath.getSetting("scene"); 
     190        mSceneFiles = cfDeath.getSetting("scene"); 
     191        mViewCells = cfDeath.getSetting("viewcells"); 
    187192 
    188193        tmp = cfDeath.getSetting("shadows"); 
    … …  
    240245 
    241246        // load simple scene (planes & robots) 
    242         if (mOptions.mSceneFiles == "") 
     247        if (mSceneFiles == "") 
    243248        { 
    244249                createSimpleScene(); 
     250                mOptions.mSceneType = KdTreeAppListener::ST_SIMPLE; 
    245251                mCamNode->setPosition(Vector3(1280,600,1666)); 
    246252                mCamNode->setOrientation(Quaternion(0.936893, -0.124586, 0.323813, 0.04306)); 
    247253        } 
    248         // load terrain, but only if terrainscenemanager selected 
    249         else if (mOptions.mSceneFiles == TERRAIN_SCENE) 
    250         { 
    251                 Plane waterPlane; 
    252  
    253                 // Set ambient light 
    254                 mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5)); 
    255  
    256                 // Create a light 
    257                 Light* l = mSceneMgr->createLight("MainLight"); 
    258                 // Accept default settings: point light, white diffuse, just set position 
    259                 // NB I could attach the light to a SceneNode if I wanted it to move automatically with 
    260                 //  other objects, but I don't 
    261                 l->setPosition(20,80,50); 
    262  
    263                 // Fog 
    264                 // NB it's VERY important to set this before calling setWorldGeometry  
    265                 // because the vertex program picked will be different 
    266                 //ColourValue fadeColour(0.93, 0.86, 0.76); 
    267                 //mSceneMgr->setFog( FOG_LINEAR, fadeColour, .001, 500, 1000); 
    268                 //mWindow->getViewport(0)->setBackgroundColour(fadeColour); 
    269                 mWindow->getViewport(0)->setBackgroundColour(ColourValue::Blue); 
    270  
    271                 std::string terrain_cfg("terrain.cfg"); 
    272  
    273                 mSceneMgr -> setWorldGeometry( terrain_cfg ); 
    274  
    275                 // Define the required skyplane 
    276                 Plane plane; 
    277                 // 5000 world units from the camera 
    278                 plane.d = 5000; 
    279                 // Above the camera, facing down 
    280                 plane.normal = -Vector3::UNIT_Y; 
    281  
    282                 // read interesting params from config file 
    283                 ConfigFile terrainconf; 
    284                 std::stringstream s; 
    285                 Real x,y,z; 
    286                  
    287                 terrainconf.load(terrain_cfg); 
    288  
    289                 s << terrainconf.getSetting("PageWorldX"); 
    290                 s >> x; 
    291                 s.clear(); 
    292  
    293                 s << terrainconf.getSetting("MaxHeight"); 
    294                 s >> y; 
    295                 s.clear(); 
    296  
    297                 s << terrainconf.getSetting("PageWorldZ"); 
    298                 s >> z; 
    299                 s.clear(); 
    300  
    301                 // add stuff minus gound plane 
    302                 createTerrainScene(x, y + 1500, z); 
    303  
    304                 // Set a nice viewpoint 
    305                 mCamNode->setPosition(707,2500,528); 
    306                 mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329)); 
    307                 //mCamNode->setPosition(1056.59, 467.412, 783.502); 
    308                 //mCamNode->setOrientation(Quaternion(-0.281354, 0.0204027, 0.956747, 0.0695345)); 
    309         } 
     254        //// load terrain, but only if terrainscenemanager selected 
     255        //else if (mSceneFiles == TERRAIN_SCENE) 
     256        //{ 
     257        //      Plane waterPlane; 
     258 
     259        //      // Set ambient light 
     260        //      mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5)); 
     261 
     262        //      // Create a light 
     263        //      Light* l = mSceneMgr->createLight("MainLight"); 
     264        //      // Accept default settings: point light, white diffuse, just set position 
     265        //      // NB I could attach the light to a SceneNode if I wanted it to move automatically with 
     266        //      //  other objects, but I don't 
     267        //      l->setPosition(20,80,50); 
     268 
     269        //      // Fog 
     270        //      // NB it's VERY important to set this before calling setWorldGeometry  
     271        //      // because the vertex program picked will be different 
     272        //      //ColourValue fadeColour(0.93, 0.86, 0.76); 
     273        //      //mSceneMgr->setFog( FOG_LINEAR, fadeColour, .001, 500, 1000); 
     274        //      //mWindow->getViewport(0)->setBackgroundColour(fadeColour); 
     275        //      mWindow->getViewport(0)->setBackgroundColour(ColourValue::Blue); 
     276 
     277        //      std::string terrain_cfg("terrain.cfg"); 
     278 
     279        //      mSceneMgr -> setWorldGeometry( terrain_cfg ); 
     280 
     281        //      // Define the required skyplane 
     282        //      Plane plane; 
     283        //      // 5000 world units from the camera 
     284        //      plane.d = 5000; 
     285        //      // Above the camera, facing down 
     286        //      plane.normal = -Vector3::UNIT_Y; 
     287 
     288        //      // read interesting params from config file 
     289        //      ConfigFile terrainconf; 
     290        //      std::stringstream s; 
     291        //      Real x,y,z; 
     292        //       
     293        //      terrainconf.load(terrain_cfg); 
     294 
     295        //      s << terrainconf.getSetting("PageWorldX"); 
     296        //      s >> x; 
     297        //      s.clear(); 
     298 
     299        //      s << terrainconf.getSetting("MaxHeight"); 
     300        //      s >> y; 
     301        //      s.clear(); 
     302 
     303        //      s << terrainconf.getSetting("PageWorldZ"); 
     304        //      s >> z; 
     305        //      s.clear(); 
     306 
     307        //      // add stuff minus gound plane 
     308        //      createTerrainScene(x, y + 1500, z); 
     309 
     310        //      // Set a nice viewpoint 
     311        //      mCamNode->setPosition(707,2500,528); 
     312        //      mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329)); 
     313        //      //mCamNode->setPosition(1056.59, 467.412, 783.502); 
     314        //      //mCamNode->setOrientation(Quaternion(-0.281354, 0.0204027, 0.956747, 0.0695345)); 
     315        //} 
    310316        // load scene from file 
    311317        else 
    312318        { 
    313319                // don't load the other stuff 
    314                 loadScene(mOptions.mSceneFiles); 
    315  
    316                 // top view 
    317                 mTopCam->setPosition(Vector3(1232, 3990, -1477)); 
    318                 // walkthrough view 
    319                 mCamNode->setPosition(Vector3(827.885, 184.435, -524.984)); 
    320                 mCamNode->setOrientation(Quaternion(0.98935, 0.0348082, -0.141246, 0.00496945)); 
    321  
    322                 mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox", 5000, true); 
     320                loadScene(mSceneFiles); 
     321 
     322                if (mOptions.mSceneType == KdTreeAppListener::ST_GEOMETRY) 
     323                { 
     324                        // initial position 
     325                        mCamNode->setPosition(Vector3(827.885, 184.435, -524.984)); 
     326                        mCamNode->setOrientation(Quaternion(0.98935, 0.0348082, -0.141246, 0.00496945)); 
     327                        // initial position for vis camera 
     328                        mTopCam->setPosition(Vector3(1232, 3990, -1477)); 
     329 
     330                        // try loading view cells if specified and if scene manager supports it 
     331                        if (!mViewCells.empty()) 
     332                                mSceneMgr->setOption("LoadViewCells", mViewCells.c_str()); 
     333 
     334                        // sky box 
     335                        mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox", 5000, true); 
     336                } 
     337                else if (mOptions.mSceneType == KdTreeAppListener::ST_TERRAIN) 
     338                { 
     339                        // initial position 
     340                        mCamNode->setPosition(707,2500,528); 
     341                        mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329)); 
     342 
     343                        // sky box 
     344                        mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", mPlaneDim * 2); 
     345                } 
    323346        } 
    324347} 
    … …  
    329352        Vector3 scale(0.3, 0.3, 0.3); 
    330353        Entity *deaths; 
    331         SceneNode *nodes; 
     354        SceneNode *nodes, *anchor; 
    332355        std::string entName; 
    333356        std::string nodeName; 
    … …  
    336359        max_x -= 100; max_z -= 100; 
    337360 
    338         SceneNode *anchor = mSceneMgr->getRootSceneNode()->createChildSceneNode("AnchorNode"); 
     361        try 
     362        { 
     363                anchor = mSceneMgr->getSceneNode("AnchorNode"); 
     364        } 
     365        catch (Exception) 
     366        { 
     367                anchor = mSceneMgr->getRootSceneNode()->createChildSceneNode("AnchorNode");              
     368        } 
    339369 
    340370        if (mSelectEntities & ENT_RND) 
    … …  
    348378                                max_y,  
    349379                                Math::RangeRandom(min_z, max_z)), 0, max_y); 
     380                         
     381                        // hack to fill valleys 
     382                        if (pos == Vector3::ZERO) 
     383                        { 
     384                                -- i; 
     385                                continue; 
     386                        } 
     387 
    350388                        deaths = mSceneMgr->createEntity(cat(entName,666,i),"robot.mesh"); 
    351389                        if (mShadowsEnabled) 
    … …  
    369407                                Math::RangeRandom(min_z, max_z)), 
    370408                                Math::RangeRandom(20, 500), max_y); 
     409 
     410                        // hack to fill valleys 
     411                        if (pos == Vector3::ZERO) 
     412                        { 
     413                                -- i; 
     414                                continue; 
     415                        } 
     416 
    371417                        deaths = mSceneMgr->createEntity(cat(entName,666,i),"razor.mesh"); 
    372418                        if (mShadowsEnabled) 
    … …  
    398444                node_ball->setScale(scale/10); 
    399445        } 
    400  
    401         mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", mPlaneDim * 2); 
    402446} 
    403447 
    … …  
    644688    // You can skip this and use root.restoreConfig() to load configuration 
    645689    // settings if you were sure there are valid ones saved in ogre.cfg 
    646 #ifdef KDTREE_FASTSTART 
    647     if(mRoot->restoreConfig()) 
    648 #else 
    649         if(mRoot->showConfigDialog()) 
    650 #endif 
     690        bool cont = false; 
     691 
     692        if (mOptions.mFastStart) 
     693                cont = mRoot->restoreConfig(); 
     694        else 
     695                cont = mRoot->showConfigDialog(); 
     696 
     697        if (cont) 
    651698    { 
    652699        // If returned true, user clicked OK so initialise 
    … …  
    700747        result = vect; 
    701748 
    702         if (mOptions.mSceneFiles == TERRAIN_SCENE) 
     749        if (mOptions.mSceneType == KdTreeAppListener::ST_TERRAIN) 
    703750        { 
    704751                updateRay.setOrigin(vect); 
    … …  
    732779        } 
    733780 
     781        // hack to fill the valleys only - make cap lower than max height 
     782        if (result.y >= cap) 
     783                return Vector3::ZERO; 
     784 
    734785        result.y = result.y + offset > cap ? cap : result.y + offset; 
    735786 
    … …  
    780831                { 
    781832                        // load iv files 
    782                         loadres = loadSceneIV(fn, mSceneMgr->getRootSceneNode(), i);                     
     833                        loadres = loadSceneIV(fn, mSceneMgr->getRootSceneNode(), i); 
     834                        mOptions.mSceneType = KdTreeAppListener::ST_GEOMETRY; 
    783835                } 
    784836                else if (strstr(fn.c_str(), ".cfg")) 
    … …  
    786838                        // load terrain from cfg 
    787839                        loadres = loadSceneCfg(fn, mSceneMgr->getRootSceneNode(), i); 
     840                        mOptions.mSceneType = KdTreeAppListener::ST_TERRAIN; 
    788841                } 
    789842                else if (strstr(fn.c_str(), ".txt")) 
    … …  
    899952                                s.clear(); 
    900953                                s << line[2]; 
    901                                 s >> or.x >> or.y >> or.z >> or.w; 
     954                                s >> or.w >> or.x >> or.y >> or.z; 
    902955                                s.clear(); 
    903956                                s << line[3]; 
    … …  
    912965                                } 
    913966                                // build node 
    914                                 SceneNode *newnode = anchor->createChildSceneNode(node, pos, or); 
    915                                 newnode->setScale(scale); 
     967                                //SceneNode *newnode = anchor->createChildSceneNode(node, pos, or); 
     968                                SceneNode *newnode = anchor->createChildSceneNode(node); 
    916969                                for (EntMeshMap::iterator emmit = emm.begin(); emmit != emm.end(); emmit ++) 
    917970                                { 
    … …  
    919972                                        newnode->attachObject(entity); 
    920973                                } 
     974                                newnode->setPosition(pos); 
     975                                newnode->setOrientation(or); 
     976                                newnode->setScale(scale); 
    921977                                emm.clear(); 
    922978                        } 

  • GTP/trunk/App/Demos/Vis/KdTreeDemo/OGRE/src/TestKdTreeAppListener.cpp

    r1285 r1296  
    113113mTopCamFollow(true), 
    114114mShowTree(SHOWTREE_OFF), 
     115// view cells 
     116mUseViewCells(false), 
     117mUseVisibilityFilter(false), 
    115118//counters 
    116119mSeqNum(0), 
    … …  
    164167        mCamNode = sm->getSceneNode("PlayerCamNode"); 
    165168 
     169        sm->getOption("UseViewCells", &mUseViewCells); 
     170        sm->getOption("UseVisibilityFilter", &mUseVisibilityFilter); 
     171 
    166172        mRaySceneQuery = mSceneMgr->createRayQuery(Ray(mCamNode->getPosition(), Vector3::NEGATIVE_UNIT_Y)); 
    167173 
    … …  
    248254 
    249255        String ext = "KdTree/"; 
    250         String sMD, sKT, sKI, sHL, sBM, sRM, sFM, sTC, sEV; 
     256        String sMD, sKT, sKI, sHL, sBM, sRM, sFM, sTC, sEV, sVC, sVF; 
    251257 
    252258        int maxd; 
    … …  
    319325        else 
    320326                sTC = ": Free"; 
     327 
     328        if (mSceneMgr->getOption("UseViewCells", &mUseViewCells)) 
     329        { 
     330                if (mUseViewCells) 
     331                        sVC = ": on"; 
     332                else 
     333                        sVC = ": off"; 
     334        } 
     335        else 
     336        { 
     337                sVC = NA; 
     338        } 
     339 
     340        if (mSceneMgr->getOption("UseVisibilityFilter", &mUseVisibilityFilter)) 
     341        { 
     342                if (mUseVisibilityFilter) 
     343                        sVF = ": on"; 
     344                else 
     345                        sVF = ": off"; 
     346        } 
     347        else 
     348        { 
     349                sVF = NA; 
     350        } 
    321351 
    322352        initOverlayElement(&mRenderMethodInfo, ext, "RenderMethod", top, sRM); top += vert_space; 
    … …  
    329359        initOverlayElement(&mMovementInfo, ext, "Movement", top, sFM); top += vert_space; 
    330360        initOverlayElement(&mTopCamInfo, ext, "TopCam", top, sTC); top += vert_space; 
     361        initOverlayElement(&mViewCellsInfo, ext, "ViewCells", top, sVC); top += vert_space; 
     362        initOverlayElement(&mViewFilterInfo, ext, "ViewFilter", top, sVF); top += vert_space; 
    331363 
    332364        OverlayElement *visPanel = OverlayManager::getSingleton(). 
    … …  
    350382                        mKdTreeOverlay->hide(); 
    351383                } 
     384        } 
     385} 
     386 
     387void KdTreeAppListener::toggleUseViewCells() 
     388{ 
     389        mUseViewCells = !mUseViewCells; 
     390        if (mSceneMgr->setOption("UseViewCells", &mUseViewCells)) 
     391        { 
     392                if (mUseViewCells) 
     393                        mViewCellsInfo->setCaption(": on"); 
     394                else 
     395                        mViewCellsInfo->setCaption(": off"); 
     396        } 
     397        else 
     398        { 
     399                mViewCellsInfo->setCaption(NA); 
     400        } 
     401} 
     402 
     403void KdTreeAppListener::toggleUseVisibilityFilter() 
     404{ 
     405        mUseVisibilityFilter = !mUseVisibilityFilter; 
     406        if (mSceneMgr->setOption("UseVisibilityFilter", &mUseVisibilityFilter)) 
     407        { 
     408                if (mUseVisibilityFilter) 
     409                        mViewFilterInfo->setCaption(": on"); 
     410                else 
     411                        mViewFilterInfo->setCaption(": off"); 
     412        } 
     413        else 
     414        { 
     415                mViewFilterInfo->setCaption(NA); 
    352416        } 
    353417} 
    … …  
    442506                        else 
    443507                                mEnhancedVisInfo->setCaption(": Simple"); 
     508 
     509                        mOptions.mEnhancedVisibility = mode; 
    444510                } 
    445511        } 
    … …  
    458524                bm = (bm + 1) % KdTree::KDBM_SIZE; 
    459525                if (mSceneMgr->setOption("BuildMethod", &bm)) 
     526                { 
    460527                        mBuildMethodInfo->setCaption(": " + BUILDMETHODCAPTION[bm]); 
     528                        mOptions.mBuildMethod = bm; 
     529                } 
    461530        } 
    462531        else 
    … …  
    474543                rm = (rm + 1) % KdTree::KDRM_SIZE; 
    475544                if (mSceneMgr->setOption("RenderMethod", &rm)) 
     545                { 
    476546                        mRenderMethodInfo->setCaption(": " + RENDERMETHODCAPTION[rm]); 
     547                        mOptions.mRenderMethod = rm; 
     548                } 
    477549        } 
    478550        else 
    … …  
    553625        } 
    554626 
     627        if (mInputDevice->isKeyDown(KC_F8) && mTimeUntilNextToggle <= 0) 
     628        { 
     629                // fill scene only once (for now), stop if anchor node exists 
     630                try 
     631                { 
     632                        SceneNode *entnode = mSceneMgr->getSceneNode("AnchorNode"); 
     633                } 
     634                catch (Exception) 
     635                { 
     636                        // read interesting params from config file 
     637                        ConfigFile terrainconf; 
     638                        std::stringstream s; 
     639                        Real x,y,z; 
     640                         
     641                        terrainconf.load("terrain.cfg"); 
     642 
     643                        s << terrainconf.getSetting("PageWorldX"); 
     644                        s >> x; 
     645                        s.clear(); 
     646 
     647                        s << terrainconf.getSetting("MaxHeight"); 
     648                        s >> y; 
     649                        s.clear(); 
     650 
     651                        s << terrainconf.getSetting("PageWorldZ"); 
     652                        s >> z; 
     653                        s.clear(); 
     654 
     655                        mOptions.myApp->createTerrainScene(x, y * 0.3, z); 
     656 
     657                        // rebuild tree 
     658                        mSceneMgr->setOption("RebuildKdTree", 0); 
     659                } 
     660 
     661                mTimeUntilNextToggle = 0.5; 
     662        } 
     663 
     664 
    555665        if (mInputDevice->isKeyDown(KC_F9) && mTimeUntilNextToggle <= 0) 
    556666        { 
    … …  
    571681        } 
    572682 
    573         if (mInputDevice->isKeyDown(KC_V) && mTimeUntilNextToggle <= 0) 
    574         { 
    575                 toggleEnhancedVisibility(); 
     683        if (mInputDevice->isKeyDown(KC_C) && mTimeUntilNextToggle <= 0) 
     684        { 
     685                toggleUseViewCells(); 
     686                mTimeUntilNextToggle = 0.5; 
     687        } 
     688 
     689        if (mInputDevice->isKeyDown(KC_X) && mTimeUntilNextToggle <= 0) 
     690        { 
     691                toggleUseVisibilityFilter(); 
    576692                mTimeUntilNextToggle = 0.5; 
    577693        } 
    … …  
    9821098        if (!mFreeMove) 
    9831099        { 
    984                 if (mOptions.mSceneFiles == TERRAIN_SCENE) 
     1100                if (mOptions.mSceneType == ST_TERRAIN) 
    9851101                { 
    9861102                        static Vector3 pos; 
    … …  
    11551271                        { 
    11561272                                saveLog(); 
    1157                                 return false; 
     1273                                if (mOptions.mBurnIn) 
     1274                                        togglePlayback(); 
     1275                                else 
     1276                                        return false; 
    11581277                        } 
    11591278                } 
    … …  
    13441463                mDemoStats.mEllapsedTime = 0.0f; 
    13451464                mDemoStats.mTotalEllapsedTime = 0.0f; 
     1465                mDemoFPS.clear(); 
    13461466        } 
    13471467        // stop playback 
    … …  
    15971717                if (mOptions.mSceneManager == SM_KDT || mOptions.mSceneManager == SM_KTE) 
    15981718                { 
    1599                         logwrite << ds << RENDERMETHOD[mOptions.mRenderMethod] << ds << mOptions.mMaxDepth << ds  
    1600                                 << mOptions.mKT << ds << mOptions.mKI; 
     1719                        // info about enhanced visibility if internal rendering 
     1720                        String senhvis; 
     1721                        if (mOptions.mRenderMethod == KdTree::KDRM_INTERNAL) 
     1722                        { 
     1723                                if (mOptions.mEnhancedVisibility) 
     1724                                        senhvis = "E" + ds; 
     1725                                else 
     1726                                        senhvis = "S" + ds; 
     1727                        } 
     1728 
     1729                        logwrite << ds << RENDERMETHOD[mOptions.mRenderMethod] << ds << senhvis <<  
     1730                                mOptions.mMaxDepth << ds << mOptions.mKT << ds << mOptions.mKI << ds <<  
     1731                                BUILDMETHOD[mOptions.mBuildMethod]; 
    16011732                } 
    16021733                else if (mOptions.mSceneManager == SM_OCM && mOptions.mRenderMethod != KdTree::KDRM_INTERNAL) 
    16031734                { 
    1604                         logwrite << ds << RENDERMETHOD[(mOptions.mRenderMethod+3)%3]; 
     1735                        logwrite << ds << RENDERMETHOD[CONV_OCM_TO_KDT_ALG(mOptions.mRenderMethod)]; 
    16051736                } 
    16061737                logwrite << "\"" << fs; 

  • GTP/trunk/App/Demos/Vis/KdTreeDemo/README.txt

    r1285 r1296  
    2020    as a CSV text file. See DEMOS for details. 
    2121    To have any effect, requires --demomode. 
     22     
     23  -f, --faststart 
     24    Skip Ogre startup dialog. A valid ogre.cfg file must exist in the working 
     25    directory, otherwise the program will abort. 
    2226 
    2327  -d, --demomode 
    2428    Start the application in demomode. See DEMOS for details. 
    2529    Requires --infile, otherwise no benchmark is run. 
     30     
     31  -b, --burnin 
     32    Run a burn-in demo, i.e. loop the demo until ESC is pressed. Requires 
     33    --demomode. If --logfile is specified, the result of each run will be saved. 
    2634 
    2735  -s <sm_id>, --scenemgr <sm_id> 
    … …  
    5058     
    5159  --savesceneto <filename> 
    52         Specifies file name (with .txt extension) to which the positions of all 
    53         entities in the scene will be saved. If the filename is appended to 
    54         the scene parameter in the config file, the entities are loaded at 
    55         startup 
     60    Specifies file name (with .txt extension) to which the positions of all 
     61    entities in the scene will be saved. If the filename is appended to 
     62    the scene parameter in the config file, the entities are loaded at 
     63    startup 
    5664 
    5765  The following options apply only to the KDT and KTE scene managers. They have 
    … …  
    98106            list of scene files to load. So far the application supports the 
    99107            following formats: 
    100                 .iv, .wrl:      Mesh files like the vienna scene. 
    101                 .cfg:                           Config files for terrain creation. You need to specify 
    102                                                                 an appropriate scene manager which supports terrain 
    103                                                                 world geometry rendering (KTE, OCM, TER). 
    104                 .txt:                           Text file created by the application which store 
    105                                                                 positions of entites (small movable objects) 
     108              .iv, .wrl:  Mesh files like the vienna scene. 
     109              .cfg:       Config files for terrain creation. You need to specify 
     110                          an appropriate scene manager which supports terrain 
     111                          world geometry rendering (KTE, OCM, TER). 
     112              .txt:       Text file created by the application which store 
     113                          positions of entites (small movable objects) 
     114    viewcells: 
     115            Load preprocessed PVS from file. Has no effect for terrain and 
     116            simple scenes. 
    106117    movespeed, rotatespeed: 
    107118            Set the speed of movement and rotation for the player camera. 
    … …  
    175186    R     Toggle OpenGL/Direct3D render mode (Full, Line, Point) 
    176187    T     Toggle OpenGL/Direct3D texture filtering (Bilinear, Trilinear, Aniso) 
     188    C     Toggle use view cells from PVS (need to load them first) 
     189    X     Toggle use visibility filter (whatever that is) 
    177190 
    178191  Other: 
    … …  
    182195    P     Show/Hide player cam position 
    183196    PRINT Save sceen shot 
    184     F7          Save Entities in the scene to file 
     197    F7    Save Entities in the scene to file 
     198    F8    Generate random entities for terrain scene 
    185199 
    186200DEMOS 
Note: See TracChangeset for help on using the changeset viewer.