Changeset 540 for trunk/VUT/GtpVisibilityPreprocessor/src/GlRenderer.cpp

Timestamp:

01/15/06 04:23:51 (18 years ago)

Author:

mattausch

Message:

 

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/GlRenderer.cpp (modified) (18 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/GlRenderer.cpp

@@ -16 +16 @@
 static CGprofile sCgFragmentProfile;
 
-GLuint depthMap;
+GLuint frontDepthMap;
+GLuint backDepthMap;
+
 const int depthMapSize = 512;
 static vector<int> sQueries;
@@ -99 +101 @@
 }
 
+
+int GlRenderer::GetId(int r, int g, int b) const
+{
+        return r + (g << 8) + (b << 16);
+}
+
 void
 GlRenderer::SetupMaterial(Material *m)
@@ -152 +160 @@
   glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)
         wglGetProcAddress("glGetOcclusionQueryuivNV");
-
-  // initialise second depth buffer texture
-  glGenTextures(1, &depthMap);
-  glBindTexture(GL_TEXTURE_2D, depthMap);
-  
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, depthMapSize, 
-                           depthMapSize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
-  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
-
-  // cg initialization
-  cgSetErrorCallback(handleCgError);
-  sCgContext = cgCreateContext();
-
-  if (cgGLIsProfileSupported(CG_PROFILE_ARBFP1))
-          sCgFragmentProfile = CG_PROFILE_ARBFP1;
-  else {
-          // try FP30
-          if (cgGLIsProfileSupported(CG_PROFILE_FP30))
-            sCgFragmentProfile = CG_PROFILE_FP30;
-          else {
-                  fprintf(stderr, "Neither arbfp1 or fp30 fragment profiles supported on this system.\n");
-                  exit(1);
-          }
-  }
-
-  sCgFragmentProgram = cgCreateProgramFromFile(sCgContext,              
-                                                                                           CG_SOURCE, "../src/dual_depth.cg",
-                                                                                           sCgFragmentProfile,
-                                                                                           NULL, 
-                                                                                           NULL);
-
-  if (!cgIsProgramCompiled(sCgFragmentProgram))
-          cgCompileProgram(sCgFragmentProgram);
-
-  cgGLLoadProgram(sCgFragmentProgram);
-  cgGLBindProgram(sCgFragmentProgram);
- // Debug << "LAST LISTING----" << cgGetLastListing(sCgContext) << "----\n";
-
-  Debug << "---- PROGRAM BEGIN ----\n" << 
-          cgGetProgramString(sCgFragmentProgram, CG_COMPILED_PROGRAM) << "---- PROGRAM END ----\n";
 }
 
