Changeset 3065 for GTP

Timestamp:

10/24/08 12:29:30 (16 years ago)

Author:

mattausch

Message:

found bug with near plane intersection: q? why did it work with vbo rendering? (probably because of tighter bounds ...)

Location:

GTP/trunk/App/Demos/Vis/FriendlyCulling

Files:

• default.env (modified) (1 diff)
• src/AxisAlignedBox3.cpp (modified) (2 diffs)
• src/Bvh.cpp (modified) (27 diffs)
• src/Bvh.h (modified) (16 diffs)
• src/BvhLoader.cpp (modified) (1 diff)
• src/CHCPlusPlusTraverser.cpp (modified) (1 diff)
• src/CHCTraverser.cpp (modified) (1 diff)
• src/Material.cpp (modified) (5 diffs)
• src/Material.h (modified) (1 diff)
• src/RenderState.cpp (modified) (3 diffs)
• src/RenderState.h (modified) (1 diff)
• src/RenderTraverser.h (modified) (2 diffs)
• src/StopAndWaitTraverser.cpp (modified) (2 diffs)
• src/chcdemo.cpp (modified) (5 diffs)

GTP/trunk/App/Demos/Vis/FriendlyCulling/default.env

@@ -4 +4 @@
 assumedVisibleFrames=10
 maxBatchSize=50
-trianglesPerVirtualLeaf=300
+#trianglesPerVirtualLeaf=300
+trianglesPerVirtualLeaf=30000
 keyForwardMotion=20.0f
 keyRotation=1.5f

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/AxisAlignedBox3.cpp

@@ -56 +56 @@
 {
         return (mMin == Vector3(-MAXFLOAT)) || 
-                (mMax == Vector3(-MAXFLOAT));
+                   (mMax == Vector3(-MAXFLOAT));
 }
 
@@ -216 +216 @@
 AxisAlignedBox3::IsInside(const Vector3 &v) const
 {
-        return ! ((v.x < mMin.x) ||
-                (v.x > mMax.x) ||
-                (v.y < mMin.y) ||
-                (v.y > mMax.y) ||
-                (v.z < mMin.z) ||
-                (v.z > mMax.z));
+        return !((v.x < mMin.x) ||
+                    (v.x > mMax.x) ||
+                        (v.y < mMin.y) ||
+                        (v.y > mMax.y) ||
+                        (v.z < mMin.z) ||
+                        (v.z > mMax.z));
 }
 

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Bvh.cpp

@@ -27 +27 @@
 #endif
 
