tr_main.c File Reference

#include "tr_local.h"

Include dependency graph for tr_main.c:

Go to the source code of this file.

Defines
#define	CUTOFF   8
#define	SWAP_DRAW_SURF(a, b)   temp=((int *)a)[0];((int *)a)[0]=((int *)b)[0];((int *)b)[0]=temp; temp=((int *)a)[1];((int *)a)[1]=((int *)b)[1];((int *)b)[1]=temp;
Functions
qboolean	IsMirror (const drawSurf_t *drawSurf, int entityNum)
void	myGlMultMatrix (const float *a, const float *b, float *out)
void	qsortFast (void *base, unsigned num, unsigned width)
void	R_AddDrawSurf (surfaceType_t *surface, shader_t *shader, int fogIndex, int dlightMap)
void	R_AddEntitySurfaces (void)
int	R_CullLocalBox (vec3_t bounds[2])
int	R_CullLocalPointAndRadius (vec3_t pt, float radius)
int	R_CullPointAndRadius (vec3_t pt, float radius)
void	R_DebugGraphics (void)
void	R_DebugPolygon (int color, int numPoints, float *points)
void	R_DecomposeSort (unsigned sort, int *entityNum, shader_t **shader, int *fogNum, int *dlightMap)
void	R_GenerateDrawSurfs (void)
qboolean	R_GetPortalOrientations (drawSurf_t *drawSurf, int entityNum, orientation_t *surface, orientation_t *camera, vec3_t pvsOrigin, qboolean *mirror)
void	R_LocalNormalToWorld (vec3_t local, vec3_t world)
void	R_LocalPointToWorld (vec3_t local, vec3_t world)
void	R_MirrorPoint (vec3_t in, orientation_t *surface, orientation_t *camera, vec3_t out)
void	R_MirrorVector (vec3_t in, orientation_t *surface, orientation_t *camera, vec3_t out)
qboolean	R_MirrorViewBySurface (drawSurf_t *drawSurf, int entityNum)
void	R_PlaneForSurface (surfaceType_t *surfType, cplane_t *plane)
void	R_RenderView (viewParms_t *parms)
void	R_RotateForEntity (const trRefEntity_t *ent, const viewParms_t *viewParms, orientationr_t *or)
void	R_RotateForViewer (void)
void	R_SetupFrustum (void)
void	R_SetupProjection (void)
void	R_SortDrawSurfs (drawSurf_t *drawSurfs, int numDrawSurfs)
int	R_SpriteFogNum (trRefEntity_t *ent)
void	R_TransformClipToWindow (const vec4_t clip, const viewParms_t *view, vec4_t normalized, vec4_t window)
void	R_TransformModelToClip (const vec3_t src, const float *modelMatrix, const float *projectionMatrix, vec4_t eye, vec4_t dst)
void	R_WorldToLocal (vec3_t world, vec3_t local)
void	SetFarClip (void)
void	shortsort (drawSurf_t *lo, drawSurf_t *hi)
qboolean	SurfIsOffscreen (const drawSurf_t *drawSurf, vec4_t clipDest[128])
Variables
surfaceType_t	entitySurface = SF_ENTITY
refimport_t	ri
float	s_flipMatrix [16]
trGlobals_t	tr

---

Define Documentation

#define CUTOFF   8

Definition at line 1012 of file tr_main.c.

#define SWAP_DRAW_SURF (  a, b   )     temp=((int *)a)[0];((int *)a)[0]=((int *)b)[0];((int *)b)[0]=temp; temp=((int *)a)[1];((int *)a)[1]=((int *)b)[1];((int *)b)[1]=temp;

Definition at line 1006 of file tr_main.c. Referenced by qsortFast(), and shortsort().

---

Function Documentation

qboolean IsMirror (  const drawSurf_t *  drawSurf, int  entityNum )  [static]