@@ -617 +582 @@
                                                                                            BeamSampleStatistics &stat)
 {
+        // create beam mesh if not already doen
+        //TODO: should this be done here?
+        
+        beam.CreateMesh(2.0f * Magnitude(mSceneGraph->GetBox().Diagonal()));
+
         // TODO: should not be done every time here
         // only back faces are interesting for the depth pass
@@ -636 +606 @@
         // would distribute the 'efective viewpoints' of the object surface and thus
         // with a few viewpoints better sample the vipoint space....
-  
-        int viewPointSamples = sqrt((float)desiredSamples);
-
+  //TODO: remove
+        //int viewPointSamples = sqrt((float)desiredSamples);
+        int viewPointSamples = max(desiredSamples / (GetWidth() * GetHeight()), 1);
+        
         // the number of direction samples per pass is given by the number of viewpoints
-        int directionalSamples = desiredSamples/viewPointSamples;
-        
+        int directionalSamples = desiredSamples / viewPointSamples;
+        
+        Debug << "directional samples: " << directionalSamples << endl;
         for (int i = 0; i < viewPointSamples; ++ i) 
         {
@@ -674 +646 @@
                                                                                                         const Vector3 viewPoint,
                                                                                                         Beam &beam,
-                                                                                                        const int desiredSamples,
+                                                                                                        const int samples,
                                                     BeamSampleStatistics &stat)
 {
-        // 1. setup the view port to match the desired samples
-        glViewport(0, 0, desiredSamples, desiredSamples);
+    // 1. setup the view port to match the desired samples
+        glViewport(0, 0, GetWidth(), GetHeight());
 
         // 2. setup the projection matrix and view matrix to match the viewpoint + beam.mDirBox
         SetupProjectionForViewPoint(viewPoint, beam, sourceObject);
-        
+
         // 3. reset z-buffer to 0 and render the source object for the beam
         //    with glCullFace(Enabled) and glFrontFace(GL_CW)
         //    save result to depth map
+
+        // front depth buffer must bé initialised to 0
+        float clearDepth;
+        glGetFloatv(GL_DEPTH_CLEAR_VALUE, &clearDepth);
+        glClearDepth(0.0f);
+        
+
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+        //glFrontFace(GL_CW);
         glEnable(GL_CULL_FACE);
-        glEnable(GL_STENCIL_TEST);
         glCullFace(GL_FRONT);
         glColorMask(0, 0, 0, 0);
         
+
         // stencil is increased where the source object is located
+        glEnable(GL_STENCIL_TEST);      
         glStencilFunc(GL_ALWAYS, 0x1, 0x1);
-        glStencilOp(GL_INCR, GL_INCR, GL_INCR);
+        glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
 
 #if 0
@@ -713 +694 @@
 
 #endif  
+        // reset clear function
+        glClearDepth(clearDepth);
+
+        // copy contents of depth buffer into depth texture
+        // depth buffer holds ray origins
+        glBindTexture(GL_TEXTURE_2D, frontDepthMap);    
+        glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, depthMapSize, depthMapSize);
+
+
+#if 0
+        // only the samples which are inside the beam AND on the source object
+        // should be considered => only where stencil == 2
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        glStencilFunc(GL_ALWAYS, 0x2, 0x2);
+        glStencilOp(GL_INCR, GL_INCR, GL_INCR);
+
+        // render back face of frustum beam
+        RenderMesh(beam.mMesh);
+#endif
+
 
         // 4. set back to normal rendering and clear the ray termination depth buffer
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
         glColorMask(1, 1, 1, 1);
-        
+        glDepthMask(1);
+        glEnable(GL_DEPTH_TEST);
+        glDisable(GL_STENCIL_TEST);     
+        glEnable(GL_CULL_FACE);
+        glCullFace(GL_BACK);
+
         // 5. render all objects inside the beam using id based false color
         //    (objects can be compiled to a gl list now so that subsequent rendering for
@@ -743 +749 @@
                 ObjectContainer::const_iterator it, it_end = beam.mObjects.end();
                 for (it = beam.mObjects.begin(); it != it_end; ++ it)
-                        RenderIntersectable(*it);
+                {
+                        if (*it != sourceObject)
+                                RenderIntersectable(*it);
+                }
                 
                 glEndList();
@@ -750 +759 @@
 #else
         ObjectContainer::const_iterator it, it_end = beam.mObjects.end();
-                for (it = beam.mObjects.begin(); it != it_end; ++ it)
+        for (it = beam.mObjects.begin(); it != it_end; ++ it)
+        {       
+                if (*it != sourceObject)
                         RenderIntersectable(*it);
+        }
 #endif
 
-        // remove objects again
-        if (beam.mFlags & !Beam::STORE_OBJECTS)
-                beam.mObjects.clear();
-
-        // bind ray origin depth buffer
-        glBindTexture(GL_TEXTURE_2D, depthMap);
-    glEnable(GL_TEXTURE_2D);
-        
-
-        //Read the depth buffer into the shadow map texture
-        glBindTexture(GL_TEXTURE_2D, depthMap);
-        glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, depthMapSize, depthMapSize);
-
-        
-        // 6. Now we have a two depth buffers defining the ray origin and termination
+        
+    // 6. Now we have a two depth buffers defining the ray origin and termination
         //    only rays which have non-zero entry in the origin buffer are valid since
         //    they realy start on the object surface (this can also be tagged by setting a
         //    stencil buffer bit at step 3)
+        
+        glDisable(GL_STENCIL_TEST);
+        //glEnable(GL_STENCIL_TEST);
         glStencilFunc(GL_EQUAL, 0x1, 0x1);
- 
-        //cgGLBindProgram(sCgFragmentProgram);
+        //glStencilFunc(GL_EQUAL, 0x2, 0x2);
+        glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+
+        // bind depth texture
+        glEnable(GL_TEXTURE_2D);
+        
+        // bind depth cull pixel shader
+        cgGLBindProgram(sCgFragmentProgram);
         cgGLEnableProfile(sCgFragmentProfile);
 
@@ -785 +793 @@
 
         // now check whether any backfacing polygon would pass the depth test?
+        //matt: should check both back /front facing because of dual depth buffer
+        //and danger of cutting the near plane with front facing polys.
         glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
         glDepthMask(GL_FALSE);
@@ -817 +827 @@
                                                                  GL_PIXEL_COUNT_NV,
                                                                  &pixelCount);
