/cygdrive/d/src/svn/vrut/trunk/modules/ChcRenderer/OcclusionQuery.cpp

Go to the documentation of this file.

#include "OcclusionQuery.h"
#include <iostream>

#include "../../core/src/flexilog.h"

#ifdef _WIN32
#define GLEW_STATIC
#include <GL/glew.h>
#else
#define GLEW_STATIC
#include <GL/glew.h>
#include <GL/gl.h>
//#include <GL/glu.h>
//#include <GL/glxext.h>
#endif


using namespace std;

bool OcclusionQuery::sUseArbQueries = true;

OcclusionQuery::OcclusionQuery()
{
  GLuint id;

  if (sUseArbQueries) {
       glGenQueriesARB(1, &id);
  } else {           
       glGenOcclusionQueriesNV(1, &id);
  }
}

OcclusionQuery::OcclusionQuery(const unsigned int idx):
  mId(idx)
{}


OcclusionQuery::~OcclusionQuery()
{
  if (sUseArbQueries) {
       glDeleteQueriesARB(1, &mId);
  } else {
       glDeleteOcclusionQueriesNV(1, &mId);
  }
}

//-----------------------------------------------------------------------
void
OcclusionQuery::BeginQuery()
{
       if (sUseArbQueries) {
         glBeginQueryARB(GL_SAMPLES_PASSED_ARB, mId);
       } else {
         glBeginOcclusionQueryNV(mId);
       }
}
//-----------------------------------------------------------------------
void
OcclusionQuery::EndQuery()
{
       if (sUseArbQueries) {
         glEndQueryARB(GL_SAMPLES_PASSED_ARB);
       } else {
         glEndOcclusionQueryNV();  
       }
}


unsigned int
OcclusionQuery::GetQueryId() const
{
  return mId;
}

bool
OcclusionQuery::ResultAvailable() const
{
  GLuint available;
  
  if (sUseArbQueries) {
       glGetQueryObjectuivARB(mId,
                                             GL_QUERY_RESULT_AVAILABLE_ARB,
                                             &available);
       return available == GL_TRUE;
  } else {
         glGetOcclusionQueryuivNV(mId, GL_PIXEL_COUNT_AVAILABLE_NV, &available);
         return available == GL_TRUE;
  }
}


unsigned int
OcclusionQuery::GetQueryResult() const
{
  GLuint sampleCount;
  
  if (sUseArbQueries)       {
       glGetQueryObjectuivARB(mId, GL_QUERY_RESULT_ARB, &sampleCount);
       return sampleCount;
  } else {    
       glGetOcclusionQueryuivNV(mId, GL_PIXEL_COUNT_NV, &sampleCount);
       return sampleCount;
  }
}


void
OcclusionQuery::GenQueries(std::vector<OcclusionQuery * > &queries, const int numQueries)
{
  //Debug<<"Generating queries "<<numQueries<<" occlussion queries"<<endl;
  if ((int)queries.size() < numQueries) {
       const int n = numQueries - (int)queries.size();
       GLuint *newQueries = new GLuint[n];

       LOG(wxString::Format(wxT("Generating %i occlusion queries."), n));
       
       if (sUseArbQueries) {
         glGenQueriesARB(n, newQueries);
       } else {
         glGenOcclusionQueriesNV(n, newQueries);
       }
       
       for (int i = 0; i < n; ++ i) {
         queries.push_back(new OcclusionQuery(newQueries[i]));
       }
       
       delete newQueries;
  }
}

---