static void Init( void )
{
const char *ext = (const char *) glGetString(GL_EXTENSIONS);
GLint bits;
int i;
if (!strstr(ext, "GL_ARB_occlusion_query")) {
printf("Sorry, this demo requires the GL_ARB_occlusion_query extension\n");
exit(-1);
}
glGetQueryivARB(GL_SAMPLES_PASSED_ARB, GL_QUERY_COUNTER_BITS_ARB, &bits);
if (!bits) {
printf("Hmmm, GL_QUERY_COUNTER_BITS_ARB is zero!\n");
exit(-1);
}
glGetIntegerv(GL_DEPTH_BITS, &bits);
printf("Depthbits: %d\n", bits);
glGenQueriesARB(NUM_OCC, OccQuery);
glEnable(GL_DEPTH_TEST);
for (i = 0; i < NUM_OCC; i++) {
float t = (float) i / (NUM_OCC - 1);
Xpos[i] = 2.5 * t;
Ypos[i] = 4.0 * (t - 0.5);
Sign[i] = 1.0;
}
}
/*
* void GetQueryivARB(enum target, enum pname, int *params);
*
* If <pname> is QUERY_COUNTER_BITS_ARB, the number of bits in the counter
* for <target> will be placed in <params>. The minimum number of query
* counter bits allowed is a function of the implementation's maximum
* viewport dimensions (MAX_VIEWPORT_DIMS). If the counter is non-zero,
* then the counter must be able to represent at least two overdraws for
* every pixel in the viewport using only one sample buffer. The formula to
* compute the allowable minimum value is below (where n is the minimum
* number of bits):
* n = (min (32, ceil (log2 (maxViewportWidth x maxViewportHeight x 2) ) ) ) or 0
*/
static bool
conformOQ_GetQueryCounterBits(void)
{
int bit_num, dims[2];
float min_impl, min_bit_num;
/* get the minimum bit number supported by the implementation,
* and check the legality of result of GL_QUERY_COUNTER_BITS_ARB
*/
glGetQueryivARB(GL_SAMPLES_PASSED_ARB, GL_QUERY_COUNTER_BITS_ARB,
&bit_num);
glGetIntegerv(GL_MAX_VIEWPORT_DIMS, dims);
if (!piglit_check_gl_error(GL_NO_ERROR))
return false;
min_impl =
ceil(logf((float) dims[0] * (float) dims[1] * 1.0 * 2.0) /
logf(2.0));
min_bit_num = 32.0 > min_impl ? min_impl : 32.0;
if ((float) bit_num < min_bit_num)
return false;
return true;
}
static void Init( void )
{
const char *ext = (const char *) glGetString(GL_EXTENSIONS);
GLint bits;
if (!strstr(ext, "GL_ARB_occlusion_query")) {
printf("Sorry, this demo requires the GL_ARB_occlusion_query extension\n");
exit(-1);
}
#if defined(GL_ARB_occlusion_query)
glGetQueryivARB(GL_SAMPLES_PASSED_ARB, GL_QUERY_COUNTER_BITS_ARB, &bits);
if (!bits) {
printf("Hmmm, GL_QUERY_COUNTER_BITS_ARB is zero!\n");
exit(-1);
}
#endif /* GL_ARB_occlusion_query */
glGetIntegerv(GL_DEPTH_BITS, &bits);
printf("Depthbits: %d\n", bits);
#if defined(GL_ARB_occlusion_query)
glGenQueriesARB(1, &OccQuery);
assert(OccQuery > 0);
#endif /* GL_ARB_occlusion_query */
glEnable(GL_DEPTH_TEST);
}
static void GLimp_InitExtensionsR2(void)
{
Com_Printf("Initializing OpenGL extensions\n");
// GL_ARB_depth_texture
GLimp_CheckForVersionExtension("GL_ARB_depth_texture", 130, qtrue, NULL);
if (GLimp_CheckForVersionExtension("GL_ARB_texture_cube_map", 130, qtrue, NULL))
{
glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig2.maxCubeMapTextureSize);
}
GL_CheckErrors();
GLimp_CheckForVersionExtension("GL_ARB_vertex_program", 210, qtrue, NULL);
GLimp_CheckForVersionExtension("GL_ARB_vertex_buffer_object", 300, qtrue, NULL);
// GL_ARB_occlusion_query
glConfig2.occlusionQueryAvailable = qfalse;
glConfig2.occlusionQueryBits = 0;
if (GLimp_CheckForVersionExtension("GL_ARB_occlusion_query", 150, qfalse, r_ext_occlusion_query))
{
glConfig2.occlusionQueryAvailable = qtrue;
glGetQueryivARB(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &glConfig2.occlusionQueryBits);
}
GL_CheckErrors();
GLimp_CheckForVersionExtension("GL_ARB_shader_objects", 210, qtrue, NULL);
if (GLimp_CheckForVersionExtension("GL_ARB_vertex_shader", 210, qtrue, NULL))
{
int reservedComponents;
GL_CheckErrors();
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &glConfig2.maxVertexUniforms); GL_CheckErrors();
//glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &glConfig.maxVaryingFloats); GL_CheckErrors();
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &glConfig2.maxVertexAttribs); GL_CheckErrors();
reservedComponents = 16 * 10; // approximation how many uniforms we have besides the bone matrices
glConfig2.maxVertexSkinningBones = (int) Q_bound(0.0, (Q_max(glConfig2.maxVertexUniforms - reservedComponents, 0) / 16), MAX_BONES);
glConfig2.vboVertexSkinningAvailable = (qboolean)(r_vboVertexSkinning->integer && ((glConfig2.maxVertexSkinningBones >= 12) ? qtrue : qfalse));
}
GL_CheckErrors();
GLimp_CheckForVersionExtension("GL_ARB_fragment_shader", 210, qtrue, NULL);
// GL_ARB_shading_language_100
if (GLimp_CheckForVersionExtension("GL_ARB_shading_language_100", 210, qtrue, NULL))
{
Q_strncpyz(glConfig2.shadingLanguageVersion, (char *)glGetString(GL_SHADING_LANGUAGE_VERSION_ARB), sizeof(glConfig2.shadingLanguageVersion));
sscanf(glConfig2.shadingLanguageVersion, "%d.%d", &glConfig2.glslMajorVersion, &glConfig2.glslMinorVersion);
}
GL_CheckErrors();
glConfig2.textureNPOTAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_ARB_texture_non_power_of_two", 300, qfalse, r_ext_texture_non_power_of_two))
{
glConfig2.textureNPOTAvailable = qtrue;
}
glConfig2.drawBuffersAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_ARB_draw_buffers", /* -1 */ 300, qfalse, r_ext_draw_buffers))
{
glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &glConfig2.maxDrawBuffers);
glConfig2.drawBuffersAvailable = qtrue;
}
glConfig2.textureHalfFloatAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_ARB_half_float_pixel", 300, qfalse, r_ext_half_float_pixel))
{
glConfig2.textureHalfFloatAvailable = qtrue;
}
glConfig2.textureFloatAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_ARB_texture_float", 300, qfalse, r_ext_texture_float))
{
glConfig2.textureFloatAvailable = qtrue;
}
glConfig2.ARBTextureCompressionAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_ARB_texture_compression", 300, qfalse, r_ext_compressed_textures))
{
glConfig2.ARBTextureCompressionAvailable = qtrue;
glConfig.textureCompression = TC_NONE;
}
glConfig2.vertexArrayObjectAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_ARB_vertex_array_object", 300, qfalse, r_ext_vertex_array_object))
{
glConfig2.vertexArrayObjectAvailable = qtrue;
}
// GL_EXT_texture_compression_s3tc
if (GLimp_CheckForVersionExtension("GL_EXT_texture_compression_s3tc", -1, qfalse, r_ext_compressed_textures))
{
glConfig.textureCompression = TC_S3TC_ARB;
}
glConfig2.texture3DAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_EXT_texture3D", 170, qfalse, NULL))
{
glConfig2.texture3DAvailable = qtrue;
}
glConfig2.stencilWrapAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_EXT_stencil_wrap", 210, qfalse, r_ext_stencil_wrap))
{
glConfig2.stencilWrapAvailable = qtrue;
}
glConfig2.textureAnisotropyAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_EXT_texture_filter_anisotropic", -1, qfalse, r_ext_texture_filter_anisotropic))
{
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig2.maxTextureAnisotropy);
glConfig2.textureAnisotropyAvailable = qtrue;
}
GL_CheckErrors();
GLimp_CheckForVersionExtension("GL_EXT_stencil_two_side", 210, qfalse, r_ext_stencil_two_side);
GLimp_CheckForVersionExtension("GL_EXT_depth_bounds_test", 170, qfalse, r_ext_depth_bounds_test);
glConfig2.framebufferObjectAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_EXT_framebuffer_object", 300, qfalse, r_ext_packed_depth_stencil))
{
glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE_EXT, &glConfig2.maxRenderbufferSize);
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &glConfig2.maxColorAttachments);
glConfig2.framebufferObjectAvailable = qtrue;
}
GL_CheckErrors();
glConfig2.framebufferPackedDepthStencilAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_EXT_packed_depth_stencil", 300, qfalse, r_ext_packed_depth_stencil))
{
glConfig2.framebufferPackedDepthStencilAvailable = qtrue;
}
glConfig2.framebufferBlitAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_EXT_framebuffer_blit", 300, qfalse, r_ext_framebuffer_blit))
{
glConfig2.framebufferBlitAvailable = qtrue;
}
// GL_EXTX_framebuffer_mixed_formats not used
glConfig2.generateMipmapAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_SGIS_generate_mipmap", 140, qfalse, r_ext_generate_mipmap))
{
glConfig2.generateMipmapAvailable = qtrue;
}
glConfig2.getProgramBinaryAvailable = qfalse;
if (GLimp_CheckForVersionExtension("GL_ARB_get_program_binary", 410, qfalse, NULL))
{
int formats = 0;
glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &formats);
if (formats)
{
glConfig2.getProgramBinaryAvailable = qtrue;
}
}
// If we are in developer mode, then we will print out messages from the gfx driver
if (GLimp_CheckForVersionExtension("GL_ARB_debug_output", 410, qfalse, NULL) && ri.Cvar_VariableIntegerValue("developer"))
{
#ifdef GL_DEBUG_OUTPUT
glEnable(GL_DEBUG_OUTPUT);
if (410 <= glConfig2.contextCombined)
{
glDebugMessageCallback(Glimp_DebugCallback, NULL);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
}
else
{
glDebugMessageCallbackARB(Glimp_DebugCallback, NULL);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
}
#endif
}
}
/*
===============
GLimp_InitExtensions
===============
*/
static void GLimp_InitExtensions(void)
{
ri.Printf(PRINT_ALL, "Initializing OpenGL extensions\n");
// GL_ARB_multitexture
if(glConfig.driverType != GLDRV_OPENGL3)
{
if(GLEW_ARB_multitexture)
{
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &glConfig.maxActiveTextures);
if(glConfig.maxActiveTextures > 1)
{
ri.Printf(PRINT_ALL, "...using GL_ARB_multitexture\n");
}
else
{
ri.Error(ERR_FATAL, "...not using GL_ARB_multitexture, < 2 texture units\n");
}
}
else
{
ri.Error(ERR_FATAL, "...GL_ARB_multitexture not found\n");
}
}
// GL_ARB_depth_texture
if(GLEW_ARB_depth_texture)
{
ri.Printf(PRINT_ALL, "...using GL_ARB_depth_texture\n");
}
else
{
ri.Error(ERR_FATAL, "...GL_ARB_depth_texture not found\n");
}
// GL_ARB_texture_cube_map
if(GLEW_ARB_texture_cube_map)
{
glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig2.maxCubeMapTextureSize);
ri.Printf(PRINT_ALL, "...using GL_ARB_texture_cube_map\n");
}
else
{
ri.Error(ERR_FATAL, "...GL_ARB_texture_cube_map not found\n");
}
GL_CheckErrors();
// GL_ARB_vertex_program
if(GLEW_ARB_vertex_program)
{
ri.Printf(PRINT_ALL, "...using GL_ARB_vertex_program\n");
}
else
{
ri.Error(ERR_FATAL, "...GL_ARB_vertex_program not found\n");
}
// GL_ARB_vertex_buffer_object
if(GLEW_ARB_vertex_buffer_object)
{
ri.Printf(PRINT_ALL, "...using GL_ARB_vertex_buffer_object\n");
}
else
{
ri.Error(ERR_FATAL, "...GL_ARB_vertex_buffer_object not found\n");
}
// GL_ARB_occlusion_query
glConfig2.occlusionQueryAvailable = qfalse;
glConfig2.occlusionQueryBits = 0;
if(GLEW_ARB_occlusion_query)
{
if(r_ext_occlusion_query->value)
{
glConfig2.occlusionQueryAvailable = qtrue;
glGetQueryivARB(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &glConfig2.occlusionQueryBits);
ri.Printf(PRINT_ALL, "...using GL_ARB_occlusion_query\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_ARB_occlusion_query\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_ARB_occlusion_query not found\n");
}
GL_CheckErrors();
// GL_ARB_shader_objects
if(GLEW_ARB_shader_objects)
{
ri.Printf(PRINT_ALL, "...using GL_ARB_shader_objects\n");
}
else
{
ri.Error(ERR_FATAL, "...GL_ARB_shader_objects not found\n");
}
// GL_ARB_vertex_shader
if(GLEW_ARB_vertex_shader)
{
int reservedComponents;
GL_CheckErrors();
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &glConfig2.maxVertexUniforms); GL_CheckErrors();
//glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &glConfig.maxVaryingFloats); GL_CheckErrors();
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &glConfig2.maxVertexAttribs); GL_CheckErrors();
reservedComponents = 16 * 10; // approximation how many uniforms we have besides the bone matrices
/*
if(glConfig.driverType == GLDRV_MESA)
{
// HACK
// restrict to number of vertex uniforms to 512 because of:
// xreal.x86_64: nv50_program.c:4181: nv50_program_validate_data: Assertion `p->param_nr <= 512' failed
glConfig2.maxVertexUniforms = Q_bound(0, glConfig2.maxVertexUniforms, 512);
}
*/
glConfig2.maxVertexSkinningBones = (int) Q_bound(0.0, (Q_max(glConfig2.maxVertexUniforms - reservedComponents, 0) / 16), MAX_BONES);
glConfig2.vboVertexSkinningAvailable = r_vboVertexSkinning->integer && ((glConfig2.maxVertexSkinningBones >= 12) ? qtrue : qfalse);
ri.Printf(PRINT_ALL, "...using GL_ARB_vertex_shader\n");
}
else
{
ri.Error(ERR_FATAL, "...GL_ARB_vertex_shader not found\n");
}
GL_CheckErrors();
// GL_ARB_fragment_shader
if(GLEW_ARB_fragment_shader)
{
ri.Printf(PRINT_ALL, "...using GL_ARB_fragment_shader\n");
}
else
{
ri.Error(ERR_FATAL, "...GL_ARB_fragment_shader not found\n");
}
// GL_ARB_shading_language_100
if(GLEW_ARB_shading_language_100)
{
Q_strncpyz(glConfig2.shadingLanguageVersion, (char*)glGetString(GL_SHADING_LANGUAGE_VERSION_ARB),
sizeof(glConfig2.shadingLanguageVersion));
ri.Printf(PRINT_ALL, "...using GL_ARB_shading_language_100\n");
}
else
{
ri.Printf(ERR_FATAL, "...GL_ARB_shading_language_100 not found\n");
}
GL_CheckErrors();
// GL_ARB_texture_non_power_of_two
glConfig2.textureNPOTAvailable = qfalse;
if(GLEW_ARB_texture_non_power_of_two)
{
if(r_ext_texture_non_power_of_two->integer)
{
glConfig2.textureNPOTAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_ARB_texture_non_power_of_two\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_ARB_texture_non_power_of_two\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_ARB_texture_non_power_of_two not found\n");
}
// GL_ARB_draw_buffers
glConfig2.drawBuffersAvailable = qfalse;
if(GLEW_ARB_draw_buffers)
{
glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &glConfig2.maxDrawBuffers);
if(r_ext_draw_buffers->integer)
{
glConfig2.drawBuffersAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_ARB_draw_buffers\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_ARB_draw_buffers\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_ARB_draw_buffers not found\n");
}
// GL_ARB_half_float_pixel
glConfig2.textureHalfFloatAvailable = qfalse;
if(GLEW_ARB_half_float_pixel)
{
if(r_ext_half_float_pixel->integer)
{
glConfig2.textureHalfFloatAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_ARB_half_float_pixel\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_ARB_half_float_pixel\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_ARB_half_float_pixel not found\n");
}
// GL_ARB_texture_float
glConfig2.textureFloatAvailable = qfalse;
if(GLEW_ARB_texture_float)
{
if(r_ext_texture_float->integer)
{
glConfig2.textureFloatAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_ARB_texture_float\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_ARB_texture_float\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_ARB_texture_float not found\n");
}
// GL_ARB_texture_compression
glConfig.textureCompression = TC_NONE;
if(GLEW_ARB_texture_compression)
{
if(r_ext_compressed_textures->integer)
{
glConfig2.ARBTextureCompressionAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_ARB_texture_compression\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_ARB_texture_compression\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_ARB_texture_compression not found\n");
}
// GL_ARB_vertex_array_object
glConfig2.vertexArrayObjectAvailable = qfalse;
if(GLEW_ARB_vertex_array_object)
{
if(r_ext_vertex_array_object->integer)
{
glConfig2.vertexArrayObjectAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_ARB_vertex_array_object\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_ARB_vertex_array_object\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_ARB_vertex_array_object not found\n");
}
// GL_EXT_texture_compression_s3tc
if(GLEW_EXT_texture_compression_s3tc)
{
if(r_ext_compressed_textures->integer)
{
glConfig.textureCompression = TC_S3TC;
ri.Printf(PRINT_ALL, "...using GL_EXT_texture_compression_s3tc\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_texture_compression_s3tc\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_texture_compression_s3tc not found\n");
}
// GL_EXT_texture3D
glConfig2.texture3DAvailable = qfalse;
if(GLEW_EXT_texture3D)
{
//if(r_ext_texture3d->value)
{
glConfig2.texture3DAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_EXT_texture3D\n");
}
/*
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_texture3D\n");
}
*/
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_texture3D not found\n");
}
// GL_EXT_stencil_wrap
glConfig2.stencilWrapAvailable = qfalse;
if(GLEW_EXT_stencil_wrap)
{
if(r_ext_stencil_wrap->value)
{
glConfig2.stencilWrapAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_EXT_stencil_wrap\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_stencil_wrap\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_stencil_wrap not found\n");
}
// GL_EXT_texture_filter_anisotropic
glConfig2.textureAnisotropyAvailable = qfalse;
if(GLEW_EXT_texture_filter_anisotropic)
{
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig2.maxTextureAnisotropy);
if(r_ext_texture_filter_anisotropic->value)
{
glConfig2.textureAnisotropyAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_EXT_texture_filter_anisotropic\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_texture_filter_anisotropic\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_texture_filter_anisotropic not found\n");
}
GL_CheckErrors();
// GL_EXT_stencil_two_side
if(GLEW_EXT_stencil_two_side)
{
if(r_ext_stencil_two_side->value)
{
ri.Printf(PRINT_ALL, "...using GL_EXT_stencil_two_side\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_stencil_two_side\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_stencil_two_side not found\n");
}
// GL_EXT_depth_bounds_test
if(GLEW_EXT_depth_bounds_test)
{
if(r_ext_depth_bounds_test->value)
{
ri.Printf(PRINT_ALL, "...using GL_EXT_depth_bounds_test\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_depth_bounds_test\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_depth_bounds_test not found\n");
}
// GL_EXT_framebuffer_object
glConfig2.framebufferObjectAvailable = qfalse;
if(GLEW_EXT_framebuffer_object)
{
glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE_EXT, &glConfig2.maxRenderbufferSize);
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &glConfig2.maxColorAttachments);
if(r_ext_framebuffer_object->value)
{
glConfig2.framebufferObjectAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_EXT_framebuffer_object\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_framebuffer_object\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_framebuffer_object not found\n");
}
GL_CheckErrors();
// GL_EXT_packed_depth_stencil
glConfig2.framebufferPackedDepthStencilAvailable = qfalse;
if(GLEW_EXT_packed_depth_stencil && glConfig.driverType != GLDRV_MESA)
{
if(r_ext_packed_depth_stencil->integer)
{
glConfig2.framebufferPackedDepthStencilAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_EXT_packed_depth_stencil\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_packed_depth_stencil\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_packed_depth_stencil not found\n");
}
// GL_EXT_framebuffer_blit
glConfig2.framebufferBlitAvailable = qfalse;
if(GLEW_EXT_framebuffer_blit)
{
if(r_ext_framebuffer_blit->integer)
{
glConfig2.framebufferBlitAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_EXT_framebuffer_blit\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_framebuffer_blit\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_framebuffer_blit not found\n");
}
// GL_EXTX_framebuffer_mixed_formats
/*
glConfig.framebufferMixedFormatsAvailable = qfalse;
if(GLEW_EXTX_framebuffer_mixed_formats)
{
if(r_extx_framebuffer_mixed_formats->integer)
{
glConfig.framebufferMixedFormatsAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_EXTX_framebuffer_mixed_formats\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXTX_framebuffer_mixed_formats\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXTX_framebuffer_mixed_formats not found\n");
}
*/
// GL_ATI_separate_stencil
if(GLEW_ATI_separate_stencil)
{
if(r_ext_separate_stencil->value)
{
ri.Printf(PRINT_ALL, "...using GL_ATI_separate_stencil\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_ATI_separate_stencil\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_ATI_separate_stencil not found\n");
}
// GL_SGIS_generate_mipmap
glConfig2.generateMipmapAvailable = qfalse;
if(GLEW_SGIS_generate_mipmap)
{
if(r_ext_generate_mipmap->value)
{
glConfig2.generateMipmapAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_SGIS_generate_mipmap\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_SGIS_generate_mipmap\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_SGIS_generate_mipmap not found\n");
}
// GL_GREMEDY_string_marker
if(GLEW_GREMEDY_string_marker)
{
ri.Printf(PRINT_ALL, "...using GL_GREMEDY_string_marker\n");
}
else
{
ri.Printf(PRINT_ALL, "...GL_GREMEDY_string_marker not found\n");
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryivARB(JNIEnv *env, jclass clazz, jint target, jint pname, jlong params, jlong function_pointer) {
GLint *params_address = (GLint *)(intptr_t)params;
glGetQueryivARBPROC glGetQueryivARB = (glGetQueryivARBPROC)((intptr_t)function_pointer);
glGetQueryivARB(target, pname, params_address);
}
static void GLimp_InitExtensions()
{
ri.Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
if ( LOAD_EXTENSION_WITH_CVAR(ARB_debug_output, r_glDebugProfile) )
{
glDebugMessageCallbackARB( (GLDEBUGPROCARB)GLimp_DebugCallback, nullptr );
glEnable( GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB );
}
// Shaders
REQUIRE_EXTENSION( ARB_fragment_shader );
REQUIRE_EXTENSION( ARB_vertex_shader );
glGetIntegerv( GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &glConfig2.maxVertexUniforms );
glGetIntegerv( GL_MAX_VERTEX_ATTRIBS_ARB, &glConfig2.maxVertexAttribs );
int reservedComponents = 36 * 10; // approximation how many uniforms we have besides the bone matrices
glConfig2.maxVertexSkinningBones = Math::Clamp( ( glConfig2.maxVertexUniforms - reservedComponents ) / 16, 0, MAX_BONES );
glConfig2.vboVertexSkinningAvailable = r_vboVertexSkinning->integer && ( ( glConfig2.maxVertexSkinningBones >= 12 ) ? true : false );
// GLSL
REQUIRE_EXTENSION( ARB_shading_language_100 );
Q_strncpyz( glConfig2.shadingLanguageVersionString, ( char * ) glGetString( GL_SHADING_LANGUAGE_VERSION_ARB ),
sizeof( glConfig2.shadingLanguageVersionString ) );
int majorVersion, minorVersion;
if ( sscanf( glConfig2.shadingLanguageVersionString, "%i.%i", &majorVersion, &minorVersion ) != 2 )
{
ri.Printf( PRINT_ALL, "WARNING: unrecognized shading language version string format\n" );
}
glConfig2.shadingLanguageVersion = majorVersion * 100 + minorVersion;
ri.Printf( PRINT_ALL, "...found shading language version %i\n", glConfig2.shadingLanguageVersion );
// Texture formats and compression
REQUIRE_EXTENSION( ARB_depth_texture );
REQUIRE_EXTENSION( ARB_texture_cube_map );
glGetIntegerv( GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &glConfig2.maxCubeMapTextureSize );
glConfig2.textureHalfFloatAvailable = LOAD_EXTENSION_WITH_CVAR(ARB_half_float_pixel, r_ext_half_float_pixel);
glConfig2.textureFloatAvailable = LOAD_EXTENSION_WITH_CVAR(ARB_texture_float, r_ext_texture_float);
glConfig2.textureRGAvailable = LOAD_EXTENSION_WITH_CVAR(ARB_texture_rg, r_ext_texture_rg);
// TODO figure out what was the problem with MESA
glConfig2.framebufferPackedDepthStencilAvailable = glConfig.driverType != GLDRV_MESA && LOAD_EXTENSION_WITH_CVAR(EXT_packed_depth_stencil, r_ext_packed_depth_stencil);
glConfig2.ARBTextureCompressionAvailable = LOAD_EXTENSION_WITH_CVAR(ARB_texture_compression, r_ext_compressed_textures);
glConfig.textureCompression = TC_NONE;
if( LOAD_EXTENSION_WITH_CVAR(EXT_texture_compression_s3tc, r_ext_compressed_textures) )
{
glConfig.textureCompression = TC_S3TC;
}
//REQUIRE_EXTENSION(EXT_texture3D);
// Texture - others
glConfig2.textureNPOTAvailable = LOAD_EXTENSION_WITH_CVAR(ARB_texture_non_power_of_two, r_ext_texture_non_power_of_two);
glConfig2.generateMipmapAvailable = LOAD_EXTENSION_WITH_CVAR(SGIS_generate_mipmap, r_ext_generate_mipmap);
glConfig2.textureAnisotropyAvailable = false;
if ( LOAD_EXTENSION_WITH_CVAR(EXT_texture_filter_anisotropic, r_ext_texture_filter_anisotropic) )
{
glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &glConfig2.maxTextureAnisotropy );
glConfig2.textureAnisotropyAvailable = true;
}
// VAO and VBO
//REQUIRE_EXTENSION( ARB_vertex_array_object );
REQUIRE_EXTENSION( ARB_vertex_buffer_object );
REQUIRE_EXTENSION( ARB_half_float_vertex );
// FBO
glConfig2.framebufferObjectAvailable = false;
if ( LOAD_EXTENSION_WITH_CVAR(ARB_framebuffer_object, r_arb_framebuffer_object) )
{
glGetIntegerv( GL_MAX_RENDERBUFFER_SIZE, &glConfig2.maxRenderbufferSize );
glGetIntegerv( GL_MAX_COLOR_ATTACHMENTS, &glConfig2.maxColorAttachments );
glConfig2.framebufferObjectAvailable = true;
}
// Other
REQUIRE_EXTENSION( ARB_shader_objects );
glConfig2.occlusionQueryAvailable = false;
glConfig2.occlusionQueryBits = 0;
if ( LOAD_EXTENSION_WITH_CVAR(ARB_occlusion_query, r_ext_occlusion_query) )
{
glConfig2.occlusionQueryAvailable = true;
glGetQueryivARB( GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &glConfig2.occlusionQueryBits );
}
glConfig2.drawBuffersAvailable = false;
if ( LOAD_EXTENSION_WITH_CVAR(ARB_draw_buffers, r_ext_draw_buffers) )
{
glGetIntegerv( GL_MAX_DRAW_BUFFERS_ARB, &glConfig2.maxDrawBuffers );
glConfig2.drawBuffersAvailable = true;
}
// gDEBugger debug
if ( GLEW_GREMEDY_string_marker )
{
ri.Printf( PRINT_ALL, "...using GL_GREMEDY_string_marker\n" );
}
else
{
ri.Printf( PRINT_ALL, "...GL_GREMEDY_string_marker not found\n" );
}
#ifdef GLEW_ARB_get_program_binary
if( GLEW_ARB_get_program_binary )
{
int formats = 0;
glGetIntegerv( GL_NUM_PROGRAM_BINARY_FORMATS, &formats );
if ( !formats )
{
ri.Printf( PRINT_ALL, "...GL_ARB_get_program_binary found, but with no binary formats\n");
glConfig2.getProgramBinaryAvailable = false;
}
else
{
ri.Printf( PRINT_ALL, "...using GL_ARB_get_program_binary\n");
glConfig2.getProgramBinaryAvailable = true;
}
}
else
#endif
{
ri.Printf( PRINT_ALL, "...GL_ARB_get_program_binary not found\n");
glConfig2.getProgramBinaryAvailable = false;
}
#ifdef GLEW_ARB_buffer_storage
if ( GLEW_ARB_buffer_storage )
{
if ( r_arb_buffer_storage->integer )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_buffer_storage\n" );
glConfig2.bufferStorageAvailable = true;
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_buffer_storage\n" );
glConfig2.bufferStorageAvailable = false;
}
}
else
#endif
{
ri.Printf( PRINT_ALL, "...GL_ARB_buffer_storage not found\n" );
glConfig2.bufferStorageAvailable = false;
}
glConfig2.mapBufferRangeAvailable = LOAD_EXTENSION_WITH_CVAR( ARB_map_buffer_range, r_arb_map_buffer_range );
glConfig2.syncAvailable = LOAD_EXTENSION_WITH_CVAR( ARB_sync, r_arb_sync );
GL_CheckErrors();
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBOcclusionQuery_nglGetQueryivARB(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;
glGetQueryivARBPROC glGetQueryivARB = (glGetQueryivARBPROC)((intptr_t)function_pointer);
glGetQueryivARB(target, pname, params_address);
}
