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);
}
