Changeset 1968 for GTP/trunk/Lib/Vis/Preprocessing/src/GlobalLinesRenderer.cpp

Timestamp:

01/11/07 04:18:36 (18 years ago)

Author:

mattausch

Message:

early exit for global lines
preprocessor support

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/GlobalLinesRenderer.cpp (modified) (10 diffs)

GTP/trunk/Lib/Vis/Preprocessing/src/GlobalLinesRenderer.cpp

@@ -200 +200 @@
 
 
-/*GlobalLinesRenderer::GlobalLinesRenderer(RenderTexture *buffer1, 
-                                                                                 RenderTexture *buffer2, 
-                                                                                 Preprocessor *preprocessor,
-                                                                                 GlRenderer *renderer)
-: mNewTexture(buffer1), mOldTexture(buffer2), mPreprocessor(preprocessor), mMaxDepth(100),
-mRenderer(renderer)
-{
-}
-*/
-
-
 GlobalLinesRenderer::GlobalLinesRenderer(Preprocessor *preprocessor, 
-                                                                                 GlRenderer *renderer,
-                                                                                 const float mTexHeight,
-                                                                                 const float mTexWidth,
-                                                                                 const float eps): 
+                                                                                 const int texHeight,
+                                                                                 const int texWidth,
+                                                                                 const float eps,
+                                                                                 const int maxDepth,
+                                                                                 const bool sampleReverse):
 mNewTexture(NULL), 
 mOldTexture(NULL), 
-mMaxDepth(0), 
-mRenderer(renderer), 
 mPreprocessor(preprocessor),
 mTexHeight(mTexHeight),
 mTexWidth(mTexWidth),
-mEpsilon(eps)
-{
-}
-
-
-GlobalLinesRenderer::GlobalLinesRenderer(Preprocessor *preprocessor, 
-                                                                                 GlRenderer *renderer):
+mEpsilon(eps),
+mMaxDepth(maxDepth),
+mSampleReverse(sampleReverse)
+{
+        mRenderer = new GlRenderer(mPreprocessor->mSceneGraph,
+                                                           mPreprocessor->mViewCellsManager,
+                                                           mPreprocessor->mKdTree);
+
+}
+
+
+GlobalLinesRenderer::GlobalLinesRenderer(Preprocessor *preprocessor):
 mNewTexture(NULL), 
 mOldTexture(NULL), 
-mMaxDepth(0), 
-mRenderer(renderer), 
+mMaxDepth(40), 
 mPreprocessor(preprocessor),
 mTexHeight(128),
 mTexWidth(128),
-mEpsilon(0.0001)
-{}
+mEpsilon(0.0001),
+mSampleReverse(true)
+{
+        mRenderer = new GlRenderer(mPreprocessor->mSceneGraph,
+                                                           mPreprocessor->mViewCellsManager,
+                                                           mPreprocessor->mKdTree);
+}
 
 
@@ -288 +285 @@
         delete mNewItemBuffer;
         delete mOldItemBuffer;
+
+        DEL_PTR(mRenderer);
 }
 
  
