Changeset 1296 for GTP/trunk/App/Demos/Vis

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:

• OGRE/include/TestKdTree.h (modified) (3 diffs)
• OGRE/include/TestKdTreeAppListener.h (modified) (8 diffs)
• OGRE/src/TestKdTree.cpp (modified) (17 diffs)
• OGRE/src/TestKdTreeAppListener.cpp (modified) (15 diffs)
• README.txt (modified) (5 diffs)

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

@@ -48 +48 @@
         // save entities to ascii file
         bool saveSceneASCII(const String& filename, SceneNode *entityroot);
+        void createTerrainScene(Real max_x, Real max_y, Real max_z);
+        Vector3 clampToGround(const Vector3& vect, Real offset, Real cap);
 protected:
         KdTreeAppListener *mFrameListener;
@@ -57 +59 @@
 
         // scene options
-        //String  mSceneFiles;
+        String  mSceneFiles;
+        String  mViewCells;
         Real    mRotationRadius;
         int             mModelSpacing;
@@ -96 +99 @@
         void createMaterials(void);
         void createSimpleScene(void);
-        void createTerrainScene(Real max_x, Real max_y, Real max_z);
-        Vector3 clampToGround(const Vector3& vect, Real offset, Real cap);
 
         RaySceneQuery* mRaySceneQuery;

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

@@ -81 +81 @@
         };
 
+        enum SceneType
+        {
+                ST_SIMPLE,
+                ST_TERRAIN,
+                ST_GEOMETRY
+        };
+
         enum SceneMgr
         {
@@ -120 +127 @@
                 mRenderMethod(KdTree::KDRM_GTP_CHC),
                 mBuildMethod(KdTree::KDBM_PRIORITYQUEUE),
+                mSceneType(ST_SIMPLE),
+                mFastStart(false),
+                mBurnIn(false),
                 mDemoMode(false),
                 mEnhancedVisibility(false),
@@ -128 +138 @@
                 }
 
-                String mSceneFiles;
                 String mSceneOutfileName;
                 String mDemoInfileName;
@@ -143 +152 @@
                 int mRenderMethod;
                 int mBuildMethod;
+                int mSceneType;
+                bool mFastStart;
+                bool mBurnIn;
                 bool mDemoMode;
                 bool mEnhancedVisibility;
@@ -171 +183 @@
 
         void showDebugOverlay(bool show);
+
+        void toggleUseViewCells(void);
+
+        void toggleUseVisibilityFilter(void);
 
         void toggleVizCamera(void);
@@ -231 +247 @@
         int mShowTree;
 
+        // view cells
+        bool mUseViewCells;
+        bool mUseVisibilityFilter;
+
         // counters
         int mSeqNum;
@@ -252 +272 @@
         TextAreaOverlayElement *mDemoTime;
         TextAreaOverlayElement *mDemoFPSDisp;
-
 
         OverlayElement *mRenderMethodInfo;
@@ -263 +282 @@
         OverlayElement *mMovementInfo;
         OverlayElement *mTopCamInfo;
+        OverlayElement *mViewCellsInfo;
+        OverlayElement *mViewFilterInfo;
 
         OverlayElement *mFrustumCulledNodesInfo;

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

@@ -39 +39 @@
                                 .addOpt("","comment", ARGUMENT_REQUIRED)
                                 .addOpt("e","enhancevis", ARGUMENT_NONE)
-                                .addOpt("","savesceneto", ARGUMENT_REQUIRED);
+                                .addOpt("","savesceneto", ARGUMENT_REQUIRED)
+                                .addOpt("f","faststart", ARGUMENT_NONE)
+                                .addOpt("b","burnin", ARGUMENT_NONE);
 
 
@@ -46 +48 @@
                         cmdparser.getOpt("l", options.mDemoLogfileName);
                         cmdparser.getOpt("comment", options.mComment);
+                        options.mFastStart = cmdparser.getOpt("f");
+                        options.mBurnIn = cmdparser.getOpt("b");
                         options.mDemoMode = cmdparser.getOpt("d");
                         options.mEnhancedVisibility = cmdparser.getOpt("e");
@@ -184 +188 @@
         cfDeath.load("testKdTree.cfg");
 
-        mOptions.mSceneFiles = cfDeath.getSetting("scene");
+        mSceneFiles = cfDeath.getSetting("scene");
+        mViewCells = cfDeath.getSetting("viewcells");
 
         tmp = cfDeath.getSetting("shadows");
