#include "r_local.h"

Macros
#define	STRINGER(x) "x"

#define	NUM_BEAM_SEGS 6

Functions
void	R_MarkLeaves (void)

void	R_InitTextures (void)

void	R_InitTurb (void)

void	R_ImageList_f (void)

void	R_Register (void)

void	R_UnRegister (void)

int	R_Init (void hInstance, void wndProc)

void	R_Shutdown (void)

void	R_NewMap (void)

void	R_DrawNullModel (void)

void	R_DrawEntitiesOnList (void)

int	R_BmodelCheckBBox (float *minmaxs)

mnode_t *	R_FindTopnode (vec3_t mins, vec3_t maxs)

void	RotatedBBox (vec3_t mins, vec3_t maxs, vec3_t angles, vec3_t tmins, vec3_t tmaxs)

void	R_DrawBEntitiesOnList (void)

void	R_EdgeDrawing (void)

void	R_CalcPalette (void)

void	R_SetLightLevel (void)

void	R_RenderFrame (refdef_t *fd)

void	R_InitGraphics (int width, int height)

void	R_BeginFrame (float camera_separation)

void	R_GammaCorrectAndSetPalette (const unsigned char *palette)

void	R_CinematicSetPalette (const unsigned char *palette)

void	Draw_BuildGammaTable (void)

void	R_DrawBeam (entity_t *e)

void	R_SetSky (char *name, float rotate, vec3_t axis)

void	Draw_GetPalette (void)

struct image_s *	R_RegisterSkin (char *name)

refexport_t	GetRefAPI (refimport_t rimp)

void	Sys_Error (char *error,...)

void	Com_Printf (char *fmt,...)

Variables
viddef_t	vid

refimport_t	ri

unsigned	d_8to24table [256]

entity_t	r_worldentity

char	skyname [MAX_QPATH]

float	skyrotate

vec3_t	skyaxis

image_t *	sky_images [6]

refdef_t	r_newrefdef

model_t *	currentmodel

model_t *	r_worldmodel

byte	r_warpbuffer [WARP_WIDTH *WARP_HEIGHT]

swstate_t	sw_state

void *	colormap

vec3_t	viewlightvec

alight_t	r_viewlighting = {128, 192, viewlightvec}

float	r_time1

int	r_numallocatededges

float	r_aliasuvscale = 1.0

int	r_outofsurfaces

int	r_outofedges

qboolean	r_dowarp

mvertex_t *	r_pcurrentvertbase

int	c_surf

int	r_maxsurfsseen

int	r_maxedgesseen

int	r_cnumsurfs

qboolean	r_surfsonstack

int	r_clipflags

vec3_t	vup

vec3_t	base_vup

vec3_t	vpn

vec3_t	base_vpn

vec3_t	vright

vec3_t	base_vright

vec3_t	r_origin

oldrefdef_t	r_refdef

float	xcenter

float	ycenter

float	xscale

float	yscale

float	xscaleinv

float	yscaleinv

float	xscaleshrink

float	yscaleshrink

float	aliasxscale

float	aliasyscale

float	aliasxcenter

float	aliasycenter

int	r_screenwidth

float	verticalFieldOfView

float	xOrigin

float	yOrigin

mplane_t	screenedge [4]

int	r_framecount = 1

int	r_visframecount

int	d_spanpixcount

int	r_polycount

int	r_drawnpolycount

int	r_wholepolycount

int *	pfrustum_indexes [4]

int	r_frustum_indexes [4 *6]

mleaf_t *	r_viewleaf

int	r_viewcluster

int	r_oldviewcluster

image_t *	r_notexture_mip

float	da_time1

float	da_time2

float	dp_time1

float	dp_time2

float	db_time1

float	db_time2

float	rw_time1

float	rw_time2

float	se_time1

float	se_time2

float	de_time1

float	de_time2

cvar_t *	r_lefthand

cvar_t *	sw_aliasstats

cvar_t *	sw_allow_modex

cvar_t *	sw_clearcolor

cvar_t *	sw_drawflat

cvar_t *	sw_draworder

cvar_t *	sw_maxedges

cvar_t *	sw_maxsurfs

cvar_t *	sw_mode

cvar_t *	sw_reportedgeout

cvar_t *	sw_reportsurfout

cvar_t *	sw_stipplealpha

cvar_t *	sw_surfcacheoverride

cvar_t *	sw_waterwarp

cvar_t *	r_drawworld

cvar_t *	r_drawentities

cvar_t *	r_dspeeds

cvar_t *	r_fullbright

cvar_t *	r_lerpmodels

cvar_t *	r_novis

cvar_t *	r_speeds

cvar_t *	r_lightlevel

cvar_t *	vid_fullscreen

cvar_t *	vid_gamma

cvar_t *	sw_lockpvs

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 *	cacheblock

int	cachewidth

pixel_t *	d_viewbuffer

short *	d_pzbuffer

unsigned int	d_zrowbytes

unsigned int	d_zwidth

byte	r_notexture_buffer [1024]

char *	suf [6] = {"rt", "bk", "lf", "ft", "up", "dn"}

int	r_skysideimage [6] = {5, 2, 4, 1, 0, 3}

mtexinfo_t	r_skytexinfo [6]

Macro Definition Documentation

◆ NUM_BEAM_SEGS