+#define INVALID_TEST ((unsigned int)-1)
+
+using namespace std;
 
 namespace CHCDemoEngine
 {
-
-#define INVALID_TEST ((unsigned int)-1)
-
-using namespace std;
-
 
 int BvhNode::sCurrentState = 0;
@@ -76 +74 @@
 
 static Plane3 sNearPlane;
+static float sNear;
 static Frustum sFrustum;
 
@@ -147 +146 @@
 
 
-/***********************************************************/
-/*                class Bvh implementation                 */
-/***********************************************************/
+/**********************************************************/
+/*                class Bvh implementation                */
+/**********************************************************/
 
 
@@ -183 +182 @@
 
         if (mRoot) delete mRoot;
-
         // delete vbo
         glDeleteBuffersARB(1, &mVboId);
@@ -191 +189 @@
 void Bvh::Init()
 {
-        mStaticRoot = NULL;
+        //mStaticRoot = NULL;
         mDynamicRoot = NULL;
         mRoot = NULL;
@@ -202 +200 @@
         
         // nodes are tested using the subnodes from 3 levels below
-        mMaxDepthForTestingChildren = 3;
+        mMaxDepthForTestingChildren = 0;//3;
         //mMaxDepthForTestingChildren = 4;
 
@@ -311 +309 @@
                 tStack.pop();
 
-                // found depth => take this node
+                // found node in specified depth => take this node
                 if ((d == depth) || (node->IsLeaf()))
                 {
@@ -338 +336 @@
         // do the test only if necessary
         if (!(node->mPlaneMask[BvhNode::sCurrentState] & (1 << i)))
+        {
                 return true;
-                        
+        }
+
+
         ////////
         //-- test the n-vertex
@@ -375 +376 @@
 
         ////////
-        //-- apply frustum culling for the planes [mPreferredPlane - 5]
+        //-- apply frustum culling for the planes with index mPreferredPlane to 6
 
         for (int i = node->mPreferredPlane[BvhNode::sCurrentState]; i < 6; ++ i)
@@ -382 +383 @@
 
         //////////
-        //-- do the view frustum culling for the planes [0 - m_iPreferredPlane)
+        //-- apply frustum culling for the planes with index 0 to mPreferredPlane
 
         for (int i = 0; i < node->mPreferredPlane[BvhNode::sCurrentState]; ++ i)
@@ -413 +414 @@
         // store near plane
         sNearPlane = Plane3(cam->GetDirection(), cam->GetPosition());
+        sNear = cam->GetNear();
 
         // rebuild dynamic part of the hierarchy
@@ -424 +426 @@
 void Bvh::UpdateDistance(BvhNode *node) const
 {
-        // use distance to center rather than the distance to the near plane because
-        // otherwise problems with big object penetrating the near plane 
+        // q: should we use distance to center rather than the distance to the near plane?
+        
+        // because otherwise problems with big object penetrating the near plane 
         // (e.g., big objects in the distance which are then always visible)
         // especially annoying is this problem when using the frustum 
         // fitting on the visible objects for shadow mapping
-
-        //node->mDistance = node->GetBox()GetMinDistance(sNearPlane);
+        // on the other hand, distance to near plane can also be used 
+        // for near plane intersection
         node->mDistance = sNearPlane.Distance(node->GetBox().Center());
+        //node->mDistance = node->GetBox().GetMinDistance(sNearPlane);
 }
 
@@ -458 +462 @@
 void Bvh::RenderBounds(BvhNode *node, RenderState *state, bool useTightBounds)
 {
-        // if not using tight bounds, rendering boxes in immediate mode
-        // is preferable to vertex arrays (less setup time)
-        if (!useTightBounds)
-        {
-                RenderBoundingBoxImmediate(node->GetBox());
-        }
-        else
-        {
-                // hack: use dummy wrapper in order to use function
-                static BvhNodeContainer dummy(1);
-                dummy[0] = node;
-                RenderBounds(dummy, state, useTightBounds);
-        }
+        // hack: use dummy contayiner as wrapper in order to use multibox function
+        static BvhNodeContainer dummy(1);
+        dummy[0] = node;
+        RenderBounds(dummy, state, useTightBounds);
 }
 
@@ -490 +485 @@
                         RenderBoundingBoxImmediate((*nit)->GetBox());
                 }
-cout<<"y";
+
                 renderedBoxes = (int)nodes.size();
         }
         else
-        {cout<<"x";
+        {
                 renderedBoxes = PrepareBoundsWithDrawArrays(nodes);
                 RenderBoundsWithDrawArrays(renderedBoxes, state);
@@ -529 +524 @@
         {
                 BvhNode *node = *nit;
-
         const int numIndices = node->mNumTestNodes * sNumIndicesPerBox;
                 
@@ -569 +563 @@
         // collect bvh nodes
         BvhNodeContainer nodes;
-        CollectNodes(mStaticRoot, nodes);
+        CollectNodes(mRoot, nodes);
 
         cout << "creating new indices" << endl;
@@ -587 +581 @@
         }
 
-
         cout << "creating global indices buffer" << endl;
 
@@ -607 +600 @@
                 // resize array
                 node->mIndicesPtr = mCurrentIndicesPtr;
-
                 int numIndices = 0;
 
-                // the bounding box of the test nodes are rendered instead of the root node
+                // the bounding boxes of the test nodes are rendered instead of the node itself
                 // => store their indices
                 for (int i = 0; i < node->mNumTestNodes; ++ i, numIndices += sNumIndicesPerBox)
@@ -657 +649 @@
 
         nodes.reserve(GetNumStaticNodes());
-        CollectNodes(mStaticRoot, nodes);
+        CollectNodes(mRoot, nodes);
 
         const unsigned int bufferSize = 8 * (int)nodes.size();
@@ -717 +709 @@
         // collect all nodes
         BvhNodeContainer nodes;
-        CollectNodes(mStaticRoot, nodes);
+        CollectNodes(mRoot, nodes);
 
         cout << "recomputing bounds, children will be tested in depth " << mMaxDepthForTestingChildren << endl;
@@ -930 +922 @@
         // first invalidate old virtual leaves
         BvhNodeContainer leaves;
-        CollectVirtualLeaves(mStaticRoot, leaves);
+        CollectVirtualLeaves(mRoot, leaves);
 
         BvhNodeContainer::const_iterator bit, bit_end = leaves.end();
@@ -998 +990 @@
 
         std::stack<BvhNode *> nodeStack;
-        nodeStack.push(mStaticRoot);
+        nodeStack.push(mRoot);
 
         while (!nodeStack.empty()) 
@@ -1039 +1031 @@
         const Vector3 u = box.Max();
 
+        ///////////
+        //-- render AABB as triangle strips
+
         glBegin(GL_TRIANGLE_STRIP);
-        {
-                ///////////
-                //-- render AABB as triangle strips
-
-                // render first half of AABB
-                glVertex3f(l.x, l.y, u.z);
-                glVertex3f(u.x, l.y, u.z);
-                glVertex3f(l.x, u.y, u.z);
-                glVertex3f(u.x, u.y, u.z);
-                glVertex3f(l.x, u.y, l.z); 
-                glVertex3f(u.x, u.y, l.z);
-                glVertex3f(l.x, l.y, l.z); 
-                glVertex3f(u.x, l.y, l.z);
-
-                glPrimitiveRestartNV();
-
-                // render second half of AABB
-                glVertex3f(l.x, u.y, u.z); 
-                glVertex3f(l.x, u.y, l.z);
-                glVertex3f(l.x, l.y, u.z);
-                glVertex3f(l.x, l.y, l.z);
-                glVertex3f(u.x, l.y, u.z); 
-                glVertex3f(u.x, l.y, l.z);
-                glVertex3f(u.x, u.y, u.z); 
-                glVertex3f(u.x, u.y, l.z);
-        }
+
+        // render first half of AABB
+        glVertex3f(l.x, l.y, u.z);
+        glVertex3f(u.x, l.y, u.z);
+        glVertex3f(l.x, u.y, u.z);
+        glVertex3f(u.x, u.y, u.z);
+        glVertex3f(l.x, u.y, l.z); 
+        glVertex3f(u.x, u.y, l.z);
+        glVertex3f(l.x, l.y, l.z); 
+        glVertex3f(u.x, l.y, l.z);
+
+        glPrimitiveRestartNV();
+
+        // render second half of AABB
+        glVertex3f(l.x, u.y, u.z); 
+        glVertex3f(l.x, u.y, l.z);
+        glVertex3f(l.x, l.y, u.z);
+        glVertex3f(l.x, l.y, l.z);
+        glVertex3f(u.x, l.y, u.z); 
+        glVertex3f(u.x, l.y, l.z);
+        glVertex3f(u.x, u.y, u.z); 
+        glVertex3f(u.x, u.y, l.z);
+
         glEnd();
 }
-
-
 
 
@@ -1123 +1113 @@
                                                          bool useTightBounds)
 {
-        glDisable(GL_TEXTURE_2D);
-        glDisable(GL_LIGHTING);
         glColor3f(1, 1, 1);
 
         // hack: for deferred shading we have to define a material
         static Technique boxMat;
+        boxMat.SetLightingEnabled(false);
+
         boxMat.SetEmmisive(RgbaColor(1.0f, 1.0f, 1.0f, 1.0f));
 
@@ -1135 +1125 @@
         if (!useTightBounds)
         {
-                RenderBoxForViz(node->GetBox());
+                //RenderBoxForViz(node->GetBox());
+                glPolygonMode(GL_FRONT, GL_LINE);
+                RenderBoundingBoxImmediate(node->GetBox());
+                glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
         }
         else
@@ -1144 +1137 @@
                 }
         }