@@ -240 +245 @@
 
         // load simple scene (planes & robots)
-        if (mOptions.mSceneFiles == "")
+        if (mSceneFiles == "")
         {
                 createSimpleScene();
+                mOptions.mSceneType = KdTreeAppListener::ST_SIMPLE;
                 mCamNode->setPosition(Vector3(1280,600,1666));
                 mCamNode->setOrientation(Quaternion(0.936893, -0.124586, 0.323813, 0.04306));
         }
-        // load terrain, but only if terrainscenemanager selected
-        else if (mOptions.mSceneFiles == TERRAIN_SCENE)
-        {
-                Plane waterPlane;
-
-                // Set ambient light
-                mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
-
-                // Create a light
-                Light* l = mSceneMgr->createLight("MainLight");
-                // Accept default settings: point light, white diffuse, just set position
-                // NB I could attach the light to a SceneNode if I wanted it to move automatically with
-                //  other objects, but I don't
-                l->setPosition(20,80,50);
-
-                // Fog
-                // NB it's VERY important to set this before calling setWorldGeometry 
-                // because the vertex program picked will be different
-                //ColourValue fadeColour(0.93, 0.86, 0.76);
-                //mSceneMgr->setFog( FOG_LINEAR, fadeColour, .001, 500, 1000);
-                //mWindow->getViewport(0)->setBackgroundColour(fadeColour);
-                mWindow->getViewport(0)->setBackgroundColour(ColourValue::Blue);
-
-                std::string terrain_cfg("terrain.cfg");
-
-                mSceneMgr -> setWorldGeometry( terrain_cfg );
-
-                // Define the required skyplane
-                Plane plane;
-                // 5000 world units from the camera
-                plane.d = 5000;
-                // Above the camera, facing down
-                plane.normal = -Vector3::UNIT_Y;
-
-                // read interesting params from config file
-                ConfigFile terrainconf;
-                std::stringstream s;
-                Real x,y,z;
-                
-                terrainconf.load(terrain_cfg);
-
-                s << terrainconf.getSetting("PageWorldX");
-                s >> x;
-                s.clear();
-
-                s << terrainconf.getSetting("MaxHeight");
-                s >> y;
-                s.clear();
-
-                s << terrainconf.getSetting("PageWorldZ");
-                s >> z;
-                s.clear();
-
-                // add stuff minus gound plane
-                createTerrainScene(x, y + 1500, z);
-
-                // Set a nice viewpoint
-                mCamNode->setPosition(707,2500,528);
-                mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));
-                //mCamNode->setPosition(1056.59, 467.412, 783.502);
-                //mCamNode->setOrientation(Quaternion(-0.281354, 0.0204027, 0.956747, 0.0695345));
-        }
+        //// load terrain, but only if terrainscenemanager selected
+        //else if (mSceneFiles == TERRAIN_SCENE)
+        //{
+        //      Plane waterPlane;
+
+        //      // Set ambient light
+        //      mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
+
+        //      // Create a light
+        //      Light* l = mSceneMgr->createLight("MainLight");
+        //      // Accept default settings: point light, white diffuse, just set position
+        //      // NB I could attach the light to a SceneNode if I wanted it to move automatically with
+        //      //  other objects, but I don't
+        //      l->setPosition(20,80,50);
+
+        //      // Fog
+        //      // NB it's VERY important to set this before calling setWorldGeometry 
+        //      // because the vertex program picked will be different
+        //      //ColourValue fadeColour(0.93, 0.86, 0.76);
+        //      //mSceneMgr->setFog( FOG_LINEAR, fadeColour, .001, 500, 1000);
+        //      //mWindow->getViewport(0)->setBackgroundColour(fadeColour);
+        //      mWindow->getViewport(0)->setBackgroundColour(ColourValue::Blue);
+
+        //      std::string terrain_cfg("terrain.cfg");
+
+        //      mSceneMgr -> setWorldGeometry( terrain_cfg );
+
+        //      // Define the required skyplane
+        //      Plane plane;
+        //      // 5000 world units from the camera
+        //      plane.d = 5000;
+        //      // Above the camera, facing down
+        //      plane.normal = -Vector3::UNIT_Y;
+
+        //      // read interesting params from config file
+        //      ConfigFile terrainconf;
+        //      std::stringstream s;
+        //      Real x,y,z;
+        //      
+        //      terrainconf.load(terrain_cfg);
+
+        //      s << terrainconf.getSetting("PageWorldX");
+        //      s >> x;
+        //      s.clear();
+
+        //      s << terrainconf.getSetting("MaxHeight");
+        //      s >> y;
+        //      s.clear();
+
+        //      s << terrainconf.getSetting("PageWorldZ");
+        //      s >> z;
+        //      s.clear();
+
+        //      // add stuff minus gound plane
+        //      createTerrainScene(x, y + 1500, z);
+
+        //      // Set a nice viewpoint
+        //      mCamNode->setPosition(707,2500,528);
+        //      mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));
+        //      //mCamNode->setPosition(1056.59, 467.412, 783.502);
+        //      //mCamNode->setOrientation(Quaternion(-0.281354, 0.0204027, 0.956747, 0.0695345));
+        //}
         // load scene from file
         else
         {
                 // don't load the other stuff
-                loadScene(mOptions.mSceneFiles);
-
-                // top view
-                mTopCam->setPosition(Vector3(1232, 3990, -1477));
-                // walkthrough view
-                mCamNode->setPosition(Vector3(827.885, 184.435, -524.984));
-                mCamNode->setOrientation(Quaternion(0.98935, 0.0348082, -0.141246, 0.00496945));
-
-                mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox", 5000, true);
+                loadScene(mSceneFiles);
+
+                if (mOptions.mSceneType == KdTreeAppListener::ST_GEOMETRY)
+                {
+                        // initial position
+                        mCamNode->setPosition(Vector3(827.885, 184.435, -524.984));
+                        mCamNode->setOrientation(Quaternion(0.98935, 0.0348082, -0.141246, 0.00496945));
+                        // initial position for vis camera
+                        mTopCam->setPosition(Vector3(1232, 3990, -1477));
+
+                        // try loading view cells if specified and if scene manager supports it
+                        if (!mViewCells.empty())
+                                mSceneMgr->setOption("LoadViewCells", mViewCells.c_str());
+
+                        // sky box
+                        mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox", 5000, true);
+                }
+                else if (mOptions.mSceneType == KdTreeAppListener::ST_TERRAIN)
+                {
+                        // initial position
+                        mCamNode->setPosition(707,2500,528);
+                        mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));
+
+                        // sky box
+                        mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", mPlaneDim * 2);
+                }
         }
 }
