mirror of
https://github.com/openmoh/openmohaa.git
synced 2025-04-28 13:47:58 +03:00
28bdd1b2b3
This removes coupling between the renderer and UI/client functions. An option USE_RENDERER_DLOPEN was added to specify whether a renderer module should be compiled and loaded, instead of integrating the renderer into the executable directly. This opens the door for a new renderer
914 lines
20 KiB
C
914 lines
20 KiB
C
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
Quake III Arena source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Foobar; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
#include "tr_local.h"
|
|
|
|
|
|
|
|
/*
|
|
=================
|
|
R_CullTriSurf
|
|
|
|
Returns true if the grid is completely culled away.
|
|
Also sets the clipped hint bit in tess
|
|
=================
|
|
*/
|
|
static qboolean R_CullTriSurf( srfTriangles_t *cv ) {
|
|
int boxCull;
|
|
|
|
boxCull = R_CullLocalBox( cv->bounds );
|
|
|
|
if ( boxCull == CULL_OUT ) {
|
|
return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_CullGrid
|
|
|
|
Returns true if the grid is completely culled away.
|
|
Also sets the clipped hint bit in tess
|
|
=================
|
|
*/
|
|
static qboolean R_CullGrid( srfGridMesh_t *cv ) {
|
|
int boxCull;
|
|
int sphereCull;
|
|
|
|
if ( r_nocurves->integer ) {
|
|
return qtrue;
|
|
}
|
|
|
|
if (!tr.refdef.render_terrain) {
|
|
return qtrue;
|
|
}
|
|
|
|
if ( tr.currentEntityNum != ENTITYNUM_WORLD ) {
|
|
sphereCull = R_CullLocalPointAndRadius( cv->localOrigin, cv->meshRadius );
|
|
} else {
|
|
sphereCull = R_CullPointAndRadius( cv->localOrigin, cv->meshRadius );
|
|
}
|
|
boxCull = CULL_OUT;
|
|
|
|
// check for trivial reject
|
|
if ( sphereCull == CULL_OUT )
|
|
{
|
|
tr.pc.c_sphere_cull_patch_out++;
|
|
return qtrue;
|
|
}
|
|
// check bounding box if necessary
|
|
else if ( sphereCull == CULL_CLIP )
|
|
{
|
|
tr.pc.c_sphere_cull_patch_clip++;
|
|
|
|
boxCull = R_CullLocalBox( cv->meshBounds );
|
|
|
|
if ( boxCull == CULL_OUT )
|
|
{
|
|
tr.pc.c_box_cull_patch_out++;
|
|
return qtrue;
|
|
}
|
|
else if ( boxCull == CULL_IN )
|
|
{
|
|
tr.pc.c_box_cull_patch_in++;
|
|
}
|
|
else
|
|
{
|
|
tr.pc.c_box_cull_patch_clip++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tr.pc.c_sphere_cull_patch_in++;
|
|
}
|
|
|
|
return qfalse;
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
R_CullSurface
|
|
|
|
Tries to back face cull surfaces before they are lighted or
|
|
added to the sorting list.
|
|
|
|
This will also allow mirrors on both sides of a model without recursion.
|
|
================
|
|
*/
|
|
static qboolean R_CullSurface( surfaceType_t *surface, shader_t *shader ) {
|
|
srfSurfaceFace_t *sface;
|
|
float d;
|
|
|
|
if ( r_nocull->integer ) {
|
|
return qfalse;
|
|
}
|
|
|
|
if ( *surface == SF_GRID ) {
|
|
return R_CullGrid( (srfGridMesh_t *)surface );
|
|
}
|
|
|
|
if ( *surface == SF_TRIANGLES ) {
|
|
return R_CullTriSurf( (srfTriangles_t *)surface );
|
|
}
|
|
|
|
if ( *surface != SF_FACE ) {
|
|
return qfalse;
|
|
}
|
|
|
|
if ( shader->cullType == CT_TWO_SIDED ) {
|
|
return qfalse;
|
|
}
|
|
|
|
// face culling
|
|
if ( !r_facePlaneCull->integer ) {
|
|
return qfalse;
|
|
}
|
|
|
|
sface = ( srfSurfaceFace_t * ) surface;
|
|
d = DotProduct (tr.ori.viewOrigin, sface->plane.normal);
|
|
|
|
// 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
|
|
// epsilon isn't allowed here
|
|
if ( shader->cullType == CT_FRONT_SIDED ) {
|
|
if ( d < sface->plane.dist - 8 ) {
|
|
return qtrue;
|
|
}
|
|
} else {
|
|
if ( d > sface->plane.dist + 8 ) {
|
|
return qtrue;
|
|
}
|
|
}
|
|
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
======================
|
|
R_FastDlightFace
|
|
======================
|
|
*/
|
|
static int R_FastDlightFace( srfSurfaceFace_t *face, int dlightBits ) {
|
|
float d;
|
|
int i;
|
|
dlight_t *dl;
|
|
|
|
for ( i = 0 ; i < tr.refdef.num_dlights ; i++ ) {
|
|
if ( ! ( dlightBits & ( 1 << i ) ) ) {
|
|
continue;
|
|
}
|
|
dl = &tr.refdef.dlights[i];
|
|
d = DotProduct( dl->transformed, face->plane.normal ) - face->plane.dist;
|
|
if ( d < -dl->radius || d > dl->radius ) {
|
|
// dlight doesn't reach the plane
|
|
dlightBits &= ~( 1 << i );
|
|
}
|
|
}
|
|
|
|
if ( !dlightBits ) {
|
|
tr.pc.c_dlightSurfacesCulled++;
|
|
}
|
|
|
|
face->dlightBits[ tr.smpFrame ] = dlightBits;
|
|
return dlightBits;
|
|
}
|
|
|
|
/*
|
|
======================
|
|
R_FastDlightGrid
|
|
======================
|
|
*/
|
|
static int R_FastDlightGrid( srfGridMesh_t *grid, int dlightBits ) {
|
|
int i;
|
|
dlight_t *dl;
|
|
|
|
for ( i = 0 ; i < tr.refdef.num_dlights ; i++ ) {
|
|
if ( ! ( dlightBits & ( 1 << i ) ) ) {
|
|
continue;
|
|
}
|
|
dl = &tr.refdef.dlights[i];
|
|
if ( dl->origin[0] - dl->radius > grid->meshBounds[1][0]
|
|
|| dl->origin[0] + dl->radius < grid->meshBounds[0][0]
|
|
|| dl->origin[1] - dl->radius > grid->meshBounds[1][1]
|
|
|| dl->origin[1] + dl->radius < grid->meshBounds[0][1]
|
|
|| dl->origin[2] - dl->radius > grid->meshBounds[1][2]
|
|
|| dl->origin[2] + dl->radius < grid->meshBounds[0][2] ) {
|
|
// dlight doesn't reach the bounds
|
|
dlightBits &= ~( 1 << i );
|
|
}
|
|
}
|
|
|
|
if ( !dlightBits ) {
|
|
tr.pc.c_dlightSurfacesCulled++;
|
|
}
|
|
|
|
grid->dlightBits[ tr.smpFrame ] = dlightBits;
|
|
return dlightBits;
|
|
}
|
|
|
|
/*
|
|
======================
|
|
R_FastDlightTerrain
|
|
======================
|
|
*/
|
|
static int R_FastDlightTerrain(cTerraPatchUnpacked_t* srf, int dlightBits) {
|
|
dlight_t* dl;
|
|
float* origin;
|
|
int i;
|
|
|
|
for (i = 0; i < tr.refdef.num_dlights; i++) {
|
|
dl = &tr.refdef.dlights[i];
|
|
origin = dl->transformed;
|
|
|
|
if (srf->x0 - origin[0] > dl->radius
|
|
|| srf->x0 - origin[0] < -512.0 - dl->radius
|
|
|| srf->y0 - origin[1] > dl->radius
|
|
|| srf->y0 - origin[1] < -512.0 - dl->radius
|
|
|| srf->z0 - origin[2] > dl->radius
|
|
|| srf->z0 - origin[2] < -srf->zmax - dl->radius
|
|
) {
|
|
// dlight doesn't reach the bounds
|
|
dlightBits &= ~(1 << i);
|
|
}
|
|
}
|
|
|
|
if (!dlightBits) {
|
|
tr.pc.c_dlightSurfacesCulled++;
|
|
}
|
|
|
|
srf->drawinfo.dlightBits[tr.smpFrame] = dlightBits;
|
|
return dlightBits;
|
|
}
|
|
|
|
/*
|
|
======================
|
|
R_DlightTrisurf
|
|
======================
|
|
*/
|
|
static int R_DlightTrisurf( srfTriangles_t *surf, int dlightBits ) {
|
|
// FIXME: more dlight culling to trisurfs...
|
|
surf->dlightBits[ tr.smpFrame ] = dlightBits;
|
|
return dlightBits;
|
|
#if 0
|
|
int i;
|
|
dlight_t *dl;
|
|
|
|
for ( i = 0 ; i < tr.refdef.num_dlights ; i++ ) {
|
|
if ( ! ( dlightBits & ( 1 << i ) ) ) {
|
|
continue;
|
|
}
|
|
dl = &tr.refdef.dlights[i];
|
|
if ( dl->origin[0] - dl->radius > grid->meshBounds[1][0]
|
|
|| dl->origin[0] + dl->radius < grid->meshBounds[0][0]
|
|
|| dl->origin[1] - dl->radius > grid->meshBounds[1][1]
|
|
|| dl->origin[1] + dl->radius < grid->meshBounds[0][1]
|
|
|| dl->origin[2] - dl->radius > grid->meshBounds[1][2]
|
|
|| dl->origin[2] + dl->radius < grid->meshBounds[0][2] ) {
|
|
// dlight doesn't reach the bounds
|
|
dlightBits &= ~( 1 << i );
|
|
}
|
|
}
|
|
|
|
if ( !dlightBits ) {
|
|
tr.pc.c_dlightSurfacesCulled++;
|
|
}
|
|
|
|
grid->dlightBits[ tr.smpFrame ] = dlightBits;
|
|
return dlightBits;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
====================
|
|
R_DlightSurface
|
|
|
|
The given surface is going to be drawn, and it touches a leaf
|
|
that is touched by one or more dlights, so try to throw out
|
|
more dlights if possible.
|
|
====================
|
|
*/
|
|
static int R_DlightSurface( msurface_t *surf, int dlightBits ) {
|
|
int dlightMap;
|
|
|
|
dlightMap = 0;
|
|
|
|
if ( *surf->data == SF_FACE ) {
|
|
if (!r_fastdlights->integer) {
|
|
if (surf->shader->lightmapIndex >= 0) {
|
|
dlightMap = R_RealDlightFace((srfSurfaceFace_t*)surf->data, dlightBits);
|
|
} else {
|
|
((srfSurfaceFace_t*)surf->data)->dlightMap[tr.smpFrame] = 0;
|
|
dlightMap = 0;
|
|
}
|
|
return dlightMap;
|
|
} else {
|
|
dlightBits = R_FastDlightFace((srfSurfaceFace_t*)surf->data, dlightBits);
|
|
}
|
|
} else if ( *surf->data == SF_GRID ) {
|
|
if (!r_fastdlights->integer) {
|
|
if (surf->shader->lightmapIndex >= 0) {
|
|
dlightMap = R_RealDlightPatch((srfGridMesh_t*)surf->data, dlightBits);
|
|
} else {
|
|
((srfGridMesh_t*)surf->data)->dlightMap[tr.smpFrame] = 0.f;
|
|
dlightMap = 0;
|
|
}
|
|
return dlightMap;
|
|
} else {
|
|
dlightBits = R_FastDlightGrid((srfGridMesh_t*)surf->data, dlightBits);
|
|
}
|
|
} else {
|
|
return dlightMap;
|
|
}
|
|
|
|
if (dlightBits) {
|
|
tr.pc.c_dlightSurfaces++;
|
|
return 1;
|
|
}
|
|
|
|
return dlightMap;
|
|
}
|
|
|
|
/*
|
|
======================
|
|
R_DlightTerrain
|
|
======================
|
|
*/
|
|
int R_DlightTerrain(cTerraPatchUnpacked_t* surf, int dlightBits)
|
|
{
|
|
int dlightMap;
|
|
|
|
dlightMap = 0;
|
|
|
|
if (r_fastdlights->integer)
|
|
{
|
|
if (R_FastDlightTerrain(surf, dlightBits)) {
|
|
++tr.pc.c_dlightSurfaces;
|
|
dlightMap = 1;
|
|
}
|
|
} else if (surf->shader->lightmapIndex < 0) {
|
|
surf->drawinfo.dlightMap[tr.smpFrame] = 0;
|
|
} else {
|
|
dlightMap = R_RealDlightTerrain(surf, dlightBits);
|
|
}
|
|
|
|
return dlightMap;
|
|
}
|
|
|
|
/*
|
|
======================
|
|
R_CheckDlightSurface
|
|
======================
|
|
*/
|
|
static int R_CheckDlightSurface(msurface_t* surf, int dlightBits)
|
|
{
|
|
if (dlightBits && surf->frameCount != tr.frameCount)
|
|
{
|
|
surf->frameCount = tr.frameCount;
|
|
return R_DlightSurface(surf, dlightBits);
|
|
}
|
|
|
|
if (dlightBits)
|
|
{
|
|
//
|
|
// Added in 2.0
|
|
// Return the existing dlight map
|
|
if (*surf->data == SF_FACE)
|
|
{
|
|
return ((srfSurfaceFace_t*)surf->data)->dlightMap[tr.smpFrame];
|
|
}
|
|
else if (*surf->data == SF_GRID)
|
|
{
|
|
return ((srfGridMesh_t*)surf->data)->dlightMap[tr.smpFrame];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (*surf->data == SF_FACE)
|
|
{
|
|
((srfSurfaceFace_t*)surf->data)->dlightMap[tr.smpFrame] = 0;
|
|
((srfSurfaceFace_t*)surf->data)->dlightBits[tr.smpFrame] = 0;
|
|
}
|
|
else if (*surf->data == SF_GRID)
|
|
{
|
|
((srfGridMesh_t*)surf->data)->dlightMap[tr.smpFrame] = 0;
|
|
((srfGridMesh_t*)surf->data)->dlightBits[tr.smpFrame] = 0;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
======================
|
|
R_CheckDlightTerrain
|
|
======================
|
|
*/
|
|
int R_CheckDlightTerrain(cTerraPatchUnpacked_t* surf, int dlightBits)
|
|
{
|
|
if (surf->frameCount == tr.frameCount) {
|
|
return surf->drawinfo.dlightMap[tr.smpFrame];
|
|
}
|
|
|
|
surf->frameCount = tr.frameCount;
|
|
if (dlightBits) {
|
|
return R_DlightTerrain(surf, dlightBits);
|
|
}
|
|
|
|
surf->drawinfo.dlightMap[tr.smpFrame] = 0;
|
|
surf->drawinfo.dlightBits[tr.smpFrame] = 0;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
======================
|
|
R_AddWorldSurface
|
|
======================
|
|
*/
|
|
static void R_AddWorldSurface( msurface_t *surf, int dlightBits ) {
|
|
//if ( surf->viewCount == tr.viewCount ) {
|
|
// return; // already in this view
|
|
//}
|
|
|
|
surf->viewCount = tr.viewCount;
|
|
// FIXME: bmodel fog?
|
|
|
|
// try to cull before dlighting or adding
|
|
if ( R_CullSurface( surf->data, surf->shader ) ) {
|
|
return;
|
|
}
|
|
|
|
// check for dlighting
|
|
dlightBits = R_CheckDlightSurface(surf, dlightBits);
|
|
if (surf->shader && surf->shader->isPortalSky) {
|
|
// Sky portal
|
|
R_Sky_AddSurf(surf);
|
|
return;
|
|
}
|
|
|
|
R_AddDrawSurf( surf->data, surf->shader, dlightBits );
|
|
}
|
|
|
|
/*
|
|
=============================================================
|
|
|
|
BRUSH MODELS
|
|
|
|
=============================================================
|
|
*/
|
|
|
|
/*
|
|
=================
|
|
R_AddBrushModelSurfaces
|
|
=================
|
|
*/
|
|
void R_AddBrushModelSurfaces ( trRefEntity_t *ent ) {
|
|
bmodel_t *bmodel;
|
|
int clip;
|
|
model_t *pModel;
|
|
int i;
|
|
|
|
pModel = R_GetModelByHandle( ent->e.hModel );
|
|
|
|
bmodel = pModel->d.bmodel;
|
|
|
|
clip = R_CullLocalBox( bmodel->bounds );
|
|
if ( clip == CULL_OUT ) {
|
|
return;
|
|
}
|
|
|
|
R_DlightBmodel( bmodel );
|
|
|
|
for ( i = 0 ; i < bmodel->numSurfaces ; i++ ) {
|
|
R_AddWorldSurface( bmodel->firstSurface + i, tr.currentEntity->needDlights );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=============================================================
|
|
|
|
WORLD MODEL
|
|
|
|
=============================================================
|
|
*/
|
|
|
|
void R_GetInlineModelBounds(int iIndex, vec3_t vMins, vec3_t vMaxs)
|
|
{
|
|
bmodel_t* bmodel;
|
|
|
|
bmodel = &tr.world->bmodels[iIndex];
|
|
VectorCopy(bmodel->bounds[0], vMins);
|
|
VectorCopy(bmodel->bounds[1], vMaxs);
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
R_RecursiveWorldNode
|
|
================
|
|
*/
|
|
static void R_RecursiveWorldNode( mnode_t *node, int planeBits, int dlightBits ) {
|
|
|
|
do {
|
|
// if the node wasn't marked as potentially visible, exit
|
|
if (node->visframe != tr.visCount) {
|
|
return;
|
|
}
|
|
|
|
// if the bounding volume is outside the frustum, nothing
|
|
// inside can be visible OPTIMIZE: don't do this all the way to leafs?
|
|
|
|
if ( !r_nocull->integer ) {
|
|
int r;
|
|
|
|
if (planeBits & 1) {
|
|
r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[0]);
|
|
if (r == 2) {
|
|
return; // culled
|
|
}
|
|
if (r == 1) {
|
|
planeBits &= ~1; // all descendants will also be in front
|
|
}
|
|
}
|
|
|
|
if (planeBits & 2) {
|
|
r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[1]);
|
|
if (r == 2) {
|
|
return; // culled
|
|
}
|
|
if (r == 1) {
|
|
planeBits &= ~2; // all descendants will also be in front
|
|
}
|
|
}
|
|
|
|
if (planeBits & 4) {
|
|
r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[2]);
|
|
if (r == 2) {
|
|
return; // culled
|
|
}
|
|
if (r == 1) {
|
|
planeBits &= ~4; // all descendants will also be in front
|
|
}
|
|
}
|
|
|
|
if (planeBits & 8) {
|
|
r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[3]);
|
|
if (r == 2) {
|
|
return; // culled
|
|
}
|
|
if (r == 1) {
|
|
planeBits &= ~8; // all descendants will also be in front
|
|
}
|
|
}
|
|
|
|
if (planeBits & 16) {
|
|
r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[4]);
|
|
if (r == 2) {
|
|
return; // culled
|
|
}
|
|
if (r == 1) {
|
|
planeBits &= ~16; // all descendants will also be in front
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if ( node->contents != -1 ) {
|
|
break;
|
|
}
|
|
|
|
// recurse down the children, front side first
|
|
R_RecursiveWorldNode (node->children[0], planeBits, dlightBits);
|
|
|
|
// tail recurse
|
|
node = node->children[1];
|
|
} while ( 1 );
|
|
|
|
{
|
|
// leaf node, so add mark surfaces
|
|
int c;
|
|
msurface_t *surf, **mark;
|
|
|
|
tr.pc.c_leafs++;
|
|
|
|
// add to z buffer bounds
|
|
if ( node->mins[0] < tr.viewParms.visBounds[0][0] ) {
|
|
tr.viewParms.visBounds[0][0] = node->mins[0];
|
|
}
|
|
if ( node->mins[1] < tr.viewParms.visBounds[0][1] ) {
|
|
tr.viewParms.visBounds[0][1] = node->mins[1];
|
|
}
|
|
if ( node->mins[2] < tr.viewParms.visBounds[0][2] ) {
|
|
tr.viewParms.visBounds[0][2] = node->mins[2];
|
|
}
|
|
|
|
if ( node->maxs[0] > tr.viewParms.visBounds[1][0] ) {
|
|
tr.viewParms.visBounds[1][0] = node->maxs[0];
|
|
}
|
|
if ( node->maxs[1] > tr.viewParms.visBounds[1][1] ) {
|
|
tr.viewParms.visBounds[1][1] = node->maxs[1];
|
|
}
|
|
if ( node->maxs[2] > tr.viewParms.visBounds[1][2] ) {
|
|
tr.viewParms.visBounds[1][2] = node->maxs[2];
|
|
}
|
|
|
|
tr.portalsky.cntNode = node;
|
|
|
|
if (r_drawbrushes->integer) {
|
|
// add the individual surfaces
|
|
mark = node->firstmarksurface;
|
|
c = node->nummarksurfaces;
|
|
while (c--) {
|
|
// the surface may have already been added if it
|
|
// spans multiple leafs
|
|
surf = *mark;
|
|
if (surf->viewCount != tr.viewCount) {
|
|
R_AddWorldSurface(surf, dlightBits);
|
|
}
|
|
mark++;
|
|
}
|
|
}
|
|
|
|
if (r_drawterrain->integer && tr.refdef.render_terrain && !tr.viewParms.isPortalSky)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < node->numTerraPatches; i++) {
|
|
R_MarkTerrainPatch(tr.world->visTerraPatches[node->firstTerraPatch + i]);
|
|
}
|
|
}
|
|
|
|
if (r_drawstaticdecals->integer) {
|
|
if (node->pFirstMarkFragment) {
|
|
R_AddPermanentMarkFragmentSurfaces(node->pFirstMarkFragment, node->iNumMarkFragment);
|
|
}
|
|
}
|
|
|
|
if (r_drawstaticmodels->integer) {
|
|
int i;
|
|
|
|
for (i = 0; i < node->numStaticModels; i++) {
|
|
tr.world->visStaticModels[node->firstStaticModel + i]->visCount = tr.visCount;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
int R_SphereInLeafs(const vec3_t p, float r, mnode_t** nodes, int nMaxNodes) {
|
|
mnode_t* nodestack[1024];
|
|
int iNodeStackPos;
|
|
mnode_t* pCurNode;
|
|
int nFoundNodes;
|
|
|
|
iNodeStackPos = 0;
|
|
pCurNode = tr.world->nodes;
|
|
nFoundNodes = 0;
|
|
|
|
while (1)
|
|
{
|
|
cplane_t* plane;
|
|
float d;
|
|
|
|
while (pCurNode->contents == -1)
|
|
{
|
|
plane = pCurNode->plane;
|
|
if (plane->type >= PLANE_NON_AXIAL) {
|
|
d = DotProduct(p, plane->normal) - plane->dist;
|
|
} else {
|
|
d = p[plane->type] - plane->dist;
|
|
}
|
|
|
|
if (d < r) {
|
|
if (d > -r) {
|
|
nodestack[iNodeStackPos++] = pCurNode->children[0];
|
|
}
|
|
pCurNode = pCurNode->children[1];
|
|
} else {
|
|
pCurNode = pCurNode->children[0];
|
|
}
|
|
}
|
|
|
|
nodes[nFoundNodes++] = pCurNode;
|
|
if (!iNodeStackPos || nFoundNodes == nMaxNodes) {
|
|
break;
|
|
}
|
|
|
|
iNodeStackPos--;
|
|
pCurNode = nodestack[iNodeStackPos];
|
|
}
|
|
|
|
return nFoundNodes;
|
|
}
|
|
/*
|
|
===============
|
|
R_PointInLeaf
|
|
===============
|
|
*/
|
|
mnode_t *R_PointInLeaf( const vec3_t p ) {
|
|
mnode_t *node;
|
|
float d;
|
|
cplane_t *plane;
|
|
|
|
if ( !tr.world ) {
|
|
ri.Error (ERR_DROP, "R_PointInLeaf: bad model");
|
|
}
|
|
|
|
node = tr.world->nodes;
|
|
while( 1 ) {
|
|
if (node->contents != -1) {
|
|
break;
|
|
}
|
|
plane = node->plane;
|
|
d = DotProduct (p,plane->normal) - plane->dist;
|
|
if (d > 0) {
|
|
node = node->children[0];
|
|
} else {
|
|
node = node->children[1];
|
|
}
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
R_ClusterPVS
|
|
==============
|
|
*/
|
|
static const byte *R_ClusterPVS (int cluster) {
|
|
if (!tr.world || !tr.world->vis || cluster < 0 || cluster >= tr.world->numClusters ) {
|
|
return tr.world->novis;
|
|
}
|
|
|
|
return tr.world->vis + cluster * tr.world->clusterBytes;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_inPVS
|
|
=================
|
|
*/
|
|
qboolean R_inPVS( const vec3_t p1, const vec3_t p2 ) {
|
|
mnode_t *leaf;
|
|
byte *vis;
|
|
|
|
leaf = R_PointInLeaf( p1 );
|
|
vis = ri.CM_ClusterPVS( leaf->cluster );
|
|
leaf = R_PointInLeaf( p2 );
|
|
|
|
if ( !(vis[leaf->cluster>>3] & (1<<(leaf->cluster&7))) ) {
|
|
return qfalse;
|
|
}
|
|
return qtrue;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
R_MarkLeaves
|
|
|
|
Mark the leaves and nodes that are in the PVS for the current
|
|
cluster
|
|
===============
|
|
*/
|
|
static void R_MarkLeaves (void) {
|
|
const byte *vis;
|
|
mnode_t *leaf, *parent;
|
|
int i;
|
|
int cluster;
|
|
|
|
// lockpvs lets designers walk around to determine the
|
|
// extent of the current pvs
|
|
if ( r_lockpvs->integer ) {
|
|
return;
|
|
}
|
|
|
|
// current viewcluster
|
|
leaf = R_PointInLeaf( tr.viewParms.pvsOrigin );
|
|
cluster = leaf->cluster;
|
|
|
|
// if the cluster is the same and the area visibility matrix
|
|
// hasn't changed, we don't need to mark everything again
|
|
|
|
// if r_showcluster was just turned on, remark everything
|
|
if ( tr.viewCluster == cluster && !tr.refdef.areamaskModified
|
|
&& !r_showcluster->modified ) {
|
|
return;
|
|
}
|
|
|
|
if ( r_showcluster->modified || r_showcluster->integer ) {
|
|
r_showcluster->modified = qfalse;
|
|
if ( r_showcluster->integer ) {
|
|
ri.Printf( PRINT_ALL, "cluster:%i area:%i\n", cluster, leaf->area );
|
|
}
|
|
}
|
|
|
|
tr.visCount++;
|
|
tr.viewCluster = cluster;
|
|
|
|
if ( r_novis->integer || tr.viewCluster == -1 ) {
|
|
for (i=0 ; i<tr.world->numnodes ; i++) {
|
|
if (tr.world->nodes[i].contents != CONTENTS_SOLID) {
|
|
tr.world->nodes[i].visframe = tr.visCount;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
vis = R_ClusterPVS (tr.viewCluster);
|
|
|
|
for (i=0,leaf=tr.world->nodes ; i<tr.world->numnodes ; i++, leaf++) {
|
|
cluster = leaf->cluster;
|
|
if ( cluster < 0 || cluster >= tr.world->numClusters ) {
|
|
continue;
|
|
}
|
|
|
|
// check general pvs
|
|
if ( !(vis[cluster>>3] & (1<<(cluster&7))) ) {
|
|
continue;
|
|
}
|
|
|
|
// check for door connection
|
|
if ( (tr.refdef.areamask[leaf->area>>3] & (1<<(leaf->area&7)) ) ) {
|
|
continue; // not visible
|
|
}
|
|
|
|
parent = leaf;
|
|
do {
|
|
if (parent->visframe == tr.visCount)
|
|
break;
|
|
parent->visframe = tr.visCount;
|
|
parent = parent->parent;
|
|
} while (parent);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
R_AddWorldSurfaces
|
|
=============
|
|
*/
|
|
void R_AddWorldSurfaces (void) {
|
|
if (!r_drawworld->integer) {
|
|
return;
|
|
}
|
|
|
|
if (tr.refdef.rdflags & RDF_NOWORLDMODEL) {
|
|
return;
|
|
}
|
|
|
|
tr.currentEntityNum = ENTITYNUM_WORLD;
|
|
tr.shiftedEntityNum = tr.currentEntityNum << QSORT_ENTITYNUM_SHIFT;
|
|
|
|
if (r_drawterrain->integer && tr.refdef.render_terrain && !tr.viewParms.isPortalSky) {
|
|
R_TerrainPrepareFrame();
|
|
}
|
|
|
|
// determine which leaves are in the PVS / areamask
|
|
R_MarkLeaves();
|
|
|
|
// clear out the visible min/max
|
|
ClearBounds(tr.viewParms.visBounds[0], tr.viewParms.visBounds[1]);
|
|
|
|
// perform frustum culling and add all the potentially visible surfaces
|
|
if (tr.refdef.num_dlights > 32) {
|
|
tr.refdef.num_dlights = 32;
|
|
}
|
|
R_TransformDlights(tr.refdef.num_dlights, tr.refdef.dlights, &tr.viewParms.world);
|
|
R_RecursiveWorldNode(tr.world->nodes, tr.viewParms.fog.extrafrustums ? 31 : 15, (1 << tr.refdef.num_dlights) - 1);
|
|
|
|
if (r_drawterrain->integer && tr.refdef.render_terrain && !tr.viewParms.isPortalSky) {
|
|
R_AddTerrainSurfaces();
|
|
}
|
|
if (r_drawstaticmodels->integer) {
|
|
R_AddStaticModelSurfaces();
|
|
}
|
|
|
|
if (g_bInfostaticmodels) {
|
|
g_bInfostaticmodels = 0;
|
|
R_PrintInfoStaticModels();
|
|
}
|
|
|
|
R_UpdateLevelMarksSystem();
|
|
}
|