Changeset 85 for trunk/VUT/Ogre

Timestamp:

05/04/05 17:58:13 (20 years ago)

Author:

mattausch

Message:

corrected bug so chc is much faster than stop and wait

Location:

trunk/VUT/Ogre

Files:

• include/OgrePlatformHierarchyInterface.h (modified) (2 diffs)
• include/OgreSceneNodeHierarchyInterface.h (modified) (1 diff)
• include/OgreSolidHalfBoundingBox.h (modified) (2 diffs)
• src/OgreOctreeHierarchyInterface.cpp (modified) (1 diff)
• src/OgrePlatformHierarchyInterface.cpp (modified) (7 diffs)
• src/OgreSceneNodeHierarchyInterface.cpp (modified) (1 diff)
• src/OgreSolidHalfBoundingBox.cpp (modified) (6 diffs)
• src/OgreVisibilityTerrainSceneManager.cpp (modified) (1 diff)

trunk/VUT/Ogre/include/OgrePlatformHierarchyInterface.h

@@ -77 +77 @@
         */
         void RenderBoundingBox(AxisAlignedBox *box);
-        /** Returns one half of the bounding box.
-                @param half the half index of the bouding box (0 or 1)
+        /** Returns pointer to current renderable half bounding box geometry
         */
-        SolidHalfBoundingBox *GetSolidHalfBoundingBox(int half);
+        SolidHalfBoundingBox *GetSolidHalfBoundingBox();
 
-        /** two halfes of an aabb. 
+        /** one renderable half of an aabb. 
         */
-        SolidHalfBoundingBox *mHalfBoundingBox[2];      
+        SolidHalfBoundingBox *mSolidHalfBoundingBox;
 
         SceneManager *mSceneManager;
@@ -91 +90 @@
         Camera *mCamera;
         AxisAlignedBox mBox;
-
+        
         std::vector<PlatformOcclusionQuery *> mOcclusionQueries;
 };

trunk/VUT/Ogre/include/OgreSceneNodeHierarchyInterface.h

@@ -36 +36 @@
 
         AxisAlignedBox *GetBoundingBox(GtpVisibility::HierarchyNode *node);
-
-protected:
-        
-        
 };
 

trunk/VUT/Ogre/include/OgreSolidHalfBoundingBox.h

@@ -15 +15 @@
 public:
 
-        SolidHalfBoundingBox(bool isFirstHalf);
-        void setupBoundingBox(const AxisAlignedBox& aabb);
-        /** Override this method to prevent parent transforms (rotation,translation,scale)
-                and to make it public.
+        SolidHalfBoundingBox();
+        /** Sets up the first or second half of a solid bounding box.
+                @param aab the axis aligned bounding box
+                @param isFirstHalf if it is the first or the second half
+        */
+        void SetupBoundingBox(const AxisAlignedBox& aabb, const bool isFirstHalf);
+        
+protected:
+    /** Builds the wireframe line list.
+                @param aab the axis aligned bounding box for setting up the vertices
+                @param first or second half of the box
     */
-        void getWorldTransforms(Matrix4* xform) const;
-
-protected:
-    
-    /** Builds the wireframe line list.
-                @param aab the axis aligned bounding box for setting up the list.
-    */
-        void setupBoundingBoxVertices(const AxisAlignedBox& aab);
+        void SetupBoundingBoxVertices(const AxisAlignedBox& aab, const bool isFirstHalf);
         /** 
                 Sets the material used for occlusion queries. 
@@ -33 +33 @@
                 uses no lighting, no depth write, and no colours
         */
-        void setOcclusionQueryMaterial();
+        void SetOcclusionQueryMaterial();
         /** Whether this half box is the first or the second half of the bounding box. 
         */

trunk/VUT/Ogre/src/OgreOctreeHierarchyInterface.cpp