#define NUM_BEAM_SEGS 6

◆ STRINGER

#define STRINGER ( x ) "x"

Definition at line 143 of file r_main.c.

Function Documentation

◆ Com_Printf()

void Com_Printf	(	char *	fmt,
			...
	)

Definition at line 1423 of file r_main.c.

 {
     va_list     argptr;
     char        text[1024];
  
     va_start (argptr, fmt);
     vsprintf (text, fmt, argptr);
     va_end (argptr);
  
     ri.Con_Printf (PRINT_ALL, "%s", text);
 }

◆ Draw_BuildGammaTable()

void Draw_BuildGammaTable ( void )

Definition at line 1217 of file r_main.c.

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

Referenced by R_BeginFrame().

◆ Draw_GetPalette()

void Draw_GetPalette ( void )

Definition at line 1326 of file r_main.c.

 {
     byte    *pal, *out;
     int     i;
     int     r, g, b;
  
     // get the palette and colormap
     LoadPCX ("pics/colormap.pcx", &vid.colormap, &pal, NULL, NULL);
     if (!vid.colormap)
         ri.Sys_Error (ERR_FATAL, "Couldn't load pics/colormap.pcx");
     vid.alphamap = vid.colormap + 64*256;
  
     out = (byte *)d_8to24table;
     for (i=0 ; i<256 ; i++, out+=4)
     {
         r = pal[i*3+0];
         g = pal[i*3+1];
         b = pal[i*3+2];
  
         out[0] = r;
         out[1] = g;
         out[2] = b;
     }
  
     free (pal);
 }

Referenced by R_Init().

◆ GetRefAPI()

refexport_t GetRefAPI ( refimport_t rimp )

Definition at line 1361 of file r_main.c.

 {
     refexport_t re;
  
     ri = rimp;
  
     re.api_version = API_VERSION;
  
     re.BeginRegistration = R_BeginRegistration;
     re.RegisterModel = R_RegisterModel;
     re.RegisterSkin = R_RegisterSkin;
     re.RegisterPic = Draw_FindPic;
     re.SetSky = R_SetSky;
     re.EndRegistration = R_EndRegistration;
  
     re.RenderFrame = R_RenderFrame;
  
     re.DrawGetPicSize = Draw_GetPicSize;
  
  
 #ifdef QMAX
     re.DrawScaledPic = Draw_ScaledPic;
     re.AddStain = R_AddStain;
 #endif
  
     re.DrawPic = Draw_Pic;
     re.DrawStretchPic = Draw_StretchPic;
     re.DrawChar = Draw_Char;
     re.DrawTileClear = Draw_TileClear;
     re.DrawFill = Draw_Fill;
     re.DrawFadeScreen= Draw_FadeScreen;
  
     re.DrawStretchRaw = Draw_StretchRaw;
  
     re.Init = R_Init;
     re.Shutdown = R_Shutdown;
  
     re.CinematicSetPalette = R_CinematicSetPalette;
     re.BeginFrame = R_BeginFrame;
     re.EndFrame = SWimp_EndFrame;
  
     re.AppActivate = SWimp_AppActivate;
  
     Swap_Init ();
  
     return re;
 }

Referenced by VID_LoadRefresh().

◆ R_BeginFrame()

void R_BeginFrame ( float camera_separation )

Definition at line 1099 of file r_main.c.

 {
     extern void Draw_BuildGammaTable( void );
 #ifdef REDBLUE
     SetStereoBuffer((camera_separation <= 0.0) ? 0 : 1);
 #endif
     /*
     ** rebuild the gamma correction palette if necessary
     */
     if ( vid_gamma->modified )
     {
         Draw_BuildGammaTable();
         R_GammaCorrectAndSetPalette( ( const unsigned char * ) d_8to24table );
  
         vid_gamma->modified = false;
     }
  
     while ( sw_mode->modified || vid_fullscreen->modified )
     {
         rserr_t err;
  
         /*
         ** if this returns rserr_invalid_fullscreen then it set the mode but not as a
         ** fullscreen mode, e.g. 320x200 on a system that doesn't support that res
         */
         if ( ( err = SWimp_SetMode( &vid.width, &vid.height, sw_mode->value, vid_fullscreen->value ) ) == rserr_ok )
         {
             R_InitGraphics( vid.width, vid.height );
  
             sw_state.prev_mode = sw_mode->value;
             vid_fullscreen->modified = false;
             sw_mode->modified = false;
         }
         else
         {
             if ( err == rserr_invalid_mode )
             {
                 ri.Cvar_SetValue( "sw_mode", sw_state.prev_mode );
                 ri.Con_Printf( PRINT_ALL, "ref_soft::R_BeginFrame() - could not set mode\n" );
             }
             else if ( err == rserr_invalid_fullscreen )
             {
                 R_InitGraphics( vid.width, vid.height );
  
                 ri.Cvar_SetValue( "vid_fullscreen", 0);
                 ri.Con_Printf( PRINT_ALL, "ref_soft::R_BeginFrame() - fullscreen unavailable in this mode\n" );
                 sw_state.prev_mode = sw_mode->value;
 //              vid_fullscreen->modified = false;
 //              sw_mode->modified = false;
             }
             else
             {
                 ri.Sys_Error( ERR_FATAL, "ref_soft::R_BeginFrame() - catastrophic mode change failure\n" );
             }
         }
     }
 }