-
-        glEnable(GL_LIGHTING);
-        glEnable(GL_TEXTURE_2D);
 }
 
@@ -1297 +1287 @@
 
 
-}
+bool Bvh::IntersectsNearPlane(BvhNode *node) const
+{ 
+        float distanceToNearPlane = node->GetBox().GetMinDistance(sNearPlane);
+        // we stored the near plane distance => we can use it also here
+        //float distanceToNearPlane = node->GetDistance();
+        
+        return distanceToNearPlane < sNear;
+}
+
+
+}

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Bvh.h

@@ -62 +62 @@
         */
         BvhNode(BvhNode *parent);
+        /** Virtual destructor doing nothing.
+        */
+        virtual ~BvhNode();
+        /** Reset the status of this node.
+        */
+        virtual void ResetVisibility();
         /** Returns true if this node is a leaf.
         */
-        //virtual bool IsPseudoLeaf() = 0;
-        /** Virtual destructor doing nothing.
-        */
-        virtual ~BvhNode();
+        virtual bool IsLeaf() const = 0;
         /** Depth of this node in the tree.
         */
-        inline int GetDepth() const {return mDepth;}
+        inline int GetDepth() const;
         /** Returns parent of this bvh node, NULL if it is root.
         */
-        inline BvhNode *GetParent() {return mParent;}
+        inline BvhNode *GetParent();
         /** Number of leaves in the subtree induced by this node.
         */