@@ -329 +352 @@
         Vector3 scale(0.3, 0.3, 0.3);
         Entity *deaths;
-        SceneNode *nodes;
+        SceneNode *nodes, *anchor;
         std::string entName;
         std::string nodeName;
@@ -336 +359 @@
         max_x -= 100; max_z -= 100;
 
-        SceneNode *anchor = mSceneMgr->getRootSceneNode()->createChildSceneNode("AnchorNode");
+        try
+        {
+                anchor = mSceneMgr->getSceneNode("AnchorNode");
+        }
+        catch (Exception)
+        {
+                anchor = mSceneMgr->getRootSceneNode()->createChildSceneNode("AnchorNode");             
+        }
 
         if (mSelectEntities & ENT_RND)
@@ -348 +378 @@
                                 max_y, 
                                 Math::RangeRandom(min_z, max_z)), 0, max_y);
+                        
+                        // hack to fill valleys
+                        if (pos == Vector3::ZERO)
+                        {
+                                -- i;
+                                continue;
+                        }
+
                         deaths = mSceneMgr->createEntity(cat(entName,666,i),"robot.mesh");
                         if (mShadowsEnabled)
@@ -369 +407 @@
                                 Math::RangeRandom(min_z, max_z)),
                                 Math::RangeRandom(20, 500), max_y);
+
+                        // hack to fill valleys
+                        if (pos == Vector3::ZERO)
+                        {
+                                -- i;
+                                continue;
+                        }
+
                         deaths = mSceneMgr->createEntity(cat(entName,666,i),"razor.mesh");
                         if (mShadowsEnabled)
@@ -398 +444 @@
                 node_ball->setScale(scale/10);
         }
-
-        mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", mPlaneDim * 2);
 }
 
@@ -644 +688 @@
     // You can skip this and use root.restoreConfig() to load configuration
     // settings if you were sure there are valid ones saved in ogre.cfg