Referenced by GetRefAPI(), and R_Init().

◆ R_BmodelCheckBBox()

int R_BmodelCheckBBox ( float * minmaxs )

Definition at line 619 of file r_main.c.

 {
     int         i, *pindex, clipflags;
     vec3_t      acceptpt, rejectpt;
     float       d;
  
     clipflags = 0;
  
     for (i=0 ; i<4 ; i++)
     {
     // generate accept and reject points
     // FIXME: do with fast look-ups or integer tests based on the sign bit
     // of the floating point values
  
         pindex = pfrustum_indexes[i];
  
         rejectpt[0] = minmaxs[pindex[0]];
         rejectpt[1] = minmaxs[pindex[1]];
         rejectpt[2] = minmaxs[pindex[2]];
         
         d = DotProduct (rejectpt, view_clipplanes[i].normal);
         d -= view_clipplanes[i].dist;
  
         if (d <= 0)
             return BMODEL_FULLY_CLIPPED;
  
         acceptpt[0] = minmaxs[pindex[3+0]];
         acceptpt[1] = minmaxs[pindex[3+1]];
         acceptpt[2] = minmaxs[pindex[3+2]];
  
         d = DotProduct (acceptpt, view_clipplanes[i].normal);
         d -= view_clipplanes[i].dist;
  
         if (d <= 0)
             clipflags |= (1<<i);
     }
  
     return clipflags;
 }

Referenced by R_DrawBEntitiesOnList().

◆ R_CalcPalette()

void R_CalcPalette ( void )

Definition at line 919 of file r_main.c.

 {
     static qboolean modified;
     byte    palette[256][4], *in, *out;
     int     i, j;
     float   alpha, one_minus_alpha;
     vec3_t  premult;
     int     v;
  
     alpha = r_newrefdef.blend[3];
     if (alpha <= 0)
     {
         if (modified)
         {   // set back to default
             modified = false;
             R_GammaCorrectAndSetPalette( ( const unsigned char * ) d_8to24table );
             return;
         }
         return;
     }
  
     modified = true;
     if (alpha > 1)
         alpha = 1;
  
     premult[0] = r_newrefdef.blend[0]*alpha*255;
     premult[1] = r_newrefdef.blend[1]*alpha*255;
     premult[2] = r_newrefdef.blend[2]*alpha*255;
  
     one_minus_alpha = (1.0 - alpha);
  
     in = (byte *)d_8to24table;
     out = palette[0];
     for (i=0 ; i<256 ; i++, in+=4, out+=4)
     {
         for (j=0 ; j<3 ; j++)
         {
             v = premult[j] + one_minus_alpha * in[j];
             if (v > 255)
                 v = 255;
             out[j] = v;
         }
         out[3] = 255;
     }
  
     R_GammaCorrectAndSetPalette( ( const unsigned char * ) palette[0] );
 //  SWimp_SetPalette( palette[0] );
 }

Referenced by R_RenderFrame().

◆ R_CinematicSetPalette()

void R_CinematicSetPalette ( const unsigned char * palette )

Definition at line 1177 of file r_main.c.

 {
     byte palette32[1024];
     int     i, j, w;
     int     *d;
  
     // clear screen to black to avoid any palette flash
     w = abs(vid.rowbytes)>>2;   // stupid negative pitch win32 stuff...
     for (i=0 ; i<vid.height ; i++, d+=w)
     {
         d = (int *)(vid.buffer + i*vid.rowbytes);
         for (j=0 ; j<w ; j++)
             d[j] = 0;
     }
     // flush it to the screen
     SWimp_EndFrame ();
  
     if ( palette )
     {
         for ( i = 0; i < 256; i++ )
         {
             palette32[i*4+0] = palette[i*3+0];
             palette32[i*4+1] = palette[i*3+1];
             palette32[i*4+2] = palette[i*3+2];
             palette32[i*4+3] = 0xFF;
         }
  
         R_GammaCorrectAndSetPalette( palette32 );
     }
     else
     {
         R_GammaCorrectAndSetPalette( ( const unsigned char * ) d_8to24table );
     }
 }

Referenced by GetRefAPI().

◆ R_DrawBeam()

void R_DrawBeam ( entity_t * e )

Definition at line 1245 of file r_main.c.

 {
 #define NUM_BEAM_SEGS 6
  
     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.0/NUM_BEAM_SEGS)*i );
         VectorAdd( start_points[i], origin, start_points[i] );
         VectorAdd( start_points[i], direction, end_points[i] );
     }
  
     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],
                             e->skinnum & 0xFF,
                             e->alpha );
     }
 }

Referenced by R_DrawEntitiesOnList().

◆ R_DrawBEntitiesOnList()

void R_DrawBEntitiesOnList ( void )

