void CQuickSpriteSystem::StartGroup(textureBundle_t *bundle, unsigned long glbits, unsigned long fogcolor )
{
mNextVert = 0;
mTexBundle = bundle;
mGLStateBits = glbits;
if (fogcolor)
{
mUseFog = qtrue;
mFogColor = fogcolor;
}
else
{
mUseFog = qfalse;
}
int cullingOn;
qglGetIntegerv(GL_CULL_FACE,&cullingOn);
if(cullingOn)
{
mTurnCullBackOn=true;
}
else
{
mTurnCullBackOn=false;
}
qglDisable(GL_CULL_FACE);
}
/**
* Creates gl texture font from true type font;
* @param ft_library: base font library;
* @param face_data: pointer to the buffer with font file content; DO NOT FREE that pointer otherway using FT_Face prevets to crash;
* @param face_data_size: size of buffer with font file content;
* @param font_size: size of font glyph?
* @return pointer to the gl_tex_font_s structure;
*/
gl_tex_font_p glf_create_font_mem(void *face_data, size_t face_data_size, uint16_t font_size)
{
if(g_ft_library)
{
gl_tex_font_p glf = (gl_tex_font_p)malloc(sizeof(gl_tex_font_t));
glf->ft_face = NULL;
if(FT_New_Memory_Face(g_ft_library, (const FT_Byte*)face_data, face_data_size, 0, (FT_Face*)&glf->ft_face))
{
free(glf);
return NULL;
}
glf->glyphs_count = ((FT_Face)glf->ft_face)->num_glyphs;
glf->glyphs = (char_info_p)malloc(glf->glyphs_count * sizeof(char_info_t));
qglGetIntegerv(GL_MAX_TEXTURE_SIZE, &glf->gl_max_tex_width);
glf->gl_tex_width = glf->gl_max_tex_width;
glf->gl_tex_indexes = NULL;
glf->gl_tex_indexes_count = 0;
glf->gl_real_tex_indexes_count = 0;
glf_resize(glf, font_size);
FT_Select_Charmap(glf->ft_face, FT_ENCODING_UNICODE);
return glf;
}
return NULL;
}
gl_tex_font_p glf_create_font(const char *file_name, uint16_t font_size)
{
if(g_ft_library)
{
gl_tex_font_p glf = (gl_tex_font_p)malloc(sizeof(gl_tex_font_t));
glf->ft_face = NULL;
if(FT_New_Face(g_ft_library, file_name, 0, (FT_Face*)&glf->ft_face))
{
free(glf);
return NULL;
}
glf->glyphs_count = ((FT_Face)glf->ft_face)->num_glyphs;
glf->glyphs = (char_info_p)malloc(glf->glyphs_count * sizeof(char_info_t));
qglGetIntegerv(GL_MAX_TEXTURE_SIZE, &glf->gl_max_tex_width);
glf->gl_tex_width = glf->gl_max_tex_width;
glf->gl_tex_indexes = NULL;
glf->gl_tex_indexes_count = 0;
glf->gl_real_tex_indexes_count = 0;
glf->gl_font_color[0] = 0.0;
glf->gl_font_color[1] = 0.0;
glf->gl_font_color[2] = 0.0;
glf->gl_font_color[3] = 1.0;
glf_resize(glf, font_size);
FT_Select_Charmap(glf->ft_face, FT_ENCODING_UNICODE);
return glf;
}
return NULL;
}
/*
** GLimp_Init
**
** This is the platform specific OpenGL initialization function. It
** is responsible for loading OpenGL, initializing it, setting
** extensions, creating a window of the appropriate size, doing
** fullscreen manipulations, etc. Its overall responsibility is
** to make sure that a functional OpenGL subsystem is operating
** when it returns to the ref.
*/
void GLimp_Init( void )
{
// load appropriate DLL and initialize subsystem
GLW_StartOpenGL();
// get our config strings
glConfig.vendor_string = (const char *) qglGetString (GL_VENDOR);
glConfig.renderer_string = (const char *) qglGetString (GL_RENDERER);
glConfig.version_string = (const char *) qglGetString (GL_VERSION);
glConfig.extensions_string = (const char *) qglGetString (GL_EXTENSIONS);
if (!glConfig.vendor_string || !glConfig.renderer_string || !glConfig.version_string || !glConfig.extensions_string)
{
Com_Error( ERR_FATAL, "GLimp_Init() - Invalid GL Driver\n" );
}
// OpenGL driver constants
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
// stubbed or broken drivers may have reported 0...
if ( glConfig.maxTextureSize <= 0 )
{
glConfig.maxTextureSize = 0;
}
GLW_InitExtensions();
WG_CheckHardwareGamma();
}
/*
** InitOpenGL
**
** This function is responsible for initializing a valid OpenGL subsystem. This
** is done by calling GLimp_Init (which gives us a working OGL subsystem) then
** setting variables, checking GL constants, and reporting the gfx system config
** to the user.
*/
static void InitOpenGL( void ) {
char renderer_buffer[1024];
//
// initialize OS specific portions of the renderer
//
// GLimp_Init directly or indirectly references the following cvars:
// - r_fullscreen
// - r_mode
// - r_(color|depth|stencil)bits
// - r_ignorehwgamma
// - r_gamma
//
if ( glConfig.vidWidth == 0 ) {
GLint temp;
GLimp_Init();
strcpy( renderer_buffer, glConfig.renderer_string );
Q_strlwr( renderer_buffer );
// OpenGL driver constants
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &temp );
glConfig.maxTextureSize = temp;
// stubbed or broken drivers may have reported 0...
if ( glConfig.maxTextureSize <= 0 ) {
glConfig.maxTextureSize = 0;
}
}
// set default state
GL_SetDefaultState();
}
void CQuickSpriteSystem::StartGroup(textureBundle_t *bundle, uint32_t glbits, int fogIndex )
{
mNextVert = 0;
mTexBundle = bundle;
mGLStateBits = glbits;
if (fogIndex != -1)
{
mUseFog = qtrue;
mFogIndex = fogIndex;
}
else
{
mUseFog = qfalse;
}
int cullingOn;
qglGetIntegerv(GL_CULL_FACE,&cullingOn);
if(cullingOn)
{
mTurnCullBackOn=true;
}
else
{
mTurnCullBackOn=false;
}
qglDisable(GL_CULL_FACE);
}
/*
==================
RB_ReadPixels
Reads an image but takes care of alignment issues for reading RGB images.
Reads a minimum offset for where the RGB data starts in the image from
integer stored at pointer offset. When the function has returned the actual
offset was written back to address offset. This address will always have an
alignment of packAlign to ensure efficient copying.
Stores the length of padding after a line of pixels to address padlen
Return value must be freed with ri.Hunk_FreeTempMemory()
==================
*/
byte *RB_ReadPixels(int x, int y, int width, int height, size_t *offset, int *padlen)
{
byte *buffer, *bufstart;
int padwidth, linelen;
GLint packAlign;
qglGetIntegerv(GL_PACK_ALIGNMENT, &packAlign);
linelen = width * 3;
padwidth = PAD(linelen, packAlign);
// Allocate a few more bytes so that we can choose an alignment we like
buffer = ri.Hunk_AllocateTempMemory(padwidth * height + *offset + packAlign - 1);
bufstart = buffer;
padwidth = linelen;
int p2width = 1, p2height = 1;
int xx, yy, aa;
while (p2width < glConfig.vidWidth)
p2width *= 2;
while (p2height < glConfig.vidHeight)
p2height *= 2;
byte *source = (byte *) ri.Hunk_AllocateTempMemory(p2width * p2height * 4);
qglReadPixels(0, 0, p2width, p2height, GL_RGBA, GL_UNSIGNED_BYTE, source);
for (yy = y; yy < height; yy++)
for (xx = x; xx < width; xx++)
for (aa = 0; aa < 3; aa++)
buffer[yy * width * 3 + xx * 3 + aa] = source[(yy + y) * p2width * 4 + (xx + x) * 4 + aa];
ri.Hunk_FreeTempMemory(source);
*offset = bufstart - buffer;
*padlen = padwidth - linelen;
return buffer;
}
/*
* GfxMemInfo_f
*/
void
GfxMemInfo_f(void)
{
switch(glRefConfig.memInfo){
case MI_NONE:
{
ri.Printf(PRINT_ALL, "No extension found for GPU memory info.\n");
}
break;
case MI_NVX:
{
int value;
qglGetIntegerv(GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, &value);
ri.Printf(PRINT_ALL, "GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX: %ikb\n", value);
qglGetIntegerv(GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX, &value);
ri.Printf(PRINT_ALL, "GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX: %ikb\n", value);
qglGetIntegerv(GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &value);
ri.Printf(PRINT_ALL, "GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX: %ikb\n", value);
qglGetIntegerv(GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX, &value);
ri.Printf(PRINT_ALL, "GPU_MEMORY_INFO_EVICTION_COUNT_NVX: %i\n", value);
qglGetIntegerv(GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX, &value);
ri.Printf(PRINT_ALL, "GPU_MEMORY_INFO_EVICTED_MEMORY_NVX: %ikb\n", value);
}
break;
case MI_ATI:
{
/* GL_ATI_meminfo */
int value[4];
qglGetIntegerv(GL_VBO_FREE_MEMORY_ATI, &value[0]);
ri.Printf(PRINT_ALL,
"VBO_FREE_MEMORY_ATI: %ikb total %ikb largest aux: %ikb total %ikb largest\n",
value[0], value[1], value[2],
value[3]);
qglGetIntegerv(GL_TEXTURE_FREE_MEMORY_ATI, &value[0]);
ri.Printf(PRINT_ALL,
"TEXTURE_FREE_MEMORY_ATI: %ikb total %ikb largest aux: %ikb total %ikb largest\n",
value[0], value[1], value[2],
value[3]);
qglGetIntegerv(GL_RENDERBUFFER_FREE_MEMORY_ATI, &value[0]);
ri.Printf(
PRINT_ALL,
"RENDERBUFFER_FREE_MEMORY_ATI: %ikb total %ikb largest aux: %ikb total %ikb largest\n",
value[0], value[1], value[2], value[3]);
}
break;
}
}
bordered_texture_atlas::bordered_texture_atlas(int border,
size_t page_count,
const tr4_textile32_t *pages,
size_t object_texture_count,
const tr4_object_texture_t *object_textures,
size_t sprite_texture_count,
const tr_sprite_texture_t *sprite_textures)
: border_width(border),
number_result_pages(0),
result_page_width(0),
result_page_height(NULL),
number_original_pages(page_count),
original_pages(pages),
number_file_object_textures(0),
file_object_textures(NULL),
number_sprite_textures(0),
canonical_textures_for_sprite_textures(NULL),
number_canonical_object_textures(0),
canonical_object_textures(NULL),
textures_indexes(NULL)
{
GLint max_texture_edge_length = 0;
qglGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_edge_length);
if (max_texture_edge_length > 4096)
max_texture_edge_length = 4096; // That is already 64 MB and covers up to 256 pages.
result_page_width = max_texture_edge_length;
size_t maxNumberCanonicalTextures = object_texture_count + sprite_texture_count + 1;
canonical_object_textures = new canonical_object_texture[maxNumberCanonicalTextures];
number_canonical_object_textures = 1;
canonical_object_texture &canonical = canonical_object_textures[0];
canonical.width = 8;
canonical.height = 8;
canonical.original_page = WHITE_TEXTURE_INDEX;
canonical.original_x = 0;
canonical.original_y = 0;
file_object_textures = new file_object_texture[object_texture_count];
for (size_t i = 0; i < object_texture_count; i++)
{
addObjectTexture(object_textures[i]);
}
canonical_textures_for_sprite_textures = new unsigned long[sprite_texture_count];
for (size_t i = 0; i < sprite_texture_count; i++)
{
addSpriteTexture(sprite_textures[i]);
}
layOutTextures();
}
static void GLW_InitExtensions()
{
ri.Printf( PRINT_DEVELOPER, "Initializing OpenGL extensions\n" );
#define QGL_EXT(T, fn) q##fn = (T)qwglGetProcAddress( #fn ); \
if (!q##fn) Com_Error( ERR_FATAL, "QGL_EXT: required extension "#fn" not found" );
QGL_EXT( PFNGLLOCKARRAYSEXTPROC, glLockArraysEXT );
QGL_EXT( PFNGLUNLOCKARRAYSEXTPROC, glUnlockArraysEXT );
QGL_EXT( PFNGLACTIVETEXTUREARBPROC, glActiveTextureARB );
QGL_EXT( PFNGLCLIENTACTIVETEXTUREARBPROC, glClientActiveTextureARB );
#undef QGL_EXT
// WGL_EXT_swap_control
qwglSwapIntervalEXT = ( BOOL (WINAPI *)(int)) qwglGetProcAddress( "wglSwapIntervalEXT" );
if ( qwglSwapIntervalEXT )
{
ri.Printf( PRINT_DEVELOPER, "...using WGL_EXT_swap_control\n" );
r_swapInterval->modified = qtrue; // force a set next frame
}
else
{
ri.Printf( PRINT_DEVELOPER, "...WGL_EXT_swap_control not found\n" );
}
int maxAnisotropy = 0;
if ( strstr( glConfig.extensions_string, "GL_EXT_texture_filter_anisotropic" ) )
{
if (r_ext_max_anisotropy->integer > 1) {
qglGetIntegerv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy );
if ( maxAnisotropy <= 0 ) {
ri.Printf( PRINT_DEVELOPER, "...GL_EXT_texture_filter_anisotropic not properly supported!\n" );
maxAnisotropy = 0;
}
else
{
ri.Printf( PRINT_DEVELOPER, "...using GL_EXT_texture_filter_anisotropic (max: %i)\n", maxAnisotropy );
}
}
else
{
ri.Printf( PRINT_DEVELOPER, "...ignoring GL_EXT_texture_filter_anisotropic\n" );
}
}
else
{
ri.Printf( PRINT_DEVELOPER, "...GL_EXT_texture_filter_anisotropic not found\n" );
}
Cvar_Set( "r_ext_max_anisotropy", va("%i", maxAnisotropy) );
}
static void glEndFragmentShaderATI (void) {
GLint errPos;
int i;
char fragString[4096];
sGeneratingProgram = 0;
// header
strcpy(fragString, "!!ATIfs1.0\n");
// constants
if (sConstString[0] || sConstUsed) {
strcat (fragString, "StartConstants;\n");
if (sConstUsed) {
for (i = 0; i < 8; i ++) {
if (sConst[i] == 1) {
char str[128];
sprintf (str, " CONSTANT c%d = program.env[%d];\n", i, i);
strcat (fragString, str);
}
}
}
if (sConstString[0]) {
strcat (fragString, sConstString);
}
strcat (fragString, "EndConstants;\n\n");
}
if (sCurrentPass == 0) {
strcat(fragString, "StartOutputPass;\n");
strcat(fragString, sPassString[0]);
strcat(fragString, "EndPass;\n");
} else {
strcat(fragString, "StartPrelimPass;\n");
strcat(fragString, sPassString[0]);
strcat(fragString, "EndPass;\n\n");
strcat(fragString, "StartOutputPass;\n");
strcat(fragString, sPassString[1]);
strcat(fragString, "EndPass;\n");
}
qglProgramStringARB(GL_TEXT_FRAGMENT_SHADER_ATI, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(fragString), fragString);
qglGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &errPos );
if(errPos != -1) {
const GLubyte *errString = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
common->Warning("WARNING: glError at %d:%s when compiling atiFragmentShader %s", errPos, errString, fragString);
}
}
/*
* R_PrintMemoryInfo
*/
static void R_PrintMemoryInfo( void )
{
int mem[12];
Com_Printf( "\n" );
Com_Printf( "Video memory information:\n" );
if( glConfig.ext.gpu_memory_info ) {
// NV
qglGetIntegerv( GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX, mem );
Com_Printf( "total: %i MB\n", mem[0] >>10 );
qglGetIntegerv( GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, mem );
Com_Printf( "dedicated: %i MB\n", mem[0] >>10 );
qglGetIntegerv( GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, mem );
Com_Printf( "available: %i MB\n", mem[0] >>10 );
qglGetIntegerv( GPU_MEMORY_INFO_EVICTION_COUNT_NVX, mem );
Com_Printf( "eviction count: %i MB\n", mem[0] >> 10 );
qglGetIntegerv( GPU_MEMORY_INFO_EVICTED_MEMORY_NVX, mem );
Com_Printf( "totally evicted: %i MB\n", mem[0] >>10 );
}
/*
** InitOpenGL
**
** This function is responsible for initializing a valid OpenGL subsystem. This
** is done by calling GLimp_Init (which gives us a working OGL subsystem) then
** setting variables, checking GL constants, and reporting the gfx system config
** to the user.
*/
static void InitOpenGL( void )
{
char renderer_buffer[1024];
//
// initialize OS specific portions of the renderer
//
// GLimp_Init directly or indirectly references the following cvars:
// - r_fullscreen
// - r_glDriver
// - r_mode
// - r_(color|depth|stencil)bits
// - r_ignorehwgamma
// - r_gamma
//
if ( !glState.initialized ) // @pjb: vdConfig.vidWidth == 0 is no longer a good indicator
{
GLint temp;
GLimp_Init();
strcpy( renderer_buffer, vdConfig.renderer_string );
Q_strlwr( renderer_buffer );
// OpenGL driver constants
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &temp );
vdConfig.maxTextureSize = temp;
// stubbed or broken drivers may have reported 0...
if ( vdConfig.maxTextureSize <= 0 )
{
vdConfig.maxTextureSize = 0;
}
glState.initialized = qtrue;
}
// init command buffers and SMP
R_InitCommandBuffers();
// print info
GLRB_GfxInfo_f();
// set default state
GL_SetDefaultState();
}
/*
===============
idRenderSystemLocal::ProjectMouseToWorldCoord
http://nehe.gamedev.net/article/using_gluunproject/16013/
===============
*/
void idRenderSystemLocal::ProjectMouseToWorldCoord( idVec2 mouseXY, idVec3 &worldPos ) {
GLint viewport[4]; // Where The Viewport Values Will Be Stored
GLfloat modelview[16]; // Where The 16 Doubles Of The Modelview Matrix Are To Be Stored
GLfloat projection[16];
GLfloat winX, winY, winZ;
qglGetIntegerv(GL_VIEWPORT, viewport); // Retrieves The Viewport Values (X, Y, Width, height).
qglGetFloatv(GL_MODELVIEW_MATRIX, modelview); // Retrieve The Modelview Matrix
qglGetFloatv(GL_PROJECTION_MATRIX, projection); // Retrieve The Modelview Matrix
winX = (float)mouseXY.x;
winY = (float)viewport[3] - (float)mouseXY.y;
qglReadPixels( mouseXY.x, int(winY), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ );
myUnProjectf( winX, winY, winZ, modelview, projection, viewport, &worldPos.x);
}
/*
** InitOpenGL
**
** This function is responsible for initializing a valid OpenGL subsystem. This
** is done by calling GLimp_Init (which gives us a working OGL subsystem) then
** setting variables, checking GL constants, and reporting the gfx system config
** to the user.
*/
static void
InitOpenGL(void)
{
char renderer_buffer[1024];
/*
* initialize OS specific portions of the renderer
*
* GLimp_Init directly or indirectly references the following cvars:
* - r_fullscreen
* - r_mode
* - r_(color|depth|stencil)bits
* - r_ignorehwgamma
* - r_gamma
* */
if(glConfig.vidWidth == 0){
GLint temp;
GLimp_Init();
strcpy(renderer_buffer, glConfig.renderer_string);
Q_strlwr(renderer_buffer);
/* OpenGL driver constants */
qglGetIntegerv(GL_MAX_TEXTURE_SIZE, &temp);
glConfig.maxTextureSize = temp;
/* stubbed or broken drivers may have reported 0... */
if(glConfig.maxTextureSize <= 0){
glConfig.maxTextureSize = 0;
}
}
/* init command buffers and SMP */
R_InitCommandBuffers();
/* print info */
GfxInfo_f();
/* set default state */
GL_SetDefaultState();
}
/*
** GLW_InitExtensions
*/
static void GLW_InitExtensions( void )
{
// Select our tc scheme
GLW_InitTextureCompression();
// GL_EXT_texture_env_add
glConfig.textureEnvAddAvailable = qfalse;
if ( strstr( glConfig.extensions_string, "EXT_texture_env_add" ) )
{
glConfig.textureEnvAddAvailable = qtrue;
}
// GL_EXT_texture_filter_anisotropic
glConfig.textureFilterAnisotropicAvailable = qfalse;
if ( strstr( glConfig.extensions_string, "EXT_texture_filter_anisotropic" ) )
{
glConfig.textureFilterAnisotropicAvailable = qtrue;
}
// GL_EXT_clamp_to_edge
glConfig.clampToEdgeAvailable = qfalse;
if ( strstr( glConfig.extensions_string, "GL_EXT_texture_edge_clamp" ) )
{
glConfig.clampToEdgeAvailable = qtrue;
}
// GL_ARB_multitexture
if ( strstr( glConfig.extensions_string, "GL_ARB_multitexture" ) )
{
if ( qglActiveTextureARB )
{
qglGetIntegerv( GL_MAX_ACTIVE_TEXTURES_ARB, &glConfig.maxActiveTextures );
if ( glConfig.maxActiveTextures < 2 )
{
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
}
}
}
}
byte* RB_ReadPixels(int x, int y, int width, int height, size_t* offset, int* padlen) {
byte* buffer, *bufstart;
int padwidth, linelen;
GLint packAlign;
qglGetIntegerv(GL_PACK_ALIGNMENT, &packAlign);
linelen = width * 3;
padwidth = PAD(linelen, packAlign);
// Allocate a few more bytes so that we can choose an alignment we like
buffer = ri.Hunk_AllocateTempMemory(padwidth * height + *offset + packAlign - 1);
bufstart = PADP((intptr_t) buffer + *offset, packAlign);
qglReadPixels(x, y, width, height, GL_RGB, GL_UNSIGNED_BYTE, bufstart);
*offset = bufstart - buffer;
*padlen = padwidth - linelen;
return buffer;
}
/*
=================
R_R200_Init
=================
*/
void R_R200_Init( void ) {
glConfig.allowR200Path = false;
common->Printf( "----------- R200_Init -----------\n" );
if ( !glConfig.atiFragmentShaderAvailable || !glConfig.ARBVertexProgramAvailable || !glConfig.ARBVertexBufferObjectAvailable ) {
common->Printf( "Not available.\n" );
return;
}
GL_CheckErrors();
qglGetIntegerv( GL_NUM_FRAGMENT_REGISTERS_ATI, &fsi.numFragmentRegisters );
qglGetIntegerv( GL_NUM_FRAGMENT_CONSTANTS_ATI, &fsi.numFragmentConstants );
qglGetIntegerv( GL_NUM_PASSES_ATI, &fsi.numPasses );
qglGetIntegerv( GL_NUM_INSTRUCTIONS_PER_PASS_ATI, &fsi.numInstructionsPerPass );
qglGetIntegerv( GL_NUM_INSTRUCTIONS_TOTAL_ATI, &fsi.numInstructionsTotal );
qglGetIntegerv( GL_COLOR_ALPHA_PAIRING_ATI, &fsi.colorAlphaPairing );
qglGetIntegerv( GL_NUM_LOOPBACK_COMPONENTS_ATI, &fsi.numLoopbackComponenets );
qglGetIntegerv( GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI, &fsi.numInputInterpolatorComponents );
common->Printf( "GL_NUM_FRAGMENT_REGISTERS_ATI: %i\n", fsi.numFragmentRegisters );
common->Printf( "GL_NUM_FRAGMENT_CONSTANTS_ATI: %i\n", fsi.numFragmentConstants );
common->Printf( "GL_NUM_PASSES_ATI: %i\n", fsi.numPasses );
common->Printf( "GL_NUM_INSTRUCTIONS_PER_PASS_ATI: %i\n", fsi.numInstructionsPerPass );
common->Printf( "GL_NUM_INSTRUCTIONS_TOTAL_ATI: %i\n", fsi.numInstructionsTotal );
common->Printf( "GL_COLOR_ALPHA_PAIRING_ATI: %i\n", fsi.colorAlphaPairing );
common->Printf( "GL_NUM_LOOPBACK_COMPONENTS_ATI: %i\n", fsi.numLoopbackComponenets );
common->Printf( "GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI: %i\n", fsi.numInputInterpolatorComponents );
common->Printf( "FPROG_FAST_PATH\n" );
R_BuildSurfaceFragmentProgram( FPROG_FAST_PATH );
common->Printf( "---------------------\n" );
glConfig.allowR200Path = true;
}
byte *RB_ReadZBuffer(int x, int y, int width, int height, int *padlen)
{
byte *buffer, *bufstart;
int padwidth, linelen;
GLint packAlign;
qglGetIntegerv(GL_PACK_ALIGNMENT, &packAlign);
linelen = width;
padwidth = PAD(linelen, packAlign);
// Allocate a few more bytes so that we can choose an alignment we like
buffer = ri.Hunk_AllocateTempMemory(padwidth * height + packAlign - 1);
bufstart = PADP(( intptr_t ) buffer, packAlign);
qglDepthRange(0.0f, 1.0f);
qglReadPixels(x, y, width, height, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, bufstart);
*padlen = padwidth - linelen;
return buffer;
}
byte *RB_ReadZBuffer(int x, int y, int width, int height, int *padlen)
{
byte *buffer, *bufstart;
int padwidth, linelen;
GLint packAlign;
qglGetIntegerv(GL_PACK_ALIGNMENT, &packAlign);
linelen = width;
padwidth = PAD(linelen, packAlign);
// Allocate a few more bytes so that we can choose an alignment we like
buffer = ri.Hunk_AllocateTempMemory(padwidth * height + packAlign - 1);
bufstart = PADP(( intptr_t ) buffer, packAlign);
qglDepthRange(0.0f, 1.0f);
memset(buffer, 0, padwidth * height + packAlign - 1); //*TODO* find something to read DepthBuffer ?!
*padlen = padwidth - linelen;
return buffer;
}
/*
===============
GLimp_InitExtensions
===============
*/
static void GLimp_InitExtensions( void )
{
if ( !r_allowExtensions->integer )
{
ri->Printf( PRINT_ALL, "* IGNORING OPENGL EXTENSIONS *\n" );
return;
}
ri->Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
glConfig.textureCompression = TC_NONE;
// GL_EXT_texture_compression_s3tc
if ( GLimp_HaveExtension( "GL_ARB_texture_compression" ) &&
GLimp_HaveExtension( "GL_EXT_texture_compression_s3tc" ) )
{
if ( r_ext_compressed_textures->value )
{
glConfig.textureCompression = TC_S3TC_ARB;
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_S3_s3tc ... legacy extension before GL_EXT_texture_compression_s3tc.
if (glConfig.textureCompression == TC_NONE)
{
if ( GLimp_HaveExtension( "GL_S3_s3tc" ) )
{
if ( r_ext_compressed_textures->value )
{
glConfig.textureCompression = TC_S3TC;
ri->Printf( PRINT_ALL, "...using GL_S3_s3tc\n" );
}
else
{
ri->Printf( PRINT_ALL, "...ignoring GL_S3_s3tc\n" );
}
}
else
{
ri->Printf( PRINT_ALL, "...GL_S3_s3tc not found\n" );
}
}
// GL_EXT_texture_env_add
glConfig.textureEnvAddAvailable = false;
if ( GLimp_HaveExtension( "EXT_texture_env_add" ) )
{
if ( r_ext_texture_env_add->integer )
{
glConfig.textureEnvAddAvailable = true;
ri->Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
}
else
{
glConfig.textureEnvAddAvailable = false;
ri->Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
}
}
else
{
ri->Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
}
// GL_ARB_multitexture
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
if ( GLimp_HaveExtension( "GL_ARB_multitexture" ) )
{
if ( r_ext_multitexture->value )
{
qglMultiTexCoord2fARB = ( void( APIENTRYP ) ( GLenum target, GLfloat s, GLfloat t ) )SDL_GL_GetProcAddress( "glMultiTexCoord2fARB" );
qglActiveTextureARB = ( void( APIENTRYP ) ( GLenum texture ) )SDL_GL_GetProcAddress( "glActiveTextureARB" );
qglClientActiveTextureARB = ( void( APIENTRYP ) ( GLenum texture ) )SDL_GL_GetProcAddress( "glClientActiveTextureARB" );
if ( qglActiveTextureARB )
{
GLint glint = 0;
qglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glint );
glConfig.numTextureUnits = (int) glint;
if ( glConfig.numTextureUnits > 1 )
{
ri->Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
}
else
{
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
ri->Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
}
}
}
else
{
ri->Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
}
}
else
{
ri->Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
}
// GL_EXT_compiled_vertex_array
if ( GLimp_HaveExtension( "GL_EXT_compiled_vertex_array" ) )
{
if ( r_ext_compiled_vertex_array->value )
{
ri->Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
qglLockArraysEXT = ( void ( APIENTRY * )( GLint, GLint ) ) SDL_GL_GetProcAddress( "glLockArraysEXT" );
qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) SDL_GL_GetProcAddress( "glUnlockArraysEXT" );
if (!qglLockArraysEXT || !qglUnlockArraysEXT)
{
ri->Error (ERR_FATAL, "bad getprocaddress");
}
}
else
{
ri->Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
}
}
else
{
ri->Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
}
textureFilterAnisotropic = false;
if ( GLimp_HaveExtension( "GL_EXT_texture_filter_anisotropic" ) )
{
if ( r_ext_texture_filter_anisotropic->integer ) {
qglGetIntegerv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint *)&maxAnisotropy );
if ( maxAnisotropy <= 0 ) {
ri->Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic not properly supported!\n" );
maxAnisotropy = 0;
}
else
{
ri->Printf( PRINT_ALL, "...using GL_EXT_texture_filter_anisotropic (max: %i)\n", maxAnisotropy );
textureFilterAnisotropic = true;
}
}
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" );
}
}
/*
** GLW_InitExtensions
*/
static void GLW_InitExtensions( void ) {
if ( !r_allowExtensions->integer ) {
ri.Printf( PRINT_ALL, "*** IGNORING OPENGL EXTENSIONS ***\n" );
return;
}
ri.Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
#ifndef HAVE_GLES
// GL_S3_s3tc
if ( Q_stristr( glConfig.extensions_string, "GL_S3_s3tc" ) ) {
if ( r_ext_compressed_textures->value ) {
glConfig.textureCompression = TC_S3TC;
ri.Printf( PRINT_ALL, "...using GL_S3_s3tc\n" );
} else
{
glConfig.textureCompression = TC_NONE;
ri.Printf( PRINT_ALL, "...ignoring GL_S3_s3tc\n" );
}
} else
#endif
{
glConfig.textureCompression = TC_NONE;
ri.Printf( PRINT_ALL, "...GL_S3_s3tc not found\n" );
}
// GL_EXT_texture_env_add
#ifdef HAVE_GLES
glConfig.textureEnvAddAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
#else
glConfig.textureEnvAddAvailable = qfalse;
if ( Q_stristr( glConfig.extensions_string, "EXT_texture_env_add" ) ) {
if ( r_ext_texture_env_add->integer ) {
glConfig.textureEnvAddAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
} else
{
glConfig.textureEnvAddAvailable = qfalse;
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
}
} else
{
ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
}
#endif
// GL_ARB_multitexture
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
#ifdef HAVE_GLES
qglGetIntegerv( GL_MAX_TEXTURE_UNITS, &glConfig.maxActiveTextures );
//ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, %i texture units\n", glConfig.maxActiveTextures );
//glConfig.maxActiveTextures=4;
qglMultiTexCoord2fARB = myglMultiTexCoord2f;
qglActiveTextureARB = glActiveTexture;
qglClientActiveTextureARB = glClientActiveTexture;
if ( glConfig.maxActiveTextures > 1 )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture (%i texture units)\n", glConfig.maxActiveTextures );
}
else
{
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
}
#else
if ( Q_stristr( glConfig.extensions_string, "GL_ARB_multitexture" ) ) {
if ( r_ext_multitexture->value ) {
qglMultiTexCoord2fARB = ( PFNGLMULTITEXCOORD2FARBPROC ) dlsym( glw_state.OpenGLLib, "glMultiTexCoord2fARB" );
qglActiveTextureARB = ( PFNGLACTIVETEXTUREARBPROC ) dlsym( glw_state.OpenGLLib, "glActiveTextureARB" );
qglClientActiveTextureARB = ( PFNGLCLIENTACTIVETEXTUREARBPROC ) dlsym( glw_state.OpenGLLib, "glClientActiveTextureARB" );
if ( qglActiveTextureARB ) {
qglGetIntegerv( GL_MAX_ACTIVE_TEXTURES_ARB, &glConfig.maxActiveTextures );
if ( glConfig.maxActiveTextures > 1 ) {
ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
} else
{
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
}
}
} else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
}
} else
{
ri.Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
}
#endif
// GL_EXT_compiled_vertex_array
#ifndef HAVE_GLES
if ( Q_stristr( glConfig.extensions_string, "GL_EXT_compiled_vertex_array" ) ) {
if ( r_ext_compiled_vertex_array->value ) {
ri.Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
qglLockArraysEXT = ( void ( APIENTRY * )( int, int ) )dlsym( glw_state.OpenGLLib, "glLockArraysEXT" );
qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) )dlsym( glw_state.OpenGLLib, "glUnlockArraysEXT" );
if ( !qglLockArraysEXT || !qglUnlockArraysEXT ) {
ri.Error( ERR_FATAL, "bad getprocaddress" );
}
} else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
}
} else
#endif
{
ri.Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
}
// GL_NV_fog_distance
#ifndef HAVE_GLES
if ( Q_stristr( glConfig.extensions_string, "GL_NV_fog_distance" ) ) {
if ( r_ext_NV_fog_dist->integer ) {
glConfig.NVFogAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_NV_fog_distance\n" );
} else {
ri.Printf( PRINT_ALL, "...ignoring GL_NV_fog_distance\n" );
ri.Cvar_Set( "r_ext_NV_fog_dist", "0" );
}
} else
#endif
{
ri.Printf( PRINT_ALL, "...GL_NV_fog_distance not found\n" );
ri.Cvar_Set( "r_ext_NV_fog_dist", "0" );
}
}
static void GLimp_InitExtensions(void)
{
if (!r_allowExtensions->integer)
{
Com_Printf("* IGNORING OPENGL EXTENSIONS *\n");
return;
}
Com_Printf("Initializing OpenGL extensions\n");
glConfig.textureCompression = TC_NONE;
#if !defined(FEATURE_RENDERER_GLES)
// GL_EXT_texture_compression_s3tc
if (GLEW_ARB_texture_compression &&
GLEW_EXT_texture_compression_s3tc)
{
if (r_ext_compressed_textures->value)
{
glConfig.textureCompression = TC_S3TC_ARB;
Com_Printf("...found OpenGL extension - GL_EXT_texture_compression_s3tc\n");
}
else
{
Com_Printf("...ignoring GL_EXT_texture_compression_s3tc\n");
}
}
else
#endif
{
Com_Printf("...GL_EXT_texture_compression_s3tc not found\n");
}
#if !defined(FEATURE_RENDERER_GLES)
// GL_S3_s3tc ... legacy extension before GL_EXT_texture_compression_s3tc.
if (glConfig.textureCompression == TC_NONE)
{
if (GLEW_S3_s3tc)
{
if (r_ext_compressed_textures->value)
{
glConfig.textureCompression = TC_S3TC;
Com_Printf("...found OpenGL extension - GL_S3_s3tc\n");
}
else
{
Com_Printf("...ignoring GL_S3_s3tc\n");
}
}
else
{
Com_Printf("...GL_S3_s3tc not found\n");
}
}
#endif
// GL_EXT_texture_env_add
#ifdef FEATURE_RENDERER_GLES
glConfig.textureEnvAddAvailable = qtrue;
Com_Printf("...using GL_EXT_texture_env_add\n");
#else
glConfig.textureEnvAddAvailable = qfalse;
if (GLEW_EXT_texture_env_add)
{
if (r_ext_texture_env_add->integer)
{
glConfig.textureEnvAddAvailable = qtrue;
Com_Printf("...found OpenGL extension - GL_EXT_texture_env_add\n");
}
else
{
glConfig.textureEnvAddAvailable = qfalse;
Com_Printf("...ignoring GL_EXT_texture_env_add\n");
}
}
else
{
Com_Printf("...GL_EXT_texture_env_add not found\n");
}
#endif
// GL_ARB_multitexture
glConfig.maxActiveTextures = 1;
#if defined(FEATURE_RENDERER_GLES)
GLint glint = 0;
qglGetIntegerv(GL_MAX_TEXTURE_UNITS, &glint);
glConfig.maxActiveTextures = (int)glint;
if (glConfig.maxActiveTextures > 1)
{
Com_Printf("...using GL_ARB_multitexture (%i texture units)\n", glConfig.maxActiveTextures);
}
else
{
Com_Printf("...not using GL_ARB_multitexture, < 2 texture units\n");
}
#elif defined(FEATURE_RENDERER2)
glConfig.maxActiveTextures = 32;
#else
if (GLEW_ARB_multitexture)
{
if (r_ext_multitexture->value)
{
GLint glint = 0;
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &glint);
glConfig.maxActiveTextures = (int) glint;
if (glConfig.maxActiveTextures > 1)
{
Com_Printf("...found OpenGL extension - GL_ARB_multitexture\n");
}
else
{
Com_Printf("...not using GL_ARB_multitexture, < 2 texture units\n");
}
}
else
{
Com_Printf("...ignoring GL_ARB_multitexture\n");
}
}
else
{
Com_Printf("...GL_ARB_multitexture not found\n");
}
#endif
}
/*
=================
R_LoadARBProgram
=================
*/
void R_LoadARBProgram( int progIndex ) {
int ofs;
int err;
idStr fullPath = "glprogs/";
fullPath += progs[progIndex].name;
char *fileBuffer;
char *buffer;
char *start, *end;
common->Printf( "%s", fullPath.c_str() );
// load the program even if we don't support it, so
// fs_copyfiles can generate cross-platform data dumps
fileSystem->ReadFile( fullPath.c_str(), (void **)&fileBuffer, NULL );
if ( !fileBuffer ) {
common->Printf( ": File not found\n" );
return;
}
// copy to stack memory and free
buffer = (char *)_alloca( strlen( fileBuffer ) + 1 );
strcpy( buffer, fileBuffer );
fileSystem->FreeFile( fileBuffer );
if ( !glConfig.isInitialized ) {
return;
}
//
// submit the program string at start to GL
//
if ( progs[progIndex].ident == 0 ) {
// allocate a new identifier for this program
progs[progIndex].ident = PROG_USER + progIndex;
}
// vertex and fragment programs can both be present in a single file, so
// scan for the proper header to be the start point, and stamp a 0 in after the end
if ( progs[progIndex].target == GL_VERTEX_PROGRAM_ARB ) {
if ( !glConfig.ARBVertexProgramAvailable ) {
common->Printf( ": GL_VERTEX_PROGRAM_ARB not available\n" );
return;
}
start = strstr( (char *)buffer, "!!ARBvp" );
}
if ( progs[progIndex].target == GL_FRAGMENT_PROGRAM_ARB ) {
if ( !glConfig.ARBFragmentProgramAvailable ) {
common->Printf( ": GL_FRAGMENT_PROGRAM_ARB not available\n" );
return;
}
start = strstr( (char *)buffer, "!!ARBfp" );
}
if ( !start ) {
common->Printf( ": !!ARB not found\n" );
return;
}
end = strstr( start, "END" );
if ( !end ) {
common->Printf( ": END not found\n" );
return;
}
end[3] = 0;
qglBindProgramARB( progs[progIndex].target, progs[progIndex].ident );
qglGetError();
qglProgramStringARB( progs[progIndex].target, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen( start ), (unsigned char *)start );
err = qglGetError();
qglGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, (GLint *)&ofs );
if ( err == GL_INVALID_OPERATION ) {
const GLubyte *str = qglGetString( GL_PROGRAM_ERROR_STRING_ARB );
common->Printf( "\nGL_PROGRAM_ERROR_STRING_ARB: %s\n", str );
if ( ofs < 0 ) {
common->Printf( "GL_PROGRAM_ERROR_POSITION_ARB < 0 with error\n" );
} else if ( ofs >= (int)strlen( (char *)start ) ) {
common->Printf( "error at end of program\n" );
} else {
common->Printf( "error at %i:\n%s", ofs, start + ofs );
}
return;
}
if ( ofs != -1 ) {
common->Printf( "\nGL_PROGRAM_ERROR_POSITION_ARB != -1 without error\n" );
return;
}
common->Printf( "\n" );
}
/*
===============
GLimp_InitExtensions
===============
*/
static void GLimp_InitExtensions( void )
{
if ( !r_allowExtensions->integer )
{
ri.Printf( PRINT_ALL, "* IGNORING OPENGL EXTENSIONS *\n" );
return;
}
ri.Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
glConfig.textureCompression = TC_NONE;
#ifndef HAVE_GLES
// GL_EXT_texture_compression_s3tc
if ( GLimp_HaveExtension( "GL_ARB_texture_compression" ) &&
GLimp_HaveExtension( "GL_EXT_texture_compression_s3tc" ) )
{
if ( r_ext_compressed_textures->value )
{
glConfig.textureCompression = TC_S3TC_ARB;
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_S3_s3tc ... legacy extension before GL_EXT_texture_compression_s3tc.
if (glConfig.textureCompression == TC_NONE)
{
if ( GLimp_HaveExtension( "GL_S3_s3tc" ) )
{
if ( r_ext_compressed_textures->value )
{
glConfig.textureCompression = TC_S3TC;
ri.Printf( PRINT_ALL, "...using GL_S3_s3tc\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_S3_s3tc\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_S3_s3tc not found\n" );
}
}
#endif
// GL_EXT_texture_env_add
#ifdef HAVE_GLES
glConfig.textureEnvAddAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
#else
glConfig.textureEnvAddAvailable = qfalse;
if ( GLimp_HaveExtension( "EXT_texture_env_add" ) )
{
if ( r_ext_texture_env_add->integer )
{
glConfig.textureEnvAddAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
}
else
{
glConfig.textureEnvAddAvailable = qfalse;
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
}
#endif
// GL_ARB_multitexture
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
#ifdef HAVE_GLES
qglGetIntegerv( GL_MAX_TEXTURE_UNITS, &glConfig.numTextureUnits );
//ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, %i texture units\n", glConfig.maxActiveTextures );
//glConfig.maxActiveTextures=4;
qglMultiTexCoord2fARB = myglMultiTexCoord2f;
qglActiveTextureARB = glActiveTexture;
qglClientActiveTextureARB = glClientActiveTexture;
if ( glConfig.numTextureUnits > 1 )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture (%i texture units)\n", glConfig.numTextureUnits );
}
else
{
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
}
#else
if ( GLimp_HaveExtension( "GL_ARB_multitexture" ) )
{
if ( r_ext_multitexture->value )
{
qglMultiTexCoord2fARB = SDL_GL_GetProcAddress( "glMultiTexCoord2fARB" );
qglActiveTextureARB = SDL_GL_GetProcAddress( "glActiveTextureARB" );
qglClientActiveTextureARB = SDL_GL_GetProcAddress( "glClientActiveTextureARB" );
if ( qglActiveTextureARB )
{
GLint glint = 0;
qglGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &glint );
glConfig.numTextureUnits = (int) glint;
if ( glConfig.numTextureUnits > 1 )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
}
else
{
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
}
}
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_ARB_multitexture not found\n" );
}
#endif
#ifndef HAVE_GLES
// GL_EXT_compiled_vertex_array
if ( GLimp_HaveExtension( "GL_EXT_compiled_vertex_array" ) )
{
if ( r_ext_compiled_vertex_array->value )
{
ri.Printf( PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n" );
qglLockArraysEXT = ( void ( APIENTRY * )( GLint, GLint ) ) SDL_GL_GetProcAddress( "glLockArraysEXT" );
qglUnlockArraysEXT = ( void ( APIENTRY * )( void ) ) SDL_GL_GetProcAddress( "glUnlockArraysEXT" );
if (!qglLockArraysEXT || !qglUnlockArraysEXT)
{
ri.Error (ERR_FATAL, "bad getprocaddress");
}
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n" );
}
}
else
#endif
{
ri.Printf( PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n" );
}
textureFilterAnisotropic = qfalse;
if ( GLimp_HaveExtension( "GL_EXT_texture_filter_anisotropic" ) )
{
if ( r_ext_texture_filter_anisotropic->integer ) {
qglGetIntegerv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint *)&maxAnisotropy );
if ( maxAnisotropy <= 0 ) {
ri.Printf( PRINT_ALL, "...GL_EXT_texture_filter_anisotropic not properly supported!\n" );
maxAnisotropy = 0;
}
else
{
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_filter_anisotropic (max: %i)\n", maxAnisotropy );
textureFilterAnisotropic = qtrue;
}
}
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" );
}
vertexShaders = qfalse;
#ifndef HAVE_GLES
if ( GLimp_HaveExtension( "GL_ARB_shader_objects" )
&& GLimp_HaveExtension( "GL_ARB_fragment_shader" )
&& GLimp_HaveExtension( "GL_ARB_vertex_shader" )
&& GLimp_HaveExtension( "GL_ARB_shading_language_100" ) )
{
if ( r_ext_vertex_shader->integer ) {
ri.Printf( PRINT_ALL, "...using GL_ARB_vertex_shader\n" );
qglDeleteObjectARB = (GLvoid (APIENTRYP)(GLhandleARB)) SDL_GL_GetProcAddress("glDeleteObjectARB");
qglGetHandleARB = (GLhandleARB (APIENTRYP)(GLenum)) SDL_GL_GetProcAddress("glGetHandleARB");
qglDetachObjectARB = (GLvoid (APIENTRYP)(GLhandleARB, GLhandleARB)) SDL_GL_GetProcAddress("glDetachObjectARB");
qglCreateShaderObjectARB = (GLhandleARB (APIENTRYP)(GLenum)) SDL_GL_GetProcAddress("glCreateShaderObjectARB");
qglShaderSourceARB = (GLvoid (APIENTRYP)(GLhandleARB, GLsizei, const GLcharARB **,
const GLint *)) SDL_GL_GetProcAddress("glShaderSourceARB");
qglCompileShaderARB = (GLvoid (APIENTRYP)(GLhandleARB)) SDL_GL_GetProcAddress("glCompileShaderARB");
qglCreateProgramObjectARB = (GLhandleARB (APIENTRYP)(void)) SDL_GL_GetProcAddress("glCreateProgramObjectARB");
qglAttachObjectARB = (GLvoid (APIENTRYP)(GLhandleARB, GLhandleARB)) SDL_GL_GetProcAddress("glAttachObjectARB");
qglLinkProgramARB = (GLvoid (APIENTRYP)(GLhandleARB)) SDL_GL_GetProcAddress("glLinkProgramARB");
qglUseProgramObjectARB = (GLvoid (APIENTRYP)(GLhandleARB)) SDL_GL_GetProcAddress("glUseProgramObjectARB");
qglValidateProgramARB = (GLvoid (APIENTRYP)(GLhandleARB)) SDL_GL_GetProcAddress("glValidateProgramARB");
qglUniform1fARB = (GLvoid (APIENTRYP)(GLint, GLfloat)) SDL_GL_GetProcAddress("glUniform1fARB");
qglUniform2fARB = (GLvoid (APIENTRYP)(GLint, GLfloat, GLfloat)) SDL_GL_GetProcAddress("glUniform2fARB");
qglUniform3fARB = (GLvoid (APIENTRYP)(GLint, GLfloat, GLfloat, GLfloat)) SDL_GL_GetProcAddress("glUniform3fARB");
qglUniform4fARB = (GLvoid (APIENTRYP)(GLint, GLfloat, GLfloat, GLfloat, GLfloat)) SDL_GL_GetProcAddress("glUniform4fARB");
qglUniform1iARB = (GLvoid (APIENTRYP)(GLint, GLint)) SDL_GL_GetProcAddress("glUniform1iARB");
qglUniform2iARB = (GLvoid (APIENTRYP)(GLint, GLint, GLint)) SDL_GL_GetProcAddress("glUniform2iARB");
qglUniform3iARB = (GLvoid (APIENTRYP)(GLint, GLint, GLint, GLint)) SDL_GL_GetProcAddress("glUniform3iARB");
qglUniform4iARB = (GLvoid (APIENTRYP)(GLint, GLint, GLint, GLint, GLint)) SDL_GL_GetProcAddress("glUniform4iARB");
qglUniform1fvARB = (GLvoid (APIENTRYP)(GLint, GLsizei, const GLfloat *)) SDL_GL_GetProcAddress("glUniform1fvARB");
qglUniform2fvARB = (GLvoid (APIENTRYP)(GLint, GLsizei, const GLfloat *)) SDL_GL_GetProcAddress("glUniform2fvARB");
qglUniform3fvARB = (GLvoid (APIENTRYP)(GLint, GLsizei, const GLfloat *)) SDL_GL_GetProcAddress("glUniform3fvARB");
qglUniform4fvARB = (GLvoid (APIENTRYP)(GLint, GLsizei, const GLfloat *)) SDL_GL_GetProcAddress("glUniform4fvARB");
qglUniform1ivARB = (GLvoid (APIENTRYP)(GLint, GLsizei, const GLint *)) SDL_GL_GetProcAddress("glUniform1ivARB");
qglUniform2ivARB = (GLvoid (APIENTRYP)(GLint, GLsizei, const GLint *)) SDL_GL_GetProcAddress("glUniform2ivARB");
qglUniform3ivARB = (GLvoid (APIENTRYP)(GLint, GLsizei, const GLint *)) SDL_GL_GetProcAddress("glUniform3ivARB");
qglUniform4ivARB = (GLvoid (APIENTRYP)(GLint, GLsizei, const GLint *)) SDL_GL_GetProcAddress("glUniform4ivARB");
qglUniformMatrix2fvARB = (GLvoid (APIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)) SDL_GL_GetProcAddress("glUniformMatrix2fvARB");
qglUniformMatrix3fvARB = (GLvoid (APIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)) SDL_GL_GetProcAddress("glUniformMatrix3fvARB");
qglUniformMatrix4fvARB = (GLvoid (APIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)) SDL_GL_GetProcAddress("glUniformMatrix4fvARB");
qglGetObjectParameterfvARB = (GLvoid (APIENTRYP)(GLhandleARB, GLenum, GLfloat *)) SDL_GL_GetProcAddress("glGetObjectParameterfvARB");
qglGetObjectParameterivARB = (GLvoid (APIENTRYP)(GLhandleARB, GLenum, GLint *)) SDL_GL_GetProcAddress("glGetObjectParameterivARB");
qglGetInfoLogARB = (GLvoid (APIENTRYP)(GLhandleARB, GLsizei, GLsizei *, GLcharARB *)) SDL_GL_GetProcAddress("glGetInfoLogARB");
qglGetAttachedObjectsARB = (GLvoid (APIENTRYP)(GLhandleARB, GLsizei, GLsizei *, GLhandleARB *)) SDL_GL_GetProcAddress("glGetAttachedObjectsARB");
qglGetUniformLocationARB = (GLint (APIENTRYP)(GLhandleARB, const GLcharARB *)) SDL_GL_GetProcAddress("glGetUniformLocationARB");
qglGetActiveUniformARB = (GLvoid (APIENTRYP)(GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *)) SDL_GL_GetProcAddress("glGetActiveUniformARB");
qglGetUniformfvARB = (GLvoid (APIENTRYP)(GLhandleARB, GLint, GLfloat *)) SDL_GL_GetProcAddress("glGetUniformfvARB");
qglGetUniformivARB = (GLvoid (APIENTRYP)(GLhandleARB, GLint, GLint *)) SDL_GL_GetProcAddress("glGetUniformivARB");
qglGetShaderSourceARB = (GLvoid (APIENTRYP)(GLhandleARB, GLsizei, GLsizei *, GLcharARB *)) SDL_GL_GetProcAddress("glGetShaderSourceARB");
qglVertexAttrib1fARB = (GLvoid (APIENTRYP)(GLuint, GLfloat)) SDL_GL_GetProcAddress("glVertexAttrib1fARB");
qglVertexAttrib1sARB = (GLvoid (APIENTRYP)(GLuint, GLshort)) SDL_GL_GetProcAddress("glVertexAttrib1sARB");
qglVertexAttrib1dARB = (GLvoid (APIENTRYP)(GLuint, GLdouble)) SDL_GL_GetProcAddress("glVertexAttrib1dARB");
qglVertexAttrib2fARB = (GLvoid (APIENTRYP)(GLuint, GLfloat, GLfloat)) SDL_GL_GetProcAddress("glVertexAttrib2fARB");
qglVertexAttrib2sARB = (GLvoid (APIENTRYP)(GLuint, GLshort, GLshort)) SDL_GL_GetProcAddress("glVertexAttrib2sARB");
qglVertexAttrib2dARB = (GLvoid (APIENTRYP)(GLuint, GLdouble, GLdouble)) SDL_GL_GetProcAddress("glVertexAttrib2dARB");
qglVertexAttrib3fARB = (GLvoid (APIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat)) SDL_GL_GetProcAddress("glVertexAttrib3fARB");
qglVertexAttrib3sARB = (GLvoid (APIENTRYP)(GLuint, GLshort, GLshort, GLshort)) SDL_GL_GetProcAddress("glVertexAttrib3sARB");
qglVertexAttrib3dARB = (GLvoid (APIENTRYP)(GLuint, GLdouble, GLdouble, GLdouble)) SDL_GL_GetProcAddress("glVertexAttrib3dARB");
qglVertexAttrib4fARB = (GLvoid (APIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat)) SDL_GL_GetProcAddress("glVertexAttrib4fARB");
qglVertexAttrib4sARB = (GLvoid (APIENTRYP)(GLuint, GLshort, GLshort, GLshort, GLshort)) SDL_GL_GetProcAddress("glVertexAttrib4sARB");
qglVertexAttrib4dARB = (GLvoid (APIENTRYP)(GLuint, GLdouble, GLdouble, GLdouble, GLdouble)) SDL_GL_GetProcAddress("glVertexAttrib4dARB");
qglVertexAttrib4NubARB = (GLvoid (APIENTRYP)(GLuint, GLubyte, GLubyte, GLubyte, GLubyte)) SDL_GL_GetProcAddress("glVertexAttrib4NubARB");
qglVertexAttrib1fvARB = (GLvoid (APIENTRYP)(GLuint, GLfloat *)) SDL_GL_GetProcAddress("glVertexAttrib1fvARB");
qglVertexAttrib1svARB = (GLvoid (APIENTRYP)(GLuint, GLshort *)) SDL_GL_GetProcAddress("glVertexAttrib1svARB");
qglVertexAttrib1dvARB = (GLvoid (APIENTRYP)(GLuint, GLdouble *)) SDL_GL_GetProcAddress("glVertexAttrib1dvARB");
qglVertexAttrib2fvARB = (GLvoid (APIENTRYP)(GLuint, GLfloat *)) SDL_GL_GetProcAddress("glVertexAttrib2fvARB");
qglVertexAttrib2svARB = (GLvoid (APIENTRYP)(GLuint, GLshort *)) SDL_GL_GetProcAddress("glVertexAttrib2svARB");
qglVertexAttrib2dvARB = (GLvoid (APIENTRYP)(GLuint, GLdouble *)) SDL_GL_GetProcAddress("glVertexAttrib2dvARB");
qglVertexAttrib3fvARB = (GLvoid (APIENTRYP)(GLuint, GLfloat *)) SDL_GL_GetProcAddress("glVertexAttrib3fvARB");
qglVertexAttrib3svARB = (GLvoid (APIENTRYP)(GLuint, GLshort *)) SDL_GL_GetProcAddress("glVertexAttrib3svARB");
qglVertexAttrib3dvARB = (GLvoid (APIENTRYP)(GLuint, GLdouble *)) SDL_GL_GetProcAddress("glVertexAttrib3dvARB");
qglVertexAttrib4fvARB = (GLvoid (APIENTRYP)(GLuint, GLfloat *)) SDL_GL_GetProcAddress("glVertexAttrib4fvARB");
qglVertexAttrib4svARB = (GLvoid (APIENTRYP)(GLuint, GLshort *)) SDL_GL_GetProcAddress("glVertexAttrib4svARB");
qglVertexAttrib4dvARB = (GLvoid (APIENTRYP)(GLuint, GLdouble *)) SDL_GL_GetProcAddress("glVertexAttrib4dvARB");
qglVertexAttrib4ivARB = (GLvoid (APIENTRYP)(GLuint, GLint *)) SDL_GL_GetProcAddress("glVertexAttrib4ivARB");
qglVertexAttrib4bvARB = (GLvoid (APIENTRYP)(GLuint, GLbyte *)) SDL_GL_GetProcAddress("glVertexAttrib4bvARB");
qglVertexAttrib4ubvARB = (GLvoid (APIENTRYP)(GLuint, GLubyte *)) SDL_GL_GetProcAddress("glVertexAttrib4ubvARB");
qglVertexAttrib4usvARB = (GLvoid (APIENTRYP)(GLuint, GLushort *)) SDL_GL_GetProcAddress("glVertexAttrib4usvARB");
qglVertexAttrib4uivARB = (GLvoid (APIENTRYP)(GLuint, GLuint *)) SDL_GL_GetProcAddress("glVertexAttrib4uivARB");
qglVertexAttrib4NbvARB = (GLvoid (APIENTRYP)(GLuint, const GLbyte *)) SDL_GL_GetProcAddress("glVertexAttrib4NbvARB");
qglVertexAttrib4NsvARB = (GLvoid (APIENTRYP)(GLuint, const GLshort *)) SDL_GL_GetProcAddress("glVertexAttrib4NsvARB");
qglVertexAttrib4NivARB = (GLvoid (APIENTRYP)(GLuint, const GLint *)) SDL_GL_GetProcAddress("glVertexAttrib4NivARB");
qglVertexAttrib4NubvARB = (GLvoid (APIENTRYP)(GLuint, const GLubyte *)) SDL_GL_GetProcAddress("glVertexAttrib4NubvARB");
qglVertexAttrib4NusvARB = (GLvoid (APIENTRYP)(GLuint, const GLushort *)) SDL_GL_GetProcAddress("glVertexAttrib4NusvARB");
qglVertexAttrib4NuivARB = (GLvoid (APIENTRYP)(GLuint, const GLuint *)) SDL_GL_GetProcAddress("glVertexAttrib4NuivARB");
qglVertexAttribPointerARB = (GLvoid (APIENTRYP)(GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *)) SDL_GL_GetProcAddress("glVertexAttribPointerARB");
qglEnableVertexAttribArrayARB = (GLvoid (APIENTRYP)(GLuint)) SDL_GL_GetProcAddress("glEnableVertexAttribArrayARB");
qglDisableVertexAttribArrayARB = (GLvoid (APIENTRYP)(GLuint)) SDL_GL_GetProcAddress("glDisableVertexAttribArrayARB");
qglBindAttribLocationARB = (GLvoid (APIENTRYP)(GLhandleARB, GLuint, const GLcharARB *)) SDL_GL_GetProcAddress("glBindAttribLocationARB");
qglGetActiveAttribARB = (GLvoid (APIENTRYP)(GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *)) SDL_GL_GetProcAddress("glGetActiveAttribARB");
qglGetAttribLocationARB = (GLint (APIENTRYP)(GLhandleARB, const GLcharARB *)) SDL_GL_GetProcAddress("glGetAttribLocationARB");
qglGetVertexAttribdvARB = (GLvoid (APIENTRYP)(GLuint, GLenum, GLdouble *)) SDL_GL_GetProcAddress("glGetVertexAttribdvARB");
qglGetVertexAttribfvARB = (GLvoid (APIENTRYP)(GLuint, GLenum, GLfloat *)) SDL_GL_GetProcAddress("glGetVertexAttribfvARB");
qglGetVertexAttribivARB = (GLvoid (APIENTRYP)(GLuint, GLenum, GLint *)) SDL_GL_GetProcAddress("glGetVertexAAttribivARB");
qglGetVertexAttribPointervARB = (GLvoid (APIENTRYP)(GLuint, GLenum, GLvoid **)) SDL_GL_GetProcAddress("glGetVertexAttribPointervARB");
vertexShaders = qtrue;
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_vertex_shader\n" );
}
}
else
#endif
{
ri.Printf( PRINT_ALL, "...GL_ARB_vertex_shader not found\n" );
}
}
void GLimp_InitExtensions(void)
{
ri.Printf(PRINT_ALL, "Initializing OpenGL extensions\n");
glConfig.textureCompression = TC_NONE;
if (glConfig.textureCompression == TC_NONE)
{
if (GLimp_HaveExtension("GL_S3_s3tc"))
{
if (r_ext_compressed_textures->value)
{
glConfig.textureCompression = TC_S3TC;
ri.Printf(PRINT_ALL, "...using GL_S3_s3tc\n");
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_S3_s3tc\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_S3_s3tc not found\n");
}
}
glConfig.textureEnvAddAvailable = qfalse;
if (GLimp_HaveExtension("EXT_texture_env_add"))
{
if (r_ext_texture_env_add->integer)
{
glConfig.textureEnvAddAvailable = qtrue;
ri.Printf(PRINT_ALL, "...using GL_EXT_texture_env_add\n");
}
else
{
glConfig.textureEnvAddAvailable = qfalse;
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_texture_env_add not found\n");
}
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
if (GLimp_HaveExtension("GL_ARB_multitexture"))
{
if (r_ext_multitexture->value)
{
qglMultiTexCoord2fARB = SDL_GL_GetProcAddress("glMultiTexCoord2fARB");
qglActiveTextureARB = SDL_GL_GetProcAddress("glActiveTextureARB");
qglClientActiveTextureARB = SDL_GL_GetProcAddress("glClientActiveTextureARB");
if (qglActiveTextureARB)
{
GLint glint = 0;
qglGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &glint);
glConfig.maxActiveTextures = (int) glint;
if (glConfig.maxActiveTextures > 1)
{
ri.Printf(PRINT_ALL, "...using GL_ARB_multitexture\n");
}
else
{
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
ri.Printf(PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n");
}
}
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_ARB_multitexture\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_ARB_multitexture not found\n");
}
if (GLimp_HaveExtension("GL_EXT_compiled_vertex_array"))
{
if (r_ext_compiled_vertex_array->value)
{
ri.Printf(PRINT_ALL, "...using GL_EXT_compiled_vertex_array\n");
qglLockArraysEXT = (void (APIENTRY *)(GLint, GLint))SDL_GL_GetProcAddress("glLockArraysEXT");
qglUnlockArraysEXT = (void (APIENTRY *)(void))SDL_GL_GetProcAddress("glUnlockArraysEXT");
if (!qglLockArraysEXT || !qglUnlockArraysEXT)
{
ri.Error(ERR_FATAL, "bad getprocaddress\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...ignoring GL_EXT_compiled_vertex_array\n");
}
}
else
{
ri.Printf(PRINT_ALL, "...GL_EXT_compiled_vertex_array not found\n");
}
}
/*
===============
GLimp_InitExtensions
===============
*/
static void GLimp_InitExtensions( void )
{
if ( !r_allowExtensions->integer )
{
ri.Printf( PRINT_ALL, "* IGNORING OPENGL EXTENSIONS *\n" );
return;
}
ri.Printf( PRINT_ALL, "Initializing OpenGL extensions\n" );
glConfig.textureCompression = TC_NONE;
// GL_EXT_texture_compression_s3tc
if ( GLimp_HaveExtension( "GL_ARB_texture_compression" ) &&
GLimp_HaveExtension( "GL_EXT_texture_compression_s3tc" ) )
{
if ( r_ext_compressed_textures->value )
{
glConfig.textureCompression = TC_S3TC_ARB;
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_S3_s3tc ... legacy extension before GL_EXT_texture_compression_s3tc.
if (glConfig.textureCompression == TC_NONE)
{
if ( GLimp_HaveExtension( "GL_S3_s3tc" ) )
{
if ( r_ext_compressed_textures->value )
{
glConfig.textureCompression = TC_S3TC;
ri.Printf( PRINT_ALL, "...using GL_S3_s3tc\n" );
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_S3_s3tc\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_S3_s3tc not found\n" );
}
}
// GL_EXT_texture_env_add
glConfig.textureEnvAddAvailable = qtrue; //qfalse;
#if 0
if ( GLimp_HaveExtension( "EXT_texture_env_add" ) )
{
if ( r_ext_texture_env_add->integer )
{
glConfig.textureEnvAddAvailable = qtrue;
ri.Printf( PRINT_ALL, "...using GL_EXT_texture_env_add\n" );
}
else
{
glConfig.textureEnvAddAvailable = qfalse;
ri.Printf( PRINT_ALL, "...ignoring GL_EXT_texture_env_add\n" );
}
}
else
{
ri.Printf( PRINT_ALL, "...GL_EXT_texture_env_add not found\n" );
}
#endif
// GL_ARB_multitexture
/*
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
*/
//if ( GLimp_HaveExtension( "GL_ARB_multitexture" ) )
{
if ( r_ext_multitexture->value )
{
qglMultiTexCoord2fARB = qglMultiTexCoord2f;
qglActiveTextureARB = qglActiveTexture;
qglClientActiveTextureARB = qglClientActiveTexture;
if ( qglActiveTextureARB )
{
GLint glint = 0;
qglGetIntegerv( GL_MAX_TEXTURE_UNITS, &glint );
glConfig.numTextureUnits = (int) glint;
if ( glConfig.numTextureUnits > 1 )
{
ri.Printf( PRINT_ALL, "...using GL_ARB_multitexture\n" );
}
else
{
qglMultiTexCoord2fARB = NULL;
qglActiveTextureARB = NULL;
qglClientActiveTextureARB = NULL;
ri.Printf( PRINT_ALL, "...not using GL_ARB_multitexture, < 2 texture units\n" );
}
}
}
else
{
ri.Printf( PRINT_ALL, "...ignoring GL_ARB_multitexture\n" );
}
}
#if 0
else
{
/*
==================
RB_TakeVideoFrameCmd
==================
*/
const void *RB_TakeVideoFrameCmd( const void *data )
{
const videoFrameCommand_t *cmd;
byte *cBuf;
size_t memcount, linelen;
int padwidth, avipadwidth, padlen, avipadlen;
GLint packAlign;
cmd = (const videoFrameCommand_t *)data;
qglGetIntegerv(GL_PACK_ALIGNMENT, &packAlign);
linelen = cmd->width * 3;
// Alignment stuff for glReadPixels
padwidth = PAD(linelen, packAlign);
padlen = padwidth - linelen;
// AVI line padding
avipadwidth = PAD(linelen, AVI_LINE_PADDING);
avipadlen = avipadwidth - linelen;
cBuf = PADP(cmd->captureBuffer, packAlign);
qglReadPixels(0, 0, cmd->width, cmd->height, GL_RGB,
GL_UNSIGNED_BYTE, cBuf);
memcount = padwidth * cmd->height;
// gamma correct
if(glConfig.deviceSupportsGamma)
R_GammaCorrect(cBuf, memcount);
if(cmd->motionJpeg)
{
memcount = RE_SaveJPGToBuffer(cmd->encodeBuffer, linelen * cmd->height,
r_aviMotionJpegQuality->integer,
cmd->width, cmd->height, cBuf, padlen);
ri.CL_WriteAVIVideoFrame(cmd->encodeBuffer, memcount);
}
else
{
byte *lineend, *memend;
byte *srcptr, *destptr;
srcptr = cBuf;
destptr = cmd->encodeBuffer;
memend = srcptr + memcount;
// swap R and B and remove line paddings
while(srcptr < memend)
{
lineend = srcptr + linelen;
while(srcptr < lineend)
{
*destptr++ = srcptr[2];
*destptr++ = srcptr[1];
*destptr++ = srcptr[0];
srcptr += 3;
}
Com_Memset(destptr, '\0', avipadlen);
destptr += avipadlen;
srcptr += padlen;
}
ri.CL_WriteAVIVideoFrame(cmd->encodeBuffer, avipadwidth * cmd->height);
}
return (const void *)(cmd + 1);
}
/*
** GL_SetDefaultState
*/
void GL_SetDefaultState( void ) {
qglClearDepth( 1.0f );
qglCullFace( GL_FRONT );
qglColor4f( 1,1,1,1 );
// initialize downstream texture unit if we're running
// in a multitexture environment
if ( qglActiveTextureARB ) {
GL_SelectTexture( 1 );
GL_TextureMode( r_textureMode->string );
GL_TexEnv( GL_MODULATE );
qglDisable( GL_TEXTURE_2D );
GL_SelectTexture( 0 );
}
qglEnable( GL_TEXTURE_2D );
GL_TextureMode( r_textureMode->string );
GL_TexEnv( GL_MODULATE );
qglShadeModel( GL_SMOOTH );
qglDepthFunc( GL_LEQUAL );
// the vertex array is always enabled, but the color and texture
// arrays are enabled and disabled around the compiled vertex array call
qglEnableClientState( GL_VERTEX_ARRAY );
//
// make sure our GL state vector is set correctly
//
glState.glStateBits = GLS_DEPTHTEST_DISABLE | GLS_DEPTHMASK_TRUE;
#ifdef USE_OPENGLES
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
#else
qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
#endif
qglDepthMask( GL_TRUE );
qglDisable( GL_DEPTH_TEST );
qglEnable( GL_SCISSOR_TEST );
qglDisable( GL_CULL_FACE );
qglDisable( GL_BLEND );
#ifndef USE_OPENGLES
//----(SA) added.
// ATI pn_triangles
if ( qglPNTrianglesiATI ) {
int maxtess;
// get max supported tesselation
qglGetIntegerv( GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI, (GLint*)&maxtess );
glConfig.ATIMaxTruformTess = maxtess;
// cap if necessary
if ( r_ati_truform_tess->value > maxtess ) {
ri.Cvar_Set( "r_ati_truform_tess", va( "%d", maxtess ) );
}
// set Wolf defaults
qglPNTrianglesiATI( GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI, r_ati_truform_tess->value );
}
//----(SA) end
#endif
if ( glConfig.anisotropicAvailable ) {
float maxAnisotropy;
qglGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy );
glConfig.maxAnisotropy = maxAnisotropy;
// set when rendering
// qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, glConfig.maxAnisotropy);
}
}
void GLimp_Init( void )
{
ri->Cvar_Get( "r_restartOnResize", "1", CVAR_ARCHIVE );
ri->Cvar_Get( "r_resizeDelay", "1000", CVAR_ARCHIVE );
r_allowSoftwareGL = ri->Cvar_Get( "r_allowSoftwareGL", "0", CVAR_LATCH );
r_sdlDriver = ri->Cvar_Get( "r_sdlDriver", "", CVAR_ROM );
r_allowResize = ri->Cvar_Get( "r_allowResize", "0", CVAR_ARCHIVE );
/* if( Cvar_VariableIntegerValue( "com_abnormalExit" ) )
{
Cvar_Set( "r_mode", va( "%d", R_MODE_FALLBACK ) );
Cvar_Set( "r_picmap", "1" );
Cvar_Set( "r_texturebits", "0" );
Cvar_Set( "r_textureMode", "GL_LINEAR_MIPMAP_NEAREST" );
Cvar_Set( "r_fullscreen", "0" );
Cvar_Set( "r_centerWindow", "0" );
Cvar_Set( "com_abnormalExit", "0" );
}*/
// Create the window and set up the context
if(GLimp_StartDriverAndSetMode(r_mode->integer, (qboolean)r_fullscreen->integer, (qboolean)r_noborder->integer))
goto success;
// Try again, this time in a platform specific "safe mode"
/* Sys_GLimpSafeInit( );
if(GLimp_StartDriverAndSetMode(r_mode->integer, r_fullscreen->integer, qfalse))
goto success; */
/* // Finally, try the default screen resolution
if( r_mode->integer != R_MODE_FALLBACK )
{
Com_Printf( "Setting r_mode %d failed, falling back on r_mode %d\n",
r_mode->integer, R_MODE_FALLBACK );
if(GLimp_StartDriverAndSetMode(R_MODE_FALLBACK, qfalse, qfalse))
goto success;
}*/
// Nothing worked, give up
Com_Error( ERR_FATAL, "GLimp_Init() - could not load OpenGL subsystem" );
success:
// This values force the UI to disable driver selection
// glConfig.driverType = GLDRV_ICD;
// glConfig.hardwareType = GLHW_GENERIC;
glConfig.deviceSupportsGamma = (qboolean)(!r_ignorehwgamma->integer &&
SDL_SetWindowBrightness( screen, 1.0f ) >= 0);
// get our config strings
glConfig.vendor_string = (const char *) qglGetString (GL_VENDOR);
glConfig.renderer_string = (const char *) qglGetString (GL_RENDERER);
glConfig.version_string = (const char *) qglGetString (GL_VERSION);
glConfig.extensions_string = (const char *) qglGetString (GL_EXTENSIONS);
// OpenGL driver constants
qglGetIntegerv( GL_MAX_TEXTURE_SIZE, &glConfig.maxTextureSize );
// stubbed or broken drivers may have reported 0...
if ( glConfig.maxTextureSize <= 0 )
{
glConfig.maxTextureSize = 0;
}
// initialize extensions
GLimp_InitExtensions( );
ri->Cvar_Get( "r_availableModes", "", CVAR_ROM );
// This depends on SDL_INIT_VIDEO, hence having it here
ri->IN_Init( screen );
}