Definition at line 739 of file tr_main.c. References cplane_t, trGlobals_t::currentEntity, trGlobals_t::currentEntityNum, d, cplane_s::dist, DotProduct, drawSurf_t, trRefEntity_t::e, e, trRefdef_t::entities, i, cplane_s::normal, trRefdef_t::num_entities, refEntity_t::oldorigin, trGlobals_t::or, refEntity_t::origin, orientationr_t::origin, qboolean, R_LocalNormalToWorld(), R_PlaneForSurface(), R_RotateForEntity(), trGlobals_t::refdef, refEntity_t::reType, drawSurf_s::surface, tr, and trGlobals_t::viewParms. Referenced by SurfIsOffscreen(). { int i; cplane_t originalPlane, plane; trRefEntity_t *e; float d; // create plane axis for the portal we are seeing R_PlaneForSurface( drawSurf->surface, &originalPlane ); // rotate the plane if necessary if ( entityNum != ENTITYNUM_WORLD ) { tr.currentEntityNum = entityNum; tr.currentEntity = &tr.refdef.entities[entityNum]; // get the orientation of the entity R_RotateForEntity( tr.currentEntity, &tr.viewParms, &tr.or ); // rotate the plane, but keep the non-rotated version for matching // against the portalSurface entities R_LocalNormalToWorld( originalPlane.normal, plane.normal ); plane.dist = originalPlane.dist + DotProduct( plane.normal, tr.or.origin ); // translate the original plane originalPlane.dist = originalPlane.dist + DotProduct( originalPlane.normal, tr.or.origin ); } else { plane = originalPlane; } // locate the portal entity closest to this plane. // origin will be the origin of the portal, origin2 will be // the origin of the camera for ( i = 0 ; i < tr.refdef.num_entities ; i++ ) { e = &tr.refdef.entities[i]; if ( e->e.reType != RT_PORTALSURFACE ) { continue; } d = DotProduct( e->e.origin, originalPlane.normal ) - originalPlane.dist; if ( d > 64 || d < -64) { continue; } // if the entity is just a mirror, don't use as a camera point if ( e->e.oldorigin[0] == e->e.origin[0] && e->e.oldorigin[1] == e->e.origin[1] && e->e.oldorigin[2] == e->e.origin[2] ) { return qtrue; } return qfalse; } return qfalse; }

Here is the call graph for this function:

void myGlMultMatrix (  const float *  a, const float *  b, float *  out )

Definition at line 247 of file tr_main.c. References a, b, i, and j. Referenced by R_RotateForEntity(), and R_RotateForViewer(). { int i, j; for ( i = 0 ; i < 4 ; i++ ) { for ( j = 0 ; j < 4 ; j++ ) { out[ i * 4 + j ] = a [ i * 4 + 0 ] * b [ 0 * 4 + j ] + a [ i * 4 + 1 ] * b [ 1 * 4 + j ] + a [ i * 4 + 2 ] * b [ 2 * 4 + j ] + a [ i * 4 + 3 ] * b [ 3 * 4 + j ]; } } }

void qsortFast (  void *  base, unsigned  num, unsigned  width )

Definition at line 1035 of file tr_main.c. References drawSurf_t, ERR_DROP, ri, shortsort(), SWAP_DRAW_SURF, and width. Referenced by R_SortDrawSurfs(). { char *lo, *hi; /* ends of sub-array currently sorting */ char *mid; /* points to middle of subarray */ char *loguy, *higuy; /* traveling pointers for partition step */ unsigned size; /* size of the sub-array */ char *lostk[30], *histk[30]; int stkptr; /* stack for saving sub-array to be processed */ int temp; if ( sizeof(drawSurf_t) != 8 ) { ri.Error( ERR_DROP, "change SWAP_DRAW_SURF macro" ); } /* Note: the number of stack entries required is no more than 1 + log2(size), so 30 is sufficient for any array */ if (num < 2 || width == 0) return; /* nothing to do */ stkptr = 0; /* initialize stack */ lo = base; hi = (char *)base + width * (num-1); /* initialize limits */ /* this entry point is for pseudo-recursion calling: setting lo and hi and jumping to here is like recursion, but stkptr is prserved, locals aren't, so we preserve stuff on the stack */ recurse: size = (hi - lo) / width + 1; /* number of el's to sort */ /* below a certain size, it is faster to use a O(n^2) sorting method */ if (size <= CUTOFF) { shortsort((drawSurf_t *)lo, (drawSurf_t *)hi); } else { /* First we pick a partititioning element. The efficiency of the algorithm demands that we find one that is approximately the median of the values, but also that we select one fast. Using the first one produces bad performace if the array is already sorted, so we use the middle one, which would require a very wierdly arranged array for worst case performance. Testing shows that a median-of-three algorithm does not, in general, increase performance. */ mid = lo + (size / 2) * width; /* find middle element */ SWAP_DRAW_SURF(mid, lo); /* swap it to beginning of array */ /* We now wish to partition the array into three pieces, one consisiting of elements <= partition element, one of elements equal to the parition element, and one of element >= to it. This is done below; comments indicate conditions established at every step. */ loguy = lo; higuy = hi + width; /* Note that higuy decreases and loguy increases on every iteration, so loop must terminate. */ for (;;) { /* lo <= loguy < hi, lo < higuy <= hi + 1, A[i] <= A[lo] for lo <= i <= loguy, A[i] >= A[lo] for higuy <= i <= hi */ do { loguy += width; } while (loguy <= hi && ( ((drawSurf_t *)loguy)->sort <= ((drawSurf_t *)lo)->sort ) ); /* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy, either loguy > hi or A[loguy] > A[lo] */ do { higuy -= width; } while (higuy > lo && ( ((drawSurf_t *)higuy)->sort >= ((drawSurf_t *)lo)->sort ) ); /* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi, either higuy <= lo or A[higuy] < A[lo] */ if (higuy < loguy) break; /* if loguy > hi or higuy <= lo, then we would have exited, so A[loguy] > A[lo], A[higuy] < A[lo], loguy < hi, highy > lo */ SWAP_DRAW_SURF(loguy, higuy); /* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top of loop is re-established */ } /* A[i] >= A[lo] for higuy < i <= hi, A[i] <= A[lo] for lo <= i < loguy, higuy < loguy, lo <= higuy <= hi implying: A[i] >= A[lo] for loguy <= i <= hi, A[i] <= A[lo] for lo <= i <= higuy, A[i] = A[lo] for higuy < i < loguy */ SWAP_DRAW_SURF(lo, higuy); /* put partition element in place */ /* OK, now we have the following: A[i] >= A[higuy] for loguy <= i <= hi, A[i] <= A[higuy] for lo <= i < higuy A[i] = A[lo] for higuy <= i < loguy */ /* We've finished the partition, now we want to sort the subarrays [lo, higuy-1] and [loguy, hi]. We do the smaller one first to minimize stack usage. We only sort arrays of length 2 or more.*/ if ( higuy - 1 - lo >= hi - loguy ) { if (lo + width < higuy) { lostk[stkptr] = lo; histk[stkptr] = higuy - width; ++stkptr; } /* save big recursion for later */ if (loguy < hi) { lo = loguy; goto recurse; /* do small recursion */ } } else { if (loguy < hi) { lostk[stkptr] = loguy; histk[stkptr] = hi; ++stkptr; /* save big recursion for later */ } if (lo + width < higuy) { hi = higuy - width; goto recurse; /* do small recursion */ } } } /* We have sorted the array, except for any pending sorts on the stack. Check if there are any, and do them. */ --stkptr; if (stkptr >= 0) { lo = lostk[stkptr]; hi = histk[stkptr]; goto recurse; /* pop subarray from stack */ } else return; /* all subarrays done */ }

Here is the call graph for this function:

void R_AddDrawSurf (  surfaceType_t *  surface, shader_t *  shader, int  fogIndex, int  dlightMap )

Definition at line 1200 of file tr_main.c. References trRefdef_t::drawSurfs, trRefdef_t::numDrawSurfs, trGlobals_t::refdef, shader_t, trGlobals_t::shiftedEntityNum, drawSurf_s::sort, shader_s::sortedIndex, drawSurf_s::surface, and tr. Referenced by R_AddAnimSurfaces(), R_AddEntitySurfaces(), R_AddMD3Surfaces(), R_AddPolygonSurfaces(), and R_AddWorldSurface(). { int index; // instead of checking for overflow, we just mask the index // so it wraps around index = tr.refdef.numDrawSurfs & DRAWSURF_MASK; // the sort data is packed into a single 32 bit value so it can be // compared quickly during the qsorting process tr.refdef.drawSurfs[index].sort = (shader->sortedIndex << QSORT_SHADERNUM_SHIFT) | tr.shiftedEntityNum | ( fogIndex << QSORT_FOGNUM_SHIFT ) | (int)dlightMap; tr.refdef.drawSurfs[index].surface = surface; tr.refdef.numDrawSurfs++; }

void R_AddEntitySurfaces (  void   )

Definition at line 1289 of file tr_main.c. References trGlobals_t::currentEntity, trGlobals_t::currentEntityNum, trGlobals_t::currentModel, refEntity_t::customShader, trGlobals_t::defaultShader, trRefEntity_t::e, trRefdef_t::entities, entitySurface, ERR_DROP, refEntity_t::hModel, cvar_s::integer, viewParms_t::isPortal, MOD_BAD, MOD_BRUSH, MOD_MD4, MOD_MESH, trRefEntity_t::needDlights, trRefdef_t::num_entities, trGlobals_t::or, R_AddAnimSurfaces(), R_AddBrushModelSurfaces(), R_AddDrawSurf(), R_AddMD3Surfaces(), r_drawentities, R_GetModelByHandle(), R_GetShaderByHandle(), R_RotateForEntity(), R_SpriteFogNum(), trGlobals_t::refdef, refEntity_t::renderfx, refEntity_t::reType, ri, RT_BEAM, RT_LIGHTNING, RT_MODEL, RT_PORTALSURFACE, RT_RAIL_CORE, RT_RAIL_RINGS, RT_SPRITE, shader_t, trGlobals_t::shiftedEntityNum, tr, model_s::type, and trGlobals_t::viewParms. Referenced by R_GenerateDrawSurfs(). { trRefEntity_t *ent; shader_t *shader; if ( !r_drawentities->integer ) { return; } for ( tr.currentEntityNum = 0; tr.currentEntityNum < tr.refdef.num_entities; tr.currentEntityNum++ ) { ent = tr.currentEntity = &tr.refdef.entities[tr.currentEntityNum]; ent->needDlights = qfalse; // preshift the value we are going to OR into the drawsurf sort tr.shiftedEntityNum = tr.currentEntityNum << QSORT_ENTITYNUM_SHIFT; // // the weapon model must be handled special -- // we don't want the hacked weapon position showing in // mirrors, because the true body position will already be drawn // if ( (ent->e.renderfx & RF_FIRST_PERSON) && tr.viewParms.isPortal) { continue; } // simple generated models, like sprites and beams, are not culled switch ( ent->e.reType ) { case RT_PORTALSURFACE: break; // don't draw anything case RT_SPRITE: case RT_BEAM: case RT_LIGHTNING: case RT_RAIL_CORE: case RT_RAIL_RINGS: // self blood sprites, talk balloons, etc should not be drawn in the primary // view. We can't just do this check for all entities, because md3 // entities may still want to cast shadows from them if ( (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal) { continue; } shader = R_GetShaderByHandle( ent->e.customShader ); R_AddDrawSurf( &entitySurface, shader, R_SpriteFogNum( ent ), 0 ); break; case RT_MODEL: // we must set up parts of tr.or for model culling R_RotateForEntity( ent, &tr.viewParms, &tr.or ); tr.currentModel = R_GetModelByHandle( ent->e.hModel ); if (!tr.currentModel) { R_AddDrawSurf( &entitySurface, tr.defaultShader, 0, 0 ); } else { switch ( tr.currentModel->type ) { case MOD_MESH: R_AddMD3Surfaces( ent ); break; case MOD_MD4: R_AddAnimSurfaces( ent ); break; case MOD_BRUSH: R_AddBrushModelSurfaces( ent ); break; case MOD_BAD: // null model axis if ( (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal) { break; } shader = R_GetShaderByHandle( ent->e.customShader ); R_AddDrawSurf( &entitySurface, tr.defaultShader, 0, 0 ); break; default: ri.Error( ERR_DROP, "R_AddEntitySurfaces: Bad modeltype" ); break; } } break; default: ri.Error( ERR_DROP, "R_AddEntitySurfaces: Bad reType" ); } } }

Here is the call graph for this function:

int R_CullLocalBox (  vec3_t  bounds[2]  )

Definition at line 51 of file tr_main.c. References orientationr_t::axis, cplane_t, cplane_s::dist, DotProduct, viewParms_t::frustum, i, cvar_s::integer, j, cplane_s::normal, trGlobals_t::or, orientationr_t::origin, r_nocull, tr, v, vec3_t, VectorCopy, VectorMA, and trGlobals_t::viewParms. Referenced by R_AddBrushModelSurfaces(), R_CullGrid(), R_CullModel(), and R_CullTriSurf(). { int i, j; vec3_t transformed[8]; float dists[8]; vec3_t v; cplane_t *frust; int anyBack; int front, back; if ( r_nocull->integer ) { return CULL_CLIP; } // transform into world space for (i = 0 ; i < 8 ; i++) { v[0] = bounds[i&1][0]; v[1] = bounds[(i>>1)&1][1]; v[2] = bounds[(i>>2)&1][2]; VectorCopy( tr.or.origin, transformed[i] ); VectorMA( transformed[i], v[0], tr.or.axis[0], transformed[i] ); VectorMA( transformed[i], v[1], tr.or.axis[1], transformed[i] ); VectorMA( transformed[i], v[2], tr.or.axis[2], transformed[i] ); } // check against frustum planes anyBack = 0; for (i = 0 ; i < 4 ; i++) { frust = &tr.viewParms.frustum[i]; front = back = 0; for (j = 0 ; j < 8 ; j++) { dists[j] = DotProduct(transformed[j], frust->normal); if ( dists[j] > frust->dist ) { front = 1; if ( back ) { break; // a point is in front } } else { back = 1; } } if ( !front ) { // all points were behind one of the planes return CULL_OUT; } anyBack |= back; } if ( !anyBack ) { return CULL_IN; // completely inside frustum } return CULL_CLIP; // partially clipped }

int R_CullLocalPointAndRadius (  vec3_t  pt, float  radius )

Definition at line 110 of file tr_main.c. References R_CullPointAndRadius(), R_LocalPointToWorld(), and vec3_t. Referenced by R_CullGrid(), and R_CullModel(). { vec3_t transformed; R_LocalPointToWorld( pt, transformed ); return R_CullPointAndRadius( transformed, radius ); }

Here is the call graph for this function:

int R_CullPointAndRadius (  vec3_t  pt, float  radius )

Definition at line 122 of file tr_main.c. References cplane_t, cplane_s::dist, DotProduct, viewParms_t::frustum, i, cvar_s::integer, cplane_s::normal, qboolean, r_nocull, tr, and trGlobals_t::viewParms. Referenced by R_CullGrid(), and R_CullLocalPointAndRadius(). { int i; float dist; cplane_t *frust; qboolean mightBeClipped = qfalse; if ( r_nocull->integer ) { return CULL_CLIP; } // check against frustum planes for (i = 0 ; i < 4 ; i++) { frust = &tr.viewParms.frustum[i]; dist = DotProduct( pt, frust->normal) - frust->dist; if ( dist < -radius ) { return CULL_OUT; } else if ( dist <= radius ) { mightBeClipped = qtrue; } } if ( mightBeClipped ) { return CULL_CLIP; } return CULL_IN; // completely inside frustum }

void R_DebugGraphics (  void   )

Definition at line 1432 of file tr_main.c. References refimport_t::CM_DrawDebugSurface, CT_FRONT_SIDED, GL_Bind(), GL_Cull(), cvar_s::integer, R_DebugPolygon(), r_debugSurface, R_SyncRenderThread(), ri, tr, and trGlobals_t::whiteImage. Referenced by R_RenderView(). { if ( !r_debugSurface->integer ) { return; } // the render thread can't make callbacks to the main thread R_SyncRenderThread(); GL_Bind( tr.whiteImage); GL_Cull( CT_FRONT_SIDED ); ri.CM_DrawDebugSurface( R_DebugPolygon ); }

Here is the call graph for this function:

void R_DebugPolygon (  int  color, int  numPoints, float *  points )

Definition at line 1399 of file tr_main.c. References GL_State(), GLS_DEPTHMASK_TRUE, GLS_DSTBLEND_ONE, GLS_POLYMODE_LINE, GLS_SRCBLEND_ONE, i, points, qglBegin, qglColor3f, qglDepthRange, qglEnd, and qglVertex3fv. Referenced by R_DebugGraphics(). { int i; GL_State( GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE ); // draw solid shade qglColor3f( color&1, (color>>1)&1, (color>>2)&1 ); qglBegin( GL_POLYGON ); for ( i = 0 ; i < numPoints ; i++ ) { qglVertex3fv( points + i * 3 ); } qglEnd(); // draw wireframe outline GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE | GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE ); qglDepthRange( 0, 0 ); qglColor3f( 1, 1, 1 ); qglBegin( GL_POLYGON ); for ( i = 0 ; i < numPoints ; i++ ) { qglVertex3fv( points + i * 3 ); } qglEnd(); qglDepthRange( 0, 1 ); }

Here is the call graph for this function:

void R_DecomposeSort (  unsigned  sort, int *  entityNum, shader_t **  shader, int *  fogNum, int *  dlightMap )

Definition at line 1220 of file tr_main.c. References MAX_SHADERS, shader_t, sort(), trGlobals_t::sortedShaders, and tr. Referenced by FixRenderCommandList(), R_SortDrawSurfs(), RB_RenderDrawSurfList(), and SurfIsOffscreen(). { *fogNum = ( sort >> QSORT_FOGNUM_SHIFT ) & 31; *shader = tr.sortedShaders[ ( sort >> QSORT_SHADERNUM_SHIFT ) & (MAX_SHADERS-1) ]; *entityNum = ( sort >> QSORT_ENTITYNUM_SHIFT ) & 1023; *dlightMap = sort & 3; }

Here is the call graph for this function:

void R_GenerateDrawSurfs (  void   )

Definition at line 1379 of file tr_main.c. References R_AddEntitySurfaces(), R_AddPolygonSurfaces(), R_AddWorldSurfaces(), and R_SetupProjection(). Referenced by R_RenderView(). { R_AddWorldSurfaces (); R_AddPolygonSurfaces(); // set the projection matrix with the minimum zfar // now that we have the world bounded // this needs to be done before entities are // added, because they use the projection // matrix for lod calculation R_SetupProjection (); R_AddEntitySurfaces (); }

Here is the call graph for this function:

qboolean R_GetPortalOrientations (  drawSurf_t *  drawSurf, int  entityNum, orientation_t *  surface, orientation_t *  camera, vec3_t  pvsOrigin, qboolean *  mirror )

Definition at line 620 of file tr_main.c. References refEntity_t::axis, orientation_t::axis, AxisCopy(), camera, cplane_t, CrossProduct(), trGlobals_t::currentEntity, trGlobals_t::currentEntityNum, d, cplane_s::dist, DotProduct, drawSurf_t, trRefEntity_t::e, e, trRefdef_t::entities, refEntity_t::frame, i, cplane_s::normal, trRefdef_t::num_entities, refEntity_t::oldframe, refEntity_t::oldorigin, trGlobals_t::or, orientation_t::origin, refEntity_t::origin, orientationr_t::origin, PerpendicularVector(), qboolean, R_LocalNormalToWorld(), R_PlaneForSurface(), R_RotateForEntity(), trGlobals_t::refdef, refEntity_t::reType, RotatePointAroundVector(), sin(), refEntity_t::skinNum, drawSurf_s::surface, trRefdef_t::time, tr, vec3_origin, vec3_t, VectorCopy, VectorMA, VectorScale, VectorSubtract, and trGlobals_t::viewParms. Referenced by R_MirrorViewBySurface(). { int i; cplane_t originalPlane, plane; trRefEntity_t *e; float d; vec3_t transformed; // create plane axis for the portal we are seeing R_PlaneForSurface( drawSurf->surface, &originalPlane ); // rotate the plane if necessary if ( entityNum != ENTITYNUM_WORLD ) { tr.currentEntityNum = entityNum; tr.currentEntity = &tr.refdef.entities[entityNum]; // get the orientation of the entity R_RotateForEntity( tr.currentEntity, &tr.viewParms, &tr.or ); // rotate the plane, but keep the non-rotated version for matching // against the portalSurface entities R_LocalNormalToWorld( originalPlane.normal, plane.normal ); plane.dist = originalPlane.dist + DotProduct( plane.normal, tr.or.origin ); // translate the original plane originalPlane.dist = originalPlane.dist + DotProduct( originalPlane.normal, tr.or.origin ); } else { plane = originalPlane; } VectorCopy( plane.normal, surface->axis[0] ); PerpendicularVector( surface->axis[1], surface->axis[0] ); CrossProduct( surface->axis[0], surface->axis[1], surface->axis[2] ); // locate the portal entity closest to this plane. // origin will be the origin of the portal, origin2 will be // the origin of the camera for ( i = 0 ; i < tr.refdef.num_entities ; i++ ) { e = &tr.refdef.entities[i]; if ( e->e.reType != RT_PORTALSURFACE ) { continue; } d = DotProduct( e->e.origin, originalPlane.normal ) - originalPlane.dist; if ( d > 64 || d < -64) { continue; } // get the pvsOrigin from the entity VectorCopy( e->e.oldorigin, pvsOrigin ); // if the entity is just a mirror, don't use as a camera point if ( e->e.oldorigin[0] == e->e.origin[0] && e->e.oldorigin[1] == e->e.origin[1] && e->e.oldorigin[2] == e->e.origin[2] ) { VectorScale( plane.normal, plane.dist, surface->origin ); VectorCopy( surface->origin, camera->origin ); VectorSubtract( vec3_origin, surface->axis[0], camera->axis[0] ); VectorCopy( surface->axis[1], camera->axis[1] ); VectorCopy( surface->axis[2], camera->axis[2] ); *mirror = qtrue; return qtrue; } // project the origin onto the surface plane to get // an origin point we can rotate around d = DotProduct( e->e.origin, plane.normal ) - plane.dist; VectorMA( e->e.origin, -d, surface->axis[0], surface->origin ); // now get the camera origin and orientation VectorCopy( e->e.oldorigin, camera->origin ); AxisCopy( e->e.axis, camera->axis ); VectorSubtract( vec3_origin, camera->axis[0], camera->axis[0] ); VectorSubtract( vec3_origin, camera->axis[1], camera->axis[1] ); // optionally rotate if ( e->e.oldframe ) { // if a speed is specified if ( e->e.frame ) { // continuous rotate d = (tr.refdef.time/1000.0f) * e->e.frame; VectorCopy( camera->axis[1], transformed ); RotatePointAroundVector( camera->axis[1], camera->axis[0], transformed, d ); CrossProduct( camera->axis[0], camera->axis[1], camera->axis[2] ); } else { // bobbing rotate, with skinNum being the rotation offset d = sin( tr.refdef.time * 0.003f ); d = e->e.skinNum + d * 4; VectorCopy( camera->axis[1], transformed ); RotatePointAroundVector( camera->axis[1], camera->axis[0], transformed, d ); CrossProduct( camera->axis[0], camera->axis[1], camera->axis[2] ); } } else if ( e->e.skinNum ) { d = e->e.skinNum; VectorCopy( camera->axis[1], transformed ); RotatePointAroundVector( camera->axis[1], camera->axis[0], transformed, d ); CrossProduct( camera->axis[0], camera->axis[1], camera->axis[2] ); } *mirror = qfalse; return qtrue; } // if we didn't locate a portal entity, don't render anything. // We don't want to just treat it as a mirror, because without a // portal entity the server won't have communicated a proper entity set // in the snapshot // unfortunately, with local movement prediction it is easily possible // to see a surface before the server has communicated the matching // portal surface entity, so we don't want to print anything here... //ri.Printf( PRINT_ALL, "Portal surface without a portal entity\n" ); return qfalse; }

Here is the call graph for this function:

void R_LocalNormalToWorld (  vec3_t  local, vec3_t  world )

Definition at line 164 of file tr_main.c. References orientationr_t::axis, trGlobals_t::or, and tr. Referenced by IsMirror(), and R_GetPortalOrientations(). { world[0] = local[0] * tr.or.axis[0][0] + local[1] * tr.or.axis[1][0] + local[2] * tr.or.axis[2][0]; world[1] = local[0] * tr.or.axis[0][1] + local[1] * tr.or.axis[1][1] + local[2] * tr.or.axis[2][1]; world[2] = local[0] * tr.or.axis[0][2] + local[1] * tr.or.axis[1][2] + local[2] * tr.or.axis[2][2]; }

void R_LocalPointToWorld (  vec3_t  local, vec3_t  world )

Definition at line 176 of file tr_main.c. References orientationr_t::axis, trGlobals_t::or, orientationr_t::origin, and tr. Referenced by R_CullLocalPointAndRadius(). { world[0] = local[0] * tr.or.axis[0][0] + local[1] * tr.or.axis[1][0] + local[2] * tr.or.axis[2][0] + tr.or.origin[0]; world[1] = local[0] * tr.or.axis[0][1] + local[1] * tr.or.axis[1][1] + local[2] * tr.or.axis[2][1] + tr.or.origin[1]; world[2] = local[0] * tr.or.axis[0][2] + local[1] * tr.or.