Definition at line 768 of file r_main.c.

 {
     int         i, clipflags;
     vec3_t      oldorigin;
     vec3_t      mins, maxs;
     float       minmaxs[6];
     mnode_t     *topnode;
  
     if (!r_drawentities->value)
         return;
  
     VectorCopy (modelorg, oldorigin);
     insubmodel = true;
     r_dlightframecount = r_framecount;
  
     for (i=0 ; i<r_newrefdef.num_entities ; i++)
     {
         currententity = &r_newrefdef.entities[i];
         currentmodel = currententity->model;
         if (!currentmodel)
             continue;
         if (currentmodel->nummodelsurfaces == 0)
             continue;   // clip brush only
         if ( currententity->flags & RF_BEAM )
             continue;
         if (currentmodel->type != mod_brush)
             continue;
     // see if the bounding box lets us trivially reject, also sets
     // trivial accept status
         RotatedBBox (currentmodel->mins, currentmodel->maxs,
             currententity->angles, mins, maxs);
         VectorAdd (mins, currententity->origin, minmaxs);
         VectorAdd (maxs, currententity->origin, (minmaxs+3));
  
         clipflags = R_BmodelCheckBBox (minmaxs);
         if (clipflags == BMODEL_FULLY_CLIPPED)
             continue;   // off the edge of the screen
  
         topnode = R_FindTopnode (minmaxs, minmaxs+3);
         if (!topnode)
             continue;   // no part in a visible leaf
  
         VectorCopy (currententity->origin, r_entorigin);
         VectorSubtract (r_origin, r_entorigin, modelorg);
  
         r_pcurrentvertbase = currentmodel->vertexes;
  
     // FIXME: stop transforming twice
         R_RotateBmodel ();
  
     // calculate dynamic lighting for bmodel
         R_PushDlights (currentmodel);
  
         if (topnode->contents == CONTENTS_NODE)
         {
         // not a leaf; has to be clipped to the world BSP
             r_clipflags = clipflags;
             R_DrawSolidClippedSubmodelPolygons (currentmodel, topnode);
         }
         else
         {
         // falls entirely in one leaf, so we just put all the
         // edges in the edge list and let 1/z sorting handle
         // drawing order
             R_DrawSubmodelPolygons (currentmodel, clipflags, topnode);
         }
  
     // put back world rotation and frustum clipping     
     // FIXME: R_RotateBmodel should just work off base_vxx
         VectorCopy (base_vpn, vpn);
         VectorCopy (base_vup, vup);
         VectorCopy (base_vright, vright);
         VectorCopy (oldorigin, modelorg);
         R_TransformFrustum ();
     }
  
     insubmodel = false;
 }

Referenced by R_EdgeDrawing().

◆ R_DrawEntitiesOnList()

void R_DrawEntitiesOnList ( void )

Definition at line 513 of file r_main.c.

 {
     int         i;
     qboolean    translucent_entities = false;
  
     if (!r_drawentities->value)
         return;
  
     // all bmodels have already been drawn by the edge list
     for (i=0 ; i<r_newrefdef.num_entities ; i++)
     {
         currententity = &r_newrefdef.entities[i];
  
         if ( currententity->flags & RF_TRANSLUCENT )
         {
             translucent_entities = true;
             continue;
         }
  
         if ( currententity->flags & RF_BEAM )
         {
             modelorg[0] = -r_origin[0];
             modelorg[1] = -r_origin[1];
             modelorg[2] = -r_origin[2];
             VectorCopy( vec3_origin, r_entorigin );
             R_DrawBeam( currententity );
         }
         else
         {
             currentmodel = currententity->model;
             if (!currentmodel)
             {
                 R_DrawNullModel();
                 continue;
             }
             VectorCopy (currententity->origin, r_entorigin);
             VectorSubtract (r_origin, r_entorigin, modelorg);
  
             switch (currentmodel->type)
             {
             case mod_sprite:
                 R_DrawSprite ();
                 break;
  
             case mod_alias:
                 R_AliasDrawModel ();
                 break;
  
             default:
                 break;
             }
         }
     }
  
     if ( !translucent_entities )
         return;
  
     for (i=0 ; i<r_newrefdef.num_entities ; i++)
     {
         currententity = &r_newrefdef.entities[i];
  
         if ( !( currententity->flags & RF_TRANSLUCENT ) )
             continue;
  
         if ( currententity->flags & RF_BEAM )
         {
             modelorg[0] = -r_origin[0];
             modelorg[1] = -r_origin[1];
             modelorg[2] = -r_origin[2];
             VectorCopy( vec3_origin, r_entorigin );
             R_DrawBeam( currententity );
         }
         else
         {
             currentmodel = currententity->model;
             if (!currentmodel)
             {
                 R_DrawNullModel();
                 continue;
             }
             VectorCopy (currententity->origin, r_entorigin);
             VectorSubtract (r_origin, r_entorigin, modelorg);
  
             switch (currentmodel->type)
             {
             case mod_sprite:
                 R_DrawSprite ();
                 break;
  
             case mod_alias:
                 R_AliasDrawModel ();
                 break;
  
             default:
                 break;
             }
         }
     }
 }

Referenced by R_RenderFrame().

◆ R_DrawNullModel()

void R_DrawNullModel ( void )

Definition at line 504 of file r_main.c.

505 {

506 }

Referenced by R_DrawEntitiesOnList().

◆ R_EdgeDrawing()

void R_EdgeDrawing ( void )