-
-                Debug << "visble pixels: " << pixelCount << endl;
+                if (pixelCount)
+                        Debug << "view cell " << (*vit)->GetId() << " visible pixels: " << pixelCount << endl;
         }
         
@@ -828 +838 @@
         // evaluate the contribution entropy for example)
         // However might be an option to extract/store only those the rays which made a contribution
-        // (new viewcell has been discovered) or relative contribution greater than a threashold ... 
-
+        // (new viewcell has been discovered) or relative contribution greater than a threshold ... 
+
+        ObjectContainer pvsObj;
+        stat.pvsSize = ComputePvs(beam.mObjects, pvsObj);
+        
+        
+#if 0
+        // copy contents of back depth buffer into depth texture
+        // depth buffer holds ray origins
+        glBindTexture(GL_TEXTURE_2D, backDepthMap);     
+        glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, depthMapSize, depthMapSize);
+#endif
+        // reset state
         glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
         glDepthMask(GL_TRUE);
         glEnable(GL_CULL_FACE);
-
-
+        glDisable(GL_STENCIL_TEST);
         cgGLDisableProfile(sCgFragmentProfile);
         glDisable(GL_TEXTURE_2D);
+
+        // remove objects again
+        if (beam.mFlags & !Beam::STORE_OBJECTS)
+                beam.mObjects.clear();
 }
 
@@ -845 +869 @@
         {
                 const int n = numQueries - (int)sQueries.size();
-                int *newQueries = new int[n];
-
-                glGenOcclusionQueriesNV(n, (unsigned int *)&newQueries);
+                unsigned int *newQueries = new unsigned int[n];
+
+                glGenOcclusionQueriesNV(n, (unsigned int *)newQueries);
 
                 for (int i = 0; i < n; ++ i)
@@ -854 +878 @@
                 }
 
-                delete newQueries;
+                delete [] newQueries;
         }
 }