-void GlobalLinesRenderer::InitScene(const float alpha, const float beta)
-{
-        AxisAlignedBox3 bbox = globalLinesRenderer->mPreprocessor->mKdTree->GetBox();
-        
-        const float sceneSize = Magnitude(bbox.Diagonal());
-
-        // compute the center of the scene
-        Vector3 midPoint = bbox.Center();
-        
-        // add a small offset to provide some randomness in the sampling
-        Vector3 offset(Random(sceneSize * 1e-3f), 
-                                   Random(sceneSize * 1e-3f), 
-                                   Random(sceneSize * 1e-3f));
-
-        midPoint += offset;
-                
-        mNear = 1;
-        mFar = sceneSize * 2;
-        mWidth = sceneSize;
-
-        ComputeLookAt(alpha, 
-                                  beta,
-                                  mEyeVec, 
-                                  mUpVec,
-                                  mLeftVec);
-        
-        mViewPoint = midPoint - 0.5f * sceneSize * mEyeVec;
-
-        cout << "mid point: " << midPoint << endl;
-        cout << "view point: " << mViewPoint << endl;
-        cout << "scene: " << bbox << endl;
-
+void GlobalLinesRenderer::InitRenderTexture(RenderTexture *rt)
+{
          // setup the rendering context for the RenderTexture
-        mNewTexture->BeginCapture();
+        rt->BeginCapture();
         {
                 //Reshape(mTexWidth, mTexHeight);
@@ -346 +315 @@
                 glLoadIdentity();
                 gluLookAt(mViewPoint.x, mViewPoint.y, mViewPoint.z, 
-                                  midPoint.x, midPoint.y, midPoint.z, 
+                                  mTermination.x, mTermination.y, mTermination.z, 
                                   mUpVec.x, mUpVec.y, mUpVec.z);
 
         }
-        mNewTexture->EndCapture();
-
-        // setup the rendering context for the other depth buffer
-        mOldTexture->BeginCapture();
-        {
-                // for item buffer: white means no color
-                glClearColor(1, 1, 1, 1);
-       
-                //Reshape(mTexWidth, mTexHeight);
-                glViewport(0, 0, mTexWidth, mTexHeight);
-                SetFrustum(mWidth, mWidth, mNear, mFar);
-
-                glMatrixMode(GL_MODELVIEW);
-                glLoadIdentity();
+        rt->EndCapture();
+}
+
+
+void GlobalLinesRenderer::InitScene(const float alpha, const float beta)
+{
+        AxisAlignedBox3 bbox = 
+                globalLinesRenderer->mPreprocessor->mKdTree->GetBox();
+        
+        const float sceneSize = Magnitude(bbox.Diagonal());
+
+        // compute the center of the scene
+        mTermination = bbox.Center();
+        
+        // add a small offset to provide some randomness in the sampling
+        if (0)
+        {
+                Vector3 offset(
+                        Random(sceneSize * 1e-3f), 
+                        Random(sceneSize * 1e-3f), 
+                        Random(sceneSize * 1e-3f));
+
+                mTermination += offset;
+        }
                 
-                glFrontFace(GL_CCW);
-                glCullFace(GL_BACK);
-                
-                glDisable(GL_CULL_FACE);
-                //glEnable(GL_CULL_FACE);
-                
-                glShadeModel(GL_FLAT);
-                glEnable(GL_DEPTH_TEST);
-                
-                gluLookAt(mViewPoint.x, mViewPoint.y, mViewPoint.z, 
-                                  midPoint.x, midPoint.y, midPoint.z, 
-                                  mUpVec.x, mUpVec.y, mUpVec.z);
-        }
-        mOldTexture->EndCapture();
-
+        mNear = 1;
+        mFar = sceneSize * 2;
+        mWidth = sceneSize;
+
+        ComputeLookAt(alpha, 
+                                  beta,
+                                  mEyeVec, 
+                                  mUpVec,
+                                  mLeftVec);
+        
+        mViewPoint = mTermination - 0.5f * sceneSize * mEyeVec;
+
+        cout << "termination point: " << mTermination << endl;
+        cout << "view point: " << mViewPoint << endl;
+        cout << "scene: " << bbox << endl;
+
+        InitRenderTexture(mNewTexture);
+        InitRenderTexture(mOldTexture);
+        
+        cout << "eye: " << mEyeVec << " left: " << mLeftVec << " up: " << mUpVec << endl;
+}
+
+
+void GlobalLinesRenderer::InitScene(const SimpleRay &ray)
+{
+        AxisAlignedBox3 bbox = 
+                globalLinesRenderer->mPreprocessor->mKdTree->GetBox();
+        
+        const float sceneSize = Magnitude(bbox.Diagonal());
+
+        // compute the center of the scene
+        mViewPoint = ray.mOrigin;
+        mTermination = ray.mOrigin + ray.mDirection;
+
+        mEyeVec = Normalize(ray.mDirection);
+
+        mNear = 1;
+        mFar = sceneSize * 2;
+        mWidth = sceneSize;
+
+        mEyeVec.RightHandedBase(mUpVec, mLeftVec);
+    mViewPoint = mTermination - 0.5f * sceneSize * mEyeVec;
+
+        cout << "termination point: " << mTermination << endl;
+        cout << "view point: " << mViewPoint << endl;
+        cout << "scene: " << bbox << endl;
+
+        InitRenderTexture(mNewTexture);
+        InitRenderTexture(mOldTexture);
+        
         cout << "eye: " << mEyeVec << " left: " << mLeftVec << " up: " << mUpVec << endl;
 }
@@ -395 +409 @@
 }
 
