gl.h File Reference

#include "shared/shared.h"
#include "common/bsp.h"
#include "common/cmd.h"
#include "common/common.h"
#include "common/cvar.h"
#include "common/files.h"
#include "common/math.h"
#include "client/video.h"
#include "client/client.h"
#include "refresh/refresh.h"
#include "refresh/images.h"
#include "refresh/models.h"
#include "system/hunk.h"
#include "qgl/dynamic.h"

Go to the source code of this file.

Classes
struct	glStatic_t
struct	glRefdef_t
struct	glConfig_t
struct	statCounters_t
struct	maliastc_s
struct	masliasvert_s
struct	maliasframe_s
struct	maliasmesh_s
struct	lightmap_builder_t
struct	glState_t
struct	drawStatic_t
struct	tesselator_t

Macros
#define	QGL_INDEX_TYPE   GLuint
#define	QGL_INDEX_ENUM   GL_UNSIGNED_INT
#define	MAX_TMUS   2
#define	TAB_SIN(x)   gl_static.sintab[(x) & 255]
#define	TAB_COS(x)   gl_static.sintab[((x) + 64) & 255]
#define	NUM_TEXNUMS   6
#define	AT_LEAST_OPENGL_ANY(major, minor)   (gl_config.version_major > major || (gl_config.version_major == major && gl_config.version_minor >= minor))
#define	AT_LEAST_OPENGL(major, minor)   (!gl_config.es_profile && AT_LEAST_OPENGL_ANY(major, minor))
#define	AT_LEAST_OPENGL_ES(major, minor)   (gl_config.es_profile && AT_LEAST_OPENGL_ANY(major, minor))
#define	VERTEX_SIZE   8
#define	LIGHT_STYLE(surf, i)   &glr.fd.lightstyles[gl_static.lightstylemap[(surf)->styles[i]]]
#define	LM_MAX_LIGHTMAPS   32
#define	LM_BLOCK_WIDTH   256
#define	LM_BLOCK_HEIGHT   256
#define	GLS_BLEND_MASK   (GLS_BLEND_BLEND | GLS_BLEND_ADD | GLS_BLEND_MODULATE)
#define	TEXNUM_DEFAULT   gl_static.texnums[0]
#define	TEXNUM_SCRAP   gl_static.texnums[1]
#define	TEXNUM_PARTICLE   gl_static.texnums[2]
#define	TEXNUM_BEAM   gl_static.texnums[3]
#define	TEXNUM_WHITE   gl_static.texnums[4]
#define	TEXNUM_BLACK   gl_static.texnums[5]
#define	TESS_MAX_VERTICES   4096
#define	TESS_MAX_INDICES   (3 * TESS_MAX_VERTICES)

Typedefs
typedef struct maliastc_s	maliastc_t
typedef struct masliasvert_s	maliasvert_t
typedef struct maliasframe_s	maliasframe_t
typedef struct maliasmesh_s	maliasmesh_t

Enumerations
enum	glCullResult_t { CULL_OUT, CULL_IN, CULL_CLIP }
enum	glStateBits_t {   GLS_DEFAULT = 0, GLS_DEPTHMASK_FALSE = (1 << 0), GLS_DEPTHTEST_DISABLE = (1 << 1), GLS_BLEND_BLEND = (1 << 2),   GLS_BLEND_ADD = (1 << 3), GLS_BLEND_MODULATE = (1 << 4), GLS_ALPHATEST_ENABLE = (1 << 5), GLS_TEXTURE_REPLACE = (1 << 6),   GLS_FLOW_ENABLE = (1 << 7), GLS_LIGHTMAP_ENABLE = (1 << 8), GLS_WARP_ENABLE = (1 << 9), GLS_CULL_DISABLE = (1 << 10),   GLS_SHADE_SMOOTH = (1 << 11) }
enum	glArrayBits_t {   GLA_NONE = 0, GLA_VERTEX = (1 << 0), GLA_TC = (1 << 1), GLA_LMTC = (1 << 2),   GLA_COLOR = (1 << 3) }

Functions
glCullResult_t	GL_CullBox (vec3_t bounds[2])
glCullResult_t	GL_CullSphere (const vec3_t origin, float radius)
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 *out, const GLfloat *a, const GLfloat *b)
void	GL_RotateForEntity (vec3_t origin, float scale)
void	QGL_ClearErrors (void)
qboolean	GL_ShowErrors (const char *func)
void	GL_AdjustColor (vec3_t color)
void	GL_PushLights (mface_t *surf)
void	GL_RebuildLighting (void)
void	GL_FreeWorld (void)
void	GL_LoadWorld (const char *name)
static void	GL_ActiveTexture (GLuint tmu)
static void	GL_ClientActiveTexture (GLuint tmu)
static void	GL_VertexPointer (GLint size, GLsizei stride, const GLfloat *pointer)
static void	GL_TexCoordPointer (GLint size, GLsizei stride, const GLfloat *pointer)
static void	GL_LightCoordPointer (GLint size, GLsizei stride, const GLfloat *pointer)
static void	GL_ColorBytePointer (GLint size, GLsizei stride, const GLubyte *pointer)
static void	GL_ColorFloatPointer (GLint size, GLsizei stride, const GLfloat *pointer)
static void	GL_LockArrays (GLsizei count)
static void	GL_UnlockArrays (void)
static void	GL_LoadMatrix (const GLfloat *matrix)
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)
void	GL_Setup3D (void)
void	GL_SetDefaultState (void)
void	GL_InitPrograms (void)
void	GL_ShutdownPrograms (void)
void	GL_EnableOutlines (void)
void	GL_DisableOutlines (void)
void	GL_Blend (void)
void	R_ClearColor_GL (void)
void	R_SetAlpha_GL (float alpha)
void	R_SetAlphaScale_GL (float alpha)
void	R_SetColor_GL (uint32_t color)
void	R_SetClipRect_GL (const clipRect_t *clip)
float	R_ClampScaleGL (cvar_t *var)
void	R_SetScale_GL (float scale)
void	R_DrawStretchPic_GL (int x, int y, int w, int h, qhandle_t pic)
void	R_DrawPic_GL (int x, int y, qhandle_t pic)
void	R_TileClear_GL (int x, int y, int w, int h, qhandle_t pic)
void	R_DrawFill8_GL (int x, int y, int w, int h, int c)
void	R_DrawFill32_GL (int x, int y, int w, int h, uint32_t color)
void	R_DrawChar_GL (int x, int y, int flags, int c, qhandle_t font)
int	R_DrawString_GL (int x, int y, int flags, size_t maxlen, const char *s, qhandle_t font)
void	Scrap_Upload (void)
void	GL_InitImages (void)
void	GL_ShutdownImages (void)
void	IMG_Load_GL (image_t *image, byte *pic)
void	IMG_Unload_GL (image_t *image)
byte *	IMG_ReadPixels_GL (int *width, int *height, int *rowbytes)
void	GL_Flush2D (void)
void	GL_DrawParticles (void)
void	GL_DrawBeams (void)
void	GL_BindArrays (void)
void	GL_Flush3D (void)
void	GL_DrawFace (mface_t *surf)
void	GL_AddAlphaFace (mface_t *face)
void	GL_AddSolidFace (mface_t *face)
void	GL_DrawAlphaFaces (void)
void	GL_DrawSolidFaces (void)
void	GL_ClearSolidFaces (void)
void	GL_DrawBspModel (mmodel_t *model)
void	GL_DrawWorld (void)
void	GL_SampleLightPoint (vec3_t color)
void	GL_LightPoint (vec3_t origin, vec3_t color)
void	R_LightPoint_GL (vec3_t origin, vec3_t color)
void	R_AddSkySurface (mface_t *surf)
void	R_ClearSkyBox (void)
void	R_DrawSkyBox (void)
void	R_SetSky_GL (const char *name, float rotate, vec3_t axis)
void	GL_DrawAliasModel (model_t *model)
void	HQ2x_Render (uint32_t *output, const uint32_t *input, int width, int height)
void	HQ4x_Render (uint32_t *output, const uint32_t *input, int width, int height)
void	HQ2x_Init (void)
qerror_t	MOD_LoadMD2_GL (model_t *model, const void *rawdata, size_t length)
qerror_t	MOD_LoadMD3_GL (model_t *model, const void *rawdata, size_t length)
void	MOD_Reference_GL (model_t *model)

Variables
glStatic_t	gl_static
glConfig_t	gl_config
glRefdef_t	glr
entity_t	gl_world
statCounters_t	c
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_fontshadow
cvar_t *	gl_znear
cvar_t *	gl_drawsky
cvar_t *	gl_showtris
cvar_t *	gl_cull_nodes
cvar_t *	gl_hash_faces
cvar_t *	gl_clear
cvar_t *	gl_novis
cvar_t *	gl_lockpvs
cvar_t *	gl_lightmap
cvar_t *	gl_fullbright
cvar_t *	gl_vertexlight
lightmap_builder_t	lm
glState_t	gls
drawStatic_t	draw
tesselator_t	tess

Macro Definition Documentation

AT_LEAST_OPENGL

#define AT_LEAST_OPENGL	(		major,
			minor
	)		(!gl_config.es_profile && AT_LEAST_OPENGL_ANY(major, minor))

Definition at line 121 of file gl.h.

AT_LEAST_OPENGL_ANY

#define AT_LEAST_OPENGL_ANY	(		major,
			minor
	)		(gl_config.version_major > major || (gl_config.version_major == major && gl_config.version_minor >= minor))

Definition at line 118 of file gl.h.

AT_LEAST_OPENGL_ES

#define AT_LEAST_OPENGL_ES	(		major,
			minor
	)		(gl_config.es_profile && AT_LEAST_OPENGL_ANY(major, minor))

Definition at line 124 of file gl.h.

GLS_BLEND_MASK

#define GLS_BLEND_MASK   (GLS_BLEND_BLEND | GLS_BLEND_ADD | GLS_BLEND_MODULATE)

Definition at line 297 of file gl.h.

LIGHT_STYLE

#define LIGHT_STYLE	(		surf,
			i
	)		&glr.fd.lightstyles[gl_static.lightstylemap[(surf)->styles[i]]]

Definition at line 251 of file gl.h.

LM_BLOCK_HEIGHT

#define LM_BLOCK_HEIGHT   256

Definition at line 256 of file gl.h.

LM_BLOCK_WIDTH

#define LM_BLOCK_WIDTH   256

Definition at line 255 of file gl.h.

LM_MAX_LIGHTMAPS

#define LM_MAX_LIGHTMAPS   32

Definition at line 254 of file gl.h.

MAX_TMUS

#define MAX_TMUS   2

Definition at line 52 of file gl.h.

NUM_TEXNUMS

