main.c File Reference

#include "gl.h"

Go to the source code of this file.

Macros
#define	E(x)   case GL_##x: str = "GL_"#x; break;

Functions
static void	GL_SetupFrustum (void)
glCullResult_t	GL_CullBox (vec3_t bounds[2])
glCullResult_t	GL_CullSphere (const vec3_t origin, float radius)
static void	make_box_points (const vec3_t origin, vec3_t bounds[2], vec3_t points[8])
glCullResult_t	GL_CullLocalBox (const vec3_t origin, vec3_t bounds[2])
qboolean	GL_AllocBlock (int width, int height, int *inuse, int w, int h, int *s, int *t)
void	GL_MultMatrix (GLfloat *p, const GLfloat *a, const GLfloat *b)
void	GL_RotateForEntity (vec3_t origin, float scale)
static void	GL_DrawSpriteModel (model_t *model)
static void	GL_DrawNullModel (void)
static void	GL_DrawEntities (int mask)
static void	GL_DrawTearing (void)
static const char *	GL_ErrorString (GLenum err)
void	QGL_ClearErrors (void)
qboolean	GL_ShowErrors (const char *func)
void	R_RenderFrame_GL (refdef_t *fd)
void	R_BeginFrame_GL (void)
void	R_EndFrame_GL (void)
static void	GL_Strings_f (void)
static size_t	GL_ViewCluster_m (char *buffer, size_t size)
static void	gl_lightmap_changed (cvar_t *self)
static void	gl_modulate_entities_changed (cvar_t *self)
static void	gl_modulate_changed (cvar_t *self)
static void	gl_drawsky_changed (cvar_t *self)
static void	gl_novis_changed (cvar_t *self)
static void	GL_Register (void)
static void	GL_Unregister (void)
static qboolean	GL_SetupConfig (void)
static void	GL_InitTables (void)
static void	GL_PostInit (void)
qboolean	R_Init_GL (qboolean total)
void	R_Shutdown_GL (qboolean total)
void	R_BeginRegistration_GL (const char *name)
void	R_EndRegistration_GL (void)
void	R_ModeChanged_GL (int width, int height, int flags, int rowbytes, void *pixels)
void	R_AddDecal_GL (decal_t *d)
qboolean	R_InterceptKey_GL (unsigned key, qboolean down)
void	R_RegisterFunctionsGL ()

Variables
glRefdef_t	glr
glStatic_t	gl_static
glConfig_t	gl_config
statCounters_t	c
entity_t	gl_world
int	registration_sequence
cvar_t *	gl_partscale
cvar_t *	gl_partstyle
cvar_t *	gl_celshading
cvar_t *	gl_dotshading
cvar_t *	gl_shadows
cvar_t *	gl_modulate
cvar_t *	gl_modulate_world
cvar_t *	gl_coloredlightmaps
cvar_t *	gl_brightness
cvar_t *	gl_dynamic
cvar_t *	gl_modulate_entities
cvar_t *	gl_doublelight_entities
cvar_t *	gl_fragment_program
cvar_t *	gl_vertex_buffer_object
cvar_t *	gl_fontshadow
cvar_t *	gl_znear
cvar_t *	gl_drawworld
cvar_t *	gl_drawentities
cvar_t *	gl_drawsky
cvar_t *	gl_showtris
cvar_t *	gl_showorigins
cvar_t *	gl_showtearing
cvar_t *	gl_cull_nodes
cvar_t *	gl_cull_models
cvar_t *	gl_clear
cvar_t *	gl_finish
cvar_t *	gl_hash_faces
cvar_t *	gl_novis
cvar_t *	gl_lockpvs
cvar_t *	gl_lightmap
cvar_t *	gl_fullbright
cvar_t *	gl_vertexlight
cvar_t *	gl_polyblend
cvar_t *	gl_showerrors

Macro Definition Documentation

E

#define E

(

x

)

case GL_##x: str = "GL_"#x; break;

Function Documentation

GL_AllocBlock()

qboolean GL_AllocBlock	(	int	width,
		int	height,
		int *	inuse,
		int	w,
		int	h,
		int *	s,
		int *	t
	)

Definition at line 252 of file main.c.

{
    int i, j, k, x, y, max_inuse, min_inuse;
 
    x = 0; y = height;
    min_inuse = height;
    for (i = 0; i < width - w; i++) {
        max_inuse = 0;
        for (j = 0; j < w; j++) {
            k = inuse[i + j];
            if (k >= min_inuse) {
                break;
            }
            if (max_inuse < k) {
                max_inuse = k;
            }
        }
        if (j == w) {
            x = i;
            y = min_inuse = max_inuse;
        }
    }
 
    if (y + h > height) {
        return qfalse;
    }
 
    for (i = 0; i < w; i++) {
        inuse[x + i] = y + h;
    }
 
    *s = x;
    *t = y;
    return qtrue;
}

GL_CullBox()

glCullResult_t GL_CullBox

(

vec3_t

bounds[2]

)

Definition at line 122 of file main.c.

{
    int i, bits;
    glCullResult_t cull;
 
    if (!gl_cull_models->integer) {
        return CULL_IN;
    }
 
    cull = CULL_IN;
    for (i = 0; i < 4; i++) {
        bits = BoxOnPlaneSide(bounds[0], bounds[1], &glr.frustumPlanes[i]);
        if (bits == BOX_BEHIND) {
            return CULL_OUT;
        }
        if (bits != BOX_INFRONT) {
            cull = CULL_CLIP;
        }
    }
 
    return cull;
}

Referenced by cull_lerped_model(), cull_static_model(), and GL_DrawBspModel().

GL_CullLocalBox()

glCullResult_t GL_CullLocalBox	(	const vec3_t	origin,
		vec3_t	bounds[2]
	)

Definition at line 185 of file main.c.

{
    vec3_t points[8];
    cplane_t *p;
    int i, j;
    vec_t dot;
    qboolean infront;
    glCullResult_t cull;
 
    if (!gl_cull_models->integer) {
        return CULL_IN;
    }
 
    make_box_points(origin, bounds, points);
 
    cull = CULL_IN;
    for (i = 0, p = glr.frustumPlanes; i < 4; i++, p++) {
        infront = qfalse;
        for (j = 0; j < 8; j++) {
            dot = DotProduct(points[j], p->normal);
            if (dot >= p->dist) {
                infront = qtrue;
                if (cull == CULL_CLIP) {
                    break;
                }
            } else {
                cull = CULL_CLIP;
                if (infront) {
                    break;
                }
            }
        }
        if (!infront) {
            return CULL_OUT;
        }
    }
 
    return cull;
}

Referenced by cull_lerped_model(), cull_static_model(), and GL_DrawBspModel().

GL_CullSphere()

glCullResult_t GL_CullSphere	(	const vec3_t	origin,
		float	radius
	)

Definition at line 145 of file main.c.

{
    float dist;
    cplane_t *p;
    int i;
    glCullResult_t cull;
 
    if (!gl_cull_models->integer) {
        return CULL_IN;
    }
 
    cull = CULL_IN;
    for (i = 0, p = glr.frustumPlanes; i < 4; i++, p++) {
        dist = PlaneDiff(origin, p);
        if (dist < -radius) {
            return CULL_OUT;
        }
        if (dist <= radius) {
            cull = CULL_CLIP;
        }
    }
 
    return cull;
}