-#ifdef KDTREE_FASTSTART
-    if(mRoot->restoreConfig())
-#else
-        if(mRoot->showConfigDialog())
-#endif
+        bool cont = false;
+
+        if (mOptions.mFastStart)
+                cont = mRoot->restoreConfig();
+        else
+                cont = mRoot->showConfigDialog();
+
+        if (cont)
     {
         // If returned true, user clicked OK so initialise
@@ -700 +747 @@
         result = vect;
 
-        if (mOptions.mSceneFiles == TERRAIN_SCENE)
+        if (mOptions.mSceneType == KdTreeAppListener::ST_TERRAIN)
         {
                 updateRay.setOrigin(vect);
@@ -732 +779 @@
         }
 
+        // hack to fill the valleys only - make cap lower than max height
+        if (result.y >= cap)
+                return Vector3::ZERO;
+
         result.y = result.y + offset > cap ? cap : result.y + offset;
 
@@ -780 +831 @@
                 {
                         // load iv files
-                        loadres = loadSceneIV(fn, mSceneMgr->getRootSceneNode(), i);                    
+                        loadres = loadSceneIV(fn, mSceneMgr->getRootSceneNode(), i);
+                        mOptions.mSceneType = KdTreeAppListener::ST_GEOMETRY;
                 }
                 else if (strstr(fn.c_str(), ".cfg"))
@@ -786 +838 @@
                         // load terrain from cfg
                         loadres = loadSceneCfg(fn, mSceneMgr->getRootSceneNode(), i);
+                        mOptions.mSceneType = KdTreeAppListener::ST_TERRAIN;
                 }
                 else if (strstr(fn.c_str(), ".txt"))
@@ -899 +952 @@
                                 s.clear();
                                 s << line[2];
-                                s >> or.x >> or.y >> or.z >> or.w;
+                                s >> or.w >> or.x >> or.y >> or.z;
                                 s.clear();
                                 s << line[3];
@@ -912 +965 @@
                                 }
                                 // build node
-                                SceneNode *newnode = anchor->createChildSceneNode(node, pos, or);
-                                newnode->setScale(scale);
+                                //SceneNode *newnode = anchor->createChildSceneNode(node, pos, or);
+                                SceneNode *newnode = anchor->createChildSceneNode(node);
                                 for (EntMeshMap::iterator emmit = emm.begin(); emmit != emm.end(); emmit ++)
                                 {
@@ -919 +972 @@
                                         newnode->attachObject(entity);
                                 }
+                                newnode->setPosition(pos);
+                                newnode->setOrientation(or);
+                                newnode->setScale(scale);
                                 emm.clear();
                         }

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

@@ -113 +113 @@
 mTopCamFollow(true),
 mShowTree(SHOWTREE_OFF),
+// view cells
+mUseViewCells(false),
+mUseVisibilityFilter(false),
 //counters
 mSeqNum(0),
@@ -164 +167 @@
         mCamNode = sm->getSceneNode("PlayerCamNode");
 
+        sm->getOption("UseViewCells", &mUseViewCells);
+        sm->getOption("UseVisibilityFilter", &mUseVisibilityFilter);
+
         mRaySceneQuery = mSceneMgr->createRayQuery(Ray(mCamNode->getPosition(), Vector3::NEGATIVE_UNIT_Y));
 
@@ -248 +254 @@
 
         String ext = "KdTree/";
-        String sMD, sKT, sKI, sHL, sBM, sRM, sFM, sTC, sEV;
+        String sMD, sKT, sKI, sHL, sBM, sRM, sFM, sTC, sEV, sVC, sVF;
 
         int maxd;
@@ -319 +325 @@
         else
                 sTC = ": Free";
+
+        if (mSceneMgr->getOption("UseViewCells", &mUseViewCells))
+        {
+                if (mUseViewCells)
+                        sVC = ": on";
+                else
+                        sVC = ": off";
+        }
+        else
+        {
+                sVC = NA;
+        }
+
+        if (mSceneMgr->getOption("UseVisibilityFilter", &mUseVisibilityFilter))
+        {
+                if (mUseVisibilityFilter)
+                        sVF = ": on";
+                else
+                        sVF = ": off";
+        }
+        else
+        {
+                sVF = NA;
+        }
 
         initOverlayElement(&mRenderMethodInfo, ext, "RenderMethod", top, sRM); top += vert_space;
@@ -329 +359 @@
         initOverlayElement(&mMovementInfo, ext, "Movement", top, sFM); top += vert_space;
         initOverlayElement(&mTopCamInfo, ext, "TopCam", top, sTC); top += vert_space;
+        initOverlayElement(&mViewCellsInfo, ext, "ViewCells", top, sVC); top += vert_space;
+        initOverlayElement(&mViewFilterInfo, ext, "ViewFilter", top, sVF); top += vert_space;
 
         OverlayElement *visPanel = OverlayManager::getSingleton().
