source: trunk/VUT/GtpVisibilityPreprocessor/src/GlRenderer.cpp @ 497

#include "Mesh.h"
#include "GlRenderer.h"
#include "ViewCellsManager.h"
#include "SceneGraph.h"
#include "Pvs.h"
#include "Viewcell.h"

#include <GL/glext.h>

GlRendererWidget *rendererWidget = NULL;

#ifdef _WIN32
PFNGLGENOCCLUSIONQUERIESNVPROC glGenOcclusionQueriesNV;
PFNGLBEGINOCCLUSIONQUERYNVPROC glBeginOcclusionQueryNV;
PFNGLENDOCCLUSIONQUERYNVPROC glEndOcclusionQueryNV;
PFNGLGETOCCLUSIONQUERYUIVNVPROC glGetOcclusionQueryuivNV;
#endif

GlRenderer::GlRenderer(SceneGraph *sceneGraph,
                                           ViewCellsManager *viewCellsManager):
  Renderer(sceneGraph, viewCellsManager)
{
  mSceneGraph->CollectObjects(&mObjects);
  mViewPoint = mSceneGraph->GetBox().Center();
  mViewDirection = Vector3(0,0,1);
  //  timerId = startTimer(10);
  mFrame = 0;
}

GlRenderer::~GlRenderer()
{
}

void
GlRenderer::RenderIntersectable(Intersectable *object)
{

  SetupFalseColor(object->mId);

  switch (object->Type()) {
  case Intersectable::MESH_INSTANCE:
        RenderMeshInstance((MeshInstance *)object);
        break;
  default:
        cerr<<"Rendering this object not yet implemented\n";
        break;
  }
}


void
GlRenderer::RenderMeshInstance(MeshInstance *mi)
{
  RenderMesh(mi->GetMesh());
}

void
GlRenderer::SetupFalseColor(const int id)
{
  // swap bits of the color
  
  glColor3ub(id&255, (id>>8)&255, (id>>16)&255);
}

void
GlRenderer::SetupMaterial(Material *m)
{
  if (m)
        glColor3fv(&(m->mDiffuseColor.r));
  else
        glColor3f(1.0f, 1.0f, 1.0f);
}

void
GlRenderer::RenderMesh(Mesh *mesh)
{
  int i = 0;

  if (!mUseFalseColors)
        SetupMaterial(mesh->mMaterial);
  
  for (i=0; i < mesh->mFaces.size(); i++) {
        glBegin(GL_POLYGON);
        Face *face = mesh->mFaces[i];
        for (int j = 0; j < face->mVertexIndices.size(); j++) {
          glVertex3fv(&mesh->mVertices[face->mVertexIndices[j]].x);
        }
        glEnd();
  }
}
        
void
GlRenderer::InitGL()
{
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  glEnable(GL_CULL_FACE);
  glShadeModel(GL_FLAT);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);
  
  glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)
        wglGetProcAddress("glGenOcclusionQueriesNV");
  glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)
        wglGetProcAddress("glBeginOcclusionQueryNV");
  glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)
        wglGetProcAddress("glEndOcclusionQueryNV");
  glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)
        wglGetProcAddress("glGetOcclusionQueryuivNV");
}



