sw.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/client.h"
#include "client/video.h"
#include "refresh/refresh.h"
#include "refresh/images.h"
#include "refresh/models.h"
#include "system/system.h"

Go to the source code of this file.

Classes
struct	viddef_t
struct	oldrefdef_t
struct	emitpoint_t
struct	finalvert_s
struct	affinetridesc_t
struct	drawsurf_s
struct	bedge_s
struct	clipplane_s
struct	surfcache_s
struct	espan_s
struct	polydesc_t
struct	surf_s
struct	edge_s
struct	maliasst_s
struct	maliastri_s
struct	maliasvert_s
struct	maliasframe_s
struct	aliastriangleparms_t

Macros
#define	REF_VERSION   "SOFT 0.01"
#define	DSURF_SKY   2
#define	DSURF_TURB   4
#define	DSURF_BACKGROUND   8
#define	CACHE_SIZE   32
#define	VID_BYTES   4
#define	TEX_BYTES   4
#define	MAXVERTS   64
#define	MAXWORKINGVERTS   (MAXVERTS + 4)
#define	MAXHEIGHT   1200
#define	MAXWIDTH   1600
#define	INFINITE_DISTANCE   0x10000
#define	WARP_WIDTH   320
#define	WARP_HEIGHT   240
#define	PARTICLE_Z_CLIP   8.0
#define	TRANSPARENT_COLOR   0xFF
#define	TURB_SIZE   64
#define	TURB_MASK   (TURB_SIZE - 1)
#define	CYCLE   128
#define	DS_SPAN_LIST_END   -128
#define	NUMSTACKEDGES   3000
#define	MINEDGES   NUMSTACKEDGES
#define	MAXEDGES   30000
#define	NUMSTACKSURFACES   1000
#define	MINSURFACES   NUMSTACKSURFACES
#define	MAXSURFACES   10000
#define	MAXSPANS   3000
#define	ALIAS_LEFT_CLIP   0x0001
#define	ALIAS_TOP_CLIP   0x0002
#define	ALIAS_RIGHT_CLIP   0x0004
#define	ALIAS_BOTTOM_CLIP   0x0008
#define	ALIAS_Z_CLIP   0x0010
#define	ALIAS_XY_CLIP_MASK   0x000F
#define	SURFCACHE_SIZE_AT_320X240   1024*768
#define	BMODEL_FULLY_CLIPPED   0x10
#define	CLIP_EPSILON   0.001
#define	BACKFACE_EPSILON   0.01
#define	NEAR_CLIP   0.01
#define	ALIAS_Z_CLIP_PLANE   4
#define	AMP   8*0x10000
#define	AMP2   3
#define	SPEED   20
#define	MAX_BLOCKLIGHTS   1024
#define	LIGHTMAP_BYTES   3

Typedefs
typedef unsigned char	pixel_t
typedef struct finalvert_s	finalvert_t
typedef struct drawsurf_s	drawsurf_t
typedef struct bedge_s	bedge_t
typedef struct clipplane_s	clipplane_t
typedef int	blocklight_t
typedef struct surfcache_s	surfcache_t
typedef struct espan_s	espan_t
typedef struct surf_s	surf_t
typedef struct edge_s	edge_t
typedef struct maliasst_s	maliasst_t
typedef struct maliastri_s	maliastri_t
typedef struct maliasvert_s	maliasvert_t
typedef struct maliasframe_s	maliasframe_t

Functions
void	D_DrawSurfaces (void)
void	D_WarpScreen (void)
void	D_DrawTurbulent16 (espan_t *pspan, int *warptable)
void	D_DrawSpans16 (espan_t *pspans)
void	D_DrawZSpans (espan_t *pspans)
surfcache_t *	D_CacheSurface (mface_t *surface, int miplevel)
void	R_TransformVector (vec3_t in, vec3_t out)
void	R_RenderWorld (void)
void	R_DrawAlphaSurfaces (void)
void	R_DrawSprite (void)
void	R_DrawBeam (entity_t *e)
void	R_RenderFace (mface_t *fa, int clipflags)
void	R_RenderBmodelFace (bedge_t *pedges, mface_t *psurf)
void	R_TransformPlane (cplane_t *p, float *normal, float *dist)
void	R_TransformFrustum (void)
void	R_DrawSubmodelPolygons (mmodel_t *pmodel, int clipflags, mnode_t *topnode)
void	R_DrawSolidClippedSubmodelPolygons (mmodel_t *pmodel, mnode_t *topnode)
void	R_AliasDrawModel (void)
void	R_BeginEdgeFrame (void)
void	R_ScanEdges (void)
void	R_MarkLights (mnode_t *headnode)
void	R_RotateBmodel (void)
void	R_DrawParticles (void)
void	R_DrawTriangle (void)
void	R_AliasClipTriangle (finalvert_t *index0, finalvert_t *index1, finalvert_t *index2)
void	R_AliasProjectAndClipTestFinalVert (finalvert_t *fv)
void	R_PrintAliasStats (void)
void	R_PrintTimes (void)
void	R_LightPoint (vec3_t p, vec3_t color)
void	R_SetupFrame (void)
void	R_BuildLightMap (void)
void	R_NewMap (void)
void	R_InitCaches (void)
void	R_FreeCaches (void)
void	D_FlushCaches (void)
void	D_SCDump_f (void)
void	R_InitTurb (void)
void	R_InitImages (void)
void	R_ShutdownImages (void)
void	R_BuildGammaTable (void)
void	R_InitSkyBox (void)
void	R_EmitSkyBox (void)
void	R_ApplySIRDAlgorithum (void)
void	R_IMFlatShadedQuad (vec3_t a, vec3_t b, vec3_t c, vec3_t d, color_t color, float alpha)
void	R_InitDraw (void)

Variables
int	r_framecount
qboolean	r_dowarp
affinetridesc_t	r_affinetridesc
drawsurf_t	r_drawsurf
int	c_surf
byte	r_warpbuffer [WARP_WIDTH *WARP_HEIGHT *VID_BYTES]
float	d_sdivzstepu
float	d_tdivzstepu
float	d_zistepu
float	d_sdivzstepv
float	d_tdivzstepv
float	d_zistepv
float	d_sdivzorigin
float	d_tdivzorigin
float	d_ziorigin
fixed16_t	sadjust
fixed16_t	tadjust
fixed16_t	bbextents
fixed16_t	bbextentt
pixel_t *	d_viewbuffer
int	d_screenrowbytes
short *	d_pzbuffer
int	d_zrowbytes
int	d_zwidth
byte *	d_spantable [MAXHEIGHT]
short *	d_zspantable [MAXHEIGHT]
int	d_minmip
float	d_scalemip [3]
viddef_t	vid
oldrefdef_t	r_refdef
int	cachewidth
pixel_t *	cacheblock
int	r_drawnpolycount
int	sintable [CYCLE *2]
int	intsintable [CYCLE *2]
int	blanktable [CYCLE *2]
vec3_t	vup
vec3_t	base_vup
vec3_t	vpn
vec3_t	base_vpn
vec3_t	vright
vec3_t	base_vright
surf_t *	auxsurfaces
surf_t *	surfaces
surf_t *	surface_p
surf_t *	surf_max
vec3_t	sxformaxis [4]
vec3_t	txformaxis [4]
cvar_t *	sw_aliasstats
cvar_t *	sw_clearcolor
cvar_t *	sw_drawflat
cvar_t *	sw_draworder
cvar_t *	sw_maxedges
cvar_t *	sw_maxsurfs
cvar_t *	sw_mipcap
cvar_t *	sw_mipscale
cvar_t *	sw_mode
cvar_t *	sw_reportsurfout
cvar_t *	sw_reportedgeout
cvar_t *	sw_surfcacheoverride
cvar_t *	sw_waterwarp
cvar_t *	sw_drawsird
cvar_t *	sw_dynamic
cvar_t *	sw_modulate
cvar_t *	r_fullbright
cvar_t *	r_drawentities
cvar_t *	r_drawworld
cvar_t *	r_lerpmodels
cvar_t *	r_speeds
cvar_t *	vid_fullscreen
cvar_t *	vid_gamma
clipplane_t	view_clipplanes [4]
int *	pfrustum_indexes [4]
cplane_t	screenedge [4]
vec3_t	r_origin
entity_t	r_worldentity
model_t *	currentmodel
entity_t *	currententity
vec3_t	modelorg
vec3_t	r_entorigin
vec3_t	entity_rotation [3]
int	r_visframecount
mface_t *	r_alpha_surfaces
qboolean	insubmodel
int	c_faceclip
int	r_polycount
int	r_wholepolycount
mvertex_t *	r_ptverts
mvertex_t *	r_ptvertsmax
int	r_currentkey
int	r_currentbkey
int	r_amodels_drawn
edge_t *	auxedges
int	r_numallocatededges
edge_t *	r_edges
edge_t *	edge_p
edge_t *	edge_max
edge_t *	newedges [MAXHEIGHT]
edge_t *	removeedges [MAXHEIGHT]
fixed8_t	r_aliasblendcolor [3]
int	r_alias_alpha
int	r_alias_one_minus_alpha
int	r_outofsurfaces
int	r_outofedges
int	r_maxvalidedgeoffset
aliastriangleparms_t	aliastriangleparms
float	r_time1
int	r_frustum_indexes [4 *6]
int	r_maxsurfsseen
int	r_maxedgesseen
int	r_cnumsurfs
qboolean	r_surfsonstack
mleaf_t *	r_viewleaf
int	r_viewcluster
int	r_oldviewcluster
int	r_clipflags
int	r_dlightframecount
bsp_t *	r_worldmodel
blocklight_t	blocklights [MAX_BLOCKLIGHTS *LIGHTMAP_BYTES]
refdef_t	r_newrefdef

Macro Definition Documentation

ALIAS_BOTTOM_CLIP

#define ALIAS_BOTTOM_CLIP   0x0008

Definition at line 90 of file sw.h.

ALIAS_LEFT_CLIP

#define ALIAS_LEFT_CLIP   0x0001

Definition at line 87 of file sw.h.

ALIAS_RIGHT_CLIP

#define ALIAS_RIGHT_CLIP   0x0004

Definition at line 89 of file sw.h.

ALIAS_TOP_CLIP

#define ALIAS_TOP_CLIP   0x0002

Definition at line 88 of file sw.h.

ALIAS_XY_CLIP_MASK

#define ALIAS_XY_CLIP_MASK   0x000F

Definition at line 92 of file sw.h.

ALIAS_Z_CLIP

#define ALIAS_Z_CLIP   0x0010

Definition at line 91 of file sw.h.

ALIAS_Z_CLIP_PLANE

#define ALIAS_Z_CLIP_PLANE   4

Definition at line 105 of file sw.h.

AMP

#define AMP   8*0x10000

Definition at line 108 of file sw.h.

AMP2

#define AMP2   3

Definition at line 109 of file sw.h.

BACKFACE_EPSILON

#define BACKFACE_EPSILON   0.01

Definition at line 101 of file sw.h.

BMODEL_FULLY_CLIPPED

#define BMODEL_FULLY_CLIPPED   0x10

Definition at line 96 of file sw.h.

CACHE_SIZE

#define CACHE_SIZE   32

Definition at line 47 of file sw.h.

CLIP_EPSILON

#define CLIP_EPSILON   0.001

Definition at line 99 of file sw.h.

CYCLE

#define CYCLE   128

Definition at line 74 of file sw.h.

DS_SPAN_LIST_END

#define DS_SPAN_LIST_END   -128

Definition at line 76 of file sw.h.

DSURF_BACKGROUND

#define DSURF_BACKGROUND   8

Definition at line 45 of file sw.h.

DSURF_SKY

#define DSURF_SKY   2

Definition at line 43 of file sw.h.

DSURF_TURB

#define DSURF_TURB   4

Definition at line 44 of file sw.h.

INFINITE_DISTANCE

#define INFINITE_DISTANCE   0x10000

Definition at line 60 of file sw.h.

LIGHTMAP_BYTES

#define LIGHTMAP_BYTES   3

Definition at line 203 of file sw.h.

MAX_BLOCKLIGHTS

#define MAX_BLOCKLIGHTS   1024

Definition at line 202 of file sw.h.

MAXEDGES

#define MAXEDGES   30000

Definition at line 80 of file sw.h.

MAXHEIGHT

#define MAXHEIGHT   1200

Definition at line 57 of file sw.h.

MAXSPANS

#define MAXSPANS   3000

Definition at line 84 of file sw.h.

MAXSURFACES

#define MAXSURFACES   10000

Definition at line 83 of file sw.h.

MAXVERTS

#define MAXVERTS   64

Definition at line 53 of file sw.h.

MAXWIDTH

#define MAXWIDTH   1600

Definition at line 58 of file sw.h.

MAXWORKINGVERTS

#define MAXWORKINGVERTS   (MAXVERTS + 4)

Definition at line 54 of file sw.h.

MINEDGES

#define MINEDGES   NUMSTACKEDGES

Definition at line 79 of file sw.h.

MINSURFACES

#define MINSURFACES   NUMSTACKSURFACES

Definition at line 82 of file sw.h.

NEAR_CLIP

#define NEAR_CLIP   0.01

Definition at line 103 of file sw.h.

NUMSTACKEDGES

#define NUMSTACKEDGES   3000

Definition at line 78 of file sw.h.

NUMSTACKSURFACES

#define NUMSTACKSURFACES   1000

Definition at line 81 of file sw.h.

PARTICLE_Z_CLIP

#define PARTICLE_Z_CLIP   8.0

Definition at line 67 of file sw.h.

REF_VERSION

#define REF_VERSION   "SOFT 0.01"

Definition at line 33 of file sw.h.

SPEED

#define SPEED   20

Definition at line 110 of file sw.h.

SURFCACHE_SIZE_AT_320X240

#define SURFCACHE_SIZE_AT_320X240   1024*768

Definition at line 94 of file sw.h.

TEX_BYTES

#define TEX_BYTES   4

Definition at line 50 of file sw.h.

TRANSPARENT_COLOR

#define TRANSPARENT_COLOR   0xFF

Definition at line 69 of file sw.h.

TURB_MASK

#define TURB_MASK   (TURB_SIZE - 1)

Definition at line 72 of file sw.h.

TURB_SIZE

#define TURB_SIZE   64

Definition at line 71 of file sw.h.

VID_BYTES