Referenced by cull_lerped_model(), cull_static_model(), and GL_DrawBspModel().

GL_DrawEntities()

static void GL_DrawEntities ( int  mask )

static

Definition at line 418 of file main.c.

{
    entity_t *ent, *last;
    model_t *model;
 
    if (!gl_drawentities->integer) {
        return;
    }
 
    last = glr.fd.entities + glr.fd.num_entities;
    for (ent = glr.fd.entities; ent != last; ent++) {
        if (ent->flags & RF_BEAM) {
            // beams are drawn elsewhere in single batch
            glr.num_beams++;
            continue;
        }
        if ((ent->flags & RF_TRANSLUCENT) != mask) {
            continue;
        }
 
        glr.ent = ent;
 
        // convert angles to axis
        if (VectorEmpty(ent->angles)) {
            glr.entrotated = qfalse;
            VectorSet(glr.entaxis[0], 1, 0, 0);
            VectorSet(glr.entaxis[1], 0, 1, 0);
            VectorSet(glr.entaxis[2], 0, 0, 1);
        } else {
            glr.entrotated = qtrue;
            AnglesToAxis(ent->angles, glr.entaxis);
        }
 
        // inline BSP model
        if (ent->model & 0x80000000) {
            bsp_t *bsp = gl_static.world.cache;
            int index = ~ent->model;
 
            if (glr.fd.rdflags & RDF_NOWORLDMODEL) {
                Com_Error(ERR_DROP, "%s: inline model without world",
                          __func__);
            }
 
            if (index < 1 || index >= bsp->nummodels) {
                Com_Error(ERR_DROP, "%s: inline model %d out of range",
                          __func__, index);
            }
 
            GL_DrawBspModel(&bsp->models[index]);
            continue;
        }
 
        model = MOD_ForHandle(ent->model);
        if (!model) {
            GL_DrawNullModel();
            continue;
        }
 
        switch (model->type) {
        case MOD_ALIAS:
            GL_DrawAliasModel(model);
            break;
        case MOD_SPRITE:
            GL_DrawSpriteModel(model);
            break;
        case MOD_EMPTY:
            break;
        default:
            Com_Error(ERR_FATAL, "%s: bad model type", __func__);
        }
 
        if (gl_showorigins->integer) {
            GL_DrawNullModel();
        }
    }
}

Referenced by R_RenderFrame_GL().

GL_DrawNullModel()

static void GL_DrawNullModel ( void  )

static

Definition at line 391 of file main.c.

{
    static const uint32_t colors[6] = {
        U32_RED, U32_RED,
        U32_GREEN, U32_GREEN,
        U32_BLUE, U32_BLUE
    };
    entity_t *e = glr.ent;
    vec3_t points[6];
 
    VectorCopy(e->origin, points[0]);
    VectorCopy(e->origin, points[2]);
    VectorCopy(e->origin, points[4]);
 
    VectorMA(e->origin, 16, glr.entaxis[0], points[1]);
    VectorMA(e->origin, 16, glr.entaxis[1], points[3]);
    VectorMA(e->origin, 16, glr.entaxis[2], points[5]);
 
    GL_LoadMatrix(glr.viewmatrix);
    GL_BindTexture(0, TEXNUM_WHITE);
    GL_StateBits(GLS_DEFAULT);
    GL_ArrayBits(GLA_VERTEX | GLA_COLOR);
    GL_ColorBytePointer(4, 0, (GLubyte *)colors);
    GL_VertexPointer(3, 0, &points[0][0]);
    qglDrawArrays(GL_LINES, 0, 6);
}

Referenced by GL_DrawEntities().

gl_drawsky_changed()

static void gl_drawsky_changed ( cvar_t *  self )

static

Definition at line 724 of file main.c.

{
    if (gl_static.world.cache)
        CL_SetSky();
}

Referenced by GL_Register().

GL_DrawSpriteModel()

static void GL_DrawSpriteModel ( model_t *  model )

static

Definition at line 336 of file main.c.

{
    static const vec_t tcoords[8] = { 0, 1, 0, 0, 1, 1, 1, 0 };
    entity_t *e = glr.ent;
    mspriteframe_t *frame = &model->spriteframes[e->frame % model->numframes];
    image_t *image = frame->image;
    float alpha = (e->flags & RF_TRANSLUCENT) ? e->alpha : 1;
    int bits = GLS_DEPTHMASK_FALSE;
    vec3_t up, down, left, right;
    vec3_t points[4];
 
    const vec3_t world_y = { 0.f, 0.f, 1.f };
 
    if (alpha == 1) {
        if (image->flags & IF_TRANSPARENT) {
            if (image->flags & IF_PALETTED) {
                bits |= GLS_ALPHATEST_ENABLE;
            } else {
                bits |= GLS_BLEND_BLEND;
            }
        }
    } else {
        bits |= GLS_BLEND_BLEND;
    }
 
    GL_LoadMatrix(glr.viewmatrix);
    GL_BindTexture(0, image->texnum);
    GL_StateBits(bits);
    GL_ArrayBits(GLA_VERTEX | GLA_TC);
    qglColor4f(1, 1, 1, alpha);
 
    VectorScale(glr.viewaxis[1], frame->origin_x, left);
    VectorScale(glr.viewaxis[1], frame->origin_x - frame->width, right);
 
    if (model->sprite_vertical)
    {
        VectorScale(world_y, -frame->origin_y, down);
        VectorScale(world_y, frame->height - frame->origin_y, up);
    }
    else
    {
        VectorScale(glr.viewaxis[2], -frame->origin_y, down);
        VectorScale(glr.viewaxis[2], frame->height - frame->origin_y, up);
    }
 
    VectorAdd3(e->origin, down, left, points[0]);
    VectorAdd3(e->origin, up, left, points[1]);
    VectorAdd3(e->origin, down, right, points[2]);
    VectorAdd3(e->origin, up, right, points[3]);
 
    GL_TexCoordPointer(2, 0, tcoords);
    GL_VertexPointer(3, 0, &points[0][0]);
    qglDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}

Referenced by GL_DrawEntities().

GL_DrawTearing()

static void GL_DrawTearing ( void  )

static

Definition at line 495 of file main.c.

{
    static int i;
 
    // alternate colors to make tearing obvious
    i++;
    if (i & 1) {
        qglClearColor(1, 1, 1, 1);
    } else {
        qglClearColor(1, 0, 0, 0);
    }
 
    qglClear(GL_COLOR_BUFFER_BIT);
    qglClearColor(0, 0, 0, 1);
}

Referenced by R_EndFrame_GL().

GL_ErrorString()

static const char* GL_ErrorString ( GLenum  err )

static

Definition at line 511 of file main.c.

{
    const char *str;
 
    switch (err) {
#define E(x) case GL_##x: str = "GL_"#x; break;
        E(NO_ERROR)
        E(INVALID_ENUM)
        E(INVALID_VALUE)
        E(INVALID_OPERATION)
        E(STACK_OVERFLOW)
        E(STACK_UNDERFLOW)
        E(OUT_OF_MEMORY)
    default: str = "UNKNOWN ERROR";
#undef E
    }
 
    return str;
}

