VRUT::ChcRenderer Class Reference

Ray Tracer module - implements recursive ray tracing. More...

#include <ChcRenderer.h>

Inheritance diagram for VRUT::ChcRenderer:

List of all members.

Public Member Functions
	ChcRenderer (const MODULE_ID &_id, const wxString &_name, EventHandler *msgSink)
	Class constructor - do not alter.
virtual	~ChcRenderer ()
	Class destructor - deinitialize your data.
virtual wxString	GetDesc () const
	Always overload method giving description for your module.
virtual void	Draw ()
virtual void	Deinitialize ()
void	DrawItems (BVH::ItemsList &itemsList)
	draw the geoemtry list obtained by culling the bvh
void	DrawItemsReverse (BVH::BlendedList &itemsList)
void	DrawNode (const GeometryNode *node)
	Draw a geometry node.
void	RenderBox (const AABB &box)
	Render a bounding box.
void	ProcessNode (NodeInfo &info, const VECTOR3 &cameraPos, const int planeMask, vector< const GeometryNode * > &blendedNodes, priority_queue< NodeInfo > &nodeStack)
void	PullUpInvisibility (BVHNode *node)
void	PullUpVisibility (BVHNode *node)
Protected Member Functions
virtual void	processEvent (wxCommandEvent &evt)
	Overload this to process events you need.
virtual bool	Initialize ()
	initialize Opengl
Protected Attributes
int	var
	Add any variables.
Parameter::ParameterIdentificator	varParamID
	Add var param identificator to register this as parameter.
int	frame
	number of current frame
vector< ChcNodeInfo >	nodeInfo
stack< OcclusionQuery * >	occlusionQueries
	occlusion queries used by the CHC method
int	renderedNodes
	number of nodes rendered in the current frame
int	renderedBlendedNodes
	number of nodes rendered in the current frame
int	queriedNodes
	number of queried nodes

---

Detailed Description

Ray Tracer module - implements recursive ray tracing.

Definition at line 64 of file ChcRenderer.h.

---

Constructor & Destructor Documentation

VRUT::ChcRenderer::ChcRenderer	(	const MODULE_ID &	_id,
		const wxString &	_name,
		EventHandler *	msgSink
	)			[inline]

Class constructor - do not alter.

Initialize your variables Do not change other than param name when initializing param identificators

Register your params - choose GUI type or just register w/o GUI

Definition at line 105 of file ChcRenderer.h.

              : RenderGlModule(_id, _name, msgSink),
                varParamID(_name, wxT("var"), _id)
         {
              //            REGISTER_PARAM_GUI_SLIDER(varParamID, wxT("100"), 0, 200);
         }

virtual VRUT::ChcRenderer::~ChcRenderer

(

)

[inline, virtual]

Class destructor - deinitialize your data.

Definition at line 118 of file ChcRenderer.h.

         {
         }

---

Member Function Documentation

virtual void VRUT::ChcRenderer::processEvent

(

wxCommandEvent &

evt

)

[inline, protected, virtual]

Overload this to process events you need.

Always call base method

Remember to process registered param update events

Reimplemented from VRUT::RenderGlModule.

Definition at line 79 of file ChcRenderer.h.

         {
              RenderGlModule::processEvent(evt);
              
              switch (evt.GetEventType()) {
              case Event::EVT_PARAM_SET:
                UPDATE_PARAM_FROM_EVENT_INT(varParamID, var, evt);
                break;
              }
         }

bool ChcRenderer::Initialize

(

)

[protected, virtual]

initialize Opengl

Using default (sphere) mapping for texture coordinates generation

Build texture

Init shaders

Resize arrays

Reimplemented from VRUT::RenderGlModule.

Definition at line 24 of file ChcRenderer.cpp.

                        {

  if (!initialized) {
       bool res = RenderGlModule::Initialize();
       
       GLenum err = glewInit();
       //  _assert(err == GLEW_OK, (char *)glewGetErrorString(err),
       //              "RendererWidget::initializeGL");
       
       //_assert(GLEW_VERSION_2_0 != 0, "OpenGL 2.0 required");
       
       if (res) {
         vector<OcclusionQuery *> queries;
         const int nq = 1000;
         OcclusionQuery::GenQueries(queries, nq);
         for (int i=0; i < nq; i++)
              occlusionQueries.push(queries[i]);
       }
       initialized = res;
  }
  
  return initialized;
}