#define NUM_TEXNUMS   6

Definition at line 57 of file gl.h.

QGL_INDEX_ENUM

#define QGL_INDEX_ENUM   GL_UNSIGNED_INT

Definition at line 49 of file gl.h.

QGL_INDEX_TYPE

#define QGL_INDEX_TYPE   GLuint

Definition at line 48 of file gl.h.

TAB_COS

#define TAB_COS

(

x

)

gl_static.sintab[((x) + 64) & 255]

Definition at line 55 of file gl.h.

TAB_SIN

#define TAB_SIN

(

x

)

gl_static.sintab[(x) & 255]

Definition at line 54 of file gl.h.

TESS_MAX_INDICES

#define TESS_MAX_INDICES   (3 * TESS_MAX_VERTICES)

Definition at line 460 of file gl.h.

TESS_MAX_VERTICES

#define TESS_MAX_VERTICES   4096

Definition at line 459 of file gl.h.

TEXNUM_BEAM

#define TEXNUM_BEAM   gl_static.texnums[3]

Definition at line 442 of file gl.h.

TEXNUM_BLACK

#define TEXNUM_BLACK   gl_static.texnums[5]

Definition at line 444 of file gl.h.

TEXNUM_DEFAULT

#define TEXNUM_DEFAULT   gl_static.texnums[0]

Definition at line 439 of file gl.h.

TEXNUM_PARTICLE

#define TEXNUM_PARTICLE   gl_static.texnums[2]

Definition at line 441 of file gl.h.

TEXNUM_SCRAP

#define TEXNUM_SCRAP   gl_static.texnums[1]

Definition at line 440 of file gl.h.

TEXNUM_WHITE

#define TEXNUM_WHITE   gl_static.texnums[4]

Definition at line 443 of file gl.h.

VERTEX_SIZE

#define VERTEX_SIZE   8

Definition at line 245 of file gl.h.

Typedef Documentation

maliasframe_t

typedef struct maliasframe_s maliasframe_t

maliasmesh_t

typedef struct maliasmesh_s maliasmesh_t

maliastc_t

typedef struct maliastc_s maliastc_t

maliasvert_t

typedef struct masliasvert_s maliasvert_t

Enumeration Type Documentation

glArrayBits_t

enum glArrayBits_t

Enumerator
GLA_NONE
GLA_VERTEX
GLA_TC
GLA_LMTC
GLA_COLOR

Definition at line 299 of file gl.h.

             {
    GLA_NONE        = 0,
    GLA_VERTEX      = (1 << 0),
    GLA_TC          = (1 << 1),
    GLA_LMTC        = (1 << 2),
    GLA_COLOR       = (1 << 3),
} glArrayBits_t;

glCullResult_t

enum glCullResult_t

Enumerator
CULL_OUT
CULL_IN
CULL_CLIP

Definition at line 190 of file gl.h.

             {
    CULL_OUT,
    CULL_IN,
    CULL_CLIP
} glCullResult_t;

glStateBits_t

enum glStateBits_t

Enumerator
GLS_DEFAULT
GLS_DEPTHMASK_FALSE
GLS_DEPTHTEST_DISABLE
GLS_BLEND_BLEND
GLS_BLEND_ADD
GLS_BLEND_MODULATE
GLS_ALPHATEST_ENABLE
GLS_TEXTURE_REPLACE
GLS_FLOW_ENABLE
GLS_LIGHTMAP_ENABLE
GLS_WARP_ENABLE
GLS_CULL_DISABLE
GLS_SHADE_SMOOTH

Definition at line 281 of file gl.h.

             {
    GLS_DEFAULT             = 0,
    GLS_DEPTHMASK_FALSE     = (1 << 0),
    GLS_DEPTHTEST_DISABLE   = (1 << 1),
    GLS_BLEND_BLEND         = (1 << 2),
    GLS_BLEND_ADD           = (1 << 3),
    GLS_BLEND_MODULATE      = (1 << 4),
    GLS_ALPHATEST_ENABLE    = (1 << 5),
    GLS_TEXTURE_REPLACE     = (1 << 6),
    GLS_FLOW_ENABLE         = (1 << 7),
    GLS_LIGHTMAP_ENABLE     = (1 << 8),
    GLS_WARP_ENABLE         = (1 << 9),
    GLS_CULL_DISABLE        = (1 << 10),
    GLS_SHADE_SMOOTH        = (1 << 11)
} glStateBits_t;

Function Documentation

GL_ActiveTexture()

static void GL_ActiveTexture ( GLuint  tmu )

inlinestatic

Definition at line 318 of file gl.h.

{
    if (gls.server_tmu != tmu) {
        qglActiveTextureARB(GL_TEXTURE0_ARB + tmu);
        gls.server_tmu = tmu;
    }
}

Referenced by GL_BindTexture(), GL_ForceTexture(), and GL_StateBits().

GL_AddAlphaFace()

void GL_AddAlphaFace

(

mface_t *

face

)

Definition at line 476 of file tess.c.

{
    // draw back-to-front
    face->next = faces_alpha;
    faces_alpha = face;
}

Referenced by GL_DrawBspModel(), and GL_DrawNode().

GL_AddSolidFace()

void GL_AddSolidFace

(

mface_t *

face

)

Definition at line 462 of file tess.c.

{
    unsigned hash;
 
    hash = face->texnum[0] ^ face->texnum[1] ^ face->statebits;
    hash ^= hash >> FACE_HASH_BITS;
    hash &= FACE_HASH_MASK;
 
    // preserve front-to-back ordering
    face->next = NULL;
    *faces_next[hash] = face;
    faces_next[hash] = &face->next;
}

Referenced by GL_DrawNode().

GL_AdjustColor()

void GL_AdjustColor

(

vec3_t

color

)

Definition at line 94 of file surf.c.

{
    adjust_color_f(color, color, gl_static.entity_modulate);
    VectorScale(color, (1.0f / 255), color);
}

Referenced by _GL_LightPoint().

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_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_BindArrays()

void GL_BindArrays

(

void

)

Definition at line 255 of file tess.c.

{
    vec_t *ptr;
 
    if (gl_static.world.vertices) {
        ptr = tess.vertices;
    } else {
        ptr = NULL;
        qglBindBufferARB(GL_ARRAY_BUFFER_ARB, gl_static.world.bufnum);
    }
 
    GL_VertexPointer(3, VERTEX_SIZE, ptr + 0);
 
    if (gl_lightmap->integer) {
        GL_TexCoordPointer(2, VERTEX_SIZE, ptr + 6);
    } else {
        GL_TexCoordPointer(2, VERTEX_SIZE, ptr + 4);
        if (lm.nummaps) {
            GL_LightCoordPointer(2, VERTEX_SIZE, ptr + 6);
        }
    }
 
    GL_ColorBytePointer(4, VERTEX_SIZE, (GLubyte *)(ptr + 3));
 
    if (!gl_static.world.vertices) {
        qglBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
    }
}

Referenced by GL_DrawAlphaFaces(), GL_DrawBspModel(), and GL_DrawWorld().

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_Blend()

void GL_Blend

(

void

)

Definition at line 79 of file draw.c.

{
    color_t color;
 
    color.u8[0] = glr.fd.blend[0] * 255;
    color.u8[1] = glr.fd.blend[1] * 255;
    color.u8[2] = glr.fd.blend[2] * 255;
    color.u8[3] = glr.fd.blend[3] * 255;
 
    _GL_StretchPic(glr.fd.x, glr.fd.y, glr.fd.width, glr.fd.height, 0, 0, 1, 1,
                   color.u32, TEXNUM_WHITE, 0);
}

Referenced by R_RenderFrame_GL().

GL_ClearSolidFaces()

void GL_ClearSolidFaces

(

void

)

Definition at line 427 of file tess.c.

{
    int i;
 
    for (i = 0; i < FACE_HASH_SIZE; i++) {
        faces_next[i] = &faces_head[i];
    }
}

Referenced by GL_DrawWorld().

GL_ClientActiveTexture()

static void GL_ClientActiveTexture ( GLuint  tmu )

inlinestatic

Definition at line 326 of file gl.h.

{
    if (gls.client_tmu != tmu) {
        qglClientActiveTextureARB(GL_TEXTURE0_ARB + tmu);
        gls.client_tmu = tmu;
    }
}

Referenced by GL_ArrayBits(), GL_LightCoordPointer(), and GL_TexCoordPointer().

GL_ColorBytePointer()

static void GL_ColorBytePointer ( GLint  size, GLsizei  stride, const GLubyte *  pointer  )

inlinestatic

Definition at line 351 of file gl.h.

{
    qglColorPointer(size, GL_UNSIGNED_BYTE, sizeof(GLfloat) * stride, pointer);
}

Referenced by GL_BindArrays(), GL_DrawBeams(), GL_DrawNullModel(), GL_DrawParticles(), and GL_Flush2D().

GL_ColorFloatPointer()

static void GL_ColorFloatPointer ( GLint  size, GLsizei  stride, const GLfloat *  pointer  )

inlinestatic

Definition at line 356 of file gl.h.

{
    qglColorPointer(size, GL_FLOAT, sizeof(GLfloat) * stride, pointer);
}

Referenced by draw_alias_mesh().

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_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_DrawAliasModel()

void GL_DrawAliasModel

(

model_t *

model

)

Definition at line 623 of file mesh.c.

