/cygdrive/d/src/svn/vrut/trunk/modules/RayTracer/RayTracer.cpp

Go to the documentation of this file.

/*
 * $Id: _render.cpp 324 2008-10-01 18:04:45Z kybav1 $
 *
 * Description  : One line description of file.
 * Author       : Vaclav Kyba <mail/Jabber: vaseo1@gmail.com>  <ICQ: 98576293>
 *
 * Purpose      :
 *     Long description of what the file is for.
 */

#include <stack>

#include "RayTracer.h"
#include "../../core/src/geometrynode.h"

using namespace VRUT;

         
void
RayTracer::processEvent(wxCommandEvent & evt)
{
  RenderModule::processEvent(evt);
  
  switch (evt.GetEventType()) {
  case Event::EVT_PARAM_SET:
       UPDATE_PARAM_FROM_EVENT_INT(varParamID, var, evt);
       break;
  }
}


bool
RayTracer::CastRay(const Ray & ray,
                               RayIntersectionInfo &bestFound)
{
  if (!bvh->GetRoot())
       return false;
  
  bestFound.dist = 1e9f;
  bestFound.nodeID = NODE_ID_NONE;
  
  std::stack<BVHNode *> stack;
  stack.push(bvh->GetRoot());
  while (!stack.empty()) {
       BVHNode * node = stack.top();
       stack.pop();
       
       float dist = 1e9f;
       VECTOR3 intersection;
       bvh->UpdateBV(node);
       if (node->GetAABB()->Intersects(ray, 0, bestFound.dist, &dist)) {
         if (node->IsLeaf()) {
              const GeometryNode * sNode = (const GeometryNode *)scene->GetNode(node->GetSceneNodeID());
              const MATRIX * worldMat = sNode->GetWorldTransMatrix();
              MATRIX invWorldMat = worldMat->Inverse();
              VECTOR3 modelOrigin = invWorldMat.TransformCoord(ray.origin);
              VECTOR3 modelDir = invWorldMat.TransformNormal(ray.direction).Normalize();
              const Ray modelRay(modelOrigin, modelDir);
              RayIntersectionInfo gInfo;
              if (scene->GetGeometry(sNode->GetGeometryID())->CastRay(modelRay, gInfo)) {
                VECTOR3 intersection = modelRay.origin + modelRay.direction * gInfo.dist;
                intersection = worldMat->TransformCoord(intersection);
                dist = (ray.origin - intersection).Length();
                if (dist < bestFound.dist && dist > 0) {
                     bestFound.nodeID = node->GetSceneNodeID();
                     bestFound.dist = dist;
                     bestFound.intersection = intersection;
                     bestFound.normal = worldMat->TransformNormal(gInfo.normal);
                }
              }
         }
         else
              {
                if (node->GetLChild())
                     stack.push(node->GetLChild());
                if (node->GetRChild())
                     stack.push(node->GetRChild());
              }
       }
  }
  
  return bestFound.nodeID != NODE_ID_NONE;
}



RayTracer::RayTracer(const MODULE_ID & _id, const wxString & _name,
                                    EventHandler * msgSink)
  : RenderModule(_id, _name, 0, msgSink)
{
  REGISTER_PARAM_GUI_SLIDER(varParamID, wxT("Test var"), wxT("100"), 0, 200, wxT("test var"));
}

void
RayTracer::Draw()      
{
  glClearColor(0.8, 0.1, 0.1, 0.0);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
  scene = GetSceneMgr()->GetScene(GetSceneID());
  if (!scene)
       return;
  
  bvh = scene->GetBVH();
  
  Camera * camera = (Camera *)scene->GetNode(cameraID);
  if (!camera || !bvh)
       return;
  
  glMatrixMode(GL_PROJECTION);
  WriteLocker wrLock(*camera);
  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);

  glDisable(GL_LIGHTING);
  glDisable(GL_TEXTURE_2D);

  // now perform ray casting
  VECTOR3 origin(0, 0, 0);
  origin = camera->GetWorldTransMatrix()->TransformCoord(origin);
         
  glBegin(GL_POINTS);
  for (unsigned int y = 0; y < h; y+=2)
       for (unsigned int x = 0; x < w; x+=2) {
         
         float px = ((( 2.0f * x) / w) - 1.0f) / camera->GetProjectionMatrix()->_m11;
         float py = (((-2.0f * y) / h) + 1.0f) / camera->GetProjectionMatrix()->_m22;

         VECTOR3 direction(px, py, -1.0f);

         direction = camera->GetWorldTransMatrix()->TransformNormal(direction).Normalize();

         Ray ray(origin, direction);
         RayIntersectionInfo info;
         
         // call cast ray routine...
         if (bvh->CastRay(ray, info)) {
              VECTOR3 p = info.intersection;

              // do some simple shading
              const GeometryNode * sNode = (const GeometryNode *)scene->GetNode(info.nodeID);
              const Material * material = scene->GetMaterial(sNode->GetMaterialID());
              float a = abs(direction.Dot(info.normal));

              if (material) {
                vector4 c = a*material->diffuse;
                //            glColor3fv(material->diffuse._v);
                glColor4fv(c._v);

                
                //glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, material->ambient._v);
                //glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, material->emission._v);
                //glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, material->specular._v);
                // glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, material->shininess);
              } else
                glColor3f(a, a, a);
              

              
              glVertex3f(p.x,
                               p.y,
                               p.z);
         }
       }
  
  glEnd();
  
  if (0) {
  std::stack<const BVHNode *> stack;
  VECTOR3 color(1,1,1);

  stack.push(bvh->GetRoot());

  while (!stack.empty()) {
       const BVHNode * node = stack.top();
       stack.pop();
       
       if (node) {
         glColor3fv(color._v);
         VECTOR3 v0(node->GetAABB()->MinBound);
         VECTOR3 v7(node->GetAABB()->MaxBound);
         VECTOR3 v1(v7.x, v0.y, v0.z);
         VECTOR3 v2(v0.x, v7.y, v0.z);
         VECTOR3 v3(v7.x, v7.y, v0.z);
         VECTOR3 v4(v0.x, v0.y, v7.z);
         VECTOR3 v5(v7.x, v0.y, v7.z);
         VECTOR3 v6(v0.x, v7.y, v7.z);
         glBegin(GL_LINE_STRIP);
         glVertex3fv(v0._v);
         glVertex3fv(v1._v);
         glVertex3fv(v3._v);
         glVertex3fv(v2._v);
         glVertex3fv(v0._v);
         glVertex3fv(v4._v);
         glVertex3fv(v6._v);
         glVertex3fv(v7._v);
         glVertex3fv(v5._v);
         glVertex3fv(v4._v);
         glVertex3fv(v6._v);
         glVertex3fv(v2._v);
         glVertex3fv(v3._v);
         glVertex3fv(v7._v);
         glVertex3fv(v5._v);
         glVertex3fv(v1._v);
         glEnd();
         
         stack.push(node->GetLChild());
         stack.push(node->GetRChild());
       }
       
  }
  }
}

---