#define VID_BYTES   4

Definition at line 49 of file sw.h.

WARP_HEIGHT

#define WARP_HEIGHT   240

Definition at line 65 of file sw.h.

WARP_WIDTH

#define WARP_WIDTH   320

Definition at line 64 of file sw.h.

Typedef Documentation

bedge_t

typedef struct bedge_s bedge_t

blocklight_t

typedef int blocklight_t

Definition at line 205 of file sw.h.

clipplane_t

typedef struct clipplane_s clipplane_t

drawsurf_t

typedef struct drawsurf_s drawsurf_t

edge_t

typedef struct edge_s edge_t

espan_t

typedef struct espan_s espan_t

finalvert_t

typedef struct finalvert_s finalvert_t

maliasframe_t

typedef struct maliasframe_s maliasframe_t

maliasst_t

typedef struct maliasst_s maliasst_t

maliastri_t

typedef struct maliastri_s maliastri_t

maliasvert_t

typedef struct maliasvert_s maliasvert_t

pixel_t

typedef unsigned char pixel_t

Definition at line 121 of file sw.h.

surf_t

typedef struct surf_s surf_t

surfcache_t

typedef struct surfcache_s surfcache_t

Function Documentation

D_CacheSurface()

surfcache_t* D_CacheSurface	(	mface_t *	surface,
		int	miplevel
	)

Definition at line 330 of file surf.c.

{
    surfcache_t     *cache;
    float           surfscale;
 
//
// if the surface is animating or flashing, flush the cache
//
    r_drawsurf.image = R_TextureAnimation(surface->texinfo);
    r_drawsurf.lightadj[0] = r_newrefdef.lightstyles[surface->styles[0]].white * sw_modulate->value * 256;
    r_drawsurf.lightadj[1] = r_newrefdef.lightstyles[surface->styles[1]].white * sw_modulate->value * 256;
    r_drawsurf.lightadj[2] = r_newrefdef.lightstyles[surface->styles[2]].white * sw_modulate->value * 256;
    r_drawsurf.lightadj[3] = r_newrefdef.lightstyles[surface->styles[3]].white * sw_modulate->value * 256;
 
//
// see if the cache holds apropriate data
//
    cache = surface->cachespots[miplevel];
 
    if (cache && !cache->dlight && surface->dlightframe != r_framecount
        && cache->image == r_drawsurf.image
        && cache->lightadj[0] == r_drawsurf.lightadj[0]
        && cache->lightadj[1] == r_drawsurf.lightadj[1]
        && cache->lightadj[2] == r_drawsurf.lightadj[2]
        && cache->lightadj[3] == r_drawsurf.lightadj[3])
        return cache;
 
//
// determine shape of surface
//
    surfscale = 1.0 / (1 << miplevel);
    r_drawsurf.surfmip = miplevel;
    r_drawsurf.surfwidth = surface->extents[0] >> miplevel;
    r_drawsurf.rowbytes = r_drawsurf.surfwidth * TEX_BYTES;
    r_drawsurf.surfheight = surface->extents[1] >> miplevel;
 
//
// allocate memory if needed
//
    if (!cache) {   // if a texture just animated, don't reallocate it
        cache = D_SCAlloc(r_drawsurf.surfwidth,
                          r_drawsurf.surfwidth * r_drawsurf.surfheight * TEX_BYTES);
        surface->cachespots[miplevel] = cache;
        cache->owner = &surface->cachespots[miplevel];
        cache->mipscale = surfscale;
    }
 
    if (surface->dlightframe == r_framecount)
        cache->dlight = 1;
    else
        cache->dlight = 0;
 
    r_drawsurf.surfdat = (pixel_t *)cache->data;
 
    cache->image = r_drawsurf.image;
    cache->lightadj[0] = r_drawsurf.lightadj[0];
    cache->lightadj[1] = r_drawsurf.lightadj[1];
    cache->lightadj[2] = r_drawsurf.lightadj[2];
    cache->lightadj[3] = r_drawsurf.lightadj[3];
 
//
// draw and light the surface texture
//
    r_drawsurf.surf = surface;
 
    c_surf++;
 
    // calculate the lightings
    R_BuildLightMap();
 
    // rasterize the surface into the cache
    R_DrawSurface();
 
    return cache;
}

Referenced by D_SolidSurf(), and R_BuildPolygonFromSurface().

D_DrawSpans16()

void D_DrawSpans16

(

espan_t *

pspans

)

Definition at line 222 of file scan.c.

{
    int             count, spancount;
    byte            *pbase, *pdest, *ptex;
    fixed16_t       s, t, snext, tnext, sstep, tstep;
    float           sdivz, tdivz, zi, z, du, dv, spancountminus1;
    float           sdivz16stepu, tdivz16stepu, zi16stepu;
 
    sstep = 0;  // keep compiler happy
    tstep = 0;  // ditto
 
    pbase = (byte *)cacheblock;
 
    sdivz16stepu = d_sdivzstepu * 16;
    tdivz16stepu = d_tdivzstepu * 16;
    zi16stepu = d_zistepu * 16;
 
    do {
        pdest = d_spantable[pspan->v] + pspan->u * VID_BYTES;
 
        count = pspan->count;
 
        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
        du = (float)pspan->u;
        dv = (float)pspan->v;
 
        sdivz = d_sdivzorigin + dv * d_sdivzstepv + du * d_sdivzstepu;
        tdivz = d_tdivzorigin + dv * d_tdivzstepv + du * d_tdivzstepu;
        zi = d_ziorigin + dv * d_zistepv + du * d_zistepu;
        z = (float)0x10000 / zi;    // prescale to 16.16 fixed-point
 
        s = (int)(sdivz * z) + sadjust;
        if (s > bbextents)
            s = bbextents;
        else if (s < 0)
            s = 0;
 
        t = (int)(tdivz * z) + tadjust;
        if (t > bbextentt)
            t = bbextentt;
        else if (t < 0)
            t = 0;
 
        do {
            // calculate s and t at the far end of the span
            if (count >= 16)
                spancount = 16;
            else
                spancount = count;
 
            count -= spancount;
 
            if (q_likely(count)) {
                // calculate s/z, t/z, zi->fixed s and t at far end of span,
                // calculate s and t steps across span by shifting
                sdivz += sdivz16stepu;
                tdivz += tdivz16stepu;
                zi += zi16stepu;
                z = (float)0x10000 / zi;    // prescale to 16.16 fixed-point
 
                snext = (int)(sdivz * z) + sadjust;
                if (snext > bbextents)
                    snext = bbextents;
                else if (snext < 16)
                    snext = 16; // prevent round-off error on <0 steps from
                                // from causing overstepping & running off the
                                // edge of the texture
 
                tnext = (int)(tdivz * z) + tadjust;
                if (tnext > bbextentt)
                    tnext = bbextentt;
                else if (tnext < 16)
                    tnext = 16;  // guard against round-off error on <0 steps
 
                sstep = (snext - s) >> 4;
                tstep = (tnext - t) >> 4;
            } else {
                // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
                // can't step off polygon), clamp, calculate s and t steps across
                // span by division, biasing steps low so we don't run off the
                // texture
                spancountminus1 = (float)(spancount - 1);
                sdivz += d_sdivzstepu * spancountminus1;
                tdivz += d_tdivzstepu * spancountminus1;
                zi += d_zistepu * spancountminus1;
                z = (float)0x10000 / zi;    // prescale to 16.16 fixed-point
 
                snext = (int)(sdivz * z) + sadjust;
                if (snext > bbextents)
                    snext = bbextents;
                else if (snext < 16)
                    snext = 16; // prevent round-off error on <0 steps from
                                // from causing overstepping & running off the
                                // edge of the texture
 
                tnext = (int)(tdivz * z) + tadjust;
                if (tnext > bbextentt)
                    tnext = bbextentt;
                else if (tnext < 16)
                    tnext = 16;  // guard against round-off error on <0 steps
 
                if (spancount > 1) {
                    sstep = (snext - s) / (spancount - 1);
                    tstep = (tnext - t) / (spancount - 1);
                }
            }
 
            do {
                ptex = pbase + (s >> 16) * TEX_BYTES + (t >> 16) * cachewidth;
                pdest[0] = ptex[2];
                pdest[1] = ptex[1];
                pdest[2] = ptex[0];
                pdest += VID_BYTES;
                s += sstep;
                t += tstep;
            } while (--spancount > 0);
 
            s = snext;
            t = tnext;
 
        } while (count > 0);
 
    } while ((pspan = pspan->pnext) != NULL);
}

Referenced by D_SkySurf(), and D_SolidSurf().

D_DrawSurfaces()

void D_DrawSurfaces

(

void

)

Definition at line 1001 of file edge.c.

{
    surf_t          *s;
 
//  currententity = NULL;   //&r_worldentity;
    VectorSubtract(r_origin, vec3_origin, modelorg);
    R_TransformVector(modelorg, transformed_modelorg);
    VectorCopy(transformed_modelorg, world_transformed_modelorg);
 
    if (sw_drawsird->integer) {
        D_DrawZSurfaces();
    } else if (sw_drawflat->integer) {
        D_DrawflatSurfaces();
    } else {
        for (s = &surfaces[1]; s < surface_p; s++) {
            if (!s->spans)
                continue;
 
            r_drawnpolycount++;
 
            if (s->flags & DSURF_SKY)
                D_SkySurf(s);
            else if (s->flags & DSURF_BACKGROUND)
                D_BackgroundSurf(s);
            else if (s->flags & DSURF_TURB)
                D_TurbulentSurf(s);
            else
                D_SolidSurf(s);
        }
    }
 
    currententity = NULL;   //&r_worldentity;
    VectorSubtract(r_origin, vec3_origin, modelorg);
    R_TransformFrustum();
}

Referenced by R_ScanEdges().

D_DrawTurbulent16()

void D_DrawTurbulent16	(	espan_t *	pspan,
		int *	warptable
	)

Definition at line 83 of file scan.c.

{
    int             count, spancount;
    byte            *pbase, *pdest, *ptex;
    fixed16_t       s, t, snext, tnext, sstep, tstep;
    float           sdivz, tdivz, zi, z, du, dv, spancountminus1;
    float           sdivz16stepu, tdivz16stepu, zi16stepu;
    int             *turb;
    int             turb_s, turb_t;
 
    turb = warptable + ((int)(r_newrefdef.time * SPEED) & (CYCLE - 1));
 
    sstep = 0;   // keep compiler happy
    tstep = 0;   // ditto
 
    pbase = (byte *)cacheblock;
 
    sdivz16stepu = d_sdivzstepu * 16;
    tdivz16stepu = d_tdivzstepu * 16;
    zi16stepu = d_zistepu * 16;
 
    do {
        pdest = d_spantable[pspan->v] + pspan->u * VID_BYTES;
 
        count = pspan->count;
 
        // calculate the initial s/z, t/z, 1/z, s, and t and clamp
        du = (float)pspan->u;
        dv = (float)pspan->v;
 
        sdivz = d_sdivzorigin + dv * d_sdivzstepv + du * d_sdivzstepu;
        tdivz = d_tdivzorigin + dv * d_tdivzstepv + du * d_tdivzstepu;
        zi = d_ziorigin + dv * d_zistepv + du * d_zistepu;
        z = (float)0x10000 / zi;    // prescale to 16.16 fixed-point
 
        s = (int)(sdivz * z) + sadjust;
        if (s > bbextents)
            s = bbextents;
        else if (s < 0)
            s = 0;
 
        t = (int)(tdivz * z) + tadjust;
        if (t > bbextentt)
            t = bbextentt;
        else if (t < 0)
            t = 0;
 
        do {
            // calculate s and t at the far end of the span
            if (count >= 16)
                spancount = 16;
            else
                spancount = count;
 
            count -= spancount;
 
            if (q_likely(count)) {
                // calculate s/z, t/z, zi->fixed s and t at far end of span,
                // calculate s and t steps across span by shifting
                sdivz += sdivz16stepu;
                tdivz += tdivz16stepu;
                zi += zi16stepu;
                z = (float)0x10000 / zi;    // prescale to 16.16 fixed-point
 
                snext = (int)(sdivz * z) + sadjust;
                if (snext > bbextents)
                    snext = bbextents;
                else if (snext < 16)
                    snext = 16; // prevent round-off error on <0 steps from
                                // from causing overstepping & running off the
                                // edge of the texture
 
                tnext = (int)(tdivz * z) + tadjust;
                if (tnext > bbextentt)
                    tnext = bbextentt;
                else if (tnext < 16)
                    tnext = 16; // guard against round-off error on <0 steps
 
                sstep = (snext - s) >> 4;
                tstep = (tnext - t) >> 4;
            } else {
                // calculate s/z, t/z, zi->fixed s and t at last pixel in span (so
                // can't step off polygon), clamp, calculate s and t steps across
                // span by division, biasing steps low so we don't run off the
                // texture
                spancountminus1 = (float)(spancount - 1);
                sdivz += d_sdivzstepu * spancountminus1;
                tdivz += d_tdivzstepu * spancountminus1;
                zi += d_zistepu * spancountminus1;
                z = (float)0x10000 / zi;    // prescale to 16.16 fixed-point
 
                snext = (int)(sdivz * z) + sadjust;
                if (snext > bbextents)
                    snext = bbextents;
                else if (snext < 16)
                    snext = 16; // prevent round-off error on <0 steps from
                                // from causing overstepping & running off the
                                // edge of the texture
 
                tnext = (int)(tdivz * z) + tadjust;
                if (tnext > bbextentt)
                    tnext = bbextentt;
                else if (tnext < 16)
                    tnext = 16; // guard against round-off error on <0 steps
 
                if (spancount > 1) {
                    sstep = (snext - s) / (spancount - 1);
                    tstep = (tnext - t) / (spancount - 1);
                }
            }
 
            s = s & ((CYCLE << 16) - 1);
            t = t & ((CYCLE << 16) - 1);
 
            do {
                turb_s = ((s + turb[(t >> 16) & (CYCLE - 1)]) >> 16) & TURB_MASK;
                turb_t = ((t + turb[(s >> 16) & (CYCLE - 1)]) >> 16) & TURB_MASK;
                ptex = pbase + (turb_t * TURB_SIZE * TEX_BYTES) + turb_s * TEX_BYTES;
                pdest[0] = ptex[2];
                pdest[1] = ptex[1];
                pdest[2] = ptex[0];
                pdest += VID_BYTES;
                s += sstep;
                t += tstep;
            } while (--spancount > 0);
 
            s = snext;
            t = tnext;
 
        } while (count > 0);
 
    } while ((pspan = pspan->pnext) != NULL);
}