@@ -350 +382 @@
                         mKdTreeOverlay->hide();
                 }
+        }
+}
+
+void KdTreeAppListener::toggleUseViewCells()
+{
+        mUseViewCells = !mUseViewCells;
+        if (mSceneMgr->setOption("UseViewCells", &mUseViewCells))
+        {
+                if (mUseViewCells)
+                        mViewCellsInfo->setCaption(": on");
+                else
+                        mViewCellsInfo->setCaption(": off");
+        }
+        else
+        {
+                mViewCellsInfo->setCaption(NA);
+        }
+}
+
+void KdTreeAppListener::toggleUseVisibilityFilter()
+{
+        mUseVisibilityFilter = !mUseVisibilityFilter;
+        if (mSceneMgr->setOption("UseVisibilityFilter", &mUseVisibilityFilter))
+        {
+                if (mUseVisibilityFilter)
+                        mViewFilterInfo->setCaption(": on");
+                else
+                        mViewFilterInfo->setCaption(": off");
+        }
+        else
+        {
+                mViewFilterInfo->setCaption(NA);
         }
 }
@@ -442 +506 @@
                         else
                                 mEnhancedVisInfo->setCaption(": Simple");
+
+                        mOptions.mEnhancedVisibility = mode;
                 }
         }
@@ -458 +524 @@
                 bm = (bm + 1) % KdTree::KDBM_SIZE;
                 if (mSceneMgr->setOption("BuildMethod", &bm))
+                {
                         mBuildMethodInfo->setCaption(": " + BUILDMETHODCAPTION[bm]);
+                        mOptions.mBuildMethod = bm;
+                }
         }
         else
@@ -474 +543 @@
                 rm = (rm + 1) % KdTree::KDRM_SIZE;
                 if (mSceneMgr->setOption("RenderMethod", &rm))
+                {
                         mRenderMethodInfo->setCaption(": " + RENDERMETHODCAPTION[rm]);
+                        mOptions.mRenderMethod = rm;
+                }
         }
         else
@@ -553 +625 @@
         }
 
+        if (mInputDevice->isKeyDown(KC_F8) && mTimeUntilNextToggle <= 0)
+        {
+                // fill scene only once (for now), stop if anchor node exists
+                try
+                {
+                        SceneNode *entnode = mSceneMgr->getSceneNode("AnchorNode");
+                }
+                catch (Exception)
+                {
+                        // read interesting params from config file
+                        ConfigFile terrainconf;
+                        std::stringstream s;
+                        Real x,y,z;
+                        
+                        terrainconf.load("terrain.cfg");
+
+                        s << terrainconf.getSetting("PageWorldX");
+                        s >> x;
+                        s.clear();
+
+                        s << terrainconf.getSetting("MaxHeight");
+                        s >> y;
+                        s.clear();
+
+                        s << terrainconf.getSetting("PageWorldZ");
+                        s >> z;
+                        s.clear();
+
+                        mOptions.myApp->createTerrainScene(x, y * 0.3, z);
+
+                        // rebuild tree
+                        mSceneMgr->setOption("RebuildKdTree", 0);
+                }
+
+                mTimeUntilNextToggle = 0.5;
+        }
+
+
         if (mInputDevice->isKeyDown(KC_F9) && mTimeUntilNextToggle <= 0)
         {
@@ -571 +681 @@
         }
 
