ioquake
/
jedi-outcast
mirror of https://github.com/ioquake/jedi-outcast.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

'or' is a c++ operator so rename variables to avoid it

This commit is contained in:
Jonathan Gray 2013-04-23 10:01:12 +10:00
parent 73b8d667f7
commit a06907e8f5
14 changed files with 188 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
code/renderer/tr_backend.cpp
View File

@ -482,10 +482,10 @@ void RB_BeginDrawingView (void) {
plane[2] = backEnd.viewParms.portalPlane.normal[2]; plane[2] = backEnd.viewParms.portalPlane.normal[2];
plane[3] = backEnd.viewParms.portalPlane.dist; plane[3] = backEnd.viewParms.portalPlane.dist;
plane2[0] = DotProduct (backEnd.viewParms.or.axis[0], plane); plane2[0] = DotProduct (backEnd.viewParms.ori.axis[0], plane);
plane2[1] = DotProduct (backEnd.viewParms.or.axis[1], plane); plane2[1] = DotProduct (backEnd.viewParms.ori.axis[1], plane);
plane2[2] = DotProduct (backEnd.viewParms.or.axis[2], plane); plane2[2] = DotProduct (backEnd.viewParms.ori.axis[2], plane);
plane2[3] = DotProduct (plane, backEnd.viewParms.or.origin) - plane[3]; plane2[3] = DotProduct (plane, backEnd.viewParms.ori.origin) - plane[3];
qglLoadMatrixf( s_flipMatrix ); qglLoadMatrixf( s_flipMatrix );
qglClipPlane (GL_CLIP_PLANE0, plane2); qglClipPlane (GL_CLIP_PLANE0, plane2);
@ -591,11 +591,11 @@ void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
backEnd.refdef.floatTime = originalTime - backEnd.currentEntity->e.shaderTime; backEnd.refdef.floatTime = originalTime - backEnd.currentEntity->e.shaderTime;
// set up the transformation matrix // set up the transformation matrix
R_RotateForEntity( backEnd.currentEntity, &backEnd.viewParms, &backEnd.or ); R_RotateForEntity( backEnd.currentEntity, &backEnd.viewParms, &backEnd.ori );
// set up the dynamic lighting if needed // set up the dynamic lighting if needed
if ( backEnd.currentEntity->needDlights ) { if ( backEnd.currentEntity->needDlights ) {
R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.or ); R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
} }
if ( backEnd.currentEntity->e.renderfx & RF_DEPTHHACK ) { if ( backEnd.currentEntity->e.renderfx & RF_DEPTHHACK ) {
@ -605,11 +605,11 @@ void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
} else { } else {
backEnd.currentEntity = &tr.worldEntity; backEnd.currentEntity = &tr.worldEntity;
backEnd.refdef.floatTime = originalTime; backEnd.refdef.floatTime = originalTime;
backEnd.or = backEnd.viewParms.world; backEnd.ori = backEnd.viewParms.world;
R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.or ); R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
} }
qglLoadMatrixf( backEnd.or.modelMatrix ); qglLoadMatrixf( backEnd.ori.modelMatrix );
// //
// change depthrange if needed // change depthrange if needed

12
code/renderer/tr_light.cpp
View File

