void recursion( float startX, float startY, float startZ, float startW) { glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,streamoutBufffer[0]); glBeginTransformFeedback(GL_POINTS); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, outputQuery); glPointSize(1); glBegin(GL_POINTS); glVertex4f(startX, startY, startZ, startW); glEnd(); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); glEndTransformFeedback(); GLint outPointCount = 0; GLint succ = 0; while(!succ) glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT_AVAILABLE, &succ); glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT, &outPointCount); //std::cout << "points written: " << outPointCount << std::endl; succ = 0; glEnableClientState(GL_VERTEX_ARRAY); int bb = 0; while(outPointCount > 0) { glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,streamoutBufffer[(bb+1)%2]); glBeginTransformFeedback(GL_POINTS); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, outputQuery); glBindBufferARB(GL_ARRAY_BUFFER_ARB, streamoutBufffer[bb]); glVertexPointer(4,GL_FLOAT,0,NULL); glDrawArrays(GL_POINTS, 0, outPointCount); glEndTransformFeedback(); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); while(!succ) glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT_AVAILABLE, &succ); glGetQueryObjectiv(outputQuery, GL_QUERY_RESULT, &outPointCount); succ = 0; bb = (bb + 1) % 2; } glDisableClientState(GL_VERTEX_ARRAY); }
float stop_timing() { glEndQuery(GL_TIME_ELAPSED); GLint available = GL_FALSE; while (available == GL_FALSE) glGetQueryObjectiv(gTimer, GL_QUERY_RESULT_AVAILABLE, &available); GLint result; glGetQueryObjectiv(gTimer, GL_QUERY_RESULT, &result); float timeElapsed = result / (1000.0f * 1000.0f * 1000.0f); return timeElapsed; }
float CoronaVisibility (int nQuery) { GLuint nSamples = 0; GLint bAvailable = 0; int nAttempts = 2; float fIntensity; #if DBG GLint nError; #endif if (! (ogl.m_states.bOcclusionQuery && nQuery) || (CoronaStyle () != 1)) return 1; if (! (gameStates.render.bQueryCoronas || gameData.render.lights.coronaSamples [nQuery - 1])) return 0; for (;;) { glGetQueryObjectiv (gameData.render.lights.coronaQueries [nQuery - 1], GL_QUERY_RESULT_AVAILABLE_ARB, &bAvailable); if (glGetError ()) { #if DBG glGetQueryObjectiv (gameData.render.lights.coronaQueries [nQuery - 1], GL_QUERY_RESULT_AVAILABLE_ARB, &bAvailable); if ((nError = glGetError ())) #endif return 0; } if (bAvailable) break; if (!--nAttempts) return 0; G3_SLEEP (1); }; glGetQueryObjectuiv (gameData.render.lights.coronaQueries [nQuery - 1], GL_QUERY_RESULT_ARB, &nSamples); if (glGetError ()) return 0; if (gameStates.render.bQueryCoronas == 1) { #if DBG if (!nSamples) { GLint nBits; glGetQueryiv (GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &nBits); glGetQueryObjectuiv (gameData.render.lights.coronaQueries [nQuery - 1], GL_QUERY_RESULT_ARB, &nSamples); } #endif return (float) (gameData.render.lights.coronaSamples [nQuery - 1] = nSamples); } fIntensity = (float) nSamples / (float) gameData.render.lights.coronaSamples [nQuery - 1]; #if DBG if (fIntensity > 1) fIntensity = 1; #endif return (fIntensity > 1) ? 1 : (float) sqrt (fIntensity); }
enum piglit_result piglit_display(void) { bool pass = true; GLuint ids[10]; GLint param; /* Throw some invalid inputs at glCreateQueries */ /* n is negative */ glCreateQueries(GL_SAMPLES_PASSED, -1, ids); SUBTEST(GL_INVALID_VALUE, pass, "n < 0"); /* invalid target */ glCreateQueries(GL_RGBA, 0, ids); SUBTEST(GL_INVALID_ENUM, pass, "invalid target"); /* Throw some valid inputs at glCreateQueries. */ /* n is zero */ glCreateQueries(GL_SAMPLES_PASSED, 0, NULL); SUBTEST(GL_NO_ERROR, pass, "n == 0"); /* n is more than 1 */ glCreateQueries(GL_SAMPLES_PASSED, 10, ids); SUBTEST(GL_NO_ERROR, pass, "n > 1"); /* test the default state of dsa-created query objects */ SUBTESTCONDITION(glIsQuery(ids[2]), pass, "IsQuery()"); glGetQueryObjectiv(ids[2], GL_QUERY_RESULT_AVAILABLE, ¶m); piglit_check_gl_error(GL_NO_ERROR); SUBTESTCONDITION(param == GL_TRUE, pass, "default AVAILABLE state(%d) == TRUE", param); glGetQueryObjectiv(ids[2], GL_QUERY_RESULT, ¶m); piglit_check_gl_error(GL_NO_ERROR); SUBTESTCONDITION(param == 0, pass, "default RESULT(%d) == 0", param); /* test the target */ glGetQueryObjectiv(ids[2], GL_QUERY_TARGET, ¶m); piglit_check_gl_error(GL_NO_ERROR); SUBTESTCONDITION(param == GL_SAMPLES_PASSED, pass, "TARGET(%s) == " "GL_SAMPLES_PASSED", piglit_get_gl_enum_name(param)); /* clean up */ glDeleteQueries(10, ids); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
int stopGPUTimer(GPUtimer* timer, float* times, int maxTimes) { // NVG_NOTUSED(times); // NVG_NOTUSED(maxTimes); GLint available = 1; int n = 0; if (!timer->supported) return 0; glEndQuery(GL_TIME_ELAPSED); while (available && timer->ret <= timer->cur) { // check for results if there are any glGetQueryObjectiv(timer->queries[timer->ret % GPU_QUERY_COUNT], GL_QUERY_RESULT_AVAILABLE, &available); if (available) { GLuint64 timeElapsed = 0; glGetQueryObjectui64v(timer->queries[timer->ret % GPU_QUERY_COUNT], GL_QUERY_RESULT, &timeElapsed); timer->ret++; if (n < maxTimes) { times[n] = (float)((double)timeElapsed * 1e-9); n++; } } } return n; }
GLint GL3OcclusionQueryProvider::get_result() const { OpenGL::set_active(gc_provider); GLint result; glGetQueryObjectiv(handle, GL_QUERY_RESULT, &result); return result; }
enum piglit_result piglit_display(void) { int test_pass = 1; GLuint query; GLint result; piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* Guaranteed to be random, see: http://xkcd.com/221 */ query = 3243; test_pass &= is_query_matches(query, 0, "with un-generated name"); glGenQueries(1, &query); test_pass &= is_query_matches(query, 0, "after glGenQueries"); glQueryCounter(query, GL_TIMESTAMP); test_pass &= is_query_matches(query, 1, "after glQueryCounter"); /* Do a little drawing at least */ glColor3ub(0x00, 0xff, 0x00); piglit_draw_rect(0, 0, piglit_width, piglit_height); glGetQueryObjectiv(query, GL_QUERY_RESULT, &result); test_pass &= is_query_matches(query, 1, "after glGetQueryObjectiv"); glDeleteQueries(1, &query); test_pass &= is_query_matches(query, 0, "after glDeleteQueries"); piglit_present_results(); return test_pass ? PIGLIT_PASS : PIGLIT_FAIL; }
bool GPUTimer::updateResults() { if( !glExt::ARB_timer_query ) return false; if( _numQueries == 0 ) { _time = 0; return true; } // Make sure that last query is available GLint available; glGetQueryObjectiv( _queryPool[_numQueries * 2 - 1], GL_QUERY_RESULT_AVAILABLE, &available ); if( !available ) return false; // Accumulate time GLuint64 timeStart = 0, timeEnd = 0, timeAccum = 0; for( uint32 i = 0; i < _numQueries; ++i ) { glGetQueryObjectui64v( _queryPool[i * 2], GL_QUERY_RESULT, &timeStart ); glGetQueryObjectui64v( _queryPool[i * 2 + 1], GL_QUERY_RESULT, &timeEnd ); timeAccum += timeEnd - timeStart; } _time = (float)((double)timeAccum / 1000000.0); return true; }
bool GL3OcclusionQueryProvider::is_result_ready() const { OpenGL::set_active(gc_provider); int available; glGetQueryObjectiv(handle, GL_QUERY_RESULT_AVAILABLE, &available); return (available != 0); }
bool GLEventQuery::isReady() const { GLint done = 0; glGetQueryObjectiv(mQueryObj, GL_QUERY_RESULT_AVAILABLE, &done); return done == GL_TRUE; }
PIGLIT_GL_TEST_CONFIG_END enum piglit_result piglit_display(void) { GLuint oq[3]; GLint result[3] = {2, 2, 2}; bool pass = true; int i; glEnable(GL_DEPTH_TEST); glClearDepth(1.0); glClearColor(0.5, 0.5, 0.5, 0.5); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glGenQueries(3, oq); glDeleteQueries(3, oq); glColor4f(0.0, 1.0, 0.0, 0.0); glBeginQuery(GL_ANY_SAMPLES_PASSED, oq[0]); piglit_draw_rect_z(0.5, -1, -1, 2, 2); glEndQuery(GL_ANY_SAMPLES_PASSED); glBeginQuery(GL_ANY_SAMPLES_PASSED, oq[1]); glEndQuery(GL_ANY_SAMPLES_PASSED); glColor4f(1.0, 0.0, 0.0, 0.0); glBeginQuery(GL_ANY_SAMPLES_PASSED, oq[2]); piglit_draw_rect_z(0.75, -0.5, -0.5, 1.0, 1.0); glEndQuery(GL_ANY_SAMPLES_PASSED); piglit_present_results(); for (i = 0; i < 3; i++) { glGetQueryObjectiv(oq[i], GL_QUERY_RESULT, &result[i]); } if (result[0] != GL_TRUE) { fprintf(stderr, "GL_ANY_SAMPLES_PASSED with passed fragments returned %d\n", result[0]); pass = false; } if (result[1] != GL_FALSE) { fprintf(stderr, "GL_ANY_SAMPLES_PASSED with no rendering returned %d\n", result[1]); pass = false; } if (result[2] != GL_FALSE) { fprintf(stderr, "GL_ANY_SAMPLES_PASSED with occluded rendering returned %d\n", result[2]); pass = false; } return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
PIGLIT_GL_TEST_CONFIG_END enum piglit_result piglit_display(void) { GLuint active, inactive; GLint elapsed; /* Generate and start a query. */ glGenQueries(1, &active); glBeginQuery(GL_SAMPLES_PASSED, active); printf ("Testing Gen/Delete of query while another query is active.\n"); { /* While first query is active, gen a new one. */ glGenQueries(1, &inactive); if (!piglit_check_gl_error(GL_NO_ERROR)) return PIGLIT_FAIL; /* Delete the inactive query. */ glDeleteQueries(1, &inactive); if (!piglit_check_gl_error(GL_NO_ERROR)) return PIGLIT_FAIL; /* Finish and get result from active query. */ glEndQuery(GL_SAMPLES_PASSED); glGetQueryObjectiv(active, GL_QUERY_RESULT, &elapsed); } printf ("Testing Delete of currently-active query.\n"); { /* Finally, ensure that an active query can be deleted. */ glGenQueries(1, &active); glBeginQuery(GL_SAMPLES_PASSED, active); glDeleteQueries(1, &active); if (!piglit_check_gl_error(GL_NO_ERROR)) return PIGLIT_FAIL; } printf ("Testing that glEndQuery on deleted query (expecting error).\n"); { /* And ensure that we get an error if we try to end a deleted * query. */ glEndQuery(GL_SAMPLES_PASSED); if (!piglit_check_gl_error(GL_INVALID_OPERATION)) return PIGLIT_FAIL; } return PIGLIT_PASS; }
static void SCE_ROcclusionQueryCallback (int begin) { if (begin) glBeginQuery (GL_SAMPLES_PASSED, queryid); else { glEndQuery (GL_SAMPLES_PASSED); glGetQueryObjectiv (queryid, GL_QUERY_RESULT, &drawpixels); } }
std::vector<int> CDecalsDrawerGL4::UpdateOverlap_CheckQueries() { // query the results of the last issued test (if any pixels were rendered for the decal) std::vector<int> candidatesForRemoval; candidatesForRemoval.reserve(waitingOverlapGlQueries.size()); for (auto& p: waitingOverlapGlQueries) { GLint rendered = GL_FALSE; glGetQueryObjectiv(p.second, GL_QUERY_RESULT, &rendered); glDeleteQueries(1, &p.second); if (rendered == GL_FALSE) { candidatesForRemoval.push_back(p.first); } } waitingOverlapGlQueries.clear(); // no candidates left, restart with stage 0 if (candidatesForRemoval.empty()) { overlapStage = 0; return candidatesForRemoval; } //FIXME comment auto sortBeginIt = candidatesForRemoval.begin(); auto sortEndIt = candidatesForRemoval.end(); while (sortBeginIt != sortEndIt) { std::sort(sortBeginIt, sortEndIt, [&](const int& idx1, const int& idx2){ return decals[idx1].generation < decals[idx2].generation; }); sortEndIt = std::partition(sortBeginIt+1, sortEndIt, [&](const int& idx){ return !Overlap(decals[*sortBeginIt], decals[idx]); }); ++sortBeginIt; } auto eraseIt = sortEndIt; // free one decal (+ remove it from the overlap texture) int freed = 0; CVertexArray* va = GetVertexArray(); glStencilFunc(GL_ALWAYS, 0, 0xFF); glStencilOp(GL_DECR_WRAP, GL_DECR_WRAP, GL_DECR_WRAP); va->Initialize(); for (auto it = candidatesForRemoval.begin(); it != eraseIt; ++it) { const int curIndex = *it; const Decal& d = decals[curIndex]; DRAW_DECAL(va, &d); FreeDecal(curIndex); freed++; } va->DrawArray2dT(GL_QUADS); candidatesForRemoval.erase(candidatesForRemoval.begin(), eraseIt); //FIXME LOG_L(L_ERROR, "Query freed: %i of %i (decals:%i groups:%i)", freed, int(candidatesForRemoval.size()), int(decals.size() - freeIds.size()), int(groups.size())); // overlap texture changed, so need to retest the others return candidatesForRemoval; }
bool GpuQuery::IsResultAvailable() const { Context::EnsureContext(); GLint available; glGetQueryObjectiv(m_id, GL_QUERY_RESULT_AVAILABLE, &available); return available == GL_TRUE; }
bool GLTimerQuery::isReady() const { if (!mEndIssued) return false; GLint done = 0; glGetQueryObjectiv(mQueryEndObj, GL_QUERY_RESULT_AVAILABLE, &done); return done == GL_TRUE; }
PIGLIT_GL_TEST_CONFIG_END static bool run_test(bool scissor_clear) { GLuint query; GLint result = -1; piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glClearColor(0.0, 1.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); glGenQueries(1, &query); glBeginQuery(GL_SAMPLES_PASSED, query); /* Render 64 pixels. This should affect the query */ piglit_draw_rect(0, 0, 8, 8); /* Clear the framebuffer. This shouldn't affect the query */ glClearColor(0.0, 0.0, 1.0, 0.0); if (scissor_clear) { glScissor(0, 0, piglit_width / 2, piglit_height / 2); glEnable(GL_SCISSOR_TEST); } glClear(GL_COLOR_BUFFER_BIT); if (scissor_clear) { glDisable(GL_SCISSOR_TEST); } /* Render another 64 pixels. This should continue adding to * the query */ piglit_draw_rect(4, 0, 8, 8); glEndQuery(GL_SAMPLES_PASSED); glGetQueryObjectiv(query, GL_QUERY_RESULT, &result); glDeleteQueries(1, &query); piglit_present_results(); if (result != 128) { printf("Failure: \n"); printf(" Occlusion query resulted in %d samples " "(expected 128)\n", result); printf(" Scissor enabled? %s\n", scissor_clear ? "yes" : "no"); return false; } else { return true; } }
float CoronaVisibility (int nQuery) { GLuint nSamples = 0; GLint bAvailable = 0; float fIntensity; #ifdef _DEBUG GLint nError; #endif if (!(gameStates.ogl.bOcclusionQuery && nQuery) || (CoronaStyle () != 1)) return 1; if (!(gameStates.render.bQueryCoronas || gameData.render.lights.coronaSamples [nQuery - 1])) return 1; do { glGetQueryObjectiv (gameData.render.lights.coronaQueries [nQuery - 1], GL_QUERY_RESULT_AVAILABLE_ARB, &bAvailable); if (glGetError ()) { #ifdef _DEBUG glGetQueryObjectiv (gameData.render.lights.coronaQueries [nQuery - 1], GL_QUERY_RESULT_AVAILABLE_ARB, &bAvailable); if (nError = glGetError ()) #endif return 1; } } while (!bAvailable); glGetQueryObjectuiv (gameData.render.lights.coronaQueries [nQuery - 1], GL_QUERY_RESULT_ARB, &nSamples); if (glGetError ()) return 1; if (gameStates.render.bQueryCoronas == 1) { #ifdef _DEBUG if (!nSamples) { GLint nBits; glGetQueryiv (GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &nBits); } #endif return (float) (gameData.render.lights.coronaSamples [nQuery - 1] = nSamples); } fIntensity = (float) nSamples / (float) gameData.render.lights.coronaSamples [nQuery - 1]; #ifdef _DEBUG if (fIntensity > 1) fIntensity = 1; #endif return (fIntensity > 1) ? 1 : (float) sqrt (fIntensity); }
template<> Int AbstractQuery::result<Int>() { Int result; #ifndef MAGNUM_TARGET_GLES glGetQueryObjectiv(_id, GL_QUERY_RESULT, &result); #elif !defined(CORRADE_TARGET_NACL) glGetQueryObjectivEXT(_id, GL_QUERY_RESULT_EXT, &result); #else CORRADE_ASSERT_UNREACHABLE(); #endif return result; }
bool GLOcclusionQuery::isReady() const { if (!mEndIssued) return false; GLint done = 0; glGetQueryObjectiv(mQueryObj, GL_QUERY_RESULT_AVAILABLE, &done); BS_CHECK_GL_ERROR(); return done == GL_TRUE; }
enum piglit_result piglit_display(void) { #define NUM_QUERIES 5 GLuint queries[NUM_QUERIES], available; bool test_pass = true; GLint result; int i; piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); glClearColor(1.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glGenQueries(NUM_QUERIES, queries); glColor4f(0.0f, 1.0f, 0.0f, 1.0f); /* Queue up a bunch of drawing with several queries. */ for (i = 0; i < NUM_QUERIES - 1; i++) { glBeginQuery(GL_SAMPLES_PASSED, queries[i]); draw_some_things((double)i / (NUM_QUERIES - 1)); glEndQuery(GL_SAMPLES_PASSED); } /* Now fire off a query with no drawing. */ glBeginQuery(GL_SAMPLES_PASSED, queries[NUM_QUERIES - 1]); glEndQuery(GL_SAMPLES_PASSED); /* Get the result for the final query. */ glGetQueryObjectiv(queries[NUM_QUERIES - 1], GL_QUERY_RESULT, &result); /* At this point, the results of all the previous queries * should be available. */ for (i = 0; i < NUM_QUERIES - 1; i++) { glGetQueryObjectuiv(queries[i], GL_QUERY_RESULT_AVAILABLE, &available); if (available != 1) { printf("Query #%d result not available (expected in-order processing)\n", i); test_pass = false; } } glDeleteQueries(NUM_QUERIES, queries); piglit_present_results(); return test_pass ? PIGLIT_PASS : PIGLIT_FAIL; }
u32 GLGSRender::synchronize_zcull_stats(bool hard_sync) { if (!zcull_rendering_enabled || zcull_task_queue.pending == 0) return 0; u32 result = UINT16_MAX; GLint count, status; for (auto &query : zcull_task_queue.task_stack) { if (query == nullptr || query->active) continue; glGetQueryObjectiv(query->handle, GL_QUERY_RESULT_AVAILABLE, &status); if (status == GL_FALSE && !hard_sync) continue; glGetQueryObjectiv(query->handle, GL_QUERY_RESULT, &count); query->pending = false; query = nullptr; current_zcull_stats.zpass_pixel_cnt += count; zcull_task_queue.pending--; } for (u32 i = 0; i < occlusion_query_count; ++i) { auto &query = occlusion_query_data[i]; if (!query.pending && !query.active) { result = i; break; } } if (result == UINT16_MAX && !hard_sync) return synchronize_zcull_stats(true); return result; }
GLuint64 OpenGLTimer::GetElapsedTime() { GLint stopTimerAvailable = 0; while (!stopTimerAvailable) { glGetQueryObjectiv(endQuery, GL_QUERY_RESULT_AVAILABLE, &stopTimerAvailable); } glGetQueryObjectui64v(startQuery, GL_QUERY_RESULT, &startTime); glGetQueryObjectui64v(endQuery, GL_QUERY_RESULT, &endTime); elapsedTime = (endTime - startTime) / 1000000.0; return elapsedTime; }
bool render() { glm::ivec2 WindowSize(this->getWindowSize()); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * this->view() * Model; glQueryCounter(QueryName[query::BEGIN], GL_TIMESTAMP); glViewport(0, 0, WindowSize.x, WindowSize.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); glUseProgram(ProgramName); glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]); glBindVertexArray(VertexArrayName); glDrawArrays(GL_TRIANGLES, 0, VertexCount); glQueryCounter(QueryName[query::END], GL_TIMESTAMP); GLint AvailableBegin = GL_FALSE; glGetQueryObjectiv(QueryName[query::BEGIN], GL_QUERY_RESULT_AVAILABLE, &AvailableBegin); GLint AvailableEnd = GL_FALSE; glGetQueryObjectiv(QueryName[query::END], GL_QUERY_RESULT_AVAILABLE, &AvailableEnd); // The OpenGL implementations will wait for the query if it's not available GLint64 TimeBegin = 0, TimeEnd = 0; glGetQueryObjecti64v(QueryName[query::BEGIN], GL_QUERY_RESULT, &TimeBegin); glGetQueryObjecti64v(QueryName[query::END], GL_QUERY_RESULT, &TimeEnd); //glGetInteger64v(GL_TIMESTAMP, &TimeBegin); //glGetInteger64v(GL_TIMESTAMP, &TimeEnd); fprintf(stdout, "%d, %d / Time stamp: %f ms \r", AvailableBegin, AvailableEnd, (TimeEnd - TimeBegin) / 1000.f / 1000.f); return TimeEnd - TimeBegin > 0; }
void Profile::begin() { assert(!CHECKERROR); if (ready) { ready = false; } if (queries.size()) { //if the last query is done, they are all done GLint available; glGetQueryObjectiv(queryObjs[current-1], GL_QUERY_RESULT_AVAILABLE, &available); if (available) { //get the results timeStamps.resize(queryObjs.size()); for (int i = 0; i < (int)queryObjs.size(); ++i) { CHECKERROR; GLuint64 result; glGetQueryObjectui64vEXT(queryObjs[i], GL_QUERY_RESULT, &result); timeStamps[i] = result; CHECKERROR; } //append the differences to the samples list for (QueryMap::iterator it = queries.begin(); it != queries.end(); ++it) { if (it->second.timeDiff < 1) continue; GLuint64 timediff = timeStamps[it->second.timeDiff] - timeStamps[it->second.timeDiff-1]; it->second.times.push_back(timediff); if (it->second.times.size() > PROFILE_SAMPLES) it->second.times.pop_front(); it->second.timeDiff = -1; } //start the next set of samples ready = true; restartQueries(); } } else ready = true; if (ready) { glQueryCounter(getNextQuery(), GL_TIMESTAMP); } }
/** * Method is used to check occlusion query results. Wait for result and if result is 0, set entity state * to invisible. * @param engineScene is pointer to engine scene. */ void Occlusion::checkQueriesResults(SceneManager* engineScene) { vector<SceneEntity*>* entities = &engineScene->getSceneGraph()->sceneEntities; for(unsigned int i = 0; i < entities->size(); ++i) { GLint available; do { glGetQueryObjectiv(queries[i],GL_QUERY_RESULT_AVAILABLE,&available); } while(!available); } for(unsigned int i = 0; i < entities->size(); ++i) { GLint result = 0; glGetQueryObjectiv(queries[i],GL_QUERY_RESULT,&result); if(result == 0) entities->at(i)->entityState.isVisible = false; } }
template<> Int AbstractQuery::result<Int>() { CORRADE_ASSERT(!target, "AbstractQuery::result(): the query is currently running", {}); /** @todo Re-enable when extension loader is available for ES */ Int result; #ifndef MAGNUM_TARGET_GLES glGetQueryObjectiv(_id, GL_QUERY_RESULT, &result); #elif defined(CORRADE_TARGET_NACL) glGetQueryObjectivEXT(_id, GL_QUERY_RESULT_EXT, &result); #else CORRADE_INTERNAL_ASSERT(false); #endif return result; }
GFXOcclusionQuery::OcclusionQueryStatus GFXGLOcclusionQuery::getStatus(bool block, U32* data) { // If this ever shows up near the top of a profile // then your system is GPU bound. PROFILE_SCOPE(GFXGLOcclusionQuery_getStatus); GLint numPixels = 0; GLint queryDone = false; if (block) queryDone = true; else glGetQueryObjectiv(mQuery, GL_QUERY_RESULT_AVAILABLE, &queryDone); if (queryDone) glGetQueryObjectiv(mQuery, GL_QUERY_RESULT, &numPixels); else return Waiting; if (data) *data = numPixels; return numPixels > 0 ? NotOccluded : Occluded; }
bool OcclusionQuery::hasResultAvailable() const { if (m_active) return false; int available; glGetQueryObjectiv(m_queryID, GL_QUERY_RESULT_AVAILABLE, &available); #if NORI_DEBUG if (!checkGL("OpenGL error during occlusion query result availability check")) return false; #endif return available ? true : false; }
GLuint64 getResultSync() { if (thisQueryActive) return 0; GLuint64 result; GLint isReady = GL_FALSE; while (isReady == GL_FALSE) glGetQueryObjectiv(query, GL_QUERY_RESULT_AVAILABLE, &isReady); glGetQueryObjectui64v(query, GL_QUERY_RESULT, &result); return result; }