/*
====================
idMD5Mesh::UpdateSurface
====================
*/
void idMD5Mesh::UpdateSurface( const struct renderEntity_s *ent, const idJointMat *entJoints,
const idJointMat *entJointsInverted, modelSurface_t *surf ) {
tr.pc.c_deformedSurfaces++;
tr.pc.c_deformedVerts += deformInfo->numOutputVerts;
tr.pc.c_deformedIndexes += deformInfo->numIndexes;
surf->shader = shader;
if ( surf->geometry != NULL ) {
// if the number of verts and indexes are the same we can re-use the triangle surface
if ( surf->geometry->numVerts == deformInfo->numOutputVerts && surf->geometry->numIndexes == deformInfo->numIndexes ) {
R_FreeStaticTriSurfVertexCaches( surf->geometry );
} else {
R_FreeStaticTriSurf( surf->geometry );
surf->geometry = R_AllocStaticTriSurf();
}
} else {
surf->geometry = R_AllocStaticTriSurf();
}
srfTriangles_t * tri = surf->geometry;
// note that some of the data is referenced, and should not be freed
tri->referencedIndexes = true;
tri->numIndexes = deformInfo->numIndexes;
tri->indexes = deformInfo->indexes;
tri->silIndexes = deformInfo->silIndexes;
tri->numMirroredVerts = deformInfo->numMirroredVerts;
tri->mirroredVerts = deformInfo->mirroredVerts;
tri->numDupVerts = deformInfo->numDupVerts;
tri->dupVerts = deformInfo->dupVerts;
tri->numSilEdges = deformInfo->numSilEdges;
tri->silEdges = deformInfo->silEdges;
tri->indexCache = deformInfo->staticIndexCache;
tri->numVerts = deformInfo->numOutputVerts;
if ( r_useGPUSkinning.GetBool() ) {
if ( tri->verts != NULL && tri->verts != deformInfo->verts ) {
R_FreeStaticTriSurfVerts( tri );
}
tri->verts = deformInfo->verts;
tri->ambientCache = deformInfo->staticAmbientCache;
tri->shadowCache = deformInfo->staticShadowCache;
tri->referencedVerts = true;
} else {
if ( tri->verts == NULL || tri->verts == deformInfo->verts ) {
tri->verts = NULL;
R_AllocStaticTriSurfVerts( tri, deformInfo->numOutputVerts );
assert( tri->verts != NULL ); // quiet analyze warning
memcpy( tri->verts, deformInfo->verts, deformInfo->numOutputVerts * sizeof( deformInfo->verts[0] ) ); // copy over the texture coordinates
}
TransformVertsAndTangents( tri->verts, deformInfo->numOutputVerts, deformInfo->verts, entJointsInverted );
tri->referencedVerts = false;
}
tri->tangentsCalculated = true;
CalculateBounds( entJoints, tri->bounds );
}
/*
=================
R_MergeSurfaceList
Only deals with vertexes and indexes, not silhouettes, planes, etc.
Does NOT perform a cleanup triangles, so there may be duplicated verts in the result.
=================
*/
srfTriangles_t *R_MergeSurfaceList( const srfTriangles_t **surfaces, int numSurfaces ) {
srfTriangles_t *newTri;
const srfTriangles_t *tri;
int i, j;
int totalVerts;
int totalIndexes;
totalVerts = 0;
totalIndexes = 0;
for ( i = 0 ; i < numSurfaces ; i++ ) {
totalVerts += surfaces[i]->numVerts;
totalIndexes += surfaces[i]->numIndices;
}
newTri = R_AllocStaticTriSurf();
newTri->numVerts = totalVerts;
newTri->numIndices = totalIndexes;
R_AllocStaticTriSurfVerts( newTri, newTri->numVerts );
R_AllocStaticTriSurfIndices( newTri, newTri->numIndices );
totalVerts = 0;
totalIndexes = 0;
for ( i = 0 ; i < numSurfaces ; i++ ) {
tri = surfaces[i];
memcpy( newTri->verts + totalVerts, tri->verts, tri->numVerts * sizeof( *tri->verts ) );
for ( j = 0 ; j < tri->numIndices ; j++ ) {
newTri->indices[ totalIndexes + j ] = totalVerts + tri->indices[j];
}
totalVerts += tri->numVerts;
totalIndexes += tri->numIndices;
}
return newTri;
}
void GameLocal::LoadAllModel()
{
StaticModel* dsmodel = new StaticModel;
LoadMesh3DS("../Media/Dino.3ds", dsmodel);
AddStaticModel(dsmodel);
StaticModel* model = resourceSys->AddMesh("ninja.b3d");
AddStaticModel(model);
drawSurf_t* drawSur = R_AllocDrawSurf();
drawSur->geo = R_AllocStaticTriSurf();
srfTriangles_t* tri = drawSur->geo;
tri->numVerts = KnightModel::numVertices;
tri->numIndexes = KnightModel::numIndices;
drawSur->view = _camera->GetViewProj();
R_AllocStaticTriSurfVerts(tri, tri->numVerts);
for (int i = 0; i < KnightModel::numVertices; i++)
{
memcpy(&(tri->verts[i].xyz), KnightModel::vertices[i].position, sizeof(float) * 3);
memcpy(&(tri->verts[i].uv), KnightModel::vertices[i].uv, sizeof(float) * 3);
memcpy(&(tri->verts[i].normal), KnightModel::vertices[i].normal, sizeof(float) * 3);
}
tri->indexes = new glIndex_t[KnightModel::numIndices];
memcpy(tri->indexes, KnightModel::indices, tri->numIndexes*sizeof(glIndex_t));
R_GenerateGeometryVbo(tri);
renderSys->AddDrawSur(drawSur);
}
/*
====================
idRenderModelLiquid::GenerateSurface
====================
*/
modelSurface_t idRenderModelLiquid::GenerateSurface( float lerp ) {
srfTriangles_t *tri;
int i, base;
idDrawVert *vert;
modelSurface_t surf;
float inv_lerp;
inv_lerp = 1.0f - lerp;
vert = verts.Ptr();
for( i = 0; i < verts.Num(); i++, vert++ ) {
vert->xyz.z = page1[ i ] * lerp + page2[ i ] * inv_lerp;
}
tr.pc.c_deformedSurfaces++;
tr.pc.c_deformedVerts += deformInfo->numOutputVerts;
tr.pc.c_deformedIndexes += deformInfo->numIndexes;
tri = R_AllocStaticTriSurf();
// note that some of the data is references, and should not be freed
tri->deformedSurface = true;
tri->numIndexes = deformInfo->numIndexes;
tri->indexes = deformInfo->indexes;
tri->silIndexes = deformInfo->silIndexes;
tri->numMirroredVerts = deformInfo->numMirroredVerts;
tri->mirroredVerts = deformInfo->mirroredVerts;
tri->numDupVerts = deformInfo->numDupVerts;
tri->dupVerts = deformInfo->dupVerts;
tri->numSilEdges = deformInfo->numSilEdges;
tri->silEdges = deformInfo->silEdges;
tri->dominantTris = deformInfo->dominantTris;
tri->numVerts = deformInfo->numOutputVerts;
R_AllocStaticTriSurfVerts( tri, tri->numVerts );
SIMDProcessor->Memcpy( tri->verts, verts.Ptr(), deformInfo->numSourceVerts * sizeof(tri->verts[0]) );
// replicate the mirror seam vertexes
base = deformInfo->numOutputVerts - deformInfo->numMirroredVerts;
for ( i = 0 ; i < deformInfo->numMirroredVerts ; i++ ) {
tri->verts[base + i] = tri->verts[deformInfo->mirroredVerts[i]];
}
R_BoundTriSurf( tri );
// If a surface is going to be have a lighting interaction generated, it will also have to call
// R_DeriveTangents() to get normals, tangents, and face planes. If it only
// needs shadows generated, it will only have to generate face planes. If it only
// has ambient drawing, or is culled, no additional work will be necessary
if ( !r_useDeferredTangents.GetBool() ) {
// set face planes, vertex normals, tangents
R_DeriveTangents( tri );
}
surf.geometry = tri;
surf.shader = shader;
return surf;
}
/*
=====================
R_PolytopeSurface
Generate vertexes and indexes for a polytope, and optionally returns the polygon windings.
The positive sides of the planes will be visible.
=====================
*/
srfTriangles_t *R_PolytopeSurface( int numPlanes, const idPlane *planes, idWinding **windings ) {
int i, j;
srfTriangles_t *tri;
idFixedWinding planeWindings[MAX_POLYTOPE_PLANES];
int numVerts, numIndexes;
if( numPlanes > MAX_POLYTOPE_PLANES ) {
common->Error( "R_PolytopeSurface: more than %d planes", MAX_POLYTOPE_PLANES );
}
numVerts = 0;
numIndexes = 0;
for( i = 0; i < numPlanes; i++ ) {
const idPlane &plane = planes[i];
idFixedWinding &w = planeWindings[i];
w.BaseForPlane( plane );
for( j = 0; j < numPlanes; j++ ) {
const idPlane &plane2 = planes[j];
if( j == i ) {
continue;
} else if( !w.ClipInPlace( -plane2, ON_EPSILON ) ) {
break;
}
}
if( w.GetNumPoints() <= 2 ) {
continue;
}
numVerts += w.GetNumPoints();
numIndexes += ( w.GetNumPoints() - 2 ) * 3;
}
// allocate the surface
tri = R_AllocStaticTriSurf();
R_AllocStaticTriSurfVerts( tri, numVerts );
R_AllocStaticTriSurfIndexes( tri, numIndexes );
// copy the data from the windings
for( i = 0; i < numPlanes; i++ ) {
idFixedWinding &w = planeWindings[i];
if( !w.GetNumPoints() ) {
continue;
}
for( j = 0 ; j < w.GetNumPoints() ; j++ ) {
tri->verts[tri->numVerts + j ].Clear();
tri->verts[tri->numVerts + j ].xyz = w[j].ToVec3();
}
for( j = 1 ; j < w.GetNumPoints() - 1 ; j++ ) {
tri->indexes[ tri->numIndexes + 0 ] = tri->numVerts;
tri->indexes[ tri->numIndexes + 1 ] = tri->numVerts + j;
tri->indexes[ tri->numIndexes + 2 ] = tri->numVerts + j + 1;
tri->numIndexes += 3;
}
tri->numVerts += w.GetNumPoints();
// optionally save the winding
if( windings ) {
windings[i] = new idWinding( w.GetNumPoints() );
*windings[i] = w;
}
}
R_BoundTriSurf( tri );
return tri;
}
/*
================
CombineModelSurfaces
Frees the model and returns a new model with all triangles combined
into one surface
================
*/
static idRenderModel *CombineModelSurfaces( idRenderModel *model ) {
int totalVerts;
int totalIndexes;
int numIndexes;
int numVerts;
int i, j;
totalVerts = 0;
totalIndexes = 0;
for ( i = 0 ; i < model->NumSurfaces() ; i++ ) {
const modelSurface_t *surf = model->Surface(i);
totalVerts += surf->geometry->numVerts;
totalIndexes += surf->geometry->numIndexes;
}
srfTriangles_t *newTri = R_AllocStaticTriSurf();
R_AllocStaticTriSurfVerts( newTri, totalVerts );
R_AllocStaticTriSurfIndexes( newTri, totalIndexes );
newTri->numVerts = totalVerts;
newTri->numIndexes = totalIndexes;
newTri->bounds.Clear();
idDrawVert *verts = newTri->verts;
glIndex_t *indexes = newTri->indexes;
numIndexes = 0;
numVerts = 0;
for ( i = 0 ; i < model->NumSurfaces() ; i++ ) {
const modelSurface_t *surf = model->Surface(i);
const srfTriangles_t *tri = surf->geometry;
memcpy( verts + numVerts, tri->verts, tri->numVerts * sizeof( tri->verts[0] ) );
for ( j = 0 ; j < tri->numIndexes ; j++ ) {
indexes[numIndexes+j] = numVerts + tri->indexes[j];
}
newTri->bounds.AddBounds( tri->bounds );
numIndexes += tri->numIndexes;
numVerts += tri->numVerts;
}
modelSurface_t surf;
surf.id = 0;
surf.geometry = newTri;
surf.shader = tr.defaultMaterial;
idRenderModel *newModel = renderModelManager->AllocModel();
newModel->AddSurface( surf );
renderModelManager->FreeModel( model );
return newModel;
}
/*
================
idRenderWorldLocal::ParseShadowModel
================
*/
idRenderModel *idRenderWorldLocal::ParseShadowModel( idLexer *src ) {
idRenderModel *model;
idToken token;
int j;
srfTriangles_t *tri;
modelSurface_t surf;
src->ExpectTokenString( "{" );
// parse the name
src->ExpectAnyToken( &token );
model = renderModelManager->AllocModel();
model->InitEmpty( token );
surf.shader = tr.defaultMaterial;
tri = R_AllocStaticTriSurf();
surf.geometry = tri;
tri->numVerts = src->ParseInt();
tri->numShadowIndexesNoCaps = src->ParseInt();
tri->numShadowIndexesNoFrontCaps = src->ParseInt();
tri->numIndexes = src->ParseInt();
tri->shadowCapPlaneBits = src->ParseInt();
R_AllocStaticTriSurfShadowVerts( tri, tri->numVerts );
tri->bounds.Clear();
for ( j = 0 ; j < tri->numVerts ; j++ ) {
float vec[8];
src->Parse1DMatrix( 3, vec );
tri->shadowVertexes[j].xyz[0] = vec[0];
tri->shadowVertexes[j].xyz[1] = vec[1];
tri->shadowVertexes[j].xyz[2] = vec[2];
tri->shadowVertexes[j].xyz[3] = 1; // no homogenous value
tri->bounds.AddPoint( tri->shadowVertexes[j].xyz.ToVec3() );
}
R_AllocStaticTriSurfIndexes( tri, tri->numIndexes );
for ( j = 0 ; j < tri->numIndexes ; j++ ) {
tri->indexes[j] = src->ParseInt();
}
// add the completed surface to the model
model->AddSurface( surf );
src->ExpectTokenString( "}" );
// we do NOT do a model->FinishSurfaceces, because we don't need sil edges, planes, tangents, etc.
// model->FinishSurfaces();
return model;
}
/*
====================
ShareMapTriVerts
Converts independent triangles to shared vertex triangles
====================
*/
srfTriangles_t *ShareMapTriVerts( const mapTri_t *tris )
{
const mapTri_t *step;
int count;
int i, j;
int numVerts;
int numIndexes;
srfTriangles_t *uTri;
// unique the vertexes
count = CountTriList( tris );
uTri = R_AllocStaticTriSurf();
R_AllocStaticTriSurfVerts( uTri, count * 3 );
R_AllocStaticTriSurfIndexes( uTri, count * 3 );
numVerts = 0;
numIndexes = 0;
for ( step = tris ; step ; step = step->next )
{
for ( i = 0 ; i < 3 ; i++ )
{
const idDrawVert *dv;
dv = &step->v[i];
// search for a match
for ( j = 0 ; j < numVerts ; j++ )
{
if ( MatchVert( &uTri->verts[j], dv ) )
{
break;
}
}
if ( j == numVerts )
{
numVerts++;
uTri->verts[j].xyz = dv->xyz;
uTri->verts[j].normal = dv->normal;
uTri->verts[j].st[0] = dv->st[0];
uTri->verts[j].st[1] = dv->st[1];
}
uTri->indexes[numIndexes++] = j;
}
}
uTri->numVerts = numVerts;
uTri->numIndexes = numIndexes;
return uTri;
}
/*
====================
idRenderModelLiquid::GenerateSurface
====================
*/
modelSurface_t idRenderModelLiquid::GenerateSurface( float lerp )
{
srfTriangles_t* tri;
int i, base;
idDrawVert* vert;
modelSurface_t surf;
float inv_lerp;
inv_lerp = 1.0f - lerp;
vert = verts.Ptr();
for( i = 0; i < verts.Num(); i++, vert++ )
{
vert->xyz.z = page1[ i ] * lerp + page2[ i ] * inv_lerp;
}
tr.pc.c_deformedSurfaces++;
tr.pc.c_deformedVerts += deformInfo->numOutputVerts;
tr.pc.c_deformedIndexes += deformInfo->numIndexes;
tri = R_AllocStaticTriSurf();
// note that some of the data is references, and should not be freed
tri->referencedIndexes = true;
tri->numIndexes = deformInfo->numIndexes;
tri->indexes = deformInfo->indexes;
tri->silIndexes = deformInfo->silIndexes;
tri->numMirroredVerts = deformInfo->numMirroredVerts;
tri->mirroredVerts = deformInfo->mirroredVerts;
tri->numDupVerts = deformInfo->numDupVerts;
tri->dupVerts = deformInfo->dupVerts;
tri->numSilEdges = deformInfo->numSilEdges;
tri->silEdges = deformInfo->silEdges;
tri->numVerts = deformInfo->numOutputVerts;
R_AllocStaticTriSurfVerts( tri, tri->numVerts );
SIMDProcessor->Memcpy( tri->verts, verts.Ptr(), deformInfo->numSourceVerts * sizeof( tri->verts[0] ) );
// replicate the mirror seam vertexes
base = deformInfo->numOutputVerts - deformInfo->numMirroredVerts;
for( i = 0 ; i < deformInfo->numMirroredVerts ; i++ )
{
tri->verts[base + i] = tri->verts[deformInfo->mirroredVerts[i]];
}
R_BoundTriSurf( tri );
surf.geometry = tri;
surf.shader = shader;
return surf;
}
/*
=============
idRenderModelMD3::InstantiateDynamicModel
=============
*/
idRenderModel *idRenderModelMD3::InstantiateDynamicModel( const struct renderEntity_s *ent, const struct viewDef_s *view, idRenderModel *cachedModel ) {
int i, j;
float backlerp;
int * triangles;
float * texCoords;
int indexes;
int numVerts;
md3Surface_t * surface;
int frame, oldframe;
idRenderModelStatic *staticModel;
if ( cachedModel ) {
delete cachedModel;
cachedModel = NULL;
}
staticModel = new idRenderModelStatic;
staticModel->bounds.Clear();
surface = (md3Surface_t *) ((byte *)md3 + md3->ofsSurfaces);
// TODO: these need set by an entity
frame = ent->shaderParms[SHADERPARM_MD3_FRAME]; // probably want to keep frames < 1000 or so
oldframe = ent->shaderParms[SHADERPARM_MD3_LASTFRAME];
backlerp = ent->shaderParms[SHADERPARM_MD3_BACKLERP];
for( i = 0; i < md3->numSurfaces; i++ ) {
srfTriangles_t *tri = R_AllocStaticTriSurf();
R_AllocStaticTriSurfVerts( tri, surface->numVerts );
R_AllocStaticTriSurfIndexes( tri, surface->numTriangles * 3 );
tri->bounds.Clear();
modelSurface_t surf;
surf.geometry = tri;
md3Shader_t* shaders = (md3Shader_t *) ((byte *)surface + surface->ofsShaders);
surf.shader = shaders->shader;
LerpMeshVertexes( tri, surface, backlerp, frame, oldframe );
triangles = (int *) ((byte *)surface + surface->ofsTriangles);
indexes = surface->numTriangles * 3;
for (j = 0 ; j < indexes ; j++) {
tri->indexes[j] = triangles[j];
}
tri->numIndexes += indexes;
texCoords = (float *) ((byte *)surface + surface->ofsSt);
numVerts = surface->numVerts;
for ( j = 0; j < numVerts; j++ ) {
idDrawVert *stri = &tri->verts[j];
stri->st[0] = texCoords[j*2+0];
stri->st[1] = texCoords[j*2+1];
}
R_BoundTriSurf( tri );
staticModel->AddSurface( surf );
staticModel->bounds.AddPoint( surf.geometry->bounds[0] );
staticModel->bounds.AddPoint( surf.geometry->bounds[1] );
// find the next surface
surface = (md3Surface_t *)( (byte *)surface + surface->ofsEnd );
}
return staticModel;
}
/*
====================
R_CreateInteractionLightTris
This is only used for the static interaction case, dynamic interactions
just draw everything and let the GPU deal with it.
The resulting surface will be a subset of the original triangles,
it will never clip triangles, but it may cull on a per-triangle basis.
====================
*/
static srfTriangles_t* R_CreateInteractionLightTris( const idRenderEntityLocal* ent,
const srfTriangles_t* tri, const idRenderLightLocal* light,
const idMaterial* shader )
{
SCOPED_PROFILE_EVENT( "R_CreateInteractionLightTris" );
int i;
int numIndexes;
triIndex_t* indexes;
srfTriangles_t* newTri;
int c_backfaced;
int c_distance;
idBounds bounds;
bool includeBackFaces;
int faceNum;
c_backfaced = 0;
c_distance = 0;
numIndexes = 0;
indexes = NULL;
// it is debatable if non-shadowing lights should light back faces. we aren't at the moment
// RB: now we do with r_useHalfLambert, so don't cull back faces if we have smooth shadowing enabled
if( r_lightAllBackFaces.GetBool() || light->lightShader->LightEffectsBackSides()
|| shader->ReceivesLightingOnBackSides() || ent->parms.noSelfShadow || ent->parms.noShadow || ( r_useHalfLambertLighting.GetInteger() && r_useShadowMapping.GetBool() ) )
{
includeBackFaces = true;
}
else
{
includeBackFaces = false;
}
// allocate a new surface for the lit triangles
newTri = R_AllocStaticTriSurf();
// save a reference to the original surface
newTri->ambientSurface = const_cast<srfTriangles_t*>( tri );
// the light surface references the verts of the ambient surface
newTri->numVerts = tri->numVerts;
R_ReferenceStaticTriSurfVerts( newTri, tri );
// calculate cull information
srfCullInfo_t cullInfo = {};
if( !includeBackFaces )
{
R_CalcInteractionFacing( ent, tri, light, cullInfo );
}
R_CalcInteractionCullBits( ent, tri, light, cullInfo );
// if the surface is completely inside the light frustum
if( cullInfo.cullBits == LIGHT_CULL_ALL_FRONT )
{
// if we aren't self shadowing, let back facing triangles get
// through so the smooth shaded bump maps light all the way around
if( includeBackFaces )
{
// the whole surface is lit so the light surface just references the indexes of the ambient surface
newTri->indexes = tri->indexes;
newTri->indexCache = tri->indexCache;
// R_ReferenceStaticTriSurfIndexes( newTri, tri );
numIndexes = tri->numIndexes;
bounds = tri->bounds;
}
else
{
// the light tris indexes are going to be a subset of the original indexes so we generally
// allocate too much memory here but we decrease the memory block when the number of indexes is known
R_AllocStaticTriSurfIndexes( newTri, tri->numIndexes );
// back face cull the individual triangles
indexes = newTri->indexes;
const byte* facing = cullInfo.facing;
for( faceNum = i = 0; i < tri->numIndexes; i += 3, faceNum++ )
{
if( !facing[ faceNum ] )
{
c_backfaced++;
continue;
}
indexes[numIndexes + 0] = tri->indexes[i + 0];
indexes[numIndexes + 1] = tri->indexes[i + 1];
indexes[numIndexes + 2] = tri->indexes[i + 2];
numIndexes += 3;
}
// get bounds for the surface
SIMDProcessor->MinMax( bounds[0], bounds[1], tri->verts, indexes, numIndexes );
// decrease the size of the memory block to the size of the number of used indexes
newTri->numIndexes = numIndexes;
R_ResizeStaticTriSurfIndexes( newTri, numIndexes );
}
}
else
{
// the light tris indexes are going to be a subset of the original indexes so we generally
// allocate too much memory here but we decrease the memory block when the number of indexes is known
R_AllocStaticTriSurfIndexes( newTri, tri->numIndexes );
// cull individual triangles
indexes = newTri->indexes;
const byte* facing = cullInfo.facing;
const byte* cullBits = cullInfo.cullBits;
for( faceNum = i = 0; i < tri->numIndexes; i += 3, faceNum++ )
{
int i1, i2, i3;
// if we aren't self shadowing, let back facing triangles get
// through so the smooth shaded bump maps light all the way around
if( !includeBackFaces )
{
// back face cull
if( !facing[ faceNum ] )
{
c_backfaced++;
continue;
}
}
i1 = tri->indexes[i + 0];
i2 = tri->indexes[i + 1];
i3 = tri->indexes[i + 2];
// fast cull outside the frustum
// if all three points are off one plane side, it definately isn't visible
if( cullBits[i1] & cullBits[i2] & cullBits[i3] )
{
c_distance++;
continue;
}
// add to the list
indexes[numIndexes + 0] = i1;
indexes[numIndexes + 1] = i2;
indexes[numIndexes + 2] = i3;
numIndexes += 3;
}
// get bounds for the surface
SIMDProcessor->MinMax( bounds[0], bounds[1], tri->verts, indexes, numIndexes );
// decrease the size of the memory block to the size of the number of used indexes
newTri->numIndexes = numIndexes;
R_ResizeStaticTriSurfIndexes( newTri, numIndexes );
}
// free the cull information when it's no longer needed
R_FreeInteractionCullInfo( cullInfo );
if( !numIndexes )
{
R_FreeStaticTriSurf( newTri );
return NULL;
}
newTri->numIndexes = numIndexes;
newTri->bounds = bounds;
return newTri;
}
/*
====================
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
}
}
/*
===============
idRenderModelSprite::InstantiateDynamicModel
===============
*/
idRenderModel * idRenderModelSprite::InstantiateDynamicModel( const struct renderEntity_s *renderEntity, const struct viewDef_s *viewDef, idRenderModel *cachedModel ) {
idRenderModelStatic *staticModel;
srfTriangles_t *tri;
modelSurface_t surf;
if ( cachedModel && !r_useCachedDynamicModels.GetBool() ) {
delete cachedModel;
cachedModel = NULL;
}
if ( renderEntity == NULL || viewDef == NULL ) {
delete cachedModel;
return NULL;
}
if ( cachedModel != NULL ) {
assert( dynamic_cast<idRenderModelStatic *>( cachedModel ) != NULL );
assert( idStr::Icmp( cachedModel->Name(), sprite_SnapshotName ) == 0 );
staticModel = static_cast<idRenderModelStatic *>( cachedModel );
surf = *staticModel->Surface( 0 );
tri = surf.geometry;
} else {
staticModel = new idRenderModelStatic;
staticModel->InitEmpty( sprite_SnapshotName );
tri = R_AllocStaticTriSurf();
R_AllocStaticTriSurfVerts( tri, 4 );
R_AllocStaticTriSurfIndexes( tri, 6 );
tri->verts[ 0 ].Clear();
tri->verts[ 0 ].normal.Set( 1.0f, 0.0f, 0.0f );
tri->verts[ 0 ].tangents[0].Set( 0.0f, 1.0f, 0.0f );
tri->verts[ 0 ].tangents[1].Set( 0.0f, 0.0f, 1.0f );
tri->verts[ 0 ].st[ 0 ] = 0.0f;
tri->verts[ 0 ].st[ 1 ] = 0.0f;
tri->verts[ 1 ].Clear();
tri->verts[ 1 ].normal.Set( 1.0f, 0.0f, 0.0f );
tri->verts[ 1 ].tangents[0].Set( 0.0f, 1.0f, 0.0f );
tri->verts[ 1 ].tangents[1].Set( 0.0f, 0.0f, 1.0f );
tri->verts[ 1 ].st[ 0 ] = 1.0f;
tri->verts[ 1 ].st[ 1 ] = 0.0f;
tri->verts[ 2 ].Clear();
tri->verts[ 2 ].normal.Set( 1.0f, 0.0f, 0.0f );
tri->verts[ 2 ].tangents[0].Set( 0.0f, 1.0f, 0.0f );
tri->verts[ 2 ].tangents[1].Set( 0.0f, 0.0f, 1.0f );
tri->verts[ 2 ].st[ 0 ] = 1.0f;
tri->verts[ 2 ].st[ 1 ] = 1.0f;
tri->verts[ 3 ].Clear();
tri->verts[ 3 ].normal.Set( 1.0f, 0.0f, 0.0f );
tri->verts[ 3 ].tangents[0].Set( 0.0f, 1.0f, 0.0f );
tri->verts[ 3 ].tangents[1].Set( 0.0f, 0.0f, 1.0f );
tri->verts[ 3 ].st[ 0 ] = 0.0f;
tri->verts[ 3 ].st[ 1 ] = 1.0f;
tri->indexes[ 0 ] = 0;
tri->indexes[ 1 ] = 1;
tri->indexes[ 2 ] = 3;
tri->indexes[ 3 ] = 1;
tri->indexes[ 4 ] = 2;
tri->indexes[ 5 ] = 3;
tri->numVerts = 4;
tri->numIndexes = 6;
surf.geometry = tri;
surf.id = 0;
surf.shader = tr.defaultMaterial;
staticModel->AddSurface( surf );
}
int red = idMath::FtoiFast( renderEntity->shaderParms[ SHADERPARM_RED ] * 255.0f );
int green = idMath::FtoiFast( renderEntity->shaderParms[ SHADERPARM_GREEN ] * 255.0f );
int blue = idMath::FtoiFast( renderEntity->shaderParms[ SHADERPARM_BLUE ] * 255.0f );
int alpha = idMath::FtoiFast( renderEntity->shaderParms[ SHADERPARM_ALPHA ] * 255.0f );
idVec3 right = idVec3( 0.0f, renderEntity->shaderParms[ SHADERPARM_SPRITE_WIDTH ] * 0.5f, 0.0f );
idVec3 up = idVec3( 0.0f, 0.0f, renderEntity->shaderParms[ SHADERPARM_SPRITE_HEIGHT ] * 0.5f );
tri->verts[ 0 ].xyz = up + right;
tri->verts[ 0 ].color[ 0 ] = red;
tri->verts[ 0 ].color[ 1 ] = green;
tri->verts[ 0 ].color[ 2 ] = blue;
tri->verts[ 0 ].color[ 3 ] = alpha;
tri->verts[ 1 ].xyz = up - right;
tri->verts[ 1 ].color[ 0 ] = red;
tri->verts[ 1 ].color[ 1 ] = green;
tri->verts[ 1 ].color[ 2 ] = blue;
tri->verts[ 1 ].color[ 3 ] = alpha;
tri->verts[ 2 ].xyz = - right - up;
tri->verts[ 2 ].color[ 0 ] = red;
tri->verts[ 2 ].color[ 1 ] = green;
tri->verts[ 2 ].color[ 2 ] = blue;
tri->verts[ 2 ].color[ 3 ] = alpha;
tri->verts[ 3 ].xyz = right - up;
tri->verts[ 3 ].color[ 0 ] = red;
tri->verts[ 3 ].color[ 1 ] = green;
tri->verts[ 3 ].color[ 2 ] = blue;
tri->verts[ 3 ].color[ 3 ] = alpha;
R_BoundTriSurf( tri );
staticModel->bounds = tri->bounds;
return staticModel;
}
/*
=====================
R_CreateVertexProgramTurboShadowVolume
are dangling edges that are outside the light frustum still making planes?
=====================
*/
srfTriangles_t *R_CreateVertexProgramTurboShadowVolume( const idRenderEntityLocal *ent,
const srfTriangles_t *tri, const idRenderLightLocal *light,
srfCullInfo_t &cullInfo ) {
int i, j;
srfTriangles_t *newTri;
silEdge_t *sil;
const glIndex_t *indexes;
const byte *facing;
R_CalcInteractionFacing( ent, tri, light, cullInfo );
if ( r_useShadowProjectedCull.GetBool() ) {
R_CalcInteractionCullBits( ent, tri, light, cullInfo );
}
int numFaces = tri->numIndexes / 3;
int numShadowingFaces = 0;
facing = cullInfo.facing;
// if all the triangles are inside the light frustum
if ( cullInfo.cullBits == LIGHT_CULL_ALL_FRONT || !r_useShadowProjectedCull.GetBool() ) {
// count the number of shadowing faces
for ( i = 0; i < numFaces; i++ ) {
numShadowingFaces += facing[i];
}
numShadowingFaces = numFaces - numShadowingFaces;
} else {
// make all triangles that are outside the light frustum "facing", so they won't cast shadows
indexes = tri->indexes;
byte *modifyFacing = cullInfo.facing;
const byte *cullBits = cullInfo.cullBits;
for ( j = i = 0; i < tri->numIndexes; i += 3, j++ ) {
if ( !modifyFacing[j] ) {
int i1 = indexes[i+0];
int i2 = indexes[i+1];
int i3 = indexes[i+2];
if ( cullBits[i1] & cullBits[i2] & cullBits[i3] ) {
modifyFacing[j] = 1;
} else {
numShadowingFaces++;
}
}
}
}
if ( !numShadowingFaces ) {
// no faces are inside the light frustum and still facing the right way
return NULL;
}
// shadowVerts will be NULL on these surfaces, so the shadowVerts will be taken from the ambient surface
newTri = R_AllocStaticTriSurf();
newTri->numVerts = tri->numVerts * 2;
// alloc the max possible size
#ifdef USE_TRI_DATA_ALLOCATOR
R_AllocStaticTriSurfIndexes( newTri, ( numShadowingFaces + tri->numSilEdges ) * 6 );
glIndex_t *tempIndexes = newTri->indexes;
glIndex_t *shadowIndexes = newTri->indexes;
#else
glIndex_t *tempIndexes = (glIndex_t *)_alloca16( tri->numSilEdges * 6 * sizeof( tempIndexes[0] ) );
glIndex_t *shadowIndexes = tempIndexes;
#endif
// create new triangles along sil planes
for ( sil = tri->silEdges, i = tri->numSilEdges; i > 0; i--, sil++ ) {
int f1 = facing[sil->p1];
int f2 = facing[sil->p2];
if ( !( f1 ^ f2 ) ) {
continue;
}
int v1 = sil->v1 << 1;
int v2 = sil->v2 << 1;
// set the two triangle winding orders based on facing
// without using a poorly-predictable branch
shadowIndexes[0] = v1;
shadowIndexes[1] = v2 ^ f1;
shadowIndexes[2] = v2 ^ f2;
shadowIndexes[3] = v1 ^ f2;
shadowIndexes[4] = v1 ^ f1;
shadowIndexes[5] = v2 ^ 1;
shadowIndexes += 6;
}
int numShadowIndexes = shadowIndexes - tempIndexes;
// we aren't bothering to separate front and back caps on these
newTri->numIndexes = newTri->numShadowIndexesNoFrontCaps = numShadowIndexes + numShadowingFaces * 6;
newTri->numShadowIndexesNoCaps = numShadowIndexes;
newTri->shadowCapPlaneBits = SHADOW_CAP_INFINITE;
#ifdef USE_TRI_DATA_ALLOCATOR
// decrease the size of the memory block to only store the used indexes
R_ResizeStaticTriSurfIndexes( newTri, newTri->numIndexes );
#else
// allocate memory for the indexes
R_AllocStaticTriSurfIndexes( newTri, newTri->numIndexes );
// copy the indexes we created for the sil planes
SIMDProcessor->Memcpy( newTri->indexes, tempIndexes, numShadowIndexes * sizeof( tempIndexes[0] ) );
#endif
// these have no effect, because they extend to infinity
newTri->bounds.Clear();
// put some faces on the model and some on the distant projection
indexes = tri->indexes;
shadowIndexes = newTri->indexes + numShadowIndexes;
for ( i = 0, j = 0; i < tri->numIndexes; i += 3, j++ ) {
if ( facing[j] ) {
continue;
}
int i0 = indexes[i+0] << 1;
shadowIndexes[2] = i0;
shadowIndexes[3] = i0 ^ 1;
int i1 = indexes[i+1] << 1;
shadowIndexes[1] = i1;
shadowIndexes[4] = i1 ^ 1;
int i2 = indexes[i+2] << 1;
shadowIndexes[0] = i2;
shadowIndexes[5] = i2 ^ 1;
shadowIndexes += 6;
}
return newTri;
}
/*
================
idRenderWorldLocal::ParseModel
================
*/
idRenderModel *idRenderWorldLocal::ParseModel( idLexer *src ) {
idRenderModel *model;
idToken token;
int i, j;
srfTriangles_t *tri;
modelSurface_t surf;
src->ExpectTokenString( "{" );
// parse the name
src->ExpectAnyToken( &token );
model = renderModelManager->AllocModel();
model->InitEmpty( token );
int numSurfaces = src->ParseInt();
if ( numSurfaces < 0 ) {
src->Error( "R_ParseModel: bad numSurfaces" );
}
for ( i = 0 ; i < numSurfaces ; i++ ) {
src->ExpectTokenString( "{" );
src->ExpectAnyToken( &token );
surf.shader = declManager->FindMaterial( token );
((idMaterial*)surf.shader)->AddReference();
tri = R_AllocStaticTriSurf();
surf.geometry = tri;
tri->numVerts = src->ParseInt();
tri->numIndexes = src->ParseInt();
R_AllocStaticTriSurfVerts( tri, tri->numVerts );
for ( j = 0 ; j < tri->numVerts ; j++ ) {
float vec[8];
src->Parse1DMatrix( 8, vec );
tri->verts[j].xyz[0] = vec[0];
tri->verts[j].xyz[1] = vec[1];
tri->verts[j].xyz[2] = vec[2];
tri->verts[j].st[0] = vec[3];
tri->verts[j].st[1] = vec[4];
tri->verts[j].normal[0] = vec[5];
tri->verts[j].normal[1] = vec[6];
tri->verts[j].normal[2] = vec[7];
}
R_AllocStaticTriSurfIndexes( tri, tri->numIndexes );
for ( j = 0 ; j < tri->numIndexes ; j++ ) {
tri->indexes[j] = src->ParseInt();
}
src->ExpectTokenString( "}" );
// add the completed surface to the model
model->AddSurface( surf );
}
src->ExpectTokenString( "}" );
model->FinishSurfaces();
return model;
}
/*
=====================
R_CreateInteractionShadowVolume
Note that dangling edges outside the light frustum don't make silhouette planes because
a triangle outside the light frustum is considered facing and the "fake triangle" on
the outside of the dangling edge is also set to facing: cullInfo.facing[numFaces] = 1;
=====================
*/
static srfTriangles_t *R_CreateInteractionShadowVolume( const idRenderEntityLocal * ent,
const srfTriangles_t * tri, const idRenderLightLocal * light ) {
SCOPED_PROFILE_EVENT( "R_CreateInteractionShadowVolume" );
srfCullInfo_t cullInfo = {};
R_CalcInteractionFacing( ent, tri, light, cullInfo );
R_CalcInteractionCullBits( ent, tri, light, cullInfo );
int numFaces = tri->numIndexes / 3;
int numShadowingFaces = 0;
const byte * facing = cullInfo.facing;
// if all the triangles are inside the light frustum
if ( cullInfo.cullBits == LIGHT_CULL_ALL_FRONT ) {
// count the number of shadowing faces
for ( int i = 0; i < numFaces; i++ ) {
numShadowingFaces += facing[i];
}
numShadowingFaces = numFaces - numShadowingFaces;
} else {
// make all triangles that are outside the light frustum "facing", so they won't cast shadows
const triIndex_t * indexes = tri->indexes;
byte *modifyFacing = cullInfo.facing;
const byte *cullBits = cullInfo.cullBits;
for ( int i = 0, j = 0; i < tri->numIndexes; i += 3, j++ ) {
if ( !modifyFacing[j] ) {
int i1 = indexes[i+0];
int i2 = indexes[i+1];
int i3 = indexes[i+2];
if ( cullBits[i1] & cullBits[i2] & cullBits[i3] ) {
modifyFacing[j] = 1;
} else {
numShadowingFaces++;
}
}
}
}
if ( !numShadowingFaces ) {
// no faces are inside the light frustum and still facing the right way
R_FreeInteractionCullInfo( cullInfo );
return NULL;
}
// shadowVerts will be NULL on these surfaces, so the shadowVerts will be taken from the ambient surface
srfTriangles_t * newTri = R_AllocStaticTriSurf();
newTri->numVerts = tri->numVerts * 2;
// alloc the max possible size
R_AllocStaticTriSurfIndexes( newTri, ( numShadowingFaces + tri->numSilEdges ) * 6 );
triIndex_t * tempIndexes = newTri->indexes;
triIndex_t * shadowIndexes = newTri->indexes;
// create new triangles along sil planes
const silEdge_t * sil = tri->silEdges;
for ( int i = tri->numSilEdges; i > 0; i--, sil++ ) {
int f1 = facing[sil->p1];
int f2 = facing[sil->p2];
if ( !( f1 ^ f2 ) ) {
continue;
}
int v1 = sil->v1 << 1;
int v2 = sil->v2 << 1;
// set the two triangle winding orders based on facing
// without using a poorly-predictable branch
shadowIndexes[0] = v1;
shadowIndexes[1] = v2 ^ f1;
shadowIndexes[2] = v2 ^ f2;
shadowIndexes[3] = v1 ^ f2;
shadowIndexes[4] = v1 ^ f1;
shadowIndexes[5] = v2 ^ 1;
shadowIndexes += 6;
}
int numShadowIndexes = shadowIndexes - tempIndexes;
// we aren't bothering to separate front and back caps on these
newTri->numIndexes = newTri->numShadowIndexesNoFrontCaps = numShadowIndexes + numShadowingFaces * 6;
newTri->numShadowIndexesNoCaps = numShadowIndexes;
newTri->shadowCapPlaneBits = SHADOW_CAP_INFINITE;
// decrease the size of the memory block to only store the used indexes
// R_ResizeStaticTriSurfIndexes( newTri, newTri->numIndexes );
// these have no effect, because they extend to infinity
newTri->bounds.Clear();
// put some faces on the model and some on the distant projection
const triIndex_t * indexes = tri->indexes;
shadowIndexes = newTri->indexes + numShadowIndexes;
for ( int i = 0, j = 0; i < tri->numIndexes; i += 3, j++ ) {
if ( facing[j] ) {
continue;
}
int i0 = indexes[i+0] << 1;
int i1 = indexes[i+1] << 1;
int i2 = indexes[i+2] << 1;
shadowIndexes[0] = i2;
shadowIndexes[1] = i1;
shadowIndexes[2] = i0;
shadowIndexes[3] = i0 ^ 1;
shadowIndexes[4] = i1 ^ 1;
shadowIndexes[5] = i2 ^ 1;
shadowIndexes += 6;
}
R_FreeInteractionCullInfo( cullInfo );
return newTri;
}
/*
====================
idRenderModelPrt::InstantiateDynamicModel
====================
*/
idRenderModel* idRenderModelPrt::InstantiateDynamicModel( const struct renderEntity_s* renderEntity, const viewDef_t* viewDef, idRenderModel* cachedModel )
{
idRenderModelStatic* staticModel;
if( cachedModel && !r_useCachedDynamicModels.GetBool() )
{
delete cachedModel;
cachedModel = NULL;
}
// this may be triggered by a model trace or other non-view related source, to which we should look like an empty model
if( renderEntity == NULL || viewDef == NULL )
{
delete cachedModel;
return NULL;
}
if( r_skipParticles.GetBool() )
{
delete cachedModel;
return NULL;
}
/*
// if the entire system has faded out
if ( renderEntity->shaderParms[SHADERPARM_PARTICLE_STOPTIME] && viewDef->renderView.time * 0.001f >= renderEntity->shaderParms[SHADERPARM_PARTICLE_STOPTIME] ) {
delete cachedModel;
return NULL;
}
*/
if( cachedModel != NULL )
{
assert( dynamic_cast<idRenderModelStatic*>( cachedModel ) != NULL );
assert( idStr::Icmp( cachedModel->Name(), parametricParticle_SnapshotName ) == 0 );
staticModel = static_cast<idRenderModelStatic*>( cachedModel );
}
else
{
staticModel = new( TAG_MODEL ) idRenderModelStatic;
staticModel->InitEmpty( parametricParticle_SnapshotName );
}
particleGen_t g;
g.renderEnt = renderEntity;
g.renderView = &viewDef->renderView;
g.origin.Zero();
g.axis.Identity();
for( int stageNum = 0; stageNum < particleSystem->stages.Num(); stageNum++ )
{
idParticleStage* stage = particleSystem->stages[stageNum];
if( !stage->material )
{
continue;
}
if( !stage->cycleMsec )
{
continue;
}
if( stage->hidden ) // just for gui particle editor use
{
staticModel->DeleteSurfaceWithId( stageNum );
continue;
}
idRandom steppingRandom, steppingRandom2;
int stageAge = g.renderView->time[renderEntity->timeGroup] + renderEntity->shaderParms[SHADERPARM_TIMEOFFSET] * 1000 - stage->timeOffset * 1000;
int stageCycle = stageAge / stage->cycleMsec;
// some particles will be in this cycle, some will be in the previous cycle
steppingRandom.SetSeed( ( ( stageCycle << 10 ) & idRandom::MAX_RAND ) ^ ( int )( renderEntity->shaderParms[SHADERPARM_DIVERSITY] * idRandom::MAX_RAND ) );
steppingRandom2.SetSeed( ( ( ( stageCycle - 1 ) << 10 ) & idRandom::MAX_RAND ) ^ ( int )( renderEntity->shaderParms[SHADERPARM_DIVERSITY] * idRandom::MAX_RAND ) );
int count = stage->totalParticles * stage->NumQuadsPerParticle();
int surfaceNum;
modelSurface_t* surf;
if( staticModel->FindSurfaceWithId( stageNum, surfaceNum ) )
{
surf = &staticModel->surfaces[surfaceNum];
R_FreeStaticTriSurfVertexCaches( surf->geometry );
}
else
{
surf = &staticModel->surfaces.Alloc();
surf->id = stageNum;
surf->shader = stage->material;
surf->geometry = R_AllocStaticTriSurf();
R_AllocStaticTriSurfVerts( surf->geometry, 4 * count );
R_AllocStaticTriSurfIndexes( surf->geometry, 6 * count );
}
int numVerts = 0;
idDrawVert* verts = surf->geometry->verts;
for( int index = 0; index < stage->totalParticles; index++ )
{
g.index = index;
// bump the random
steppingRandom.RandomInt();
steppingRandom2.RandomInt();
// calculate local age for this index
int bunchOffset = stage->particleLife * 1000 * stage->spawnBunching * index / stage->totalParticles;
int particleAge = stageAge - bunchOffset;
int particleCycle = particleAge / stage->cycleMsec;
if( particleCycle < 0 )
{
// before the particleSystem spawned
continue;
}
if( stage->cycles && particleCycle >= stage->cycles )
{
// cycled systems will only run cycle times
continue;
}
if( particleCycle == stageCycle )
{
g.random = steppingRandom;
}
else
{
g.random = steppingRandom2;
}
int inCycleTime = particleAge - particleCycle * stage->cycleMsec;
if( renderEntity->shaderParms[SHADERPARM_PARTICLE_STOPTIME] &&
g.renderView->time[renderEntity->timeGroup] - inCycleTime >= renderEntity->shaderParms[SHADERPARM_PARTICLE_STOPTIME] * 1000 )
{
// don't fire any more particles
continue;
}
// supress particles before or after the age clamp
g.frac = ( float )inCycleTime / ( stage->particleLife * 1000 );
if( g.frac < 0.0f )
{
// yet to be spawned
continue;
}
if( g.frac > 1.0f )
{
// this particle is in the deadTime band
continue;
}
// this is needed so aimed particles can calculate origins at different times
g.originalRandom = g.random;
g.age = g.frac * stage->particleLife;
// if the particle doesn't get drawn because it is faded out or beyond a kill region, don't increment the verts
numVerts += stage->CreateParticle( &g, verts + numVerts );
}
// numVerts must be a multiple of 4
assert( ( numVerts & 3 ) == 0 && numVerts <= 4 * count );
// build the indexes
int numIndexes = 0;
triIndex_t* indexes = surf->geometry->indexes;
for( int i = 0; i < numVerts; i += 4 )
{
indexes[numIndexes + 0] = i + 0;
indexes[numIndexes + 1] = i + 2;
indexes[numIndexes + 2] = i + 3;
indexes[numIndexes + 3] = i + 0;
indexes[numIndexes + 4] = i + 3;
indexes[numIndexes + 5] = i + 1;
numIndexes += 6;
}
surf->geometry->tangentsCalculated = false;
surf->geometry->numVerts = numVerts;
surf->geometry->numIndexes = numIndexes;
surf->geometry->bounds = stage->bounds; // just always draw the particles
}
return staticModel;
}
static int lgeo_new(lua_State* L)
{
srfTriangles_s** obj = (srfTriangles_s **)lua_newuserdata(L, sizeof(srfTriangles_s*));
*obj = R_AllocStaticTriSurf();
return 1;
}
/*
================
idRenderWorldLocal::ParseModel
================
*/
idRenderModel* idRenderWorldLocal::ParseModel( idLexer* src, const char* mapName, ID_TIME_T mapTimeStamp, idFile* fileOut )
{
idToken token;
src->ExpectTokenString( "{" );
// parse the name
src->ExpectAnyToken( &token );
idRenderModel* model = renderModelManager->AllocModel();
model->InitEmpty( token );
if( fileOut != NULL )
{
// write out the type so the binary reader knows what to instantiate
fileOut->WriteString( "shadowmodel" );
fileOut->WriteString( token );
}
int numSurfaces = src->ParseInt();
if( numSurfaces < 0 )
{
src->Error( "R_ParseModel: bad numSurfaces" );
}
for( int i = 0; i < numSurfaces; i++ )
{
src->ExpectTokenString( "{" );
src->ExpectAnyToken( &token );
modelSurface_t surf;
surf.shader = declManager->FindMaterial( token );
( ( idMaterial* )surf.shader )->AddReference();
srfTriangles_t* tri = R_AllocStaticTriSurf();
surf.geometry = tri;
tri->numVerts = src->ParseInt();
tri->numIndexes = src->ParseInt();
// parse the vertices
idTempArray<float> verts( tri->numVerts * 8 );
for( int j = 0; j < tri->numVerts; j++ )
{
src->Parse1DMatrix( 8, &verts[j * 8] );
}
// parse the indices
idTempArray<triIndex_t> indexes( tri->numIndexes );
for( int j = 0; j < tri->numIndexes; j++ )
{
indexes[j] = src->ParseInt();
}
#if 1
// find the island that each vertex belongs to
idTempArray<int> vertIslands( tri->numVerts );
idTempArray<bool> trisVisited( tri->numIndexes );
vertIslands.Zero();
trisVisited.Zero();
int numIslands = 0;
for( int j = 0; j < tri->numIndexes; j += 3 )
{
if( trisVisited[j] )
{
continue;
}
int islandNum = ++numIslands;
vertIslands[indexes[j + 0]] = islandNum;
vertIslands[indexes[j + 1]] = islandNum;
vertIslands[indexes[j + 2]] = islandNum;
trisVisited[j] = true;
idList<int> queue;
queue.Append( j );
for( int n = 0; n < queue.Num(); n++ )
{
int t = queue[n];
for( int k = 0; k < tri->numIndexes; k += 3 )
{
if( trisVisited[k] )
{
continue;
}
bool connected = indexes[t + 0] == indexes[k + 0] || indexes[t + 0] == indexes[k + 1] || indexes[t + 0] == indexes[k + 2] ||
indexes[t + 1] == indexes[k + 0] || indexes[t + 1] == indexes[k + 1] || indexes[t + 1] == indexes[k + 2] ||
indexes[t + 2] == indexes[k + 0] || indexes[t + 2] == indexes[k + 1] || indexes[t + 2] == indexes[k + 2];
if( connected )
{
vertIslands[indexes[k + 0]] = islandNum;
vertIslands[indexes[k + 1]] = islandNum;
vertIslands[indexes[k + 2]] = islandNum;
trisVisited[k] = true;
queue.Append( k );
}
}
}
}
// center the texture coordinates for each island for maximum 16-bit precision
for( int j = 1; j <= numIslands; j++ )
{
float minS = idMath::INFINITY;
float minT = idMath::INFINITY;
float maxS = -idMath::INFINITY;
float maxT = -idMath::INFINITY;
for( int k = 0; k < tri->numVerts; k++ )
{
if( vertIslands[k] == j )
{
minS = Min( minS, verts[k * 8 + 3] );
maxS = Max( maxS, verts[k * 8 + 3] );
minT = Min( minT, verts[k * 8 + 4] );
maxT = Max( maxT, verts[k * 8 + 4] );
}
}
const float averageS = idMath::Ftoi( ( minS + maxS ) * 0.5f );
const float averageT = idMath::Ftoi( ( minT + maxT ) * 0.5f );
for( int k = 0; k < tri->numVerts; k++ )
{
if( vertIslands[k] == j )
{
verts[k * 8 + 3] -= averageS;
verts[k * 8 + 4] -= averageT;
}
}
}
#endif
R_AllocStaticTriSurfVerts( tri, tri->numVerts );
for( int j = 0; j < tri->numVerts; j++ )
{
tri->verts[j].xyz[0] = verts[j * 8 + 0];
tri->verts[j].xyz[1] = verts[j * 8 + 1];
tri->verts[j].xyz[2] = verts[j * 8 + 2];
tri->verts[j].SetTexCoord( verts[j * 8 + 3], verts[j * 8 + 4] );
tri->verts[j].SetNormal( verts[j * 8 + 5], verts[j * 8 + 6], verts[j * 8 + 7] );
}
R_AllocStaticTriSurfIndexes( tri, tri->numIndexes );
for( int j = 0; j < tri->numIndexes; j++ )
{
tri->indexes[j] = indexes[j];
}
src->ExpectTokenString( "}" );
// add the completed surface to the model
model->AddSurface( surf );
}
src->ExpectTokenString( "}" );
model->FinishSurfaces();
if( fileOut != NULL && model->SupportsBinaryModel() && r_binaryLoadRenderModels.GetBool() )
{
model->WriteBinaryModel( fileOut, &mapTimeStamp );
}
return model;
}
bool MeshLoaderB3D::ReadVrts() {
const int max_tex_coords = 3;
int flags, tex_coord_sets, tex_coord_set_size;
_file->ReadInt(flags);
_file->ReadInt(tex_coord_sets);
_file->ReadInt(tex_coord_set_size);
if (tex_coord_sets >= max_tex_coords || tex_coord_set_size >= 4) // Something is wrong
{
Sys_Printf("tex_coord_sets or tex_coord_set_size too big");
return false;
}
//------ Allocate Memory, for speed -----------//
int sizeOfVertex = 3;
bool hasNormal = false;
bool hasVertexColors = false;
if (flags & 1) {
hasNormal = true;
sizeOfVertex += 3;
}
if (flags & 2) {
sizeOfVertex += 4;
hasVertexColors=true;
}
sizeOfVertex += tex_coord_sets*tex_coord_set_size;
unsigned int size = _stack[_stackIndex-1] - _file->Tell();
//106407 16800
unsigned int numVertex = size / sizeof(float) ;
numVertex /= sizeOfVertex;
srfTriangles_t* tri = R_AllocStaticTriSurf();
R_AllocStaticTriSurfVerts(tri, numVertex);
tri->numVerts = numVertex;
int idx = 0;
while( CheckSize()) {
float color[4]={1.0f, 1.0f, 1.0f, 1.0f};
_file->ReadVec3(tri->verts[idx].xyz);
if (flags & 1) {
_file->ReadVec3(tri->verts[idx].normal);
}
if (flags & 2) {
_file->ReadFloat(color[0]);
_file->ReadFloat(color[1]);
_file->ReadFloat(color[2]);
_file->ReadFloat(color[3]);
}
float u, v;
for (int i = 0; i < tex_coord_sets; ++i) {
//for (int j = 0; j < tex_coord_set_size; ++j)
{
_file->ReadFloat(u);
_file->ReadFloat(v);
//v = 1 - v;
}
}
tri->verts[idx].st = idVec2(u, v);
idx++;
}
modelSurface_t modelSurf;
modelSurf.id = _surfaces.Size();
modelSurf.shader = declManager->FindMaterial("textures/ninja/ninja");
modelSurf.geometry = tri;
_surfaces.Append(modelSurf);
return true;
}
/*
====================
idMD5Mesh::UpdateSurface
====================
*/
void idMD5Mesh::UpdateSurface( const struct renderEntity_s *ent, const idJointMat *entJoints, modelSurface_t *surf ) {
int i, base;
srfTriangles_t *tri;
tr.pc.c_deformedSurfaces++;
tr.pc.c_deformedVerts += deformInfo->numOutputVerts;
tr.pc.c_deformedIndexes += deformInfo->numIndexes;
surf->shader = shader;
if ( surf->geometry ) {
// if the number of verts and indexes are the same we can re-use the triangle surface
// the number of indexes must be the same to assure the correct amount of memory is allocated for the facePlanes
if ( surf->geometry->numVerts == deformInfo->numOutputVerts && surf->geometry->numIndexes == deformInfo->numIndexes ) {
R_FreeStaticTriSurfVertexCaches( surf->geometry );
} else {
R_FreeStaticTriSurf( surf->geometry );
surf->geometry = R_AllocStaticTriSurf();
}
} else {
surf->geometry = R_AllocStaticTriSurf();
}
tri = surf->geometry;
// note that some of the data is references, and should not be freed
tri->deformedSurface = true;
tri->tangentsCalculated = false;
tri->facePlanesCalculated = false;
tri->numIndexes = deformInfo->numIndexes;
tri->indexes = deformInfo->indexes;
tri->silIndexes = deformInfo->silIndexes;
tri->numMirroredVerts = deformInfo->numMirroredVerts;
tri->mirroredVerts = deformInfo->mirroredVerts;
tri->numDupVerts = deformInfo->numDupVerts;
tri->dupVerts = deformInfo->dupVerts;
tri->numSilEdges = deformInfo->numSilEdges;
tri->silEdges = deformInfo->silEdges;
tri->dominantTris = deformInfo->dominantTris;
tri->numVerts = deformInfo->numOutputVerts;
if ( tri->verts == NULL ) {
R_AllocStaticTriSurfVerts( tri, tri->numVerts );
for ( i = 0; i < deformInfo->numSourceVerts; i++ ) {
tri->verts[i].Clear();
tri->verts[i].st = texCoords[i];
}
}
if ( ent->shaderParms[ SHADERPARM_MD5_SKINSCALE ] != 0.0f ) {
TransformScaledVerts( tri->verts, entJoints, ent->shaderParms[ SHADERPARM_MD5_SKINSCALE ] );
} else {
TransformVerts( tri->verts, entJoints );
}
// replicate the mirror seam vertexes
base = deformInfo->numOutputVerts - deformInfo->numMirroredVerts;
for ( i = 0; i < deformInfo->numMirroredVerts; i++ ) {
tri->verts[base + i] = tri->verts[deformInfo->mirroredVerts[i]];
}
R_BoundTriSurf( tri );
// If a surface is going to be have a lighting interaction generated, it will also have to call
// R_DeriveTangents() to get normals, tangents, and face planes. If it only
// needs shadows generated, it will only have to generate face planes. If it only
// has ambient drawing, or is culled, no additional work will be necessary
if ( !r_useDeferredTangents.GetBool() ) {
// set face planes, vertex normals, tangents
R_DeriveTangents( tri );
}
}
/*
====================
R_CreateLightTris
The resulting surface will be a subset of the original triangles,
it will never clip triangles, but it may cull on a per-triangle basis.
====================
*/
static srfTriangles_t *R_CreateLightTris( const idRenderEntityLocal *ent,
const srfTriangles_t *tri, const idRenderLightLocal *light,
const idMaterial *shader, srfCullInfo_t &cullInfo ) {
int i;
int numIndexes;
glIndex_t *indexes;
srfTriangles_t *newTri;
int c_backfaced;
int c_distance;
idBounds bounds;
bool includeBackFaces;
int faceNum;
tr.pc.c_createLightTris++;
c_backfaced = 0;
c_distance = 0;
numIndexes = 0;
indexes = NULL;
// it is debatable if non-shadowing lights should light back faces. we aren't at the moment
if ( r_lightAllBackFaces.GetBool() || light->lightShader->LightEffectsBackSides()
|| shader->ReceivesLightingOnBackSides()
|| ent->parms.noSelfShadow || ent->parms.noShadow ) {
includeBackFaces = true;
} else {
includeBackFaces = false;
}
// allocate a new surface for the lit triangles
newTri = R_AllocStaticTriSurf();
// save a reference to the original surface
newTri->ambientSurface = const_cast<srfTriangles_t *>(tri);
// the light surface references the verts of the ambient surface
newTri->numVerts = tri->numVerts;
R_ReferenceStaticTriSurfVerts( newTri, tri );
// calculate cull information
if ( !includeBackFaces ) {
R_CalcInteractionFacing( ent, tri, light, cullInfo );
}
R_CalcInteractionCullBits( ent, tri, light, cullInfo );
// if the surface is completely inside the light frustum
if ( cullInfo.cullBits == LIGHT_CULL_ALL_FRONT ) {
// if we aren't self shadowing, let back facing triangles get
// through so the smooth shaded bump maps light all the way around
if ( includeBackFaces ) {
// the whole surface is lit so the light surface just references the indexes of the ambient surface
R_ReferenceStaticTriSurfIndexes( newTri, tri );
numIndexes = tri->numIndexes;
bounds = tri->bounds;
} else {
// the light tris indexes are going to be a subset of the original indexes so we generally
// allocate too much memory here but we decrease the memory block when the number of indexes is known
R_AllocStaticTriSurfIndexes( newTri, tri->numIndexes );
// back face cull the individual triangles
indexes = newTri->indexes;
const byte *facing = cullInfo.facing;
for ( faceNum = i = 0; i < tri->numIndexes; i += 3, faceNum++ ) {
if ( !facing[ faceNum ] ) {
c_backfaced++;
continue;
}
indexes[numIndexes+0] = tri->indexes[i+0];
indexes[numIndexes+1] = tri->indexes[i+1];
indexes[numIndexes+2] = tri->indexes[i+2];
numIndexes += 3;
}
// get bounds for the surface
SIMDProcessor->MinMax( bounds[0], bounds[1], tri->verts, indexes, numIndexes );
// decrease the size of the memory block to the size of the number of used indexes
R_ResizeStaticTriSurfIndexes( newTri, numIndexes );
}
} else {
// the light tris indexes are going to be a subset of the original indexes so we generally
// allocate too much memory here but we decrease the memory block when the number of indexes is known
R_AllocStaticTriSurfIndexes( newTri, tri->numIndexes );
// cull individual triangles
indexes = newTri->indexes;
const byte *facing = cullInfo.facing;
const byte *cullBits = cullInfo.cullBits;
for ( faceNum = i = 0; i < tri->numIndexes; i += 3, faceNum++ ) {
int i1, i2, i3;
// if we aren't self shadowing, let back facing triangles get
// through so the smooth shaded bump maps light all the way around
if ( !includeBackFaces ) {
// back face cull
if ( !facing[ faceNum ] ) {
c_backfaced++;
continue;
}
}
i1 = tri->indexes[i+0];
i2 = tri->indexes[i+1];
i3 = tri->indexes[i+2];
// fast cull outside the frustum
// if all three points are off one plane side, it definately isn't visible
if ( cullBits[i1] & cullBits[i2] & cullBits[i3] ) {
c_distance++;
continue;
}
if ( r_usePreciseTriangleInteractions.GetBool() ) {
// do a precise clipped cull if none of the points is completely inside the frustum
// note that we do not actually use the clipped triangle, which would have Z fighting issues.
if ( cullBits[i1] && cullBits[i2] && cullBits[i3] ) {
int cull = cullBits[i1] | cullBits[i2] | cullBits[i3];
if ( !R_ClipTriangleToLight( tri->verts[i1].xyz, tri->verts[i2].xyz, tri->verts[i3].xyz, cull, cullInfo.localClipPlanes ) ) {
continue;
}
}
}
// add to the list
indexes[numIndexes+0] = i1;
indexes[numIndexes+1] = i2;
indexes[numIndexes+2] = i3;
numIndexes += 3;
}
// get bounds for the surface
SIMDProcessor->MinMax( bounds[0], bounds[1], tri->verts, indexes, numIndexes );
// decrease the size of the memory block to the size of the number of used indexes
R_ResizeStaticTriSurfIndexes( newTri, numIndexes );
}
if ( !numIndexes ) {
R_ReallyFreeStaticTriSurf( newTri );
return NULL;
}
newTri->numIndexes = numIndexes;
newTri->bounds = bounds;
return newTri;
}
/*
===============
idRenderModelBeam::InstantiateDynamicModel
===============
*/
idRenderModel *idRenderModelBeam::InstantiateDynamicModel(const struct renderEntity_s *renderEntity, const struct viewDef_s *viewDef, idRenderModel *cachedModel)
{
idRenderModelStatic *staticModel;
srfTriangles_t *tri;
modelSurface_t surf;
if (cachedModel) {
delete cachedModel;
cachedModel = NULL;
}
if (renderEntity == NULL || viewDef == NULL) {
delete cachedModel;
return NULL;
}
if (cachedModel != NULL) {
assert(dynamic_cast<idRenderModelStatic *>(cachedModel) != NULL);
assert(idStr::Icmp(cachedModel->Name(), beam_SnapshotName) == 0);
staticModel = static_cast<idRenderModelStatic *>(cachedModel);
surf = *staticModel->Surface(0);
tri = surf.geometry;
} else {
staticModel = new idRenderModelStatic;
staticModel->InitEmpty(beam_SnapshotName);
tri = R_AllocStaticTriSurf();
R_AllocStaticTriSurfVerts(tri, 4);
R_AllocStaticTriSurfIndexes(tri, 6);
tri->verts[0].Clear();
tri->verts[0].st[0] = 0;
tri->verts[0].st[1] = 0;
tri->verts[1].Clear();
tri->verts[1].st[0] = 0;
tri->verts[1].st[1] = 1;
tri->verts[2].Clear();
tri->verts[2].st[0] = 1;
tri->verts[2].st[1] = 0;
tri->verts[3].Clear();
tri->verts[3].st[0] = 1;
tri->verts[3].st[1] = 1;
tri->indexes[0] = 0;
tri->indexes[1] = 2;
tri->indexes[2] = 1;
tri->indexes[3] = 2;
tri->indexes[4] = 3;
tri->indexes[5] = 1;
tri->numVerts = 4;
tri->numIndexes = 6;
surf.geometry = tri;
surf.id = 0;
surf.shader = tr.defaultMaterial;
staticModel->AddSurface(surf);
}
idVec3 target = *reinterpret_cast<const idVec3 *>(&renderEntity->shaderParms[SHADERPARM_BEAM_END_X]);
// we need the view direction to project the minor axis of the tube
// as the view changes
idVec3 localView, localTarget;
float modelMatrix[16];
R_AxisToModelMatrix(renderEntity->axis, renderEntity->origin, modelMatrix);
R_GlobalPointToLocal(modelMatrix, viewDef->renderView.vieworg, localView);
R_GlobalPointToLocal(modelMatrix, target, localTarget);
idVec3 major = localTarget;
idVec3 minor;
idVec3 mid = 0.5f * localTarget;
idVec3 dir = mid - localView;
minor.Cross(major, dir);
minor.Normalize();
if (renderEntity->shaderParms[SHADERPARM_BEAM_WIDTH] != 0.0f) {
minor *= renderEntity->shaderParms[SHADERPARM_BEAM_WIDTH] * 0.5f;
}
int red = idMath::FtoiFast(renderEntity->shaderParms[SHADERPARM_RED] * 255.0f);
int green = idMath::FtoiFast(renderEntity->shaderParms[SHADERPARM_GREEN] * 255.0f);
int blue = idMath::FtoiFast(renderEntity->shaderParms[SHADERPARM_BLUE] * 255.0f);
int alpha = idMath::FtoiFast(renderEntity->shaderParms[SHADERPARM_ALPHA] * 255.0f);
tri->verts[0].xyz = minor;
tri->verts[0].color[0] = red;
tri->verts[0].color[1] = green;
tri->verts[0].color[2] = blue;
tri->verts[0].color[3] = alpha;
tri->verts[1].xyz = -minor;
tri->verts[1].color[0] = red;
tri->verts[1].color[1] = green;
tri->verts[1].color[2] = blue;
tri->verts[1].color[3] = alpha;
tri->verts[2].xyz = localTarget + minor;
tri->verts[2].color[0] = red;
tri->verts[2].color[1] = green;
tri->verts[2].color[2] = blue;
tri->verts[2].color[3] = alpha;
tri->verts[3].xyz = localTarget - minor;
tri->verts[3].color[0] = red;
tri->verts[3].color[1] = green;
tri->verts[3].color[2] = blue;
tri->verts[3].color[3] = alpha;
R_BoundTriSurf(tri);
staticModel->bounds = tri->bounds;
return staticModel;
}
/*
================
idRenderWorldLocal::ParseShadowModel
================
*/
idRenderModel* idRenderWorldLocal::ParseShadowModel( idLexer* src, idFile* fileOut )
{
idToken token;
src->ExpectTokenString( "{" );
// parse the name
src->ExpectAnyToken( &token );
idRenderModel* model = renderModelManager->AllocModel();
model->InitEmpty( token );
if( fileOut != NULL )
{
// write out the type so the binary reader knows what to instantiate
fileOut->WriteString( "shadowmodel" );
fileOut->WriteString( token );
}
srfTriangles_t* tri = R_AllocStaticTriSurf();
tri->numVerts = src->ParseInt();
tri->numShadowIndexesNoCaps = src->ParseInt();
tri->numShadowIndexesNoFrontCaps = src->ParseInt();
tri->numIndexes = src->ParseInt();
tri->shadowCapPlaneBits = src->ParseInt();
assert( ( tri->numVerts & 1 ) == 0 );
R_AllocStaticTriSurfPreLightShadowVerts( tri, ALIGN( tri->numVerts, 2 ) );
tri->bounds.Clear();
for( int j = 0; j < tri->numVerts; j++ )
{
float vec[8];
src->Parse1DMatrix( 3, vec );
tri->preLightShadowVertexes[j].xyzw[0] = vec[0];
tri->preLightShadowVertexes[j].xyzw[1] = vec[1];
tri->preLightShadowVertexes[j].xyzw[2] = vec[2];
tri->preLightShadowVertexes[j].xyzw[3] = 1.0f; // no homogenous value
tri->bounds.AddPoint( tri->preLightShadowVertexes[j].xyzw.ToVec3() );
}
// clear the last vertex if it wasn't stored
if( ( tri->numVerts & 1 ) != 0 )
{
tri->preLightShadowVertexes[ALIGN( tri->numVerts, 2 ) - 1].xyzw.Zero();
}
// to be consistent set the number of vertices to half the number of shadow vertices
tri->numVerts = ALIGN( tri->numVerts, 2 ) / 2;
R_AllocStaticTriSurfIndexes( tri, tri->numIndexes );
for( int j = 0; j < tri->numIndexes; j++ )
{
tri->indexes[j] = src->ParseInt();
}
// add the completed surface to the model
modelSurface_t surf;
surf.id = 0;
surf.shader = tr.defaultMaterial;
surf.geometry = tri;
model->AddSurface( surf );
src->ExpectTokenString( "}" );
// NOTE: we do NOT do a model->FinishSurfaceces, because we don't need sil edges, planes, tangents, etc.
if( fileOut != NULL && model->SupportsBinaryModel() && r_binaryLoadRenderModels.GetBool() )
{
model->WriteBinaryModel( fileOut, &mapTimeStamp );
}
return model;
}
Render::Render(ResourceSystem* resourceSys) : _resourceSys(resourceSys)
{
_drawSurf = R_AllocDrawSurf();
_drawSurf->geo = R_AllocStaticTriSurf();
}