-        inline int GetNumLeaves() const {return mNumLeaves;}
-        /** Reset the status of this node.
-        */
-        virtual void ResetVisibility();
-
-        virtual bool IsLeaf() const = 0;
-
-        bool IsVirtualLeaf() const { return mIsVirtualLeaf; }
-
+        inline int GetNumLeaves() const;
+        /** Returns true if this node is a "virtual" leaf,
+                i.e., the node is handled as a leaf during traversal.
+        */
+        inline bool IsVirtualLeaf() const;
         /** Returns the stored distance to the near plane.
         */
-        float GetDistance() const  { return mDistance; }
+        inline float GetDistance() const;
 
 
@@ -131 +130 @@
         /** Returns the bounding box of this node.
         */
-        inline const AxisAlignedBox3 &GetBox() { return mBox; }
+        inline const AxisAlignedBox3 &GetBox() const;
         /** Return index of this node.
         */
-        inline int GetId() const { return mId; }
+        inline int GetId() const;
         /** See get
         */
-        inline void SetId(int id) { mId = id; }
+        inline void SetId(int id);
 
 
@@ -160 +159 @@
                 order to not break temporal coherency.
         */
-        static void SetCurrentState(int _state) { sCurrentState = _state; }
+        inline static void SetCurrentState(int _state) { sCurrentState = _state; }
 
 
@@ -174 +173 @@
 
         //////////////
-        //-- members that define the current state. There is one state for each camera
+        //-- members definig the current visibility state (one state per camera)
 
         /// the currently used state
@@ -197 +196 @@
         /// #leaves under this node
         int mNumLeaves;
-
-
-        ////////////
-        //-- rendering related options
-        
-        
-        // Indices to first and last triangle in the triangle array
-        // assumes the triangle are placed in continuous chunk of memory
-        // however this need not be a global array!
-        
-        /// the index of the first triangle
-        int mFirst;
-        /// the index of the last triangle
-        int mLast;
-
-        /// the bounding boxes of these nodes are queries instead of the current node
-        int mTestNodesIdx;
-        /// the number of tighter bounding volumes used for this node
-        int mNumTestNodes;
-        /// used for efficient element array rendering
-        int mIndicesPtr;
-
         /// Area of this node
         float mArea;
@@ -236 +213 @@
         */
         bool mIsMaxDepthForVirtualLeaf;
+
+
+        ////////////
+        //-- rendering related options
+        
+        // Indices to first and last triangle in the triangle array
+        // assumes the triangle are placed in continuous chunk of memory
+        // however this need not be a global array!
+        
+        /// the index of the first triangle
+        int mFirst;
+        /// the index of the last triangle
+        int mLast;
+
+
+        ////////////////
+        //-- rendering related options
+
+        /// the bounding boxes of the test nodes are queries instead of the actual node
+        int mTestNodesIdx;
+        /// the number of these test nodes
+        int mNumTestNodes;
+        /// used for efficient element array rendering
+        int mIndicesPtr;
 };
 