Referenced by GL_ShowErrors().

GL_InitTables()

static void GL_InitTables ( void  )

static

Definition at line 953 of file main.c.

{
    vec_t lat, lng;
    const vec_t *v;
    int i;
 
    for (i = 0; i < NUMVERTEXNORMALS; i++) {
        v = bytedirs[i];
        lat = acos(v[2]);
        lng = atan2(v[1], v[0]);
        gl_static.latlngtab[i][0] = lat * (255.0f / (2 * M_PI));
        gl_static.latlngtab[i][1] = lng * (255.0f / (2 * M_PI));
    }
 
    for (i = 0; i < 256; i++) {
        gl_static.sintab[i] = sin(i * (2 * M_PI / 255.0f));
    }
}

Referenced by R_Init_GL().

gl_lightmap_changed()

static void gl_lightmap_changed ( cvar_t *  self )

static

Definition at line 700 of file main.c.

{
    lm.scale = Cvar_ClampValue(gl_coloredlightmaps, 0, 1);
    if (AT_LEAST_OPENGL_ES(1, 0))
        lm.comp = GL_RGBA; // ES doesn't support internal format != external
    else
        lm.comp = lm.scale ? GL_RGB : GL_LUMINANCE;
    lm.add = 255 * Cvar_ClampValue(gl_brightness, -1, 1);
    lm.modulate = gl_modulate->value * gl_modulate_world->value;
    lm.dirty = qtrue; // rebuild all lightmaps next frame
}

Referenced by gl_modulate_changed(), and GL_Register().

gl_modulate_changed()

static void gl_modulate_changed ( cvar_t *  self )

static

Definition at line 717 of file main.c.

{
    gl_lightmap_changed(self);
    gl_modulate_entities_changed(self);
}

Referenced by GL_Register().

gl_modulate_entities_changed()

static void gl_modulate_entities_changed ( cvar_t *  self )

static

Definition at line 712 of file main.c.

{
    gl_static.entity_modulate = gl_modulate->value * gl_modulate_entities->value;
}

Referenced by gl_modulate_changed(), and GL_Register().

GL_MultMatrix()

void GL_MultMatrix	(	GLfloat *	p,
		const GLfloat *	a,
		const GLfloat *	b
	)

Definition at line 290 of file main.c.

{
    int i, j;
 
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            p[i * 4 + j] =
                a[0 * 4 + j] * b[i * 4 + 0] +
                a[1 * 4 + j] * b[i * 4 + 1] +
                a[2 * 4 + j] * b[i * 4 + 2] +
                a[3 * 4 + j] * b[i * 4 + 3];
        }
    }
}

Referenced by GL_RotateForEntity(), and setup_shadow().

gl_novis_changed()

static void gl_novis_changed ( cvar_t *  self )

static

Definition at line 730 of file main.c.

{
    glr.viewcluster1 = glr.viewcluster2 = -2;
}

Referenced by GL_Register().

GL_PostInit()

static void GL_PostInit ( void  )

static

Definition at line 972 of file main.c.

{
    registration_sequence = 1;
 
    if (gl_vertex_buffer_object->modified) {
        // enable buffer objects before map is loaded
        if (gl_config.ext_supported & QGL_ARB_vertex_buffer_object) {
            if (gl_vertex_buffer_object->integer) {
                Com_Printf("...enabling GL_ARB_vertex_buffer_object\n");
                QGL_InitExtensions(QGL_ARB_vertex_buffer_object);
                gl_config.ext_enabled |= QGL_ARB_vertex_buffer_object;
            } else {
                Com_Printf("...ignoring GL_ARB_vertex_buffer_object\n");
            }
        } else if (gl_vertex_buffer_object->integer) {
            Com_Printf("GL_ARB_vertex_buffer_object not found\n");
            Cvar_Set("gl_vertex_buffer_object", "0");
        }
 
        // reset the modified flag
        gl_vertex_buffer_object->modified = qfalse;
    }
 
    GL_SetDefaultState();
    GL_InitImages();
    MOD_Init();
}

Referenced by R_Init_GL().

GL_Register()

static void GL_Register ( void  )

static

Definition at line 735 of file main.c.

{
    // regular variables
    gl_partscale = Cvar_Get("gl_partscale", "2", 0);
    gl_partstyle = Cvar_Get("gl_partstyle", "0", 0);
    gl_celshading = Cvar_Get("gl_celshading", "0", 0);
    gl_dotshading = Cvar_Get("gl_dotshading", "1", 0);
    gl_shadows = Cvar_Get("gl_shadows", "1", CVAR_ARCHIVE);
    gl_modulate = Cvar_Get("gl_modulate", "1", CVAR_ARCHIVE);
    gl_modulate->changed = gl_modulate_changed;
    gl_modulate_world = Cvar_Get("gl_modulate_world", "1", 0);
    gl_modulate_world->changed = gl_lightmap_changed;
    gl_coloredlightmaps = Cvar_Get("gl_coloredlightmaps", "1", 0);
    gl_coloredlightmaps->changed = gl_lightmap_changed;
    gl_brightness = Cvar_Get("gl_brightness", "0", 0);
    gl_brightness->changed = gl_lightmap_changed;
    gl_dynamic = Cvar_Get("gl_dynamic", "1", 0);
    gl_dynamic->changed = gl_lightmap_changed;
#if USE_DLIGHTS
    gl_dlight_falloff = Cvar_Get("gl_dlight_falloff", "1", 0);
#endif
    gl_modulate_entities = Cvar_Get("gl_modulate_entities", "1", 0);
    gl_modulate_entities->changed = gl_modulate_entities_changed;
    gl_doublelight_entities = Cvar_Get("gl_doublelight_entities", "1", 0);
    gl_fragment_program = Cvar_Get("gl_fragment_program", "1", 0);
    gl_vertex_buffer_object = Cvar_Get("gl_vertex_buffer_object", "1", CVAR_FILES);
    gl_vertex_buffer_object->modified = qtrue;
    gl_fontshadow = Cvar_Get("gl_fontshadow", "0", 0);
 
    // development variables
    gl_znear = Cvar_Get("gl_znear", "2", CVAR_CHEAT);
    gl_drawworld = Cvar_Get("gl_drawworld", "1", CVAR_CHEAT);
    gl_drawentities = Cvar_Get("gl_drawentities", "1", CVAR_CHEAT);
    gl_drawsky = Cvar_Get("gl_drawsky", "1", 0);
    gl_drawsky->changed = gl_drawsky_changed;
    gl_showtris = Cvar_Get("gl_showtris", "0", CVAR_CHEAT);
    gl_showorigins = Cvar_Get("gl_showorigins", "0", CVAR_CHEAT);
    gl_showtearing = Cvar_Get("gl_showtearing", "0", 0);
#ifdef _DEBUG
    gl_log = Cvar_Get("gl_log", "0", CVAR_CHEAT);
    gl_showstats = Cvar_Get("gl_showstats", "0", 0);
    gl_showscrap = Cvar_Get("gl_showscrap", "0", 0);
    gl_nobind = Cvar_Get("gl_nobind", "0", CVAR_CHEAT);
    gl_test = Cvar_Get("gl_test", "0", 0);
#endif
    gl_cull_nodes = Cvar_Get("gl_cull_nodes", "1", 0);
    gl_cull_models = Cvar_Get("gl_cull_models", "1", 0);
    gl_hash_faces = Cvar_Get("gl_hash_faces", "1", 0);
    gl_clear = Cvar_Get("gl_clear", "0", 0);
    gl_finish = Cvar_Get("gl_finish", "0", 0);
    gl_novis = Cvar_Get("gl_novis", "0", 0);
    gl_novis->changed = gl_novis_changed;
    gl_lockpvs = Cvar_Get("gl_lockpvs", "0", CVAR_CHEAT);
    gl_lightmap = Cvar_Get("gl_lightmap", "0", CVAR_CHEAT);
    gl_fullbright = Cvar_Get("r_fullbright", "0", CVAR_CHEAT);
    gl_fullbright->changed = gl_lightmap_changed;
    gl_vertexlight = Cvar_Get("gl_vertexlight", "0", 0);
    gl_vertexlight->changed = gl_lightmap_changed;
    gl_polyblend = Cvar_Get("gl_polyblend", "1", 0);
    gl_showerrors = Cvar_Get("gl_showerrors", "1", 0);
 
    gl_lightmap_changed(NULL);
    gl_modulate_entities_changed(NULL);
 
    Cmd_AddCommand("strings", GL_Strings_f);
    Cmd_AddMacro("gl_viewcluster", GL_ViewCluster_m);
}

