mirror of
https://github.com/UberGames/lilium-voyager.git
synced 2024-11-14 00:10:39 +00:00
904bbc1a8f
Models don't have a surface limit; skins shouldn't either. Some player models require more than 32 surfaces since vanilla Quake 3 did not enforce the limit. Skins are now limited to 256 surfaces because having no limit would require parsing the skin file twice. The skin surfaces are dynamically allocated so it doesn't increase memory usage when less surfaces are used.
412 lines
10 KiB
C
412 lines
10 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 Quake III Arena source code; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
// tr_mesh.c: triangle model functions
|
|
|
|
#include "tr_local.h"
|
|
|
|
static float ProjectRadius( float r, vec3_t location )
|
|
{
|
|
float pr;
|
|
float dist;
|
|
float c;
|
|
vec3_t p;
|
|
float projected[4];
|
|
|
|
c = DotProduct( tr.viewParms.or.axis[0], tr.viewParms.or.origin );
|
|
dist = DotProduct( tr.viewParms.or.axis[0], location ) - c;
|
|
|
|
if ( dist <= 0 )
|
|
return 0;
|
|
|
|
p[0] = 0;
|
|
p[1] = fabs( r );
|
|
p[2] = -dist;
|
|
|
|
projected[0] = p[0] * tr.viewParms.projectionMatrix[0] +
|
|
p[1] * tr.viewParms.projectionMatrix[4] +
|
|
p[2] * tr.viewParms.projectionMatrix[8] +
|
|
tr.viewParms.projectionMatrix[12];
|
|
|
|
projected[1] = p[0] * tr.viewParms.projectionMatrix[1] +
|
|
p[1] * tr.viewParms.projectionMatrix[5] +
|
|
p[2] * tr.viewParms.projectionMatrix[9] +
|
|
tr.viewParms.projectionMatrix[13];
|
|
|
|
projected[2] = p[0] * tr.viewParms.projectionMatrix[2] +
|
|
p[1] * tr.viewParms.projectionMatrix[6] +
|
|
p[2] * tr.viewParms.projectionMatrix[10] +
|
|
tr.viewParms.projectionMatrix[14];
|
|
|
|
projected[3] = p[0] * tr.viewParms.projectionMatrix[3] +
|
|
p[1] * tr.viewParms.projectionMatrix[7] +
|
|
p[2] * tr.viewParms.projectionMatrix[11] +
|
|
tr.viewParms.projectionMatrix[15];
|
|
|
|
|
|
pr = projected[1] / projected[3];
|
|
|
|
if ( pr > 1.0f )
|
|
pr = 1.0f;
|
|
|
|
return pr;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
R_CullModel
|
|
=============
|
|
*/
|
|
static int R_CullModel( md3Header_t *header, trRefEntity_t *ent ) {
|
|
vec3_t bounds[2];
|
|
md3Frame_t *oldFrame, *newFrame;
|
|
int i;
|
|
|
|
// compute frame pointers
|
|
newFrame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + ent->e.frame;
|
|
oldFrame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + ent->e.oldframe;
|
|
|
|
// cull bounding sphere ONLY if this is not an upscaled entity
|
|
if ( !ent->e.nonNormalizedAxes )
|
|
{
|
|
if ( ent->e.frame == ent->e.oldframe )
|
|
{
|
|
switch ( R_CullLocalPointAndRadius( newFrame->localOrigin, newFrame->radius ) )
|
|
{
|
|
case CULL_OUT:
|
|
tr.pc.c_sphere_cull_md3_out++;
|
|
return CULL_OUT;
|
|
|
|
case CULL_IN:
|
|
tr.pc.c_sphere_cull_md3_in++;
|
|
return CULL_IN;
|
|
|
|
case CULL_CLIP:
|
|
tr.pc.c_sphere_cull_md3_clip++;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int sphereCull, sphereCullB;
|
|
|
|
sphereCull = R_CullLocalPointAndRadius( newFrame->localOrigin, newFrame->radius );
|
|
if ( newFrame == oldFrame ) {
|
|
sphereCullB = sphereCull;
|
|
} else {
|
|
sphereCullB = R_CullLocalPointAndRadius( oldFrame->localOrigin, oldFrame->radius );
|
|
}
|
|
|
|
if ( sphereCull == sphereCullB )
|
|
{
|
|
if ( sphereCull == CULL_OUT )
|
|
{
|
|
tr.pc.c_sphere_cull_md3_out++;
|
|
return CULL_OUT;
|
|
}
|
|
else if ( sphereCull == CULL_IN )
|
|
{
|
|
tr.pc.c_sphere_cull_md3_in++;
|
|
return CULL_IN;
|
|
}
|
|
else
|
|
{
|
|
tr.pc.c_sphere_cull_md3_clip++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// calculate a bounding box in the current coordinate system
|
|
for (i = 0 ; i < 3 ; i++) {
|
|
bounds[0][i] = oldFrame->bounds[0][i] < newFrame->bounds[0][i] ? oldFrame->bounds[0][i] : newFrame->bounds[0][i];
|
|
bounds[1][i] = oldFrame->bounds[1][i] > newFrame->bounds[1][i] ? oldFrame->bounds[1][i] : newFrame->bounds[1][i];
|
|
}
|
|
|
|
switch ( R_CullLocalBox( bounds ) )
|
|
{
|
|
case CULL_IN:
|
|
tr.pc.c_box_cull_md3_in++;
|
|
return CULL_IN;
|
|
case CULL_CLIP:
|
|
tr.pc.c_box_cull_md3_clip++;
|
|
return CULL_CLIP;
|
|
case CULL_OUT:
|
|
default:
|
|
tr.pc.c_box_cull_md3_out++;
|
|
return CULL_OUT;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
R_ComputeLOD
|
|
|
|
=================
|
|
*/
|
|
int R_ComputeLOD( trRefEntity_t *ent ) {
|
|
float radius;
|
|
float flod, lodscale;
|
|
float projectedRadius;
|
|
md3Frame_t *frame;
|
|
mdrHeader_t *mdr;
|
|
mdrFrame_t *mdrframe;
|
|
int lod;
|
|
|
|
if ( tr.currentModel->numLods < 2 )
|
|
{
|
|
// model has only 1 LOD level, skip computations and bias
|
|
lod = 0;
|
|
}
|
|
else
|
|
{
|
|
// multiple LODs exist, so compute projected bounding sphere
|
|
// and use that as a criteria for selecting LOD
|
|
|
|
if(tr.currentModel->type == MOD_MDR)
|
|
{
|
|
int frameSize;
|
|
mdr = (mdrHeader_t *) tr.currentModel->modelData;
|
|
frameSize = (size_t) (&((mdrFrame_t *)0)->bones[mdr->numBones]);
|
|
|
|
mdrframe = (mdrFrame_t *) ((byte *) mdr + mdr->ofsFrames + frameSize * ent->e.frame);
|
|
|
|
radius = RadiusFromBounds(mdrframe->bounds[0], mdrframe->bounds[1]);
|
|
}
|
|
else
|
|
{
|
|
frame = ( md3Frame_t * ) ( ( ( unsigned char * ) tr.currentModel->md3[0] ) + tr.currentModel->md3[0]->ofsFrames );
|
|
|
|
frame += ent->e.frame;
|
|
|
|
radius = RadiusFromBounds( frame->bounds[0], frame->bounds[1] );
|
|
}
|
|
|
|
if ( ( projectedRadius = ProjectRadius( radius, ent->e.origin ) ) != 0 )
|
|
{
|
|
lodscale = r_lodscale->value;
|
|
if (lodscale > 20) lodscale = 20;
|
|
flod = 1.0f - projectedRadius * lodscale;
|
|
}
|
|
else
|
|
{
|
|
// object intersects near view plane, e.g. view weapon
|
|
flod = 0;
|
|
}
|
|
|
|
flod *= tr.currentModel->numLods;
|
|
lod = ri.ftol(flod);
|
|
|
|
if ( lod < 0 )
|
|
{
|
|
lod = 0;
|
|
}
|
|
else if ( lod >= tr.currentModel->numLods )
|
|
{
|
|
lod = tr.currentModel->numLods - 1;
|
|
}
|
|
}
|
|
|
|
lod += r_lodbias->integer;
|
|
|
|
if ( lod >= tr.currentModel->numLods )
|
|
lod = tr.currentModel->numLods - 1;
|
|
if ( lod < 0 )
|
|
lod = 0;
|
|
|
|
return lod;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_ComputeFogNum
|
|
|
|
=================
|
|
*/
|
|
int R_ComputeFogNum( md3Header_t *header, trRefEntity_t *ent ) {
|
|
int i, j;
|
|
fog_t *fog;
|
|
md3Frame_t *md3Frame;
|
|
vec3_t localOrigin;
|
|
|
|
if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
|
|
return 0;
|
|
}
|
|
|
|
// FIXME: non-normalized axis issues
|
|
md3Frame = ( md3Frame_t * ) ( ( byte * ) header + header->ofsFrames ) + ent->e.frame;
|
|
VectorAdd( ent->e.origin, md3Frame->localOrigin, localOrigin );
|
|
for ( i = 1 ; i < tr.world->numfogs ; i++ ) {
|
|
fog = &tr.world->fogs[i];
|
|
for ( j = 0 ; j < 3 ; j++ ) {
|
|
if ( localOrigin[j] - md3Frame->radius >= fog->bounds[1][j] ) {
|
|
break;
|
|
}
|
|
if ( localOrigin[j] + md3Frame->radius <= fog->bounds[0][j] ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( j == 3 ) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
R_AddMD3Surfaces
|
|
|
|
=================
|
|
*/
|
|
void R_AddMD3Surfaces( trRefEntity_t *ent ) {
|
|
int i;
|
|
md3Header_t *header = NULL;
|
|
md3Surface_t *surface = NULL;
|
|
md3Shader_t *md3Shader = NULL;
|
|
shader_t *shader = NULL;
|
|
int cull;
|
|
int lod;
|
|
int fogNum;
|
|
qboolean personalModel;
|
|
|
|
// don't add third_person objects if not in a portal
|
|
personalModel = (ent->e.renderfx & RF_THIRD_PERSON) && !tr.viewParms.isPortal;
|
|
|
|
if ( ent->e.renderfx & RF_WRAP_FRAMES ) {
|
|
ent->e.frame %= tr.currentModel->md3[0]->numFrames;
|
|
ent->e.oldframe %= tr.currentModel->md3[0]->numFrames;
|
|
}
|
|
|
|
//
|
|
// Validate the frames so there is no chance of a crash.
|
|
// This will write directly into the entity structure, so
|
|
// when the surfaces are rendered, they don't need to be
|
|
// range checked again.
|
|
//
|
|
if ( (ent->e.frame >= tr.currentModel->md3[0]->numFrames)
|
|
|| (ent->e.frame < 0)
|
|
|| (ent->e.oldframe >= tr.currentModel->md3[0]->numFrames)
|
|
|| (ent->e.oldframe < 0) ) {
|
|
ri.Printf( PRINT_DEVELOPER, "R_AddMD3Surfaces: no such frame %d to %d for '%s'\n",
|
|
ent->e.oldframe, ent->e.frame,
|
|
tr.currentModel->name );
|
|
ent->e.frame = 0;
|
|
ent->e.oldframe = 0;
|
|
}
|
|
|
|
//
|
|
// compute LOD
|
|
//
|
|
lod = R_ComputeLOD( ent );
|
|
|
|
header = tr.currentModel->md3[lod];
|
|
|
|
//
|
|
// cull the entire model if merged bounding box of both frames
|
|
// is outside the view frustum.
|
|
//
|
|
cull = R_CullModel ( header, ent );
|
|
if ( cull == CULL_OUT ) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// set up lighting now that we know we aren't culled
|
|
//
|
|
if ( !personalModel || r_shadows->integer > 1 ) {
|
|
R_SetupEntityLighting( &tr.refdef, ent );
|
|
}
|
|
|
|
//
|
|
// see if we are in a fog volume
|
|
//
|
|
fogNum = R_ComputeFogNum( header, ent );
|
|
|
|
//
|
|
// draw all surfaces
|
|
//
|
|
surface = (md3Surface_t *)( (byte *)header + header->ofsSurfaces );
|
|
for ( i = 0 ; i < header->numSurfaces ; i++ ) {
|
|
|
|
if ( ent->e.customShader ) {
|
|
shader = R_GetShaderByHandle( ent->e.customShader );
|
|
} else if ( ent->e.customSkin > 0 && ent->e.customSkin < tr.numSkins ) {
|
|
skin_t *skin;
|
|
int j;
|
|
|
|
skin = R_GetSkinByHandle( ent->e.customSkin );
|
|
|
|
// match the surface name to something in the skin file
|
|
shader = tr.defaultShader;
|
|
for ( j = 0 ; j < skin->numSurfaces ; j++ ) {
|
|
// the names have both been lowercased
|
|
if ( !strcmp( skin->surfaces[j].name, surface->name ) ) {
|
|
shader = skin->surfaces[j].shader;
|
|
break;
|
|
}
|
|
}
|
|
if (shader == tr.defaultShader) {
|
|
ri.Printf( PRINT_DEVELOPER, "WARNING: no shader for surface %s in skin %s\n", surface->name, skin->name);
|
|
}
|
|
else if (shader->defaultShader) {
|
|
ri.Printf( PRINT_DEVELOPER, "WARNING: shader %s in skin %s not found\n", shader->name, skin->name);
|
|
}
|
|
} else if ( surface->numShaders <= 0 ) {
|
|
shader = tr.defaultShader;
|
|
} else {
|
|
md3Shader = (md3Shader_t *) ( (byte *)surface + surface->ofsShaders );
|
|
md3Shader += ent->e.skinNum % surface->numShaders;
|
|
shader = tr.shaders[ md3Shader->shaderIndex ];
|
|
}
|
|
|
|
|
|
// we will add shadows even if the main object isn't visible in the view
|
|
|
|
// stencil shadows can't do personal models unless I polyhedron clip
|
|
if ( !personalModel
|
|
&& r_shadows->integer == 2
|
|
&& fogNum == 0
|
|
&& !(ent->e.renderfx & ( RF_NOSHADOW | RF_DEPTHHACK ) )
|
|
&& shader->sort == SS_OPAQUE ) {
|
|
R_AddDrawSurf( (void *)surface, tr.shadowShader, 0, qfalse );
|
|
}
|
|
|
|
// projection shadows work fine with personal models
|
|
if ( r_shadows->integer == 3
|
|
&& fogNum == 0
|
|
&& (ent->e.renderfx & RF_SHADOW_PLANE )
|
|
&& shader->sort == SS_OPAQUE ) {
|
|
R_AddDrawSurf( (void *)surface, tr.projectionShadowShader, 0, qfalse );
|
|
}
|
|
|
|
// don't add third_person objects if not viewing through a portal
|
|
if ( !personalModel ) {
|
|
R_AddDrawSurf( (void *)surface, shader, fogNum, qfalse );
|
|
}
|
|
|
|
surface = (md3Surface_t *)( (byte *)surface + surface->ofsEnd );
|
|
}
|
|
|
|
}
|
|
|