void
GlRenderer::SetupProjection(const int w, const int h)
{
  glViewport(0, 0, w, h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(70.0, 1.0, 0.1, 2.0*Magnitude(mSceneGraph->GetBox().Diagonal()));
  glMatrixMode(GL_MODELVIEW);
}

void
GlRenderer::SetupCamera()
{
  Vector3 target = mViewPoint + mViewDirection;
  Vector3 up(0,1,0);
  
  glLoadIdentity();
  gluLookAt(mViewPoint.x, mViewPoint.y, mViewPoint.z,
                        target.x, target.y, target.z,
                        up.x, up.y, up.z);
}

void
GlRenderer::RandomViewPoint()
{
  Vector3 pVector = Vector3(halton.GetNumber(1),
                                                        halton.GetNumber(2),
                                                        halton.GetNumber(3));
  
  Vector3 dVector = Vector3(2*M_PI*halton.GetNumber(4),
                                                        M_PI*halton.GetNumber(5),
                                                        0.0f);
  
  mViewPoint = mSceneGraph->GetBox().GetPoint(pVector);
  
  mViewDirection = Normalize(Vector3(sin(dVector.x),
                                                                         //                                                                      cos(dVector.y),
                                                                         0.0f,
                                                                         cos(dVector.x)));

  halton.GenerateNext();
}


float
GlRenderer::GetPixelError()
{
  float pErrorPixels = -1.0f;

  glReadBuffer(GL_BACK);
  
  mUseFalseColors = true;

  SetupCamera();
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glEnable( GL_CULL_FACE );
  
  RenderScene();

  // now check whether any backfacing polygon would pass the depth test
  static int query = -1;
  if (query == -1)
        glGenOcclusionQueriesNV(1, (unsigned int *)&query);
  
  glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
  glDepthMask(GL_FALSE);
  glDisable( GL_CULL_FACE );
  
  glBeginOcclusionQueryNV(query);
  
  RenderScene();
  
  glEndOcclusionQueryNV();

  // at this point, if possible, go and do some other computation
  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  glDepthMask(GL_TRUE);
  glEnable( GL_CULL_FACE );
  
  unsigned int pixelCount;
  // reenable other state
  glGetOcclusionQueryuivNV(query,
                                                   GL_PIXEL_COUNT_NV,
                                                   &pixelCount);

  if (pixelCount > 0)
        return -1.0f; // backfacing polygon found -> not a valid viewspace sample

  ViewCell *viewcell = mViewCellsManager->GetViewCell(mViewPoint);
  
  if (viewcell) {
        SetupCamera();
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // Render PVS
        std::map<Intersectable *,
          PvsData<Intersectable *>,
          LtSample<Intersectable *> >::const_iterator it = viewcell->GetPvs().mEntries.begin();
        
        for (; it != viewcell->GetPvs().mEntries.end(); ++ it) {
          Intersectable *object = (*it).first;
          RenderIntersectable(object);
        }

        glBeginOcclusionQueryNV(query);

        SetupCamera();

        RenderScene();
        
        glEndOcclusionQueryNV();
        

        unsigned int pixelCount;
        // reenable other state
        glGetOcclusionQueryuivNV(query,
                                                         GL_PIXEL_COUNT_NV,
                                                         &pixelCount);
        
        pErrorPixels = (100.f*pixelCount)/(GetWidth()*GetHeight());
  }
  
  return pErrorPixels;
}


float
GlRendererWidget::RenderErrors()
{
  float pErrorPixels = -1.0f;

  glReadBuffer(GL_BACK);
  
  mUseFalseColors = true;

  SetupCamera();
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glEnable( GL_CULL_FACE );
  
  ObjectContainer::const_iterator oi = mObjects.begin();
  for (; oi != mObjects.end(); oi++)
        RenderIntersectable(*oi);

  ViewCell *viewcell = mViewCellsManager->GetViewCell(mViewPoint);
  
  QImage im1, im2;
  QImage diff;
  
  if (viewcell) {
        // read back the texture
        im1 = grabFrameBuffer(true);
        
        SetupCamera();
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        std::map<Intersectable *,
          PvsData<Intersectable *>,
          LtSample<Intersectable *> >::const_iterator it = viewcell->GetPvs().mEntries.begin();
        
        for (; it != viewcell->GetPvs().mEntries.end(); ++ it) {
          Intersectable *object = (*it).first;
          RenderIntersectable(object);
        }

        // read back the texture
        im2 = grabFrameBuffer(true);
        
        diff = im1;
        int x, y;
        int errorPixels = 0;
        
        for (y = 0; y < im1.height(); y++)
          for (x = 0; x < im1.width(); x++)
                if (im1.pixel(x, y) == im2.pixel(x, y))
                  diff.setPixel(x, y, qRgba(0,0,0,0));
                else {
                  diff.setPixel(x, y, qRgba(255,128,128,255));
                  errorPixels++;
                }
        pErrorPixels = (100.f*errorPixels)/(im1.height()*im1.width());
  }

  // now render the pvs again
  SetupCamera();
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  mUseFalseColors = false;
        
  oi = mObjects.begin();
  for (; oi != mObjects.end(); oi++)
        RenderIntersectable(*oi);

  // now render im1
  if (viewcell) {
        // init ortographic projection
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        
        glLoadIdentity();
        gluOrtho2D(0, 1.0f, 0, 1.0f);
        
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        
        bindTexture(diff);
        
        glPushAttrib(GL_ENABLE_BIT);
        glEnable( GL_ALPHA_TEST );
        glDisable( GL_CULL_FACE );
        glAlphaFunc( GL_GREATER, 0.5 );
        
        glEnable( GL_TEXTURE_2D );
        glBegin(GL_QUADS);
        
        glTexCoord2f(0,0);
        glVertex3f(0,0,0);
        
        glTexCoord2f(1,0);
        glVertex3f( 1, 0, 0);
        
        glTexCoord2f(1,1);
        glVertex3f( 1, 1, 0);
        
        glTexCoord2f(0,1);
        glVertex3f(0, 1, 0);
        glEnd();
        
        glPopAttrib();
        
        // restore the projection matrix
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
  }

  return pErrorPixels;
}


bool
GlRenderer::RenderScene()
{
  static int glList = -1;
  if (glList != -1) {
        glCallList(glList);
  } else {
        glList = glGenLists(1);
        glNewList(glList, GL_COMPILE_AND_EXECUTE);
        ObjectContainer::const_iterator oi = mObjects.begin();
        for (; oi != mObjects.end(); oi++)
          RenderIntersectable(*oi);
        glEndList();
  }
  return true;
}


void
GlRendererBuffer::ClearErrorBuffer()
{
  for (int i=0; i < mPvsStatFrames; i++) {
        mPvsErrorBuffer[i] = 1.0f;
  }
}


void
GlRendererBuffer::EvalPvsStat()
{
  mPvsStat.Reset();
  halton.Reset();

  makeCurrent();

  SetupProjection(GetWidth(), GetHeight());
  
  for (int i=0; i < mPvsStatFrames; i++) {
        float err;
        RandomViewPoint();
        if (mPvsErrorBuffer[i] > 0.0f) {
          mPvsErrorBuffer[i] = GetPixelError();
          cout<<"("<<i<<","<<mPvsErrorBuffer[i]<<")";
          //      swapBuffers();
        }
        
        err = mPvsErrorBuffer[i];
        
        if (err >= 0.0f) {
          if (err > mPvsStat.maxError)
                mPvsStat.maxError = err;
          mPvsStat.sumError += err;
          if (err == 0.0f)
                mPvsStat.errorFreeFrames++;
          mPvsStat.frames++;
        }
  }
  
  doneCurrent();

  cout<<endl<<flush;
  mRenderingFinished.wakeAll();
}





void
GlRendererWidget::mousePressEvent(QMouseEvent *e)
{
  int x = e->pos().x();
  int y = e->pos().y();

  mousePoint.x = x;
  mousePoint.y = y;
  
}

void
GlRendererWidget::mouseMoveEvent(QMouseEvent *e)
{
  float MOVE_SENSITIVITY = Magnitude(mSceneGraph->GetBox().Diagonal())*1e-3;
  float TURN_SENSITIVITY=0.1f;
  float TILT_SENSITIVITY=32.0 ;
  float TURN_ANGLE= M_PI/36.0 ;

  int x = e->pos().x();
  int y = e->pos().y();
  
  if (e->modifiers() & Qt::ControlModifier) {
        mViewPoint.y += (y-mousePoint.y)*MOVE_SENSITIVITY/2.0;
        mViewPoint.x += (x-mousePoint.x)*MOVE_SENSITIVITY/2.0;
  } else {
        mViewPoint += mViewDirection*((mousePoint.y - y)*MOVE_SENSITIVITY);
        float adiff = TURN_ANGLE*(x - mousePoint.x)*-TURN_SENSITIVITY;
        float angle = atan2(mViewDirection.x, mViewDirection.z);
        mViewDirection.x = sin(angle+adiff);
        mViewDirection.z = cos(angle+adiff);
  }
  
  mousePoint.x = x;
  mousePoint.y = y;
  
  updateGL();
}

void
GlRendererWidget::mouseReleaseEvent(QMouseEvent *)
{


}

void
GlRendererWidget::resizeGL(int w, int h)
{
  SetupProjection(w, h);
  updateGL();
}

void
GlRendererWidget::paintGL()
{
  RenderErrors();
  mFrame++;
}