Referenced by D_TurbulentSurf().

D_DrawZSpans()

void D_DrawZSpans

(

espan_t *

pspans

)

Definition at line 352 of file scan.c.

{
    int             count, doublecount, izistep;
    int             izi;
    short           *pdest;
    uint32_t        ltemp;
    float           zi;
    float           du, dv;
 
// FIXME: check for clamping/range problems
// we count on FP exceptions being turned off to avoid range problems
    izistep = (int)(d_zistepu * 0x8000 * 0x10000);
 
    do {
        pdest = d_zspantable[pspan->v] + pspan->u;
 
        count = pspan->count;
 
        // calculate the initial 1/z
        du = (float)pspan->u;
        dv = (float)pspan->v;
 
        zi = d_ziorigin + dv * d_zistepv + du * d_zistepu;
        // we count on FP exceptions being turned off to avoid range problems
        izi = (int)(zi * 0x8000 * 0x10000);
 
        if ((uintptr_t)pdest & 0x02) {
            *pdest++ = (short)(izi >> 16);
            izi += izistep;
            count--;
        }
 
        if ((doublecount = count >> 1) > 0) {
            do {
                ltemp = izi >> 16;
                izi += izistep;
                ltemp |= izi & 0xFFFF0000;
                izi += izistep;
                *(uint32_t *)pdest = ltemp;
                pdest += 2;
            } while (--doublecount > 0);
        }
 
        if (count & 1)
            *pdest = (short)(izi >> 16);
 
    } while ((pspan = pspan->pnext) != NULL);
}

Referenced by D_BackgroundSurf(), D_DrawflatSurfaces(), D_DrawZSurfaces(), D_SkySurf(), D_SolidSurf(), and D_TurbulentSurf().

D_FlushCaches()

void D_FlushCaches

(

void

)

Definition at line 222 of file surf.c.

{
    surfcache_t     *c;
 
    if (!sc_base)
        return;
 
    for (c = sc_base; c; c = c->next) {
        if (c->owner) {
            *c->owner = NULL;
        }
    }
 
    sc_rover = sc_base;
    sc_base->next = NULL;
    sc_base->owner = NULL;
    sc_base->size = sc_size;
}

Referenced by R_BeginRegistration(), R_ModeChanged(), R_SetupFrame(), and R_Shutdown().

D_SCDump_f()

void D_SCDump_f

(

void

)

Definition at line 311 of file surf.c.

{
    surfcache_t             *test;
 
    for (test = sc_base; test; test = test->next) {
        if (test == sc_rover)
            Com_Printf("ROVER:\n");
        Com_Printf("%p : %i bytes     %i width\n", test, test->size,
                   test->width);
    }
}

Referenced by R_Register().

D_WarpScreen()

void D_WarpScreen

(

void

)

Definition at line 32 of file scan.c.

{
    int     w, h;
    int     u, v, u2, v2;
    byte    *dest;
    int     *turb;
    int     *col;
    byte    **row;
 
    static int  cached_width, cached_height;
    static byte *rowptr[MAXHEIGHT * 2 + AMP2 * 2];
    static int  column[MAXWIDTH * 2 + AMP2 * 2];
 
    //
    // these are constant over resolutions, and can be saved
    //
    w = r_newrefdef.width;
    h = r_newrefdef.height;
    if (w != cached_width || h != cached_height) {
        cached_width = w;
        cached_height = h;
        for (v = 0; v < h + AMP2 * 2; v++) {
            v2 = (int)((float)v / (h + AMP2 * 2) * r_refdef.vrect.height);
            rowptr[v] = r_warpbuffer + (WARP_WIDTH * v2) * VID_BYTES;
        }
 
        for (u = 0; u < w + AMP2 * 2; u++) {
            u2 = (int)((float)u / (w + AMP2 * 2) * r_refdef.vrect.width);
            column[u] = u2 * VID_BYTES;
        }
    }
 
    turb = intsintable + ((int)(r_newrefdef.time * SPEED) & (CYCLE - 1));
    dest = vid.buffer + r_newrefdef.y * vid.rowbytes + r_newrefdef.x * VID_BYTES;
 
    for (v = 0; v < h; v++, dest += vid.rowbytes) {
        col = &column[turb[v & (CYCLE - 1)]];
        row = &rowptr[v];
        for (u = 0; u < w; u++) {
            dest[u * VID_BYTES + 0] = row[turb[u & (CYCLE - 1)]][col[u] + 0];
            dest[u * VID_BYTES + 1] = row[turb[u & (CYCLE - 1)]][col[u] + 1];
            dest[u * VID_BYTES + 2] = row[turb[u & (CYCLE - 1)]][col[u] + 2];
        }
    }
}

Referenced by R_RenderFrame().

R_AliasClipTriangle()

void R_AliasClipTriangle	(	finalvert_t *	index0,
		finalvert_t *	index1,
		finalvert_t *	index2
	)

Definition at line 183 of file aclip.c.

{
    finalvert_t     fv[2][8];
    int             i, k, pingpong;
    unsigned        clipflags;
 
// copy vertexes and fix seam texture coordinates
    fv[0][0] = *index0;
    fv[0][1] = *index1;
    fv[0][2] = *index2;
 
// clip
    clipflags = fv[0][0].flags | fv[0][1].flags | fv[0][2].flags;
 
    if (clipflags & ALIAS_Z_CLIP) {
        k = R_AliasClip(fv[0], fv[1], ALIAS_Z_CLIP, 3, R_Alias_clip_z);
        if (k == 0)
            return;
 
        pingpong = 1;
        clipflags = fv[1][0].flags | fv[1][1].flags | fv[1][2].flags;
    } else {
        pingpong = 0;
        k = 3;
    }
 
    if (clipflags & ALIAS_LEFT_CLIP) {
        k = R_AliasClip(fv[pingpong], fv[pingpong ^ 1],
                        ALIAS_LEFT_CLIP, k, R_Alias_clip_left);
        if (k == 0)
            return;
 
        pingpong ^= 1;
    }
 
    if (clipflags & ALIAS_RIGHT_CLIP) {
        k = R_AliasClip(fv[pingpong], fv[pingpong ^ 1],
                        ALIAS_RIGHT_CLIP, k, R_Alias_clip_right);
        if (k == 0)
            return;
 
        pingpong ^= 1;
    }
 
    if (clipflags & ALIAS_BOTTOM_CLIP) {
        k = R_AliasClip(fv[pingpong], fv[pingpong ^ 1],
                        ALIAS_BOTTOM_CLIP, k, R_Alias_clip_bottom);
        if (k == 0)
            return;
 
        pingpong ^= 1;
    }
 
    if (clipflags & ALIAS_TOP_CLIP) {
        k = R_AliasClip(fv[pingpong], fv[pingpong ^ 1],
                        ALIAS_TOP_CLIP, k, R_Alias_clip_top);
        if (k == 0)
            return;
 
        pingpong ^= 1;
    }
 
    for (i = 0; i < k; i++) {
        if (fv[pingpong][i].u < r_refdef.vrect.x)
            fv[pingpong][i].u = r_refdef.vrect.x;
        else if (fv[pingpong][i].u > r_refdef.vrectright)
            fv[pingpong][i].u = r_refdef.vrectright;
 
        if (fv[pingpong][i].v < r_refdef.vrect.y)
            fv[pingpong][i].v = r_refdef.vrect.y;
        else if (fv[pingpong][i].v > r_refdef.vrectbottom)
            fv[pingpong][i].v = r_refdef.vrectbottom;
 
        fv[pingpong][i].flags = 0;
    }
 
// draw triangles
    for (i = 1; i < k - 1; i++) {
        aliastriangleparms.a = &fv[pingpong][0];
        aliastriangleparms.b = &fv[pingpong][i];
        aliastriangleparms.c = &fv[pingpong][i + 1];
        R_DrawTriangle();
    }
}

Referenced by R_AliasPreparePoints().

R_AliasDrawModel()

void R_AliasDrawModel

(

void

)

Definition at line 674 of file alias.c.

{
    if (r_lerpmodels->integer == 0)
        currententity->backlerp = 0;
 
    if ((currententity->flags & (RF_WEAPONMODEL | RF_LEFTHAND)) == (RF_WEAPONMODEL | RF_LEFTHAND))
        r_refdef.xscale = -r_refdef.xscale;
 
    /*
    ** we have to set our frame pointers and transformations before
    ** doing any real work
    */
    R_AliasSetupFrames();
    R_AliasSetUpTransform();
 
    // see if the bounding box lets us trivially reject, also sets
    // trivial accept status
    if (R_AliasCheckBBox() == BBOX_TRIVIAL_REJECT)
        goto exit;
 
    // set up the skin and verify it exists
    R_AliasSetupSkin();
 
    r_amodels_drawn++;
 
    R_AliasSetupLighting();
 
    R_AliasSetupBlend();
 
    /*
    ** compute this_frame and old_frame addresses
    */
    R_AliasSetUpLerpData(currententity->backlerp);
 
    if (currententity->flags & RF_DEPTHHACK)
        s_ziscale = (float)0x8000 * (float)0x10000 * 3.0;
    else
        s_ziscale = (float)0x8000 * (float)0x10000;
 
    R_AliasPreparePoints();
 
exit:
    if ((currententity->flags & (RF_WEAPONMODEL | RF_LEFTHAND)) == (RF_WEAPONMODEL | RF_LEFTHAND))
        r_refdef.xscale = -r_refdef.xscale;
}

Referenced by R_DrawEntities().

R_AliasProjectAndClipTestFinalVert()

void R_AliasProjectAndClipTestFinalVert

(

finalvert_t *

fv

)

Definition at line 188 of file alias.c.

{
    float   zi;
    float   x, y, z;
 
    // project points
    x = fv->xyz[0];
    y = fv->xyz[1];
    z = fv->xyz[2];
    zi = 1.0 / z;
 
    fv->zi = zi * s_ziscale;
 
    fv->u = (x * r_refdef.xscale * zi) + r_refdef.xcenter;
    fv->v = (y * r_refdef.yscale * zi) + r_refdef.ycenter;
 
    if (fv->u < r_refdef.vrect.x)
        fv->flags |= ALIAS_LEFT_CLIP;
    if (fv->v < r_refdef.vrect.y)
        fv->flags |= ALIAS_TOP_CLIP;
    if (fv->u > r_refdef.vrectright)
        fv->flags |= ALIAS_RIGHT_CLIP;
    if (fv->v > r_refdef.vrectbottom)
        fv->flags |= ALIAS_BOTTOM_CLIP;
}

Referenced by R_Alias_clip_z(), and R_AliasTransformFinalVerts().

R_ApplySIRDAlgorithum()

void R_ApplySIRDAlgorithum

(

void

)

Definition at line 155 of file sird.c.

{
    short* curz, *oldz;
    short cz = 0, lastz = 0;
    byte* curp;
    byte* curbp, j = 0;
    int x, y, i, zinc, k;
    int mode = sw_drawsird->integer;
 
    //note of interest: I've made this static so that
    //if you like you could make it not static and see
    //what would happen if you didn't change the background
    static int ji = 0;
 
    //create the background image to tile
    //basically done by shifting the values around
    //each time and xoring them with a randomly
    //selected pixel
    for (i = 0; i < R_SIRDw * R_SIRDh * VID_BYTES; i++) {
        if ((i % R_SIRDnumRand) == 0) {
            ji++;
            ji %= R_SIRDnumRand;
            j = r_SIRDrandValues[r_SIRDrandValues[ji] % R_SIRDnumRand];
        }
        r_SIRDBackground[i] = r_SIRDrandValues[(i % R_SIRDnumRand) ] ^ j;
    }
 
    //if we are under water:
    if ((r_dowarp) && (vid.width != WARP_WIDTH)) {
        //the rendering is only in the top left
        //WARP_WIDTH by WARP_HEIGHT area, so scale the z-values
        //to span over the whole screen
 
 
        //why are we going backwards? so that we don't write over the
        //values before we read from them
 
        zinc = ((WARP_WIDTH * 0x10000) / vid.width);
        for (y = vid.height - 1; y >= 0; y--) {
            curz = (d_pzbuffer + (vid.width * y));
            oldz = (d_pzbuffer + (vid.width * ((y * WARP_HEIGHT) / vid.height)));
            k = (zinc * (vid.width - 1));
 
            for (x = vid.width - 1; x >= 0; x--) {
                curz[x] = oldz[k >> 16];
                k -= zinc;
            }
        }
    }
 
 
    //SIRDify each line
    for (y = 0; y < vid.height; y++) {
        curp = (vid.buffer + (vid.rowbytes * y));
        curz = (d_pzbuffer + (vid.width * y));
 
        if (mode != 3) {
            // draw the SIRD
 
            // copy the background into the left most column
            curbp = &(r_SIRDBackground[ R_SIRDw * (y % R_SIRDh) ]);
            for (x = 0; x < R_SIRDw; x++) {
                curp[0] = curbp[0];
                curp[1] = curbp[1];
                curp[2] = curbp[2];
 
                curp += VID_BYTES;
                curbp += VID_BYTES;
            }
 
            lastz = 0;
            cz = 0;
            curz += R_SIRDw;
            curbp = curp - R_SIRDw * VID_BYTES;
 
            // now calculate the SIRD
            for (x = R_SIRDw; x < vid.width; x++) {
                //only call the z-function with a new
                //value, it is slow so this saves quite
                //some time.
                if (lastz != *curz) {
                    lastz = *curz;
 
                    //convert from z to height offset
                    cz = (mode == 2) ? R_SIRDmaxDiff - R_SIRDZFunc(lastz) : R_SIRDZFunc(lastz);
 
                    //the "height offset" used in making SIRDS
                    //can be considered an adjustment of the
                    //frequency of repetition in the pattern.
                    //so here we are copying from bp to p, and so
                    //it simply increases or decreases the distance
                    //between the two.
                    curbp = (curp - R_SIRDw * VID_BYTES + cz * VID_BYTES);
                }
 
                curp[0] = curbp[0];
                curp[1] = curbp[1];
                curp[2] = curbp[2];
 
                curp += VID_BYTES;
                curbp += VID_BYTES;
                curz++;
            }
        } else {
            //if we are just drawing the height map
            //this lets you see which layers are used to
            //create the SIRD
            //
            //NOTE: even though it may sort of look like
            //a grey-scale height map, that is merely a
            //coincidence because of how the colours are
            //organized in the pallette.
 
            for (x = 0; x < vid.width; x++) {
                if (lastz != *curz) {
                    lastz = *curz;
                    cz = R_SIRDZFunc(*curz);
                }
 
                curp[0] = cz;
                curp[1] = cz;
                curp[2] = cz;
 
                curp += VID_BYTES;
                curz++;
            }
        }
    }
}

