void endProfile(trace::Call &call, bool isDraw) { if (retrace::profilingWithBackends) { if (profilingBoundaries[QUERY_BOUNDARY_CALL] || profilingBoundaries[QUERY_BOUNDARY_DRAWCALL]) { if (curMetricBackend) { curMetricBackend->endQuery(isDraw ? QUERY_BOUNDARY_DRAWCALL : QUERY_BOUNDARY_CALL); } } return; } /* CPU profiling for all calls */ if (retrace::profilingCpuTimes) { CallQuery& query = callQueries.back(); query.cpuEnd = getCurrentTime(); } /* GPU profiling only for draw calls */ if (isDraw) { if (retrace::profilingGpuTimes) { glEndQuery(GL_TIME_ELAPSED); } if (retrace::profilingPixelsDrawn) { glEndQuery(GL_SAMPLES_PASSED); } } if (retrace::profilingMemoryUsage) { CallQuery& query = callQueries.back(); query.vsizeEnd = os::getVsize(); query.rssEnd = os::getRss(); } }
void endProfile(trace::Call &call, bool isDraw) { /* CPU profiling for all calls */ if (retrace::profilingCpuTimes) { CallQuery& query = callQueries.back(); query.cpuEnd = getCurrentTime(); } /* GPU profiling only for draw calls */ if (isDraw) { if (retrace::profilingGpuTimes) { glEndQuery(GL_TIME_ELAPSED); } if (retrace::profilingPixelsDrawn) { glEndQuery(GL_SAMPLES_PASSED); } } if (retrace::profilingMemoryUsage) { CallQuery& query = callQueries.back(); query.vsizeEnd = os::getVsize(); query.rssEnd = os::getRss(); } }
enum piglit_result piglit_display(void) { bool pass = true; float green[4] = {0.0, 1.0, 0.0, 0.0}; float *buf; int i; GLuint q; glClearColor(0.5, 0.5, 0.5, 0.5); glClear(GL_COLOR_BUFFER_BIT); buf = malloc(sizeof(float) * 4 * piglit_width * piglit_height); glGenQueries(1, &q); /* Generate query pass: draw top half of screen. */ glColor4f(0.0, 1.0, 0.0, 0.0); glBeginQuery(GL_SAMPLES_PASSED, q); piglit_draw_rect(-1, 0, 2, 1); glEndQuery(GL_SAMPLES_PASSED); /* Conditional render that should draw bottom half of screen. */ for (i = 0; i < piglit_width * piglit_height / 2; i++) { buf[i * 4 + 0] = 0.0; buf[i * 4 + 1] = 1.0; buf[i * 4 + 2] = 0.0; buf[i * 4 + 3] = 0.0; } glBeginConditionalRenderNV(q, GL_QUERY_WAIT_NV); glRasterPos2i(-1, -1); glDrawPixels(piglit_width, piglit_height / 2, GL_RGBA, GL_FLOAT, buf); glEndConditionalRenderNV(); /* Generate query fail */ glBeginQuery(GL_SAMPLES_PASSED, q); glEndQuery(GL_SAMPLES_PASSED); /* Conditional render that should not draw full screen. */ for (i = 0; i < piglit_width * piglit_height; i++) { buf[i * 4 + 0] = 1.0; buf[i * 4 + 1] = 0.0; buf[i * 4 + 2] = 0.0; buf[i * 4 + 3] = 0.0; } glBeginConditionalRenderNV(q, GL_QUERY_WAIT_NV); glRasterPos2i(-1, -1); glDrawPixels(piglit_width, piglit_height, GL_RGBA, GL_FLOAT, buf); glEndConditionalRenderNV(); pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, green); glutSwapBuffers(); glDeleteQueries(1, &q); free(buf); 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; }
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; }
void OGLConditionalRender::End() { if (glloader_GL_VERSION_3_3() || glloader_GL_ARB_occlusion_query2()) { glEndQuery(GL_ANY_SAMPLES_PASSED); } else { glEndQuery(GL_SAMPLES_PASSED); } }
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; }
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); }
PIGLIT_GL_TEST_CONFIG_END enum piglit_result piglit_display(void) { bool pass = true; float green[4] = {0.0, 1.0, 0.0, 0.0}; GLuint q; GLuint list; list = glGenLists(1); glNewList(list, GL_COMPILE); glClearColor(0.5, 0.5, 0.5, 0.5); glClear(GL_COLOR_BUFFER_BIT); glGenQueries(1, &q); /* Generate query pass: draw bottom half of screen. */ glColor4f(0.0, 1.0, 0.0, 0.0); glBeginQuery(GL_SAMPLES_PASSED, q); piglit_draw_rect(-1, -1, 2, 1); glEndQuery(GL_SAMPLES_PASSED); /* Conditional render that should draw top half of screen. */ glBeginConditionalRenderNV(q, GL_QUERY_WAIT_NV); piglit_draw_rect(-1, 0, 2, 1); glEndConditionalRenderNV(); /* Generate query fail */ glBeginQuery(GL_SAMPLES_PASSED, q); glEndQuery(GL_SAMPLES_PASSED); /* Conditional render that should not draw full screen. */ glBeginConditionalRenderNV(q, GL_QUERY_WAIT_NV); glColor4f(1.0, 0.0, 0.0, 0.0); piglit_draw_rect(-1, -1, 2, 2); glEndConditionalRenderNV(); glEndList(); glCallList(list); pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, green); piglit_present_results(); glDeleteQueries(1, &q); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
static float draw(GLuint *q, int iters) { float start_time, end_time; glUseProgram(prog); glUniform1i(iters_loc, iters); start_time = get_time(); if (test == TIMESTAMP) { glQueryCounter(q[0], GL_TIMESTAMP); } else { glBeginQuery(GL_TIME_ELAPSED, q[0]); } piglit_draw_rect(-1, -1, 2, 2); if (test == TIMESTAMP) { glQueryCounter(q[1], GL_TIMESTAMP); } else { glEndQuery(GL_TIME_ELAPSED); } /* This glFinish() is important, since this is used in a * timing loop. */ glFinish(); end_time = get_time(); return end_time - start_time; }
void TransitionParticles::update(const ofBufferObject & blobs, const ofxTexture3d & noiseField, float now){ auto numParticles = totalVertices / every; computeShader.begin(); computeShader.setUniform1f("every", every); computeShader.setUniform1f("now", now); computeShader.setUniform1f("dt",ofGetLastFrameTime()*speed); computeShader.setUniform1f("repulsionForce", repulsion); computeShader.setUniform1f("attractionForce", attraction); computeShader.setUniform1f("elapsedTime",now); computeShader.setUniform1f("bufferSize", totalVertices); computeShader.setUniform1f("noiseSize", noiseField.texData.width); computeShader.setUniform1f("frameNum", ofGetFrameNum()); computeShader.setUniformTexture("noiseField", GL_TEXTURE_3D, noiseField.texData.textureID, 0); computeShader.dispatchCompute(numParticles / 1024 + 1, 1, 1); computeShader.end(); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, numVerticesQuery); shader.beginTransformFeedback(GL_TRIANGLES, feedbackBuffer); blobs.bindBase(GL_SHADER_STORAGE_BUFFER, 0); shader.setUniform1f("every", every); shader.setUniform1f("scale", scale); shader.setUniform4f("particleColor", color); model.drawInstanced(GL_TRIANGLES, 0, model.getNumVertices(), numParticles); shader.endTransformFeedback(feedbackBuffer); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); glGetQueryObjectuiv(numVerticesQuery, GL_QUERY_RESULT, &numPrimitives); }
void LODmodel::getLODvalue() { // ================================== // occlusion query alg glMatrixMode(GL_MODELVIEW); glPushMatrix(); glMultMatrixf( transformMatrix.m ); // draw bbox and query it... glBeginQuery(GL_SAMPLES_PASSED, queryID); lods[0]->drawForLOD(); glEndQuery(GL_SAMPLES_PASSED); glPopMatrix(); // decide which LOD depending on query result... GLuint result = 0; glGetQueryObjectuiv(queryID, GL_QUERY_RESULT, &result); *LODvalue = result; /* // =================================== // distance alg // get distance to camera // decide which LOD depending distance... */ }
void FeedbackTransformPass::DoRun() { glDisable(GL_DEPTH_TEST); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf->vbo); { Use shader(program); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, query); glBeginTransformFeedback(objtype); glEnable(GL_RASTERIZER_DISCARD); out->Draw(program); glDisable(GL_RASTERIZER_DISCARD); glEndTransformFeedback(); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); // performance loss of 15ms order TODO_W("Move this query to the *start* of the transform, use the old objects in the drawing phase."); glGetQueryObjectuiv(query, GL_QUERY_RESULT, &buf->count); } glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0); swap(*buf, *out); }
void occlusion_query::end_query() const { if (state_ == inactive) return; glCheck(glEndQuery(GL_SAMPLES_PASSED)); }
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; }
void GLGSRender::check_zcull_status(bool framebuffer_swap, bool force_read) { if (g_cfg.video.disable_zcull_queries) return; bool testing_enabled = zcull_pixel_cnt_enabled || zcull_stats_enabled; if (framebuffer_swap) { zcull_surface_active = false; const u32 zeta_address = depth_surface_info.address; if (zeta_address) { //Find zeta address in bound zculls for (int i = 0; i < rsx::limits::zculls_count; i++) { if (zculls[i].binded) { const u32 rsx_address = rsx::get_address(zculls[i].offset, CELL_GCM_LOCATION_LOCAL); if (rsx_address == zeta_address) { zcull_surface_active = true; break; } } } } } occlusion_query_info* query = nullptr; if (zcull_task_queue.task_stack.size() > 0) query = zcull_task_queue.active_query; if (query && query->active) { if (force_read || (!zcull_rendering_enabled || !testing_enabled || !zcull_surface_active)) { glEndQuery(GL_ANY_SAMPLES_PASSED); query->active = false; query->pending = true; } } else { if (zcull_rendering_enabled && testing_enabled && zcull_surface_active) { //Find query u32 free_index = synchronize_zcull_stats(); query = &occlusion_query_data[free_index]; zcull_task_queue.add(query); glBeginQuery(GL_ANY_SAMPLES_PASSED, query->handle); query->active = true; query->result = 0; query->num_draws = 0; } } }
void IrrDriver::computeSunVisibility() { // Is the lens flare enabled & visible? Check last frame's query. bool hasgodrays = false; if (World::getWorld() != NULL) { hasgodrays = World::getWorld()->getTrack()->hasGodRays(); } if (UserConfigParams::m_light_shaft && hasgodrays) { GLuint res = 0; if (m_query_issued) glGetQueryObjectuiv(m_lensflare_query, GL_QUERY_RESULT, &res); m_post_processing->setSunPixels(res); // Prepare the query for the next frame. glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); glBeginQuery(GL_SAMPLES_PASSED_ARB, m_lensflare_query); m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID); m_scene_manager->drawAll(scene::ESNRP_CAMERA); irr_driver->setPhase(GLOW_PASS); m_sun_interposer->render(); glEndQuery(GL_SAMPLES_PASSED_ARB); m_query_issued = true; m_lensflare->setStrength(res / 4000.0f); // Make sure the color mask is reset glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } }
unsigned int GPU_select_end(void) { unsigned int hits = 0; if (!g_query_state.use_gpu_select) { glPopName(); hits = glRenderMode(GL_RENDER); } else { int i; if (g_query_state.query_issued) { glEndQuery(GL_SAMPLES_PASSED); } for (i = 0; i < g_query_state.active_query; i++) { unsigned int result; glGetQueryObjectuiv(g_query_state.queries[i], GL_QUERY_RESULT, &result); if (result > 0) { if (g_query_state.mode != GPU_SELECT_NEAREST_SECOND_PASS) { int maxhits = g_query_state.bufsize / 4; if (hits < maxhits) { g_query_state.buffer[hits * 4] = 1; g_query_state.buffer[hits * 4 + 1] = 0xFFFF; g_query_state.buffer[hits * 4 + 2] = 0xFFFF; g_query_state.buffer[hits * 4 + 3] = g_query_state.id[i]; hits++; } else { hits = -1; break; } } else { int j; /* search in buffer and make selected object first */ for (j = 0; j < g_query_state.oldhits; j++) { if (g_query_state.buffer[j * 4 + 3] == g_query_state.id[i]) { g_query_state.buffer[j * 4 + 1] = 0; g_query_state.buffer[j * 4 + 2] = 0; } } break; } } } glDeleteQueries(g_query_state.num_of_queries, g_query_state.queries); MEM_freeN(g_query_state.queries); MEM_freeN(g_query_state.id); glPopAttrib(); glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); } g_query_state.select_is_active = false; return hits; }
uint64_t kit::GLTimer::end() { glEndQuery(GL_TIME_ELAPSED); uint64_t timenano = 0; glGetQueryObjectui64v(m_glHandle, GL_QUERY_RESULT, &timenano); return timenano;// / 1,000,000.0; }
void whitgl_profile_gpu_section(const char* name) { if(next_gpu_event > 0) glEndQuery(GL_TIME_ELAPSED); gpu_events[next_gpu_event].name = name; glBeginQuery(GL_TIME_ELAPSED, _front ? _front_queries[next_gpu_event] : _back_queries[next_gpu_event]); next_gpu_event++; }
enum piglit_result piglit_display(void) { bool pass = true; float green[4] = {0.0, 1.0, 0.0, 0.0}; GLuint qpass, qfail; glClearColor(1.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); glGenQueries(1, &qpass); glGenQueries(1, &qfail); /* Generate query pass: draw top half of screen. */ glColor4f(0.0, 1.0, 0.0, 0.0); glBeginQuery(GL_SAMPLES_PASSED, qpass); piglit_draw_rect(-1, 0, 2, 1); glEndQuery(GL_SAMPLES_PASSED); /* Generate query fail */ glBeginQuery(GL_SAMPLES_PASSED, qfail); glEndQuery(GL_SAMPLES_PASSED); /* Conditional render that should not copy red over the green. */ glBeginConditionalRenderNV(qfail, GL_QUERY_WAIT_NV); glRasterPos2i(-1, 0); glCopyPixels(0, 0, piglit_width, piglit_height / 2, GL_COLOR); glEndConditionalRenderNV(); /* Conditional render that should copy green over remaining red. */ glBeginConditionalRenderNV(qpass, GL_QUERY_WAIT_NV); glRasterPos2i(-1, -1); glCopyPixels(0, piglit_height / 2, piglit_width, piglit_height / 2, GL_COLOR); glEndConditionalRenderNV(); pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, green); glutSwapBuffers(); glDeleteQueries(1, &qfail); glDeleteQueries(1, &qpass); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
void PerfQuery::DisableQuery(PerfQueryGroup type) { // stop query if (type == PQG_ZCOMP_ZCOMPLOC || type == PQG_ZCOMP) { glEndQuery(GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGL ? GL_SAMPLES_PASSED : GL_ANY_SAMPLES_PASSED); } }
static void fgl_stats_end_recording(void) { unsigned i; for(i=0 ; i<11 ; ++i) glEndQuery(fgl_stats.targets[i]); for(i=0 ; i<11 ; ++i) glGetQueryObjectuiv(fgl_stats.names[i], GL_QUERY_RESULT, fgl_stats.results + i); }
void PerfQueryGL::DisableQuery(PerfQueryGroup type) { // stop query if (type == PQG_ZCOMP_ZCOMPLOC || type == PQG_ZCOMP) { glEndQuery(m_query_type); } }
void GPUClock::stop() { if(mStarted && !mStopped) { glEndQuery(GL_TIME_ELAPSED); mStarted = false; mStopped = true; } }
void hge::render::GeometryUnit::occlusionQuery(const math::Matrix4D<> &vp) { mvp = vp * modelMatrix.getConstRotateScaleTranslateMatrix(); glBeginQuery(GL_ANY_SAMPLES_PASSED, queries[HGEGEOMETRYOCCLUSIONQUERYINDEX]); occlusionQueryShader->setModelViewProjectionMatrix(mvp); occlusionQueryMesh->bindTotal(); occlusionQueryMesh->draw(); glEndQuery(GL_ANY_SAMPLES_PASSED); }
void end() { if (!thisQueryActive) return; glEndQuery(GL_TIME_ELAPSED); queryActive = false; thisQueryActive = false; }
static void SCE_ROcclusionQueryCallback (int begin) { if (begin) glBeginQuery (GL_SAMPLES_PASSED, queryid); else { glEndQuery (GL_SAMPLES_PASSED); glGetQueryObjectiv (queryid, GL_QUERY_RESULT, &drawpixels); } }
enum piglit_result piglit_display(void) { bool pass = true; GLfloat *v; int i; GLuint q, num_prims; glClear(GL_COLOR_BUFFER_BIT); glGenQueries(1, &q); glBeginQuery(GL_PRIMITIVES_GENERATED_EXT, q); glBeginTransformFeedback(GL_POINTS); glBindBuffer(GL_ARRAY_BUFFER, vert_buf); glVertexPointer(3, GL_FLOAT, 0, 0); glEnable(GL_VERTEX_ARRAY); glDrawArrays(GL_POINTS, 0, 3); glEndTransformFeedback(); glEndQuery(GL_PRIMITIVES_GENERATED); glGetQueryObjectuiv(q, GL_QUERY_RESULT, &num_prims); glDeleteQueries(1, &q); printf("%u primitives generated:\n", num_prims); if (num_prims != NUM_VERTS) { printf("Incorrect number of prims generated.\n"); printf("Found %u, expected %u\n", num_prims, NUM_VERTS); pass = false; } glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, xfb_buf); v = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT, GL_READ_ONLY); for (i = 0; i < num_prims; i++) { printf("vertex %2d: pos %5.2g, %5.2g, %5.2g, %5.2g " "color %5.2g, %5.2g, %5.2g, %5.2g\n", i, v[i*8+0], v[i*8+1], v[i*8+2], v[i*8+3], v[i*8+4], v[i*8+5], v[i*8+6], v[i*8+7]); /* spot-check results */ if (!equal(v[i*8+1], 0.1)) { printf("Incorrect Y coord for point %d: %f\n", i, v[i*8+1]); pass = false; } if (!equal(v[i*8+4], 0.9)) { printf("Incorrect red value for point %d: %f\n", i, v[i*8+4]); pass = false; } } glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT); piglit_present_results(); return pass ? PIGLIT_PASS : PIGLIT_FAIL; }
bool render() { glm::ivec2 WindowSize(this->getWindowSize()); { glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glm::mat4* Pointer = reinterpret_cast<glm::mat4*>(glMapBufferRange(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT)); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, static_cast<float>(WindowSize.x) / static_cast<float>(WindowSize.y), 0.1f, 100.0f); glm::mat4 Model = glm::mat4(1.0f); *Pointer = Projection * this->view() * Model; glUnmapBuffer(GL_UNIFORM_BUFFER); } // Set the display viewport glViewport(0, 0, WindowSize.x, WindowSize.y); glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]); // Clear color buffer with black glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); // Bind program glUseProgram(ProgramName); glBindVertexArray(VertexArrayName); glBindBufferRange(GL_UNIFORM_BUFFER, semantic::uniform::MATERIAL, BufferName[buffer::MATERIAL], 0, sizeof(glm::vec4)); // The first orange quad is not written in the framebuffer. glColorMaski(0, GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); // Beginning of the samples count query glBeginQuery(GL_SAMPLES_PASSED, QueryName); // To test the condional rendering, comment this line, the next draw call won't happen. glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); // End of the samples count query glEndQuery(GL_SAMPLES_PASSED); // The second blue quad is written in the framebuffer only if a sample pass the occlusion query. glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glBindBufferRange(GL_UNIFORM_BUFFER, semantic::uniform::MATERIAL, BufferName[buffer::MATERIAL], this->UniformMaterialOffset, sizeof(glm::vec4)); // Draw only if one sample went through the tests, // we don't need to get the query result which prevent the rendering pipeline to stall. glBeginConditionalRender(QueryName, GL_QUERY_WAIT); // Clear color buffer with white glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); glEndConditionalRender(); return true; }