Referenced by R_Init_GL().

GL_RotateForEntity()

void GL_RotateForEntity	(	vec3_t	origin,
		float	scale
	)

Definition at line 305 of file main.c.

{
    GLfloat matrix[16];
 
    matrix[0] = glr.entaxis[0][0] * scale;
    matrix[4] = glr.entaxis[1][0] * scale;
    matrix[8] = glr.entaxis[2][0] * scale;
    matrix[12] = origin[0];
 
    matrix[1] = glr.entaxis[0][1] * scale;
    matrix[5] = glr.entaxis[1][1] * scale;
    matrix[9] = glr.entaxis[2][1] * scale;
    matrix[13] = origin[1];
 
    matrix[2] = glr.entaxis[0][2] * scale;
    matrix[6] = glr.entaxis[1][2] * scale;
    matrix[10] = glr.entaxis[2][2] * scale;
    matrix[14] = origin[2];
 
    matrix[3] = 0;
    matrix[7] = 0;
    matrix[11] = 0;
    matrix[15] = 1;
 
    GL_MultMatrix(glr.entmatrix, glr.viewmatrix, matrix);
    qglLoadMatrixf(glr.entmatrix);
 
    // forced matrix upload
    gls.currentmatrix = glr.entmatrix;
}

Referenced by GL_DrawAliasModel(), and GL_DrawBspModel().

GL_SetupConfig()

static qboolean GL_SetupConfig ( void  )

static

Definition at line 808 of file main.c.

{
    const char *version, *extensions;
    GLint integer;
    GLfloat value;
    char *p;
 
    // get version string
    version = (const char *)qglGetString(GL_VERSION);
    if (!version || !*version) {
        Com_EPrintf("OpenGL returned NULL version string\n");
        return qfalse;
    }
 
    // parse ES profile prefix
    if (!strncmp(version, "OpenGL ES", 9)) {
        version += 9;
        if (version[0] == '-' && version[1] && version[2] && version[3] == ' ') {
            version += 4;
        } else if (version[0] == ' ') {
            version += 1;
        } else {
            Com_EPrintf("OpenGL returned invalid version string\n");
            return qfalse;
        }
        gl_config.es_profile = qtrue;
    } else {
        gl_config.es_profile = qfalse;
    }
 
    // parse version
    gl_config.version_major = strtoul(version, &p, 10);
    if (*p == '.') {
        gl_config.version_minor = strtoul(p + 1, NULL, 10);
    } else {
        gl_config.version_minor = 0;
    }
 
    if (gl_config.version_major < 1) {
        Com_EPrintf("OpenGL returned invalid version string\n");
        return qfalse;
    }
 
    // OpenGL 1.0 doesn't have vertex arrays
    if (!AT_LEAST_OPENGL(1, 1) && !AT_LEAST_OPENGL_ES(1, 0)) {
        Com_EPrintf("OpenGL version 1.1 or higher required\n");
        return qfalse;
    }
 
    // allow version override for debugging purposes
    p = Cvar_Get("gl_versionoverride", "", CVAR_REFRESH)->string;
    if (*p) {
        gl_config.version_major = strtoul(p, &p, 10);
        if (*p == '.')
            gl_config.version_minor = strtoul(p + 1, NULL, 10);
        else
            gl_config.version_minor = 0;
    }
 
    // get and parse extension string
    extensions = (const char *)qglGetString(GL_EXTENSIONS);
    gl_config.ext_supported = QGL_ParseExtensionString(extensions);
    gl_config.ext_enabled = 0;
 
    // initialize our 'always on' extensions
    if (gl_config.ext_supported & QGL_EXT_compiled_vertex_array) {
        Com_Printf("...enabling GL_EXT_compiled_vertex_array\n");
        gl_config.ext_enabled |= QGL_EXT_compiled_vertex_array;
    } else {
        Com_Printf("GL_EXT_compiled_vertex_array not found\n");
    }
 
    gl_config.numTextureUnits = 1;
    if (gl_config.ext_supported & QGL_ARB_multitexture) {
        qglGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &integer);
        if (integer >= 2) {
            Com_Printf("...enabling GL_ARB_multitexture (%d TMUs)\n", integer);
            gl_config.ext_enabled |= QGL_ARB_multitexture;
            if (integer > MAX_TMUS) {
                integer = MAX_TMUS;
            }
            gl_config.numTextureUnits = integer;
        } else {
            Com_Printf("...ignoring GL_ARB_multitexture,\n"
                       "%d TMU is not enough\n", integer);
        }
    } else {
        Com_Printf("GL_ARB_multitexture not found\n");
    }
 
    gl_config.maxAnisotropy = 1;
    if (gl_config.ext_supported & QGL_EXT_texture_filter_anisotropic) {
        qglGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &value);
        if (value >= 2) {
            Com_Printf("...enabling GL_EXT_texture_filter_anisotropic (%.f max)\n", value);
            gl_config.ext_enabled |= QGL_EXT_texture_filter_anisotropic;
            gl_config.maxAnisotropy = value;
        } else {
            Com_Printf("...ignoring GL_EXT_texture_filter_anisotropic,\n"
                       "%.f anisotropy is not enough\n", value);
        }
    } else {
        Com_Printf("GL_EXT_texture_filter_anisotropic not found\n");
    }
 
    if (AT_LEAST_OPENGL(3, 0)) {
        gl_config.ext_enabled |= QGL_3_0_core_functions;
    }
 
    QGL_InitExtensions(gl_config.ext_enabled);
 
    qglGetIntegerv(GL_MAX_TEXTURE_SIZE, &integer);
    if (integer < 256) {
        Com_EPrintf("OpenGL reports invalid maximum texture size\n");
        return qfalse;
    }
 
    if (integer & (integer - 1)) {
        integer = npot32(integer) >> 1;
    }
 
    if (integer > MAX_TEXTURE_SIZE) {
        integer = MAX_TEXTURE_SIZE;
    }
 
    gl_config.maxTextureSize = integer;
 
    gl_config.colorbits = 0;
    qglGetIntegerv(GL_RED_BITS, &integer);
    gl_config.colorbits += integer;
    qglGetIntegerv(GL_GREEN_BITS, &integer);
    gl_config.colorbits += integer;
    qglGetIntegerv(GL_BLUE_BITS, &integer);
    gl_config.colorbits += integer;
 
    qglGetIntegerv(GL_DEPTH_BITS, &integer);
    gl_config.depthbits = integer;
 
    qglGetIntegerv(GL_STENCIL_BITS, &integer);
    gl_config.stencilbits = integer;
 
    GL_ShowErrors(__func__);
    return qtrue;
}