Referenced by R_RenderFrame().

R_BeginEdgeFrame()

void R_BeginEdgeFrame

(

void

)

Definition at line 80 of file edge.c.

{
    int     v;
 
    edge_p = r_edges;
    edge_max = &r_edges[r_numallocatededges];
 
    surface_p = &surfaces[2];   // background is surface 1,
                                // surface 0 is a dummy
    surfaces[1].spans = NULL;   // no background spans yet
    surfaces[1].flags = DSURF_BACKGROUND;
 
// put the background behind everything in the world
    if (sw_draworder->integer) {
        pdrawfunc = R_GenerateSpansBackward;
        surfaces[1].key = 0;
        r_currentkey = 1;
    } else {
        pdrawfunc = R_GenerateSpans;
        surfaces[1].key = 0x7FFFFFFF;
        r_currentkey = 0;
    }
 
// FIXME: set with memset
    for (v = r_refdef.vrect.y; v < r_refdef.vrectbottom; v++) {
        newedges[v] = removeedges[v] = NULL;
    }
}

Referenced by R_EdgeDrawing().

R_BuildGammaTable()

void R_BuildGammaTable

(

void

)

Definition at line 109 of file image.c.

{
    int     i, inf;
    float   g = vid_gamma->value;
 
    if (g == 1.0) {
        for (i = 0; i < 256; i++)
            gammatable[i] = i;
        return;
    }
 
    for (i = 0; i < 256; i++) {
        inf = 255 * pow((i + 0.5) / 255.5, g) + 0.5;
        gammatable[i] = clamp(inf, 0, 255);
    }
}

Referenced by R_InitImages().

R_BuildLightMap()

void R_BuildLightMap

(

void

)

Definition at line 290 of file light.c.

{
    int             i, maps, smax, tmax, size;
    byte            *lightmap;
    mface_t         *surf;
    blocklight_t    *block;
 
    surf = r_drawsurf.surf;
    smax = S_MAX(surf);
    tmax = T_MAX(surf);
    size = smax * tmax;
 
    if (size > MAX_BLOCKLIGHTS)
        Com_Error(ERR_DROP, "R_BuildLightMap: surface blocklights size %i > %i", size, MAX_BLOCKLIGHTS);
 
    if (r_fullbright->integer || !surf->lightmap) {
        block = blocklights;
        for (i = 0; i < size; i++) {
            block[0] = block[1] = block[2] = 0xffff;
            block += LIGHTMAP_BYTES;
        }
        return;
    }
 
// clear to no light
    memset(blocklights, 0, sizeof(blocklights[0]) * size * LIGHTMAP_BYTES);
 
// add all the lightmaps
    lightmap = surf->lightmap;
    for (maps = 0; maps < surf->numstyles; maps++) {
        fixed8_t        scale;
 
        block = blocklights;
        scale = r_drawsurf.lightadj[maps];  // 8.8 fraction
        for (i = 0; i < size; i++) {
            block[0] += lightmap[0] * scale;
            block[1] += lightmap[1] * scale;
            block[2] += lightmap[2] * scale;
 
            lightmap += LIGHTMAP_BYTES;
            block += LIGHTMAP_BYTES;
        }
    }
 
// add all the dynamic lights
    if (surf->dlightframe == r_framecount)
        R_AddDynamicLights();
 
// bound
    block = blocklights;
    for (i = 0; i < size; i++) {
        blocklight_t    r, g, b, max;
 
        r = block[0];
        g = block[1];
        b = block[2];
 
        // catch negative lights
        if (r < 255)
            r = 255;
        if (g < 255)
            g = 255;
        if (b < 255)
            b = 255;
 
        // determine the brightest of the three color components
        max = g;
        if (r > max)
            max = r;
        if (b > max)
            max = b;
 
        // rescale all the color components if the intensity of the greatest
        // channel exceeds 1.0
        if (max > 65535) {
            float   y;
 
            y = 65535.0f / max;
            r *= y;
            g *= y;
            b *= y;
        }
 
        block[0] = r;
        block[1] = g;
        block[2] = b;
 
        block += LIGHTMAP_BYTES;
    }
}

Referenced by D_CacheSurface().

R_DrawAlphaSurfaces()

void R_DrawAlphaSurfaces

(

void

)

Definition at line 764 of file poly.c.

{
    mface_t *s = r_alpha_surfaces;
 
    //currentmodel = r_worldmodel;
 
    modelorg[0] = -r_origin[0];
    modelorg[1] = -r_origin[1];
    modelorg[2] = -r_origin[2];
 
    while (s) {
        R_BuildPolygonFromSurface(s);
 
        if (s->texinfo->c.flags & SURF_TRANS66)
            R_ClipAndDrawPoly(0.66f, (s->texinfo->c.flags & (SURF_WARP | SURF_FLOWING)), qtrue);
        else
            R_ClipAndDrawPoly(0.33f, (s->texinfo->c.flags & (SURF_WARP | SURF_FLOWING)), qtrue);
 
        s = s->next;
    }
 
    r_alpha_surfaces = NULL;
}

Referenced by R_RenderFrame().

R_DrawBeam()

void R_DrawBeam

(

entity_t *

e

)

Definition at line 871 of file main.c.

{
#define NUM_BEAM_SEGS 6
 
    color_t color;
    int i;
 
    vec3_t perpvec;
    vec3_t direction, normalized_direction;
    vec3_t start_points[NUM_BEAM_SEGS], end_points[NUM_BEAM_SEGS];
    vec3_t oldorigin, origin;
 
    oldorigin[0] = e->oldorigin[0];
    oldorigin[1] = e->oldorigin[1];
    oldorigin[2] = e->oldorigin[2];
 
    origin[0] = e->origin[0];
    origin[1] = e->origin[1];
    origin[2] = e->origin[2];
 
    normalized_direction[0] = direction[0] = oldorigin[0] - origin[0];
    normalized_direction[1] = direction[1] = oldorigin[1] - origin[1];
    normalized_direction[2] = direction[2] = oldorigin[2] - origin[2];
 
    if (VectorNormalize(normalized_direction) == 0)
        return;
 
    PerpendicularVector(perpvec, normalized_direction);
    VectorScale(perpvec, e->frame / 2, perpvec);
 
    for (i = 0; i < NUM_BEAM_SEGS; i++) {
        RotatePointAroundVector(start_points[i], normalized_direction,
                                perpvec, (360.0f / NUM_BEAM_SEGS) * i);
        VectorAdd(start_points[i], origin, start_points[i]);
        VectorAdd(start_points[i], direction, end_points[i]);
    }
 
    if (e->skinnum == -1)
        color.u32 = e->rgba.u32;
    else
        color.u32 = d_8to24table[e->skinnum & 0xFF];
 
    for (i = 0; i < NUM_BEAM_SEGS; i++) {
        R_IMFlatShadedQuad(start_points[i],
                           end_points[i],
                           end_points[(i + 1) % NUM_BEAM_SEGS],
                           start_points[(i + 1) % NUM_BEAM_SEGS],
                           color,
                           e->alpha);
    }
}

Referenced by R_DrawEntities().

R_DrawParticles()

void R_DrawParticles

(

void

)

Definition at line 119 of file part.c.

{
    particle_t *p;
    int         i;
    int         alpha;
 
    VectorScale(vright, r_refdef.xscaleshrink, partparms.right);
    VectorScale(vup, r_refdef.yscaleshrink, partparms.up);
    VectorCopy(vpn, partparms.pn);
 
    for (p = r_newrefdef.particles, i = 0; i < r_newrefdef.num_particles; i++, p++) {
        partparms.particle = p;
 
        alpha = 255 * p->alpha;
        partparms.one_minus_alpha = 255 - alpha;
 
        if (p->color == -1) {
            partparms.color[0] = p->rgba.u8[0] * alpha;
            partparms.color[1] = p->rgba.u8[1] * alpha;
            partparms.color[2] = p->rgba.u8[2] * alpha;
        } else {
            color_t color;
 
            color.u32 = d_8to24table[p->color & 0xff];
            partparms.color[0] = color.u8[0] * alpha;
            partparms.color[1] = color.u8[1] * alpha;
            partparms.color[2] = color.u8[2] * alpha;
        }
 
        R_DrawParticle();
    }
}

Referenced by R_RenderFrame().

R_DrawSolidClippedSubmodelPolygons()

void R_DrawSolidClippedSubmodelPolygons	(	mmodel_t *	pmodel,
		mnode_t *	topnode
	)

Definition at line 245 of file bsp.c.

{
    int         i, j;
    vec_t       dot;
    mface_t     *psurf;
    int         numsurfaces;
    cplane_t    *pplane;
    mvertex_t   bverts[MAX_BMODEL_VERTS];
    bedge_t     bedges[MAX_BMODEL_EDGES], *pbedge;
    msurfedge_t *surfedge;
 
// FIXME: use bounding-box-based frustum clipping info?
 
    psurf = pmodel->firstface;
    numsurfaces = pmodel->numfaces;
 
    for (i = 0; i < numsurfaces; i++, psurf++) {
        // find which side of the node we are on
        pplane = psurf->plane;
 
        dot = PlaneDiff(modelorg, pplane);
 
        // draw the polygon
        if ((!(psurf->drawflags & DSURF_PLANEBACK) && (dot < -BACKFACE_EPSILON)) ||
            ((psurf->drawflags & DSURF_PLANEBACK) && (dot > BACKFACE_EPSILON)))
            continue;
 
        // FIXME: use bounding-box-based frustum clipping info?
 
        // copy the edges to bedges, flipping if necessary so always
        // clockwise winding
        // FIXME: if edges and vertices get caches, these assignments must move
        // outside the loop, and overflow checking must be done here
        pbverts = bverts;
        pbedges = bedges;
        numbverts = numbedges = 0;
        pbedge = &bedges[numbedges];
        numbedges += psurf->numsurfedges;
 
        if (numbedges >= MAX_BMODEL_EDGES) {
            Com_Printf("Out of edges for bmodel\n");
            return;
        }
 
        surfedge = psurf->firstsurfedge;
        for (j = 0; j < psurf->numsurfedges; j++, surfedge++) {
            pbedge[j].v[0] = surfedge->edge->v[surfedge->vert    ];
            pbedge[j].v[1] = surfedge->edge->v[surfedge->vert ^ 1];
            pbedge[j].pnext = &pbedge[j + 1];
        }
 
        pbedge[j - 1].pnext = NULL; // mark end of edges
 
        if (!(psurf->texinfo->c.flags & SURF_TRANS_MASK))
            R_RecursiveClipBPoly(pbedge, topnode, psurf);
        else
            R_RenderBmodelFace(pbedge, psurf);
    }
}

Referenced by R_DrawBEntitiesOnList().

R_DrawSprite()

void R_DrawSprite

(

void

)

Definition at line 835 of file poly.c.

{
    vec5_t      *pverts;
    vec3_t      left, up, right, down;
    mspriteframe_t  *frame;
    int             textured;
 
    frame = &currentmodel->spriteframes[
                currententity->frame % currentmodel->numframes];
 
    r_polydesc.pixels       = frame->image->pixels[0];
    r_polydesc.pixel_width  = frame->image->upload_width;
    r_polydesc.pixel_height = frame->image->upload_height;
    r_polydesc.dist         = 0;
 
    // generate the sprite's axes, completely parallel to the viewplane.
    VectorCopy(vup, r_polydesc.vup);
    VectorCopy(vright, r_polydesc.vright);
    VectorCopy(vpn, r_polydesc.vpn);
 
// build the sprite poster in worldspace
    VectorScale(r_polydesc.vright,
                frame->width - frame->origin_x, right);
    VectorScale(r_polydesc.vup,
                frame->height - frame->origin_y, up);
    VectorScale(r_polydesc.vright,
                -frame->origin_x, left);
    VectorScale(r_polydesc.vup,
                -frame->origin_y, down);
 
    // invert UP vector for sprites
    VectorNegate(r_polydesc.vup, r_polydesc.vup);
 
    pverts = r_clip_verts[0];
 
    pverts[0][0] = r_entorigin[0] + up[0] + left[0];
    pverts[0][1] = r_entorigin[1] + up[1] + left[1];
    pverts[0][2] = r_entorigin[2] + up[2] + left[2];
    pverts[0][3] = 0;
    pverts[0][4] = 0;
 
    pverts[1][0] = r_entorigin[0] + up[0] + right[0];
    pverts[1][1] = r_entorigin[1] + up[1] + right[1];
    pverts[1][2] = r_entorigin[2] + up[2] + right[2];
    pverts[1][3] = frame->width;
    pverts[1][4] = 0;
 
    pverts[2][0] = r_entorigin[0] + down[0] + right[0];
    pverts[2][1] = r_entorigin[1] + down[1] + right[1];
    pverts[2][2] = r_entorigin[2] + down[2] + right[2];
    pverts[2][3] = frame->width;
    pverts[2][4] = frame->height;
 
    pverts[3][0] = r_entorigin[0] + down[0] + left[0];
    pverts[3][1] = r_entorigin[1] + down[1] + left[1];
    pverts[3][2] = r_entorigin[2] + down[2] + left[2];
    pverts[3][3] = 0;
    pverts[3][4] = frame->height;
 
    r_polydesc.nump = 4;
    r_polydesc.s_offset = (r_polydesc.pixel_width  >> 1);
    r_polydesc.t_offset = (r_polydesc.pixel_height >> 1);
    VectorCopy(modelorg, r_polydesc.viewer_position);
 
    if (frame->image->flags & IF_TRANSPARENT)
        textured = 2;
    else
        textured = 1;
 
    if (currententity->flags & RF_TRANSLUCENT)
        R_ClipAndDrawPoly(currententity->alpha, qfalse, textured);
    else
        R_ClipAndDrawPoly(1.0F, qfalse, textured);
}