@@ -357 +358 @@
 }
 
-
+int BvhNode::GetDepth() const 
+{ 
+        return mDepth; 
+}
+
+
+BvhNode *BvhNode::GetParent() 
+{ 
+        return mParent; 
+}
+
+
+int BvhNode::GetNumLeaves() const
+{
+        return mNumLeaves;
+}
+
+
+bool BvhNode::IsVirtualLeaf() const
+{ 
+        return mIsVirtualLeaf; 
+}
+
+
+float BvhNode::GetDistance() const
+{
+        return mDistance; 
+}
+
+        
+const AxisAlignedBox3 &BvhNode::GetBox() const
+{
+        return mBox; 
+}
+
+
+int BvhNode::GetId() const 
+{
+        return mId; 
+}
+
+
+void BvhNode::SetId(int id) 
+{
+        mId = id; 
+}
 
 
@@ -383 +429 @@
         virtual ~BvhInterior();
 
+
 protected:
 
@@ -409 +456 @@
         a lower distance has a higher value in the queue
 */
-class mygreaterdistance
+class GtDistance
 {
 public:
@@ -418 +465 @@
 };
 
-typedef std::priority_queue<BvhNode *, std::vector<BvhNode *>, mygreaterdistance> TraversalQueue;
+typedef std::priority_queue<BvhNode *, std::vector<BvhNode *>, GtDistance> TraversalQueue;
 
 
@@ -464 +511 @@
         /** Returns number of bvh nodes.
         */
-        inline int GetNumNodes() const { return mNumNodes; }
+        inline int GetNumNodes() const;
         /** Returns number of bvh leaves.
         */
-        inline int GetNumLeaves() const { return mNumNodes / 2 + 1;}
+        inline int GetNumLeaves() const;
         /** Returns number of 'virtual' nodes in the hierarchy, i.e.
                 the number of nodes actually used for traversal.
         */
-        int GetNumVirtualNodes() const  { return mNumVirtualNodes; }
+        inline int GetNumVirtualNodes() const;
         /** Returns number of bvh leaves.
         */
-        inline int GetNumVirtualLeaves() const { return mNumVirtualNodes / 2 + 1;}
+        inline int GetNumVirtualLeaves() const;
         /** Returns root node of the bvh.
         */
-        BvhNode *GetRoot() { return mRoot; }
-        
+        inline BvhNode *GetRoot();
+        /** Returns the bounding box of this bvh.
+        */
+        inline const AxisAlignedBox3 &GetBox() const;
+        /** Returns true if the current bvh node intersects the near plane.
+        */
+        bool IntersectsNearPlane(BvhNode *node) const; 
+
+
         ///////////////
         //-- functions collecting nodes based on some criteria
 
-        /** Collect all nodes higher or equal to a given depth.
+        /** Collect all child nodes in a given depth from the specified node.
         */
         void CollectNodes(BvhNode *node, BvhNodeContainer &nodes, int depth);
@@ -489 +543 @@
         */
         void CollectLeaves(BvhNode *node, BvhLeafContainer &leaves);
-        /** Collect only the virtual leaves (can be anywhere in the Žhierarchy).
+        /** Collect only the virtual leaves (can be anywhere in the hierarchy).
         */
         void CollectVirtualLeaves(BvhNode *node, BvhNodeContainer &leaves);
@@ -512 +566 @@
         */
         int RenderBounds(const BvhNodeContainer &nodes, RenderState *state, bool useTightBounds);
-        /** Returns the bounding box of this bvh.
-        */
-        inline const AxisAlignedBox3 &GetBox() { return mBox; }
+        
 
 
@@ -656 +708 @@
 
         /////////////////////////////