virtual wxString VRUT::ChcRenderer::GetDesc

(

)

const [inline, virtual]

Always overload method giving description for your module.

Reimplemented from VRUT::RenderGlModule.

Definition at line 123 of file ChcRenderer.h.

         {
              return wxT("Advanced Renderer using occlusion culling");
         }

void ChcRenderer::Draw

(

)

[virtual]

This is the most important method in any render module It is called by kernel with GL context properly set so any GL calls can be done here and nowhere else

Clear buffer even if nothing to render

Lock camera but don't block readers if not needed

Check for scene changes and reinitialize modified nodes

Set projection matrix

Fit camera if scene is being imported

Set view matrix

Camera not in node

Sphere - frustum first

AABB - frustum

Reimplemented from VRUT::RenderGlModule.

Definition at line 159 of file ChcRenderer.cpp.

{
  frame++;

  glClearColor(0.4, 0.3, 0.6, 0.0);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
  wxMutexLocker paramsLocker(paramsMutex);
  scene = GetSceneMgr()->GetScene(GetSceneID());
  if (!scene)
       return;
  
  // copy the camera node
  Camera *pcam = (Camera *)scene->GetNode(cameraID);
  //BVH should be updated, updating here could allocate memory on module's heap
  //which could cause problems if module is unloaded before deallocating
  BVH * bvh = scene->GetBVH();
  if (!pcam || !bvh || !Initialize())
       {
         scene = (Scene *)NULL;
         return;
       }

  bool wrLockNeeded = !pcam->IsValid();

  if (wrLockNeeded)
       pcam->WriteLock();
  else
       pcam->ReadLock();

  // copy the camera
  Camera camera = *pcam;
  
  if (wrLockNeeded)
       pcam->WriteUnlock();
  else
       pcam->ReadUnlock();

  vboRenderUpdated = false;
  ResetNodes();
  
  glMatrixMode(GL_PROJECTION);
  
  /*   if (sceneImportMode)
              {
              WriteLocker fitLock(*camera);
              scene->Fit(cameraID, false);
              }*/
  
  scene->UpdateTransformation(camera.GetID());
  unsigned w, h;
  camera.GetWidthHeight(&w, &h);
  glViewport(0, 0, w, h);
  glLoadMatrixf(camera.GetProjectionMatrix()->_m);
  glMatrixMode(GL_MODELVIEW);
  glLoadMatrixf(camera.GetWorldTransMatrix()->Inverse()._m);
  
  
  
  if (drawBVH) {
       LOG(wxString::Format(wxT("DraBVH: %i"), drawBVH));
       drawBVHHierarchy();
  }

  //Scene lights
  drawLights();
  

  if (nodeInfo.size() != bvh->numberOfNodes) {
       LOG(wxString::Format(wxT("Number of nodes: %i"), bvh->numberOfNodes));
       nodeInfo.resize(bvh->numberOfNodes);
       for (unsigned int i=0; i < nodeInfo.size(); i++)
         nodeInfo[i].lastVisibleFrame = 24390252;
  }
  
  
  vector<const GeometryNode *> blendedNodes;
  priority_queue< NodeInfo > nodeStack;


  
  queue<QueryInfo> queryQueue;
  
  nodeStack.push(NodeInfo(0, (BVHNode *)bvh->GetRoot(), 0.0f));
  VECTOR3 cameraPos = camera.GetWorldTransMatrix()->ExtractTranslation();

  renderedNodes = 0;
  renderedBlendedNodes = 0;
  queriedNodes = 0;
  while (!nodeStack.empty() || !queryQueue.empty()) {
       // process finished queries
       
       while (!queryQueue.empty() &&
                 queryQueue.front().query->ResultAvailable()) {
         QueryInfo *qi = &queryQueue.front();
         
         if (qi->query->GetQueryResult() != 0) {
              if (!qi->info.node->IsLeaf() ||
                     nodeInfo[qi->info.node->id].lastVisibleFrame != frame-1)
                ProcessNode(qi->info, 
                                     cameraPos,
                                     qi->info.planeMask,
                                     blendedNodes,
                                     nodeStack);
              PullUpVisibility(qi->info.node);
         } else {
              // only update the visibility info
              // pull up invisibility
              //            PullUpInvisibility(qi->info.node);
         }
         
         queryQueue.pop();
         occlusionQueries.push(qi->query);
       }

       if (!nodeStack.empty()) {
         
         NodeInfo info = nodeStack.top();
         nodeStack.pop();
         //     LOG(wxString::Format(wxT("Process node: %i"), info.node->id));

         bvh->UpdateBV(info.node);
         Camera::VFC_RESULT result = Camera::INTERSECT;
         unsigned int planeMask = info.planeMask;
         
         if (!info.node->GetAABB()->PointIsIn(cameraPos)) {
              if (planeMask!=63) {
                // if planeMask == 63 the box is completely inside
                if (!info.node->GetBSphere()->Intersects(camera.GetBSphere()))
                     result = Camera::OUTSIDE;
                else
                     result = camera.InFrustum(*info.node->GetAABB(),
                                                                 &info.node->LastOut(),
                                                                 &planeMask);
              }
              
              if (result != Camera::OUTSIDE) {
                if (info.node->IsLeaf() ||
                       (nodeInfo[info.node->id].lastVisibleFrame != frame-1)
                       ) {
                     queriedNodes++;
                     // perform stop-and-wait occlusion culling
                     glPushAttrib(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ENABLE_BIT);
                     
                     glDisable(GL_CULL_FACE);
                     glDepthMask(GL_FALSE);
                     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
                     
                     OcclusionQuery *query = occlusionQueries.top();
                     occlusionQueries.pop();
                     
                     query->BeginQuery();
                     RenderBox(*info.node->GetAABB());
                     query->EndQuery();
                     
                     glPopAttrib();
                     
                     queryQueue.push(QueryInfo(query, info));
                     
                     //              if (query->GetQueryResult() == 0) {
                     //                   result = Camera::OUTSIDE;
                     //              }

                     if (info.node->IsLeaf() &&
                            nodeInfo[info.node->id].lastVisibleFrame == frame-1) {
                       // render previously visible leaves immediatelly
                       ProcessNode(info, cameraPos, planeMask, blendedNodes, nodeStack);
                     }
                } else
                     ProcessNode(info, cameraPos, planeMask, blendedNodes, nodeStack);
              }
         } else 
              ProcessNode(info, cameraPos, planeMask, blendedNodes, nodeStack);
         
         
         //   if (result != Camera::OUTSIDE) {
         //     ProcessNode(info, cameraPos, planeMask, blendedNodes, nodeStack);
         //   }
       }
  }
  
  // now render the transparent objects
  if (blendedNodes.size()) {
       glEnable(GL_BLEND);
       for (int i = blendedNodes.size()-1; i >=0; i--) {
         renderedBlendedNodes++;
         //     LOG(wxString::Format(wxT("Render blended node")));
         DrawNode(blendedNodes[i]);
       }
       glDisable(GL_BLEND);
  }
  
  //  query->EndQuery();
  //  unsigned int pixelCount = query->GetQueryResult();
  LOG(wxString::Format(wxT("Opaque nodes: %i"), renderedNodes));
  LOG(wxString::Format(wxT("Blended nodes: %i"), renderedBlendedNodes));
  LOG(wxString::Format(wxT("Queried nodes: %i"), queriedNodes));
  
  
  scene = (Scene *)NULL;
}