@@ -140 +140 @@
 AxisAlignedBox *OctreeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node)
 {
-        static_cast<Octree *>(node)->_getCullBounds(&mBox);
+        if(node != mPreviousNode)
+        {
+                mPreviousNode = node;
+                static_cast<Octree *>(node)->_getCullBounds(&mBox);
+        }
 
         return &mBox;

trunk/VUT/Ogre/src/OgrePlatformHierarchyInterface.cpp

@@ -11 +11 @@
 //-----------------------------------------------------------------------
 PlatformHierarchyInterface::PlatformHierarchyInterface(SceneManager *sm, RenderSystem *rsys):
-mSceneManager(sm), mRenderSystem(rsys)
-{               
-        mHalfBoundingBox[0] = mHalfBoundingBox[1] = NULL;
+mSceneManager(sm), mRenderSystem(rsys), mSolidHalfBoundingBox(NULL)
+{
 }
 //-----------------------------------------------------------------------
@@ -19 +18 @@
 {
         DeleteQueries();
-        
-        if (mHalfBoundingBox[0]) 
-                delete mHalfBoundingBox[0];
 
-        if (mHalfBoundingBox[1]) 
-                delete mHalfBoundingBox[1];
+        if(mSolidHalfBoundingBox)
+                delete mSolidHalfBoundingBox;
 }
 //-----------------------------------------------------------------------
@@ -38 +34 @@
 {
         // Render two halfes of the bounding box (using triangle fans)
-        for(int half = 0; half < 2; half ++)
+        for(int halfIdx = 0; halfIdx < 2; ++halfIdx)
         {
-                static Matrix4 xform[256];
-                //TODO: this should be full bounding box
-                SolidHalfBoundingBox *halfbox = GetSolidHalfBoundingBox(half);
-                halfbox->setupBoundingBox(*box);
-                
+                //TODO: this should be the full bounding box
+                SolidHalfBoundingBox *halfbox = GetSolidHalfBoundingBox();
+                halfbox->SetupBoundingBox(*box, halfIdx == 1);
+                                
                 mRenderSystem->_setWorldMatrix(Ogre::Matrix4::IDENTITY);
                 
@@ -50 +45 @@
 
         mSceneManager->useRenderableViewProjMode(halfbox);
-                mSceneManager->setPass(halfbox->getTechnique()->getPass(0));
+                mSceneManager->setPass(GetSolidHalfBoundingBox()->getTechnique()->getPass(0));
                 halfbox->getRenderOperation(ro);
-                ro.srcRenderable = halfbox; 
+                ro.srcRenderable = halfbox;
                 mRenderSystem->_render(ro);
-                
-                // matt: change this
-//              mSceneManager->myrenderSingleObject(getSolidHalfBoundingBox(half), 
-//                      getSolidHalfBoundingBox(half)->getTechnique()->getPass(0), true);
         }
-}
-//-----------------------------------------------------------------------
-SolidHalfBoundingBox *PlatformHierarchyInterface::GetSolidHalfBoundingBox(int half)
-{
-        if(!mHalfBoundingBox[half])
-                mHalfBoundingBox[half] = new Ogre::SolidHalfBoundingBox(half == 1);
-
-        return mHalfBoundingBox[half];  
 }
 //-----------------------------------------------------------------------
@@ -100 +83 @@
 }
 //-----------------------------------------------------------------------
-bool PlatformHierarchyInterface::CheckFrustumVisible(GtpVisibility::HierarchyNode *node, bool &intersects)
+bool PlatformHierarchyInterface::CheckFrustumVisible(GtpVisibility::HierarchyNode *node, 
+                                                                                                         bool &intersects)
 {
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
@@ -109 +93 @@
 }
 //-----------------------------------------------------------------------
-GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery(GtpVisibility::HierarchyNode *node) 
+GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery(
+        GtpVisibility::HierarchyNode *node) 
 {
         // get next available test id
@@ -123 +108 @@
         return query;
 }
+//-----------------------------------------------------------------------
+SolidHalfBoundingBox *PlatformHierarchyInterface::GetSolidHalfBoundingBox()
+{
+        if(!mSolidHalfBoundingBox)
+                mSolidHalfBoundingBox = new SolidHalfBoundingBox;
+
+        return mSolidHalfBoundingBox;
+}
 
 } // namespace Ogre