{
    entity_t *ent = glr.ent;
    glCullResult_t cull;
    int i;
 
    newframenum = ent->frame;
    if (newframenum < 0 || newframenum >= model->numframes) {
        Com_DPrintf("%s: no such frame %d\n", __func__, newframenum);
        newframenum = 0;
    }
 
    oldframenum = ent->oldframe;
    if (oldframenum < 0 || oldframenum >= model->numframes) {
        Com_DPrintf("%s: no such oldframe %d\n", __func__, oldframenum);
        oldframenum = 0;
    }
 
    backlerp = ent->backlerp;
    frontlerp = 1.0f - backlerp;
 
    // optimized case
    if (backlerp == 0)
        oldframenum = newframenum;
 
    // interpolate origin, if necessarry
    if (ent->flags & RF_FRAMELERP)
        LerpVector2(ent->oldorigin, ent->origin,
                    backlerp, frontlerp, origin);
    else
        VectorCopy(ent->origin, origin);
 
    // cull the model, setup scale and translate vectors
    if (newframenum == oldframenum)
        cull = cull_static_model(model);
    else
        cull = cull_lerped_model(model);
    if (cull == CULL_OUT)
        return;
 
    // setup parameters common for all meshes
    setup_color();
    setup_celshading();
    setup_dotshading();
    setup_shadow();
 
    // select proper tessfunc
    if (ent->flags & RF_SHELL_MASK) {
        shellscale = (ent->flags & RF_WEAPONMODEL) ?
            WEAPONSHELL_SCALE : POWERSUIT_SCALE;
        tessfunc = newframenum == oldframenum ?
            tess_static_shell : tess_lerped_shell;
    } else if (shadelight) {
        tessfunc = newframenum == oldframenum ?
            tess_static_shade : tess_lerped_shade;
    } else {
        tessfunc = newframenum == oldframenum ?
            tess_static_plain : tess_lerped_plain;
    }
 
    float scale = 1.f;
    if (ent->scale > 0.f)
        scale = ent->scale;
 
    GL_RotateForEntity(origin, scale);
 
    if ((ent->flags & (RF_WEAPONMODEL | RF_LEFTHAND)) ==
        (RF_WEAPONMODEL | RF_LEFTHAND)) {
        qglMatrixMode(GL_PROJECTION);
        qglScalef(-1, 1, 1);
        qglMatrixMode(GL_MODELVIEW);
        qglFrontFace(GL_CCW);
    }
 
    if (ent->flags & RF_DEPTHHACK)
        qglDepthRange(0, 0.25f);
 
    // draw all the meshes
    for (i = 0; i < model->nummeshes; i++)
        draw_alias_mesh(&model->meshes[i]);
 
    if (ent->flags & RF_DEPTHHACK)
        qglDepthRange(0, 1);
 
    if ((ent->flags & (RF_WEAPONMODEL | RF_LEFTHAND)) ==
        (RF_WEAPONMODEL | RF_LEFTHAND)) {
        qglMatrixMode(GL_PROJECTION);
        qglScalef(-1, 1, 1);
        qglMatrixMode(GL_MODELVIEW);
        qglFrontFace(GL_CW);
    }
}

Referenced by GL_DrawEntities().

GL_DrawAlphaFaces()

void GL_DrawAlphaFaces

(

void

)

Definition at line 445 of file tess.c.

{
    if (!faces_alpha) {
        return;
    }
 
    glr.ent = &gl_world;
 
    GL_LoadMatrix(glr.viewmatrix);
 
    GL_BindArrays();
 
    GL_DrawChain(&faces_alpha);
 
    GL_Flush3D();
}

Referenced by R_RenderFrame_GL().

GL_DrawBeams()

void GL_DrawBeams

(

void

)

Definition at line 164 of file tess.c.

{
    vec3_t d1, d2, d3;
    vec_t *start, *end;
    color_t color;
    vec_t *dst_vert;
    uint32_t *dst_color;
    QGL_INDEX_TYPE *dst_indices;
    vec_t length;
    int numverts;
    int numindices;
    entity_t *ent;
    int i;
 
    if (!glr.num_beams) {
        return;
    }
 
    GL_LoadMatrix(glr.viewmatrix);
    GL_BindTexture(0, TEXNUM_BEAM);
    GL_StateBits(GLS_BLEND_BLEND | GLS_DEPTHMASK_FALSE);
    GL_ArrayBits(GLA_VERTEX | GLA_TC | GLA_COLOR);
 
    GL_VertexPointer(3, 5, tess.vertices);
    GL_TexCoordPointer(2, 5, tess.vertices + 3);
    GL_ColorBytePointer(4, 0, tess.colors);
 
    numverts = numindices = 0;
    for (i = 0, ent = glr.fd.entities; i < glr.fd.num_entities; i++, ent++) {
        if (!(ent->flags & RF_BEAM)) {
            continue;
        }
 
        start = ent->origin;
        end = ent->oldorigin;
        VectorSubtract(end, start, d1);
        VectorSubtract(glr.fd.vieworg, start, d2);
        CrossProduct(d1, d2, d3);
        length = VectorLength(d3);
        length = ent->frame * 1.2f / length;
        VectorScale(d3, length, d3);
 
        length = VectorLength(d1);
 
        if (ent->skinnum == -1) {
            color.u32 = ent->rgba.u32;
        } else {
            color.u32 = d_8to24table[ent->skinnum & 0xff];
            color.u8[3] = 255 * ent->alpha;
        }
 
        if (numverts + 4 > TESS_MAX_VERTICES ||
            numindices + 6 > TESS_MAX_INDICES) {
            qglDrawElements(GL_TRIANGLES, numindices,
                            QGL_INDEX_ENUM, tess.indices);
            numverts = numindices = 0;
        }
 
        dst_vert = tess.vertices + numverts * 5;
        VectorAdd(start, d3, dst_vert);
        VectorSubtract(start, d3, dst_vert + 5);
        VectorSubtract(end, d3, dst_vert + 10);
        VectorAdd(end, d3, dst_vert + 15);
 
        dst_vert[3] = 0; dst_vert[4] = 0;
        dst_vert[8] = 1; dst_vert[9] = 0;
        dst_vert[13] = 1; dst_vert[14] = length;
        dst_vert[18] = 0; dst_vert[19] = length;
 
        dst_color = (uint32_t *)tess.colors + numverts;
        dst_color[0] = color.u32;
        dst_color[1] = color.u32;
        dst_color[2] = color.u32;
        dst_color[3] = color.u32;
 
        dst_indices = tess.indices + numindices;
        dst_indices[0] = numverts + 0;
        dst_indices[1] = numverts + 2;
        dst_indices[2] = numverts + 3;
        dst_indices[3] = numverts + 0;
        dst_indices[4] = numverts + 1;
        dst_indices[5] = numverts + 2;
 
        numverts += 4;
        numindices += 6;
    }
 
    qglDrawElements(GL_TRIANGLES, numindices,
                    QGL_INDEX_ENUM, tess.indices);
}

Referenced by R_RenderFrame_GL().

GL_DrawBspModel()

void GL_DrawBspModel

(

mmodel_t *

model

)

Definition at line 358 of file world.c.

{
    mface_t *face, *last;
    vec3_t bounds[2];
    vec_t dot;
    vec3_t transformed, temp;
    entity_t *ent = glr.ent;
    glCullResult_t cull;
 
    if (!model->numfaces)
        return;
 
    if (glr.entrotated) {
        cull = GL_CullSphere(ent->origin, model->radius);
        if (cull == CULL_OUT) {
            c.spheresCulled++;
            return;
        }
        if (cull == CULL_CLIP) {
            VectorCopy(model->mins, bounds[0]);
            VectorCopy(model->maxs, bounds[1]);
            cull = GL_CullLocalBox(ent->origin, bounds);
            if (cull == CULL_OUT) {
                c.rotatedBoxesCulled++;
                return;
            }
        }
        VectorSubtract(glr.fd.vieworg, ent->origin, temp);
        transformed[0] = DotProduct(temp, glr.entaxis[0]);
        transformed[1] = DotProduct(temp, glr.entaxis[1]);
        transformed[2] = DotProduct(temp, glr.entaxis[2]);
    } else {
        VectorAdd(model->mins, ent->origin, bounds[0]);
        VectorAdd(model->maxs, ent->origin, bounds[1]);
        cull = GL_CullBox(bounds);
        if (cull == CULL_OUT) {
            c.boxesCulled++;
            return;
        }
        VectorSubtract(glr.fd.vieworg, ent->origin, transformed);
    }
 
    GL_TransformLights(model);
 
    GL_RotateForEntity(ent->origin, 1.f);
 
    GL_BindArrays();
 
    // draw visible faces
    last = model->firstface + model->numfaces;
    for (face = model->firstface; face < last; face++) {
        dot = PlaneDiffFast(transformed, face->plane);
        if (BSP_CullFace(face, dot)) {
            c.facesCulled++;
            continue;
        }
 
        // sky faces don't have their polygon built
        if (face->drawflags & SURF_SKY) {
            continue;
        }
 
        // alpha faces on transformed inline models are drawn with world GL
        // matrix. this bug is intentional: some maps exploit this to hide
        // surfaces that would otherwise be visible.
        if (face->drawflags & SURF_TRANS_MASK) {
            if (model->drawframe != glr.drawframe)
                GL_AddAlphaFace(face);
            continue;
        }
 
        if (gl_dynamic->integer) {
            GL_PushLights(face);
        }
 
        GL_DrawFace(face);
    }
 
    GL_Flush3D();
 
    // protect against infinite loop if the same inline model
    // with alpha faces is referenced by multiple entities
    model->drawframe = glr.drawframe;
}

Referenced by GL_DrawEntities().

GL_DrawFace()

void GL_DrawFace

(

mface_t *

surf

)

Definition at line 367 of file tess.c.

{
    int numtris = surf->numsurfedges - 2;
    int numindices = numtris * 3;
    GLuint texnum[2];
    QGL_INDEX_TYPE *dst_indices;
    int i, j;
 
    if (q_unlikely(gl_lightmap->integer)) {
        texnum[0] = surf->texnum[1];
        if (!texnum[0])
            texnum[0] = GL_TextureAnimation(surf->texinfo);
        texnum[1] = 0;
    } else {
        texnum[0] = GL_TextureAnimation(surf->texinfo);
        texnum[1] = surf->texnum[1];
    }
 
    if (tess.texnum[0] != texnum[0] ||
        tess.texnum[1] != texnum[1] ||
        tess.flags != surf->statebits ||
        tess.numindices + numindices > TESS_MAX_INDICES) {
        GL_Flush3D();
    }
 
    tess.texnum[0] = texnum[0];
    tess.texnum[1] = texnum[1];
    tess.flags = surf->statebits;
 
    if (q_unlikely(gl_static.world.vertices)) {
        j = GL_CopyVerts(surf);
    } else {
        j = surf->firstvert;
    }
 
    dst_indices = tess.indices + tess.numindices;
    for (i = 0; i < numtris; i++) {
        dst_indices[0] = j;
        dst_indices[1] = j + (i + 1);
        dst_indices[2] = j + (i + 2);
        dst_indices += 3;
    }
    tess.numindices += numindices;
 
    c.trisDrawn += numtris;
    c.facesTris += numtris;
    c.facesDrawn++;
}

Referenced by GL_DrawBspModel(), GL_DrawChain(), and GL_DrawNode().

GL_DrawParticles()

void GL_DrawParticles

(

void

)

Definition at line 79 of file tess.c.

