source: GTP/trunk/Lib/Vis/Preprocessing/src/OcclusionQuery.cpp @ 1001

//#include "glInterface.h"
#include "OcclusionQuery.h"
#include <iostream>
//#include <GL/gl.h>
//#include <QtOpenGL>
#include <glInterface.h>


using namespace std;

namespace GtpVisibilityPreprocessor {

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)
        {
                //GLint available;
                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)
        {
//              GLint sampleCount;
                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)
{
        if ((int)queries.size() < numQueries)
        {
                const int n = numQueries - (int)queries.size();
                unsigned int *newQueries = new unsigned int[n];


                if (sUseArbQueries)
                {
                        glGenQueriesARB(n, (unsigned int *)newQueries);
                }
                else
                {
                        glGenOcclusionQueriesNV(n, (unsigned int *)newQueries);
                }

                for (int i = 0; i < n; ++ i)
                {
                        queries.push_back(new OcclusionQuery(newQueries[i]));
                        //cout << "q: " << i << " id: " << newQueries[i] << endl;
                }

                delete [] newQueries;
        }
}
} // namespace