/*
** 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;
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglDepthMask( GL_TRUE );
qglDisable( GL_DEPTH_TEST );
qglEnable( GL_SCISSOR_TEST );
qglDisable( GL_CULL_FACE );
qglDisable( GL_BLEND );
qglColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
qglClearDepth( 1.0 );
qglDrawBuffer( GL_FRONT );
#ifdef IOS
qglClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
#else
qglClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ACCUM_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
#endif
qglDrawBuffer( GL_BACK );
#ifdef IOS
qglClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
#else
qglClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ACCUM_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
#endif
}
/*
** 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 );
//
// make sure our GL state vector is set correctly
//
glState.glStateBits = GLS_DEPTHTEST_DISABLE | GLS_DEPTHMASK_TRUE;
glState.vertexAttribsState = 0;
glState.vertexAttribPointersSet = 0;
glState.currentProgram = 0;
qglUseProgramObjectARB(0);
qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
glState.currentVBO = NULL;
glState.currentIBO = NULL;
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglDepthMask( GL_TRUE );
qglDisable( GL_DEPTH_TEST );
qglEnable( GL_SCISSOR_TEST );
qglDisable( GL_CULL_FACE );
qglDisable( GL_BLEND );
qglColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f );
qglClearDepth( 1.0 );
qglDrawBuffer( GL_FRONT );
qglClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ACCUM_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
qglDrawBuffer( GL_BACK );
qglClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ACCUM_BUFFER_BIT|GL_STENCIL_BUFFER_BIT );
}
/*
======================
RB_SetDefaultGLState
This should initialize all GL state that any part of the entire program
may touch, including the editor.
======================
*/
void RB_SetDefaultGLState( void ) {
int i;
RB_LogComment( "--- R_SetDefaultGLState ---\n" );
qglClearDepth( 1.0f );
qglColor4f (1,1,1,1);
// the vertex array is always enabled
qglEnableClientState( GL_VERTEX_ARRAY );
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
qglDisableClientState( GL_COLOR_ARRAY );
//
// make sure our GL state vector is set correctly
//
memset( &backEnd.glState, 0, sizeof( backEnd.glState ) );
backEnd.glState.forceGlState = true;
qglColorMask( 1, 1, 1, 1 );
qglEnable( GL_DEPTH_TEST );
qglEnable( GL_BLEND );
qglEnable( GL_SCISSOR_TEST );
qglEnable( GL_CULL_FACE );
qglDisable( GL_LIGHTING );
qglDisable( GL_LINE_STIPPLE );
qglDisable( GL_STENCIL_TEST );
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglDepthMask( GL_TRUE );
qglDepthFunc( GL_ALWAYS );
qglCullFace( GL_FRONT_AND_BACK );
qglShadeModel( GL_SMOOTH );
if ( r_useScissor.GetBool() ) {
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
}
for ( i = glConfig.maxTextureUnits - 1 ; i >= 0 ; i-- ) {
GL_SelectTexture( i );
// object linear texgen is our default
qglTexGenf( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
qglTexGenf( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
qglTexGenf( GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
qglTexGenf( GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
GL_TexEnv( GL_MODULATE );
qglDisable( GL_TEXTURE_2D );
if ( glConfig.texture3DAvailable ) {
qglDisable( GL_TEXTURE_3D );
}
if ( glConfig.cubeMapAvailable ) {
qglDisable( GL_TEXTURE_CUBE_MAP_EXT );
}
}
}
/*
** 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 );
//
// make sure our GL state vector is set correctly
//
glState.glStateBits = GLS_DEPTHTEST_DISABLE | GLS_DEPTHMASK_TRUE;
glState.storedGlState = 0;
glState.faceCulling = CT_TWO_SIDED;
glState.faceCullFront = qtrue;
glState.currentProgram = 0;
qglUseProgramObjectARB(0);
if (glRefConfig.vertexArrayObject)
qglBindVertexArrayARB(0);
qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
glState.currentVao = NULL;
glState.vertexAttribsEnabled = 0;
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglDepthMask( GL_TRUE );
qglDisable( GL_DEPTH_TEST );
qglEnable( GL_SCISSOR_TEST );
qglDisable( GL_CULL_FACE );
qglDisable( GL_BLEND );
if (glRefConfig.seamlessCubeMap)
qglEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
// GL_POLYGON_OFFSET_FILL will be glEnable()d when this is used
qglPolygonOffset( r_offsetFactor->value, r_offsetUnits->value );
qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); // FIXME: get color of sky
}
/*
** 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;
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglDepthMask( GL_TRUE );
qglDisable( GL_DEPTH_TEST );
qglEnable( GL_SCISSOR_TEST );
qglDisable( GL_CULL_FACE );
qglDisable( GL_BLEND );
#ifdef _NPATCH
// If n-patches are supported, make sure they are disabled for now
// Set the initial tesselation level and the interpolation modes
if ( qglPNTrianglesiATI )
{
qglDisable( GL_PN_TRIANGLES_ATI );
qglPNTrianglesiATI( GL_PN_TRIANGLES_POINT_MODE_ATI, GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI );
qglPNTrianglesiATI( GL_PN_TRIANGLES_NORMAL_MODE_ATI, GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI );
qglPNTrianglesiATI( GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI, 3 );
}
#endif // _NPATCH
}
/*
** 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;
glState.vertexAttribsState = 0;
glState.vertexAttribPointersSet = 0;
glState.currentProgram = 0;
qglUseProgramObjectARB(0);
qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
qglBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
glState.currentVBO = NULL;
glState.currentIBO = NULL;
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglDepthMask(GL_TRUE);
qglDisable(GL_DEPTH_TEST);
qglEnable(GL_SCISSOR_TEST);
qglDisable(GL_CULL_FACE);
qglDisable(GL_BLEND);
}
/*
** GL_SetDefaultState
*/
void GL_SetDefaultState( void )
{
qglClearDepth( 1.0f );
qglCullFace(GL_FRONT);
qglColor4f (1,1,1,1);
GL_BindNullTextures();
if (glRefConfig.framebufferObject)
GL_BindNullFramebuffers();
qglEnable(GL_TEXTURE_2D);
GL_TextureMode( r_textureMode->string );
//qglShadeModel( GL_SMOOTH );
qglDepthFunc( GL_LEQUAL );
//
// make sure our GL state vector is set correctly
//
glState.glStateBits = GLS_DEPTHTEST_DISABLE | GLS_DEPTHMASK_TRUE;
glState.storedGlState = 0;
glState.faceCulling = CT_TWO_SIDED;
glState.faceCullFront = qtrue;
GL_BindNullProgram();
if (glRefConfig.vertexArrayObject)
qglBindVertexArray(0);
qglBindBuffer(GL_ARRAY_BUFFER, 0);
qglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glState.currentVao = NULL;
glState.vertexAttribsEnabled = 0;
qglPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
qglDepthMask( GL_TRUE );
qglDisable( GL_DEPTH_TEST );
qglEnable( GL_SCISSOR_TEST );
qglDisable( GL_CULL_FACE );
qglDisable( GL_BLEND );
if (glRefConfig.seamlessCubeMap)
qglEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
// GL_POLYGON_OFFSET_FILL will be glEnable()d when this is used
qglPolygonOffset( r_offsetFactor->value, r_offsetUnits->value );
qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); // FIXME: get color of sky
}
/*
==================
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;
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
//*SEB* ? not the best place !
glLockArraysEXT = NULL;
glUnlockArraysEXT = NULL;
qglDepthMask(GL_TRUE);
qglDisable(GL_DEPTH_TEST);
qglEnable(GL_SCISSOR_TEST);
qglDisable(GL_CULL_FACE);
qglDisable(GL_BLEND);
}
/*
** 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);
}
}
/*
* RB_ClearDepth
*/
void RB_ClearDepth( float depth )
{
qglClearDepth( depth );
}
/*
==================
GL_Setup3D
TODO: time is messed up
==================
*/
void GL_Setup3D (int time){
double clipPlane[4];
QGL_LogPrintf("---------- RB_Setup3D ----------\n");
backEnd.projection2D = false;
backEnd.time = time;
backEnd.floatTime = MS2SEC(Sys_Milliseconds());
backEnd.viewport.x = backEnd.viewParms.viewport.x;
backEnd.viewport.y = backEnd.viewParms.viewport.y;
backEnd.viewport.width = backEnd.viewParms.viewport.width;
backEnd.viewport.height = backEnd.viewParms.viewport.height;
backEnd.scissor.x = backEnd.viewParms.scissor.x;
backEnd.scissor.y = backEnd.viewParms.scissor.y;
backEnd.scissor.width = backEnd.viewParms.scissor.width;
backEnd.scissor.height = backEnd.viewParms.scissor.height;
backEnd.coordScale[0] = 1.0f / backEnd.viewport.width;
backEnd.coordScale[1] = 1.0f / backEnd.viewport.height;
backEnd.coordBias[0] = -backEnd.viewport.x * backEnd.coordScale[0];
backEnd.coordBias[1] = -backEnd.viewport.y * backEnd.coordScale[1];
backEnd.depthFilling = false;
backEnd.debugRendering = false;
backEnd.currentColorCaptured = SORT_BAD;
backEnd.currentDepthCaptured = false;
// Set up the viewport
GL_Viewport(backEnd.viewport);
// Set up the scissor
GL_Scissor(backEnd.viewport);
// Set up the depth bounds
if (glConfig.depthBoundsTestAvailable)
GL_DepthBounds(0.0f, 1.0f);
// Set the projection matrix
GL_LoadMatrix(GL_PROJECTION, backEnd.viewParms.projectionMatrix);
// Set the modelview matrix
GL_LoadIdentity(GL_MODELVIEW);
// Set the GL state
GL_PolygonMode(GL_FILL);
GL_Disable(GL_CULL_FACE);
GL_Disable(GL_POLYGON_OFFSET_FILL);
GL_Disable(GL_BLEND);
GL_Disable(GL_ALPHA_TEST);
GL_Disable(GL_DEPTH_TEST);
GL_Disable(GL_STENCIL_TEST);
GL_DepthRange(0.0f, 1.0f);
GL_ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
GL_DepthMask(GL_TRUE);
GL_StencilMask(255);
// Enable the clip plane if needed
if (backEnd.viewParms.viewType != VIEW_MIRROR)
qglDisable(GL_CLIP_PLANE0);
else {
clipPlane[0] = -DotProduct(backEnd.viewParms.axis[1], backEnd.viewParms.clipPlane.normal);
clipPlane[1] = DotProduct(backEnd.viewParms.axis[2], backEnd.viewParms.clipPlane.normal);
clipPlane[2] = -DotProduct(backEnd.viewParms.axis[0], backEnd.viewParms.clipPlane.normal);
clipPlane[3] = DotProduct(backEnd.viewParms.origin, backEnd.viewParms.clipPlane.normal) - backEnd.viewParms.clipPlane.dist;
qglEnable(GL_CLIP_PLANE0);
qglClipPlane(GL_CLIP_PLANE0, clipPlane);
}
// Enable multisampling if available
if (glConfig.multiSamples > 1)
qglEnable(GL_MULTISAMPLE);
// Clear the buffers
qglClearColor(0.0f, 0.0f, 0.0f, 1.0f);
qglClearDepth(1.0f);
qglClearStencil(0);
if (backEnd.viewParms.primaryView)
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
else
qglClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// Check for errors
if (!r_ignoreGLErrors->integerValue)
GL_CheckForErrors();
QGL_LogPrintf("--------------------\n");
}
/*
==================
GL_SetDefaultState
==================
*/
void GL_SetDefaultState (){
int i;
QGL_LogPrintf("---------- GL_SetDefaultState ----------\n");
// Reset the state manager
glState.projectionMatrixIdentity = true;
glState.modelviewMatrixIdentity = true;
for (i = 0; i < MAX_TEXTURE_UNITS; i++)
glState.textureMatrixIdentity[i] = true;
for (i = 0; i < MAX_TEXTURE_UNITS; i++)
glState.texture[i] = NULL;
glState.program = NULL;
glState.indexBuffer = NULL;
glState.vertexBuffer = NULL;
glState.viewportX = 0;
glState.viewportY = 0;
glState.viewportWidth = glConfig.videoWidth;
glState.viewportHeight = glConfig.videoHeight;
glState.scissorX = 0;
glState.scissorY = 0;
glState.scissorWidth = glConfig.videoWidth;
glState.scissorHeight = glConfig.videoHeight;
glState.depthBoundsMin = 0.0f;
glState.depthBoundsMax = 1.0f;
glState.texUnit = 0;
for (i = 0; i < MAX_TEXTURE_UNITS; i++){
glState.texTarget[i] = 0;
glState.texEnv[i] = GL_MODULATE;
glState.texGen[i][0] = GL_OBJECT_LINEAR;
glState.texGen[i][1] = GL_OBJECT_LINEAR;
glState.texGen[i][2] = GL_OBJECT_LINEAR;
glState.texGen[i][3] = GL_OBJECT_LINEAR;
}
glState.cullFace = false;
glState.polygonOffsetFill = false;
glState.polygonOffsetLine = false;
glState.blend = false;
glState.alphaTest = false;
glState.depthTest = false;
glState.stencilTest = false;
for (i = 0; i < MAX_TEXTURE_UNITS; i++){
glState.textureGen[i][0] = false;
glState.textureGen[i][1] = false;
glState.textureGen[i][2] = false;
glState.textureGen[i][3] = false;
}
glState.cullMode = GL_FRONT;
glState.polygonMode = GL_FILL;
glState.polygonOffsetFactor = 0.0f;
glState.polygonOffsetUnits = 0.0f;
glState.blendSrc = GL_ONE;
glState.blendDst = GL_ZERO;
glState.blendMode = GL_FUNC_ADD;
glState.alphaFunc = GL_GREATER;
glState.alphaFuncRef = 0.0f;
glState.depthFunc = GL_LEQUAL;
glState.stencilFunc[0] = GL_ALWAYS;
glState.stencilFunc[1] = GL_ALWAYS;
glState.stencilFuncRef[0] = 0;
glState.stencilFuncRef[1] = 0;
glState.stencilFuncMask[0] = 255;
glState.stencilFuncMask[1] = 255;
glState.stencilOpFail[0] = GL_KEEP;
glState.stencilOpFail[1] = GL_KEEP;
glState.stencilOpZFail[0] = GL_KEEP;
glState.stencilOpZFail[1] = GL_KEEP;
glState.stencilOpZPass[0] = GL_KEEP;
glState.stencilOpZPass[1] = GL_KEEP;
glState.depthMin = 0.0f;
glState.depthMax = 1.0f;
glState.colorMask[0] = GL_TRUE;
glState.colorMask[1] = GL_TRUE;
glState.colorMask[2] = GL_TRUE;
glState.colorMask[3] = GL_TRUE;
glState.depthMask = GL_TRUE;
glState.stencilMask[0] = 255;
glState.stencilMask[1] = 255;
// Set default state
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
for (i = MAX_TEXTURE_UNITS - 1; i >= 0; i--){
if (i >= glConfig.maxTextureImageUnits)
continue;
if (i >= glConfig.maxTextureUnits){
qglActiveTexture(GL_TEXTURE0 + i);
qglBindTexture(GL_TEXTURE_2D, 0);
qglBindTexture(GL_TEXTURE_3D, 0);
qglBindTexture(GL_TEXTURE_CUBE_MAP, 0);
qglBindTexture(GL_TEXTURE_2D_ARRAY, 0);
continue;
}
qglActiveTexture(GL_TEXTURE0 + i);
qglMatrixMode(GL_TEXTURE);
qglLoadIdentity();
qglDisable(GL_TEXTURE_2D);
qglDisable(GL_TEXTURE_3D);
qglDisable(GL_TEXTURE_CUBE_MAP);
qglDisable(GL_TEXTURE_2D_ARRAY);
qglBindTexture(GL_TEXTURE_2D, 0);
qglBindTexture(GL_TEXTURE_3D, 0);
qglBindTexture(GL_TEXTURE_CUBE_MAP, 0);
qglBindTexture(GL_TEXTURE_2D_ARRAY, 0);
qglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
qglDisable(GL_TEXTURE_GEN_S);
qglDisable(GL_TEXTURE_GEN_T);
qglDisable(GL_TEXTURE_GEN_R);
qglDisable(GL_TEXTURE_GEN_Q);
qglTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
qglTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
qglTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
qglTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
}
qglDisable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
qglUseProgram(0);
qglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
qglBindBuffer(GL_ARRAY_BUFFER, 0);
qglViewport(0, 0, glConfig.videoWidth, glConfig.videoHeight);
qglEnable(GL_SCISSOR_TEST);
qglScissor(0, 0, glConfig.videoWidth, glConfig.videoHeight);
qglEnable(GL_DEPTH_BOUNDS_TEST_EXT);
qglDepthBoundsEXT(0.0f, 1.0f);
qglFrontFace(GL_CCW);
qglShadeModel(GL_SMOOTH);
qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
qglDisable(GL_CULL_FACE);
qglCullFace(GL_FRONT);
qglDisable(GL_POLYGON_OFFSET_FILL);
qglDisable(GL_POLYGON_OFFSET_LINE);
qglPolygonOffset(0.0f, 0.0f);
qglDisable(GL_BLEND);
qglBlendFunc(GL_ONE, GL_ZERO);
qglBlendEquation(GL_FUNC_ADD);
qglDisable(GL_ALPHA_TEST);
qglAlphaFunc(GL_GREATER, 0.0f);
qglDisable(GL_DEPTH_TEST);
qglDepthFunc(GL_LEQUAL);
qglDisable(GL_STENCIL_TEST);
qglStencilFunc(GL_ALWAYS, 128, 255);
qglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
qglDepthRange(0.0f, 1.0f);
qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
qglDepthMask(GL_TRUE);
qglStencilMask(255);
qglDisable(GL_DEPTH_CLAMP);
qglDisable(GL_CLIP_PLANE0);
if (glConfig.multiSamples > 1){
qglDisable(GL_MULTISAMPLE);
qglDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
}
qglClearColor(0.0f, 0.0f, 0.0f, 1.0f);
qglClearDepth(1.0f);
qglClearStencil(128);
qglEnableClientState(GL_VERTEX_ARRAY);
qglDisableVertexAttribArray(GL_ATTRIB_NORMAL);
qglDisableVertexAttribArray(GL_ATTRIB_TANGENT1);
qglDisableVertexAttribArray(GL_ATTRIB_TANGENT2);
qglDisableVertexAttribArray(GL_ATTRIB_TEXCOORD);
qglDisableVertexAttribArray(GL_ATTRIB_COLOR);
QGL_LogPrintf("--------------------\n");
}