{
    particle_t *p;
    int total, count;
    vec3_t transformed;
    vec_t scale, dist;
    color_t color;
    int numverts;
    vec_t *dst_vert;
    uint32_t *dst_color;
    int blend;
 
    if (!glr.fd.num_particles)
        return;
 
    if (gl_partstyle->integer)
        blend = GLS_BLEND_ADD;
    else
        blend = GLS_BLEND_BLEND;
 
    GL_LoadMatrix(glr.viewmatrix);
 
    GL_VertexPointer(3, 5, tess.vertices);
    GL_TexCoordPointer(2, 5, tess.vertices + 3);
    GL_ColorBytePointer(4, 0, tess.colors);
 
    p = glr.fd.particles;
    total = glr.fd.num_particles;
    do {
        GL_BindTexture(0, TEXNUM_PARTICLE);
        GL_StateBits(blend | GLS_DEPTHMASK_FALSE);
        GL_ArrayBits(GLA_VERTEX | GLA_TC | GLA_COLOR);
 
        count = total;
        if (count > TESS_MAX_VERTICES / 3)
            count = TESS_MAX_VERTICES / 3;
 
        total -= count;
 
        numverts = 0;
        do {
            VectorSubtract(p->origin, glr.fd.vieworg, transformed);
            dist = DotProduct(transformed, glr.viewaxis[0]);
 
            scale = gl_partscale->value;
            if (dist > 20)
                scale += dist * 0.01f;
 
            if (p->color == -1) {
                color.u32 = p->rgba.u32;
            } else {
                color.u32 = d_8to24table[p->color & 0xff];
                color.u8[3] = 255 * p->alpha;
            }
 
            dst_vert = tess.vertices + numverts * 5;
            VectorMA(p->origin, scale * PARTICLE_SCALE, glr.viewaxis[1], dst_vert);
            VectorMA(dst_vert, -scale * PARTICLE_SCALE, glr.viewaxis[2], dst_vert);
            VectorMA(dst_vert, scale, glr.viewaxis[2], dst_vert + 5);
            VectorMA(dst_vert, -scale, glr.viewaxis[1], dst_vert + 10);
 
            dst_vert[ 3] = 0;               dst_vert[ 4] = 0;
            dst_vert[ 8] = 0;               dst_vert[ 9] = PARTICLE_SIZE;
            dst_vert[13] = PARTICLE_SIZE;   dst_vert[14] = 0;
 
            dst_color = (uint32_t *)tess.colors + numverts;
            dst_color[0] = color.u32;
            dst_color[1] = color.u32;
            dst_color[2] = color.u32;
 
            p++;
            numverts += 3;
        } while (--count);
 
        qglDrawArrays(GL_TRIANGLES, 0, numverts);
 
        if (gl_showtris->integer) {
            GL_EnableOutlines();
            qglDrawArrays(GL_TRIANGLES, 0, numverts);
            GL_DisableOutlines();
        }
    } while (total);
}

Referenced by R_RenderFrame_GL().

GL_DrawSolidFaces()

void GL_DrawSolidFaces

(

void

)

Definition at line 436 of file tess.c.

{
    int i;
 
    for (i = 0; i < FACE_HASH_SIZE; i++) {
        GL_DrawChain(&faces_head[i]);
    }
}

Referenced by GL_DrawWorld().

GL_DrawWorld()

void GL_DrawWorld

(

void

)

Definition at line 552 of file world.c.

{
    // auto cycle the world frame for texture animation
    gl_world.frame = (int)(glr.fd.time * 2);
 
    glr.ent = &gl_world;
 
    GL_MarkLeaves();
 
    GL_MarkLights();
 
    R_ClearSkyBox();
 
    GL_LoadMatrix(glr.viewmatrix);
 
    GL_BindArrays();
 
    GL_ClearSolidFaces();
 
    GL_WorldNode_r(gl_static.world.cache->nodes,
                   gl_cull_nodes->integer ? NODE_CLIPPED : NODE_UNCLIPPED);
 
    GL_DrawSolidFaces();
 
    GL_Flush3D();
 
    R_DrawSkyBox();
}

Referenced by R_RenderFrame_GL().

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_Flush2D()

void GL_Flush2D

(

void

)

Definition at line 31 of file tess.c.

{
    glStateBits_t bits;
 
    if (!tess.numverts) {
        return;
    }
 
    bits = GLS_DEPTHTEST_DISABLE | GLS_DEPTHMASK_FALSE | GLS_CULL_DISABLE;
    if (tess.flags & 2) {
        bits |= GLS_BLEND_BLEND;
    } else if (tess.flags & 1) {
        bits |= GLS_ALPHATEST_ENABLE;
    }
 
    Scrap_Upload();
 
    GL_BindTexture(0, tess.texnum[0]);
    GL_StateBits(bits);
    GL_ArrayBits(GLA_VERTEX | GLA_TC | GLA_COLOR);
 
    GL_VertexPointer(2, 4, tess.vertices);
    GL_TexCoordPointer(2, 4, tess.vertices + 2);
    GL_ColorBytePointer(4, 0, tess.colors);
 
    GL_LockArrays(tess.numverts);
 
    qglDrawElements(GL_TRIANGLES, tess.numindices, QGL_INDEX_ENUM, tess.indices);
 
    if (gl_showtris->integer > 1) {
        GL_EnableOutlines();
        qglDrawElements(GL_TRIANGLES, tess.numindices, QGL_INDEX_ENUM, tess.indices);
        GL_DisableOutlines();
    }
 
    GL_UnlockArrays();
 
    c.batchesDrawn2D++;
 
    tess.numindices = 0;
    tess.numverts = 0;
    tess.texnum[0] = 0;
    tess.flags = 0;
}

Referenced by _GL_StretchPic(), R_EndFrame_GL(), R_RenderFrame_GL(), R_SetClipRect_GL(), and R_SetScale_GL().

GL_Flush3D()

void GL_Flush3D

(

void

)

Definition at line 284 of file tess.c.

{
    glStateBits_t state = tess.flags;
    glArrayBits_t array = GLA_VERTEX | GLA_TC;
 
    if (!tess.numindices) {
        return;
    }
 
    if (q_likely(tess.texnum[1])) {
        state |= GLS_LIGHTMAP_ENABLE;
        array |= GLA_LMTC;
    }
 
    if (!(state & GLS_TEXTURE_REPLACE)) {
        array |= GLA_COLOR;
    }
 
    GL_StateBits(state);
    GL_ArrayBits(array);
 
    GL_BindTexture(0, tess.texnum[0]);
    if (q_likely(tess.texnum[1])) {
        GL_BindTexture(1, tess.texnum[1]);
    }
 
    if (gl_static.world.vertices) {
        GL_LockArrays(tess.numverts);
    }
 
    qglDrawElements(GL_TRIANGLES, tess.numindices, QGL_INDEX_ENUM, tess.indices);
 
    if (gl_showtris->integer) {
        GL_EnableOutlines();
        qglDrawElements(GL_TRIANGLES, tess.numindices, QGL_INDEX_ENUM, tess.indices);
        GL_DisableOutlines();
    }
 
    if (gl_static.world.vertices) {
        GL_UnlockArrays();
    }
 
    c.batchesDrawn++;
 
    tess.texnum[0] = tess.texnum[1] = 0;
    tess.numindices = 0;
    tess.numverts = 0;
    tess.flags = 0;
}

Referenced by GL_CopyVerts(), GL_DrawAlphaFaces(), GL_DrawBspModel(), GL_DrawFace(), and GL_DrawWorld().

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_FreeWorld()

void GL_FreeWorld

(

void

)

Definition at line 859 of file surf.c.

{
    if (!gl_static.world.cache) {
        return;
    }
 
    BSP_Free(gl_static.world.cache);
 
    if (gl_static.world.vertices) {
        Hunk_Free(&gl_static.world.hunk);
    } else if (qglDeleteBuffersARB) {
        qglDeleteBuffersARB(1, &gl_static.world.bufnum);
    }
 
    memset(&gl_static.world, 0, sizeof(gl_static.world));
}

Referenced by GL_LoadWorld(), and R_Shutdown_GL().

GL_InitImages()

void GL_InitImages

(

void

)

Definition at line 855 of file images.c.

{
    gl_bilerp_chars = Cvar_Get("gl_bilerp_chars", "0", 0);
    gl_bilerp_chars->changed = gl_bilerp_chars_changed;
    gl_bilerp_pics = Cvar_Get("gl_bilerp_pics", "1", 0);
    gl_bilerp_pics->changed = gl_bilerp_pics_changed;
    gl_texturemode = Cvar_Get("gl_texturemode",
                              "GL_LINEAR_MIPMAP_LINEAR", CVAR_ARCHIVE);
    gl_texturemode->changed = gl_texturemode_changed;
    gl_texturemode->generator = gl_texturemode_g;
    gl_texturebits = Cvar_Get("gl_texturebits", "0", CVAR_FILES);
    gl_texture_non_power_of_two = Cvar_Get("gl_texture_non_power_of_two", "1", 0);
    gl_anisotropy = Cvar_Get("gl_anisotropy", "8", 0);
    gl_anisotropy->changed = gl_anisotropy_changed;
    gl_noscrap = Cvar_Get("gl_noscrap", "0", CVAR_FILES);
    gl_round_down = Cvar_Get("gl_round_down", "0", CVAR_FILES);
    gl_picmip = Cvar_Get("gl_picmip", "0", CVAR_FILES);
    gl_downsample_skins = Cvar_Get("gl_downsample_skins", "1", CVAR_FILES);
    gl_gamma_scale_pics = Cvar_Get("gl_gamma_scale_pics", "0", CVAR_FILES);
    gl_upscale_pcx = Cvar_Get("gl_upscale_pcx", "0", CVAR_FILES);
    gl_saturation = Cvar_Get("gl_saturation", "1", CVAR_FILES);
    gl_intensity = Cvar_Get("intensity", "2", CVAR_FILES);
    gl_invert = Cvar_Get("gl_invert", "0", CVAR_FILES);
    gl_gamma = Cvar_Get("vid_gamma", "0.8", CVAR_ARCHIVE);
 
    if (r_config.flags & QVF_GAMMARAMP) {
        gl_gamma->changed = gl_gamma_changed;
        gl_gamma->flags &= ~CVAR_FILES;
    } else {
        gl_gamma->flags |= CVAR_FILES;
    }
 
    if (AT_LEAST_OPENGL(3, 0)) {
        gl_texture_non_power_of_two->flags |= CVAR_FILES;
    } else {
        gl_texture_non_power_of_two->flags &= ~CVAR_FILES;
    }
 
    IMG_Init();
 
    IMG_GetPalette();
 
    if (gl_upscale_pcx->integer) {
        HQ2x_Init();
    }
 
    GL_BuildIntensityTable();
 
    if (r_config.flags & QVF_GAMMARAMP) {
        gl_gamma_changed(gl_gamma);
    } else {
        GL_BuildGammaTables();
    }
 
    // FIXME: the name 'saturation' is misleading in this context
    colorscale = Cvar_ClampValue(gl_saturation, 0, 1);
 
    gl_texturemode_changed(gl_texturemode);
    gl_texturebits_changed(gl_texturebits);
    gl_anisotropy_changed(gl_anisotropy);
    gl_bilerp_chars_changed(gl_bilerp_chars);
    gl_bilerp_pics_changed(gl_bilerp_pics);
 
    qglGenTextures(NUM_TEXNUMS, gl_static.texnums);
    qglGenTextures(LM_MAX_LIGHTMAPS, lm.texnums);
 
    Scrap_Init();
 
    GL_InitDefaultTexture();
    GL_InitParticleTexture();
    GL_InitWhiteImage();
    GL_InitBeamTexture();
 
    GL_ShowErrors(__func__);
}

