state.c File Reference

#include "gl.h"
#include "arbfp.h"

Go to the source code of this file.

Functions
void	GL_ForceTexture (GLuint tmu, GLuint texnum)
void	GL_BindTexture (GLuint tmu, GLuint texnum)
void	GL_StateBits (glStateBits_t bits)
void	GL_ArrayBits (glArrayBits_t bits)
void	GL_Ortho (GLfloat xmin, GLfloat xmax, GLfloat ymin, GLfloat ymax, GLfloat znear, GLfloat zfar)
void	GL_Setup2D (void)
static void	GL_Frustum (void)
static void	GL_RotateForViewer (void)
void	GL_Setup3D (void)
void	GL_SetDefaultState (void)
byte *	IMG_ReadPixels_GL (int *width, int *height, int *rowbytes)
void	GL_EnableOutlines (void)
void	GL_DisableOutlines (void)
void	GL_InitPrograms (void)
void	GL_ShutdownPrograms (void)

Variables
glState_t	gls

Function Documentation

GL_ArrayBits()

void GL_ArrayBits

(

glArrayBits_t

bits

)

Definition at line 185 of file state.c.

{
    glArrayBits_t diff = bits ^ gls.array_bits;
 
    if (!diff) {
        return;
    }
 
    if (diff & GLA_VERTEX) {
        if (bits & GLA_VERTEX) {
            qglEnableClientState(GL_VERTEX_ARRAY);
        } else {
            qglDisableClientState(GL_VERTEX_ARRAY);
        }
    }
 
    if (diff & GLA_TC) {
        GL_ClientActiveTexture(0);
        if (bits & GLA_TC) {
            qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
        } else {
            qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
        }
    }
 
    if (diff & GLA_LMTC) {
        GL_ClientActiveTexture(1);
        if (bits & GLA_LMTC) {
            qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
        } else {
            qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
        }
    }
 
    if (diff & GLA_COLOR) {
        if (bits & GLA_COLOR) {
            qglEnableClientState(GL_COLOR_ARRAY);
        } else {
            qglDisableClientState(GL_COLOR_ARRAY);
        }
    }
 
    gls.array_bits = bits;
}

Referenced by draw_alias_mesh(), draw_celshading(), draw_shadow(), GL_DrawBeams(), GL_DrawNullModel(), GL_DrawParticles(), GL_EnableOutlines(), GL_Flush2D(), GL_Flush3D(), and R_DrawSkyBox().

GL_BindTexture()

void GL_BindTexture	(	GLuint	tmu,
		GLuint	texnum
	)

Definition at line 40 of file state.c.

{
#ifdef _DEBUG
    if (gl_nobind->integer && !tmu) {
        texnum = TEXNUM_DEFAULT;
    }
#endif
 
    if (gls.texnums[tmu] == texnum) {
        return;
    }
 
    GL_ActiveTexture(tmu);
 
    qglBindTexture(GL_TEXTURE_2D, texnum);
    gls.texnums[tmu] = texnum;
 
    c.texSwitches++;
}

Referenced by draw_alias_mesh(), draw_celshading(), draw_shadow(), GL_DrawBeams(), GL_DrawNullModel(), GL_DrawParticles(), GL_EnableOutlines(), GL_Flush2D(), GL_Flush3D(), and R_DrawSkyBox().

GL_DisableOutlines()

void GL_DisableOutlines

(

void

)

Definition at line 471 of file state.c.

