static void test_tf_bits(GLenum target) { GLint bits = -1; const char *name; if (target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN) name = "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN bits"; else name = "GL_PRIMITIVES_GENERATED bits"; /* From the GL 3.0 specification, page 329: * * "If pname is QUERY_COUNTER_BITS, the * implementation-dependent number of query counter bits * may be zero, in which case the counter contains no * useful information. * * For primitive queries (PRIMITIVES GENERATED and * TRANSFORM FEEDBACK PRIMITIVES WRITTEN) if the number * of bits is non-zero, the minimum number of bits * allowed is 32." */ glGetQueryiv(target, GL_QUERY_COUNTER_BITS, &bits); if (bits == 0 || bits >= 32) { printf("%-50s %8s %8d\n", name, "0 / 32", bits); } else { fprintf(stderr, "%-50s %8s %8d (ERROR)\n", name, "0 / 32", bits); pass = false; } }
int Lensflare::run() { SDL sdl; OpenGLWindow window("Shader Test", m_window_size, // window size m_aspect_ratio, // aspect ratio m_fullscreen, // fullscreen 4); // anti-alias TextureManager texture_manager; SurfaceManager surface_manager; if (!GLEW_ARB_occlusion_query) { throw std::runtime_error("GL_ARB_occlusion_query not supported"); } m_light = Surface::create(Pathname("light.png", Pathname::kSysPath)); m_lightquery = Surface::create(Pathname("lightquery.png", Pathname::kSysPath)); m_superlight = Surface::create(Pathname("superlight.png", Pathname::kSysPath)); m_flair1 = Surface::create(Pathname("flair1.png", Pathname::kSysPath)); m_flair2 = Surface::create(Pathname("flair2.png", Pathname::kSysPath)); m_cover = Surface::create(Pathname("cover.png", Pathname::kSysPath)); m_halo = Surface::create(Pathname("halo.png", Pathname::kSysPath)); float pos[] = { 0.1f, 0.2f, 0.4f, 0.8f, 1.6f, 3.2f }; for(size_t i = 0; i < sizeof(pos)/sizeof(float); ++i) { m_flairs.push_back(Flair(m_flair2, pos[i], 1.0f * pos[i], Color(1,1,1,1))); m_flairs.push_back(Flair(m_flair2, -pos[i] * 0.7f, 1.0f * pos[i] * 0.7f, Color(1,1,1,1))); } for(size_t i = 0; i < sizeof(pos)/sizeof(float); ++i) { m_flairs.push_back(Flair(m_flair1, pos[i]* 0.2f, 1.0f * pos[i] * 0.2f, Color(1,1,1,0.1f))); m_flairs.push_back(Flair(m_flair1, -pos[i] * 0.1f, 1.0f * pos[i] * 0.1f, Color(1,1,1,0.1f))); } GLint query_counter_bits = 0; glGetQueryiv(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &query_counter_bits); if (query_counter_bits == 0) { std::cout << "Occlusion query not supported" << std::endl; } m_loop = true; while(m_loop) { glClearColor(0,0,0,1); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); process_input(); draw(); window.swap_buffers(); } return 0; }
GLint Query::get(const GLenum target, const GLenum pname) { GLint value = 0; glGetQueryiv(target, pname, &value); return value; }
bool initQuery() { glGenQueries(1, &QueryName); int QueryBits(0); glGetQueryiv(GL_ANY_SAMPLES_PASSED_CONSERVATIVE, GL_QUERY_COUNTER_BITS, &QueryBits); return QueryBits >= 1; }
bool initQuery() { int QueryBits(0); glGetQueryiv(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, &QueryBits); bool Validated = QueryBits >= 30; if(Validated) glGenQueries(static_cast<GLsizei>(QueryName.size()), &QueryName[0]); return Validated && this->checkError("initQuery"); }
bool initQuery() { glGenQueries(1, &QueryName); int QueryBits(0); glGetQueryiv(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_QUERY_COUNTER_BITS, &QueryBits); bool Validated = QueryBits >= 1; return Validated && this->checkError("initQuery"); }
bool initQuery() { glGenQueries(1, &QueryName); int QueryBits(0); glGetQueryiv(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &QueryBits); bool Validated = QueryBits >= 32; return Validated && this->checkError("initQuery"); }
void initContext() { /* Ensure we have adequate extension support */ assert(currentContext); supportsTimestamp = currentContext->hasExtension("GL_ARB_timer_query"); supportsElapsed = currentContext->hasExtension("GL_EXT_timer_query") || supportsTimestamp; supportsOcclusion = currentContext->hasExtension("GL_ARB_occlusion_query"); supportsDebugOutput = currentContext->hasExtension("GL_ARB_debug_output"); /* Check for timer query support */ if (retrace::profilingGpuTimes) { if (!supportsTimestamp && !supportsElapsed) { std::cout << "Error: Cannot run profile, GL_EXT_timer_query extension is not supported." << std::endl; exit(-1); } GLint bits = 0; glGetQueryiv(GL_TIME_ELAPSED, GL_QUERY_COUNTER_BITS, &bits); if (!bits) { std::cout << "Error: Cannot run profile, GL_QUERY_COUNTER_BITS == 0." << std::endl; exit(-1); } } /* Check for occlusion query support */ if (retrace::profilingPixelsDrawn && !supportsOcclusion) { std::cout << "Error: Cannot run profile, GL_ARB_occlusion_query extension is not supported." << std::endl; exit(-1); } /* Setup debug message call back */ if (retrace::debug && supportsDebugOutput) { glDebugMessageCallbackARB(&debugOutputCallback, currentContext); if (DEBUG_OUTPUT_SYNCHRONOUS) { glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); } } /* Sync the gpu and cpu start times */ if (retrace::profilingCpuTimes || retrace::profilingGpuTimes) { if (!retrace::profiler.hasBaseTimes()) { GLint64 gpuTime, cpuTime; getCurrentTimes(cpuTime, gpuTime); retrace::profiler.setBaseCpuTime(cpuTime); retrace::profiler.setBaseGpuTime(gpuTime); } } }
MetricBackend_opengl::MetricBackend_opengl(glretrace::Context* context, MmapAllocator<char> &alloc) : alloc(alloc) { glprofile::Profile currentProfile = context->actualProfile(); supportsTimestamp = currentProfile.versionGreaterOrEqual(glprofile::API_GL, 3, 3) || context->hasExtension("GL_ARB_timer_query"); supportsElapsed = context->hasExtension("GL_EXT_timer_query") || supportsTimestamp; supportsOcclusion = currentProfile.versionGreaterOrEqual(glprofile::API_GL, 1, 5); #ifdef __APPLE__ // GL_TIMESTAMP doesn't work on Apple. GL_TIME_ELAPSED still does however. // http://lists.apple.com/archives/mac-opengl/2014/Nov/threads.html#00001 supportsTimestamp = false; #endif // Add metrics below metrics.emplace_back(0, 0, "CPU Start", "", CNT_NUM_INT64, CNT_TYPE_TIMESTAMP); metrics.emplace_back(0, 1, "CPU Duration", "", CNT_NUM_INT64, CNT_TYPE_DURATION); metrics.emplace_back(1, 0, "GPU Start", "", CNT_NUM_INT64, CNT_TYPE_TIMESTAMP); metrics.emplace_back(1, 1, "GPU Duration", "", CNT_NUM_INT64, CNT_TYPE_DURATION); metrics.emplace_back(1, 2, "Pixels Drawn", "", CNT_NUM_INT64, CNT_TYPE_GENERIC); metrics.emplace_back(0, 2, "VSIZE Start", "", CNT_NUM_INT64, CNT_TYPE_GENERIC); metrics.emplace_back(0, 3, "VSIZE Duration", "", CNT_NUM_INT64, CNT_TYPE_GENERIC); metrics.emplace_back(0, 4, "RSS Start", "", CNT_NUM_INT64, CNT_TYPE_GENERIC); metrics.emplace_back(0, 5, "RSS Duration", "", CNT_NUM_INT64, CNT_TYPE_GENERIC); metrics[METRIC_CPU_START].available = true; metrics[METRIC_CPU_DURATION].available = true; metrics[METRIC_CPU_VSIZE_START].available = true; metrics[METRIC_CPU_VSIZE_DURATION].available = true; metrics[METRIC_CPU_RSS_START].available = true; metrics[METRIC_CPU_RSS_DURATION].available = true; if (supportsTimestamp) metrics[METRIC_GPU_START].available = true; if (supportsElapsed) { GLint bits = 0; glGetQueryiv(GL_TIME_ELAPSED, GL_QUERY_COUNTER_BITS, &bits); if (bits) metrics[METRIC_GPU_DURATION].available = true; } if (supportsOcclusion) { metrics[METRIC_GPU_PIXELS].available = true; } // populate lookups for (auto &m : metrics) { idLookup[std::make_pair(m.groupId(), m.id())] = &m; nameLookup[m.name()] = &m; } }
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); }
void piglit_init(int argc, char **argv) { GLint query_bits; piglit_require_extension("GL_ARB_occlusion_query"); /* It is legal for a driver to support the query API but not have * any query bits. I wonder how many applications actually check for * this case... */ glGetQueryiv(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &query_bits); if (query_bits == 0) piglit_report_result(PIGLIT_SKIP); }
void fe_gl_stats_setup(void) { unsigned i; if(fe_gl_has(ARB_pipeline_statistics_query)) { glGenQueries(11, fgl_stats.names); for(i=0 ; i<11 ; ++i) glGetQueryiv(fgl_stats.targets[i], GL_QUERY_COUNTER_BITS, fgl_stats.bits + i); fe_gl_stats_start_recording = fgl_stats_start_recording; fe_gl_stats_end_recording = fgl_stats_end_recording; fe_gl_stats_get_stats = fgl_stats_get_stats; } else { memset(fgl_stats.names, 0, 11*sizeof(GLuint)); fe_gl_stats_start_recording = fgl_stats_dummy; fe_gl_stats_end_recording = fgl_stats_dummy; fe_gl_stats_get_stats = fgl_stats_get_stats_dummy; } }
bool begin() { bool Validated = true; GLint QueryCounter(0); glGetQueryiv(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &QueryCounter); if(Validated) Validated = initProgram(); if(Validated) Validated = initBuffer(); if(Validated) Validated = initVertexArray(); if(Validated) Validated = initQuery(); return Validated && this->checkError("begin"); }
static void test_oq_bits() { GLint dims[2]; GLint minbits, oqbits; /* From the GL 3.0 specification, page 329: * * "If pname is QUERY_COUNTER_BITS, the * implementation-dependent number of query counter bits * may be zero, in which case the counter contains no * useful information. * * For occlusion queries (SAMPLES PASSED), if the number * of bits is non-zero, the minimum number of bits * allowed is a function of the implementation’s maximum * viewport dimensions (MAX VIEWPORT DIMS). The counter * must be able to represent at least two overdraws for * every pixel in the viewport. The formula to compute * the allowable minimum value (where n is the minimum * number of bits) is * * n = min{32, log2(maxViewportWidth ∗ maxViewportHeight * 2}" */ glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims); minbits = log2((float)dims[0] * dims[1] * 2); if (minbits > 32) minbits = 32; glGetQueryiv(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &oqbits); if (oqbits == 0 || oqbits >= minbits) { printf("%-50s 0 / %2d %8d\n", "GL_QUERY_COUNTER_BITS(GL_SAMPLES_PASSED)", minbits, oqbits); } else { fprintf(stderr, "%-50s 0 / %2d %8d\n", "GL_QUERY_COUNTER_BITS(GL_SAMPLES_PASSED)", minbits, oqbits); pass = false; } }
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); }
void piglit_test_oq_bits() { GLint dims[2] = {9999, 9999}; GLint minbits, oqbits = 9999; /* From the GL 2.1 specification: * * "The number of query counter bits may be zero, in which * case the counter contains no useful * information. Otherwise, the minimum number of bits * allowed is a function of the implementation’s maximum * viewport dimensions (MAX_VIEWPORT_DIMS). In this case, * the counter must be able to represent at least two * overdraws for every pixel in the viewport The formula * to compute the allowable minimum value (where n is the * minimum number of bits) is: * * n = min{32, log2(maxViewportWidth ∗ maxViewportHeight * 2}" */ glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims); minbits = log2((float)dims[0] * dims[1] * 2); if (minbits > 32) minbits = 32; glGetQueryiv(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &oqbits); if (oqbits == 0 || oqbits >= minbits) { printf("%-50s 0 / %2d %8d\n", "GL_QUERY_COUNTER_BITS(GL_SAMPLES_PASSED)", minbits, oqbits); } else { fprintf(stderr, "%-50s 0 / %2d %8d\n", "GL_QUERY_COUNTER_BITS(GL_SAMPLES_PASSED)", minbits, oqbits); piglit_minmax_pass = false; } }
void initContext() { glretrace::Context *currentContext = glretrace::getCurrentContext(); /* Ensure we have adequate extension support */ assert(currentContext); supportsTimestamp = currentContext->hasExtension("GL_ARB_timer_query"); supportsElapsed = currentContext->hasExtension("GL_EXT_timer_query") || supportsTimestamp; supportsOcclusion = currentContext->hasExtension("GL_ARB_occlusion_query"); supportsDebugOutput = currentContext->hasExtension("GL_ARB_debug_output"); supportsARBShaderObjects = currentContext->hasExtension("GL_ARB_shader_objects"); /* Check for timer query support */ if (retrace::profilingGpuTimes) { if (!supportsTimestamp && !supportsElapsed) { std::cout << "Error: Cannot run profile, GL_ARB_timer_query or GL_EXT_timer_query extensions are not supported." << std::endl; exit(-1); } GLint bits = 0; glGetQueryiv(GL_TIME_ELAPSED, GL_QUERY_COUNTER_BITS, &bits); if (!bits) { std::cout << "Error: Cannot run profile, GL_QUERY_COUNTER_BITS == 0." << std::endl; exit(-1); } } /* Check for occlusion query support */ if (retrace::profilingPixelsDrawn && !supportsOcclusion) { std::cout << "Error: Cannot run profile, GL_ARB_occlusion_query extension is not supported." << std::endl; exit(-1); } /* Setup debug message call back */ if (retrace::debug && supportsDebugOutput) { glretrace::Context *currentContext = glretrace::getCurrentContext(); glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE); glDebugMessageCallbackARB(&debugOutputCallback, currentContext); if (DEBUG_OUTPUT_SYNCHRONOUS) { glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); } } /* Sync the gpu and cpu start times */ if (retrace::profilingCpuTimes || retrace::profilingGpuTimes) { if (!retrace::profiler.hasBaseTimes()) { double cpuTimeScale = 1.0E9 / getTimeFrequency(); GLint64 currentTime = getCurrentTime() * cpuTimeScale; retrace::profiler.setBaseCpuTime(currentTime); retrace::profiler.setBaseGpuTime(currentTime); } } if (retrace::profilingMemoryUsage) { GLint64 currentVsize, currentRss; getCurrentVsize(currentVsize); retrace::profiler.setBaseVsizeUsage(currentVsize); getCurrentRss(currentRss); retrace::profiler.setBaseRssUsage(currentRss); } }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15C_nglGetQueryiv__IIJ(JNIEnv *__env, jclass clazz, jint target, jint pname, jlong paramsAddress) { glGetQueryivPROC glGetQueryiv = (glGetQueryivPROC)tlsGetFunction(449); intptr_t params = (intptr_t)paramsAddress; UNUSED_PARAM(clazz) glGetQueryiv(target, pname, params); }
void InitializeGlut(int *argc, char *argv[]) { int i,j; glutInit(argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(screenwidth, screenheight); glutCreateWindow(argv[0]); glutDisplayFunc(Display); glutKeyboardFunc(Keyboard); // Support mapped pinned allocations cudaSetDeviceFlags(cudaDeviceMapHost); cudaGLSetGLDevice(0); cublasCreate_v2(&cublasHd); glewInit(); GLint max_texture_size; glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size); if(max_texture_size < screenwidth || screenwidth < screenheight) { printf("Max size of texttur(%d) is less than screensize(%d, %d)\n", max_texture_size, screenwidth, screenheight); exit(0); } //Create the textures glActiveTextureARB(GL_TEXTURE0_ARB); // 처리용 텍스쳐 2장 // Q. 왜 2장일까? glGenTextures(2, Processed_Texture); glBindTexture(GL_TEXTURE_RECTANGLE_NV, Processed_Texture[0]); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA32F_ARB, screenwidth+2, screenheight+2, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); glBindTexture(GL_TEXTURE_RECTANGLE_NV, Processed_Texture[1]); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA32F_ARB, screenwidth+2, screenheight+2, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); // Site용 텍스쳐 // Q. 처리용과 별개인 이유는? glGenTextures(1, &Site_Texture); glBindTexture(GL_TEXTURE_RECTANGLE_NV, Site_Texture); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA32F_ARB, screenwidth+2, screenheight+2, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); // Registers the texture or renderbuffer object specified by image for access by CUDA. // A handle to the registered object is returned as resource cutilSafeCall(cudaGraphicsGLRegisterImage(&grSite, Site_Texture, GL_TEXTURE_RECTANGLE_NV, cudaGraphicsMapFlagsReadOnly)); // 에너지용 텍스쳐 // 처리용과 동일한 2장 // Q. 왜?? glGenTextures(2, Energy_Texture); glBindTexture(GL_TEXTURE_RECTANGLE_NV, Energy_Texture[0]); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA32F_ARB, screenwidth+2, screenheight+2, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); glBindTexture(GL_TEXTURE_RECTANGLE_NV, Energy_Texture[1]); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA32F_ARB, screenwidth+2, screenheight+2, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); // 인덱스용 텍스쳐 // 인덱스를 컬러로 표현 glGenTextures(1, &IndexColor_Texture); glBindTexture(GL_TEXTURE_RECTANGLE_NV, IndexColor_Texture); glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_RGBA, screenwidth, screenheight, 0, GL_RGBA, GL_FLOAT, NULL); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP); // Render Buffer Object glGenFramebuffersEXT(1, &RB_object); glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, RB_object); glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGBA32F_ARB, screenwidth+2, screenheight+2); // Frame(?) Buffer Object glGenFramebuffersEXT(1, &FB_objects); // ???? // NVIDIA 확인이라는 점만 확인 // http://developer.download.nvidia.com/opengl/specs/nvOpenGLspecs.pdf glGetQueryiv(GL_SAMPLES_PASSED_ARB, GL_QUERY_COUNTER_BITS_ARB, &oq_bitsSupported); glGenQueriesARB(1, &occlusion_query); InitCg(); // 미리 컴파일된 화면 픽셀 목록 ScreenPointsList = glGenLists(1); glNewList(ScreenPointsList, GL_COMPILE); glBegin(GL_POINTS); for (i=0; i<screenwidth; i++) for (j=0; j<screenheight; j++) glVertex2f(i+1.5, j+1.5); glEnd(); glEndList(); }
/* * Called the first time a context is made current. */ void initContext() { glretrace::Context *currentContext = glretrace::getCurrentContext(); assert(currentContext); /* Ensure we have adequate extension support */ glprofile::Profile currentProfile = currentContext->actualProfile(); supportsTimestamp = currentProfile.versionGreaterOrEqual(glprofile::API_GL, 3, 3) || currentContext->hasExtension("GL_ARB_timer_query"); supportsElapsed = currentContext->hasExtension("GL_EXT_timer_query") || supportsTimestamp; supportsOcclusion = currentProfile.versionGreaterOrEqual(glprofile::API_GL, 1, 5); supportsARBShaderObjects = currentContext->hasExtension("GL_ARB_shader_objects"); currentContext->KHR_debug = currentContext->hasExtension("GL_KHR_debug"); if (currentContext->KHR_debug) { glGetIntegerv(GL_MAX_DEBUG_MESSAGE_LENGTH, ¤tContext->maxDebugMessageLength); assert(currentContext->maxDebugMessageLength > 0); } #ifdef __APPLE__ // GL_TIMESTAMP doesn't work on Apple. GL_TIME_ELAPSED still does however. // http://lists.apple.com/archives/mac-opengl/2014/Nov/threads.html#00001 supportsTimestamp = false; #endif /* Check for timer query support */ if (retrace::profilingGpuTimes) { if (!supportsTimestamp && !supportsElapsed) { std::cout << "error: cannot profile, GL_ARB_timer_query or GL_EXT_timer_query extensions are not supported." << std::endl; exit(-1); } GLint bits = 0; glGetQueryiv(GL_TIME_ELAPSED, GL_QUERY_COUNTER_BITS, &bits); if (!bits) { std::cout << "error: cannot profile, GL_QUERY_COUNTER_BITS == 0." << std::endl; exit(-1); } } /* Check for occlusion query support */ if (retrace::profilingPixelsDrawn && !supportsOcclusion) { std::cout << "error: cannot profile, GL_ARB_occlusion_query extension is not supported (" << currentProfile << ")" << std::endl; exit(-1); } /* Setup debug message call back */ if (retrace::debug) { if (currentContext->KHR_debug) { if (currentProfile.desktop()) { glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE); glDebugMessageCallback(&debugOutputCallback, currentContext); } else { glDebugMessageControlKHR(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE); glDebugMessageCallbackKHR(&debugOutputCallback, currentContext); } if (DEBUG_OUTPUT_SYNCHRONOUS) { glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); } } else if (currentContext->hasExtension("GL_ARB_debug_output")) { glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, 0, GL_TRUE); glDebugMessageCallbackARB(&debugOutputCallback, currentContext); if (DEBUG_OUTPUT_SYNCHRONOUS) { glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB); } } } /* Sync the gpu and cpu start times */ if (retrace::profilingCpuTimes || retrace::profilingGpuTimes) { if (!retrace::profiler.hasBaseTimes()) { double cpuTimeScale = 1.0E9 / getTimeFrequency(); GLint64 currentTime = getCurrentTime() * cpuTimeScale; retrace::profiler.setBaseCpuTime(currentTime); retrace::profiler.setBaseGpuTime(currentTime); } } if (retrace::profilingMemoryUsage) { GLint64 currentVsize, currentRss; getCurrentVsize(currentVsize); retrace::profiler.setBaseVsizeUsage(currentVsize); getCurrentRss(currentRss); retrace::profiler.setBaseRssUsage(currentRss); } }
bool initQuery() { glGenQueries(statistics::MAX, &QueryName[0]); std::array<GLint, statistics::MAX> QueryCounterBits; glGetQueryiv(GL_VERTICES_SUBMITTED_ARB, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::VERTICES_SUBMITTED]); glGetQueryiv(GL_PRIMITIVES_SUBMITTED_ARB, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::PRIMITIVES_SUBMITTED]); glGetQueryiv(GL_VERTEX_SHADER_INVOCATIONS_ARB, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::VERTEX_SHADER_INVOCATIONS]); glGetQueryiv(GL_TESS_CONTROL_SHADER_PATCHES_ARB, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::TESS_CONTROL_SHADER_PATCHES]); glGetQueryiv(GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::TESS_EVALUATION_SHADER_INVOCATIONS]); glGetQueryiv(GL_GEOMETRY_SHADER_INVOCATIONS, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::GEOMETRY_SHADER_INVOCATIONS]); glGetQueryiv(GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::GEOMETRY_SHADER_PRIMITIVES_EMITTED]); glGetQueryiv(GL_FRAGMENT_SHADER_INVOCATIONS_ARB, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::FRAGMENT_SHADER_INVOCATIONS]); glGetQueryiv(GL_COMPUTE_SHADER_INVOCATIONS_ARB, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::COMPUTE_SHADER_INVOCATIONS]); glGetQueryiv(GL_CLIPPING_INPUT_PRIMITIVES_ARB, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::CLIPPING_INPUT_PRIMITIVES]); glGetQueryiv(GL_CLIPPING_OUTPUT_PRIMITIVES_ARB, GL_QUERY_COUNTER_BITS, &QueryCounterBits[statistics::CLIPPING_OUTPUT_PRIMITIVES]); bool Validated = true; for(std::size_t i = 0; i < QueryCounterBits.size(); ++i) Validated = Validated && QueryCounterBits[i] >= 18; return Validated; }
PsychError SCREENGetWindowInfo(void) { const char *FieldNames[]={ "Beamposition", "LastVBLTimeOfFlip", "LastVBLTime", "VBLCount", "TimeAtSwapRequest", "TimePostSwapRequest", "RawSwapTimeOfFlip", "VBLTimePostFlip", "OSSwapTimestamp", "GPULastFrameRenderTime", "StereoMode", "ImagingMode", "MultiSampling", "MissedDeadlines", "FlipCount", "StereoDrawBuffer", "GuesstimatedMemoryUsageMB", "VBLStartline", "VBLEndline", "VideoRefreshFromBeamposition", "GLVendor", "GLRenderer", "GLVersion", "GPUCoreId", "GLSupportsFBOUpToBpc", "GLSupportsBlendingUpToBpc", "GLSupportsTexturesUpToBpc", "GLSupportsFilteringUpToBpc", "GLSupportsPrecisionColors", "GLSupportsFP32Shading", "BitsPerColorComponent", "IsFullscreen", "SpecialFlags", "SwapGroup", "SwapBarrier" }; const int fieldCount = 35; PsychGenericScriptType *s; PsychWindowRecordType *windowRecord; double beamposition, lastvbl; int infoType = 0, retIntArg; double auxArg1, auxArg2, auxArg3; CGDirectDisplayID displayId; psych_uint64 postflip_vblcount; double vbl_startline; long scw, sch; psych_bool onscreen; int queryState; unsigned int gpuTimeElapsed; //all subfunctions should have these two lines. PsychPushHelp(useString, synopsisString, seeAlsoString); if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);}; PsychErrorExit(PsychCapNumInputArgs(5)); //The maximum number of inputs PsychErrorExit(PsychRequireNumInputArgs(1)); //The required number of inputs PsychErrorExit(PsychCapNumOutputArgs(1)); //The maximum number of outputs // Query infoType flag: Defaults to zero. PsychCopyInIntegerArg(2, FALSE, &infoType); if (infoType < 0 || infoType > 6) PsychErrorExitMsg(PsychError_user, "Invalid 'infoType' argument specified! Valid are 0, 1, 2, 3, 4, 5 and 6."); // Windowserver info requested? if (infoType == 2 || infoType == 3) { // Return info about WindowServer: #if PSYCH_SYSTEM == PSYCH_OSX const char *CoreGraphicsFieldNames[]={ "CGSFps", "CGSValue1", "CGSValue2", "CGSValue3", "CGSDebugOptions" }; const int CoreGraphicsFieldCount = 5; float cgsFPS, val1, val2, val3; // This (undocumented) Apple call retrieves information about performance statistics of // the Core graphics server, also known as WindowServer or Quartz compositor: CGSGetPerformanceData(_CGSDefaultConnection(), &cgsFPS, &val1, &val2, &val3); if (CGSGetDebugOptions(&retIntArg)) { if (PsychPrefStateGet_Verbosity() > 1) printf("PTB-WARNING: GetWindowInfo: Call to CGSGetDebugOptions() failed!\n"); } PsychAllocOutStructArray(1, FALSE, 1, CoreGraphicsFieldCount, CoreGraphicsFieldNames, &s); PsychSetStructArrayDoubleElement("CGSFps", 0 , cgsFPS, s); PsychSetStructArrayDoubleElement("CGSValue1", 0, val1, s); PsychSetStructArrayDoubleElement("CGSValue2", 0, val2, s); PsychSetStructArrayDoubleElement("CGSValue3", 0, val3, s); PsychSetStructArrayDoubleElement("CGSDebugOptions", 0, (double) retIntArg, s); if ( (infoType == 3) && PsychCopyInDoubleArg(3, FALSE, &auxArg1) ) { // Type 3 setup request with auxArg1 provided. Apple auxArg1 as debugFlag setting // for the CoreGraphics server: DANGEROUS! if (CGSSetDebugOptions((unsigned int) auxArg1)) { if (PsychPrefStateGet_Verbosity() > 1) printf("PTB-WARNING: GetWindowInfo: Call to CGSSetDebugOptions() failed!\n"); } } #endif #if PSYCH_SYSTEM == PSYCH_WINDOWS psych_uint64 onsetVBLCount, frameId; double onsetVBLTime, compositionRate; psych_uint64 targetVBL; PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord); // Query all DWM presentation timing info, return full info as struct in optional return argument '1': if (PsychOSGetPresentationTimingInfo(windowRecord, TRUE, 0, &onsetVBLCount, &onsetVBLTime, &frameId, &compositionRate, 1)) { // Query success: Info struct has been created and returned by PsychOSGetPresentationTimingInfo()... auxArg1 = auxArg2 = 0; auxArg3 = 2; // Want us to change settings? if ( (infoType == 3) && PsychCopyInDoubleArg(3, FALSE, &auxArg1) && PsychCopyInDoubleArg(4, FALSE, &auxArg2) && PsychCopyInDoubleArg(5, FALSE, &auxArg3)) { if (auxArg1 < 0) auxArg1 = 0; targetVBL = auxArg1; if (PsychOSSetPresentParameters(windowRecord, targetVBL, (int) auxArg3, auxArg2)) { if (PsychPrefStateGet_Verbosity() > 5) printf("PTB-DEBUG: GetWindowInfo: Call to PsychOSSetPresentParameters(%i, %i, %f) SUCCESS!\n", (int) auxArg1, (int) auxArg3, auxArg2); } else { if (PsychPrefStateGet_Verbosity() > 1) printf("PTB-WARNING: GetWindowInfo: Call to PsychOSSetPresentParameters() failed!\n"); } } } else { // Unsupported / Failed: PsychCopyOutDoubleArg(1, FALSE, -1); } #endif #if PSYCH_SYSTEM == PSYCH_LINUX if (infoType == 2) { // MMIO register Read for screenid "auxArg1", register offset "auxArg2": PsychCopyInDoubleArg(3, TRUE, &auxArg1); PsychCopyInDoubleArg(4, TRUE, &auxArg2); PsychCopyOutDoubleArg(1, FALSE, (double) PsychOSKDReadRegister((int) auxArg1, (unsigned int) auxArg2, NULL)); } if (infoType == 3) { // MMIO register Write for screenid "auxArg1", register offset "auxArg2", to value "auxArg3": PsychCopyInDoubleArg(3, TRUE, &auxArg1); PsychCopyInDoubleArg(4, TRUE, &auxArg2); PsychCopyInDoubleArg(5, TRUE, &auxArg3); PsychOSKDWriteRegister((int) auxArg1, (unsigned int) auxArg2, (unsigned int) auxArg3, NULL); } #endif // Done. return(PsychError_none); } // Get the window record: PsychAllocInWindowRecordArg(kPsychUseDefaultArgPosition, TRUE, &windowRecord); onscreen = PsychIsOnscreenWindow(windowRecord); if (onscreen) { // Query rasterbeam position: Will return -1 if unsupported. PsychGetCGDisplayIDFromScreenNumber(&displayId, windowRecord->screenNumber); beamposition = (double) PsychGetDisplayBeamPosition(displayId, windowRecord->screenNumber); } else { beamposition = -1; } if (infoType == 1) { // Return the measured beamposition: PsychCopyOutDoubleArg(1, FALSE, beamposition); } else if (infoType == 4) { // Return async flip state: 1 = Active, 0 = Inactive. PsychCopyOutDoubleArg(1, FALSE, (((NULL != windowRecord->flipInfo) && (0 != windowRecord->flipInfo->asyncstate)) ? 1 : 0)); } else if (infoType == 5) { if (!PsychIsOnscreenWindow(windowRecord)) { PsychErrorExitMsg(PsychError_user, "Tried to create a GPU rendertime query on a texture or offscreen window. Only supported on onscreen windows!"); } // Only need OpenGL mastercontext, not full drawingtarget: PsychSetGLContext(windowRecord); // Create a GL_EXT_timer_query object for this window: if (glewIsSupported("GL_EXT_timer_query")) { // Pending queries finished? if (windowRecord->gpuRenderTimeQuery > 0) { PsychErrorExitMsg(PsychError_user, "Tried to create a new GPU rendertime query, but last query not yet finished! Call Screen('Flip') first!"); } // Generate Query object: glGenQueries(1, &windowRecord->gpuRenderTimeQuery); // Emit Query: GPU will measure elapsed processing time in Nanoseconds, starting // with the first GL command executed after this command: glBeginQuery(GL_TIME_ELAPSED_EXT, windowRecord->gpuRenderTimeQuery); // Reset last measurement: windowRecord->gpuRenderTime = 0; // Report status "in progress" = 1: PsychCopyOutDoubleArg(1, FALSE, 1); } else { if (PsychPrefStateGet_Verbosity() > 4) printf("PTB-INFO: GetWindowInfo for infoType 5: GPU timer query objects are unsupported on this platform and GPU. Call ignored!\n"); // Report status "unsupported" = 0: PsychCopyOutDoubleArg(1, FALSE, 0); } } else if (infoType == 6) { if (!PsychIsOnscreenWindow(windowRecord)) { PsychErrorExitMsg(PsychError_user, "Tried to finish a GPU rendertime query on a texture or offscreen window. Only supported on onscreen windows!"); } // End time measurement for any previously submitted rendering commands if a // GPU rendertime query was requested, otherwise just no-op: if (windowRecord->gpuRenderTimeQuery) { // Only need OpenGL mastercontext, not full drawingtarget: PsychSetGLContext(windowRecord); // Unfinished query? If so, finish it. glGetQueryiv(GL_TIME_ELAPSED_EXT, GL_CURRENT_QUERY, &queryState); if (queryState > 0) glEndQuery(GL_TIME_ELAPSED_EXT); } // Report if a query was pending: PsychCopyOutDoubleArg(1, FALSE, (windowRecord->gpuRenderTimeQuery) ? 1 : 0); } else { // Set OpenGL context (always needed) and drawing target, as setting // our windowRecord as a drawingtarget is an expected side-effect of // this function. Quite a bit of PTB M-Functions and usercode rely on // this: PsychSetDrawingTarget(windowRecord); // Return all information: PsychAllocOutStructArray(1, FALSE, 1, fieldCount, FieldNames, &s); // Rasterbeam position: PsychSetStructArrayDoubleElement("Beamposition", 0, beamposition, s); // Time of last vertical blank when a double-buffer swap occured: if ((windowRecord->flipCount > 0) && (windowRecord->time_at_last_vbl == 0) && (PsychPrefStateGet_VBLTimestampingMode() == 4)) { // If time_at_last_vbl for an already finished or at least pending flip isn't available and // we have support for OS-Builtin timestamping enabled, we try to employ OS-Builtin timestamping // to get a timestamp for the most recent pending or finished flip. If this fails or is unsupported, // it will have no effect: PsychOSGetSwapCompletionTimestamp(windowRecord, 0, &(windowRecord->time_at_last_vbl)); } // Return it - or the value zero if it is (still) undefined/unavailable: PsychSetStructArrayDoubleElement("LastVBLTimeOfFlip", 0, windowRecord->time_at_last_vbl, s); // Uncorrected timestamp of flip swap completion: PsychSetStructArrayDoubleElement("RawSwapTimeOfFlip", 0, windowRecord->rawtime_at_swapcompletion, s); // Timestamp immediately prior to call to PsychOSFlipWindowBuffers(), i.e., time at swap request submission: PsychSetStructArrayDoubleElement("TimeAtSwapRequest", 0, windowRecord->time_at_swaprequest, s); // Timestamp immediately after call to PsychOSFlipWindowBuffers() returns, i.e., time at swap request submission completion: PsychSetStructArrayDoubleElement("TimePostSwapRequest", 0, windowRecord->time_post_swaprequest, s); // Timestamp immediately after call to PsychOSFlipWindowBuffers() returns, i.e., time at swap request submission completion: PsychSetStructArrayDoubleElement("VBLTimePostFlip", 0, windowRecord->postflip_vbltimestamp, s); // Swap completion timestamp for most recently completed swap, according to OS-builtin PsychOSGetSwapCompletionTimestamp() method: PsychSetStructArrayDoubleElement("OSSwapTimestamp", 0, windowRecord->osbuiltin_swaptime, s); // Any GPU rendertime queries submitted whose results we shall collect? if (windowRecord->gpuRenderTimeQuery) { // Yes: Poll if query result is available, otherwise no-op for this invocation: gpuTimeElapsed = 0; glGetQueryObjectuiv(windowRecord->gpuRenderTimeQuery, GL_QUERY_RESULT_AVAILABLE, &gpuTimeElapsed); if (gpuTimeElapsed > 0) { // Result available: Get it! glGetQueryObjectuiv(windowRecord->gpuRenderTimeQuery, GL_QUERY_RESULT, &gpuTimeElapsed); // Destroy query object: glDeleteQueries(1, &windowRecord->gpuRenderTimeQuery); windowRecord->gpuRenderTimeQuery = 0; // Convert result in Nanoseconds back to seconds, and assign it: windowRecord->gpuRenderTime = (double) gpuTimeElapsed / (double) 1e9; } } // Result from last GPU rendertime query as triggered by infoType 5: Zero if undefined. PsychSetStructArrayDoubleElement("GPULastFrameRenderTime", 0, windowRecord->gpuRenderTime, s); // Try to determine system time of last VBL on display, independent of any // flips / bufferswaps. lastvbl = -1; postflip_vblcount = 0; // On supported systems, we can query the OS for the system time of last VBL, so we can // use the most recent VBL timestamp as baseline for timing calculations, // instead of one far in the past. if (onscreen) { lastvbl = PsychOSGetVBLTimeAndCount(windowRecord, &postflip_vblcount); } // If we couldn't determine this information we just set lastvbl to the last known // vbl timestamp of last flip -- better than nothing... if (lastvbl < 0) lastvbl = windowRecord->time_at_last_vbl; PsychSetStructArrayDoubleElement("LastVBLTime", 0, lastvbl, s); PsychSetStructArrayDoubleElement("VBLCount", 0, (double) (psych_int64) postflip_vblcount, s); // Misc. window parameters: PsychSetStructArrayDoubleElement("StereoMode", 0, windowRecord->stereomode, s); PsychSetStructArrayDoubleElement("ImagingMode", 0, windowRecord->imagingMode, s); PsychSetStructArrayDoubleElement("SpecialFlags", 0, windowRecord->specialflags, s); PsychSetStructArrayDoubleElement("IsFullscreen", 0, (windowRecord->specialflags & kPsychIsFullscreenWindow) ? 1 : 0, s); PsychSetStructArrayDoubleElement("MultiSampling", 0, windowRecord->multiSample, s); PsychSetStructArrayDoubleElement("MissedDeadlines", 0, windowRecord->nr_missed_deadlines, s); PsychSetStructArrayDoubleElement("FlipCount", 0, windowRecord->flipCount, s); PsychSetStructArrayDoubleElement("StereoDrawBuffer", 0, windowRecord->stereodrawbuffer, s); PsychSetStructArrayDoubleElement("GuesstimatedMemoryUsageMB", 0, (double) windowRecord->surfaceSizeBytes / 1024 / 1024, s); PsychSetStructArrayDoubleElement("BitsPerColorComponent", 0, (double) windowRecord->bpc, s); // Query real size of the underlying display in order to define the vbl_startline: PsychGetScreenSize(windowRecord->screenNumber, &scw, &sch); vbl_startline = (double) sch; PsychSetStructArrayDoubleElement("VBLStartline", 0, vbl_startline, s); // And VBL endline: PsychSetStructArrayDoubleElement("VBLEndline", 0, windowRecord->VBL_Endline, s); // Video refresh interval duration from beamposition method: PsychSetStructArrayDoubleElement("VideoRefreshFromBeamposition", 0, windowRecord->ifi_beamestimate, s); // Swap group assignment and swap barrier assignment, if any: PsychSetStructArrayDoubleElement("SwapGroup", 0, windowRecord->swapGroup, s); PsychSetStructArrayDoubleElement("SwapBarrier", 0, windowRecord->swapBarrier, s); // Which basic GPU architecture is this? PsychSetStructArrayStringElement("GPUCoreId", 0, windowRecord->gpuCoreId, s); // FBO's supported, and how deep? if (windowRecord->gfxcaps & kPsychGfxCapFBO) { if (windowRecord->gfxcaps & kPsychGfxCapFPFBO32) { PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 32, s); } else if (windowRecord->gfxcaps & kPsychGfxCapFPFBO16) { PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 16, s); } else PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 8, s); } else { PsychSetStructArrayDoubleElement("GLSupportsFBOUpToBpc", 0, 0, s); } // How deep is alpha blending supported? if (windowRecord->gfxcaps & kPsychGfxCapFPBlend32) { PsychSetStructArrayDoubleElement("GLSupportsBlendingUpToBpc", 0, 32, s); } else if (windowRecord->gfxcaps & kPsychGfxCapFPBlend16) { PsychSetStructArrayDoubleElement("GLSupportsBlendingUpToBpc", 0, 16, s); } else PsychSetStructArrayDoubleElement("GLSupportsBlendingUpToBpc", 0, 8, s); // How deep is texture mapping supported? if (windowRecord->gfxcaps & kPsychGfxCapFPTex32) { PsychSetStructArrayDoubleElement("GLSupportsTexturesUpToBpc", 0, 32, s); } else if (windowRecord->gfxcaps & kPsychGfxCapFPTex16) { PsychSetStructArrayDoubleElement("GLSupportsTexturesUpToBpc", 0, 16, s); } else PsychSetStructArrayDoubleElement("GLSupportsTexturesUpToBpc", 0, 8, s); // How deep is texture filtering supported? if (windowRecord->gfxcaps & kPsychGfxCapFPFilter32) { PsychSetStructArrayDoubleElement("GLSupportsFilteringUpToBpc", 0, 32, s); } else if (windowRecord->gfxcaps & kPsychGfxCapFPFilter16) { PsychSetStructArrayDoubleElement("GLSupportsFilteringUpToBpc", 0, 16, s); } else PsychSetStructArrayDoubleElement("GLSupportsFilteringUpToBpc", 0, 8, s); if (windowRecord->gfxcaps & kPsychGfxCapVCGood) { PsychSetStructArrayDoubleElement("GLSupportsPrecisionColors", 0, 1, s); } else PsychSetStructArrayDoubleElement("GLSupportsPrecisionColors", 0, 0, s); if (windowRecord->gfxcaps & kPsychGfxCapFP32Shading) { PsychSetStructArrayDoubleElement("GLSupportsFP32Shading", 0, 1, s); } else PsychSetStructArrayDoubleElement("GLSupportsFP32Shading", 0, 0, s); // Renderer information: This comes last, and would fail if async flips // are active, because it needs PsychSetDrawingTarget, which in turn needs async // flips to be inactive, unless imaging pipeline is fully enabled: PsychSetStructArrayStringElement("GLVendor", 0, (char*) glGetString(GL_VENDOR), s); PsychSetStructArrayStringElement("GLRenderer", 0, (char*) glGetString(GL_RENDERER), s); PsychSetStructArrayStringElement("GLVersion", 0, (char*) glGetString(GL_VERSION), s); } // Done. return(PsychError_none); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL15_nglGetQueryiv(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) { GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; glGetQueryivPROC glGetQueryiv = (glGetQueryivPROC)((intptr_t)function_pointer); glGetQueryiv(target, pname, params_address); }