Referenced by R_Init_GL().

GL_SetupFrustum()

static void GL_SetupFrustum ( void  )

static

Definition at line 86 of file main.c.

{
    vec_t angle, sf, cf;
    vec3_t forward, left, up;
    cplane_t *p;
    int i;
 
    // right/left
    angle = DEG2RAD(glr.fd.fov_x / 2);
    sf = sin(angle);
    cf = cos(angle);
 
    VectorScale(glr.viewaxis[0], sf, forward);
    VectorScale(glr.viewaxis[1], cf, left);
 
    VectorAdd(forward, left, glr.frustumPlanes[0].normal);
    VectorSubtract(forward, left, glr.frustumPlanes[1].normal);
 
    // top/bottom
    angle = DEG2RAD(glr.fd.fov_y / 2);
    sf = sin(angle);
    cf = cos(angle);
 
    VectorScale(glr.viewaxis[0], sf, forward);
    VectorScale(glr.viewaxis[2], cf, up);
 
    VectorAdd(forward, up, glr.frustumPlanes[2].normal);
    VectorSubtract(forward, up, glr.frustumPlanes[3].normal);
 
    for (i = 0, p = glr.frustumPlanes; i < 4; i++, p++) {
        p->dist = DotProduct(glr.fd.vieworg, p->normal);
        p->type = PLANE_NON_AXIAL;
        SetPlaneSignbits(p);
    }
}

Referenced by R_RenderFrame_GL().

GL_ShowErrors()

qboolean GL_ShowErrors

(

const char *

func

)

Definition at line 539 of file main.c.

{
    GLenum err = qglGetError();
 
    if (err == GL_NO_ERROR) {
        return qfalse;
    }
 
    do {
        if (gl_showerrors->integer) {
            Com_EPrintf("%s: %s\n", func, GL_ErrorString(err));
        }
    } while ((err = qglGetError()) != GL_NO_ERROR);
 
    return qtrue;
}

Referenced by create_surface_vbo(), GL_InitImages(), GL_InitPrograms(), GL_LoadWorld(), GL_SetupConfig(), R_BeginFrame_GL(), R_EndFrame_GL(), and R_RenderFrame_GL().

GL_Strings_f()

static void GL_Strings_f ( void  )

static

Definition at line 682 of file main.c.

{
    Com_Printf("GL_VENDOR: %s\n", qglGetString(GL_VENDOR));
    Com_Printf("GL_RENDERER: %s\n", qglGetString(GL_RENDERER));
    Com_Printf("GL_VERSION: %s\n", qglGetString(GL_VERSION));
    Com_Printf("GL_EXTENSIONS: %s\n", qglGetString(GL_EXTENSIONS));
    Com_Printf("GL_MAX_TEXTURE_SIZE: %d\n", gl_config.maxTextureSize);
    Com_Printf("GL_MAX_TEXTURE_UNITS: %d\n", gl_config.numTextureUnits);
    Com_Printf("GL_MAX_TEXTURE_MAX_ANISOTROPY: %.f\n", gl_config.maxAnisotropy);
    Com_Printf("GL_PFD: color(%d-bit) Z(%d-bit) stencil(%d-bit)\n",
               gl_config.colorbits, gl_config.depthbits, gl_config.stencilbits);
}

Referenced by GL_Register().

GL_Unregister()

static void GL_Unregister ( void  )

static

Definition at line 803 of file main.c.

{
    Cmd_RemoveCommand("strings");
}

Referenced by R_Shutdown_GL().

GL_ViewCluster_m()

static size_t GL_ViewCluster_m ( char *  buffer, size_t  size  )

static

Definition at line 695 of file main.c.

{
    return Q_scnprintf(buffer, size, "%d", glr.viewcluster1);
}

Referenced by GL_Register().

make_box_points()

static void make_box_points ( const vec3_t  origin, vec3_t  bounds[2], vec3_t  points[8]  )

inlinestatic

Definition at line 170 of file main.c.

{
    int i;
 
    for (i = 0; i < 8; i++) {
        VectorCopy(origin, points[i]);
        VectorMA(points[i], bounds[(i >> 0) & 1][0], glr.entaxis[0], points[i]);
        VectorMA(points[i], bounds[(i >> 1) & 1][1], glr.entaxis[1], points[i]);
        VectorMA(points[i], bounds[(i >> 2) & 1][2], glr.entaxis[2], points[i]);
    }
 
}

Referenced by GL_CullLocalBox().

QGL_ClearErrors()

void QGL_ClearErrors

(

void

)

Definition at line 531 of file main.c.

{
    GLenum err;
 
    while ((err = qglGetError()) != GL_NO_ERROR)
        ;
}

Referenced by create_surface_vbo(), and GL_InitPrograms().

R_AddDecal_GL()

void R_AddDecal_GL

(

decal_t *

d

)

Definition at line 1144 of file main.c.

{}

Referenced by R_RegisterFunctionsGL().

R_BeginFrame_GL()

void R_BeginFrame_GL

(

void

)

Definition at line 618 of file main.c.

{
#ifdef _DEBUG
    if (gl_log->integer) {
        QGL_LogComment("\n*** R_BeginFrame ***\n");
    }
#endif
 
    memset(&c, 0, sizeof(c));
 
    if (gl_finish->integer) {
        qglFinish();
    }
 
    GL_Setup2D();
 
    if (gl_clear->integer) {
        qglClear(GL_COLOR_BUFFER_BIT);
    }
 
    GL_ShowErrors(__func__);
}

Referenced by R_RegisterFunctionsGL().

R_BeginRegistration_GL()

void R_BeginRegistration_GL

(

const char *

name

)

Definition at line 1105 of file main.c.

{
    char fullname[MAX_QPATH];
 
    gl_static.registering = qtrue;
    registration_sequence++;
 
    memset(&glr, 0, sizeof(glr));
    glr.viewcluster1 = glr.viewcluster2 = -2;
 
    Q_concat(fullname, sizeof(fullname), "maps/", name, ".bsp", NULL);
    GL_LoadWorld(fullname);
}