+
+void GlobalLinesRenderer::CastGlobalLines(const SimpleRay &ray, 
+                                                                                  VssRayContainer &rays)
+{
+        InitScene(ray);
+
+        // bind pixel shader implementing the front depth buffer functionality
+        ApplyDepthPeeling(rays);
+}
 
 void GlobalLinesRenderer::RenderObject(Intersectable *obj)
@@ -438 +461 @@
                                                                                 Vector3 &left)
 {
-        //float x = cos(alpha);
-        //float y = sin(alpha);
         eye.x = sin(alpha) * cos(beta);
         eye.y = sin(alpha) * sin(beta);
         eye.z = cos(alpha);
 
-        //eye = Normalize(eye);
         eye.RightHandedBase(up, left);
 }
@@ -637 +657 @@
 
 
-void GlobalLinesRenderer::ProcessDepthBuffer(VssRayContainer &vssRays, 
+bool GlobalLinesRenderer::ProcessDepthBuffer(VssRayContainer &vssRays, 
                                                                                          const bool oldBufferInitialised,
                                                                                          const int pass)
@@ -660 +680 @@
                         mOldItemBuffer[i * 4 + 3] = 255;
                 }
+        }
+
+        /////////////////
+        // test for validity
+
+        bool buffersEqual = true;
+        bool bufferEmpty = true;
+
+        for (int y = 0; y < mTexHeight; ++ y)
+        {
+                for (int x = 0; x < mTexWidth; ++ x)
+                {
+                        const int depthIndex = x + mTexWidth * y;   
+                        const int itemIndex = 4 * depthIndex;
+                
+                        if (mOldItemBuffer[itemIndex] != mNewItemBuffer[itemIndex])
+                        {
+                                buffersEqual = false;
+                        }
+
+                        unsigned char r = mNewItemBuffer[itemIndex];
+                        unsigned char g = mNewItemBuffer[itemIndex + 1];
+                        unsigned char b = mNewItemBuffer[itemIndex + 2];
+
+                        // 3 times 255 means no valid object
+                        if (!((r == 255) && (g == 255) && (b == 255)))
+                        {
+                                bufferEmpty = false;
+                        }
+                }
+                
+                // early exit
+                if (!buffersEqual && !bufferEmpty)
+                        break;
+        }
+
+        // depth buffer not valid
+        if (buffersEqual || bufferEmpty)
+        {
+                cout << "stopped at layer " << pass << endl;
+                return false;
         }
 
@@ -698 +759 @@
                         }
 
-                        if (termObj2)
+                        if (mSampleReverse && termObj2)
                         {
                                 vssRays.push_back(new VssRay(clippedNewPt, clippedOldPt, NULL, termObj2, pass));
@@ -705 +766 @@
                 }
         }
+
+        return true;
 }
 
@@ -912 +975 @@
 
                 // process the buffers for following layer
-                ProcessDepthBuffer(rays, true, i);
+                // jump out of loop for the first invalid buffer
+                if (!ProcessDepthBuffer(rays, true, i))
+                        break;
         }