trunk/VUT/Ogre/src/OgreSceneNodeHierarchyInterface.cpp

@@ -123 +123 @@
 AxisAlignedBox *SceneNodeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node)
 {
-        SceneNode *sceneNode = static_cast<SceneNode *>(node);
+        if(node != mPreviousNode)
+        {
+                mPreviousNode = node;
+
+                mBox = static_cast<SceneNode *>(node)->_getWorldAABB();
+        }
+
         return &mBox;
 }

trunk/VUT/Ogre/src/OgreSolidHalfBoundingBox.cpp

@@ -12 +12 @@
 #define POSITION_BINDING 0
 //-----------------------------------------------------------------------
-SolidHalfBoundingBox::SolidHalfBoundingBox(bool isFirstHalf)
-        :WireBoundingBox(), mIsFirstHalf(isFirstHalf)
+SolidHalfBoundingBox::SolidHalfBoundingBox()
 {
-        setOcclusionQueryMaterial();
+        SetOcclusionQueryMaterial();
         
         mRenderOp.vertexData->vertexCount = 8;
@@ -21 +20 @@
 }
 //-----------------------------------------------------------------------
-void SolidHalfBoundingBox::setupBoundingBoxVertices(const AxisAlignedBox& aab) {
-
+void SolidHalfBoundingBox::SetupBoundingBoxVertices(const AxisAlignedBox& aab, 
+                                                                                                        const bool isFirstHalf) 
+{
         Vector3 vmax = aab.getMaximum();
         Vector3 vmin = aab.getMinimum();
-        
-        
+                
         Real sqLen = std::max(vmax.squaredLength(), vmin.squaredLength());
     mRadius = Math::Sqrt(sqLen);
@@ -38 +37 @@
         Real minz = vmin.z;
         
-        // fill in the Vertex buffer: 12 lines with 2 endpoints each make up a box
+        // fill the vertex buffer: 12 lines with 2 endpoints each make up a box
     HardwareVertexBufferSharedPtr vbuf =
         mRenderOp.vertexData->vertexBufferBinding->getBuffer(POSITION_BINDING);     
@@ -55 +54 @@
 
         // fan 1
-        if(mIsFirstHalf)
+        if(isFirstHalf)
         {
                 *pPos++ = minx; *pPos++ = maxy; *pPos++ = maxz; //011
@@ -66 +65 @@
                 *pPos++ = minx; *pPos++ = miny; *pPos++ = minz; //000
                 *pPos++ = minx; *pPos++ = miny; *pPos++ = maxz; //001
-
         }
         else
@@ -84 +82 @@
     vbuf->unlock();
 }
-
-void SolidHalfBoundingBox::setupBoundingBox(const AxisAlignedBox& aabb) 
+//-----------------------------------------------------------------------
+void SolidHalfBoundingBox::SetupBoundingBox(const AxisAlignedBox& aabb, 
+                                                                                        const bool isFirstHalf) 
 {
         // init the vertices to the aabb
-        SolidHalfBoundingBox::setupBoundingBoxVertices(aabb);
+        SetupBoundingBoxVertices(aabb, isFirstHalf);
 
     // setup the bounding box of this SimpleRenderable
         setBoundingBox(aabb);
 }
-// Override this method to prevent parent transforms (rotation,translation,scale)
-void SolidHalfBoundingBox::getWorldTransforms( Matrix4* xform ) const
-{
-        // return identity matrix to prevent parent transforms
-    *xform = Matrix4::IDENTITY;
-}
-
-void SolidHalfBoundingBox::setOcclusionQueryMaterial( void )
+//-----------------------------------------------------------------------
+void SolidHalfBoundingBox::SetOcclusionQueryMaterial( void )
 {
         m_pMaterial = MaterialManager::getSingleton().getByName("OcclusionQuery");

trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

@@ -19 +19 @@
 
         setVisibilityManager(visManager);
-        mShowBoxes = true;
+        //mShowBoxes = true;
         //mDisplayNodes = true;
-        mShowBoundingBoxes = true;
+        //mShowBoundingBoxes = true;
         mMaxDepth = 20;
 }