Definition at line 853 of file r_main.c.

 {
     edge_t  ledges[NUMSTACKEDGES +
                 ((CACHE_SIZE - 1) / sizeof(edge_t)) + 1];
     surf_t  lsurfs[NUMSTACKSURFACES +
                 ((CACHE_SIZE - 1) / sizeof(surf_t)) + 1];
  
     if ( r_newrefdef.rdflags & RDF_NOWORLDMODEL )
         return;
  
     if (auxedges)
     {
         r_edges = auxedges;
     }
     else
     {
         r_edges =  (edge_t *)
                 (((long)&ledges[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
     }
  
     if (r_surfsonstack)
     {
         surfaces =  (surf_t *)
                 (((long)&lsurfs[0] + CACHE_SIZE - 1) & ~(CACHE_SIZE - 1));
         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_SurfacePatch ();
     }
  
     R_BeginEdgeFrame ();
  
     if (r_dspeeds->value)
     {
         rw_time1 = Sys_Milliseconds ();
     }
  
     R_RenderWorld ();
  
     if (r_dspeeds->value)
     {
         rw_time2 = Sys_Milliseconds ();
         db_time1 = rw_time2;
     }
  
     R_DrawBEntitiesOnList ();
  
     if (r_dspeeds->value)
     {
         db_time2 = Sys_Milliseconds ();
         se_time1 = db_time2;
     }
  
     R_ScanEdges ();
 }

Referenced by R_RenderFrame().

◆ R_FindTopnode()

mnode_t* R_FindTopnode	(	vec3_t	mins,
		vec3_t	maxs
	)

Definition at line 667 of file r_main.c.

 {
     mplane_t    *splitplane;
     int         sides;
     mnode_t *node;
  
     node = r_worldmodel->nodes;
  
     while (1)
     {
         if (node->visframe != r_visframecount)
             return NULL;        // not visible at all
         
         if (node->contents != CONTENTS_NODE)
         {
             if (node->contents != CONTENTS_SOLID)
                 return  node; // we've reached a non-solid leaf, so it's
                             //  visible and not BSP clipped
             return NULL;    // in solid, so not visible
         }
         
         splitplane = node->plane;
         sides = BOX_ON_PLANE_SIDE(mins, maxs, (cplane_t *)splitplane);
         
         if (sides == 3)
             return node;    // this is the splitter
         
     // not split yet; recurse down the contacted side
         if (sides & 1)
             node = node->children[0];
         else
             node = node->children[1];
     }
 }

Referenced by R_DrawBEntitiesOnList().

◆ R_GammaCorrectAndSetPalette()

void R_GammaCorrectAndSetPalette ( const unsigned char * palette )

Definition at line 1160 of file r_main.c.

 {
     int i;
  
     for ( i = 0; i < 256; i++ )
     {
         sw_state.currentpalette[i*4+0] = sw_state.gammatable[palette[i*4+0]];
         sw_state.currentpalette[i*4+1] = sw_state.gammatable[palette[i*4+1]];
         sw_state.currentpalette[i*4+2] = sw_state.gammatable[palette[i*4+2]];
     }
  
     SWimp_SetPalette( sw_state.currentpalette );
 }

Referenced by R_BeginFrame(), R_CalcPalette(), R_CinematicSetPalette(), R_InitGraphics(), and SWimp_SetMode().

◆ R_ImageList_f()

void R_ImageList_f ( void )

Definition at line 34 of file r_image.c.

 {
     int     i;
     image_t *image;
     int     texels;
  
     ri.Con_Printf (PRINT_ALL, "------------------\n");
     texels = 0;
  
     for (i=0, image=r_images ; i<numr_images ; i++, image++)
     {
         if (image->registration_sequence <= 0)
             continue;
         texels += image->width*image->height;
         switch (image->type)
         {
         case it_skin:
             ri.Con_Printf (PRINT_ALL, "M");
             break;
         case it_sprite:
             ri.Con_Printf (PRINT_ALL, "S");
             break;
         case it_wall:
             ri.Con_Printf (PRINT_ALL, "W");
             break;
         case it_pic:
             ri.Con_Printf (PRINT_ALL, "P");
             break;
         default:
             ri.Con_Printf (PRINT_ALL, " ");
             break;
         }
  
         ri.Con_Printf (PRINT_ALL,  " %3i %3i : %s\n",
             image->width, image->height, image->name);
     }
     ri.Con_Printf (PRINT_ALL, "Total texel count: %i\n", texels);
 }

Referenced by R_Register().

◆ R_Init()

int R_Init	(	void *	hInstance,
		void *	wndProc
	)

Definition at line 300 of file r_main.c.

 {
     R_InitImages ();
     Mod_Init ();
     Draw_InitLocal ();
     R_InitTextures ();
  
     R_InitTurb ();
  
     view_clipplanes[0].leftedge = true;
     view_clipplanes[1].rightedge = true;
     view_clipplanes[1].leftedge = view_clipplanes[2].leftedge =
             view_clipplanes[3].leftedge = false;
     view_clipplanes[0].rightedge = view_clipplanes[2].rightedge =
             view_clipplanes[3].rightedge = false;
  
     r_refdef.xOrigin = XCENTERING;
     r_refdef.yOrigin = YCENTERING;
  
 // TODO: collect 386-specific code in one place
 #if id386
     Sys_MakeCodeWriteable ((long)R_EdgeCodeStart,
                          (long)R_EdgeCodeEnd - (long)R_EdgeCodeStart);
     Sys_SetFPCW ();     // get bit masks for FPCW   (FIXME: is this id386?)
 #endif  // id386
  
     r_aliasuvscale = 1.0;
  
     R_Register ();
     Draw_GetPalette ();
     if (SWimp_Init( hInstance, wndProc ) == false)
         return -1;
  
     // create the window
     R_BeginFrame( 0 );
  
     ri.Con_Printf (PRINT_ALL, "ref_soft version: "REF_VERSION"\n");
  
     return true;
 }

Referenced by GetRefAPI().

◆ R_InitGraphics()

void R_InitGraphics	(	int	width,
		int	height
	)

Definition at line 1066 of file r_main.c.

 {
     vid.width  = width;
     vid.height = height;
  
     // free z buffer
     if ( d_pzbuffer )
     {
         free( d_pzbuffer );
         d_pzbuffer = NULL;
     }
  
     // free surface cache
     if ( sc_base )
     {
         D_FlushCaches ();
         free( sc_base );
         sc_base = NULL;
     }
  
     d_pzbuffer = malloc(vid.width*vid.height*2);
  
     R_InitCaches ();
  
     R_GammaCorrectAndSetPalette( ( const unsigned char *) d_8to24table );
 }

Referenced by R_BeginFrame().

◆ R_InitTextures()

void R_InitTextures ( void )

Definition at line 196 of file r_main.c.

 {
     int     x,y, m;
     byte    *dest;
     
 // create a simple checkerboard texture for the default
     r_notexture_mip = (image_t *)&r_notexture_buffer;
     
     r_notexture_mip->width = r_notexture_mip->height = 16;
     r_notexture_mip->pixels[0] = &r_notexture_buffer[sizeof(image_t)];
     r_notexture_mip->pixels[1] = r_notexture_mip->pixels[0] + 16*16;
     r_notexture_mip->pixels[2] = r_notexture_mip->pixels[1] + 8*8;
     r_notexture_mip->pixels[3] = r_notexture_mip->pixels[2] + 4*4;
     
     for (m=0 ; m<4 ; m++)
     {
         dest = r_notexture_mip->pixels[m];
         for (y=0 ; y< (16>>m) ; y++)
             for (x=0 ; x< (16>>m) ; x++)
             {
                 if (  (y< (8>>m) ) ^ (x< (8>>m) ) )
  
                     *dest++ = 0;
                 else
                     *dest++ = 0xff;
             }
     }   
 }

Referenced by R_Init().

◆ R_InitTurb()

void R_InitTurb ( void )

Definition at line 231 of file r_main.c.

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

Referenced by R_Init().

◆ R_MarkLeaves()

void R_MarkLeaves ( void )

Definition at line 432 of file r_main.c.

 {
     byte    *vis;
     mnode_t *node;
     int     i;
     mleaf_t *leaf;
     int     cluster;
  
     if (r_oldviewcluster == r_viewcluster && !r_novis->value && r_viewcluster != -1)
         return;
     
     // development aid to let you run around and see exactly where
     // the pvs ends
     if (sw_lockpvs->value)
         return;
  
     r_visframecount++;
     r_oldviewcluster = r_viewcluster;
  
     if (r_novis->value || r_viewcluster == -1 || !r_worldmodel->vis)
     {
         // mark everything
         for (i=0 ; i<r_worldmodel->numleafs ; i++)
             r_worldmodel->leafs[i].visframe = r_visframecount;
         for (i=0 ; i<r_worldmodel->numnodes ; i++)
             r_worldmodel->nodes[i].visframe = r_visframecount;
         return;
     }
  
     vis = Mod_ClusterPVS (r_viewcluster, r_worldmodel);
     
     for (i=0,leaf=r_worldmodel->leafs ; i<r_worldmodel->numleafs ; i++, leaf++)
     {
         cluster = leaf->cluster;
         if (cluster == -1)
             continue;
         if (vis[cluster>>3] & (1<<(cluster&7)))
         {
             node = (mnode_t *)leaf;
             do
             {
                 if (node->visframe == r_visframecount)
                     break;
                 node->visframe = r_visframecount;
                 node = node->parent;
             } while (node);
         }
     }
  
 #if 0
     for (i=0 ; i<r_worldmodel->vis->numclusters ; i++)
     {
         if (vis[i>>3] & (1<<(i&7)))
         {
             node = (mnode_t *)&r_worldmodel->leafs[i];  // FIXME: cluster
             do
             {
                 if (node->visframe == r_visframecount)
                     break;
                 node->visframe = r_visframecount;
                 node = node->parent;
             } while (node);
         }
     }
 #endif
 }

Referenced by R_RenderFrame(), and R_RenderView().

◆ R_NewMap()

void R_NewMap ( void )

Definition at line 380 of file r_main.c.

 {
     r_viewcluster = -1;
  
     r_cnumsurfs = sw_maxsurfs->value;
  
     if (r_cnumsurfs <= MINSURFACES)
         r_cnumsurfs = MINSURFACES;
  
     if (r_cnumsurfs > NUMSTACKSURFACES)
     {
         surfaces = malloc (r_cnumsurfs * sizeof(surf_t));
         surface_p = surfaces;
         surf_max = &surfaces[r_cnumsurfs];
         r_surfsonstack = false;
     // 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_SurfacePatch ();
     }
     else
     {
         r_surfsonstack = true;
     }
  
     r_maxedgesseen = 0;
     r_maxsurfsseen = 0;
  
     r_numallocatededges = sw_maxedges->value;
  
     if (r_numallocatededges < MINEDGES)
         r_numallocatededges = MINEDGES;
  
     if (r_numallocatededges <= NUMSTACKEDGES)
     {
         auxedges = NULL;
     }
     else
     {
         auxedges = malloc (r_numallocatededges * sizeof(edge_t));
     }
 }

Referenced by R_BeginRegistration().

◆ R_Register()

void R_Register ( void )

Definition at line 245 of file r_main.c.

 {
     sw_aliasstats = ri.Cvar_Get ("sw_polymodelstats", "0", 0);
     sw_allow_modex = ri.Cvar_Get( "sw_allow_modex", "1", CVAR_ARCHIVE );
     sw_clearcolor = ri.Cvar_Get ("sw_clearcolor", "2", 0);
     sw_drawflat = ri.Cvar_Get ("sw_drawflat", "0", 0);
     sw_draworder = ri.Cvar_Get ("sw_draworder", "0", 0);
     sw_maxedges = ri.Cvar_Get ("sw_maxedges", STRINGER(MAXSTACKSURFACES), 0);
     sw_maxsurfs = ri.Cvar_Get ("sw_maxsurfs", "0", 0);
     sw_mipcap = ri.Cvar_Get ("sw_mipcap", "0", 0);
     sw_mipscale = ri.Cvar_Get ("sw_mipscale", "1", 0);
     sw_reportedgeout = ri.Cvar_Get ("sw_reportedgeout", "0", 0);
     sw_reportsurfout = ri.Cvar_Get ("sw_reportsurfout", "0", 0);
     sw_stipplealpha = ri.Cvar_Get( "sw_stipplealpha", "0", CVAR_ARCHIVE );
     sw_surfcacheoverride = ri.Cvar_Get ("sw_surfcacheoverride", "0", 0);
     sw_waterwarp = ri.Cvar_Get ("sw_waterwarp", "1", 0);
     sw_mode = ri.Cvar_Get( "sw_mode", "0", CVAR_ARCHIVE );
  
     r_lefthand = ri.Cvar_Get( "hand", "0", CVAR_USERINFO | CVAR_ARCHIVE );
     r_speeds = ri.Cvar_Get ("r_speeds", "0", 0);
     r_fullbright = ri.Cvar_Get ("r_fullbright", "0", 0);
     r_drawentities = ri.Cvar_Get ("r_drawentities", "1", 0);
     r_drawworld = ri.Cvar_Get ("r_drawworld", "1", 0);
     r_dspeeds = ri.Cvar_Get ("r_dspeeds", "0", 0);
     r_lightlevel = ri.Cvar_Get ("r_lightlevel", "0", 0);
     r_lerpmodels = ri.Cvar_Get( "r_lerpmodels", "1", 0 );
     r_novis = ri.Cvar_Get( "r_novis", "0", 0 );
  
     vid_fullscreen = ri.Cvar_Get( "vid_fullscreen", "0", CVAR_ARCHIVE );
     vid_gamma = ri.Cvar_Get( "vid_gamma", "1.0", CVAR_ARCHIVE );
  
     ri.Cmd_AddCommand ("modellist", Mod_Modellist_f);
     ri.Cmd_AddCommand( "screenshot", R_ScreenShot_f );
     ri.Cmd_AddCommand( "imagelist", R_ImageList_f );
  
     sw_mode->modified = true; // force us to do mode specific stuff later
     vid_gamma->modified = true; // force us to rebuild the gamma table later
  
 //PGM
     sw_lockpvs = ri.Cvar_Get ("sw_lockpvs", "0", 0);
 //PGM
 }

Referenced by R_Init().

◆ R_RegisterSkin()

struct image_s* R_RegisterSkin ( char * name )

Definition at line 564 of file r_image.c.

 {
     return R_FindImage (name, it_skin);
 }

Referenced by GetRefAPI().

◆ R_RenderFrame()

void R_RenderFrame ( refdef_t * fd )

Definition at line 992 of file r_main.c.

 {
     r_newrefdef = *fd;
  
     if (!r_worldmodel && !( r_newrefdef.rdflags & RDF_NOWORLDMODEL ) )
         ri.Sys_Error (ERR_FATAL,"R_RenderView: NULL worldmodel");
  
     VectorCopy (fd->vieworg, r_refdef.vieworg);
     VectorCopy (fd->viewangles, r_refdef.viewangles);
  
     if (r_speeds->value || r_dspeeds->value)
         r_time1 = Sys_Milliseconds ();
  
     R_SetupFrame ();
  
     R_MarkLeaves ();    // done here so we know if we're in water
  
     R_PushDlights (r_worldmodel);
  
     R_EdgeDrawing ();
  
     if (r_dspeeds->value)
     {
         se_time2 = Sys_Milliseconds ();
         de_time1 = se_time2;
     }
  
     R_DrawEntitiesOnList ();
  
     if (r_dspeeds->value)
     {
         de_time2 = Sys_Milliseconds ();
         dp_time1 = Sys_Milliseconds ();
     }
  
     R_DrawParticles ();
  
     if (r_dspeeds->value)
         dp_time2 = Sys_Milliseconds ();
  
     R_DrawAlphaSurfaces();
  
     R_SetLightLevel ();
  
     if (r_dowarp)
         D_WarpScreen ();
  
     if (r_dspeeds->value)
         da_time1 = Sys_Milliseconds ();
  
     if (r_dspeeds->value)
         da_time2 = Sys_Milliseconds ();
  
     R_CalcPalette ();
  
     if (sw_aliasstats->value)
         R_PrintAliasStats ();
         
     if (r_speeds->value)
         R_PrintTimes ();
  
     if (r_dspeeds->value)
         R_PrintDSpeeds ();
  
     if (sw_reportsurfout->value && r_outofsurfaces)
         ri.Con_Printf (PRINT_ALL,"Short %d surfaces\n", r_outofsurfaces);
  
     if (sw_reportedgeout->value && r_outofedges)
         ri.Con_Printf (PRINT_ALL,"Short roughly %d edges\n", r_outofedges * 2 / 3);
 }

Referenced by GetRefAPI().

◆ R_SetLightLevel()

void R_SetLightLevel ( void )

Definition at line 970 of file r_main.c.

 {
     vec3_t      light;
  
     if ((r_newrefdef.rdflags & RDF_NOWORLDMODEL) || (!r_drawentities->value) || (!currententity))
     {
         r_lightlevel->value = 150.0;
         return;
     }
  
     // save off light value for server to look at (BIG HACK!)
     R_LightPoint (r_newrefdef.vieworg, light);
     r_lightlevel->value = 150.0 * light[0];
 }

Referenced by R_RenderFrame().

◆ R_SetSky()

void R_SetSky	(	char *	name,
		float	rotate,
		vec3_t	axis
	)

Definition at line 1304 of file r_main.c.

 {
     int     i;
     char    pathname[MAX_QPATH];
  
     strncpy (skyname, name, sizeof(skyname)-1);
     skyrotate = rotate;
     VectorCopy (axis, skyaxis);
  
     for (i=0 ; i<6 ; i++)
     {
         Com_sprintf (pathname, sizeof(pathname), "env/%s%s.pcx", skyname, suf[r_skysideimage[i]]);
         r_skytexinfo[i].image = R_FindImage (pathname, it_sky);
     }
 }

Referenced by GetRefAPI().

◆ R_Shutdown()

void R_Shutdown ( void )

Definition at line 346 of file r_main.c.

 {
     // free z buffer
     if (d_pzbuffer)
     {
         free (d_pzbuffer);
         d_pzbuffer = NULL;
     }
     // free surface cache
     if (sc_base)
     {
         D_FlushCaches ();
         free (sc_base);
         sc_base = NULL;
     }
  
     // free colormap
     if (vid.colormap)
     {
         free (vid.colormap);
         vid.colormap = NULL;
     }
     R_UnRegister ();
     Mod_FreeAll ();
     R_ShutdownImages ();
  
     SWimp_Shutdown();
 }

Referenced by GetRefAPI().

◆ R_UnRegister()

void R_UnRegister ( void )

Definition at line 288 of file r_main.c.

 {
     ri.Cmd_RemoveCommand( "screenshot" );
     ri.Cmd_RemoveCommand ("modellist");
     ri.Cmd_RemoveCommand( "imagelist" );
 }

Referenced by R_Shutdown().

◆ RotatedBBox()

void RotatedBBox	(	vec3_t	mins,
		vec3_t	maxs,
		vec3_t	angles,
		vec3_t	tmins,
		vec3_t	tmaxs
	)

Definition at line 710 of file r_main.c.

 {
     vec3_t  tmp, v;
     int     i, j;
     vec3_t  forward, right, up;
  
     if (!angles[0] && !angles[1] && !angles[2])
     {
         VectorCopy (mins, tmins);
         VectorCopy (maxs, tmaxs);
         return;
     }
  
     for (i=0 ; i<3 ; i++)
     {
         tmins[i] = 99999;
         tmaxs[i] = -99999;
     }
  
     AngleVectors (angles, forward, right, up);
  
     for ( i = 0; i < 8; i++ )
     {
         if ( i & 1 )
             tmp[0] = mins[0];
         else
             tmp[0] = maxs[0];
  
         if ( i & 2 )
             tmp[1] = mins[1];
         else
             tmp[1] = maxs[1];
  
         if ( i & 4 )
             tmp[2] = mins[2];
         else
             tmp[2] = maxs[2];
  
  
         VectorScale (forward, tmp[0], v);
         VectorMA (v, -tmp[1], right, v);
         VectorMA (v, tmp[2], up, v);
  
         for (j=0 ; j<3 ; j++)
         {
             if (v[j] < tmins[j])
                 tmins[j] = v[j];
             if (v[j] > tmaxs[j])
                 tmaxs[j] = v[j];
         }
     }
 }

Referenced by R_DrawBEntitiesOnList().

◆ Sys_Error()

void Sys_Error	(	char *	error,
			...
	)

Definition at line 1411 of file r_main.c.

 {
     va_list     argptr;
     char        text[1024];
  
     va_start (argptr, error);
     vsprintf (text, error, argptr);
     va_end (argptr);
  
     ri.Sys_Error (ERR_FATAL, "%s", text);
 }