Referenced by R_DrawEntities().

R_DrawSubmodelPolygons()

void R_DrawSubmodelPolygons	(	mmodel_t *	pmodel,
		int	clipflags,
		mnode_t *	topnode
	)

Definition at line 313 of file bsp.c.

{
    int         i;
    vec_t       dot;
    mface_t *psurf;
    int         numsurfaces;
    cplane_t    *pplane;
 
// FIXME: use bounding-box-based frustum clipping info?
 
    psurf = pmodel->firstface;
    numsurfaces = pmodel->numfaces;
 
    for (i = 0; i < numsurfaces; i++, psurf++) {
        // find which side of the node we are on
        pplane = psurf->plane;
 
        dot = PlaneDiff(modelorg, pplane);
 
        // draw the polygon
        if (((psurf->drawflags & DSURF_PLANEBACK) && (dot < -BACKFACE_EPSILON)) ||
            (!(psurf->drawflags & DSURF_PLANEBACK) && (dot > BACKFACE_EPSILON))) {
            r_currentkey = ((mleaf_t *)topnode)->key;
 
            // FIXME: use bounding-box-based frustum clipping info?
            R_RenderFace(psurf, clipflags);
        }
    }
}

Referenced by R_DrawBEntitiesOnList().

R_DrawTriangle()

void R_DrawTriangle

(

void

)

Definition at line 113 of file polyset.c.

{
    spanpackage_t spans[DPS_MAXSPANS];
    int dv1_ab, dv0_ac;
    int dv0_ab, dv1_ac;
 
    dv0_ab = aliastriangleparms.a->u - aliastriangleparms.b->u;
    dv1_ab = aliastriangleparms.a->v - aliastriangleparms.b->v;
 
    if (!(dv0_ab | dv1_ab))
        return;
 
    dv0_ac = aliastriangleparms.a->u - aliastriangleparms.c->u;
    dv1_ac = aliastriangleparms.a->v - aliastriangleparms.c->v;
 
    if (!(dv0_ac | dv1_ac))
        return;
 
    d_xdenom = (dv0_ac * dv1_ab) - (dv0_ab * dv1_ac);
 
    if (d_xdenom < 0) {
        a_spans = spans;
 
        r_p0[0] = aliastriangleparms.a->u;      // u
        r_p0[1] = aliastriangleparms.a->v;      // v
        r_p0[2] = aliastriangleparms.a->s;      // s
        r_p0[3] = aliastriangleparms.a->t;      // t
        r_p0[4] = aliastriangleparms.a->l;      // light
        r_p0[5] = aliastriangleparms.a->zi;     // iz
 
        r_p1[0] = aliastriangleparms.b->u;
        r_p1[1] = aliastriangleparms.b->v;
        r_p1[2] = aliastriangleparms.b->s;
        r_p1[3] = aliastriangleparms.b->t;
        r_p1[4] = aliastriangleparms.b->l;
        r_p1[5] = aliastriangleparms.b->zi;
 
        r_p2[0] = aliastriangleparms.c->u;
        r_p2[1] = aliastriangleparms.c->v;
        r_p2[2] = aliastriangleparms.c->s;
        r_p2[3] = aliastriangleparms.c->t;
        r_p2[4] = aliastriangleparms.c->l;
        r_p2[5] = aliastriangleparms.c->zi;
 
        R_PolysetSetEdgeTable();
        R_RasterizeAliasPolySmooth();
    }
}

Referenced by R_AliasClipTriangle(), and R_AliasPreparePoints().

R_EmitSkyBox()

void R_EmitSkyBox

(

void

)

Definition at line 116 of file sky.c.

{
    int i, j;
    int oldkey;
 
    if (insubmodel)
        return;        // submodels should never have skies
    if (r_skyframe == r_framecount)
        return;        // already set this frame
 
    r_skyframe = r_framecount;
 
    // set the eight fake vertexes
    for (i = 0; i < 8; i++)
        for (j = 0; j < 3; j++)
            r_skyverts[i].point[j] = r_origin[j] + box_verts[i][j] * 128;
 
    // set the six fake planes
    for (i = 0; i < 6; i++)
        if (box_planes[i * 2 + 1] > 0)
            r_skyplanes[i].dist = r_origin[box_planes[i * 2]] + 128;
        else
            r_skyplanes[i].dist = r_origin[box_planes[i * 2]] - 128;
 
    // fix texture offsets
    for (i = 0; i < 6; i++) {
        r_skytexinfo[i].offset[0] = -DotProduct(r_origin, r_skytexinfo[i].axis[0]);
        r_skytexinfo[i].offset[1] = -DotProduct(r_origin, r_skytexinfo[i].axis[1]);
    }
 
    // emit the six faces
    oldkey = r_currentkey;
    r_currentkey = 0x7ffffff0;
    for (i = 0; i < 6; i++) {
        R_RenderFace(&r_skyfaces[i], 15);
    }
    r_currentkey = oldkey;  // bsp sorting order
}

Referenced by R_RenderFace().

R_FreeCaches()

void R_FreeCaches

(

void

)

Definition at line 206 of file surf.c.

{
    if (sc_base) {
        Z_Free(sc_base);
        sc_base = NULL;
    }
 
    sc_size = 0;
    sc_rover = NULL;
}

Referenced by R_ModeChanged(), and R_Shutdown().

R_IMFlatShadedQuad()

void R_IMFlatShadedQuad	(	vec3_t	a,
		vec3_t	b,
		vec3_t	c,
		vec3_t	d,
		color_t	color,
		float	alpha
	)

Definition at line 791 of file poly.c.

{
    vec3_t s0, s1;
 
    r_polydesc.nump = 4;
    VectorCopy(r_origin, r_polydesc.viewer_position);
 
    VectorCopy(a, r_clip_verts[0][0]);
    VectorCopy(b, r_clip_verts[0][1]);
    VectorCopy(c, r_clip_verts[0][2]);
    VectorCopy(d, r_clip_verts[0][3]);
 
    r_clip_verts[0][0][3] = 0;
    r_clip_verts[0][1][3] = 0;
    r_clip_verts[0][2][3] = 0;
    r_clip_verts[0][3][3] = 0;
 
    r_clip_verts[0][0][4] = 0;
    r_clip_verts[0][1][4] = 0;
    r_clip_verts[0][2][4] = 0;
    r_clip_verts[0][3][4] = 0;
 
    VectorSubtract(d, c, s0);
    VectorSubtract(c, b, s1);
    CrossProduct(s0, s1, r_polydesc.vpn);
    VectorNormalize(r_polydesc.vpn);
 
    r_polydesc.dist = DotProduct(r_polydesc.vpn, r_clip_verts[0][0]);
 
    r_polydesc.alpha = 255 * alpha;
 
    r_polyblendcolor[0] = color.u8[0] * r_polydesc.alpha;
    r_polyblendcolor[1] = color.u8[1] * r_polydesc.alpha;
    r_polyblendcolor[2] = color.u8[2] * r_polydesc.alpha;
 
    R_ClipAndDrawPoly(alpha, qfalse, qfalse);
}

Referenced by R_DrawBeam().

R_InitCaches()

void R_InitCaches

(

void

)

Definition at line 172 of file surf.c.

{
    int     size;
    int     pix;
 
    // calculate size to allocate
    if (sw_surfcacheoverride->integer) {
        size = Cvar_ClampInteger(sw_surfcacheoverride,
                                 SURFCACHE_SIZE_AT_320X240,
                                 SURFCACHE_SIZE_AT_320X240 * 25);
    } else {
        size = SURFCACHE_SIZE_AT_320X240;
 
        pix = vid.width * vid.height;
        if (pix > 64000)
            size += (pix - 64000) * 3;
    }
 
    size *= TEX_BYTES;
 
    // round up to page size
    size = (size + 8191) & ~8191;
 
    Com_DPrintf("%ik surface cache\n", size / 1024);
 
    sc_size = size;
    sc_base = (surfcache_t *)R_Malloc(size);
    sc_rover = sc_base;
 
    sc_base->next = NULL;
    sc_base->owner = NULL;
    sc_base->size = sc_size;
}

Referenced by R_ModeChanged().

R_InitDraw()

void R_InitDraw

(

void

)

Definition at line 109 of file draw.c.

{
    memset(&draw, 0, sizeof(draw));
    draw.colors[0].u32 = U32_WHITE;
    draw.colors[1].u32 = U32_WHITE;
    draw.clip.left = 0;
    draw.clip.top = 0;
    draw.clip.right = r_config.width;
    draw.clip.bottom = r_config.height;
}

Referenced by R_Init().

R_InitImages()

void R_InitImages

(

void

)

Definition at line 164 of file image.c.

{
    registration_sequence = 1;
 
    IMG_GetPalette();
 
    R_CreateNotexture();
 
    R_BuildGammaTable();
}

Referenced by R_Init().

R_InitSkyBox()

void R_InitSkyBox

(

void

)

Definition at line 77 of file sky.c.

{
    int i;
 
    for (i = 0; i < 6; i++) {
        r_skyplanes[i].normal[box_planes[i * 2]] = 1;
        r_skyplanes[i].dist = box_planes[i * 2 + 1];
 
        VectorCopy(box_axis[i][0], r_skytexinfo[i].axis[0]);
        VectorCopy(box_axis[i][1], r_skytexinfo[i].axis[1]);
 
        r_skyfaces[i].plane = &r_skyplanes[i];
        r_skyfaces[i].drawflags = box_flags[i] | DSURF_SKY;
        r_skyfaces[i].numsurfedges = 4;
        r_skyfaces[i].firstsurfedge = &r_skysurfedges[i * 4];
        r_skyfaces[i].texinfo = &r_skytexinfo[i];
        r_skyfaces[i].texturemins[0] = -128;
        r_skyfaces[i].texturemins[1] = -128;
        r_skyfaces[i].extents[0] = 256;
        r_skyfaces[i].extents[1] = 256;
    }
 
    for (i = 0; i < 24; i++) {
        r_skysurfedges[i].edge = &r_skyedges[box_surfedges[i] - 1];
        r_skysurfedges[i].vert = box_surfverts[i];
    }
 
    for (i = 0; i < 12; i++) {
        r_skyedges[i].v[0] = &r_skyverts[box_edges[i * 2 + 0] - 1];
        r_skyedges[i].v[1] = &r_skyverts[box_edges[i * 2 + 1] - 1];
        r_skyedges[i].cachededgeoffset = 0;
    }
}

Referenced by R_Init().

R_InitTurb()

void R_InitTurb

(

void

)

Definition at line 142 of file main.c.

{
    int     i;
 
    for (i = 0; i < CYCLE * 2; i++) {
        sintable[i] = AMP + sin(i * M_PI * 2 / CYCLE) * AMP;
        intsintable[i] = AMP2 + sin(i * M_PI * 2 / CYCLE) * AMP2; // AMP2, not 20
        blanktable[i] = 0;
    }
}

Referenced by R_Init().

R_LightPoint()

void R_LightPoint	(	vec3_t	p,
		vec3_t	color
	)

Definition at line 174 of file light.c.

{
    int         lnum;
    dlight_t    *dl;
    float       add;
 
    if (!r_worldmodel || !r_worldmodel->lightmap || r_fullbright->integer) {
        VectorSet(color, 1, 1, 1);
        return;
    }
 
    VectorClear(color);
 
    if (!_R_LightPoint(point, color))
        VectorSet(color, 1, 1, 1);
 
    //
    // add dynamic lights
    //
    for (lnum = 0; lnum < r_newrefdef.num_dlights; lnum++) {
        dl = &r_newrefdef.dlights[lnum];
        add = dl->intensity - DLIGHT_CUTOFF - Distance(point, dl->origin);
        if (add > 0) {
            add *= (1.0f / 255);
            VectorMA(color, add, dl->color, color);
        }
    }
 
    VectorScale(color, sw_modulate->value, color);
}

R_MarkLights()

void R_MarkLights

(

mnode_t *

headnode

)

Definition at line 76 of file light.c.

{
    dlight_t    *light;
    vec3_t      transformed;
    int         i;
 
    r_dlightframecount = r_framecount;
    for (i = 0, light = r_newrefdef.dlights; i < r_newrefdef.num_dlights; i++, light++) {
        if (insubmodel) {
            vec3_t      temp;
 
            VectorSubtract(light->origin, currententity->origin, temp);
            transformed[0] = DotProduct(temp, entity_rotation[0]);
            transformed[1] = DotProduct(temp, entity_rotation[1]);
            transformed[2] = DotProduct(temp, entity_rotation[2]);
        } else {
            VectorCopy(light->origin, transformed);
        }
        R_MarkLights_r(headnode, light, transformed, 1 << i);
    }
}

Referenced by R_DrawBEntitiesOnList(), and R_RenderFrame().

R_NewMap()

void R_NewMap

(

void

)

Definition at line 331 of file main.c.

{
    r_viewcluster = -1;
 
    if (auxsurfaces) {
        Z_Free(auxsurfaces);
        auxsurfaces = NULL;
    }
 
    if (auxedges) {
        Z_Free(auxedges);
        auxedges = NULL;
    }
 
    r_cnumsurfs = Cvar_ClampInteger(sw_maxsurfs, MINSURFACES, MAXSURFACES);
 
    if (r_cnumsurfs > NUMSTACKSURFACES) {
        surfaces = auxsurfaces = R_Mallocz(r_cnumsurfs * sizeof(surf_t));
        surface_p = surfaces;
        surf_max = &surfaces[r_cnumsurfs];
        // surface 0 doesn't really exist; it's just a dummy because index 0
        // is used to indicate no edge attached to surface
        surfaces--;
    }
 
    r_maxedgesseen = 0;
    r_maxsurfsseen = 0;
 
    r_numallocatededges = Cvar_ClampInteger(sw_maxedges, MINEDGES, MAXEDGES);
 
    if (r_numallocatededges > NUMSTACKEDGES) {
        auxedges = R_Mallocz(r_numallocatededges * sizeof(edge_t));
    }
}

Referenced by R_BeginRegistration().

R_PrintAliasStats()

void R_PrintAliasStats

(

void

)

Definition at line 58 of file misc.c.

{
    Com_Printf("%3i polygon model drawn\n", r_amodels_drawn);
}

Referenced by R_RenderFrame().