-        // functions that are required to build the dynamic part of the hierarchy
+        //-- functions used to construct the dynamic part of the hierarchy
+
         int SortTriangles(BvhLeaf *leaf, 
                               int axis, 
@@ -686 +739 @@
         BvhNode *mRoot;
         /// the root of static part of the the hierarchy
-        BvhNode *mStaticRoot;
+        //BvhNode *mStaticRoot;
         /// the root of dynamic part of the the hierarchy
         BvhNode *mDynamicRoot;
@@ -741 +794 @@
 };
 
+
+
+/////////////////
+//-- public inline functions
+
+
+int Bvh::GetNumNodes() const
+{
+        return mNumNodes; 
+}
+
+
+int Bvh::GetNumLeaves() const 
+{ 
+        return mNumNodes / 2 + 1;
+}
+
+
+int Bvh::GetNumVirtualNodes() const  
+{ 
+        return mNumVirtualNodes; 
+}
+
+
+int Bvh::GetNumVirtualLeaves() const
+{
+        return mNumVirtualNodes / 2 + 1;
+}
+
+
+BvhNode *Bvh::GetRoot()
+{ 
+        return mRoot; 
+}
+
+
+const AxisAlignedBox3 &Bvh::GetBox() const 
+{ 
+        return mBox; 
+}
+
+
 }
 

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/BvhLoader.cpp

@@ -73 +73 @@
 
         Bvh *bvh = new Bvh(entities);
-        bvh->mStaticRoot = LoadNextNode(stream, NULL);
+
+        BvhNode *root = LoadNextNode(stream, NULL);
 
 #if 1
-        bvh->mRoot = bvh->mStaticRoot;
-        bvh->mNumNodes = 1;
+
+        bvh->mRoot = root;
+
 #else
+        // copy root and set new one for dynamic objects
+        BvhInterior *newRoot = new BvhInterior(NULL);
+        
+        newRoot->mBox = root->mBox;
+        newRoot->mFirst = root->mFirst;
+        newRoot->mLast = root->mLast;
 
-        // we are setting a new root node 
-        // and adds one level of indirection to the bvh 
-        // It allows us to use dynamic objects
+        // create 'dynamic' leaf which basically is a container
+        // for all dynamic objects
+        BvhLeaf *dynamicLeaf = new BvhLeaf(newRoot);
+        dynamicLeaf->mBox = root->mBox;
 
-        // the new bvh has two main branches
-        // a static branch (the old root), and adynamic branch 
-        // we create a 'dynamic' leaf which basically is a container
-        // for all dynamic objects underneath
-        // the bounding boxes of the dynamic tree must be updated
-        // once each frame in order to be able to incorporate
-        // the movements of the objects within
+        newRoot->mFront = root;
+        root->mParent = newRoot;
 
-        // create new root
-        BvhInterior *newRoot = new BvhInterior(NULL);
+        newRoot->mBack = dynamicLeaf;
+
         bvh->mRoot = newRoot;
-
-        // the separation is a purely logical one
-        // the bounding boxes of the child nodes are 
-        // identical to those of the root node
-
-        newRoot->mBox = bvh->mStaticRoot->mBox;
-        newRoot->mArea = newRoot->mBox.SurfaceArea();
-
-        newRoot->mFirst = bvh->mStaticRoot->mFirst;
-        newRoot->mLast = bvh->mStaticRoot->mLast;
-
-        // add static root on left subtree
-        newRoot->mFront = bvh->mStaticRoot;
-        bvh->mStaticRoot->mParent = newRoot;
-        
-        // create and add dynamic root
-        BvhLeaf *dynamicRoot = new BvhLeaf(newRoot);
-        
-        dynamicRoot->mFirst = 0;
-        dynamicRoot->mLast = 0;
-        dynamicRoot->mBox = bvh->mStaticRoot->mBox;
-        dynamicRoot->mArea = dynamicRoot->mBox.SurfaceArea();
-
-        bvh->mDynamicRoot = dynamicRoot;
-        newRoot->mBack = dynamicRoot;
-
-        bvh->mNumNodes = 1;
-
 #endif
 
-        tQueue.push(bvh->mStaticRoot);
+        tQueue.push(bvh->mRoot);
+        bvh->mNumNodes = 1;
 
         while(!tQueue.empty())

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/CHCPlusPlusTraverser.cpp