Referenced by R_RegisterFunctionsGL().

R_EndFrame_GL()

void R_EndFrame_GL

(

void

)

Definition at line 641 of file main.c.

{
#ifdef _DEBUG
    if (gl_showstats->integer) {
        GL_Flush2D();
        Draw_Stats();
    }
    if (gl_showscrap->integer) {
        Draw_Scrap();
    }
#endif
    GL_Flush2D();
 
    if (gl_showtearing->integer) {
        GL_DrawTearing();
    }
 
    // enable/disable fragment programs on the fly
    if (gl_fragment_program->modified) {
        GL_ShutdownPrograms();
        GL_InitPrograms();
        gl_fragment_program->modified = qfalse;
    }
 
    GL_ShowErrors(__func__);
 
#ifdef _DEBUG
    if (gl_log->modified) {
        if (gl_log->integer)
            QGL_EnableLogging(gl_config.ext_enabled);
        else
            QGL_DisableLogging(gl_config.ext_enabled);
        gl_log->modified = qfalse;
    }
#endif
 
    VID_EndFrame();
}

Referenced by R_RegisterFunctionsGL().

R_EndRegistration_GL()

void R_EndRegistration_GL

(

void

)

Definition at line 1124 of file main.c.

{
    IMG_FreeUnused();
    MOD_FreeUnused();
    Scrap_Upload();
    gl_static.registering = qfalse;
}

Referenced by R_RegisterFunctionsGL().

R_Init_GL()

qboolean R_Init_GL

(

qboolean

total

)

Definition at line 1007 of file main.c.

{
    Com_DPrintf("GL_Init( %i )\n", total);
 
    if (!total) {
        GL_PostInit();
        return qtrue;
    }
 
    Com_Printf("------- R_Init -------\n");
    Com_DPrintf("ref_gl " VERSION_STRING ", " __DATE__ "\n");
 
    // initialize OS-specific parts of OpenGL
    // create the window and set up the context
    if (!VID_Init(GAPI_OPENGL)) {
        return qfalse;
    }
 
    // initialize our QGL dynamic bindings
    if (!QGL_Init()) {
        goto fail;
    }
 
    // initialize extensions and get various limits from OpenGL
    if (!GL_SetupConfig()) {
        goto fail;
    }
 
    // register our variables
    GL_Register();
 
#ifdef _DEBUG
    if (gl_log->integer) {
        QGL_EnableLogging(gl_config.ext_enabled);
    }
    gl_log->modified = qfalse;
#endif
 
    GL_PostInit();
 
    GL_InitPrograms();
    gl_fragment_program->modified = qfalse;
 
    GL_InitTables();
 
    Com_Printf("----------------------\n");
 
    return qtrue;
 
fail:
    memset(&gl_config, 0, sizeof(gl_config));
    QGL_Shutdown();
    VID_Shutdown();
    return qfalse;
}

Referenced by R_RegisterFunctionsGL().

R_InterceptKey_GL()

qboolean R_InterceptKey_GL	(	unsigned	key,
		qboolean	down
	)

Definition at line 1145 of file main.c.

{ return qfalse; }

Referenced by R_RegisterFunctionsGL().

R_ModeChanged_GL()

void R_ModeChanged_GL	(	int	width,
		int	height,
		int	flags,
		int	rowbytes,
		void *	pixels
	)

Definition at line 1137 of file main.c.

{
    r_config.width = width;
    r_config.height = height;
    r_config.flags = flags;
}

Referenced by R_RegisterFunctionsGL().

R_RegisterFunctionsGL()

void R_RegisterFunctionsGL

(

)

Definition at line 1147 of file main.c.

{
    R_Init = R_Init_GL;
    R_Shutdown = R_Shutdown_GL;
    R_BeginRegistration = R_BeginRegistration_GL;
    R_EndRegistration = R_EndRegistration_GL;
    R_SetSky = R_SetSky_GL;
    R_RenderFrame = R_RenderFrame_GL;
    R_LightPoint = R_LightPoint_GL;
    R_ClearColor = R_ClearColor_GL;
    R_SetAlpha = R_SetAlpha_GL;
    R_SetAlphaScale = R_SetAlphaScale_GL;
    R_SetColor = R_SetColor_GL;
    R_SetClipRect = R_SetClipRect_GL;
    R_SetScale = R_SetScale_GL;
    R_DrawChar = R_DrawChar_GL;
    R_DrawString = R_DrawString_GL;
    R_DrawPic = R_DrawPic_GL;
    R_DrawStretchPic = R_DrawStretchPic_GL;
    R_TileClear = R_TileClear_GL;
    R_DrawFill8 = R_DrawFill8_GL;
    R_DrawFill32 = R_DrawFill32_GL;
    R_BeginFrame = R_BeginFrame_GL;
    R_EndFrame = R_EndFrame_GL;
    R_ModeChanged = R_ModeChanged_GL;
    R_AddDecal = R_AddDecal_GL;
    R_InterceptKey = R_InterceptKey_GL;
    IMG_Load = IMG_Load_GL;
    IMG_Unload = IMG_Unload_GL;
    IMG_ReadPixels = IMG_ReadPixels_GL;
    MOD_LoadMD2 = MOD_LoadMD2_GL;
    MOD_LoadMD3 = MOD_LoadMD3_GL;
    MOD_Reference = MOD_Reference_GL;
}

Referenced by CL_InitRefresh().

R_RenderFrame_GL()

void R_RenderFrame_GL

(

refdef_t *

fd

)

Definition at line 556 of file main.c.

{
    GL_Flush2D();
 
    if (!gl_static.world.cache && !(fd->rdflags & RDF_NOWORLDMODEL)) {
        Com_Error(ERR_FATAL, "%s: NULL worldmodel", __func__);
    }
 
    glr.drawframe++;
 
    glr.fd = *fd;
    glr.num_beams = 0;
 
#if USE_DLIGHTS
    if (gl_dynamic->integer != 1 || gl_vertexlight->integer) {
        glr.fd.num_dlights = 0;
    }
#endif
 
    if (lm.dirty) {
        GL_RebuildLighting();
        lm.dirty = qfalse;
    }
 
    GL_Setup3D();
 
    if (gl_cull_nodes->integer) {
        GL_SetupFrustum();
    }
 
    if (!(glr.fd.rdflags & RDF_NOWORLDMODEL) && gl_drawworld->integer) {
        GL_DrawWorld();
    }
 
    GL_DrawEntities(0);
 
    GL_DrawBeams();
 
    GL_DrawParticles();
 
    GL_DrawEntities(RF_TRANSLUCENT);
 
    if (!(glr.fd.rdflags & RDF_NOWORLDMODEL)) {
        GL_DrawAlphaFaces();
    }
 
    // go back into 2D mode
    GL_Setup2D();
 
    if (gl_polyblend->integer && glr.fd.blend[3] != 0) {
        GL_Blend();
    }
 
#ifdef _DEBUG
    if (gl_lightmap->integer > 1) {
        Draw_Lightmaps();
    }
#endif
 
    GL_ShowErrors(__func__);
}

Referenced by R_RegisterFunctionsGL().