{
    qglDepthRange(0, 1);
    qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

Referenced by draw_alias_mesh(), GL_DrawParticles(), GL_Flush2D(), and GL_Flush3D().

GL_EnableOutlines()

void GL_EnableOutlines

(

void

)

Definition at line 460 of file state.c.

{
    GL_BindTexture(0, TEXNUM_WHITE);
    GL_StateBits(GLS_DEFAULT);
    GL_ArrayBits(GLA_VERTEX);
    qglColor4f(1, 1, 1, 1);
 
    qglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    qglDepthRange(0, 0);
}

Referenced by draw_alias_mesh(), GL_DrawParticles(), GL_Flush2D(), and GL_Flush3D().

GL_ForceTexture()

void GL_ForceTexture	(	GLuint	tmu,
		GLuint	texnum
	)

Definition at line 25 of file state.c.

{
    GL_ActiveTexture(tmu);
 
    if (gls.texnums[tmu] == texnum) {
        return;
    }
 
    qglBindTexture(GL_TEXTURE_2D, texnum);
    gls.texnums[tmu] = texnum;
 
    c.texSwitches++;
}

Referenced by gl_anisotropy_changed(), gl_bilerp_chars_changed(), gl_bilerp_pics_changed(), GL_InitBeamTexture(), GL_InitDefaultTexture(), GL_InitParticleTexture(), GL_InitWhiteImage(), gl_texturemode_changed(), IMG_Load_GL(), LM_RebuildSurfaces(), LM_UploadBlock(), Scrap_Upload(), and update_dynamic_lightmap().

GL_Frustum()

static void GL_Frustum ( void  )

static

Definition at line 282 of file state.c.

{
    GLfloat xmin, xmax, ymin, ymax, zfar, znear;
    GLfloat width, height, depth;
    GLfloat matrix[16];
 
    znear = gl_znear->value;
 
    if (glr.fd.rdflags & RDF_NOWORLDMODEL)
        zfar = 2048;
    else
        zfar = gl_static.world.size * 2;
 
    ymax = znear * tan(glr.fd.fov_y * M_PI / 360.0);
    ymin = -ymax;
 
    xmax = znear * tan(glr.fd.fov_x * M_PI / 360.0);
    xmin = -xmax;
 
    width = xmax - xmin;
    height = ymax - ymin;
    depth = zfar - znear;
 
    matrix[0] = 2 * znear / width;
    matrix[4] = 0;
    matrix[8] = (xmax + xmin) / width;
    matrix[12] = 0;
 
    matrix[1] = 0;
    matrix[5] = 2 * znear / height;
    matrix[9] = (ymax + ymin) / height;
    matrix[13] = 0;
 
    matrix[2] = 0;
    matrix[6] = 0;
    matrix[10] = -(zfar + znear) / depth;
    matrix[14] = -2 * zfar * znear / depth;
 
    matrix[3] = 0;
    matrix[7] = 0;
    matrix[11] = -1;
    matrix[15] = 0;
 
    qglMatrixMode(GL_PROJECTION);
    qglLoadMatrixf(matrix);
}

Referenced by GL_Setup3D().

GL_InitPrograms()

void GL_InitPrograms

(

void

)

Definition at line 477 of file state.c.

{
#ifdef GL_ARB_fragment_program
    GLuint prog = 0;
 
    if (gl_config.ext_supported & QGL_ARB_fragment_program) {
        if (gl_fragment_program->integer) {
            Com_Printf("...enabling GL_ARB_fragment_program\n");
            QGL_InitExtensions(QGL_ARB_fragment_program);
            gl_config.ext_enabled |= QGL_ARB_fragment_program;
        } else {
            Com_Printf("...ignoring GL_ARB_fragment_program\n");
        }
    } else if (gl_fragment_program->integer) {
        Com_Printf("GL_ARB_fragment_program not found\n");
        Cvar_Set("gl_fragment_program", "0");
    }
 
    if (!qglGenProgramsARB || !qglBindProgramARB ||
        !qglProgramStringARB || !qglDeleteProgramsARB) {
        return;
    }
 
    QGL_ClearErrors();
 
    qglGenProgramsARB(1, &prog);
    qglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog);
    qglProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
                        sizeof(gl_prog_warp) - 1, gl_prog_warp);
 
    if (GL_ShowErrors("Failed to initialize fragment program")) {
        qglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0);
        qglDeleteProgramsARB(1, &prog);
        return;
    }
 
    qglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0);
    gl_static.prognum_warp = prog;
#endif
}

Referenced by R_EndFrame_GL(), and R_Init_GL().

GL_Ortho()

void GL_Ortho	(	GLfloat	xmin,
		GLfloat	xmax,
		GLfloat	ymin,
		GLfloat	ymax,
		GLfloat	znear,
		GLfloat	zfar
	)