@@ -123 +123 @@
                                 // for near plane intersecting bounding box possible 
                                 // wrong results => skip occlusion query
-                                if (IntersectsNearPlane(node))
+                                if (mBvh->IntersectsNearPlane(node))
                                 {
                                         // update node's visited flag

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/CHCTraverser.cpp

@@ -71 +71 @@
                                 // for near plane intersecting bounding box possible 
                                 // wrong results => skip occlusion query
-                                if (IntersectsNearPlane(node))
+                                if (mBvh->IntersectsNearPlane(node))
                                 {
                                         // update node's visited flag

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Material.cpp

@@ -36 +36 @@
         /// if depth write should be enabled
         mDepthWriteEnabled = true;
-
+        /// the render queue bucket this technique is assigned to
         mRenderQueueBucket = NULL;
 }
@@ -60 +60 @@
 }
 
-/*
-Technique::Technique(const Technique &tech)
-{
-        mAmbientColor = tech.mAmbientColor;
-        mDiffuseColor = tech.mDiffuseColor;
-        mSpecularColor = tech.mSpecularColor;
-        mEmmisiveColor = tech.mEmmisiveColor;
-
-        mVertexProgram = tech.mVertexProgram;
-        mFragmentProgram = tech.mFragmentProgram;
-
-        mAlphaTestEnabled = tech.mAlphaTestEnabled;
-        mCullFaceEnabled = tech.mCullFaceEnabled;
-
-        mTexture = tech.mTexture;
-
-        mVertexProgramParameters = tech.mVertexProgramParameters;
-        mFragmentProgramParameters = tech.mFragmentProgramParameters;
-
-        mColorWriteEnabled = tech.mColorWriteEnabled;
-        mLightingEnabled = tech.mLightingEnabled;
-        mDepthWriteEnabled = tech.mDepthWriteEnabled;
-}*/
-
-
-Technique::~Technique()
-{
-}
-
 
 void Technique::Render(RenderState *state)