R_Shutdown_GL()

void R_Shutdown_GL

(

qboolean

total

)

Definition at line 1068 of file main.c.

{
    Com_DPrintf("GL_Shutdown( %i )\n", total);
 
    GL_FreeWorld();
    GL_ShutdownImages();
    MOD_Shutdown();
 
    if (gl_vertex_buffer_object->modified) {
        // disable buffer objects after map is freed
        QGL_ShutdownExtensions(QGL_ARB_vertex_buffer_object);
        gl_config.ext_enabled &= ~QGL_ARB_vertex_buffer_object;
    }
 
    if (!total) {
        return;
    }
 
    GL_ShutdownPrograms();
 
    // shut down OS specific OpenGL stuff like contexts, etc.
    VID_Shutdown();
 
    // shutdown our QGL subsystem
    QGL_Shutdown();
 
    GL_Unregister();
 
    memset(&gl_static, 0, sizeof(gl_static));
    memset(&gl_config, 0, sizeof(gl_config));
}

Referenced by R_RegisterFunctionsGL().

Variable Documentation

c

statCounters_t c

Definition at line 30 of file main.c.

Referenced by AC_FreeChecks(), AC_SendChecks(), BSP_ClusterVis(), CheckBlock(), CL_ConnectionlessPacket(), CL_GetDemoInfo(), CL_Heatbeam(), CL_OldRailTrail(), CL_RailSpiral(), CL_Record_f(), CL_WriteConfig_f(), clamp_output(), CM_InitBoxHull(), Cmd_EchoEx_f(), Cmd_UnAlias_f(), COM_Compress(), Com_Generic_c(), Com_HashString(), Com_HashStringLen(), COM_IsFloat(), COM_IsPath(), COM_IsUint(), COM_IsWhite(), COM_Parse(), COM_strclr(), compute_cluster_aabbs(), Con_DrawLine(), Con_Paste(), cull_lerped_model(), cull_static_model(), Cvar_BitInfo(), Cvar_Default_g(), Cvar_Get(), Cvar_List_f(), Cvar_Set_f(), Cvar_Variable_g(), D_FlushCaches(), draw_alias_mesh(), draw_char(), dummy_find_slot(), escape_path(), format_mask(), FS_NormalizePath(), FS_UnLink_f(), G_FindTeams(), get_emissive_shell(), GL_BindTexture(), GL_ColorInvertTexture(), GL_DrawBspModel(), GL_DrawFace(), GL_DrawLeaf(), GL_DrawNode(), GL_Flush2D(), GL_Flush3D(), GL_ForceTexture(), GL_GrayScaleTexture(), GL_LightScaleTexture(), GL_MarkLeaves(), GL_TextureAnimation(), GL_TextureHasAlpha(), GL_Upload32(), GL_WorldNode_r(), IMG_Load(), Info_SetValueForKey(), Info_SubValidate(), Info_Validate(), inject_model_lights(), Key_Bind_f(), KeyDown(), KeyUp(), left_of(), LM_RebuildSurfaces(), logfile_write(), MSG_ReadByte(), MSG_ReadChar(), MSG_ReadLong(), MSG_ReadShort(), MSG_ReadString(), MSG_ReadStringLine(), MSG_ReadWord(), MSG_WriteByte(), MSG_WriteChar(), MSG_WriteLong(), MSG_WriteShort(), MVD_Connect_f(), MVD_Control_f(), MVD_CountClients(), MVD_Play_f(), MVD_StreamedRecord_f(), needs_quotes(), Parse_Action(), Parse_Bind(), Parse_Bitmap(), Parse_Color(), parse_CSV_line(), Parse_Field(), parse_ignore_nick(), Parse_Pairs(), Parse_Range(), Parse_Savegame(), Parse_Spin(), Parse_Style(), Parse_Toggle(), Q_memccpy(), Q_strchrnul(), R_BeginFrame_GL(), R_DrawChar_GL(), R_DrawChar_RTX(), R_DrawFill32(), R_DrawFill8(), R_DrawFill8_GL(), R_DrawFill8_RTX(), R_DrawString(), R_DrawString_GL(), R_DrawString_RTX(), R_IMFlatShadedQuad(), R_LightScaleTexture(), R_RecursiveWorldNode(), R_TextureAnimation(), sample_spherical_lights(), SCR_Draw_f(), SCR_LagDraw(), SCR_ParseColor(), SetupRotationMatrix(), SV_ConnectionlessPacket(), SV_CvarResult_f(), SV_DumpEnts_f(), SV_ExecuteClientMessage(), SV_ExecuteUserCommand(), SV_MvdRecord_f(), SV_NewClientExecuteMove(), SV_StuffCvar_f(), SZ_WriteByte(), SZ_WriteLong(), SZ_WriteShort(), target_string_use(), TH_DrawString(), UI_DrawRect8(), UnionBounds(), update_dynamic_lightmap(), and validate_char().

gl_brightness

cvar_t* gl_brightness

Definition at line 45 of file main.c.

Referenced by CL_Begin(), CL_ClearState(), gl_lightmap_changed(), and GL_Register().

gl_celshading

cvar_t* gl_celshading

Definition at line 39 of file main.c.

Referenced by draw_celshading(), GL_Register(), and setup_celshading().

gl_clear

cvar_t* gl_clear

Definition at line 73 of file main.c.

Referenced by GL_Register(), and R_BeginFrame_GL().

gl_coloredlightmaps

cvar_t* gl_coloredlightmaps

Definition at line 44 of file main.c.

Referenced by gl_lightmap_changed(), and GL_Register().

gl_config

glConfig_t gl_config

Definition at line 29 of file main.c.

Referenced by draw_shadow(), gl_anisotropy_changed(), GL_InitPrograms(), GL_PostInit(), GL_SetFilterAndRepeat(), GL_SetupConfig(), GL_ShutdownPrograms(), GL_Strings_f(), GL_Upload32(), GL_UpscaleLevel(), R_EndFrame_GL(), R_Init_GL(), and R_Shutdown_GL().

gl_cull_models

cvar_t* gl_cull_models

Definition at line 72 of file main.c.

Referenced by GL_CullBox(), GL_CullLocalBox(), GL_CullSphere(), and GL_Register().

gl_cull_nodes

cvar_t* gl_cull_nodes

Definition at line 71 of file main.c.

Referenced by GL_DrawWorld(), GL_Register(), and R_RenderFrame_GL().

gl_dotshading

cvar_t* gl_dotshading

Definition at line 40 of file main.c.

Referenced by GL_Register(), and setup_dotshading().

gl_doublelight_entities

cvar_t* gl_doublelight_entities

Definition at line 51 of file main.c.

Referenced by GL_LightPoint(), and GL_Register().

gl_drawentities

cvar_t* gl_drawentities

Definition at line 59 of file main.c.

Referenced by GL_DrawEntities(), and GL_Register().

gl_drawsky

cvar_t* gl_drawsky

Definition at line 60 of file main.c.

Referenced by GL_Register(), and R_SetSky_GL().

gl_drawworld

cvar_t* gl_drawworld

Definition at line 58 of file main.c.

Referenced by GL_Register(), and R_RenderFrame_GL().

