Changeset 1785 for GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.cpp

Timestamp:

11/23/06 21:38:45 (18 years ago)

Author:

bittner

Message:

merge, filter update, renderebuffer made functional

File:

• GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.cpp (modified) (9 diffs)

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

@@ -25 +25 @@
 static bool nvQuerySupport = false;
 
+GLuint frontDepthMap;
+GLuint backDepthMap;
+
+const int depthMapSize = 512;
 
 static void InitExtensions() 
@@ -80 +84 @@
   mUseForcedColors = false;
   mRenderBoxes = false;
-  mUseGlLists = true;
-  //mUseGlLists = false;
+  //  mUseGlLists = true;
+  mUseGlLists = false;
 }
 
@@ -133 +137 @@
   case Intersectable::BVH_INTERSECTABLE: {
 
-          BvhNode *node = dynamic_cast<BvhNode *>(object);
-
+        BvhNode *node = dynamic_cast<BvhNode *>(object);
+        
         if (mRenderBoxes)
           RenderBox(node->GetBoundingBox());
@@ -143 +147 @@
   case Intersectable::KD_INTERSECTABLE: {
         KdNode *node = (dynamic_cast<KdIntersectable *>(object))->GetItem();
-
+        
         if (mRenderBoxes)
           RenderBox(mKdTree->GetBox(node));
@@ -293 +297 @@
   glLoadIdentity();
 
+  glFrontFace(GL_CCW);
+  glCullFace(GL_BACK);
   glEnable(GL_CULL_FACE);
   glShadeModel(GL_FLAT);
@@ -402 +408 @@
 GlRenderer::RenderScene()
 {
+  Intersectable::NewMail();
   static int glList = -1;
   if (mUseGlLists) {
@@ -459 +466 @@
 GlRenderer(sceneGraph, viewcells, tree)  
 {
-        mPixelBuffer = NULL;
-
-        // implement width and height in subclasses
+  Environment::GetSingleton()->GetIntValue("Preprocessor.pvsRenderErrorSamples", mPvsStatFrames);
+  mPvsErrorBuffer.resize(mPvsStatFrames);
+  ClearErrorBuffer();
+  
+  mPixelBuffer = NULL;
+  
+  // implement width and height in subclasses
 }
 
@@ -647 +658 @@
   if (node->IsLeaf()) {
         BvhLeaf *leaf = (BvhLeaf *) node;
-        for (int i=0; i < leaf->mObjects.size(); i++)
-          RenderIntersectable(leaf->mObjects[i]);
+
+#if 0
+        if (leaf->mGlList == 0) {
+          leaf->mGlList = glGenLists(1);
+          if (leaf->mGlList != 0)
+                glNewList(leaf->mGlList, GL_COMPILE);
+          
+          for (int i=0; i < leaf->mObjects.size(); i++)
+                RenderIntersectable(leaf->mObjects[i]);
+          
+          if (leaf->mGlList != 0)
+                glEndList();
+        }
+        
+        if (leaf->mGlList != 0)
+          glCallList(leaf->mGlList);
+#else
+          for (int i=0; i < leaf->mObjects.size(); i++)
+                RenderIntersectable(leaf->mObjects[i]);
+#endif
   } else {
         BvhInterior *in = (BvhInterior *)node;
@@ -675 +704 @@
 }
 
-}
+
+
+
+
+
+
+void
+GlRendererBuffer::EvalRenderCostSample(RenderCostSample &sample,
+                                                                           const bool useOcclusionQueries,
+                                                                           const int threshold
+                                                                           )
+{
+  // choose a random view point
+  mViewCellsManager->GetViewPoint(mViewPoint);
+  sample.mPosition = mViewPoint;
+  //cout << "viewpoint: " << mViewPoint << endl;
+  
+  // take a render cost sample by rendering a cube
+  Vector3 directions[6];
+  
+  directions[0] = Vector3(1,0,0);
+  directions[1] = Vector3(0,1,0);
+  directions[2] = Vector3(0,0,1);
+  directions[3] = Vector3(-1,0,0);
+  directions[4] = Vector3(0,-1,0);
+  directions[5] = Vector3(0,0,-1);
+  
+  sample.mVisibleObjects = 0;
+  
+  // reset object counters
+  ObjectContainer::const_iterator it, it_end = mObjects.end();
+  
+  for (it = mObjects.begin(); it != it_end; ++ it) 
+        {
+          (*it)->mCounter = 0;
+        }
+
+  ++ mFrame;
+  
+  //glCullFace(GL_FRONT);
+  glCullFace(GL_BACK);
+  glDisable(GL_CULL_FACE);
+  
+  
+        // query all 6 directions for a full point sample
+  for (int i = 0; i < 6; ++ i) 
+        {
+          mViewDirection = directions[i];
+          SetupCamera();
+          
+          glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+          glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+          //glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);    glDepthMask(GL_TRUE);
+          glDepthFunc(GL_LESS);
+          
+          mUseFalseColors = true;
+          
+          // the actual scene rendering fills the depth (for occlusion queries)
+          // and the frame buffer (for item buffer)
+          RenderScene();
+          
+          
+          if (0) 
+                {
+                  char filename[256];
+                  sprintf(filename, "snap/frame-%04d-%d.png", mFrame, i);
+                  //              QImage im = toImage();
+                  //              im.save(filename, "PNG");
+                }
+          
+          // evaluate the sample
+          if (useOcclusionQueries) 
+                {
+                  EvalQueryWithOcclusionQueries();
+                }
+          else 
+                {
+                  EvalQueryWithItemBuffer();
+                }
+        }  
+  
+  // now evaluate the statistics over that sample
+  // currently only the number of visible objects is taken into account
+  sample.Reset();
+  
+  for (it = mObjects.begin(); it != it_end; ++ it) 
+        {
+          Intersectable *obj = *it;
+          if (obj->mCounter >= threshold) 
+                {
+                  ++ sample.mVisibleObjects;
+                  sample.mVisiblePixels += obj->mCounter;
+                }
+        }
+  
+  //cout << "RS=" << sample.mVisibleObjects << " ";
+}
+
+
+GlRendererBuffer::~GlRendererBuffer()
+{
+#if USE_CG
+  if (sCgFragmentProgram)
+                cgDestroyProgram(sCgFragmentProgram);
+        if (sCgContext)
+                cgDestroyContext(sCgContext);
+#endif
+}
+
+
+void
+GlRendererBuffer::SampleRenderCost(const int numSamples,
+                                                                   vector<RenderCostSample> &samples,
+                                                                   const bool useOcclusionQueries,
+                                                                   const int threshold
+                                                                   )
+{
+  MakeCurrent();
+
+  if (mPixelBuffer == NULL)
+          mPixelBuffer = new unsigned int[GetWidth()*GetHeight()];
+  
+  // using 90 degree projection to capture 360 view with 6 samples
+  SetupProjection(GetHeight(), GetHeight(), 90.0f);
+
+  //samples.resize(numSamples);
+  halton.Reset();
+  
+  // the number of queries queried in batch mode
+  const int numQ = 500;
+
+  //const int numQ = (int)mObjects.size();
+  if (useOcclusionQueries)
+  {
+          cout << "\ngenerating " << numQ << " queries ... ";
+          OcclusionQuery::GenQueries(mOcclusionQueries, numQ);
+          cout << "finished" << endl;
+  }
+
+  // sampling queries 
+  for (int i = 0; i < numSamples; ++ i)
+  {
+          cout << ".";
+          EvalRenderCostSample(samples[i], useOcclusionQueries, threshold);
+  }
+
+  DoneCurrent();
+}
+  
+
+
+
+
+void
+GlRendererBuffer::ClearErrorBuffer()
+{
+  for (int i=0; i < mPvsStatFrames; i++) {
+        mPvsErrorBuffer[i].mError = 1.0f;
+  }
+}
+
+
+void
+GlRendererBuffer::EvalPvsStat()
+{
+  mPvsStat.Reset();
+  halton.Reset();
+
+  MakeCurrent();
+
+  SetupProjection(GetWidth(), GetHeight());
+
+  cout<<"mPvsStatFrames="<<mPvsStatFrames<<endl;
+  
+  for (int i=0; i < mPvsStatFrames; i++) {
+        float err;
+        // set frame id for saving the error buffer
+        mFrame = i;
+        RandomViewPoint();
+
+        // atlanta problematic frames: 325 525 691 1543
+#if 0
+        if (mFrame != 325 &&
+                mFrame != 525 &&
+                mFrame != 691 &&
+                mFrame != 1543)
+          mPvsErrorBuffer[i] = -1;
+        else {
+          Debug<<"frame ="<<mFrame<<" vp="<<mViewPoint<<" vd="<<mViewDirection<<endl;
+        }
+#endif
+        
+        if (mPvsErrorBuffer[i].mError > 0.0f) {
+          int pvsSize;
+
+
+          float error = GetPixelError(pvsSize);
+          mPvsErrorBuffer[i].mError = error;
+          mPvsErrorBuffer[i].mPvsSize = pvsSize;
+
+          //      emit UpdatePvsErrorItem(i,
+          //                                                      mPvsErrorBuffer[i]);
+
+          cout<<"("<<i<<","<<mPvsErrorBuffer[i].mError<<")";
+          //      swapBuffers();
+        }
+        
+        err = mPvsErrorBuffer[i].mError;
+        
+        if (err >= 0.0f) {
+          if (err > mPvsStat.maxError)
+                mPvsStat.maxError = err;
+          mPvsStat.sumError += err;
+          mPvsStat.sumPvsSize += mPvsErrorBuffer[i].mPvsSize;
+          
+          if (err == 0.0f)
+                mPvsStat.errorFreeFrames++;
+          mPvsStat.frames++;
+        }
+  }
+
+  glFinish();
+  DoneCurrent();
+
+  cout<<endl<<flush;
+  //  mRenderingFinished.wakeAll();
+}
+
+
+
+
+
+
+
+void GlRendererBuffer::SampleBeamContributions(Intersectable *sourceObject,
+                                                                                           Beam &beam,
+                                                                                           const int desiredSamples,
+                                                                                           BeamSampleStatistics &stat)
+{
+        // TODO: should be moved out of here (not to be done every time)
+        // only back faces are interesting for the depth pass
+        glShadeModel(GL_FLAT);
+        glDisable(GL_LIGHTING);
+
+        // needed to kill the fragments for the front buffer
+        glEnable(GL_ALPHA_TEST);
+        glAlphaFunc(GL_GREATER, 0);
+
+        // assumes that the beam is constructed and contains kd-tree nodes
+        // and viewcells which it intersects
+  
+  
+        // Get the number of viewpoints to be sampled
+        // Now it is a sqrt but in general a wiser decision could be made.
+        // The less viewpoints the better for rendering performance, since less passes
+        // over the beam is needed.
+        // The viewpoints could actually be generated outside of the bounding box which
+        // would distribute the 'efective viewpoints' of the object surface and thus
+        // with a few viewpoints better sample the viewpoint space....
+
+        //TODO: comment in
+        //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;
+        
+        Debug << "directional samples: " << directionalSamples << endl;
+        for (int i = 0; i < viewPointSamples; ++ i) 
+        {
+                Vector3 viewPoint = beam.mBox.GetRandomPoint();
+                
+                // perhaps the viewpoint should be shifted back a little bit so that it always lies
+                // inside the source object
+                // 'ideally' the viewpoints would be distributed on the soureObject surface, but this
+        // would require more complicated sampling (perhaps hierarchical rejection sampling of
+                // the object surface is an option here - only the mesh faces which are inside the box
+                // are considered as candidates) 
+                
+                SampleViewpointContributions(sourceObject,
+                                                                         viewPoint,
+                                                                         beam,
+                                                                         directionalSamples,
+                                                                         stat);
+        }
+
+
+        // note:
+        // this routine would be called only if the number of desired samples is sufficiently
+        // large - for other rss tree cells the cpu based sampling is perhaps more efficient
+        // distributing the work between cpu and gpu would also allow us to place more sophisticated
+        // sample distributions (silhouette ones) using the cpu and the jittered once on the GPU
+        // in order that thios scheme is working well the gpu render buffer should run in a separate
+        // thread than the cpu sampler, which would not be such a big problem....
+
+        // disable alpha test again
+        glDisable(GL_ALPHA_TEST);
+}
+
+
+
+void GlRendererBuffer::SampleViewpointContributions(Intersectable *sourceObject,
+                                                                                                        const Vector3 viewPoint,
+                                                                                                        Beam &beam,
+                                                                                                        const int samples,
+                                                    BeamSampleStatistics &stat)
+{
+    // 1. setup the view port to match the desired samples
+        glViewport(0, 0, samples, samples);
+
+        // 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 the front depth map
+        //    the front depth map holds ray origins
+
+
+        // front depth buffer must be 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_CCW);
+        glEnable(GL_CULL_FACE);
+        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_REPLACE, GL_REPLACE, GL_REPLACE);
+
+
+#if 0
+        static int glSourceObjList = -1;         
+        if (glSourceObjList != -1) 
+        {
+                glSourceObjList = glGenLists(1);
+                glNewList(glSourceObjList, GL_COMPILE);
+
+                RenderIntersectable(sourceObject);
+        
+                glEndList();
+        }
+        glCallList(glSourceObjList);
+
+#else
+        RenderIntersectable(sourceObject);
+
+#endif  
+
+         // copy contents of the front depth buffer into depth texture
+        glBindTexture(GL_TEXTURE_2D, frontDepthMap);    
+        glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, depthMapSize, depthMapSize);
+
+
+        // reset clear function
+        glClearDepth(clearDepth);
+
+        
+        
+        // 4. set up the termination depth buffer (= standard depth buffer)
+        //    only rays which have non-zero entry in the origin buffer are valid since
+        //    they realy start on the object surface (this is tagged by setting a
+        //    stencil buffer bit at step 3).
+        
+        glStencilFunc(GL_EQUAL, 0x1, 0x1);
+        glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        glDepthMask(1);
+
+        glEnable(GL_DEPTH_TEST);
+                
+        glEnable(GL_CULL_FACE);
+        glCullFace(GL_BACK);
+
+        // setup front depth buffer
+        glEnable(GL_TEXTURE_2D);
+        
+#if USE_CG
+        // bind pixel shader implementing the front depth buffer functionality
+        cgGLBindProgram(sCgFragmentProgram);
+        cgGLEnableProfile(sCgFragmentProfile);
+#endif
+
+        // 5. render all objects inside the beam 
+        //    we can use id based false color to read them back for gaining the pvs
+
+        glColorMask(1, 1, 1, 1);
+
+        
+        // if objects not stored in beam => extract objects
+        if (beam.mFlags & !Beam::STORE_OBJECTS)
+        {
+                vector<KdNode *>::const_iterator it, it_end = beam.mKdNodes.end();
+
+                Intersectable::NewMail();
+                for (it = beam.mKdNodes.begin(); it != it_end; ++ it)
+                {
+                        mKdTree->CollectObjects(*it, beam.mObjects);
+                }
+        }
+
+
+        //    (objects can be compiled to a gl list now so that subsequent rendering for
+        //    this beam is fast - the same hold for step 3)
+        //    Afterwards we have two depth buffers defining the ray origin and termination
+        
+
+#if 0
+        static int glObjList = -1; 
+        if (glObjList != -1) 
+        {
+                glObjList = glGenLists(1);
+                glNewList(glObjList, GL_COMPILE);
+        
+                ObjectContainer::const_iterator it, it_end = beam.mObjects.end();
+                for (it = beam.mObjects.begin(); it != it_end; ++ it)
+                {
+                        // render all objects except the source object
+                        if (*it != sourceObject)
+                                RenderIntersectable(*it);
+                }
+                
+                glEndList();
+        }
+
+        glCallList(glObjList);
+#else
+        ObjectContainer::const_iterator it, it_end = beam.mObjects.end();
+        for (it = beam.mObjects.begin(); it != it_end; ++ it)
+        {       
+                // render all objects except the source object
+                if (*it != sourceObject)
+                        RenderIntersectable(*it);
+        }
+#endif
+        
+   
+
+        // 6. Use occlusion queries for all viewcell meshes associated with the beam ->
+        //     a fragment passes if the corresponding stencil fragment is set and its depth is
+        //     between origin and termination buffer
+
+        // create new queries if necessary
+        OcclusionQuery::GenQueries(mOcclusionQueries, (int)beam.mViewCells.size());
+
+        // 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);
+        glDisable(GL_CULL_FACE);
+
+  
+        ViewCellContainer::const_iterator vit, vit_end = beam.mViewCells.end();
+
+        int queryIdx = 0;
+
+        for (vit = beam.mViewCells.begin(); vit != vit_end; ++ vit)
+        {
+                mOcclusionQueries[queryIdx ++]->BeginQuery();
+
+                RenderIntersectable(*vit);
+                
+                mOcclusionQueries[queryIdx]->EndQuery();
+
+                ++ queryIdx;
+        }
+
+
+
+        // at this point, if possible, go and do some other computation
+
+
+        
+        // 7. The number of visible pixels is the number of sample rays which see the source
+        //    object from the corresponding viewcell -> remember these values for later update
+        //   of the viewcell pvs - or update immediately?
+
+        queryIdx = 0;
+
+        for (vit = beam.mViewCells.begin(); vit != vit_end; ++ vit)
+        {
+                // fetch queries
+                unsigned int pixelCount = mOcclusionQueries[queryIdx ++]->GetQueryResult();
+
+                if (pixelCount)
+                        Debug << "view cell " << (*vit)->GetId() << " visible pixels: " << pixelCount << endl;
+        }
+        
+
+        // 8. Copmpute rendering statistics
+        // In general it is not neccessary to remember to extract all the rays cast. I hope it
+        // would be sufficient to gain only the intergral statistics about the new contributions
+        // and so the rss tree would actually store no new rays (only the initial ones)
+        // the subdivision of the tree would only be driven by the statistics (the glrender could
+        // 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 threshold ... 
+
+        ObjectContainer pvsObj;
+        stat.pvsSize = ComputePvs(beam.mObjects, pvsObj);
+        
+        // to gain ray source and termination
+        // copy contents of ray termination buffer into depth texture
+        // and compare with ray source buffer
+#if 0
+        VssRayContainer rays;
+
+        glBindTexture(GL_TEXTURE_2D, backDepthMap);     
+        glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, depthMapSize, depthMapSize);
+
+        ComputeRays(Intersectable *sourceObj, rays);
+
+#endif
+
+
+
+        //-- cleanup
+
+
+        // reset gl state
+        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+        glDepthMask(GL_TRUE);
+        glEnable(GL_CULL_FACE);
+        glDisable(GL_STENCIL_TEST);
+#if USE_CG
+        cgGLDisableProfile(sCgFragmentProfile);
+#endif
+        glDisable(GL_TEXTURE_2D);
+
+        // remove objects from beam
+        if (beam.mFlags & !Beam::STORE_OBJECTS)
+                beam.mObjects.clear();
+}
+
+
+void GlRendererBuffer::SetupProjectionForViewPoint(const Vector3 &viewPoint, 
+                                                                                                   const Beam &beam, 
+                                                                                                   Intersectable *sourceObject)
+{
+        float left, right, bottom, top, znear, zfar;
+
+        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);
+        //glFrustum(-1, 1, -1, 1, 1, 20000);
+
+    const Vector3 center = viewPoint + beam.GetMainDirection() * (zfar - znear) * 0.3f;
+        const Vector3 up = 
+                Normalize(CrossProd(beam.mPlanes[0].mNormal, beam.mPlanes[4].mNormal));
+
+#ifdef GTP_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()
+{
+  MakeCurrent(); 
+  GlRenderer::InitGL();
+
+#if 1
+        // 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);
+
+        
+#if USE_CG
+        // 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);
+
+  Debug << "---- PROGRAM BEGIN ----\n" <<
+          cgGetProgramString(sCgFragmentProgram, CG_COMPILED_PROGRAM) << "---- PROGRAM END ----\n";
+
+#endif
+
+#endif
+  DoneCurrent();
+}
+
+
+void GlRendererBuffer::ComputeRays(Intersectable *sourceObj, VssRayContainer &rays)
+{
+        for (int i = 0; i < depthMapSize * depthMapSize; ++ i)
+        {
+                //todo glGetTexImage()
+        }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+}