-        if (mInputDevice->isKeyDown(KC_V) && mTimeUntilNextToggle <= 0)
-        {
-                toggleEnhancedVisibility();
+        if (mInputDevice->isKeyDown(KC_C) && mTimeUntilNextToggle <= 0)
+        {
+                toggleUseViewCells();
+                mTimeUntilNextToggle = 0.5;
+        }
+
+        if (mInputDevice->isKeyDown(KC_X) && mTimeUntilNextToggle <= 0)
+        {
+                toggleUseVisibilityFilter();
                 mTimeUntilNextToggle = 0.5;
         }
@@ -982 +1098 @@
         if (!mFreeMove)
         {
-                if (mOptions.mSceneFiles == TERRAIN_SCENE)
+                if (mOptions.mSceneType == ST_TERRAIN)
                 {
                         static Vector3 pos;
@@ -1155 +1271 @@
                         {
                                 saveLog();
-                                return false;
+                                if (mOptions.mBurnIn)
+                                        togglePlayback();
+                                else
+                                        return false;
                         }
                 }
@@ -1344 +1463 @@
                 mDemoStats.mEllapsedTime = 0.0f;
                 mDemoStats.mTotalEllapsedTime = 0.0f;
+                mDemoFPS.clear();
         }
         // stop playback
@@ -1597 +1717 @@
                 if (mOptions.mSceneManager == SM_KDT || mOptions.mSceneManager == SM_KTE)
                 {
-                        logwrite << ds << RENDERMETHOD[mOptions.mRenderMethod] << ds << mOptions.mMaxDepth << ds 
-                                << mOptions.mKT << ds << mOptions.mKI;
+                        // info about enhanced visibility if internal rendering
+                        String senhvis;
+                        if (mOptions.mRenderMethod == KdTree::KDRM_INTERNAL)
+                        {
+                                if (mOptions.mEnhancedVisibility)
+                                        senhvis = "E" + ds;
+                                else
+                                        senhvis = "S" + ds;
+                        }
+
+                        logwrite << ds << RENDERMETHOD[mOptions.mRenderMethod] << ds << senhvis << 
+                                mOptions.mMaxDepth << ds << mOptions.mKT << ds << mOptions.mKI << ds << 
+                                BUILDMETHOD[mOptions.mBuildMethod];
                 }
                 else if (mOptions.mSceneManager == SM_OCM && mOptions.mRenderMethod != KdTree::KDRM_INTERNAL)
                 {
-                        logwrite << ds << RENDERMETHOD[(mOptions.mRenderMethod+3)%3];
+                        logwrite << ds << RENDERMETHOD[CONV_OCM_TO_KDT_ALG(mOptions.mRenderMethod)];
                 }
                 logwrite << "\"" << fs;

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

@@ -20 +20 @@
     as a CSV text file. See DEMOS for details.
     To have any effect, requires --demomode.
+    
+  -f, --faststart
+    Skip Ogre startup dialog. A valid ogre.cfg file must exist in the working
+    directory, otherwise the program will abort.
 
   -d, --demomode
     Start the application in demomode. See DEMOS for details.
     Requires --infile, otherwise no benchmark is run.
+    
+  -b, --burnin
+    Run a burn-in demo, i.e. loop the demo until ESC is pressed. Requires
+    --demomode. If --logfile is specified, the result of each run will be saved.
 
   -s <sm_id>, --scenemgr <sm_id>
@@ -50 +58 @@
     
   --savesceneto <filename>
-        Specifies file name (with .txt extension) to which the positions of all
-        entities in the scene will be saved. If the filename is appended to
-        the scene parameter in the config file, the entities are loaded at
-        startup
+    Specifies file name (with .txt extension) to which the positions of all
+    entities in the scene will be saved. If the filename is appended to
+    the scene parameter in the config file, the entities are loaded at
+    startup
 
   The following options apply only to the KDT and KTE scene managers. They have
@@ -98 +106 @@
             list of scene files to load. So far the application supports the
             following formats:
-                .iv, .wrl:      Mesh files like the vienna scene.
-                .cfg:                           Config files for terrain creation. You need to specify
-                                                                an appropriate scene manager which supports terrain
-                                                                world geometry rendering (KTE, OCM, TER).
-                .txt:                           Text file created by the application which store
-                                                                positions of entites (small movable objects)
+              .iv, .wrl:  Mesh files like the vienna scene.
+              .cfg:       Config files for terrain creation. You need to specify
+                          an appropriate scene manager which supports terrain
+                          world geometry rendering (KTE, OCM, TER).
+              .txt:       Text file created by the application which store
+                          positions of entites (small movable objects)
+    viewcells:
+            Load preprocessed PVS from file. Has no effect for terrain and
+            simple scenes.
     movespeed, rotatespeed:
             Set the speed of movement and rotation for the player camera.
@@ -175 +186 @@
     R     Toggle OpenGL/Direct3D render mode (Full, Line, Point)
     T     Toggle OpenGL/Direct3D texture filtering (Bilinear, Trilinear, Aniso)
+    C     Toggle use view cells from PVS (need to load them first)
+    X     Toggle use visibility filter (whatever that is)
 
   Other:
@@ -182 +195 @@
     P     Show/Hide player cam position
     PRINT Save sceen shot
-    F7          Save Entities in the scene to file
+    F7    Save Entities in the scene to file
+    F8    Generate random entities for terrain scene
 
 DEMOS