@@ -860 +884 @@
 
 void GlRendererBuffer::SetupProjectionForViewPoint(const Vector3 &viewPoint, 
-                                                                                                 const Beam &beam, 
-                                                                                                 Intersectable *sourceObject)
+                                                                                                   const Beam &beam, 
+                                                                                                   Intersectable *sourceObject)
 {
         float left, right, bottom, top, znear, zfar;
 
-        beam.ComputeFrustum(left, right, bottom, top, znear, zfar,
-                                                mSceneGraph->GetBox());
-
+        beam.ComputePerspectiveFrustum(left, right, bottom, top, znear, zfar,
+                                                                   mSceneGraph->GetBox());
+
+        //Debug << left << " " << right << " " << bottom << " " << top << " " << znear << " " << zfar << endl;
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
         glFrustum(left, right, bottom, top, znear, zfar);
-
-    const Vector3 eye = viewPoint + beam.GetMainDirection();
-        const Vector3 up;//AbitraryNormal(eye);
-
-        gluLookAt(eye.x, eye.y, eye.z, 
-                          viewPoint.x, viewPoint.y, viewPoint.z, 
+        //glFrustum(-1, 1, -1, 1, 1, 20000);
+
+    const Vector3 center = viewPoint + beam.GetMainDirection() * (zfar - znear) * 0.3;
+        const Vector3 up = 
+                Normalize(CrossProd(beam.mPlanes[0].mNormal, beam.mPlanes[4].mNormal));
+
+#ifdef _DEBUG
+        Debug << "view point: " << viewPoint << endl;
+        Debug << "eye: " << center << endl;
+        Debug << "up: " << up << endl;
+#endif
+
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+        gluLookAt(viewPoint.x, viewPoint.y, viewPoint.z, 
+                          center.x, center.y, center.z,                   
                           up.x, up.y, up.z);
 }               
 
   
+void GlRendererBuffer::InitGL()
+{
+        GlRenderer::InitGL();
+        // initialise dual depth buffer textures
+        glGenTextures(1, &frontDepthMap);
+        glBindTexture(GL_TEXTURE_2D, frontDepthMap);
+        
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, depthMapSize, 
+                depthMapSize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+
+        glGenTextures(1, &backDepthMap);
+        glBindTexture(GL_TEXTURE_2D, backDepthMap);
+        
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, depthMapSize, 
+                depthMapSize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+
+        // cg initialization
+        cgSetErrorCallback(handleCgError);
+        sCgContext = cgCreateContext();
+        
+        if (cgGLIsProfileSupported(CG_PROFILE_ARBFP1))
+                sCgFragmentProfile = CG_PROFILE_ARBFP1;
+        else 
+        {
+          // try FP30
+          if (cgGLIsProfileSupported(CG_PROFILE_FP30))
+            sCgFragmentProfile = CG_PROFILE_FP30;
+          else 
+          {
+                  Debug << "Neither arbfp1 or fp30 fragment profiles supported on this system" << endl;
+                  exit(1);
+          }
+  }
+
+  sCgFragmentProgram = cgCreateProgramFromFile(sCgContext,              
+                                                                                           CG_SOURCE, "../src/dual_depth.cg",
+                                                                                           sCgFragmentProfile,
+                                                                                           NULL, 
+                                                                                           NULL);
+
+  if (!cgIsProgramCompiled(sCgFragmentProgram))
+          cgCompileProgram(sCgFragmentProgram);
+
+  cgGLLoadProgram(sCgFragmentProgram);
+  cgGLBindProgram(sCgFragmentProgram);
  
-
-/***************************************************************/
-/*             GlDebuggerWidget implementation                             */
-/***************************************************************/
-
-
-GlDebuggerWidget::GlDebuggerWidget(QWidget *parent, GlRendererBuffer *buf)
+  Debug << "---- PROGRAM BEGIN ----\n" << 
+          cgGetProgramString(sCgFragmentProgram, CG_COMPILED_PROGRAM) << "---- PROGRAM END ----\n";
+}
+
+void GlRendererBuffer::ComputeRays(Intersectable *sourceObj, VssRayContainer &rays)
+{
+        for (int i = 0; i < depthMapSize * depthMapSize; ++ i)
+        {
+                //todo glGetTexImage()
+        }
+}
+
+
+
+inline bool ilt(Intersectable *obj1, Intersectable *obj2)
+{
+        return obj1->mId < obj2->mId;
+}
+
+
+int GlRendererBuffer::ComputePvs(ObjectContainer &objects, 
+                                                                 ObjectContainer &pvs) const
+{
+        int pvsSize = 0;
+        QImage image = toImage();
+        Intersectable::NewMail();
+
+        std::stable_sort(objects.begin(), objects.end(), ilt);
+
+        MeshInstance dummy(NULL);
+
+        Intersectable *obj = NULL;
+                        
+        for (int x = 0; x < image.width(); ++ x)
+        {
+                for (int y = 0; y < image.height(); ++ y)
+                {
+                        QRgb pix = image.pixel(x, y);
+                        const int id = GetId(qRed(pix), qGreen(pix), qBlue(pix));
+
+                        dummy.SetId(id);
+
+                        ObjectContainer::iterator oit =
+                                lower_bound(objects.begin(), objects.end(), &dummy, ilt);
+                        obj = *oit;
+                        if (!obj->Mailed())
+                        {
+                                obj->Mail();
+                                ++ pvsSize;
+                                pvs.push_back(obj);
+                        }
+                }
+        }
+
+        return pvsSize;
+}
+
+/***********************************************************************/
+/*                     GlDebuggerWidget implementation                             */
+/***********************************************************************/
+
+
+GlDebuggerWidget::GlDebuggerWidget(GlRendererBuffer *buf, QWidget *parent)
       : QGLWidget(QGLFormat(QGL::SampleBuffers), parent), mRenderBuffer(buf)
 {
@@ -932 +1078 @@
         // draw a spinning cube into the pbuffer..
         mRenderBuffer->makeCurrent();
-        //mRenderBuffer->SampleBeamContributions();
+        
+        BeamSampleStatistics stats;
+        mRenderBuffer->SampleBeamContributions(mSourceObject, mBeam, mSamples, stats);
+
         glFlush();
 
-    // rendering directly to a texture is not supported on X11, unfortunately
+        // rendering directly to a texture is not supported on X11, unfortunately
     mRenderBuffer->updateDynamicTexture(dynamicTexture);
    
-    // ..and use the pbuffer contents as a texture when rendering the
+    // and use the pbuffer contents as a texture when rendering the
     // background and the bouncing cubes
     makeCurrent();
@@ -962 +1111 @@
         // set up the pbuffer context
     mRenderBuffer->makeCurrent();
-        initCommon();
+        /*mRenderBuffer->InitGL();
 
         glViewport(0, 0, mRenderBuffer->size().width(), mRenderBuffer->size().height());
@@ -972 +1121 @@
         glLoadIdentity();
 
-        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
-
+        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);*/
+        
         // generate a texture that has the same size/format as the pbuffer
     dynamicTexture = mRenderBuffer->generateDynamicTexture();