Referenced by GL_PostInit().

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_LightCoordPointer()

static void GL_LightCoordPointer ( GLint  size, GLsizei  stride, const GLfloat *  pointer  )

inlinestatic

Definition at line 345 of file gl.h.

{
    GL_ClientActiveTexture(1);
    qglTexCoordPointer(size, GL_FLOAT, sizeof(GLfloat) * stride, pointer);
}

Referenced by GL_BindArrays().

GL_LightPoint()

void GL_LightPoint	(	vec3_t	origin,
		vec3_t	color
	)

Definition at line 233 of file world.c.

{
    if (gl_fullbright->integer) {
        VectorSet(color, 1, 1, 1);
        return;
    }
 
    // get lighting from world
    if (!_GL_LightPoint(origin, color)) {
        VectorSet(color, 1, 1, 1);
    }
 
    // add dynamic lights
    GL_AddLights(origin, color);
 
    if (gl_doublelight_entities->integer) {
        // apply modulate twice to mimic original ref_gl behavior
        VectorScale(color, gl_static.entity_modulate, color);
    }
}

Referenced by R_LightPoint_GL(), and setup_color().

GL_LoadMatrix()

void GL_LoadMatrix ( const GLfloat *  matrix )

inlinestatic

Definition at line 375 of file gl.h.

{
    if (gls.currentmatrix != matrix) {
        qglLoadMatrixf(matrix);
        gls.currentmatrix = matrix;
    }
}

Referenced by draw_alias_mesh(), draw_shadow(), GL_DrawAlphaFaces(), GL_DrawBeams(), GL_DrawNullModel(), GL_DrawParticles(), and GL_DrawWorld().

GL_LoadWorld()

void GL_LoadWorld

(

const char *

name

)

Definition at line 876 of file surf.c.

{
    char buffer[MAX_QPATH];
    size_t size;
    bsp_t *bsp;
    mtexinfo_t *info;
    mface_t *surf;
    qerror_t ret;
    imageflags_t flags;
    int i;
 
    ret = BSP_Load(name, &bsp);
    if (!bsp) {
        Com_Error(ERR_DROP, "%s: couldn't load %s: %s",
                  __func__, name, Q_ErrorString(ret));
    }
 
    // check if the required world model was already loaded
    if (gl_static.world.cache == bsp) {
        for (i = 0; i < bsp->numtexinfo; i++) {
            bsp->texinfo[i].image->registration_sequence = registration_sequence;
        }
        for (i = 0; i < bsp->numnodes; i++) {
            bsp->nodes[i].visframe = 0;
        }
        for (i = 0; i < bsp->numleafs; i++) {
            bsp->leafs[i].visframe = 0;
        }
        Com_DPrintf("%s: reused old world model\n", __func__);
        bsp->refcount--;
        return;
    }
 
    // free previous model, if any
    GL_FreeWorld();
 
    gl_static.world.cache = bsp;
 
    // calculate world size for far clip plane and sky box
    set_world_size();
 
    // register all texinfo
    for (i = 0, info = bsp->texinfo; i < bsp->numtexinfo; i++, info++) {
        if (info->c.flags & SURF_WARP)
            flags = IF_TURBULENT;
        else
            flags = IF_NONE;
 
        Q_concat(buffer, sizeof(buffer), "textures/", info->name, ".wal", NULL);
        FS_NormalizePath(buffer, buffer);
        info->image = IMG_Find(buffer, IT_WALL, flags);
    }
 
    // calculate vertex buffer size in bytes
    size = 0;
    for (i = 0, surf = bsp->faces; i < bsp->numfaces; i++, surf++) {
        // hack surface flags into drawflags for faster access
        surf->drawflags |= surf->texinfo->c.flags & ~DSURF_PLANEBACK;
 
        // don't count sky surfaces
        if (surf->drawflags & SURF_SKY)
            continue;
 
        size += surf->numsurfedges * VERTEX_SIZE * sizeof(vec_t);
    }
 
    // try VBO first, then allocate on hunk
    if (create_surface_vbo(size)) {
        Com_DPrintf("%s: %"PRIz" bytes of vertex data as VBO\n", __func__, size);
    } else {
        Hunk_Begin(&gl_static.world.hunk, size);
        gl_static.world.vertices = Hunk_Alloc(&gl_static.world.hunk, size);
        Hunk_End(&gl_static.world.hunk);
 
        Com_DPrintf("%s: %"PRIz" bytes of vertex data on hunk\n", __func__, size);
    }
 
    // begin building lightmaps
    LM_BeginBuilding();
 
    // post process all surfaces
    upload_world_surfaces();
 
    // end building lightmaps
    LM_EndBuilding();
 
    GL_ShowErrors(__func__);
}

Referenced by R_BeginRegistration_GL().

GL_LockArrays()

static void GL_LockArrays ( GLsizei  count )

inlinestatic

Definition at line 361 of file gl.h.

{
    if (qglLockArraysEXT) {
        qglLockArraysEXT(0, count);
    }
}

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

GL_MultMatrix()