gl_dynamic

cvar_t* gl_dynamic

Definition at line 46 of file main.c.

Referenced by GL_DrawBspModel(), GL_DrawNode(), GL_Register(), LM_EndBuilding(), LM_RebuildSurfaces(), and R_RenderFrame_GL().

gl_finish

cvar_t* gl_finish

Definition at line 74 of file main.c.

Referenced by GL_Register(), and R_BeginFrame_GL().

gl_fontshadow

cvar_t* gl_fontshadow

Definition at line 54 of file main.c.

Referenced by draw_char(), and GL_Register().

gl_fragment_program

cvar_t* gl_fragment_program

Definition at line 52 of file main.c.

Referenced by GL_InitPrograms(), GL_Register(), R_EndFrame_GL(), and R_Init_GL().

gl_fullbright

cvar_t* gl_fullbright

Definition at line 79 of file main.c.

Referenced by build_surface_light(), GL_LightPoint(), GL_RebuildLighting(), GL_Register(), LM_EndBuilding(), and upload_world_surfaces().

gl_hash_faces

cvar_t* gl_hash_faces

Definition at line 75 of file main.c.

Referenced by GL_DrawNode(), and GL_Register().

gl_lightmap

cvar_t* gl_lightmap

Definition at line 78 of file main.c.

Referenced by GL_BindArrays(), GL_DrawFace(), GL_Register(), and R_RenderFrame_GL().

gl_lockpvs

cvar_t* gl_lockpvs

Definition at line 77 of file main.c.

Referenced by GL_MarkLeaves(), and GL_Register().

gl_modulate

cvar_t* gl_modulate

Definition at line 42 of file main.c.

Referenced by gl_lightmap_changed(), gl_modulate_entities_changed(), and GL_Register().

gl_modulate_entities

cvar_t* gl_modulate_entities

Definition at line 50 of file main.c.

Referenced by CL_Begin(), CL_ClearState(), gl_modulate_entities_changed(), and GL_Register().

gl_modulate_world

cvar_t* gl_modulate_world

Definition at line 43 of file main.c.

Referenced by CL_Begin(), CL_ClearState(), gl_lightmap_changed(), and GL_Register().

gl_novis

cvar_t* gl_novis

Definition at line 76 of file main.c.

Referenced by GL_MarkLeaves(), and GL_Register().

gl_partscale

cvar_t* gl_partscale

Definition at line 37 of file main.c.

Referenced by GL_DrawParticles(), and GL_Register().

gl_partstyle

cvar_t* gl_partstyle

Definition at line 38 of file main.c.

Referenced by GL_DrawParticles(), and GL_Register().

gl_polyblend

cvar_t* gl_polyblend

Definition at line 81 of file main.c.

Referenced by GL_Register(), and R_RenderFrame_GL().

gl_shadows

cvar_t* gl_shadows

Definition at line 41 of file main.c.

Referenced by GL_Register(), and setup_shadow().

gl_showerrors

cvar_t* gl_showerrors

Definition at line 82 of file main.c.

Referenced by GL_Register(), and GL_ShowErrors().

gl_showorigins

cvar_t* gl_showorigins

Definition at line 62 of file main.c.

Referenced by GL_DrawEntities(), and GL_Register().

gl_showtearing

cvar_t* gl_showtearing

Definition at line 63 of file main.c.

Referenced by GL_Register(), and R_EndFrame_GL().

gl_showtris

cvar_t* gl_showtris

Definition at line 61 of file main.c.

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

gl_static

glStatic_t gl_static

Definition at line 28 of file main.c.

Referenced by _GL_LightPoint(), build_style_map(), build_surface_light(), color_for_surface(), create_surface_vbo(), draw_shadow(), GL_AdjustColor(), GL_BindArrays(), GL_BuildIntensityTable(), GL_CopyVerts(), GL_DrawEntities(), GL_DrawFace(), gl_drawsky_changed(), GL_DrawWorld(), GL_Flush3D(), GL_FreeWorld(), GL_Frustum(), GL_InitImages(), GL_InitPrograms(), GL_InitTables(), GL_LightPoint(), GL_LoadWorld(), GL_MarkLeaves(), gl_modulate_entities_changed(), GL_RebuildLighting(), GL_SetDefaultState(), GL_Setup3D(), GL_ShutdownImages(), GL_ShutdownPrograms(), GL_StateBits(), LM_RebuildSurfaces(), MakeSkyVec(), MOD_LoadMD2_GL(), R_BeginRegistration_GL(), R_EndRegistration_GL(), R_RenderFrame_GL(), R_Shutdown_GL(), set_world_size(), and upload_world_surfaces().

gl_vertex_buffer_object

cvar_t* gl_vertex_buffer_object

Definition at line 53 of file main.c.

Referenced by GL_PostInit(), GL_Register(), and R_Shutdown_GL().

gl_vertexlight

cvar_t* gl_vertexlight

Definition at line 80 of file main.c.

Referenced by build_surface_light(), GL_RebuildLighting(), GL_Register(), LM_EndBuilding(), R_RenderFrame_GL(), and upload_world_surfaces().

gl_world

entity_t gl_world

Definition at line 32 of file main.c.

Referenced by GL_DrawAlphaFaces(), and GL_DrawWorld().

gl_znear

cvar_t* gl_znear

Definition at line 57 of file main.c.

Referenced by GL_Frustum(), and GL_Register().

glr

glRefdef_t glr

Definition at line 27 of file main.c.

Referenced by _GL_LightPoint(), build_style_map(), cull_lerped_model(), cull_static_model(), draw_alias_mesh(), GL_Blend(), GL_ClipNode(), GL_CullBox(), GL_CullLocalBox(), GL_CullSphere(), GL_DrawAliasModel(), GL_DrawAlphaFaces(), GL_DrawBeams(), GL_DrawBspModel(), GL_DrawEntities(), GL_DrawLeaf(), GL_DrawNode(), GL_DrawNullModel(), GL_DrawParticles(), GL_DrawSpriteModel(), GL_DrawWorld(), GL_Frustum(), GL_MarkLeaves(), gl_novis_changed(), GL_RotateForEntity(), GL_RotateForViewer(), GL_SampleLightPoint(), GL_Setup3D(), GL_SetupFrustum(), GL_StateBits(), GL_TextureAnimation(), GL_ViewCluster_m(), GL_WorldNode_r(), make_box_points(), MakeSkyVec(), R_AddSkySurface(), R_BeginRegistration_GL(), R_RenderFrame_GL(), sample_surface_verts(), setup_celshading(), setup_color(), setup_dotshading(), setup_shadow(), texnum_for_mesh(), and update_dynamic_lightmap().

registration_sequence

int registration_sequence

Definition at line 34 of file main.c.

Referenced by enqueue_stretch_pic(), find_or_load_image(), GL_LoadWorld(), GL_PostInit(), IMG_FreeUnused(), MOD_FreeUnused(), MOD_Reference_GL(), MOD_Reference_RTX(), R_BeginRegistration_GL(), R_BeginRegistration_RTX(), R_Init_RTX(), R_InitImages(), R_RegisterModel(), and R_RegisterRawImage().