virtual void VRUT::ChcRenderer::Deinitialize

(

)

[inline, virtual]

Use this to deinitialize and release render data It is also called by kernel with GL context set so you can use anything like glDelete* etc.

Reimplemented from VRUT::RenderGlModule.

Definition at line 135 of file ChcRenderer.h.

         {
         }

void ChcRenderer::DrawItems

(

BVH::ItemsList &

itemsList

)

draw the geoemtry list obtained by culling the bvh

Draw node

Definition at line 68 of file ChcRenderer.cpp.

{
  //Draw the geometry list
  for (BVH::ItemsList::const_iterator nodeIt = itemsList.begin();
          nodeIt != itemsList.end();
          nodeIt++)
       {
         const GeometryNode * node = (const GeometryNode *)scene->GetNode(*nodeIt);
         if (!node->IsActive())
              continue;
         
         glPushMatrix();
         glMultMatrixf(node->GetWorldTransMatrix()->_m);
         
         if (useVBO && vboSupported)
              drawVBO(node);
         else
              drawDispList(node);
         
         glPopMatrix();
       }
}

void ChcRenderer::DrawItemsReverse

(

BVH::BlendedList &

itemsList

)

draw the geoemtry list in the reverse order obtained by culling the bvh

Draw node

Definition at line 93 of file ChcRenderer.cpp.