@@ -103 +74 @@
 void Technique::SetFragmentProgram(ShaderProgram *p) 
 { 
-        mFragmentProgram = p; 
-
+        mFragmentProgram = p;
         mFragmentProgramParameters.Reset();
         mFragmentProgramParameters.SetProgram(p);
@@ -113 +83 @@
 { 
         mVertexProgram = p; 
-
         mVertexProgramParameters.Reset();
         mVertexProgramParameters.SetProgram(p);
@@ -119 +88 @@
 
 
-/***********************************************/
-/*        class Material implementation        */
-/***********************************************/
+
+/***************************************************/
+/*          class Material implementation          */
+/***************************************************/
 
 

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Material.h

@@ -56 +56 @@
         */
         Technique();
-
-        //Technique(const Technique &tech);
         /** Sets ambient and diffuse color to color
         */
         Technique(const RgbaColor &color);
-
-        ~Technique();
         /** Renders this technique.
         */

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderState.cpp

@@ -86 +86 @@
 
 
-// q matt: is this function really necessary or would it be better
-// to just create a query material and use the setstate function?
+static Technique GetDummyTechnique()
+{
+        Technique tech;
+        tech.Init();
+
+        tech.SetColorWriteEnabled(true);
+        tech.SetLightingEnabled(true);
+        tech.SetDepthWriteEnabled(false);
+        //tech.SetCullFaceEnabled(false);
+
+        return tech;
+}
+
+/** A special technique for occlusion queries. This material
+        has color write, depth write, and lighting turned off
+*/
+static Technique GetQueryTechnique()
+{
+        Technique tech;
+        tech.Init();
+
+        tech.SetColorWriteEnabled(false);
+        tech.SetLightingEnabled(false);
+        tech.SetDepthWriteEnabled(false);
+        //tech.SetCullFaceEnabled(false);
+
+        return tech;
+}
+
+
 bool RenderState::SetMode(Mode mode)
 {
@@ -101 +129 @@
                 /// the query box material
                 static Technique queryTech = GetQueryTechnique();
-                SetState(&queryTech);
+                static Technique dummyTech = GetDummyTechnique();
+
+                //if ((float)rand() / RAND_MAX < 0.2)
+                //      SetState(&dummyTech);
+                //else 
+                        SetState(&queryTech);
         }
 
@@ -286 +319 @@
 
 
-Technique RenderState::GetQueryTechnique()
-{
-        Technique tech;
-
-        tech.Init();
-
-        tech.SetColorWriteEnabled(false);
-        tech.SetLightingEnabled(false);
-        tech.SetDepthWriteEnabled(false);
-
-        return tech;
-}
-
-
 void RenderState::SetUseAlphaToCoverage(bool useAlphaToCoverage)
 {

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderState.h

@@ -73 +73 @@
 protected:
 
-        /** A special technique for occlusion queries. This material
-                has color write, depth write, and lighting turned off
-        */
-        static Technique GetQueryTechnique();
-
 
         //////////////////

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderTraverser.h

@@ -154 +154 @@
         */
         void IssueOcclusionQuery(const OcclusionQuery &query);
-        /** Retunrs true if the current bvh node intersects the near plane.
-        */
-        inline bool IntersectsNearPlane(BvhNode *node) const; 
         /** Enqueues a bvh node for distance traversal
         */
@@ -216 +213 @@
 
 
-inline bool RenderTraverser::IntersectsNearPlane(BvhNode *node) const
-{ 
-        return node->GetDistance() < mCamera->GetNear();
 }
 
 
 
-}
-
-
-
 #endif // RENDERTRAVERSER_H

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/StopAndWaitTraverser.cpp

@@ -25 +25 @@
                 {
                         // if intersects near plane assume visible and don't issue test
-                        if (IntersectsNearPlane(node))
+                        if (mBvh->IntersectsNearPlane(node))
                         {
                                 TraverseNode(node);
@@ -33 +33 @@
                                 OcclusionQuery *query = IssueOcclusionQuery(node);
 
-                                const bool visible = query->GetQueryResult() > mVisibilityThreshold;
+                                const bool visible = (query->GetQueryResult() > mVisibilityThreshold);
                         
                                 if (visible)

GTP/trunk/App/Demos/Vis/FriendlyCulling/src/chcdemo.cpp

@@ -178 +178 @@
 
 bool useOptimization = false;
-//bool useTightBounds = true;
-bool useTightBounds = false;
+bool useTightBounds = true;
+//bool useTightBounds = false;
 bool useRenderQueue = true;
 bool useMultiQueries = true;
@@ -1765 +1765 @@
 
                 glEnable(GL_TEXTURE_2D);
-
                 myfont.Begin();
 
@@ -1771 +1770 @@
                 {
                         glColor3f(0.0f, 1.0f, 0.0f);
-
                         int i = 0;
 
-                        static char *renderMethodStr[] = {"forward", "depth pass + forward", "deferred shading", "depth pass + deferred"};
+                        static char *renderMethodStr[] = 
+                                {"forward", "depth pass + forward", "deferred shading", "depth pass + deferred"};
         
                         sprintf(msg[i ++], "multiqueries: %d, tight bounds: %d, render queue: %d", 
-                                                        useMultiQueries, useTightBounds, useRenderQueue);
+                                        useMultiQueries, useTightBounds, useRenderQueue);
 
                         sprintf(msg[i ++], "render technique: %s, SSAO: %d", renderMethodStr[renderMethod], useAdvancedShading);
@@ -1831 +1830 @@
                 
                 if (!showAlgorithmTime)
-                                sprintf(msg[7], "%s:  %6.1f fps", alg_str[renderMode], fps);
+                        sprintf(msg[7], "%s:  %6.1f fps", alg_str[renderMode], fps);
                 else
                         sprintf(msg[7], "%s:  %6.1f ms", alg_str[renderMode], rTime);
@@ -1850 +1849 @@
 void RenderSky()
 {
-        buddha->Render(&state);
+        //buddha->Render(&state);
 
         if ((renderMethod == RENDER_DEFERRED) || (renderMethod == RENDER_DEPTH_PASS_DEFERRED))