R_PrintTimes()

void R_PrintTimes

(

void

)

Definition at line 38 of file misc.c.

{
    int     r_time2;
    int     ms;
 
    r_time2 = Sys_Milliseconds();
 
    ms = r_time2 - r_time1;
 
    Com_Printf("%5i ms %3i/%3i/%3i poly %3i surf\n",
               ms, c_faceclip, r_polycount, r_drawnpolycount, c_surf);
    c_surf = 0;
}

Referenced by R_RenderFrame().

R_RenderBmodelFace()

void R_RenderBmodelFace	(	bedge_t *	pedges,
		mface_t *	psurf
	)

Definition at line 477 of file raster.c.

{
    int         i;
    unsigned    mask;
    cplane_t    *pplane;
    float       distinv;
    vec3_t      p_normal;
    medge_t     tedge;
    clipplane_t *pclip;
    qboolean    makeleftedge, makerightedge;
 
    if (psurf->texinfo->c.flags & SURF_TRANS_MASK) {
        psurf->next = r_alpha_surfaces;
        r_alpha_surfaces = psurf;
        return;
    }
 
// skip out if no more surfs
    if (surface_p >= surf_max) {
        r_outofsurfaces++;
        return;
    }
 
// ditto if not enough edges left, or switch to auxedges if possible
    if ((edge_p + psurf->numsurfedges + 4) >= edge_max) {
        r_outofedges += psurf->numsurfedges;
        return;
    }
 
    c_faceclip++;
 
// this is a dummy to give the caching mechanism someplace to write to
    r_pedge = &tedge;
 
// set up clip planes
    pclip = NULL;
 
    for (i = 3, mask = 0x08; i >= 0; i--, mask >>= 1) {
        if (r_clipflags & mask) {
            view_clipplanes[i].next = pclip;
            pclip = &view_clipplanes[i];
        }
    }
 
// push the edges through
    r_emitted = 0;
    r_nearzi = 0;
    r_nearzionly = qfalse;
    makeleftedge = makerightedge = qfalse;
// FIXME: keep clipped bmodel edges in clockwise order so last vertex caching
// can be used?
    r_lastvertvalid = qfalse;
 
    for (; pedges; pedges = pedges->pnext) {
        r_leftclipped = r_rightclipped = qfalse;
        R_ClipEdge(pedges->v[0], pedges->v[1], pclip);
 
        if (r_leftclipped)
            makeleftedge = qtrue;
        if (r_rightclipped)
            makerightedge = qtrue;
    }
 
// if there was a clip off the left edge, add that edge too
// FIXME: faster to do in screen space?
// FIXME: share clipped edges?
    if (makeleftedge) {
        r_pedge = &tedge;
        R_ClipEdge(&r_leftexit, &r_leftenter, pclip->next);
    }
 
// if there was a clip off the right edge, get the right r_nearzi
    if (makerightedge) {
        r_pedge = &tedge;
        r_nearzionly = qtrue;
        R_ClipEdge(&r_rightexit, &r_rightenter, view_clipplanes[1].next);
    }
 
// if no edges made it out, return without posting the surface
    if (!r_emitted)
        return;
 
    r_polycount++;
 
    surface_p->msurf = psurf;
    surface_p->nearzi = r_nearzi;
    surface_p->flags = psurf->drawflags;
    surface_p->insubmodel = qtrue;
    surface_p->spanstate = 0;
    surface_p->entity = currententity;
    surface_p->key = r_currentbkey;
    surface_p->spans = NULL;
 
    pplane = psurf->plane;
// FIXME: cache this?
    R_TransformVector(pplane->normal, p_normal);
// FIXME: cache this?
    distinv = 1.0 / (pplane->dist - DotProduct(modelorg, pplane->normal));
 
    surface_p->d_zistepu = p_normal[0] * r_refdef.xscaleinv * distinv;
    surface_p->d_zistepv = -p_normal[1] * r_refdef.yscaleinv * distinv;
    surface_p->d_ziorigin = p_normal[2] * distinv -
                            r_refdef.xcenter * surface_p->d_zistepu -
                            r_refdef.ycenter * surface_p->d_zistepv;
 
    surface_p++;
}

Referenced by R_DrawSolidClippedSubmodelPolygons(), and R_RecursiveClipBPoly().

R_RenderFace()

void R_RenderFace	(	mface_t *	fa,
		int	clipflags
	)

Definition at line 328 of file raster.c.

{
    int         i;
    unsigned    mask;
    cplane_t    *pplane;
    float       distinv;
    vec3_t      p_normal;
    medge_t     tedge;
    msurfedge_t *surfedge;
    clipplane_t *pclip;
    qboolean    makeleftedge, makerightedge;
 
    // translucent surfaces are not drawn by the edge renderer
    if (fa->texinfo->c.flags & SURF_TRANS_MASK) {
        fa->next = r_alpha_surfaces;
        r_alpha_surfaces = fa;
        return;
    }
 
    // sky surfaces encountered in the world will cause the
    // environment box surfaces to be emited
    if (fa->texinfo->c.flags & SURF_SKY) {
        R_EmitSkyBox();
        return;
    }
 
// skip out if no more surfs
    if ((surface_p) >= surf_max) {
        r_outofsurfaces++;
        return;
    }
 
// ditto if not enough edges left, or switch to auxedges if possible
    if ((edge_p + fa->numsurfedges + 4) >= edge_max) {
        r_outofedges += fa->numsurfedges;
        return;
    }
 
    c_faceclip++;
 
// set up clip planes
    pclip = NULL;
 
    for (i = 3, mask = 0x08; i >= 0; i--, mask >>= 1) {
        if (clipflags & mask) {
            view_clipplanes[i].next = pclip;
            pclip = &view_clipplanes[i];
        }
    }
 
// push the edges through
    r_emitted = 0;
    r_nearzi = 0;
    r_nearzionly = qfalse;
    makeleftedge = makerightedge = qfalse;
    r_lastvertvalid = qfalse;
 
    surfedge = fa->firstsurfedge;
    for (i = 0; i < fa->numsurfedges; i++, surfedge++) {
        r_pedge = surfedge->edge;
 
        // if the edge is cached, we can just reuse the edge
        if (!insubmodel) {
            if (r_pedge->cachededgeoffset & FULLY_CLIPPED_CACHED) {
                if ((r_pedge->cachededgeoffset & FRAMECOUNT_MASK) ==
                    r_framecount) {
                    r_lastvertvalid = qfalse;
                    continue;
                }
            } else {
                if ((((byte *)edge_p - (byte *)r_edges) >
                     r_pedge->cachededgeoffset) &&
                    (((edge_t *)((byte *)r_edges +
                                 r_pedge->cachededgeoffset))->owner == r_pedge)) {
                    R_EmitCachedEdge();
                    r_lastvertvalid = qfalse;
                    continue;
                }
            }
        }
 
        // assume it's cacheable
        cacheoffset = (byte *)edge_p - (byte *)r_edges;
        r_leftclipped = r_rightclipped = qfalse;
        R_ClipEdge(r_pedge->v[surfedge->vert    ],
                   r_pedge->v[surfedge->vert ^ 1],
                   pclip);
        r_pedge->cachededgeoffset = cacheoffset;
 
        if (r_leftclipped)
            makeleftedge = qtrue;
        if (r_rightclipped)
            makerightedge = qtrue;
        r_lastvertvalid = qtrue;
    }
 
// if there was a clip off the left edge, add that edge too
// FIXME: faster to do in screen space?
// FIXME: share clipped edges?
    if (makeleftedge) {
        r_pedge = &tedge;
        r_lastvertvalid = qfalse;
        R_ClipEdge(&r_leftexit, &r_leftenter, pclip->next);
    }
 
// if there was a clip off the right edge, get the right r_nearzi
    if (makerightedge) {
        r_pedge = &tedge;
        r_lastvertvalid = qfalse;
        r_nearzionly = qtrue;
        R_ClipEdge(&r_rightexit, &r_rightenter, view_clipplanes[1].next);
    }
 
// if no edges made it out, return without posting the surface
    if (!r_emitted)
        return;
 
    r_polycount++;
 
    surface_p->msurf = fa;
    surface_p->nearzi = r_nearzi;
    surface_p->flags = fa->drawflags;
    surface_p->insubmodel = insubmodel;
    surface_p->spanstate = 0;
    surface_p->entity = currententity;
    surface_p->key = r_currentkey++;
    surface_p->spans = NULL;
 
    pplane = fa->plane;
// FIXME: cache this?
    R_TransformVector(pplane->normal, p_normal);
// FIXME: cache this?
    distinv = 1.0 / (pplane->dist - DotProduct(modelorg, pplane->normal));
 
    surface_p->d_zistepu = p_normal[0] * r_refdef.xscaleinv * distinv;
    surface_p->d_zistepv = -p_normal[1] * r_refdef.yscaleinv * distinv;
    surface_p->d_ziorigin = p_normal[2] * distinv -
                            r_refdef.xcenter * surface_p->d_zistepu -
                            r_refdef.ycenter * surface_p->d_zistepv;
 
    surface_p++;
}

Referenced by R_DrawSubmodelPolygons(), R_EmitSkyBox(), and R_RecursiveWorldNode().

R_RenderWorld()

void R_RenderWorld

(

void

)

Definition at line 474 of file bsp.c.

{
 
    if (!r_drawworld->integer)
        return;
    if (r_newrefdef.rdflags & RDF_NOWORLDMODEL)
        return;
 
    c_drawnode = 0;
 
    // auto cycle the world frame for texture animation
    r_worldentity.frame = (int)(r_newrefdef.time * 2);
    currententity = &r_worldentity;
 
    VectorCopy(r_origin, modelorg);
 
    R_RecursiveWorldNode(r_worldmodel->nodes, 15);
}

Referenced by R_EdgeDrawing().

R_RotateBmodel()

void R_RotateBmodel

(

void

)

Definition at line 71 of file bsp.c.

{
    AnglesToAxis(currententity->angles, entity_rotation);
 
//
// rotate modelorg and the transformation matrix
//
    R_EntityRotate(modelorg);
    R_EntityRotate(vpn);
    R_EntityRotate(vright);
    R_EntityRotate(vup);
 
    R_TransformFrustum();
}

Referenced by D_SolidSurf(), D_TurbulentSurf(), and R_DrawBEntitiesOnList().

R_ScanEdges()

void R_ScanEdges

(

void

)

Definition at line 556 of file edge.c.