{
  //Draw the geometry list
  for (BVH::BlendedList::const_reverse_iterator nodeIt = itemsList.rbegin();
          nodeIt != itemsList.rend();
          nodeIt++)
       {
              const GeometryNode * node = (const GeometryNode *)scene->GetNode(nodeIt->second);
              if (!node->IsActive())
                     continue;

              glPushMatrix();
              glMultMatrixf(node->GetWorldTransMatrix()->_m);

              if (useVBO && vboSupported)
                     drawVBO(node);
              else
                     drawDispList(node);

              glPopMatrix();
       }
}

void ChcRenderer::DrawNode

(

const GeometryNode *

node

)

Draw a geometry node.

Draw node

Definition at line 50 of file ChcRenderer.cpp.

{
  if (!node->IsActive())
       return;
  
  glPushMatrix();
  glMultMatrixf(node->GetWorldTransMatrix()->_m);
  
  if (useVBO && vboSupported)
       drawVBO(node);
  else
       drawDispList(node);
  
  glPopMatrix();
}

void ChcRenderer::RenderBox

(

const AABB &

box

)

Render a bounding box.

Definition at line 120 of file ChcRenderer.cpp.

{
  
  glBegin(GL_QUADS);
  glVertex3d(box.MinBound.x, box.MaxBound.y, box.MinBound.z );
  glVertex3d(box.MaxBound.x, box.MaxBound.y, box.MinBound.z );
  glVertex3d(box.MaxBound.x, box.MinBound.y, box.MinBound.z );
  glVertex3d(box.MinBound.x, box.MinBound.y, box.MinBound.z );

  glVertex3d(box.MinBound.x, box.MinBound.y, box.MaxBound.z );
  glVertex3d(box.MaxBound.x, box.MinBound.y, box.MaxBound.z );
  glVertex3d(box.MaxBound.x, box.MaxBound.y, box.MaxBound.z );
  glVertex3d(box.MinBound.x, box.MaxBound.y, box.MaxBound.z );

  glVertex3d(box.MaxBound.x, box.MinBound.y, box.MinBound.z );
  glVertex3d(box.MaxBound.x, box.MinBound.y, box.MaxBound.z );
  glVertex3d(box.MaxBound.x, box.MaxBound.y, box.MaxBound.z );
  glVertex3d(box.MaxBound.x, box.MaxBound.y, box.MinBound.z );

  glVertex3d(box.MinBound.x, box.MinBound.y, box.MinBound.z );
  glVertex3d(box.MinBound.x, box.MinBound.y, box.MaxBound.z );
  glVertex3d(box.MinBound.x, box.MaxBound.y, box.MaxBound.z );
  glVertex3d(box.MinBound.x, box.MaxBound.y, box.MinBound.z );
  
  glVertex3d(box.MinBound.x, box.MinBound.y, box.MinBound.z );
  glVertex3d(box.MaxBound.x, box.MinBound.y, box.MinBound.z );
  glVertex3d(box.MaxBound.x, box.MinBound.y, box.MaxBound.z );
  glVertex3d(box.MinBound.x, box.MinBound.y, box.MaxBound.z );

  glVertex3d(box.MinBound.x, box.MaxBound.y, box.MinBound.z );
  glVertex3d(box.MaxBound.x, box.MaxBound.y, box.MinBound.z );
  glVertex3d(box.MaxBound.x, box.MaxBound.y, box.MaxBound.z );
  glVertex3d(box.MinBound.x, box.MaxBound.y, box.MaxBound.z );
  
  glEnd();
}