Definition at line 230 of file state.c.

{
    GLfloat width, height, depth;
    GLfloat matrix[16];
 
    width = xmax - xmin;
    height = ymax - ymin;
    depth = zfar - znear;
 
    matrix[0] = 2 / width;
    matrix[4] = 0;
    matrix[8] = 0;
    matrix[12] = -(xmax + xmin) / width;
 
    matrix[1] = 0;
    matrix[5] = 2 / height;
    matrix[9] = 0;
    matrix[13] = -(ymax + ymin) / height;
 
    matrix[2] = 0;
    matrix[6] = 0;
    matrix[10] = -2 / depth;
    matrix[14] = -(zfar + znear) / depth;
 
    matrix[3] = 0;
    matrix[7] = 0;
    matrix[11] = 0;
    matrix[15] = 1;
 
    qglMatrixMode(GL_PROJECTION);
    qglLoadMatrixf(matrix);
}

Referenced by GL_Setup2D(), and R_SetScale_GL().

GL_RotateForViewer()

static void GL_RotateForViewer ( void  )

static

Definition at line 329 of file state.c.

{
    GLfloat *matrix = glr.viewmatrix;
 
    AnglesToAxis(glr.fd.viewangles, glr.viewaxis);
 
    matrix[0] = -glr.viewaxis[1][0];
    matrix[4] = -glr.viewaxis[1][1];
    matrix[8] = -glr.viewaxis[1][2];
    matrix[12] = DotProduct(glr.viewaxis[1], glr.fd.vieworg);
 
    matrix[1] = glr.viewaxis[2][0];
    matrix[5] = glr.viewaxis[2][1];
    matrix[9] = glr.viewaxis[2][2];
    matrix[13] = -DotProduct(glr.viewaxis[2], glr.fd.vieworg);
 
    matrix[2] = -glr.viewaxis[0][0];
    matrix[6] = -glr.viewaxis[0][1];
    matrix[10] = -glr.viewaxis[0][2];
    matrix[14] = DotProduct(glr.viewaxis[0], glr.fd.vieworg);
 
    matrix[3] = 0;
    matrix[7] = 0;
    matrix[11] = 0;
    matrix[15] = 1;
 
    qglMatrixMode(GL_MODELVIEW);
    qglLoadMatrixf(matrix);
 
    // forced matrix upload
    gls.currentmatrix = matrix;
}

Referenced by GL_Setup3D().

GL_SetDefaultState()

void GL_SetDefaultState

(

void

)

Definition at line 377 of file state.c.

{
    qglClearColor(0, 0, 0, 1);
    qglClearDepth(1);
    qglClearStencil(0);
 
    qglEnable(GL_DEPTH_TEST);
    qglDepthFunc(GL_LEQUAL);
    qglDepthRange(0, 1);
    qglDepthMask(GL_TRUE);
    qglDisable(GL_BLEND);
    qglDisable(GL_ALPHA_TEST);
    qglAlphaFunc(GL_GREATER, 0.666f);
    qglPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    qglFrontFace(GL_CW);
    qglCullFace(GL_BACK);
    qglEnable(GL_CULL_FACE);
    qglShadeModel(GL_FLAT);
 
    if (qglActiveTextureARB && qglClientActiveTextureARB) {
        qglActiveTextureARB(GL_TEXTURE1_ARB);
        qglBindTexture(GL_TEXTURE_2D, 0);
        qglDisable(GL_TEXTURE_2D);
        qglClientActiveTextureARB(GL_TEXTURE1_ARB);
        qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
 
        qglActiveTextureARB(GL_TEXTURE0_ARB);
        qglBindTexture(GL_TEXTURE_2D, 0);
        qglEnable(GL_TEXTURE_2D);
        qglClientActiveTextureARB(GL_TEXTURE0_ARB);
        qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
    } else {
        qglBindTexture(GL_TEXTURE_2D, 0);
        qglEnable(GL_TEXTURE_2D);
        qglDisableClientState(GL_TEXTURE_COORD_ARRAY);
    }
 
    qglMatrixMode(GL_TEXTURE);
    qglLoadIdentity();
    qglMatrixMode(GL_MODELVIEW);
 
    qglDisableClientState(GL_VERTEX_ARRAY);
    qglDisableClientState(GL_COLOR_ARRAY);
 
    qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | gl_static.stencil_buffer_bit);
 
    memset(&gls, 0, sizeof(gls));
}