@ -23,15 +23,15 @@ Used by both the front end (for DlightBmodel) and
the back end (before doing the lighting calculation) the back end (before doing the lighting calculation)
=============== ===============
*/ */
void R_TransformDlights( int count, dlight_t *dl, orientationr_t *or) { void R_TransformDlights( int count, dlight_t *dl, orientationr_t *ori) {
int i; int i;
vec3_t temp; vec3_t temp;
for ( i = 0 ; i < count ; i++, dl++ ) { for ( i = 0 ; i < count ; i++, dl++ ) {
VectorSubtract( dl->origin, or->origin, temp ); VectorSubtract( dl->origin, ori->origin, temp );
dl->transformed[0] = DotProduct( temp, or->axis[0] ); dl->transformed[0] = DotProduct( temp, ori->axis[0] );
dl->transformed[1] = DotProduct( temp, or->axis[1] ); dl->transformed[1] = DotProduct( temp, ori->axis[1] );
dl->transformed[2] = DotProduct( temp, or->axis[2] ); dl->transformed[2] = DotProduct( temp, ori->axis[2] );
} }
} }
@ -49,7 +49,7 @@ void R_DlightBmodel( bmodel_t *bmodel ) {
msurface_t *surf; msurface_t *surf;
// transform all the lights // transform all the lights
R_TransformDlights( tr.refdef.num_dlights, tr.refdef.dlights, &tr.or ); R_TransformDlights( tr.refdef.num_dlights, tr.refdef.dlights, &tr.ori );
mask = 0; mask = 0;
for ( i=0 ; i<tr.refdef.num_dlights ; i++ ) { for ( i=0 ; i<tr.refdef.num_dlights ; i++ ) {

10
code/renderer/tr_local.h
View File

@ -519,7 +519,7 @@ typedef struct {
} fog_t; } fog_t;
typedef struct { typedef struct {
orientationr_t or; orientationr_t ori;
orientationr_t world; orientationr_t world;
vec3_t pvsOrigin; // may be different than or.origin for portals vec3_t pvsOrigin; // may be different than or.origin for portals
qboolean isPortal; // true if this view is through a portal qboolean isPortal; // true if this view is through a portal
@ -917,7 +917,7 @@ typedef struct {
int smpFrame; int smpFrame;
trRefdef_t refdef; trRefdef_t refdef;
viewParms_t viewParms; viewParms_t viewParms;
orientationr_t or; orientationr_t ori;
backEndCounters_t pc; backEndCounters_t pc;
qboolean isHyperspace; qboolean isHyperspace;
trRefEntity_t *currentEntity; trRefEntity_t *currentEntity;
@ -985,7 +985,7 @@ typedef struct {
int identityLightByte; // identityLight * 255 int identityLightByte; // identityLight * 255
int overbrightBits; // r_overbrightBits->integer, but set to 0 if no hw gamma int overbrightBits; // r_overbrightBits->integer, but set to 0 if no hw gamma
orientationr_t or; // for current entity orientationr_t ori; // for current entity
trRefdef_t refdef; trRefdef_t refdef;
@ -1215,7 +1215,7 @@ int R_CullLocalBox (vec3_t bounds[2]);
int R_CullPointAndRadius( vec3_t origin, float radius ); int R_CullPointAndRadius( vec3_t origin, float radius );
int R_CullLocalPointAndRadius( vec3_t origin, float radius ); int R_CullLocalPointAndRadius( vec3_t origin, float radius );
void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms, orientationr_t *or ); void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms, orientationr_t *ori );
/* /*
** GL wrapper/helper functions ** GL wrapper/helper functions
@ -1478,7 +1478,7 @@ LIGHTS
void R_DlightBmodel( bmodel_t *bmodel ); void R_DlightBmodel( bmodel_t *bmodel );
void R_SetupEntityLighting( const trRefdef_t *refdef, trRefEntity_t *ent ); void R_SetupEntityLighting( const trRefdef_t *refdef, trRefEntity_t *ent );
void R_TransformDlights( int count, dlight_t *dl, orientationr_t *or ); void R_TransformDlights( int count, dlight_t *dl, orientationr_t *ori );
/* /*

154
code/renderer/tr_main.cpp
View File

@ -55,10 +55,10 @@ int R_CullLocalBox (vec3_t bounds[2]) {
v[1] = bounds[(i>>1)&1][1]; v[1] = bounds[(i>>1)&1][1];
v[2] = bounds[(i>>2)&1][2]; v[2] = bounds[(i>>2)&1][2];
VectorCopy( tr.or.origin, transformed[i] ); VectorCopy( tr.ori.origin, transformed[i] );
VectorMA( transformed[i], v[0], tr.or.axis[0], transformed[i] ); VectorMA( transformed[i], v[0], tr.ori.axis[0], transformed[i] );
VectorMA( transformed[i], v[1], tr.or.axis[1], transformed[i] ); VectorMA( transformed[i], v[1], tr.ori.axis[1], transformed[i] );
VectorMA( transformed[i], v[2], tr.or.axis[2], transformed[i] ); VectorMA( transformed[i], v[2], tr.ori.axis[2], transformed[i] );
} }
// check against frustum planes // check against frustum planes
@ -164,9 +164,9 @@ R_LocalNormalToWorld
================= =================
*/ */
void R_LocalNormalToWorld (vec3_t local, vec3_t world) { void R_LocalNormalToWorld (vec3_t local, vec3_t world) {
world[0] = local[0] * tr.or.axis[0][0] + local[1] * tr.or.axis[1][0] + local[2] * tr.or.axis[2][0]; world[0] = local[0] * tr.ori.axis[0][0] + local[1] * tr.ori.axis[1][0] + local[2] * tr.ori.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[1] = local[0] * tr.ori.axis[0][1] + local[1] * tr.ori.axis[1][1] + local[2] * tr.ori.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]; world[2] = local[0] * tr.ori.axis[0][2] + local[1] * tr.ori.axis[1][2] + local[2] * tr.ori.axis[2][2];
} }
/* /*
@ -176,9 +176,9 @@ R_LocalPointToWorld
================= =================
*/ */
void R_LocalPointToWorld (vec3_t local, vec3_t world) { void R_LocalPointToWorld (vec3_t local, vec3_t world) {
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[0] = local[0] * tr.ori.axis[0][0] + local[1] * tr.ori.axis[1][0] + local[2] * tr.ori.axis[2][0] + tr.ori.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[1] = local[0] * tr.ori.axis[0][1] + local[1] * tr.ori.axis[1][1] + local[2] * tr.ori.axis[2][1] + tr.ori.origin[1];
world[2] = local[0] * tr.or.axis[0][2] + local[1] * tr.or.axis[1][2] + local[2] * tr.or.axis[2][2] + tr.or.origin[2]; world[2] = local[0] * tr.ori.axis[0][2] + local[1] * tr.ori.axis[1][2] + local[2] * tr.ori.axis[2][2] + tr.ori.origin[2];
} }
float preTransEntMatrix[16]; float preTransEntMatrix[16];
@ -239,9 +239,9 @@ R_WorldToLocal
================= =================
*/ */
void R_WorldToLocal (vec3_t world, vec3_t local) { void R_WorldToLocal (vec3_t world, vec3_t local) {
local[0] = DotProduct(world, tr.or.axis[0]); local[0] = DotProduct(world, tr.ori.axis[0]);
local[1] = DotProduct(world, tr.or.axis[1]); local[1] = DotProduct(world, tr.ori.axis[1]);
local[2] = DotProduct(world, tr.or.axis[2]); local[2] = DotProduct(world, tr.ori.axis[2]);
} }
/* /*
@ -321,47 +321,47 @@ Called by both the front end and the back end
================= =================
*/ */
void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms, void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms,
orientationr_t *or ) { orientationr_t *ori ) {
// float glMatrix[16]; // float glMatrix[16];
vec3_t delta; vec3_t delta;
float axisLength; float axisLength;
if ( ent->e.reType != RT_MODEL ) { if ( ent->e.reType != RT_MODEL ) {
*or = viewParms->world; *ori = viewParms->world;
return; return;
} }
VectorCopy( ent->e.origin, or->origin ); VectorCopy( ent->e.origin, ori->origin );
VectorCopy( ent->e.axis[0], or->axis[0] ); VectorCopy( ent->e.axis[0], ori->axis[0] );
VectorCopy( ent->e.axis[1], or->axis[1] ); VectorCopy( ent->e.axis[1], ori->axis[1] );
VectorCopy( ent->e.axis[2], or->axis[2] ); VectorCopy( ent->e.axis[2], ori->axis[2] );
preTransEntMatrix[0] = or->axis[0][0]; preTransEntMatrix[0] = ori->axis[0][0];
preTransEntMatrix[4] = or->axis[1][0]; preTransEntMatrix[4] = ori->axis[1][0];
preTransEntMatrix[8] = or->axis[2][0]; preTransEntMatrix[8] = ori->axis[2][0];
preTransEntMatrix[12] = or->origin[0]; preTransEntMatrix[12] = ori->origin[0];
preTransEntMatrix[1] = or->axis[0][1]; preTransEntMatrix[1] = ori->axis[0][1];
preTransEntMatrix[5] = or->axis[1][1]; preTransEntMatrix[5] = ori->axis[1][1];
preTransEntMatrix[9] = or->axis[2][1]; preTransEntMatrix[9] = ori->axis[2][1];
preTransEntMatrix[13] = or->origin[1]; preTransEntMatrix[13] = ori->origin[1];
preTransEntMatrix[2] = or->axis[0][2]; preTransEntMatrix[2] = ori->axis[0][2];
preTransEntMatrix[6] = or->axis[1][2]; preTransEntMatrix[6] = ori->axis[1][2];
preTransEntMatrix[10] = or->axis[2][2]; preTransEntMatrix[10] = ori->axis[2][2];
preTransEntMatrix[14] = or->origin[2]; preTransEntMatrix[14] = ori->origin[2];
preTransEntMatrix[3] = 0; preTransEntMatrix[3] = 0;
preTransEntMatrix[7] = 0; preTransEntMatrix[7] = 0;
preTransEntMatrix[11] = 0; preTransEntMatrix[11] = 0;
preTransEntMatrix[15] = 1; preTransEntMatrix[15] = 1;
myGlMultMatrix( preTransEntMatrix, viewParms->world.modelMatrix, or->modelMatrix ); myGlMultMatrix( preTransEntMatrix, viewParms->world.modelMatrix, ori->modelMatrix );
// calculate the viewer origin in the model's space // calculate the viewer origin in the model's space
// needed for fog, specular, and environment mapping // needed for fog, specular, and environment mapping
VectorSubtract( viewParms->or.origin, or->origin, delta ); VectorSubtract( viewParms->ori.origin, ori->origin, delta );
// compensate for scale in the axes if necessary // compensate for scale in the axes if necessary
if ( ent->e.nonNormalizedAxes ) { if ( ent->e.nonNormalizedAxes ) {
@ -375,9 +375,9 @@ void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms,
axisLength = 1.0; axisLength = 1.0;
} }
or->viewOrigin[0] = DotProduct( delta, or->axis[0] ) * axisLength; ori->viewOrigin[0] = DotProduct( delta, ori->axis[0] ) * axisLength;
or->viewOrigin[1] = DotProduct( delta, or->axis[1] ) * axisLength; ori->viewOrigin[1] = DotProduct( delta, ori->axis[1] ) * axisLength;
or->viewOrigin[2] = DotProduct( delta, or->axis[2] ) * axisLength; ori->viewOrigin[2] = DotProduct( delta, ori->axis[2] ) * axisLength;
} }
/* /*
@ -392,28 +392,28 @@ void R_RotateForViewer (void)
float viewerMatrix[16]; float viewerMatrix[16];
vec3_t origin; vec3_t origin;
memset (&tr.or, 0, sizeof(tr.or)); memset (&tr.ori, 0, sizeof(tr.ori));
tr.or.axis[0][0] = 1; tr.ori.axis[0][0] = 1;
tr.or.axis[1][1] = 1; tr.ori.axis[1][1] = 1;
tr.or.axis[2][2] = 1; tr.ori.axis[2][2] = 1;
VectorCopy (tr.viewParms.or.origin, tr.or.viewOrigin); VectorCopy (tr.viewParms.ori.origin, tr.ori.viewOrigin);
// transform by the camera placement // transform by the camera placement
VectorCopy( tr.viewParms.or.origin, origin ); VectorCopy( tr.viewParms.ori.origin, origin );
viewerMatrix[0] = tr.viewParms.or.axis[0][0]; viewerMatrix[0] = tr.viewParms.ori.axis[0][0];
viewerMatrix[4] = tr.viewParms.or.axis[0][1]; viewerMatrix[4] = tr.viewParms.ori.axis[0][1];
viewerMatrix[8] = tr.viewParms.or.axis[0][2]; viewerMatrix[8] = tr.viewParms.ori.axis[0][2];
viewerMatrix[12] = -origin[0] * viewerMatrix[0] + -origin[1] * viewerMatrix[4] + -origin[2] * viewerMatrix[8]; viewerMatrix[12] = -origin[0] * viewerMatrix[0] + -origin[1] * viewerMatrix[4] + -origin[2] * viewerMatrix[8];
viewerMatrix[1] = tr.viewParms.or.axis[1][0]; viewerMatrix[1] = tr.viewParms.ori.axis[1][0];
viewerMatrix[5] = tr.viewParms.or.axis[1][1]; viewerMatrix[5] = tr.viewParms.ori.axis[1][1];
viewerMatrix[9] = tr.viewParms.or.axis[1][2]; viewerMatrix[9] = tr.viewParms.ori.axis[1][2];
viewerMatrix[13] = -origin[0] * viewerMatrix[1] + -origin[1] * viewerMatrix[5] + -origin[2] * viewerMatrix[9]; viewerMatrix[13] = -origin[0] * viewerMatrix[1] + -origin[1] * viewerMatrix[5] + -origin[2] * viewerMatrix[9];
viewerMatrix[2] = tr.viewParms.or.axis[2][0]; viewerMatrix[2] = tr.viewParms.ori.axis[2][0];
viewerMatrix[6] = tr.viewParms.or.axis[2][1]; viewerMatrix[6] = tr.viewParms.ori.axis[2][1];
viewerMatrix[10] = tr.viewParms.or.axis[2][2]; viewerMatrix[10] = tr.viewParms.ori.axis[2][2];
viewerMatrix[14] = -origin[0] * viewerMatrix[2] + -origin[1] * viewerMatrix[6] + -origin[2] * viewerMatrix[10]; viewerMatrix[14] = -origin[0] * viewerMatrix[2] + -origin[1] * viewerMatrix[6] + -origin[2] * viewerMatrix[10];
viewerMatrix[3] = 0; viewerMatrix[3] = 0;
@ -423,9 +423,9 @@ void R_RotateForViewer (void)
// convert from our coordinate system (looking down X) // convert from our coordinate system (looking down X)
// to OpenGL's coordinate system (looking down -Z) // to OpenGL's coordinate system (looking down -Z)
myGlMultMatrix( viewerMatrix, s_flipMatrix, tr.or.modelMatrix ); myGlMultMatrix( viewerMatrix, s_flipMatrix, tr.ori.modelMatrix );
tr.viewParms.world = tr.or; tr.viewParms.world = tr.ori;
} }
@ -481,7 +481,7 @@ static void SetFarClip( void )
v[2] = tr.viewParms.visBounds[1][2]; v[2] = tr.viewParms.visBounds[1][2];
} }
VectorSubtract( v, tr.viewParms.or.origin, vecTo ); VectorSubtract( v, tr.viewParms.ori.origin, vecTo );
distance = vecTo[0] * vecTo[0] + vecTo[1] * vecTo[1] + vecTo[2] * vecTo[2]; distance = vecTo[0] * vecTo[0] + vecTo[1] * vecTo[1] + vecTo[2] * vecTo[2];
@ -560,25 +560,25 @@ void R_SetupFrustum (void) {
xs = sin( ang ); xs = sin( ang );
xc = cos( ang ); xc = cos( ang );
VectorScale( tr.viewParms.or.axis[0], xs, tr.viewParms.frustum[0].normal ); VectorScale( tr.viewParms.ori.axis[0], xs, tr.viewParms.frustum[0].normal );
VectorMA( tr.viewParms.frustum[0].normal, xc, tr.viewParms.or.axis[1], tr.viewParms.frustum[0].normal ); VectorMA( tr.viewParms.frustum[0].normal, xc, tr.viewParms.ori.axis[1], tr.viewParms.frustum[0].normal );
VectorScale( tr.viewParms.or.axis[0], xs, tr.viewParms.frustum[1].normal ); VectorScale( tr.viewParms.ori.axis[0], xs, tr.viewParms.frustum[1].normal );
VectorMA( tr.viewParms.frustum[1].normal, -xc, tr.viewParms.or.axis[1], tr.viewParms.frustum[1].normal ); VectorMA( tr.viewParms.frustum[1].normal, -xc, tr.viewParms.ori.axis[1], tr.viewParms.frustum[1].normal );
ang = tr.viewParms.fovY / 180 * M_PI * 0.5; ang = tr.viewParms.fovY / 180 * M_PI * 0.5;
xs = sin( ang ); xs = sin( ang );
xc = cos( ang ); xc = cos( ang );
VectorScale( tr.viewParms.or.axis[0], xs, tr.viewParms.frustum[2].normal ); VectorScale( tr.viewParms.ori.axis[0], xs, tr.viewParms.frustum[2].normal );
VectorMA( tr.viewParms.frustum[2].normal, xc, tr.viewParms.or.axis[2], tr.viewParms.frustum[2].normal ); VectorMA( tr.viewParms.frustum[2].normal, xc, tr.viewParms.ori.axis[2], tr.viewParms.frustum[2].normal );
VectorScale( tr.viewParms.or.axis[0], xs, tr.viewParms.frustum[3].normal ); VectorScale( tr.viewParms.ori.axis[0], xs, tr.viewParms.frustum[3].normal );
VectorMA( tr.viewParms.frustum[3].normal, -xc, tr.viewParms.or.axis[2], tr.viewParms.frustum[3].normal ); VectorMA( tr.viewParms.frustum[3].normal, -xc, tr.viewParms.ori.axis[2], tr.viewParms.frustum[3].normal );
for (i=0 ; i<4 ; i++) { for (i=0 ; i<4 ; i++) {
tr.viewParms.frustum[i].type = PLANE_NON_AXIAL; tr.viewParms.frustum[i].type = PLANE_NON_AXIAL;
tr.viewParms.frustum[i].dist = DotProduct (tr.viewParms.or.origin, tr.viewParms.frustum[i].normal); tr.viewParms.frustum[i].dist = DotProduct (tr.viewParms.ori.origin, tr.viewParms.frustum[i].normal);
SetPlaneSignbits( &tr.viewParms.frustum[i] ); SetPlaneSignbits( &tr.viewParms.frustum[i] );
} }
} }
@ -698,15 +698,15 @@ qboolean R_GetPortalOrientations( drawSurf_t *drawSurf, int entityNum,
tr.currentEntity = &tr.refdef.entities[entityNum]; tr.currentEntity = &tr.refdef.entities[entityNum];
// get the orientation of the entity // get the orientation of the entity
R_RotateForEntity( tr.currentEntity, &tr.viewParms, &tr.or ); R_RotateForEntity( tr.currentEntity, &tr.viewParms, &tr.ori );
// rotate the plane, but keep the non-rotated version for matching // rotate the plane, but keep the non-rotated version for matching
// against the portalSurface entities // against the portalSurface entities
R_LocalNormalToWorld( originalPlane.normal, plane.normal ); R_LocalNormalToWorld( originalPlane.normal, plane.normal );
plane.dist = originalPlane.dist + DotProduct( plane.normal, tr.or.origin ); plane.dist = originalPlane.dist + DotProduct( plane.normal, tr.ori.origin );
// translate the original plane // translate the original plane
originalPlane.dist = originalPlane.dist + DotProduct( originalPlane.normal, tr.or.origin ); originalPlane.dist = originalPlane.dist + DotProduct( originalPlane.normal, tr.ori.origin );
} else { } else {
plane = originalPlane; plane = originalPlane;
} }
@ -807,15 +807,15 @@ static qboolean IsMirror( const drawSurf_t *drawSurf, int entityNum )
tr.currentEntity = &tr.refdef.entities[entityNum]; tr.currentEntity = &tr.refdef.entities[entityNum];
// get the orientation of the entity // get the orientation of the entity
R_RotateForEntity( tr.currentEntity, &tr.viewParms, &tr.or ); R_RotateForEntity( tr.currentEntity, &tr.viewParms, &tr.ori );
// rotate the plane, but keep the non-rotated version for matching // rotate the plane, but keep the non-rotated version for matching
// against the portalSurface entities // against the portalSurface entities
R_LocalNormalToWorld( originalPlane.normal, plane.normal ); R_LocalNormalToWorld( originalPlane.normal, plane.normal );
plane.dist = originalPlane.dist + DotProduct( plane.normal, tr.or.origin ); plane.dist = originalPlane.dist + DotProduct( plane.normal, tr.ori.origin );
// translate the original plane // translate the original plane
originalPlane.dist = originalPlane.dist + DotProduct( originalPlane.normal, tr.or.origin ); originalPlane.dist = originalPlane.dist + DotProduct( originalPlane.normal, tr.ori.origin );
} }
else else
{ {
@ -884,7 +884,7 @@ static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128
int j; int j;
unsigned int pointFlags = 0; unsigned int pointFlags = 0;
R_TransformModelToClip( tess.xyz[i], tr.or.modelMatrix, tr.viewParms.projectionMatrix, eye, clip ); R_TransformModelToClip( tess.xyz[i], tr.ori.modelMatrix, tr.viewParms.projectionMatrix, eye, clip );
for ( j = 0; j < 3; j++ ) for ( j = 0; j < 3; j++ )
{ {
@ -920,7 +920,7 @@ static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128
float dot; float dot;
float len; float len;
VectorSubtract( tess.xyz[tess.indexes[i]], tr.viewParms.or.origin, normal ); VectorSubtract( tess.xyz[tess.indexes[i]], tr.viewParms.ori.origin, normal );
len = VectorLengthSquared( normal ); // lose the sqrt len = VectorLengthSquared( normal ); // lose the sqrt
if ( len < shortest ) if ( len < shortest )
@ -993,14 +993,14 @@ qboolean R_MirrorViewBySurface (drawSurf_t *drawSurf, int entityNum) {
return qfalse; // bad portal, no portalentity return qfalse; // bad portal, no portalentity
} }
R_MirrorPoint (oldParms.or.origin, &surface, &camera, newParms.or.origin ); R_MirrorPoint (oldParms.ori.origin, &surface, &camera, newParms.ori.origin );
VectorSubtract( vec3_origin, camera.axis[0], newParms.portalPlane.normal ); VectorSubtract( vec3_origin, camera.axis[0], newParms.portalPlane.normal );
newParms.portalPlane.dist = DotProduct( camera.origin, newParms.portalPlane.normal ); newParms.portalPlane.dist = DotProduct( camera.origin, newParms.portalPlane.normal );
R_MirrorVector (oldParms.or.axis[0], &surface, &camera, newParms.or.axis[0]); R_MirrorVector (oldParms.ori.axis[0], &surface, &camera, newParms.ori.axis[0]);
R_MirrorVector (oldParms.or.axis[1], &surface, &camera, newParms.or.axis[1]); R_MirrorVector (oldParms.ori.axis[1], &surface, &camera, newParms.ori.axis[1]);
R_MirrorVector (oldParms.or.axis[2], &surface, &camera, newParms.or.axis[2]); R_MirrorVector (oldParms.ori.axis[2], &surface, &camera, newParms.ori.axis[2]);
// OPTIMIZE: restrict the viewport on the mirrored view // OPTIMIZE: restrict the viewport on the mirrored view
@ -1432,8 +1432,8 @@ void R_AddEntitySurfaces (void) {
break; break;
case RT_MODEL: case RT_MODEL:
// we must set up parts of tr.or for model culling // we must set up parts of tr.ori for model culling
R_RotateForEntity( ent, &tr.viewParms, &tr.or ); R_RotateForEntity( ent, &tr.viewParms, &tr.ori );
tr.currentModel = R_GetModelByHandle( ent->e.hModel ); tr.currentModel = R_GetModelByHandle( ent->e.hModel );
if (!tr.currentModel) { if (!tr.currentModel) {

4
code/renderer/tr_mesh.cpp
View File

@ -18,8 +18,8 @@ float ProjectRadius( float r, vec3_t location )
vec3_t p; vec3_t p;
float projected[4]; float projected[4];
c = DotProduct( tr.viewParms.or.axis[0], tr.viewParms.or.origin ); c = DotProduct( tr.viewParms.ori.axis[0], tr.viewParms.ori.origin );
dist = DotProduct( tr.viewParms.or.axis[0], location ) - c; dist = DotProduct( tr.viewParms.ori.axis[0], location ) - c;
if ( dist <= 0 ) if ( dist <= 0 )
return 0; return 0;

8
code/renderer/tr_scene.cpp
View File

@ -354,10 +354,10 @@ void RE_RenderScene( const refdef_t *fd ) {
parms.fovX = tr.refdef.fov_x; parms.fovX = tr.refdef.fov_x;
parms.fovY = tr.refdef.fov_y; parms.fovY = tr.refdef.fov_y;
VectorCopy( fd->vieworg, parms.or.origin ); VectorCopy( fd->vieworg, parms.ori.origin );
VectorCopy( fd->viewaxis[0], parms.or.axis[0] ); VectorCopy( fd->viewaxis[0], parms.ori.axis[0] );
VectorCopy( fd->viewaxis[1], parms.or.axis[1] ); VectorCopy( fd->viewaxis[1], parms.ori.axis[1] );
VectorCopy( fd->viewaxis[2], parms.or.axis[2] ); VectorCopy( fd->viewaxis[2], parms.ori.axis[2] );
VectorCopy( fd->vieworg, parms.pvsOrigin ); VectorCopy( fd->vieworg, parms.pvsOrigin );

2
code/renderer/tr_shade.cpp
View File

@ -1073,7 +1073,7 @@ static void ComputeColors( shaderStage_t *pStage, int forceAlphaGen, int forceRG
float len; float len;
vec3_t v; vec3_t v;
VectorSubtract( tess.xyz[i], backEnd.viewParms.or.origin, v ); VectorSubtract( tess.xyz[i], backEnd.viewParms.ori.origin, v );
len = VectorLength( v ); len = VectorLength( v );
len /= tess.shader->portalRange; len /= tess.shader->portalRange;

48
code/renderer/tr_shade_calc.cpp
View File

@ -341,9 +341,9 @@ GlobalVectorToLocal
================== ==================
*/ */
static void GlobalVectorToLocal( const vec3_t in, vec3_t out ) { static void GlobalVectorToLocal( const vec3_t in, vec3_t out ) {
out[0] = DotProduct( in, backEnd.or.axis[0] ); out[0] = DotProduct( in, backEnd.ori.axis[0] );
out[1] = DotProduct( in, backEnd.or.axis[1] ); out[1] = DotProduct( in, backEnd.ori.axis[1] );
out[2] = DotProduct( in, backEnd.or.axis[2] ); out[2] = DotProduct( in, backEnd.ori.axis[2] );
} }
/* /*
@ -375,11 +375,11 @@ static void AutospriteDeform( void ) {
tess.numIndexes = 0; tess.numIndexes = 0;
if ( backEnd.currentEntity != &tr.worldEntity ) { if ( backEnd.currentEntity != &tr.worldEntity ) {
GlobalVectorToLocal( backEnd.viewParms.or.axis[1], leftDir ); GlobalVectorToLocal( backEnd.viewParms.ori.axis[1], leftDir );
GlobalVectorToLocal( backEnd.viewParms.or.axis[2], upDir ); GlobalVectorToLocal( backEnd.viewParms.ori.axis[2], upDir );
} else { } else {
VectorCopy( backEnd.viewParms.or.axis[1], leftDir ); VectorCopy( backEnd.viewParms.ori.axis[1], leftDir );
VectorCopy( backEnd.viewParms.or.axis[2], upDir ); VectorCopy( backEnd.viewParms.ori.axis[2], upDir );
} }
for ( i = 0 ; i < oldVerts ; i+=4 ) { for ( i = 0 ; i < oldVerts ; i+=4 ) {
@ -435,9 +435,9 @@ static void Autosprite2Deform( void ) {
} }
if ( backEnd.currentEntity != &tr.worldEntity ) { if ( backEnd.currentEntity != &tr.worldEntity ) {
GlobalVectorToLocal( backEnd.viewParms.or.axis[0], forward ); GlobalVectorToLocal( backEnd.viewParms.ori.axis[0], forward );
} else { } else {
VectorCopy( backEnd.viewParms.or.axis[0], forward ); VectorCopy( backEnd.viewParms.ori.axis[0], forward );
} }
// this is a lot of work for two triangles... // this is a lot of work for two triangles...
@ -814,11 +814,11 @@ void RB_CalcFogTexCoords( float *st ) {
fog = tr.world->fogs + tess.fogNum; fog = tr.world->fogs + tess.fogNum;
// all fogging distance is based on world Z units // all fogging distance is based on world Z units
VectorSubtract( backEnd.or.origin, backEnd.viewParms.or.origin, localVec ); VectorSubtract( backEnd.ori.origin, backEnd.viewParms.ori.origin, localVec );
fogDistanceVector[0] = -backEnd.or.modelMatrix[2]; fogDistanceVector[0] = -backEnd.ori.modelMatrix[2];
fogDistanceVector[1] = -backEnd.or.modelMatrix[6]; fogDistanceVector[1] = -backEnd.ori.modelMatrix[6];
fogDistanceVector[2] = -backEnd.or.modelMatrix[10]; fogDistanceVector[2] = -backEnd.ori.modelMatrix[10];
fogDistanceVector[3] = DotProduct( localVec, backEnd.viewParms.or.axis[0] ); fogDistanceVector[3] = DotProduct( localVec, backEnd.viewParms.ori.axis[0] );
// scale the fog vectors based on the fog's thickness // scale the fog vectors based on the fog's thickness
fogDistanceVector[0] *= fog->tcScale; fogDistanceVector[0] *= fog->tcScale;
@ -828,15 +828,15 @@ void RB_CalcFogTexCoords( float *st ) {
// rotate the gradient vector for this orientation // rotate the gradient vector for this orientation
if ( fog->hasSurface ) { if ( fog->hasSurface ) {
fogDepthVector[0] = fog->surface[0] * backEnd.or.axis[0][0] + fogDepthVector[0] = fog->surface[0] * backEnd.ori.axis[0][0] +
fog->surface[1] * backEnd.or.axis[0][1] + fog->surface[2] * backEnd.or.axis[0][2]; fog->surface[1] * backEnd.ori.axis[0][1] + fog->surface[2] * backEnd.ori.axis[0][2];
fogDepthVector[1] = fog->surface[0] * backEnd.or.axis[1][0] + fogDepthVector[1] = fog->surface[0] * backEnd.ori.axis[1][0] +
fog->surface[1] * backEnd.or.axis[1][1] + fog->surface[2] * backEnd.or.axis[1][2]; fog->surface[1] * backEnd.ori.axis[1][1] + fog->surface[2] * backEnd.ori.axis[1][2];
fogDepthVector[2] = fog->surface[0] * backEnd.or.axis[2][0] + fogDepthVector[2] = fog->surface[0] * backEnd.ori.axis[2][0] +
fog->surface[1] * backEnd.or.axis[2][1] + fog->surface[2] * backEnd.or.axis[2][2]; fog->surface[1] * backEnd.ori.axis[2][1] + fog->surface[2] * backEnd.ori.axis[2][2];
fogDepthVector[3] = -fog->surface[3] + DotProduct( backEnd.or.origin, fog->surface ); fogDepthVector[3] = -fog->surface[3] + DotProduct( backEnd.ori.origin, fog->surface );
eyeT = DotProduct( backEnd.or.viewOrigin, fogDepthVector ) + fogDepthVector[3]; eyeT = DotProduct( backEnd.ori.viewOrigin, fogDepthVector ) + fogDepthVector[3];
} else { } else {
eyeT = 1; // non-surface fog always has eye inside eyeT = 1; // non-surface fog always has eye inside
fogDepthVector[0] = fogDepthVector[1] = fogDepthVector[2] = 0.0; fogDepthVector[0] = fogDepthVector[1] = fogDepthVector[2] = 0.0;
@ -906,7 +906,7 @@ void RB_CalcEnvironmentTexCoords( float *st )
} else { //the normal way } else { //the normal way
for (i = 0 ; i < tess.numVertexes ; i++, v += 4, normal += 4, st += 2 ) for (i = 0 ; i < tess.numVertexes ; i++, v += 4, normal += 4, st += 2 )
{ {
VectorSubtract (backEnd.or.viewOrigin, v, viewer); VectorSubtract (backEnd.ori.viewOrigin, v, viewer);
VectorNormalizeFast (viewer); VectorNormalizeFast (viewer);
d = DotProduct (normal, viewer); d = DotProduct (normal, viewer);
@ -1077,7 +1077,7 @@ void RB_CalcSpecularAlpha( unsigned char *alphas ) {
reflected[1] = normal[1]*d - lightDir[1]; reflected[1] = normal[1]*d - lightDir[1];
reflected[2] = normal[2]*d - lightDir[2]; reflected[2] = normal[2]*d - lightDir[2];
VectorSubtract (backEnd.or.viewOrigin, v, viewer); VectorSubtract (backEnd.ori.viewOrigin, v, viewer);
ilength = Q_rsqrt( DotProduct( viewer, viewer ) ); ilength = Q_rsqrt( DotProduct( viewer, viewer ) );
l = DotProduct (reflected, viewer); l = DotProduct (reflected, viewer);
l *= ilength; l *= ilength;

8
code/renderer/tr_shadows.cpp
View File

@ -295,11 +295,11 @@ void RB_ProjectionShadowDeform( void ) {
xyz = ( float * ) tess.xyz; xyz = ( float * ) tess.xyz;
ground[0] = backEnd.or.axis[0][2]; ground[0] = backEnd.ori.axis[0][2];
ground[1] = backEnd.or.axis[1][2]; ground[1] = backEnd.ori.axis[1][2];
ground[2] = backEnd.or.axis[2][2]; ground[2] = backEnd.ori.axis[2][2];
groundDist = backEnd.or.origin[2] - backEnd.currentEntity->e.shadowPlane; groundDist = backEnd.ori.origin[2] - backEnd.currentEntity->e.shadowPlane;
VectorCopy( backEnd.currentEntity->lightDir, lightDir ); VectorCopy( backEnd.currentEntity->lightDir, lightDir );
d = DotProduct( lightDir, ground ); d = DotProduct( lightDir, ground );

8
code/renderer/tr_sky.cpp
View File

@ -254,7 +254,7 @@ void RB_ClipSkyPolygons( shaderCommands_t *input )
for (j = 0 ; j < 3 ; j++) for (j = 0 ; j < 3 ; j++)
{ {
VectorSubtract( input->xyz[input->indexes[i+j]], VectorSubtract( input->xyz[input->indexes[i+j]],
backEnd.viewParms.or.origin, backEnd.viewParms.ori.origin,
p[j] ); p[j] );
} }
ClipSkyPolygon( 3, p[0], 0 ); ClipSkyPolygon( 3, p[0], 0 );
@ -452,7 +452,7 @@ static void FillCloudySkySide( const int mins[2], const int maxs[2], qboolean ad
{ {
for ( s = mins[0]+HALF_SKY_SUBDIVISIONS; s <= maxs[0]+HALF_SKY_SUBDIVISIONS; s++ ) for ( s = mins[0]+HALF_SKY_SUBDIVISIONS; s <= maxs[0]+HALF_SKY_SUBDIVISIONS; s++ )
{ {
VectorAdd( s_skyPoints[t][s], backEnd.viewParms.or.origin, tess.xyz[tess.numVertexes] ); VectorAdd( s_skyPoints[t][s], backEnd.viewParms.ori.origin, tess.xyz[tess.numVertexes] );
tess.texCoords[tess.numVertexes][0][0] = s_skyTexCoords[t][s][0]; tess.texCoords[tess.numVertexes][0][0] = s_skyTexCoords[t][s][0];
tess.texCoords[tess.numVertexes][0][1] = s_skyTexCoords[t][s][1]; tess.texCoords[tess.numVertexes][0][1] = s_skyTexCoords[t][s][1];
@ -695,7 +695,7 @@ void RB_DrawSun( void ) {
return; return;
} }
qglLoadMatrixf( backEnd.viewParms.world.modelMatrix ); qglLoadMatrixf( backEnd.viewParms.world.modelMatrix );
qglTranslatef (backEnd.viewParms.or.origin[0], backEnd.viewParms.or.origin[1], backEnd.viewParms.or.origin[2]); qglTranslatef (backEnd.viewParms.ori.origin[0], backEnd.viewParms.ori.origin[1], backEnd.viewParms.ori.origin[2]);
dist = backEnd.viewParms.zFar / 1.75; // div sqrt(3) dist = backEnd.viewParms.zFar / 1.75; // div sqrt(3)
size = dist * 0.4; size = dist * 0.4;
@ -806,7 +806,7 @@ void RB_StageIteratorSky( void ) {
qglPushMatrix (); qglPushMatrix ();
GL_State( 0 ); GL_State( 0 );
qglTranslatef (backEnd.viewParms.or.origin[0], backEnd.viewParms.or.origin[1], backEnd.viewParms.or.origin[2]); qglTranslatef (backEnd.viewParms.ori.origin[0], backEnd.viewParms.ori.origin[1], backEnd.viewParms.ori.origin[2]);
DrawSkyBox( tess.shader ); DrawSkyBox( tess.shader );

58
code/renderer/tr_surface.cpp
View File

@ -95,7 +95,7 @@ void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, byte *color, flo
// constant normal all the way around // constant normal all the way around
VectorSubtract( vec3_origin, backEnd.viewParms.or.axis[0], normal ); VectorSubtract( vec3_origin, backEnd.viewParms.ori.axis[0], normal );
tess.normal[ndx][0] = tess.normal[ndx+1][0] = tess.normal[ndx+2][0] = tess.normal[ndx+3][0] = normal[0]; tess.normal[ndx][0] = tess.normal[ndx+1][0] = tess.normal[ndx+2][0] = tess.normal[ndx+3][0] = normal[0];
tess.normal[ndx][1] = tess.normal[ndx+1][1] = tess.normal[ndx+2][1] = tess.normal[ndx+3][1] = normal[1]; tess.normal[ndx][1] = tess.normal[ndx+1][1] = tess.normal[ndx+2][1] = tess.normal[ndx+3][1] = normal[1];
@ -147,8 +147,8 @@ static void RB_SurfaceSprite( void ) {
// calculate the xyz locations for the four corners // calculate the xyz locations for the four corners
radius = backEnd.currentEntity->e.radius; radius = backEnd.currentEntity->e.radius;
if ( backEnd.currentEntity->e.rotation == 0 ) { if ( backEnd.currentEntity->e.rotation == 0 ) {
VectorScale( backEnd.viewParms.or.axis[1], radius, left ); VectorScale( backEnd.viewParms.ori.axis[1], radius, left );
VectorScale( backEnd.viewParms.or.axis[2], radius, up ); VectorScale( backEnd.viewParms.ori.axis[2], radius, up );
} else { } else {
float s, c; float s, c;
float ang; float ang;
@ -157,11 +157,11 @@ static void RB_SurfaceSprite( void ) {
s = sin( ang ); s = sin( ang );
c = cos( ang ); c = cos( ang );
VectorScale( backEnd.viewParms.or.axis[1], c * radius, left ); VectorScale( backEnd.viewParms.ori.axis[1], c * radius, left );
VectorMA( left, -s * radius, backEnd.viewParms.or.axis[2], left ); VectorMA( left, -s * radius, backEnd.viewParms.ori.axis[2], left );
VectorScale( backEnd.viewParms.or.axis[2], c * radius, up ); VectorScale( backEnd.viewParms.ori.axis[2], c * radius, up );
VectorMA( up, s * radius, backEnd.viewParms.or.axis[1], up ); VectorMA( up, s * radius, backEnd.viewParms.ori.axis[1], up );
} }
if ( backEnd.viewParms.isMirror ) { if ( backEnd.viewParms.isMirror ) {
VectorSubtract( vec3_origin, left, left ); VectorSubtract( vec3_origin, left, left );
@ -364,8 +364,8 @@ void RB_SurfaceLine( void )
VectorCopy( e->origin, start ); VectorCopy( e->origin, start );
// compute side vector // compute side vector
VectorSubtract( start, backEnd.viewParms.or.origin, v1 ); VectorSubtract( start, backEnd.viewParms.ori.origin, v1 );
VectorSubtract( end, backEnd.viewParms.or.origin, v2 ); VectorSubtract( end, backEnd.viewParms.ori.origin, v2 );
CrossProduct( v1, v2, right ); CrossProduct( v1, v2, right );
VectorNormalize( right ); VectorNormalize( right );
@ -404,7 +404,7 @@ static void RB_SurfaceCone( void )
VectorAdd( e->origin, e->oldorigin, midpoint ); VectorAdd( e->origin, e->oldorigin, midpoint );
VectorScale(midpoint, 0.5, midpoint); // Average start and end VectorScale(midpoint, 0.5, midpoint); // Average start and end
VectorSubtract( midpoint, backEnd.viewParms.or.origin, midpoint ); VectorSubtract( midpoint, backEnd.viewParms.ori.origin, midpoint );
length = VectorNormalize( midpoint ); length = VectorNormalize( midpoint );
// this doesn't need to be perfect....just a rough compensation for zoom level is enough // this doesn't need to be perfect....just a rough compensation for zoom level is enough
@ -536,7 +536,7 @@ static void RB_SurfaceCylinder( void )
VectorAdd( e->origin, e->oldorigin, midpoint ); VectorAdd( e->origin, e->oldorigin, midpoint );
VectorScale(midpoint, 0.5, midpoint); // Average start and end VectorScale(midpoint, 0.5, midpoint); // Average start and end
VectorSubtract( midpoint, backEnd.viewParms.or.origin, midpoint ); VectorSubtract( midpoint, backEnd.viewParms.ori.origin, midpoint );
length = VectorNormalize( midpoint ); length = VectorNormalize( midpoint );
// this doesn't need to be perfect....just a rough compensation for zoom level is enough // this doesn't need to be perfect....just a rough compensation for zoom level is enough
@ -835,8 +835,8 @@ static void RB_SurfaceElectricity()
VectorCopy( e->oldorigin, end ); VectorCopy( e->oldorigin, end );
// compute side vector // compute side vector
VectorSubtract( start, backEnd.viewParms.or.origin, v1 ); VectorSubtract( start, backEnd.viewParms.ori.origin, v1 );
VectorSubtract( end, backEnd.viewParms.or.origin, v2 ); VectorSubtract( end, backEnd.viewParms.ori.origin, v2 );
CrossProduct( v1, v2, right ); CrossProduct( v1, v2, right );
VectorNormalize( right ); VectorNormalize( right );
@ -1116,11 +1116,11 @@ static void DoSprite( vec3_t origin, float radius, float rotation )
s = sin( ang ); s = sin( ang );
c = cos( ang ); c = cos( ang );
VectorScale( backEnd.viewParms.or.axis[1], c * radius, left ); VectorScale( backEnd.viewParms.ori.axis[1], c * radius, left );
VectorMA( left, -s * radius, backEnd.viewParms.or.axis[2], left ); VectorMA( left, -s * radius, backEnd.viewParms.ori.axis[2], left );
VectorScale( backEnd.viewParms.or.axis[2], c * radius, up ); VectorScale( backEnd.viewParms.ori.axis[2], c * radius, up );
VectorMA( up, s * radius, backEnd.viewParms.or.axis[1], up ); VectorMA( up, s * radius, backEnd.viewParms.ori.axis[1], up );
if ( backEnd.viewParms.isMirror ) if ( backEnd.viewParms.isMirror )
{ {
@ -1374,15 +1374,15 @@ static float LodErrorForVolume( vec3_t local, float radius ) {
vec3_t world; vec3_t world;
float d; float d;
world[0] = local[0] * backEnd.or.axis[0][0] + local[1] * backEnd.or.axis[1][0] + world[0] = local[0] * backEnd.ori.axis[0][0] + local[1] * backEnd.ori.axis[1][0] +
local[2] * backEnd.or.axis[2][0] + backEnd.or.origin[0]; local[2] * backEnd.ori.axis[2][0] + backEnd.ori.origin[0];
world[1] = local[0] * backEnd.or.axis[0][1] + local[1] * backEnd.or.axis[1][1] + world[1] = local[0] * backEnd.ori.axis[0][1] + local[1] * backEnd.ori.axis[1][1] +
local[2] * backEnd.or.axis[2][1] + backEnd.or.origin[1]; local[2] * backEnd.ori.axis[2][1] + backEnd.ori.origin[1];
world[2] = local[0] * backEnd.or.axis[0][2] + local[1] * backEnd.or.axis[1][2] + world[2] = local[0] * backEnd.ori.axis[0][2] + local[1] * backEnd.ori.axis[1][2] +
local[2] * backEnd.or.axis[2][2] + backEnd.or.origin[2]; local[2] * backEnd.ori.axis[2][2] + backEnd.ori.origin[2];
VectorSubtract( world, backEnd.viewParms.or.origin, world ); VectorSubtract( world, backEnd.viewParms.ori.origin, world );
d = DotProduct( world, backEnd.viewParms.or.axis[0] ); d = DotProduct( world, backEnd.viewParms.ori.axis[0] );
if ( d < 0 ) { if ( d < 0 ) {
d = -d; d = -d;
@ -1983,7 +1983,7 @@ qboolean RB_TestZFlare( vec3_t point, vec3_t color, vec3_t normal) {
// if the point is off the screen, don't bother adding it // if the point is off the screen, don't bother adding it
// calculate screen coordinates and depth // calculate screen coordinates and depth
R_TransformModelToClip( point, backEnd.or.modelMatrix, R_TransformModelToClip( point, backEnd.ori.modelMatrix,
backEnd.viewParms.projectionMatrix, eye, clip ); backEnd.viewParms.projectionMatrix, eye, clip );
// check to see if the point is completely off screen // check to see if the point is completely off screen
@ -2038,15 +2038,15 @@ void RB_SurfaceFlare( srfFlare_t *surf ) {
// calculate the xyz locations for the four corners // calculate the xyz locations for the four corners
radius = r_flareSize->value; radius = r_flareSize->value;
VectorScale( backEnd.viewParms.or.axis[1], radius, left ); VectorScale( backEnd.viewParms.ori.axis[1], radius, left );
VectorScale( backEnd.viewParms.or.axis[2], radius, up ); VectorScale( backEnd.viewParms.ori.axis[2], radius, up );
if ( backEnd.viewParms.isMirror ) { if ( backEnd.viewParms.isMirror ) {
VectorSubtract( vec3_origin, left, left ); VectorSubtract( vec3_origin, left, left );
} }
VectorMA( surf->origin, 3, surf->normal, origin ); VectorMA( surf->origin, 3, surf->normal, origin );
VectorSubtract( origin, backEnd.viewParms.or.origin, dir ); VectorSubtract( origin, backEnd.viewParms.ori.origin, dir );
VectorNormalize( dir ); VectorNormalize( dir );
d = -DotProduct( dir, surf->normal ); d = -DotProduct( dir, surf->normal );

18
code/renderer/tr_surfacesprites.cpp
View File

@ -1429,18 +1429,18 @@ void RB_DrawSurfaceSprites( shaderStage_t *stage, shaderCommands_t *input)
{ {
if (backEnd.currentEntity == &tr.worldEntity) if (backEnd.currentEntity == &tr.worldEntity)
{ // Drawing the world, so our job is dead-easy, in the viewparms { // Drawing the world, so our job is dead-easy, in the viewparms
VectorCopy(backEnd.viewParms.or.origin, ssViewOrigin); VectorCopy(backEnd.viewParms.ori.origin, ssViewOrigin);
VectorCopy(backEnd.viewParms.or.axis[1], ssViewRight); VectorCopy(backEnd.viewParms.ori.axis[1], ssViewRight);
VectorCopy(backEnd.viewParms.or.axis[2], ssViewUp); VectorCopy(backEnd.viewParms.ori.axis[2], ssViewUp);
} }
else else
{ // Drawing an entity, so we need to transform the viewparms to the model's coordinate system { // Drawing an entity, so we need to transform the viewparms to the model's coordinate system
// R_WorldPointToEntity (backEnd.viewParms.or.origin, ssViewOrigin); // R_WorldPointToEntity (backEnd.viewParms.ori.origin, ssViewOrigin);
R_WorldNormalToEntity (backEnd.viewParms.or.axis[1], ssViewRight); R_WorldNormalToEntity (backEnd.viewParms.ori.axis[1], ssViewRight);
R_WorldNormalToEntity (backEnd.viewParms.or.axis[2], ssViewUp); R_WorldNormalToEntity (backEnd.viewParms.ori.axis[2], ssViewUp);
VectorCopy(backEnd.or.viewOrigin, ssViewOrigin); VectorCopy(backEnd.ori.viewOrigin, ssViewOrigin);
// R_WorldToLocal(backEnd.viewParms.or.axis[1], ssViewRight); // R_WorldToLocal(backEnd.viewParms.ori.axis[1], ssViewRight);
// R_WorldToLocal(backEnd.viewParms.or.axis[2], ssViewUp); // R_WorldToLocal(backEnd.viewParms.ori.axis[2], ssViewUp);
} }
ssLastEntityDrawn = backEnd.currentEntity; ssLastEntityDrawn = backEnd.currentEntity;
} }

2
code/renderer/tr_world.cpp
View File

@ -125,7 +125,7 @@ static qboolean R_CullSurface( surfaceType_t *surface, shader_t *shader ) {
} }
sface = ( srfSurfaceFace_t * ) surface; sface = ( srfSurfaceFace_t * ) surface;
d = DotProduct (tr.or.viewOrigin, sface->plane.normal); d = DotProduct (tr.ori.viewOrigin, sface->plane.normal);
// don't cull exactly on the plane, because there are levels of rounding // don't cull exactly on the plane, because there are levels of rounding
// through the BSP, ICD, and hardware that may cause pixel gaps if an // through the BSP, ICD, and hardware that may cause pixel gaps if an

22
code/renderer/tr_worldeffects.cpp
View File

@ -489,8 +489,8 @@ void CMistyFog::Update(CWorldEffectsSystem *system, float elapseTime)
// translate // translate
forwardWind = DotProduct(mWindTransform, backEnd.viewParms.or.axis[0]); forwardWind = DotProduct(mWindTransform, backEnd.viewParms.ori.axis[0]);
rightWind = DotProduct(mWindTransform, backEnd.viewParms.or.axis[1]); rightWind = DotProduct(mWindTransform, backEnd.viewParms.ori.axis[1]);
mTextureCoords[0][0] += rightWind / mSpeed; mTextureCoords[0][0] += rightWind / mSpeed;
mTextureCoords[1][0] += rightWind / mSpeed; mTextureCoords[1][0] += rightWind / mSpeed;
@ -640,8 +640,8 @@ void CMistyFog::CreateTextureCoords(void)
mSpeed = 800.0 + FloatRand() * 2000.0; mSpeed = 800.0 + FloatRand() * 2000.0;
mSpeed /= 4.0; mSpeed /= 4.0;
forwardWind = DotProduct(mWindTransform, backEnd.viewParms.or.axis[0]); forwardWind = DotProduct(mWindTransform, backEnd.viewParms.ori.axis[0]);
rightWind = DotProduct(mWindTransform, backEnd.viewParms.or.axis[1]); rightWind = DotProduct(mWindTransform, backEnd.viewParms.ori.axis[1]);
if (forwardWind > 0.5) if (forwardWind > 0.5)
{ // moving away, so make the size smaller { // moving away, so make the size smaller
@ -1063,7 +1063,7 @@ void CWind::Update(CWorldEffectsSystem *system, float elapseTime)
return; return;
} }
VectorSubtract(backEnd.viewParms.or.origin, mPoint, difference); VectorSubtract(backEnd.viewParms.ori.origin, mPoint, difference);
if (VectorLength(difference) > 300.0) if (VectorLength(difference) > 300.0)
{ {
return; return;
@ -1497,7 +1497,7 @@ void CSnowSystem::Update(float elapseTime)
CWorldEffectsSystem::Update(elapseTime); CWorldEffectsSystem::Update(elapseTime);
} }
VectorCopy(backEnd.viewParms.or.origin, origin); VectorCopy(backEnd.viewParms.ori.origin, origin);
mNextWindGust -= elapseTime; mNextWindGust -= elapseTime;
if (mNextWindGust < 0.0) if (mNextWindGust < 0.0)
@ -1733,7 +1733,7 @@ void CSnowSystem::Render(void)
CWorldEffectsSystem::Render(); CWorldEffectsSystem::Render();
VectorAdd(backEnd.viewParms.or.origin, mMinSpread, origin); VectorAdd(backEnd.viewParms.ori.origin, mMinSpread, origin);
qglColor4f(0.8f, 0.8f, 0.8f, mAlpha); qglColor4f(0.8f, 0.8f, 0.8f, mAlpha);
@ -2068,8 +2068,8 @@ void CRainSystem::Render(void)
return; return;
} }
VectorScale(backEnd.viewParms.or.axis[0], 1, forward); // forward VectorScale(backEnd.viewParms.ori.axis[0], 1, forward); // forward
VectorScale(backEnd.viewParms.or.axis[1], 0.2f, left); // left VectorScale(backEnd.viewParms.ori.axis[1], 0.2f, left); // left
down[0] = 0 - mWindDirection[0] * mRainHeight * mWindAngle; down[0] = 0 - mWindDirection[0] * mRainHeight * mWindAngle;
down[1] = 0 - mWindDirection[1] * mRainHeight * mWindAngle; down[1] = 0 - mWindDirection[1] * mRainHeight * mWindAngle;
down[2] = -mRainHeight; down[2] = -mRainHeight;
@ -2082,7 +2082,7 @@ void CRainSystem::Render(void)
qglMatrixMode(GL_MODELVIEW); qglMatrixMode(GL_MODELVIEW);
qglPushMatrix(); qglPushMatrix();
qglTranslatef (backEnd.viewParms.or.origin[0], backEnd.viewParms.or.origin[1], backEnd.viewParms.or.origin[2]); qglTranslatef (backEnd.viewParms.ori.origin[0], backEnd.viewParms.ori.origin[1], backEnd.viewParms.ori.origin[2]);
item = mRainList; item = mRainList;
qglBegin(GL_TRIANGLES ); qglBegin(GL_TRIANGLES );
@ -2194,7 +2194,7 @@ void RB_RenderWorldEffects(void)
// qglPushMatrix(); // qglPushMatrix();
qglLoadMatrixf( backEnd.viewParms.world.modelMatrix ); qglLoadMatrixf( backEnd.viewParms.world.modelMatrix );
originContents = ri.CM_PointContents(backEnd.viewParms.or.origin, 0); originContents = ri.CM_PointContents(backEnd.viewParms.ori.origin, 0);
if (rainSystem) if (rainSystem)
{ {