void ChcRenderer::ProcessNode	(	NodeInfo &	info,
		const VECTOR3 &	cameraPos,
		const int	planeMask,
		vector< const GeometryNode * > &	blendedNodes,
		priority_queue< NodeInfo > &	nodeStack
	)

Definition at line 372 of file ChcRenderer.cpp.

{

  //  if (info.node->id < nodeInfo.size())
  //   nodeInfo[info.node->id].lastVisibleFrame = frame;
  
  if (info.node->IsLeaf()) {
       const GeometryNode * sceneNode =
         (const GeometryNode *)scene->GetNode(info.node->GetSceneNodeID());
       
       const Material * material =
         scene->GetMaterial(sceneNode->GetMaterialID());
       
       if (material && material->flags & Material::BLENDED)
         blendedNodes.push_back(sceneNode);
       else {
         renderedNodes++;
         //     LOG(wxString::Format(wxT("Render node: %i"), info.node->id));
         DrawNode(sceneNode);
       }
       
  } else {
       nodeStack.push( NodeInfo(planeMask,
                                                  (BVHNode *)info.node->GetLChild(),
                                                  -SqrDistance(cameraPos,
                                                                        info.node->GetLChild()->GetAABB()->Center())));
       nodeStack.push( NodeInfo(planeMask,
                                                  (BVHNode *)info.node->GetRChild(),
                                                  -SqrDistance(cameraPos,
                                                                        info.node->GetRChild()->GetAABB()->Center())));
  }
}

void ChcRenderer::PullUpInvisibility

(

BVHNode *

node

)

Definition at line 420 of file ChcRenderer.cpp.

{
  nodeInfo[node->id].lastVisibleFrame = frame-1;
  BVHNode *n = node->GetParent();
  while (n) {
       if (nodeInfo[n->GetLChild()->id].lastVisibleFrame != frame &&
              nodeInfo[n->GetRChild()->id].lastVisibleFrame != frame
              )
         nodeInfo[n->id].lastVisibleFrame = frame-1;
       else
         break;
       n = n->GetParent();
  }
}

void ChcRenderer::PullUpVisibility

(

BVHNode *

node

)

Definition at line 411 of file ChcRenderer.cpp.

{
  while (node && nodeInfo[node->id].lastVisibleFrame != frame) {
       nodeInfo[node->id].lastVisibleFrame = frame;
       node = node->GetParent();
  }
}

---

Member Data Documentation

int VRUT::ChcRenderer::var [protected]

Add any variables.

Definition at line 68 of file ChcRenderer.h.

Parameter::ParameterIdentificator VRUT::ChcRenderer::varParamID [protected]

Add var param identificator to register this as parameter.

Definition at line 71 of file ChcRenderer.h.

int VRUT::ChcRenderer::frame [protected]

number of current frame

Definition at line 74 of file ChcRenderer.h.

vector<ChcNodeInfo> VRUT::ChcRenderer::nodeInfo [protected]

Definition at line 76 of file ChcRenderer.h.

stack<OcclusionQuery *> VRUT::ChcRenderer::occlusionQueries [protected]

occlusion queries used by the CHC method

Definition at line 95 of file ChcRenderer.h.

int VRUT::ChcRenderer::renderedNodes [protected]

number of nodes rendered in the current frame

Definition at line 97 of file ChcRenderer.h.

int VRUT::ChcRenderer::renderedBlendedNodes [protected]

number of nodes rendered in the current frame

Definition at line 99 of file ChcRenderer.h.

int VRUT::ChcRenderer::queriedNodes [protected]

number of queried nodes

Definition at line 101 of file ChcRenderer.h.

---

The documentation for this class was generated from the following files:

• /cygdrive/d/src/svn/vrut/trunk/modules/ChcRenderer/ChcRenderer.h
• /cygdrive/d/src/svn/vrut/trunk/modules/ChcRenderer/ChcRenderer.cpp