/*
===============
R_ColorShiftLightingBytes
===============
*/
void R_ColorShiftLightingBytes( byte in[3] ) {
int shift, r, g, b;
// shift the color data based on overbright range
shift = Q_max( 0, r_mapOverBrightBits->integer - tr.overbrightBits );
// shift the data based on overbright range
r = in[0] << shift;
g = in[1] << shift;
b = in[2] << shift;
// normalize by color instead of saturating to white
if ( (r|g|b) > 255 ) {
int max;
max = r > g ? r : g;
max = max > b ? max : b;
r = r * 255 / max;
g = g * 255 / max;
b = b * 255 / max;
}
in[0] = r;
in[1] = g;
in[2] = b;
}
void CFuncVehicle::Blocked(CBaseEntity *pOther)
{
entvars_t *pevOther = pOther->pev;
if ((pevOther->flags & FL_ONGROUND) && VARS(pevOther->groundentity) == pev)
{
pevOther->velocity = pev->velocity;
return;
}
pevOther->velocity = (pevOther->origin - pev->origin).Normalize() * pev->dmg;
pevOther->velocity.z += 300;
pev->velocity = pev->velocity * 0.85;
ALERT(at_aiconsole, "TRAIN(%s): Blocked by %s (dmg:%.2f)\n", STRING(pev->targetname), STRING(pOther->pev->classname), pev->dmg);
UTIL_MakeVectors(pev->angles);
Vector forward, right, vOrigin;
Vector vFrontLeft = (gpGlobals->v_forward * -1) * (m_length * 0.5);
Vector vFrontRight = (gpGlobals->v_right * -1) * (m_width * 0.5);
Vector vBackLeft = pev->origin + vFrontLeft - vFrontRight;
Vector vBackRight = pev->origin - vFrontLeft + vFrontRight;
float minx = Q_min(vBackLeft.x, vBackRight.x);
float miny = Q_min(vBackLeft.y, vBackRight.y);
float maxx = Q_max(vBackLeft.x, vBackRight.x);
float maxy = Q_max(vBackLeft.y, vBackRight.y);
float minz = pev->origin.z;
#ifdef REGAMEDLL_FIXES
float maxz = pev->origin.z + (2 * Q_abs(pev->mins.z - pev->maxs.z));
#else
float maxz = pev->origin.z + (2 * Q_abs(int(pev->mins.z - pev->maxs.z)));
#endif
if (pOther->pev->origin.x < minx
|| pOther->pev->origin.x > maxx
|| pOther->pev->origin.y < miny
|| pOther->pev->origin.y > maxy
|| pOther->pev->origin.z < pev->origin.z
|| pOther->pev->origin.z > maxz)
{
pOther->TakeDamage(pev, pev, 150, DMG_CRUSH);
}
}
//=========================================================
// JKG_Array_Init
//---------------------------------------------------------
// Description:
// Initialises the dynamic array. All dynamic arrays must
// be initialised using this function.
//=========================================================
void JKG_Array_Init ( jkgArray_t *arr, unsigned int elementSize, unsigned int initialCapacity )
{
arr->data = NULL;
initialCapacity = Q_max (initialCapacity, 1);
arr->data = malloc (initialCapacity * elementSize);
arr->size = 0;
arr->_elementSize = elementSize;
arr->_capacity = initialCapacity;
}
// Find "simple" ground height, treating current nav area as part of the floor
bool CHostageImprov::__MAKE_VHOOK(GetSimpleGroundHeightWithFloor)(const Vector *pos, float *height, Vector *normal)
{
if (GetSimpleGroundHeight(pos, height, normal))
{
// our current nav area also serves as a ground polygon
if (m_lastKnownArea != NULL && m_lastKnownArea->IsOverlapping(pos))
*height = Q_max((*height), m_lastKnownArea->GetZ(pos));
return true;
}
return false;
}
/* <3fea72> ../public/MemPool.cpp:157 */
void *CMemoryPool::Alloc(unsigned int amount)
{
void *returnBlock;
if (amount > (unsigned int)_blockSize)
return NULL;
++_blocksAllocated;
_peakAlloc = Q_max(_peakAlloc, _blocksAllocated);
if (_blocksAllocated >= _numElements)
AddNewBlob();
#ifdef _WIN32
if (!_headOfFreeList)
DebugBreak();
#endif // _WIN32
returnBlock = _headOfFreeList;
_headOfFreeList = *((void **)_headOfFreeList);
return returnBlock;
}
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");
}
}
char *Q_pretifymem( float value, int digitsafterdecimal )
{
static char output[8][32];
static int current;
float onekb = 1024.0f;
float onemb = onekb * onekb;
char suffix[8];
char *out = output[current];
char val[32], *i, *o, *dot;
int pos;
current = ( current + 1 ) & ( 8 - 1 );
// first figure out which bin to use
if( value > onemb )
{
value /= onemb;
Q_sprintf( suffix, " Mb" );
}
else if( value > onekb )
{
value /= onekb;
Q_sprintf( suffix, " Kb" );
}
else Q_sprintf( suffix, " bytes" );
// clamp to >= 0
digitsafterdecimal = Q_max( digitsafterdecimal, 0 );
// if it's basically integral, don't do any decimals
if( fabs( value - (int)value ) < 0.00001 )
{
Q_sprintf( val, "%i%s", (int)value, suffix );
}
else
{
char fmt[32];
// otherwise, create a format string for the decimals
Q_sprintf( fmt, "%%.%if%s", digitsafterdecimal, suffix );
Q_sprintf( val, fmt, value );
}
// copy from in to out
i = val;
o = out;
// search for decimal or if it was integral, find the space after the raw number
dot = Q_strstr( i, "." );
if( !dot ) dot = Q_strstr( i, " " );
pos = dot - i; // compute position of dot
pos -= 3; // don't put a comma if it's <= 3 long
while( *i )
{
// if pos is still valid then insert a comma every third digit, except if we would be
// putting one in the first spot
if( pos >= 0 && !( pos % 3 ))
{
// never in first spot
if( o != out ) *o++ = ',';
}
pos--; // count down comma position
*o++ = *i++; // copy rest of data as normal
}
*o = 0; // terminate
return out;
}