{
    int     iv, bottom;
    byte    basespans[MAXSPANS * sizeof(espan_t) + CACHE_SIZE];
    espan_t *basespan_p;
    surf_t  *s;
 
    basespan_p = (espan_t *)
                 ((uintptr_t)(basespans + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
    max_span_p = &basespan_p[MAXSPANS - r_refdef.vrect.width];
 
    span_p = basespan_p;
 
// clear active edges to just the background edges around the whole screen
// FIXME: most of this only needs to be set up once
    edge_head.u = r_refdef.vrect.x << 20;
    edge_head_u_shift20 = edge_head.u >> 20;
    edge_head.u_step = 0;
    edge_head.prev = NULL;
    edge_head.next = &edge_tail;
    edge_head.surfs[0] = 0;
    edge_head.surfs[1] = 1;
 
    edge_tail.u = (r_refdef.vrectright << 20) + 0xFFFFF;
    edge_tail_u_shift20 = edge_tail.u >> 20;
    edge_tail.u_step = 0;
    edge_tail.prev = &edge_head;
    edge_tail.next = &edge_aftertail;
    edge_tail.surfs[0] = 1;
    edge_tail.surfs[1] = 0;
 
    edge_aftertail.u = -1;      // force a move
    edge_aftertail.u_step = 0;
    edge_aftertail.next = &edge_sentinel;
    edge_aftertail.prev = &edge_tail;
 
// FIXME: do we need this now that we clamp x in r_draw.c?
    edge_sentinel.u = 2000 << 20;       // make sure nothing sorts past this
    edge_sentinel.prev = &edge_aftertail;
 
//
// process all scan lines
//
    bottom = r_refdef.vrectbottom - 1;
 
    for (iv = r_refdef.vrect.y; iv < bottom; iv++) {
        current_iv = iv;
        fv = (float)iv;
 
        // mark that the head (background start) span is pre-included
        surfaces[1].spanstate = 1;
 
        if (newedges[iv]) {
            R_InsertNewEdges(newedges[iv], edge_head.next);
        }
 
        (*pdrawfunc)();
 
        // flush the span list if we can't be sure we have enough spans left for
        // the next scan
        if (span_p > max_span_p) {
            D_DrawSurfaces();
 
            // clear the surface span pointers
            for (s = &surfaces[1]; s < surface_p; s++)
                s->spans = NULL;
 
            span_p = basespan_p;
        }
 
        if (removeedges[iv])
            R_RemoveEdges(removeedges[iv]);
 
        if (edge_head.next != &edge_tail)
            R_StepActiveU(edge_head.next);
    }
 
// do the last scan (no need to step or sort or remove on the last scan)
 
    current_iv = iv;
    fv = (float)iv;
 
// mark that the head (background start) span is pre-included
    surfaces[1].spanstate = 1;
 
    if (newedges[iv])
        R_InsertNewEdges(newedges[iv], edge_head.next);
 
    (*pdrawfunc)();
 
// draw whatever's left in the span list
    D_DrawSurfaces();
}

Referenced by R_EdgeDrawing().

R_SetupFrame()

void R_SetupFrame

(

void

)

Definition at line 243 of file misc.c.

{
    int         i;
    vrect_t     vrect;
 
    if (r_fullbright->modified) {
        r_fullbright->modified = qfalse;
        D_FlushCaches();    // so all lighting changes
    }
 
    r_framecount++;
 
 
// build the transformation matrix for the given view angles
    VectorCopy(r_newrefdef.vieworg, modelorg);
    VectorCopy(r_newrefdef.vieworg, r_origin);
 
    AngleVectors(r_newrefdef.viewangles, vpn, vright, vup);
 
// current viewleaf
    if (!(r_newrefdef.rdflags & RDF_NOWORLDMODEL)) {
        r_viewleaf = BSP_PointLeaf(r_worldmodel->nodes, r_origin);
        r_viewcluster = r_viewleaf->cluster;
    }
 
    if (sw_waterwarp->integer && (r_newrefdef.rdflags & RDF_UNDERWATER))
        r_dowarp = qtrue;
    else
        r_dowarp = qfalse;
 
    if (r_dowarp) {
        // warp into off screen buffer
        vrect.x = 0;
        vrect.y = 0;
        vrect.width = r_newrefdef.width < WARP_WIDTH ? r_newrefdef.width : WARP_WIDTH;
        vrect.height = r_newrefdef.height < WARP_HEIGHT ? r_newrefdef.height : WARP_HEIGHT;
 
        d_viewbuffer = r_warpbuffer;
        d_screenrowbytes = WARP_WIDTH * VID_BYTES;
    } else {
        vrect.x = r_newrefdef.x;
        vrect.y = r_newrefdef.y;
        vrect.width = r_newrefdef.width;
        vrect.height = r_newrefdef.height;
 
        d_viewbuffer = (void *)vid.buffer;
        d_screenrowbytes = vid.rowbytes;
    }
 
    R_ViewChanged(&vrect);
 
// start off with just the four screen edge clip planes
    R_TransformFrustum();
    R_SetUpFrustumIndexes();
 
// save base values
    VectorCopy(vpn, base_vpn);
    VectorCopy(vright, base_vright);
    VectorCopy(vup, base_vup);
 
// clear frame counts
    c_faceclip = 0;
    r_polycount = 0;
    r_drawnpolycount = 0;
    r_wholepolycount = 0;
    r_amodels_drawn = 0;
    r_outofsurfaces = 0;
    r_outofedges = 0;
 
// d_setup
    for (i = 0; i < vid.height; i++) {
        d_spantable[i] = d_viewbuffer + i * d_screenrowbytes;
        d_zspantable[i] = d_pzbuffer + i * d_zwidth;
    }
 
// clear Z-buffer and color-buffers if we're doing the gallery
    if (r_newrefdef.rdflags & RDF_NOWORLDMODEL) {
        memset(d_pzbuffer, 0xff, vid.width * vid.height * sizeof(d_pzbuffer[0]));
#if 0
        R_DrawFill8(r_newrefdef.x, r_newrefdef.y, r_newrefdef.width, r_newrefdef.height, /*(int)sw_clearcolor->value & 0xff*/0);
#endif
    }
 
    d_minmip = Cvar_ClampInteger(sw_mipcap, 0, NUM_MIPS - 1);
 
    for (i = 0; i < (NUM_MIPS - 1); i++)
        d_scalemip[i] = basemip[i] * sw_mipscale->value;
}

Referenced by R_RenderFrame().

R_ShutdownImages()

void R_ShutdownImages

(

void

)

Definition at line 180 of file image.c.

{
    IMG_FreeAll();
}

Referenced by R_Shutdown().

R_TransformFrustum()

void R_TransformFrustum

(

void

)

Definition at line 70 of file misc.c.

{
    int     i;
    vec3_t  v, v2;
 
    for (i = 0; i < 4; i++) {
        v[0] = screenedge[i].normal[2];
        v[1] = -screenedge[i].normal[0];
        v[2] = screenedge[i].normal[1];
 
        v2[0] = v[1] * vright[0] + v[2] * vup[0] + v[0] * vpn[0];
        v2[1] = v[1] * vright[1] + v[2] * vup[1] + v[0] * vpn[1];
        v2[2] = v[1] * vright[2] + v[2] * vup[2] + v[0] * vpn[2];
 
        VectorCopy(v2, view_clipplanes[i].normal);
 
        view_clipplanes[i].dist = DotProduct(modelorg, v2);
    }
}

Referenced by D_DrawSurfaces(), D_SolidSurf(), D_TurbulentSurf(), R_DrawBEntitiesOnList(), R_RotateBmodel(), and R_SetupFrame().

R_TransformPlane()

void R_TransformPlane	(	cplane_t *	p,
		float *	normal,
		float *	dist
	)

R_TransformVector()

void R_TransformVector	(	vec3_t	in,
		vec3_t	out
	)

Definition at line 96 of file misc.c.

{
    out[0] = DotProduct(in, vright);
    out[1] = DotProduct(in, vup);
    out[2] = DotProduct(in, vpn);
}

Referenced by D_CalcGradients(), D_DrawSurfaces(), D_SolidSurf(), D_TurbulentSurf(), R_ClipAndDrawPoly(), R_EmitEdge(), R_PolygonCalculateGradients(), R_RenderBmodelFace(), and R_RenderFace().

Variable Documentation

aliastriangleparms

aliastriangleparms_t aliastriangleparms

Definition at line 47 of file polyset.c.

Referenced by R_AliasClipTriangle(), R_AliasPreparePoints(), and R_DrawTriangle().

auxedges

edge_t* auxedges

Definition at line 31 of file edge.c.

Referenced by R_EdgeDrawing(), R_NewMap(), and R_Shutdown().

auxsurfaces

surf_t* auxsurfaces

Definition at line 34 of file edge.c.

Referenced by R_EdgeDrawing(), R_NewMap(), and R_Shutdown().

base_vpn

vec3_t base_vpn

Definition at line 361 of file sw.h.

base_vright

vec3_t base_vright

Definition at line 362 of file sw.h.

base_vup

vec3_t base_vup

Definition at line 360 of file sw.h.

bbextents

fixed16_t bbextents

Definition at line 467 of file sw.h.

Referenced by D_CalcGradients(), D_DrawSpans16(), D_DrawTurbulent16(), R_PolygonCalculateGradients(), and R_PolygonDrawSpans().

bbextentt

fixed16_t bbextentt

Definition at line 327 of file sw.h.

blanktable

int blanktable[CYCLE *2]

Definition at line 135 of file main.c.

Referenced by D_TurbulentSurf(), R_InitTurb(), and R_PolygonDrawSpans().

blocklights

blocklight_t blocklights[MAX_BLOCKLIGHTS *LIGHTMAP_BYTES]

Definition at line 207 of file light.c.

Referenced by R_AddDynamicLights(), and R_BuildLightMap().

c_faceclip

int c_faceclip

Definition at line 35 of file raster.c.

Referenced by R_PrintTimes(), R_RenderBmodelFace(), R_RenderFace(), and R_SetupFrame().

c_surf

int c_surf

Definition at line 42 of file main.c.

Referenced by D_CacheSurface(), and R_PrintTimes().

cacheblock

pixel_t* cacheblock

Definition at line 122 of file main.c.

Referenced by D_DrawSpans16(), D_DrawTurbulent16(), D_SkySurf(), D_SolidSurf(), D_TurbulentSurf(), R_DrawPoly(), and R_PolygonDrawSpans().

cachewidth

int cachewidth

Definition at line 123 of file main.c.

Referenced by D_DrawSpans16(), D_SkySurf(), D_SolidSurf(), D_TurbulentSurf(), R_DrawPoly(), R_DrawSpanletAlphaTestBlended(), R_DrawSpanletBlended(), and R_DrawSpanletOpaque().

currententity

entity_t* currententity

Definition at line 26 of file bsp.c.

Referenced by D_DrawSurfaces(), D_SolidSurf(), D_TurbulentSurf(), R_AddDynamicLights(), R_AliasCheckBBox(), R_AliasDrawModel(), R_AliasPreparePoints(), R_AliasSetupBlend(), R_AliasSetupFrames(), R_AliasSetUpLerpData(), R_AliasSetupLighting(), R_AliasSetupSkin(), R_AliasSetUpTransform(), R_AliasTransformFinalVerts(), R_DrawBEntitiesOnList(), R_DrawEntities(), R_DrawSprite(), R_MarkLights(), R_RenderBmodelFace(), R_RenderFace(), R_RenderWorld(), R_RotateBmodel(), and R_TextureAnimation().

currentmodel

model_t* currentmodel

Definition at line 29 of file main.c.

Referenced by R_AliasPreparePoints(), R_AliasSetupFrames(), R_AliasSetupSkin(), R_DrawEntities(), and R_DrawSprite().

d_minmip

int d_minmip

Definition at line 27 of file misc.c.

Referenced by D_MipLevelForScale(), and R_SetupFrame().

d_pzbuffer

short* d_pzbuffer

Definition at line 127 of file main.c.

Referenced by R_ApplySIRDAlgorithum(), R_ModeChanged(), R_SetupFrame(), and R_Shutdown().

d_scalemip

float d_scalemip[3]

Definition at line 28 of file misc.c.

Referenced by D_MipLevelForScale(), and R_SetupFrame().

d_screenrowbytes

int d_screenrowbytes

Definition at line 126 of file main.c.

Referenced by R_DrawParticle(), R_PolysetSetUpAndScanLeftEdge(), and R_SetupFrame().

d_sdivzorigin

float d_sdivzorigin

Definition at line 118 of file main.c.

Referenced by D_CalcGradients(), D_DrawSpans16(), D_DrawTurbulent16(), R_PolygonCalculateGradients(), and R_PolygonDrawSpans().

d_sdivzstepu

float d_sdivzstepu

Definition at line 116 of file main.c.

Referenced by D_CalcGradients(), D_DrawSpans16(), D_DrawTurbulent16(), R_PolygonCalculateGradients(), and R_PolygonDrawSpans().

d_sdivzstepv

float d_sdivzstepv

Definition at line 117 of file main.c.

Referenced by D_CalcGradients(), D_DrawSpans16(), D_DrawTurbulent16(), R_PolygonCalculateGradients(), and R_PolygonDrawSpans().

d_spantable

byte* d_spantable[MAXHEIGHT]

Definition at line 130 of file main.c.

Referenced by D_DrawSpans16(), D_DrawTurbulent16(), D_FlatFillSurface(), R_DrawParticle(), R_PolygonDrawSpans(), R_PolysetSetUpAndScanLeftEdge(), and R_SetupFrame().

d_tdivzorigin

float d_tdivzorigin

Definition at line 324 of file sw.h.

d_tdivzstepu

float d_tdivzstepu

Definition at line 322 of file sw.h.

d_tdivzstepv

float d_tdivzstepv

Definition at line 323 of file sw.h.

d_viewbuffer

pixel_t* d_viewbuffer

Definition at line 125 of file main.c.

Referenced by R_SetupFrame().

d_ziorigin

float d_ziorigin

Definition at line 324 of file sw.h.

d_zistepu

float d_zistepu

Definition at line 322 of file sw.h.

d_zistepv

float d_zistepv

Definition at line 323 of file sw.h.

d_zrowbytes

int d_zrowbytes

Definition at line 128 of file main.c.

Referenced by R_ModeChanged().

d_zspantable

short* d_zspantable[MAXHEIGHT]

Definition at line 131 of file main.c.

Referenced by D_DrawZSpans(), R_DrawParticle(), R_PolygonDrawSpans(), R_PolysetSetUpAndScanLeftEdge(), and R_SetupFrame().

d_zwidth

int d_zwidth

Definition at line 129 of file main.c.

Referenced by R_DrawParticle(), R_ModeChanged(), R_PolysetSetUpAndScanLeftEdge(), and R_SetupFrame().

edge_max

edge_t * edge_max

Definition at line 479 of file sw.h.

edge_p

edge_t * edge_p

Definition at line 479 of file sw.h.

entity_rotation

vec3_t entity_rotation[3]

Definition at line 32 of file bsp.c.

Referenced by R_AddDynamicLights(), R_EntityRotate(), R_MarkLights(), R_RecursiveClipBPoly(), and R_RotateBmodel().

insubmodel

qboolean insubmodel

Definition at line 25 of file bsp.c.

Referenced by R_DrawBEntitiesOnList(), R_EmitSkyBox(), R_MarkLights(), and R_RenderFace().

intsintable

int intsintable[CYCLE *2]

Definition at line 134 of file main.c.

Referenced by D_WarpScreen(), and R_InitTurb().

modelorg

vec3_t modelorg

Definition at line 27 of file bsp.c.

Referenced by D_DrawSurfaces(), R_DrawAlphaSurfaces(), R_DrawBEntitiesOnList(), R_DrawEntities(), R_DrawSolidClippedSubmodelPolygons(), R_DrawSprite(), R_DrawSubmodelPolygons(), R_EmitEdge(), R_RecursiveWorldNode(), R_RenderBmodelFace(), R_RenderFace(), R_RenderWorld(), R_RotateBmodel(), R_SetupFrame(), and R_TransformFrustum().

newedges

edge_t* newedges[MAXHEIGHT]

Definition at line 41 of file edge.c.

Referenced by R_BeginEdgeFrame(), R_EmitEdge(), and R_ScanEdges().

pfrustum_indexes

int* pfrustum_indexes[4]

Definition at line 70 of file main.c.

Referenced by R_BmodelCheckBBox(), R_RecursiveWorldNode(), and R_SetUpFrustumIndexes().

r_affinetridesc

affinetridesc_t r_affinetridesc

Definition at line 27 of file alias.c.

Referenced by R_AliasSetupBlend(), R_AliasSetupSkin(), R_PolysetDrawSpans8_Blended(), R_PolysetDrawSpans8_Opaque(), R_PolysetScanLeftEdge(), R_PolysetSetUpAndScanLeftEdge(), and R_RasterizeAliasPolySmooth().

r_alias_alpha

int r_alias_alpha

Definition at line 29 of file alias.c.

Referenced by R_AliasSetupBlend(), and R_PolysetDrawSpans8_Blended().

r_alias_one_minus_alpha

int r_alias_one_minus_alpha

Definition at line 30 of file alias.c.

Referenced by R_AliasSetupBlend(), R_PolysetDrawSpans8_Blended(), and R_PolysetDrawSpansConstant8_Blended().

r_aliasblendcolor

fixed8_t r_aliasblendcolor[3]

Definition at line 31 of file alias.c.

Referenced by R_AliasSetupBlend(), R_AliasSetupLighting(), R_PolysetDrawSpans8_Blended(), R_PolysetDrawSpans8_Opaque(), and R_PolysetDrawSpansConstant8_Blended().

r_alpha_surfaces

mface_t* r_alpha_surfaces

Definition at line 41 of file poly.c.

Referenced by R_DrawAlphaSurfaces(), R_RenderBmodelFace(), and R_RenderFace().

r_amodels_drawn

int r_amodels_drawn

Definition at line 25 of file alias.c.

Referenced by R_AliasDrawModel(), R_PrintAliasStats(), and R_SetupFrame().

r_clipflags

int r_clipflags

Definition at line 44 of file main.c.

Referenced by R_DrawBEntitiesOnList(), and R_RenderBmodelFace().

r_cnumsurfs

int r_cnumsurfs

Definition at line 502 of file sw.h.

r_currentbkey

int r_currentbkey

Definition at line 34 of file bsp.c.

Referenced by R_RecursiveClipBPoly(), and R_RenderBmodelFace().

r_currentkey

int r_currentkey

Definition at line 46 of file edge.c.

Referenced by R_BeginEdgeFrame(), R_DrawSubmodelPolygons(), R_EmitSkyBox(), R_RecursiveWorldNode(), and R_RenderFace().

r_dlightframecount

int r_dlightframecount

Definition at line 22 of file light.c.

Referenced by R_DrawBEntitiesOnList(), R_MarkLights(), and R_MarkLights_r().

r_dowarp

qboolean r_dowarp

Definition at line 40 of file main.c.

Referenced by R_ApplySIRDAlgorithum(), R_RenderFrame(), and R_SetupFrame().

r_drawentities

cvar_t* r_drawentities

Definition at line 97 of file main.c.

Referenced by R_DrawBEntitiesOnList(), R_DrawEntitiesOnList(), and R_Register().

r_drawnpolycount

int r_drawnpolycount

Definition at line 67 of file main.c.

Referenced by D_DrawSurfaces(), R_PrintTimes(), and R_SetupFrame().

r_drawsurf

drawsurf_t r_drawsurf

Definition at line 22 of file surf.c.

Referenced by D_CacheSurface(), R_AddDynamicLights(), R_BuildLightMap(), and R_DrawSurface().

r_drawworld

cvar_t* r_drawworld

Definition at line 96 of file main.c.

Referenced by R_Register(), and R_RenderWorld().

r_edges

edge_t* r_edges

Definition at line 32 of file edge.c.

Referenced by R_BeginEdgeFrame(), R_EdgeDrawing(), R_EmitCachedEdge(), and R_RenderFace().

r_entorigin

vec3_t r_entorigin

Definition at line 29 of file bsp.c.

Referenced by R_DrawBEntitiesOnList(), R_DrawEntities(), R_DrawSprite(), and R_RecursiveClipBPoly().

r_framecount

int r_framecount

Definition at line 64 of file main.c.

Referenced by D_CacheSurface(), R_BuildLightMap(), R_ClipEdge(), R_DrawBEntitiesOnList(), R_EmitEdge(), R_EmitSkyBox(), R_MarkLights(), R_RecursiveWorldNode(), R_RenderFace(), and R_SetupFrame().

r_frustum_indexes

int r_frustum_indexes[4 *6]

Definition at line 71 of file main.c.

Referenced by R_SetUpFrustumIndexes().

r_fullbright

cvar_t* r_fullbright

Definition at line 98 of file main.c.

Referenced by R_BuildLightMap(), R_LightPoint(), R_Register(), and R_SetupFrame().

r_lerpmodels

cvar_t* r_lerpmodels

Definition at line 99 of file main.c.

Referenced by R_AliasDrawModel(), and R_Register().

r_maxedgesseen

int r_maxedgesseen

Definition at line 502 of file sw.h.

r_maxsurfsseen

int r_maxsurfsseen

Definition at line 43 of file main.c.

Referenced by R_NewMap().

r_maxvalidedgeoffset

int r_maxvalidedgeoffset

r_newrefdef

refdef_t r_newrefdef

Definition at line 28 of file main.c.

Referenced by _R_LightPoint(), D_CacheSurface(), D_CalcGradients(), D_DrawTurbulent16(), D_WarpScreen(), R_AddDynamicLights(), R_AliasSetupLighting(), R_BuildPolygonFromSurface(), R_DrawBEntitiesOnList(), R_DrawEntities(), R_DrawParticles(), R_EdgeDrawing(), R_LightPoint(), R_MarkLights(), R_PolygonDrawSpans(), R_RecursiveClipBPoly(), R_RecursiveWorldNode(), R_RenderFrame(), R_RenderWorld(), R_SetupFrame(), and R_ViewChanged().

r_numallocatededges

int r_numallocatededges

Definition at line 36 of file main.c.

Referenced by R_BeginEdgeFrame(), and R_NewMap().

r_oldviewcluster

int r_oldviewcluster

Definition at line 506 of file sw.h.

r_origin

vec3_t r_origin

Definition at line 52 of file main.c.

Referenced by D_DrawSurfaces(), D_SolidSurf(), D_TurbulentSurf(), R_AliasSetUpTransform(), R_BuildPolygonFromSurface(), R_ClipAndDrawPoly(), R_DrawAlphaSurfaces(), R_DrawBEntitiesOnList(), R_DrawEntities(), R_DrawParticle(), R_EmitSkyBox(), R_IMFlatShadedQuad(), R_RenderWorld(), and R_SetupFrame().

r_outofedges

int r_outofedges

Definition at line 38 of file main.c.

Referenced by R_RenderBmodelFace(), R_RenderFace(), R_RenderFrame(), and R_SetupFrame().

r_outofsurfaces

int r_outofsurfaces

Definition at line 37 of file main.c.

Referenced by R_RenderBmodelFace(), R_RenderFace(), R_RenderFrame(), and R_SetupFrame().

r_polycount

int r_polycount

Definition at line 66 of file main.c.

Referenced by R_PrintTimes(), R_RenderBmodelFace(), R_RenderFace(), and R_SetupFrame().

r_ptverts

mvertex_t* r_ptverts

r_ptvertsmax

mvertex_t * r_ptvertsmax

Definition at line 469 of file sw.h.

r_refdef

oldrefdef_t r_refdef

Definition at line 57 of file main.c.

Referenced by D_CalcGradients(), D_SolidSurf(), D_WarpScreen(), R_Alias_clip_bottom(), R_Alias_clip_left(), R_Alias_clip_right(), R_Alias_clip_top(), R_AliasClip(), R_AliasClipTriangle(), R_AliasDrawModel(), R_AliasProjectAndClipTestFinalVert(), R_BeginEdgeFrame(), R_ClipAndDrawPoly(), R_DrawParticle(), R_DrawParticles(), R_EmitEdge(), R_PolygonCalculateGradients(), R_PolygonScanRightEdge(), R_RenderBmodelFace(), R_RenderFace(), R_ScanEdges(), and R_ViewChanged().

r_speeds

cvar_t* r_speeds

Definition at line 102 of file main.c.

Referenced by R_Register(), and R_RenderFrame().

r_surfsonstack

qboolean r_surfsonstack

r_time1

float r_time1

Definition at line 35 of file main.c.

Referenced by R_PrintTimes(), and R_RenderFrame().

r_viewcluster

int r_viewcluster

Definition at line 74 of file main.c.

Referenced by R_MarkLeaves(), R_NewMap(), and R_SetupFrame().

r_viewleaf

mleaf_t* r_viewleaf

Definition at line 73 of file main.c.

Referenced by R_SetupFrame().

r_visframecount

int r_visframecount

Definition at line 65 of file main.c.

Referenced by R_FindTopnode(), R_MarkLeaves(), R_RecursiveClipBPoly(), and R_RecursiveWorldNode().

r_warpbuffer

byte r_warpbuffer[WARP_WIDTH *WARP_HEIGHT *VID_BYTES]

Definition at line 33 of file main.c.

Referenced by D_WarpScreen(), and R_SetupFrame().

r_wholepolycount

int r_wholepolycount

Definition at line 68 of file main.c.

Referenced by R_SetupFrame().

r_worldentity

entity_t r_worldentity

Definition at line 26 of file main.c.

Referenced by D_SolidSurf(), R_AddDynamicLights(), and R_RenderWorld().

r_worldmodel

bsp_t* r_worldmodel

Definition at line 31 of file main.c.

Referenced by _R_LightPoint(), R_BeginRegistration(), R_DrawBEntitiesOnList(), R_FindTopnode(), R_LightPoint(), R_MarkLeaves(), R_RenderFrame(), R_RenderWorld(), R_SetupFrame(), and R_Shutdown().

removeedges

edge_t* removeedges[MAXHEIGHT]

Definition at line 42 of file edge.c.

Referenced by R_BeginEdgeFrame(), R_EmitEdge(), and R_ScanEdges().

sadjust

fixed16_t sadjust

Definition at line 466 of file sw.h.

Referenced by D_CalcGradients(), D_DrawSpans16(), D_DrawTurbulent16(), R_PolygonCalculateGradients(), and R_PolygonDrawSpans().

screenedge

cplane_t screenedge[4]

Definition at line 59 of file main.c.

Referenced by R_TransformFrustum(), and R_ViewChanged().

sintable

int sintable[CYCLE *2]

Definition at line 133 of file main.c.

Referenced by D_TurbulentSurf(), R_InitTurb(), and R_PolygonDrawSpans().

surf_max

surf_t * surf_max

Definition at line 365 of file sw.h.

surface_p

surf_t * surface_p

Definition at line 365 of file sw.h.

surfaces

surf_t* surfaces

Definition at line 35 of file edge.c.

Referenced by collect_ligth_polys(), collect_surfaces(), D_DrawflatSurfaces(), D_DrawSurfaces(), D_DrawZSurfaces(), R_BeginEdgeFrame(), R_CleanupSpan(), R_EdgeDrawing(), R_EmitCachedEdge(), R_EmitEdge(), R_GenerateSpans(), R_GenerateSpansBackward(), R_LeadingEdge(), R_LeadingEdgeBackwards(), R_NewMap(), R_ScanEdges(), and R_TrailingEdge().

sw_aliasstats

cvar_t* sw_aliasstats

Definition at line 76 of file main.c.

Referenced by R_Register(), and R_RenderFrame().

sw_clearcolor

cvar_t* sw_clearcolor

Definition at line 77 of file main.c.

Referenced by D_BackgroundSurf(), and R_Register().

sw_drawflat

cvar_t* sw_drawflat

Definition at line 78 of file main.c.

Referenced by D_DrawSurfaces(), and R_Register().

sw_draworder

cvar_t* sw_draworder

Definition at line 79 of file main.c.

Referenced by R_BeginEdgeFrame(), and R_Register().

sw_drawsird

cvar_t* sw_drawsird

Definition at line 93 of file main.c.

Referenced by D_DrawSurfaces(), R_ApplySIRDAlgorithum(), R_Register(), and R_RenderFrame().

sw_dynamic

cvar_t* sw_dynamic

Definition at line 86 of file main.c.

Referenced by R_Register(), and R_RenderFrame().

sw_maxedges

cvar_t* sw_maxedges

Definition at line 80 of file main.c.

Referenced by R_NewMap(), and R_Register().

sw_maxsurfs

cvar_t* sw_maxsurfs

Definition at line 81 of file main.c.

Referenced by R_NewMap(), and R_Register().

sw_mipcap

cvar_t* sw_mipcap

Definition at line 24 of file misc.c.

Referenced by R_Register(), and R_SetupFrame().

sw_mipscale

cvar_t* sw_mipscale

Definition at line 25 of file misc.c.

Referenced by R_Register(), and R_SetupFrame().

sw_mode

cvar_t* sw_mode

sw_modulate

cvar_t* sw_modulate

Definition at line 87 of file main.c.

Referenced by D_CacheSurface(), R_AddDynamicLights(), R_LightPoint(), and R_Register().

sw_reportedgeout

cvar_t* sw_reportedgeout

Definition at line 82 of file main.c.

Referenced by R_Register(), and R_RenderFrame().

sw_reportsurfout

cvar_t* sw_reportsurfout

Definition at line 83 of file main.c.

Referenced by R_Register(), and R_RenderFrame().

sw_surfcacheoverride

cvar_t* sw_surfcacheoverride

Definition at line 84 of file main.c.

Referenced by R_InitCaches(), and R_ModeChanged().

sw_waterwarp

cvar_t* sw_waterwarp

Definition at line 85 of file main.c.

Referenced by R_Register(), and R_SetupFrame().

sxformaxis

vec3_t sxformaxis[4]

tadjust

fixed16_t tadjust

Definition at line 326 of file sw.h.

txformaxis

vec3_t txformaxis[4]

vid

viddef_t vid

Definition at line 22 of file main.c.

Referenced by D_WarpScreen(), IMG_ReadPixels(), R_ApplySIRDAlgorithum(), R_DrawFill32(), R_DrawFill8(), R_DrawFixedData(), R_DrawStretchData(), R_InitCaches(), R_ModeChanged(), R_SetupFrame(), and R_TileClear().

vid_fullscreen

cvar_t* vid_fullscreen

Definition at line 33 of file refresh.c.

Referenced by CL_InitRefresh(), CL_RunRefresh(), CL_ShutdownRefresh(), VID_GetFullscreen(), VID_ToggleFullscreen(), Win_MainWndProc(), and Win_SetMode().

vid_gamma

cvar_t* vid_gamma

Definition at line 104 of file main.c.

Referenced by R_BuildGammaTable(), and R_Register().

view_clipplanes

clipplane_t view_clipplanes[4]

Definition at line 37 of file raster.c.

Referenced by R_AliasCheckFrameBBox(), R_BmodelCheckBBox(), R_ClipAndDrawPoly(), R_Init(), R_RecursiveWorldNode(), R_RenderBmodelFace(), R_RenderFace(), R_SetUpFrustumIndexes(), and R_TransformFrustum().

vpn

vec3_t vpn

Definition at line 50 of file main.c.

Referenced by D_SolidSurf(), D_TurbulentSurf(), R_AliasSetUpTransform(), R_DrawBEntitiesOnList(), R_DrawParticles(), R_DrawSprite(), R_RotateBmodel(), R_SetupFrame(), R_TransformFrustum(), and R_TransformVector().

vright

vec3_t vright

Definition at line 51 of file main.c.

Referenced by D_SolidSurf(), D_TurbulentSurf(), R_AliasSetUpTransform(), R_DrawBEntitiesOnList(), R_DrawParticles(), R_DrawSprite(), R_RotateBmodel(), R_SetupFrame(), R_TransformFrustum(), and R_TransformVector().

vup

vec3_t vup

Definition at line 49 of file main.c.

Referenced by D_SolidSurf(), D_TurbulentSurf(), R_AliasSetUpTransform(), R_DrawBEntitiesOnList(), R_DrawParticles(), R_DrawSprite(), R_RotateBmodel(), R_SetupFrame(), R_TransformFrustum(), and R_TransformVector().