void GL_MultMatrix	(	GLfloat *	out,
		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_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_PushLights()

void GL_PushLights

(

mface_t *

surf

)

Definition at line 271 of file surf.c.

{
    lightstyle_t *style;
    int i;
 
    if (!surf->lightmap) {
        return;
    }
    if (surf->drawflags & SURF_NOLM_MASK) {
        return;
    }
    if (!surf->texnum[1]) {
        return;
    }
 
#if USE_DLIGHTS
    // dynamic this frame or dynamic previously
    if (surf->dlightframe) {
        update_dynamic_lightmap(surf);
        return;
    }
#endif
 
    // check for light style updates
    for (i = 0; i < surf->numstyles; i++) {
        style = LIGHT_STYLE(surf, i);
        if (style->white != surf->stylecache[i]) {
            update_dynamic_lightmap(surf);
            return;
        }
    }
}

Referenced by GL_DrawBspModel(), and GL_DrawNode().

GL_RebuildLighting()

void GL_RebuildLighting

(

void

)

Definition at line 836 of file surf.c.

{
    if (!gl_static.world.cache)
        return;
 
    // if doing vertex lighting, rebuild all surfaces
    if (gl_fullbright->integer || gl_vertexlight->integer) {
        upload_world_surfaces();
        return;
    }
 
    // if did vertex lighting previously, rebuild all surfaces and lightmaps
    if (gl_fullbright->modified || gl_vertexlight->modified) {
        LM_BeginBuilding();
        upload_world_surfaces();
        LM_EndBuilding();
        return;
    }
 
    // rebuild all lightmaps
    LM_RebuildSurfaces();
}

Referenced by R_RenderFrame_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_SampleLightPoint()

void GL_SampleLightPoint

(

vec3_t

color

)

Definition at line 21 of file world.c.

{
    mface_t         *surf;
    int             s, t, i;
    byte            *lightmap;
    byte            *b1, *b2, *b3, *b4;
    int             fracu, fracv;
    int             w1, w2, w3, w4;
    byte            temp[3];
    int             smax, tmax, size;
    lightstyle_t    *style;
 
    fracu = glr.lightpoint.s & 15;
    fracv = glr.lightpoint.t & 15;
 
    // compute weights of lightmap blocks
    w1 = (16 - fracu) * (16 - fracv);
    w2 = fracu * (16 - fracv);
    w3 = fracu * fracv;
    w4 = (16 - fracu) * fracv;
 
    s = glr.lightpoint.s >> 4;
    t = glr.lightpoint.t >> 4;
 
    surf = glr.lightpoint.surf;
 
    smax = S_MAX(surf);
    tmax = T_MAX(surf);
    size = smax * tmax * 3;
 
    VectorClear(color);
 
    // add all the lightmaps with bilinear filtering
    lightmap = surf->lightmap;
    for (i = 0; i < surf->numstyles; i++) {
        b1 = &lightmap[3 * ((t + 0) * smax + (s + 0))];
        b2 = &lightmap[3 * ((t + 0) * smax + (s + 1))];
        b3 = &lightmap[3 * ((t + 1) * smax + (s + 1))];
        b4 = &lightmap[3 * ((t + 1) * smax + (s + 0))];
 
        temp[0] = (w1 * b1[0] + w2 * b2[0] + w3 * b3[0] + w4 * b4[0]) >> 8;
        temp[1] = (w1 * b1[1] + w2 * b2[1] + w3 * b3[1] + w4 * b4[1]) >> 8;
        temp[2] = (w1 * b1[2] + w2 * b2[2] + w3 * b3[2] + w4 * b4[2]) >> 8;
 
        style = LIGHT_STYLE(surf, i);
 
        color[0] += temp[0] * style->rgb[0];
        color[1] += temp[1] * style->rgb[1];
        color[2] += temp[2] * style->rgb[2];
 
        lightmap += size;
    }
}

Referenced by _GL_LightPoint(), and sample_surface_verts().

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_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_ShutdownImages()

void GL_ShutdownImages

(

void

)

Definition at line 940 of file images.c.

{
    gl_bilerp_chars->changed = NULL;
    gl_bilerp_pics->changed = NULL;
    gl_texturemode->changed = NULL;
    gl_texturemode->generator = NULL;
    gl_anisotropy->changed = NULL;
    gl_gamma->changed = NULL;
 
    // delete auto textures
    qglDeleteTextures(NUM_TEXNUMS, gl_static.texnums);
    qglDeleteTextures(LM_MAX_LIGHTMAPS, lm.texnums);
 
#ifdef _DEBUG
    r_charset = NULL;
#endif
 
    IMG_FreeAll();
    IMG_Shutdown();
 
    Scrap_Shutdown();
}

Referenced by R_Shutdown_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().

GL_TexCoordPointer()

static void GL_TexCoordPointer ( GLint  size, GLsizei  stride, const GLfloat *  pointer  )

inlinestatic

Definition at line 339 of file gl.h.

{
    GL_ClientActiveTexture(0);
    qglTexCoordPointer(size, GL_FLOAT, sizeof(GLfloat) * stride, pointer);
}

Referenced by draw_alias_mesh(), GL_BindArrays(), GL_DrawBeams(), GL_DrawParticles(), GL_Flush2D(), and R_DrawSkyBox().

GL_UnlockArrays()

static void GL_UnlockArrays ( void  )

inlinestatic

Definition at line 368 of file gl.h.

{
    if (qglUnlockArraysEXT) {
        qglUnlockArraysEXT();
    }
}

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

GL_VertexPointer()

static void GL_VertexPointer ( GLint  size, GLsizei  stride, const GLfloat *  pointer  )

inlinestatic

Definition at line 334 of file gl.h.

{
    qglVertexPointer(size, GL_FLOAT, sizeof(GLfloat) * stride, pointer);
}

Referenced by draw_alias_mesh(), GL_BindArrays(), GL_DrawBeams(), GL_DrawNullModel(), GL_DrawParticles(), GL_Flush2D(), and R_DrawSkyBox().

HQ2x_Init()

void HQ2x_Init

(

void

)

Definition at line 459 of file hq2x.c.

{
    int n;
 
    cvar_t *hqx_y  = Cvar_Get("hqx_y", "48", CVAR_FILES);
    cvar_t *hqx_cb = Cvar_Get("hqx_cb", "7", CVAR_FILES);
    cvar_t *hqx_cr = Cvar_Get("hqx_cr", "6", CVAR_FILES);
 
    maxY  = FIX(Cvar_ClampValue(hqx_y,  0, 256));
    maxCb = FIX(Cvar_ClampValue(hqx_cb, 0, 256));
    maxCr = FIX(Cvar_ClampValue(hqx_cr, 0, 256));
 
    for (n = 0; n < 256; n++) {
        rotTable[n] = ((n >> 2) & 0x11) | ((n << 2) & 0x88)
                    | ((n & 0x01) << 5) | ((n & 0x08) << 3)
                    | ((n & 0x10) >> 3) | ((n & 0x80) >> 5);
    }
 
    // libjpeg YCbCr coefficients
    for (n = 0; n < 256; n++) {
        yccTable[0][n] =  FIX(0.29900f) * n;
        yccTable[1][n] =  FIX(0.58700f) * n;
        yccTable[2][n] =  FIX(0.11400f) * n;
        yccTable[3][n] = -FIX(0.16874f) * n;
        yccTable[4][n] = -FIX(0.33126f) * n;
        yccTable[5][n] =  FIX(0.50000f) * n;
        yccTable[6][n] = -FIX(0.41869f) * n;
        yccTable[7][n] = -FIX(0.08131f) * n;
    }
}

Referenced by GL_InitImages().

HQ2x_Render()

void HQ2x_Render	(	uint32_t *	output,
		const uint32_t *	input,
		int	width,
		int	height
	)

Definition at line 357 of file hq2x.c.

{
    int x, y;
 
    for (y = 0; y < height; y++) {
        const uint32_t *in = input + y * width;
        uint32_t *out0 = output + (y * 2 + 0) * width * 2;
        uint32_t *out1 = output + (y * 2 + 1) * width * 2;
 
        int prevline = (y == 0 ? 0 : width);
        int nextline = (y == height - 1 ? 0 : width);
 
        for (x = 0; x < width; x++) {
            int prev = (x == 0 ? 0 : 1);
            int next = (x == width - 1 ? 0 : 1);
 
            uint32_t A = *(in - prevline - prev);
            uint32_t B = *(in - prevline);
            uint32_t C = *(in - prevline + next);
            uint32_t D = *(in - prev);
            uint32_t E = *(in);
            uint32_t F = *(in + next);
            uint32_t G = *(in + nextline - prev);
            uint32_t H = *(in + nextline);
            uint32_t I = *(in + nextline + next);
 
            int pattern;
            pattern  = diff(E, A) << 0;
            pattern |= diff(E, B) << 1;
            pattern |= diff(E, C) << 2;
            pattern |= diff(E, D) << 3;
            pattern |= diff(E, F) << 4;
            pattern |= diff(E, G) << 5;
            pattern |= diff(E, H) << 6;
            pattern |= diff(E, I) << 7;
 
            *(out0 + 0) = hq2x_blend(hqTable[pattern], E, A, B, D, F, H); pattern = rotTable[pattern];
            *(out0 + 1) = hq2x_blend(hqTable[pattern], E, C, F, B, H, D); pattern = rotTable[pattern];
            *(out1 + 1) = hq2x_blend(hqTable[pattern], E, I, H, F, D, B); pattern = rotTable[pattern];
            *(out1 + 0) = hq2x_blend(hqTable[pattern], E, G, D, H, B, F);
 
            in++;
            out0 += 2;
            out1 += 2;
        }
    }
}

Referenced by GL_Upscale32().

HQ4x_Render()

void HQ4x_Render	(	uint32_t *	output,
		const uint32_t *	input,
		int	width,
		int	height
	)

Definition at line 405 of file hq2x.c.

{
    int x, y;
 
    for (y = 0; y < height; y++) {
        const uint32_t *in = input + y * width;
        uint32_t *out0 = output + (y * 4 + 0) * width * 4;
        uint32_t *out1 = output + (y * 4 + 1) * width * 4;
        uint32_t *out2 = output + (y * 4 + 2) * width * 4;
        uint32_t *out3 = output + (y * 4 + 3) * width * 4;
 
        int prevline = (y == 0 ? 0 : width);
        int nextline = (y == height - 1 ? 0 : width);
 
        for (x = 0; x < width; x++) {
            int prev = (x == 0 ? 0 : 1);
            int next = (x == width - 1 ? 0 : 1);
 
            uint32_t A = *(in - prevline - prev);
            uint32_t B = *(in - prevline);
            uint32_t C = *(in - prevline + next);
            uint32_t D = *(in - prev);
            uint32_t E = *(in);
            uint32_t F = *(in + next);
            uint32_t G = *(in + nextline - prev);
            uint32_t H = *(in + nextline);
            uint32_t I = *(in + nextline + next);
 
            int pattern;
            pattern  = diff(E, A) << 0;
            pattern |= diff(E, B) << 1;
            pattern |= diff(E, C) << 2;
            pattern |= diff(E, D) << 3;
            pattern |= diff(E, F) << 4;
            pattern |= diff(E, G) << 5;
            pattern |= diff(E, H) << 6;
            pattern |= diff(E, I) << 7;
 
            hq4x_blend(hqTable[pattern], out0 + 0, out0 + 1, out1 + 0, out1 + 1, E, A, B, D, F, H); pattern = rotTable[pattern];
            hq4x_blend(hqTable[pattern], out0 + 3, out1 + 3, out0 + 2, out1 + 2, E, C, F, B, H, D); pattern = rotTable[pattern];
            hq4x_blend(hqTable[pattern], out3 + 3, out3 + 2, out2 + 3, out2 + 2, E, I, H, F, D, B); pattern = rotTable[pattern];
            hq4x_blend(hqTable[pattern], out3 + 0, out2 + 0, out3 + 1, out2 + 1, E, G, D, H, B, F);
 
            in++;
            out0 += 4;
            out1 += 4;
            out2 += 4;
            out3 += 4;
        }
    }
}

Referenced by GL_Upscale32().

IMG_Load_GL()

void IMG_Load_GL	(	image_t *	image,
		byte *	pic
	)

Definition at line 618 of file images.c.

{
    byte    *src, *dst;
    int     i, s, t, maxlevel;
    int     width, height;
 
    width = image->upload_width;
    height = image->upload_height;
 
    // load small pics onto the scrap
    if (image->type == IT_PIC && width < 64 && height < 64 &&
        gl_noscrap->integer == 0 && Scrap_AllocBlock(width, height, &s, &t)) {
        src = pic;
        dst = &scrap_data[(t * SCRAP_BLOCK_WIDTH + s) * 4];
        for (i = 0; i < height; i++) {
            memcpy(dst, src, width * 4);
            src += width * 4;
            dst += SCRAP_BLOCK_WIDTH * 4;
        }
 
        image->texnum = TEXNUM_SCRAP;
        image->flags |= IF_SCRAP | IF_TRANSPARENT;
        image->sl = (s + 0.01f) / (float)SCRAP_BLOCK_WIDTH;
        image->sh = (s + width - 0.01f) / (float)SCRAP_BLOCK_WIDTH;
        image->tl = (t + 0.01f) / (float)SCRAP_BLOCK_HEIGHT;
        image->th = (t + height - 0.01f) / (float)SCRAP_BLOCK_HEIGHT;
 
        maxlevel = GL_UpscaleLevel(SCRAP_BLOCK_WIDTH, SCRAP_BLOCK_HEIGHT, IT_PIC, IF_SCRAP);
        if (maxlevel)
            image->flags |= IF_UPSCALED;
 
        scrap_dirty = qtrue;
    } else {
        qglGenTextures(1, &image->texnum);
        GL_ForceTexture(0, image->texnum);
 
        maxlevel = GL_UpscaleLevel(width, height, image->type, image->flags);
        if (maxlevel) {
            GL_Upscale32(pic, width, height, maxlevel, image->type, image->flags);
            image->flags |= IF_UPSCALED;
        } else {
            GL_Upload32(pic, width, height, maxlevel, image->type, image->flags);
        }
 
        GL_SetFilterAndRepeat(image->type, image->flags);
 
        if (upload_alpha) {
            image->flags |= IF_TRANSPARENT;
        }
        image->upload_width = upload_width << maxlevel;     // after power of 2 and scales
        image->upload_height = upload_height << maxlevel;
        image->sl = 0;
        image->sh = 1;
        image->tl = 0;
        image->th = 1;
    }
 
    // don't need pics in memory after GL upload
    Z_Free(pic);
}

Referenced by R_RegisterFunctionsGL().

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().

IMG_Unload_GL()

void IMG_Unload_GL

(

image_t *

image

)

Definition at line 679 of file images.c.

{
    if (image->texnum && !(image->flags & IF_SCRAP)) {
        if (gls.texnums[0] == image->texnum)
            gls.texnums[0] = 0;
        qglDeleteTextures(1, &image->texnum);
        image->texnum = 0;
    }
}

Referenced by R_RegisterFunctionsGL().

MOD_LoadMD2_GL()

qerror_t MOD_LoadMD2_GL	(	model_t *	model,
		const void *	rawdata,
		size_t	length
	)

Definition at line 32 of file models.c.

{
    dmd2header_t    header;
    dmd2frame_t     *src_frame;
    dmd2trivertx_t  *src_vert;
    dmd2triangle_t  *src_tri;
    dmd2stvert_t    *src_tc;
    char            *src_skin;
    maliasframe_t   *dst_frame;
    maliasvert_t    *dst_vert;
    maliasmesh_t    *dst_mesh;
    maliastc_t      *dst_tc;
    int             i, j, k, val;
    uint16_t        remap[TESS_MAX_INDICES];
    uint16_t        vertIndices[TESS_MAX_INDICES];
    uint16_t        tcIndices[TESS_MAX_INDICES];
    uint16_t        finalIndices[TESS_MAX_INDICES];
    int             numverts, numindices;
    char            skinname[MAX_QPATH];
    vec_t           scale_s, scale_t;
    vec3_t          mins, maxs;
    qerror_t        ret;
 
    if (length < sizeof(header)) {
        return Q_ERR_FILE_TOO_SMALL;
    }
 
    // byte swap the header
    header = *(dmd2header_t *)rawdata;
    for (i = 0; i < sizeof(header) / 4; i++) {
        ((uint32_t *)&header)[i] = LittleLong(((uint32_t *)&header)[i]);
    }
 
    // validate the header
    ret = MOD_ValidateMD2(&header, length);
    if (ret) {
        if (ret == Q_ERR_TOO_FEW) {
            // empty models draw nothing
            model->type = MOD_EMPTY;
            return Q_ERR_SUCCESS;
        }
        return ret;
    }
 
    // load all triangle indices
    numindices = 0;
    src_tri = (dmd2triangle_t *)((byte *)rawdata + header.ofs_tris);
    for (i = 0; i < header.num_tris; i++) {
        for (j = 0; j < 3; j++) {
            uint16_t idx_xyz = LittleShort(src_tri->index_xyz[j]);
            uint16_t idx_st = LittleShort(src_tri->index_st[j]);
 
            // some broken models have 0xFFFF indices
            if (idx_xyz >= header.num_xyz || idx_st >= header.num_st) {
                break;
            }
 
            vertIndices[numindices + j] = idx_xyz;
            tcIndices[numindices + j] = idx_st;
        }
        if (j == 3) {
            // only count good triangles
            numindices += 3;
        }
        src_tri++;
    }
 
    if (numindices < 3) {
        return Q_ERR_TOO_FEW;
    }
 
    for (i = 0; i < numindices; i++) {
        remap[i] = 0xFFFF;
    }
 
    // remap all triangle indices
    numverts = 0;
    src_tc = (dmd2stvert_t *)((byte *)rawdata + header.ofs_st);
    for (i = 0; i < numindices; i++) {
        if (remap[i] != 0xFFFF) {
            continue; // already remapped
        }
 
        for (j = i + 1; j < numindices; j++) {
            if (vertIndices[i] == vertIndices[j] &&
                (src_tc[tcIndices[i]].s == src_tc[tcIndices[j]].s &&
                 src_tc[tcIndices[i]].t == src_tc[tcIndices[j]].t)) {
                // duplicate vertex
                remap[j] = i;
                finalIndices[j] = numverts;
            }
        }
 
        // new vertex
        remap[i] = i;
        finalIndices[i] = numverts++;
    }
 
    if (numverts > TESS_MAX_VERTICES) {
        return Q_ERR_TOO_MANY;
    }
 
    Hunk_Begin(&model->hunk, 0x400000);
    model->type = MOD_ALIAS;
    model->nummeshes = 1;
    model->numframes = header.num_frames;
    model->meshes = MOD_Malloc(sizeof(maliasmesh_t));
    model->frames = MOD_Malloc(header.num_frames * sizeof(maliasframe_t));
 
    dst_mesh = model->meshes;
    dst_mesh->numtris = numindices / 3;
    dst_mesh->numindices = numindices;
    dst_mesh->numverts = numverts;
    dst_mesh->numskins = header.num_skins;
    dst_mesh->verts = MOD_Malloc(numverts * header.num_frames * sizeof(maliasvert_t));
    dst_mesh->tcoords = MOD_Malloc(numverts * sizeof(maliastc_t));
    dst_mesh->indices = MOD_Malloc(numindices * sizeof(QGL_INDEX_TYPE));
 
    if (dst_mesh->numtris != header.num_tris) {
        Com_DPrintf("%s has %d bad triangles\n", model->name, header.num_tris - dst_mesh->numtris);
    }
 
    // store final triangle indices
    for (i = 0; i < numindices; i++) {
        dst_mesh->indices[i] = finalIndices[i];
    }
 
    // load all skins
    src_skin = (char *)rawdata + header.ofs_skins;
    for (i = 0; i < header.num_skins; i++) {
        if (!Q_memccpy(skinname, src_skin, 0, sizeof(skinname))) {
            ret = Q_ERR_STRING_TRUNCATED;
            goto fail;
        }
        FS_NormalizePath(skinname, skinname);
        dst_mesh->skins[i] = IMG_Find(skinname, IT_SKIN, IF_NONE);
        src_skin += MD2_MAX_SKINNAME;
    }
 
    // load all tcoords
    src_tc = (dmd2stvert_t *)((byte *)rawdata + header.ofs_st);
    dst_tc = dst_mesh->tcoords;
    scale_s = 1.0f / header.skinwidth;
    scale_t = 1.0f / header.skinheight;
    for (i = 0; i < numindices; i++) {
        if (remap[i] != i) {
            continue;
        }
        dst_tc[finalIndices[i]].st[0] =
            (int16_t)LittleShort(src_tc[tcIndices[i]].s) * scale_s;
        dst_tc[finalIndices[i]].st[1] =
            (int16_t)LittleShort(src_tc[tcIndices[i]].t) * scale_t;
    }
 
    // load all frames
    src_frame = (dmd2frame_t *)((byte *)rawdata + header.ofs_frames);
    dst_frame = model->frames;
    for (j = 0; j < header.num_frames; j++) {
        LittleVector(src_frame->scale, dst_frame->scale);
        LittleVector(src_frame->translate, dst_frame->translate);
 
        // load frame vertices
        ClearBounds(mins, maxs);
        for (i = 0; i < numindices; i++) {
            if (remap[i] != i) {
                continue;
            }
            src_vert = &src_frame->verts[vertIndices[i]];
            dst_vert = &dst_mesh->verts[j * numverts + finalIndices[i]];
 
            dst_vert->pos[0] = src_vert->v[0];
            dst_vert->pos[1] = src_vert->v[1];
            dst_vert->pos[2] = src_vert->v[2];
 
            val = src_vert->lightnormalindex;
            if (val >= NUMVERTEXNORMALS) {
                dst_vert->norm[0] = 0;
                dst_vert->norm[1] = 0;
            } else {
                dst_vert->norm[0] = gl_static.latlngtab[val][0];
                dst_vert->norm[1] = gl_static.latlngtab[val][1];
            }
 
            for (k = 0; k < 3; k++) {
                val = dst_vert->pos[k];
                if (val < mins[k])
                    mins[k] = val;
                if (val > maxs[k])
                    maxs[k] = val;
            }
        }
 
        VectorVectorScale(mins, dst_frame->scale, mins);
        VectorVectorScale(maxs, dst_frame->scale, maxs);
 
        dst_frame->radius = RadiusFromBounds(mins, maxs);
 
        VectorAdd(mins, dst_frame->translate, dst_frame->bounds[0]);
        VectorAdd(maxs, dst_frame->translate, dst_frame->bounds[1]);
 
        src_frame = (dmd2frame_t *)((byte *)src_frame + header.framesize);
        dst_frame++;
    }
 
    Hunk_End(&model->hunk);
    return Q_ERR_SUCCESS;
 
fail:
    Hunk_Free(&model->hunk);
    return ret;
}

Referenced by R_RegisterFunctionsGL().

MOD_LoadMD3_GL()

qerror_t MOD_LoadMD3_GL	(	model_t *	model,
		const void *	rawdata,
		size_t	length
	)

Referenced by R_RegisterFunctionsGL().

MOD_Reference_GL()

void MOD_Reference_GL

(

model_t *

model

)

Definition at line 425 of file models.c.

{
    int i, j;
 
    // register any images used by the models
    switch (model->type) {
    case MOD_ALIAS:
        for (i = 0; i < model->nummeshes; i++) {
            maliasmesh_t *mesh = &model->meshes[i];
            for (j = 0; j < mesh->numskins; j++) {
                mesh->skins[j]->registration_sequence = registration_sequence;
            }
        }
        break;
    case MOD_SPRITE:
        for (i = 0; i < model->numframes; i++) {
            model->spriteframes[i].image->registration_sequence = registration_sequence;
        }
        break;
    case MOD_EMPTY:
        break;
    default:
        Com_Error(ERR_FATAL, "%s: bad model type", __func__);
    }
 
    model->registration_sequence = registration_sequence;
}

Referenced by R_RegisterFunctionsGL().

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_AddSkySurface()

void R_AddSkySurface

(

mface_t *

surf

)

Definition at line 234 of file sky.c.

{
    int         i;
    vec3_t      verts[MAX_CLIP_VERTS];
    vec3_t      temp;
    msurfedge_t *surfedge;
    mvertex_t   *vert;
 
    if (fa->numsurfedges > MAX_CLIP_VERTS) {
        Com_DPrintf("%s: too many verts\n", __func__);
        return;
    }
 
    // calculate vertex values for sky box
    surfedge = fa->firstsurfedge;
    if (skyrotate) {
        if (!skyfaces)
            SetupRotationMatrix(skymatrix, skyaxis, glr.fd.time * skyrotate);
 
        for (i = 0; i < fa->numsurfedges; i++, surfedge++) {
            vert = surfedge->edge->v[surfedge->vert];
            VectorSubtract(vert->point, glr.fd.vieworg, temp);
            SkyInverseRotate(verts[i], temp);
        }
    } else {
        for (i = 0; i < fa->numsurfedges; i++, surfedge++) {
            vert = surfedge->edge->v[surfedge->vert];
            VectorSubtract(vert->point, glr.fd.vieworg, verts[i]);
        }
    }
 
    ClipSkyPolygon(fa->numsurfedges, verts[0], 0);
    skyfaces++;
}

Referenced by GL_DrawNode().

R_ClampScaleGL()

float R_ClampScaleGL

(

cvar_t *

var

)

R_ClearColor_GL()

void R_ClearColor_GL

(

void

)

Definition at line 92 of file draw.c.

{
    draw.colors[0].u32 = U32_WHITE;
    draw.colors[1].u32 = U32_WHITE;
}

Referenced by R_RegisterFunctionsGL().

R_ClearSkyBox()

void R_ClearSkyBox

(

void

)

Definition at line 274 of file sky.c.

{
    int i;
 
    for (i = 0; i < 6; i++) {
        skymins[0][i] = skymins[1][i] = 9999;
        skymaxs[0][i] = skymaxs[1][i] = -9999;
    }
 
    skyfaces = 0;
}

Referenced by GL_DrawWorld().

R_DrawChar_GL()

void R_DrawChar_GL	(	int	x,
		int	y,
		int	flags,
		int	c,
		qhandle_t	font
	)

Definition at line 242 of file draw.c.

{
    draw_char(x, y, flags, c & 255, IMG_ForHandle(font));
}

Referenced by R_RegisterFunctionsGL().

R_DrawFill32_GL()

void R_DrawFill32_GL	(	int	x,
		int	y,
		int	w,
		int	h,
		uint32_t	color
	)

Definition at line 202 of file draw.c.

{
    if (!w || !h)
        return;
    _GL_StretchPic(x, y, w, h, 0, 0, 1, 1, color, TEXNUM_WHITE, 0);
}

Referenced by R_RegisterFunctionsGL().

R_DrawFill8_GL()

void R_DrawFill8_GL	(	int	x,
		int	y,
		int	w,
		int	h,
		int	c
	)

Definition at line 195 of file draw.c.

{
    if (!w || !h)
        return;
    _GL_StretchPic(x, y, w, h, 0, 0, 1, 1, d_8to24table[c & 0xff], TEXNUM_WHITE, 0);
}

Referenced by R_RegisterFunctionsGL().

R_DrawPic_GL()

void R_DrawPic_GL	(	int	x,
		int	y,
		qhandle_t	pic
	)

Definition at line 179 of file draw.c.

{
    image_t *image = IMG_ForHandle(pic);
 
    GL_StretchPic(x, y, image->width, image->height,
                  image->sl, image->tl, image->sh, image->th, draw.colors[0].u32, image);
}

Referenced by R_RegisterFunctionsGL().

R_DrawSkyBox()

void R_DrawSkyBox

(

void

)

Definition at line 337 of file sky.c.

{
    static const int skytexorder[6] = {0, 2, 1, 3, 4, 5};
    vec5_t verts[4];
    int i;
 
    // check for no sky at all
    if (!skyfaces)
        return; // nothing visible
 
    GL_StateBits(GLS_TEXTURE_REPLACE);
    GL_ArrayBits(GLA_VERTEX | GLA_TC);
    GL_VertexPointer(3, 5, &verts[0][0]);
    GL_TexCoordPointer(2, 5, &verts[0][3]);
 
    for (i = 0; i < 6; i++) {
        if (!SKY_VISIBLE(i)) {
            continue;
        }
 
        GL_BindTexture(0, sky_images[skytexorder[i]]);
 
        MakeSkyVec(skymaxs[0][i], skymins[1][i], i, verts[0]);
        MakeSkyVec(skymins[0][i], skymins[1][i], i, verts[1]);
        MakeSkyVec(skymaxs[0][i], skymaxs[1][i], i, verts[2]);
        MakeSkyVec(skymins[0][i], skymaxs[1][i], i, verts[3]);
        qglDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    }
}

Referenced by GL_DrawWorld().

R_DrawStretchPic_GL()

void R_DrawStretchPic_GL	(	int	x,
		int	y,
		int	w,
		int	h,
		qhandle_t	pic
	)

Definition at line 171 of file draw.c.

{
    image_t *image = IMG_ForHandle(pic);
 
    GL_StretchPic(x, y, w, h, image->sl, image->tl, image->sh, image->th,
                  draw.colors[0].u32, image);
}

Referenced by R_RegisterFunctionsGL().

R_DrawString_GL()

int R_DrawString_GL	(	int	x,
		int	y,
		int	flags,
		size_t	maxlen,
		const char *	s,
		qhandle_t	font
	)

Definition at line 247 of file draw.c.

{
    image_t *image = IMG_ForHandle(font);
 
    while (maxlen-- && *s) {
        byte c = *s++;
        draw_char(x, y, flags, c, image);
        x += CHAR_WIDTH;
    }
 
    return x;
}

Referenced by R_RegisterFunctionsGL().

R_LightPoint_GL()

void R_LightPoint_GL	(	vec3_t	origin,
		vec3_t	color
	)

Definition at line 254 of file world.c.

{
    int i;
 
    GL_LightPoint(origin, color);
 
    for (i = 0; i < 3; i++) {
        clamp(color[i], 0, 1);
    }
}

Referenced by R_RegisterFunctionsGL().

R_SetAlpha_GL()

void R_SetAlpha_GL

(

float

alpha

)

Definition at line 98 of file draw.c.

{
    draw.colors[0].u8[3] =
        draw.colors[1].u8[3] = alpha * 255;
}

Referenced by R_RegisterFunctionsGL().

R_SetAlphaScale_GL()

void R_SetAlphaScale_GL

(

float

alpha

)

Definition at line 104 of file draw.c.

{
    // nop - only used by the RTX renderer
}

Referenced by R_RegisterFunctionsGL().

R_SetClipRect_GL()

void R_SetClipRect_GL

(

const clipRect_t *

clip

)

Definition at line 115 of file draw.c.

{
    clipRect_t rc;
    float scale;
 
    GL_Flush2D();
 
    if (!clip) {
clear:
        if (draw.scissor) {
            qglDisable(GL_SCISSOR_TEST);
            draw.scissor = qfalse;
        }
        return;
    }
 
    scale = 1 / draw.scale;
 
    rc.left = clip->left * scale;
    rc.top = clip->top * scale;
    rc.right = clip->right * scale;
    rc.bottom = clip->bottom * scale;
 
    if (rc.left < 0)
        rc.left = 0;
    if (rc.top < 0)
        rc.top = 0;
    if (rc.right > r_config.width)
        rc.right = r_config.width;
    if (rc.bottom > r_config.height)
        rc.bottom = r_config.height;
    if (rc.right < rc.left)
        goto clear;
    if (rc.bottom < rc.top)
        goto clear;
 
    qglEnable(GL_SCISSOR_TEST);
    qglScissor(rc.left, r_config.height - rc.bottom,
               rc.right - rc.left, rc.bottom - rc.top);
    draw.scissor = qtrue;
}

Referenced by R_RegisterFunctionsGL().

R_SetColor_GL()

void R_SetColor_GL

(

uint32_t

color

)

Definition at line 109 of file draw.c.

{
    draw.colors[0].u32 = color;
    draw.colors[1].u8[3] = draw.colors[0].u8[3];
}

Referenced by R_RegisterFunctionsGL().

R_SetScale_GL()

void R_SetScale_GL

(

float

scale

)

Definition at line 157 of file draw.c.

{
    if (draw.scale == scale) {
        return;
    }
 
    GL_Flush2D();
 
    GL_Ortho(0, Q_rint(r_config.width * scale),
             Q_rint(r_config.height * scale), 0, -1, 1);
 
    draw.scale = scale;
}

Referenced by R_RegisterFunctionsGL().

R_SetSky_GL()

void R_SetSky_GL	(	const char *	name,
		float	rotate,
		vec3_t	axis
	)

Definition at line 382 of file sky.c.

{
    int     i;
    char    pathname[MAX_QPATH];
    image_t *image;
    size_t  len;
    // 3dstudio environment map names
    static const char suf[6][3] = { "rt", "bk", "lf", "ft", "up", "dn" };
 
    if (!gl_drawsky->integer) {
        R_UnsetSky();
        return;
    }
 
    skyrotate = rotate;
    VectorNormalize2(axis, skyaxis);
 
    for (i = 0; i < 6; i++) {
        len = Q_concat(pathname, sizeof(pathname),
                       "env/", name, suf[i], ".tga", NULL);
        if (len >= sizeof(pathname)) {
            R_UnsetSky();
            return;
        }
        FS_NormalizePath(pathname, pathname);
        image = IMG_Find(pathname, IT_SKY, IF_NONE);
        if (image->texnum == TEXNUM_DEFAULT) {
            R_UnsetSky();
            return;
        }
        sky_images[i] = image->texnum;
    }
}

Referenced by R_RegisterFunctionsGL().

R_TileClear_GL()

void R_TileClear_GL	(	int	x,
		int	y,
		int	w,
		int	h,
		qhandle_t	pic
	)

Definition at line 189 of file draw.c.

{
    GL_StretchPic(x, y, w, h, x * DIV64, y * DIV64,
                  (x + w) * DIV64, (y + h) * DIV64, U32_WHITE, IMG_ForHandle(pic));
}

Referenced by R_RegisterFunctionsGL().

Scrap_Upload()

void Scrap_Upload

(

void

)

Definition at line 220 of file images.c.

{
    int maxlevel;
 
    if (!scrap_dirty) {
        return;
    }
 
    GL_ForceTexture(0, TEXNUM_SCRAP);
 
    maxlevel = GL_UpscaleLevel(SCRAP_BLOCK_WIDTH, SCRAP_BLOCK_HEIGHT, IT_PIC, IF_SCRAP);
    if (maxlevel) {
        GL_Upscale32(scrap_data, SCRAP_BLOCK_WIDTH, SCRAP_BLOCK_HEIGHT, maxlevel, IT_PIC, IF_SCRAP);
        GL_SetFilterAndRepeat(IT_PIC, IF_SCRAP | IF_UPSCALED);
    } else {
        GL_Upload32(scrap_data, SCRAP_BLOCK_WIDTH, SCRAP_BLOCK_HEIGHT, maxlevel, IT_PIC, IF_SCRAP);
        GL_SetFilterAndRepeat(IT_PIC, IF_SCRAP);
    }
 
    scrap_dirty = qfalse;
}

Referenced by GL_Flush2D(), and R_EndRegistration_GL().

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().

draw

drawStatic_t draw

Definition at line 21 of file draw.c.

gl_brightness

cvar_t* gl_brightness

Definition at line 45 of file main.c.

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_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_drawsky

cvar_t* gl_drawsky

Definition at line 60 of file main.c.

Referenced by GL_Register(), and R_SetSky_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_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.

gl_modulate_world

cvar_t* gl_modulate_world

Definition at line 43 of file main.c.

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_shadows

cvar_t* gl_shadows

Definition at line 41 of file main.c.

Referenced by GL_Register(), and setup_shadow().

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_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().

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().

lm

lightmap_builder_t lm

Definition at line 25 of file surf.c.

Referenced by adjust_color_f(), adjust_color_ub(), build_primary_lightmap(), GL_BindArrays(), GL_InitImages(), gl_lightmap_changed(), GL_ShutdownImages(), LM_BeginBuilding(), LM_BuildSurface(), LM_EndBuilding(), LM_InitBlock(), LM_RebuildSurfaces(), LM_UploadBlock(), and R_RenderFrame_GL().

tess

tesselator_t tess

Definition at line 21 of file tess.c.

Referenced by _GL_StretchPic(), draw_alias_mesh(), GL_BindArrays(), GL_CopyVerts(), GL_DrawBeams(), GL_DrawFace(), GL_DrawParticles(), GL_Flush2D(), GL_Flush3D(), tess_lerped_plain(), tess_lerped_shade(), tess_lerped_shell(), tess_static_plain(), tess_static_shade(), tess_static_shell(), upload_surface_vbo(), and upload_world_surfaces().