Referenced by GL_PostInit().

GL_Setup2D()

void GL_Setup2D

(

void

)

Definition at line 263 of file state.c.

{
    qglViewport(0, 0, r_config.width, r_config.height);
 
    GL_Ortho(0, r_config.width, r_config.height, 0, -1, 1);
    draw.scale = 1;
 
    draw.colors[0].u32 = U32_WHITE;
    draw.colors[1].u32 = U32_WHITE;
 
    if (draw.scissor) {
        qglDisable(GL_SCISSOR_TEST);
        draw.scissor = qfalse;
    }
 
    qglMatrixMode(GL_MODELVIEW);
    qglLoadIdentity();
}

Referenced by R_BeginFrame_GL(), and R_RenderFrame_GL().

GL_Setup3D()

void GL_Setup3D

(

void

)

Definition at line 362 of file state.c.

{
    qglViewport(glr.fd.x, r_config.height - (glr.fd.y + glr.fd.height),
                glr.fd.width, glr.fd.height);
 
    GL_Frustum();
 
    GL_RotateForViewer();
 
    // enable depth writes before clearing
    GL_StateBits(GLS_DEFAULT);
 
    qglClear(GL_DEPTH_BUFFER_BIT | gl_static.stencil_buffer_bit);
}

Referenced by R_RenderFrame_GL().

GL_ShutdownPrograms()

void GL_ShutdownPrograms

(

void

)

Definition at line 518 of file state.c.

{
#ifdef GL_ARB_fragment_program
    if (!qglDeleteProgramsARB) {
        return;
    }
 
    if (gl_static.prognum_warp) {
        qglDeleteProgramsARB(1, &gl_static.prognum_warp);
        gl_static.prognum_warp = 0;
    }
 
    QGL_ShutdownExtensions(QGL_ARB_fragment_program);
    gl_config.ext_enabled &= ~QGL_ARB_fragment_program;
#endif
}

Referenced by R_EndFrame_GL(), and R_Shutdown_GL().

GL_StateBits()

void GL_StateBits

(

glStateBits_t

bits

)

Definition at line 60 of file state.c.

