mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-30 16:11:11 +00:00
736ec20d4d
Don't include the lazy precompiled.h everywhere, only what's required for the compilation unit. platform.h needs to be included instead to provide all essential defines and types. All includes use the relative path to the neo or the game specific root. Move all idlib related includes from idlib/Lib.h to precompiled.h. precompiled.h still exists for the MFC stuff in tools/. Add some missing header guards.
384 lines
12 KiB
C++
384 lines
12 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "sys/platform.h"
|
|
#include "renderer/tr_local.h"
|
|
#include "renderer/Model_local.h"
|
|
|
|
#include "renderer/ModelOverlay.h"
|
|
|
|
/*
|
|
====================
|
|
idRenderModelOverlay::idRenderModelOverlay
|
|
====================
|
|
*/
|
|
idRenderModelOverlay::idRenderModelOverlay() {
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idRenderModelOverlay::~idRenderModelOverlay
|
|
====================
|
|
*/
|
|
idRenderModelOverlay::~idRenderModelOverlay() {
|
|
int i, k;
|
|
|
|
for ( k = 0; k < materials.Num(); k++ ) {
|
|
for ( i = 0; i < materials[k]->surfaces.Num(); i++ ) {
|
|
FreeSurface( materials[k]->surfaces[i] );
|
|
}
|
|
materials[k]->surfaces.Clear();
|
|
delete materials[k];
|
|
}
|
|
materials.Clear();
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idRenderModelOverlay::Alloc
|
|
====================
|
|
*/
|
|
idRenderModelOverlay *idRenderModelOverlay::Alloc( void ) {
|
|
return new idRenderModelOverlay;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idRenderModelOverlay::Free
|
|
====================
|
|
*/
|
|
void idRenderModelOverlay::Free( idRenderModelOverlay *overlay ) {
|
|
delete overlay;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idRenderModelOverlay::FreeSurface
|
|
====================
|
|
*/
|
|
void idRenderModelOverlay::FreeSurface( overlaySurface_t *surface ) {
|
|
if ( surface->verts ) {
|
|
Mem_Free( surface->verts );
|
|
}
|
|
if ( surface->indexes ) {
|
|
Mem_Free( surface->indexes );
|
|
}
|
|
Mem_Free( surface );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idRenderModelOverlay::CreateOverlay
|
|
|
|
This projects on both front and back sides to avoid seams
|
|
The material should be clamped, because entire triangles are added, some of which
|
|
may extend well past the 0.0 to 1.0 texture range
|
|
=====================
|
|
*/
|
|
void idRenderModelOverlay::CreateOverlay( const idRenderModel *model, const idPlane localTextureAxis[2], const idMaterial *mtr ) {
|
|
int i, maxVerts, maxIndexes, surfNum;
|
|
|
|
// count up the maximum possible vertices and indexes per surface
|
|
maxVerts = 0;
|
|
maxIndexes = 0;
|
|
for ( surfNum = 0; surfNum < model->NumSurfaces(); surfNum++ ) {
|
|
const modelSurface_t *surf = model->Surface( surfNum );
|
|
if ( surf->geometry->numVerts > maxVerts ) {
|
|
maxVerts = surf->geometry->numVerts;
|
|
}
|
|
if ( surf->geometry->numIndexes > maxIndexes ) {
|
|
maxIndexes = surf->geometry->numIndexes;
|
|
}
|
|
}
|
|
|
|
// make temporary buffers for the building process
|
|
overlayVertex_t *overlayVerts = (overlayVertex_t *)_alloca( maxVerts * sizeof( *overlayVerts ) );
|
|
glIndex_t *overlayIndexes = (glIndex_t *)_alloca16( maxIndexes * sizeof( *overlayIndexes ) );
|
|
|
|
// pull out the triangles we need from the base surfaces
|
|
for ( surfNum = 0; surfNum < model->NumBaseSurfaces(); surfNum++ ) {
|
|
const modelSurface_t *surf = model->Surface( surfNum );
|
|
float d;
|
|
|
|
if ( !surf->geometry || !surf->shader ) {
|
|
continue;
|
|
}
|
|
|
|
// some surfaces can explicitly disallow overlays
|
|
if ( !surf->shader->AllowOverlays() ) {
|
|
continue;
|
|
}
|
|
|
|
const srfTriangles_t *stri = surf->geometry;
|
|
|
|
// try to cull the whole surface along the first texture axis
|
|
d = stri->bounds.PlaneDistance( localTextureAxis[0] );
|
|
if ( d < 0.0f || d > 1.0f ) {
|
|
continue;
|
|
}
|
|
|
|
// try to cull the whole surface along the second texture axis
|
|
d = stri->bounds.PlaneDistance( localTextureAxis[1] );
|
|
if ( d < 0.0f || d > 1.0f ) {
|
|
continue;
|
|
}
|
|
|
|
byte *cullBits = (byte *)_alloca16( stri->numVerts * sizeof( cullBits[0] ) );
|
|
idVec2 *texCoords = (idVec2 *)_alloca16( stri->numVerts * sizeof( texCoords[0] ) );
|
|
|
|
SIMDProcessor->OverlayPointCull( cullBits, texCoords, localTextureAxis, stri->verts, stri->numVerts );
|
|
|
|
glIndex_t *vertexRemap = (glIndex_t *)_alloca16( sizeof( vertexRemap[0] ) * stri->numVerts );
|
|
SIMDProcessor->Memset( vertexRemap, -1, sizeof( vertexRemap[0] ) * stri->numVerts );
|
|
|
|
// find triangles that need the overlay
|
|
int numVerts = 0;
|
|
int numIndexes = 0;
|
|
int triNum = 0;
|
|
for ( int index = 0; index < stri->numIndexes; index += 3, triNum++ ) {
|
|
int v1 = stri->indexes[index+0];
|
|
int v2 = stri->indexes[index+1];
|
|
int v3 = stri->indexes[index+2];
|
|
|
|
// skip triangles completely off one side
|
|
if ( cullBits[v1] & cullBits[v2] & cullBits[v3] ) {
|
|
continue;
|
|
}
|
|
|
|
// we could do more precise triangle culling, like the light interaction does, if desired
|
|
|
|
// keep this triangle
|
|
for ( int vnum = 0; vnum < 3; vnum++ ) {
|
|
int ind = stri->indexes[index+vnum];
|
|
if ( vertexRemap[ind] == (glIndex_t)-1 ) {
|
|
vertexRemap[ind] = numVerts;
|
|
|
|
overlayVerts[numVerts].vertexNum = ind;
|
|
overlayVerts[numVerts].st[0] = texCoords[ind][0];
|
|
overlayVerts[numVerts].st[1] = texCoords[ind][1];
|
|
|
|
numVerts++;
|
|
}
|
|
overlayIndexes[numIndexes++] = vertexRemap[ind];
|
|
}
|
|
}
|
|
|
|
if ( !numIndexes ) {
|
|
continue;
|
|
}
|
|
|
|
overlaySurface_t *s = (overlaySurface_t *) Mem_Alloc( sizeof( overlaySurface_t ) );
|
|
s->surfaceNum = surfNum;
|
|
s->surfaceId = surf->id;
|
|
s->verts = (overlayVertex_t *)Mem_Alloc( numVerts * sizeof( s->verts[0] ) );
|
|
memcpy( s->verts, overlayVerts, numVerts * sizeof( s->verts[0] ) );
|
|
s->numVerts = numVerts;
|
|
s->indexes = (glIndex_t *)Mem_Alloc( numIndexes * sizeof( s->indexes[0] ) );
|
|
memcpy( s->indexes, overlayIndexes, numIndexes * sizeof( s->indexes[0] ) );
|
|
s->numIndexes = numIndexes;
|
|
|
|
for ( i = 0; i < materials.Num(); i++ ) {
|
|
if ( materials[i]->material == mtr ) {
|
|
break;
|
|
}
|
|
}
|
|
if ( i < materials.Num() ) {
|
|
materials[i]->surfaces.Append( s );
|
|
} else {
|
|
overlayMaterial_t *mat = new overlayMaterial_t;
|
|
mat->material = mtr;
|
|
mat->surfaces.Append( s );
|
|
materials.Append( mat );
|
|
}
|
|
}
|
|
|
|
// remove the oldest overlay surfaces if there are too many per material
|
|
for ( i = 0; i < materials.Num(); i++ ) {
|
|
while( materials[i]->surfaces.Num() > MAX_OVERLAY_SURFACES ) {
|
|
FreeSurface( materials[i]->surfaces[0] );
|
|
materials[i]->surfaces.RemoveIndex( 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idRenderModelOverlay::AddOverlaySurfacesToModel
|
|
====================
|
|
*/
|
|
void idRenderModelOverlay::AddOverlaySurfacesToModel( idRenderModel *baseModel ) {
|
|
int i, j, k, numVerts, numIndexes, surfaceNum;
|
|
const modelSurface_t *baseSurf;
|
|
idRenderModelStatic *staticModel;
|
|
overlaySurface_t *surf;
|
|
srfTriangles_t *newTri;
|
|
modelSurface_t *newSurf;
|
|
|
|
if ( baseModel == NULL || baseModel->IsDefaultModel() ) {
|
|
return;
|
|
}
|
|
|
|
// md5 models won't have any surfaces when r_showSkel is set
|
|
if ( !baseModel->NumSurfaces() ) {
|
|
return;
|
|
}
|
|
|
|
if ( baseModel->IsDynamicModel() != DM_STATIC ) {
|
|
common->Error( "idRenderModelOverlay::AddOverlaySurfacesToModel: baseModel is not a static model" );
|
|
}
|
|
|
|
assert( dynamic_cast<idRenderModelStatic *>(baseModel) != NULL );
|
|
staticModel = static_cast<idRenderModelStatic *>(baseModel);
|
|
|
|
staticModel->overlaysAdded = 0;
|
|
|
|
if ( !materials.Num() ) {
|
|
staticModel->DeleteSurfacesWithNegativeId();
|
|
return;
|
|
}
|
|
|
|
for ( k = 0; k < materials.Num(); k++ ) {
|
|
|
|
numVerts = numIndexes = 0;
|
|
for ( i = 0; i < materials[k]->surfaces.Num(); i++ ) {
|
|
numVerts += materials[k]->surfaces[i]->numVerts;
|
|
numIndexes += materials[k]->surfaces[i]->numIndexes;
|
|
}
|
|
|
|
if ( staticModel->FindSurfaceWithId( -1 - k, surfaceNum ) ) {
|
|
newSurf = &staticModel->surfaces[surfaceNum];
|
|
} else {
|
|
newSurf = &staticModel->surfaces.Alloc();
|
|
newSurf->geometry = NULL;
|
|
newSurf->shader = materials[k]->material;
|
|
newSurf->id = -1 - k;
|
|
}
|
|
|
|
if ( newSurf->geometry == NULL || newSurf->geometry->numVerts < numVerts || newSurf->geometry->numIndexes < numIndexes ) {
|
|
R_FreeStaticTriSurf( newSurf->geometry );
|
|
newSurf->geometry = R_AllocStaticTriSurf();
|
|
R_AllocStaticTriSurfVerts( newSurf->geometry, numVerts );
|
|
R_AllocStaticTriSurfIndexes( newSurf->geometry, numIndexes );
|
|
SIMDProcessor->Memset( newSurf->geometry->verts, 0, numVerts * sizeof( newTri->verts[0] ) );
|
|
} else {
|
|
R_FreeStaticTriSurfVertexCaches( newSurf->geometry );
|
|
}
|
|
|
|
newTri = newSurf->geometry;
|
|
numVerts = numIndexes = 0;
|
|
|
|
for ( i = 0; i < materials[k]->surfaces.Num(); i++ ) {
|
|
surf = materials[k]->surfaces[i];
|
|
|
|
// get the model surface for this overlay surface
|
|
if ( surf->surfaceNum < staticModel->NumSurfaces() ) {
|
|
baseSurf = staticModel->Surface( surf->surfaceNum );
|
|
} else {
|
|
baseSurf = NULL;
|
|
}
|
|
|
|
// if the surface ids no longer match
|
|
if ( !baseSurf || baseSurf->id != surf->surfaceId ) {
|
|
// find the surface with the correct id
|
|
if ( staticModel->FindSurfaceWithId( surf->surfaceId, surf->surfaceNum ) ) {
|
|
baseSurf = staticModel->Surface( surf->surfaceNum );
|
|
} else {
|
|
// the surface with this id no longer exists
|
|
FreeSurface( surf );
|
|
materials[k]->surfaces.RemoveIndex( i );
|
|
i--;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// copy indexes;
|
|
for ( j = 0; j < surf->numIndexes; j++ ) {
|
|
newTri->indexes[numIndexes + j] = numVerts + surf->indexes[j];
|
|
}
|
|
numIndexes += surf->numIndexes;
|
|
|
|
// copy vertices
|
|
for ( j = 0; j < surf->numVerts; j++ ) {
|
|
overlayVertex_t *overlayVert = &surf->verts[j];
|
|
|
|
newTri->verts[numVerts].st[0] = overlayVert->st[0];
|
|
newTri->verts[numVerts].st[1] = overlayVert->st[1];
|
|
|
|
if ( overlayVert->vertexNum >= baseSurf->geometry->numVerts ) {
|
|
// This can happen when playing a demofile and a model has been changed since it was recorded, so just issue a warning and go on.
|
|
common->Warning( "idRenderModelOverlay::AddOverlaySurfacesToModel: overlay vertex out of range. Model has probably changed since generating the overlay." );
|
|
FreeSurface( surf );
|
|
materials[k]->surfaces.RemoveIndex( i );
|
|
staticModel->DeleteSurfaceWithId( newSurf->id );
|
|
return;
|
|
}
|
|
newTri->verts[numVerts].xyz = baseSurf->geometry->verts[overlayVert->vertexNum].xyz;
|
|
numVerts++;
|
|
}
|
|
}
|
|
|
|
newTri->numVerts = numVerts;
|
|
newTri->numIndexes = numIndexes;
|
|
R_BoundTriSurf( newTri );
|
|
|
|
staticModel->overlaysAdded++; // so we don't create an overlay on an overlay surface
|
|
}
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idRenderModelOverlay::RemoveOverlaySurfacesFromModel
|
|
====================
|
|
*/
|
|
void idRenderModelOverlay::RemoveOverlaySurfacesFromModel( idRenderModel *baseModel ) {
|
|
idRenderModelStatic *staticModel;
|
|
|
|
assert( dynamic_cast<idRenderModelStatic *>(baseModel) != NULL );
|
|
staticModel = static_cast<idRenderModelStatic *>(baseModel);
|
|
|
|
staticModel->DeleteSurfacesWithNegativeId();
|
|
staticModel->overlaysAdded = 0;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idRenderModelOverlay::ReadFromDemoFile
|
|
====================
|
|
*/
|
|
void idRenderModelOverlay::ReadFromDemoFile( idDemoFile *f ) {
|
|
// FIXME: implement
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idRenderModelOverlay::WriteToDemoFile
|
|
====================
|
|
*/
|
|
void idRenderModelOverlay::WriteToDemoFile( idDemoFile *f ) const {
|
|
// FIXME: implement
|
|
}
|