{
    glStateBits_t diff = bits ^ gls.state_bits;
 
    if (!diff) {
        return;
    }
 
    if (diff & GLS_BLEND_MASK) {
        if (bits & GLS_BLEND_MASK) {
            qglEnable(GL_BLEND);
            if (bits & GLS_BLEND_BLEND) {
                qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            } else if (bits & GLS_BLEND_ADD) {
                qglBlendFunc(GL_SRC_ALPHA, GL_ONE);
            } else if (bits & GLS_BLEND_MODULATE) {
                qglBlendFunc(GL_DST_COLOR, GL_ONE);
            }
        } else {
            qglDisable(GL_BLEND);
        }
    }
 
    if (diff & GLS_DEPTHMASK_FALSE) {
        if (bits & GLS_DEPTHMASK_FALSE) {
            qglDepthMask(GL_FALSE);
        } else {
            qglDepthMask(GL_TRUE);
        }
    }
 
    if (diff & GLS_DEPTHTEST_DISABLE) {
        if (bits & GLS_DEPTHTEST_DISABLE) {
            qglDisable(GL_DEPTH_TEST);
        } else {
            qglEnable(GL_DEPTH_TEST);
        }
    }
 
    if (diff & GLS_ALPHATEST_ENABLE) {
        if (bits & GLS_ALPHATEST_ENABLE) {
            qglEnable(GL_ALPHA_TEST);
        } else {
            qglDisable(GL_ALPHA_TEST);
        }
    }
 
    if (diff & GLS_TEXTURE_REPLACE) {
        GL_ActiveTexture(0);
        if (bits & GLS_TEXTURE_REPLACE) {
            qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
        } else {
            qglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        }
    }
 
    if (diff & GLS_FLOW_ENABLE) {
        GL_ActiveTexture(0);
        qglMatrixMode(GL_TEXTURE);
 
        if (bits & GLS_FLOW_ENABLE) {
            float scaled, scroll;
 
            if (bits & GLS_WARP_ENABLE) {
                scaled = glr.fd.time * 0.5f;
                scroll = -scaled;
            } else {
                scaled = glr.fd.time / 40;
                scroll = -64 * (scaled - (int)scaled);
            }
 
            qglTranslatef(scroll, 0, 0);
        } else {
            qglLoadIdentity();
        }
 
        qglMatrixMode(GL_MODELVIEW);
    }
 
    if (diff & GLS_LIGHTMAP_ENABLE) {
        GL_ActiveTexture(1);
        if (bits & GLS_LIGHTMAP_ENABLE) {
            qglEnable(GL_TEXTURE_2D);
        } else {
            qglDisable(GL_TEXTURE_2D);
        }
    }
 
#ifdef GL_ARB_fragment_program
    if ((diff & GLS_WARP_ENABLE) && gl_static.prognum_warp) {
        if (bits & GLS_WARP_ENABLE) {
            vec4_t param;
 
            qglEnable(GL_FRAGMENT_PROGRAM_ARB);
            qglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, gl_static.prognum_warp);
            param[0] = glr.fd.time;
            param[1] = glr.fd.time;
            param[2] = param[3] = 0;
            qglProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 0, param);
        } else {
            qglBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0);
            qglDisable(GL_FRAGMENT_PROGRAM_ARB);
        }
    }
#endif
 
    if (diff & GLS_CULL_DISABLE) {
        if (bits & GLS_CULL_DISABLE) {
            qglDisable(GL_CULL_FACE);
        } else {
            qglEnable(GL_CULL_FACE);
        }
    }
 
    if (diff & GLS_SHADE_SMOOTH) {
        if (bits & GLS_SHADE_SMOOTH) {
            qglShadeModel(GL_SMOOTH);
        } else {
            qglShadeModel(GL_FLAT);
        }
    }
 
    gls.state_bits = bits;
}

Referenced by draw_alias_mesh(), draw_celshading(), draw_shadow(), GL_DrawBeams(), GL_DrawNullModel(), GL_DrawParticles(), GL_EnableOutlines(), GL_Flush2D(), GL_Flush3D(), GL_Setup3D(), and R_DrawSkyBox().

IMG_ReadPixels_GL()

byte* IMG_ReadPixels_GL	(	int *	width,
		int *	height,
		int *	rowbytes
	)

Definition at line 427 of file state.c.

{
    int align = 4;
    int pitch;
    byte *pixels;
 
    qglGetIntegerv(GL_PACK_ALIGNMENT, &align);
    pitch = (r_config.width * 3 + align - 1) & ~(align - 1);
    pixels = FS_AllocTempMem(pitch * r_config.height);
 
    qglReadPixels(0, 0, r_config.width, r_config.height,
                  GL_RGB, GL_UNSIGNED_BYTE, pixels);
 
    int ideal_pitch = r_config.width * 3;
    if (pitch > ideal_pitch)
    {
        for (int row = 1; row < r_config.height; row++)
        {
            byte* src = pixels + row * pitch;
            byte* dst = pixels + row * ideal_pitch;
            memcpy(dst, src, ideal_pitch);
        }
 
        pitch = ideal_pitch;
    }
 
    *width = r_config.width;
    *height = r_config.height;
    *rowbytes = pitch;
 
    return pixels;
}

Referenced by R_RegisterFunctionsGL().

Variable Documentation

gls

glState_t gls

Definition at line 22 of file state.c.

Referenced by GL_ActiveTexture(), GL_ArrayBits(), GL_BindTexture(), GL_ClientActiveTexture(), GL_ForceTexture(), GL_LoadMatrix(), GL_RotateForEntity(), GL_RotateForViewer(), GL_SetDefaultState(), GL_StateBits(), and IMG_Unload_GL().