d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
527 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 035861bf52
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '035861bf52'
${ noResults }
source-engine/movieobjects/dmetestmesh.cpp

1757 lines
52 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "movieobjects/dmetestmesh.h"
#include "movieobjects/dmetransform.h"
#include "movieobjects_interfaces.h"
#include "tier0/dbg.h"
#include "datamodel/dmelementfactoryhelper.h"
#include "mathlib/vector.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/imesh.h"
#include "datacache/imdlcache.h"
#include "istudiorender.h"
#include "studio.h"
#include "bone_setup.h"
#include "materialsystem/ivertextexture.h"
#include "morphdata.h"
#include "tier3/tier3.h"
#include <strstream>
#include <fstream>
#include <algorithm>
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------------
// Expose this class to the scene database
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeTestMesh, CDmeTestMesh );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDmeTestMesh::OnConstruction()
{
m_MDLHandle = MDLHANDLE_INVALID;
m_pMaterial = NULL;
m_pMesh = NULL;
m_pMorph = NULL;
m_pControlCage = NULL;
SetValue( "transform", g_pDataModel->IsUnserializing() ? NULL : CreateElement< CDmeTransform >( "transform", GetFileId() ) );
SetValue( "mdlfilename", "models/alyx.mdl" );
SetValue( "morphfilename", "models/alyx.morph" );
SetValue( "skin", 0 );
SetValue( "body", 0 );
SetValue( "sequence", 0 );
SetValue( "lod", 0 );
SetValue( "playbackrate", 1.0f );
SetValue( "time", 0.0f );
SetValue( "subdivlevel", 1 );
}
void CDmeTestMesh::OnDestruction()
{
UnloadMorphData();
UnreferenceMDL();
DestroyControlCage();
DestroyMesh();
}
//-----------------------------------------------------------------------------
// Addref/Release the MDL handle
//-----------------------------------------------------------------------------
void CDmeTestMesh::ReferenceMDL( const char *pMDLName )
{
if ( !g_pMDLCache )
return;
if ( pMDLName && pMDLName[0] )
{
Assert( m_MDLHandle == MDLHANDLE_INVALID );
m_MDLHandle = g_pMDLCache->FindMDL( pMDLName );
}
}
void CDmeTestMesh::UnreferenceMDL()
{
if ( !g_pMDLCache )
return;
if ( m_MDLHandle != MDLHANDLE_INVALID )
{
g_pMDLCache->Release( m_MDLHandle );
m_MDLHandle = MDLHANDLE_INVALID;
}
}
//-----------------------------------------------------------------------------
// Creates the mesh to draw
//-----------------------------------------------------------------------------
void CDmeTestMesh::CreateMesh()
{
DestroyMesh();
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
m_pMaterial = g_pMaterialSystem->FindMaterial( "shadertest/vertextexturetest", NULL, false );
m_pMesh = pRenderContext->CreateStaticMesh( m_pMaterial, 0, "dmemesh" );
CMeshBuilder meshBuilder;
meshBuilder.Begin( m_pMesh, MATERIAL_TRIANGLES, 8, 36 );
// Draw a simple cube
static Vector s_pPositions[8] =
{
Vector( -10, -10, -10 ),
Vector( 10, -10, -10 ),
Vector( -10, 10, -10 ),
Vector( 10, 10, -10 ),
Vector( -10, -10, 10 ),
Vector( 10, -10, 10 ),
Vector( -10, 10, 10 ),
Vector( 10, 10, 10 ),
};
static Vector2D s_pTexCoords[8] =
{
Vector2D( 0, 0 ),
Vector2D( 0.5, 0 ),
Vector2D( 0, 0.5 ),
Vector2D( 0.5, 0.5 ),
Vector2D( 0.5, 0.5 ),
Vector2D( 1, 0.5 ),
Vector2D( 0.5, 1 ),
Vector2D( 1, 1 ),
};
static unsigned char s_pColor[8][3] =
{
{ 255, 255, 255 },
{ 0, 255, 255 },
{ 255, 0, 255 },
{ 255, 255, 0 },
{ 255, 0, 0 },
{ 0, 255, 0 },
{ 0, 0, 255 },
{ 0, 0, 0 },
};
static int s_pIndices[12][3] =
{
{ 0, 1, 5 }, { 0, 5, 4 },
{ 4, 5, 7 }, { 4, 7, 6 },
{ 0, 4, 6 }, { 0, 6, 2 },
{ 0, 2, 3 }, { 0, 3, 1 },
{ 1, 3, 7 }, { 1, 7, 5 },
{ 2, 6, 7 }, { 2, 7, 3 },
};
for ( int i = 0; i < 8; ++i )
{
meshBuilder.Position3fv( s_pPositions[ i ].Base() );
meshBuilder.TexCoord2fv( 0, s_pTexCoords[ i ].Base() );
// meshBuilder.TexCoord2f( 1, i, 0.0f );
meshBuilder.Color3ubv( s_pColor[ i ] );
meshBuilder.AdvanceVertex();
}
for ( int i = 0; i < 12; ++i )
{
meshBuilder.FastIndex( s_pIndices[i][0] );
meshBuilder.FastIndex( s_pIndices[i][1] );
meshBuilder.FastIndex( s_pIndices[i][2] );
}
meshBuilder.End();
}
void CDmeTestMesh::DestroyMesh()
{
if ( m_pMesh )
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->DestroyStaticMesh( m_pMesh );
m_pMesh = NULL;
}
}
//-----------------------------------------------------------------------------
// Morph data
//-----------------------------------------------------------------------------
void CDmeTestMesh::LoadMorphData( const char *pMorphFile, int nVertexCount )
{
UnloadMorphData();
IMorphData *pMorphData = CreateMorphData();
m_pMorph = pMorphData->Compile( pMorphFile, m_pMaterial, nVertexCount );
DestroyMorphData( pMorphData );
}
void CDmeTestMesh::UnloadMorphData()
{
if ( m_pMorph )
{
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->DestroyMorph( m_pMorph );
m_pMorph = NULL;
}
}
//-----------------------------------------------------------------------------
// This function gets called whenever an attribute changes
//-----------------------------------------------------------------------------
void CDmeTestMesh::Resolve()
{
CDmAttribute *pMDLFilename = GetAttribute( "mdlfilename" );
if ( pMDLFilename && pMDLFilename->IsFlagSet( FATTRIB_DIRTY ) )
{
UnreferenceMDL();
ReferenceMDL( GetValueString( "mdlfilename" ) );
return;
}
CDmAttribute *pMorphFilename = GetAttribute( "morphfilename" );
if ( pMorphFilename && pMorphFilename->IsFlagSet( FATTRIB_DIRTY ) )
{
CreateMesh();
UnloadMorphData();
LoadMorphData( GetValueString( "morphfilename" ), 8 );
return;
}
}
//-----------------------------------------------------------------------------
// Loads the model matrix based on the transform
//-----------------------------------------------------------------------------
void CDmeTestMesh::LoadModelMatrix( CDmeTransform *pTransform )
{
// FIXME: Should this go into the DmeTransform node?
matrix3x4_t transform;
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pTransform->GetTransform( transform );
pRenderContext->MatrixMode( MATERIAL_MODEL );
pRenderContext->LoadMatrix( transform );
}
//-----------------------------------------------------------------------------
// A subvision mesh
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// NOTES:
// The subdivision mesh is fast because it assumes a very particular ordering
// and definition of the data so that it can determine all subdivided data by
// inspection without any searching. Here's the layout:
//
// First, a face stores a list of edge indices which reference the edges
// that make up the face. A face is assumed to traverse its vertices in CCW order.
// We define the "relative edge index" for an edge within a face as the
// order in which that edge is visited while traversing the edges in CCW order,
// so 0 is the first visited edge, and 1 is the next, etc.
//
// First, edges are defined in a specific way. The edge is assumed to be
// *directed*, starting at vertex 0 and leading toward vertex 1. Now imagine the
// two faces that shared this edge and that they both traverse their edges in
// a right-handed, or CCW direction. Face 0 associated with the edge, to maintain
// a CCW ordering, must traverse the edge in a *reverse* direction, heading from
// vertex 1 to vertex 0. Face 1 associated with the edge traverses the edge
// in a forward direction, from vertex 0 to vertex 1.
//
// When subdivision happens, it occurs in a very specific way also. First, when
// creating the new vertices, for uniform subdivision, we create a new vertex
// per face, a new vertex per edge, and adjust all existing vertices. When creating
// these vertices in the subdivided mesh, we first add the face midpoint vertices,
// then the edge midpoint vertices, then the vertices from the un-subdivided mesh, to
// the m_Vertices array of the subdivided mesh.
//
// Edge subdivision always works in a uniform way: For each edge in the unsubdivided
// mesh, 4 edges are created from the edge midpoint, connecting to the two
// face midpoint vertices and the two edge endpoints. In order to maintain the
// specific ordering of the edges described above, we define the edges in the
// following manner:
// * Subdivided edge 0 : Starts at face 0 midpoint, ends at edge midpoint
// * Subdivided edge 1 : Starts at edge midpoint, ends at face 1 midpoint
// * Subdivided edge 2 : Starts at original edge's vertex 0, ends at edge midpoint
// * Subdivided edge 3 : Starts at edge midpoint, ends at original edge's vertex 1
//
// Face subdivision *also* always works in a uniform way: For each face in the
// unsubdivided mesh, N new faces are created, one for each edge in the unsubdivided
// face. The faces are ordered in a very specific way:
// * Subdivided face 0 : Starts at the face midpoint, goes to unsubdivided edge 0's midpoint,
// winds around the edge until it hits unsubdivided edge 1's midpoint,
// then heads back to the face midpoint.
// * Subdivided face 1 : Starts at the face midpoint, goes to unsubdivided edge 1's midpoint,
// winds around the edge until it hits unsubdivided edge 2's midpoint,
// then heads back to the face midpoint.
// etc.
//-----------------------------------------------------------------------------
struct SubdivVertex_t
{
Vector m_vecPosition;
Vector m_vecNormal;
Vector m_vecTexCoord;
int m_nValence;
};
// NOTE: The edge is always defined such that the edge going from vertex[0] to vertex[1]
// is counter-clockwise when seen from face[1] and and clockwise when seen from face[0].
struct Edge_t
{
int m_pFace[2];
int m_pRelativeEdgeIndex[2]; // Goes from 0-N always, specifies the Nth edge of the polygon it's part of for each of the two faces
int m_pVertex[2];
};
struct Face_t
{
int m_nFirstEdgeIndex;
int m_nEdgeCount;
// Stores the index of the first face in the subdivided mesh
// isn't actually a part of the mesh data, but I'm storing it here to reduce number of allocations to make
mutable int m_nFirstSubdividedFace;
};
struct SubdivMesh_t
{
CUtlVector<SubdivVertex_t> m_Vertices;
CUtlVector<Edge_t> m_Edges;
// Positive values mean read from m_Edges[x], use m_pVertex[0] for leading vertex
// Negative values mean read from m_Edges[-1-x], use m_pVertex[1] for leading vertex
CUtlVector<int> m_EdgeIndices;
CUtlVector<Face_t> m_Faces;
int m_nTotalIndexCount;
int m_nTotalLineCount;
};
//-----------------------------------------------------------------------------
// Clears a mesh
//-----------------------------------------------------------------------------
static void ClearMesh( SubdivMesh_t &dest )
{
dest.m_Vertices.RemoveAll();
dest.m_Edges.RemoveAll();
dest.m_EdgeIndices.RemoveAll();
dest.m_Faces.RemoveAll();
dest.m_nTotalIndexCount = 0;
dest.m_nTotalLineCount = 0;
}
//-----------------------------------------------------------------------------
// Gets the leading vertex of an edge
//-----------------------------------------------------------------------------
static inline int GetLeadingEdgeVertexIndex( const SubdivMesh_t &src, int nEdge )
{
if ( nEdge >= 0 )
{
const Edge_t &edge = src.m_Edges[nEdge];
return edge.m_pVertex[0];
}
const Edge_t &edge = src.m_Edges[ -1 - nEdge ];
return edge.m_pVertex[1];
}
static inline const SubdivVertex_t &GetLeadingEdgeVertex( const SubdivMesh_t &src, int nEdge )
{
return src.m_Vertices[ GetLeadingEdgeVertexIndex( src, nEdge ) ];
}
//-----------------------------------------------------------------------------
// Adds face midpoints to a mesh
//-----------------------------------------------------------------------------
static void AddFaceMidpointsToMesh( const SubdivMesh_t &src, SubdivMesh_t &dest )
{
int nCurrSubdividedFace = 0;
int nSrcFaceCount = src.m_Faces.Count();
for ( int i = 0; i < nSrcFaceCount; ++i )
{
int nEdgeCount = src.m_Faces[i].m_nEdgeCount;
int nEdgeIndex = src.m_Faces[i].m_nFirstEdgeIndex;
Assert( nEdgeCount != 0 );
int v = dest.m_Vertices.AddToTail( );
SubdivVertex_t &vert = dest.m_Vertices[v];
vert.m_vecPosition.Init();
vert.m_vecTexCoord.Init();
vert.m_nValence = nEdgeCount;
for ( int j = 0; j < nEdgeCount; ++j, ++nEdgeIndex )
{
// NOTE: Instead of calling GetLeadingEdgeVertex,
// I could add both vertices for each edge + multiply by 0.5
int nEdge = src.m_EdgeIndices[nEdgeIndex];
const SubdivVertex_t &srcVert = GetLeadingEdgeVertex( src, nEdge );
vert.m_vecPosition += srcVert.m_vecPosition;
vert.m_vecTexCoord += srcVert.m_vecTexCoord;
}
vert.m_vecPosition /= nEdgeCount;
vert.m_vecTexCoord /= nEdgeCount;
// Store off the face index in the dest mesh of the first subdivided face for this guy.
src.m_Faces[i].m_nFirstSubdividedFace = nCurrSubdividedFace;
nCurrSubdividedFace += nEdgeCount;
}
}
//-----------------------------------------------------------------------------
// Adds edge midpoints to a mesh
//-----------------------------------------------------------------------------
static void AddEdgeMidpointsToMesh( const SubdivMesh_t &src, SubdivMesh_t &dest )
{
int nSrcEdgeCount = src.m_Edges.Count();
for ( int i = 0; i < nSrcEdgeCount; ++i )
{
const Edge_t &edge = src.m_Edges[i];
int v = dest.m_Vertices.AddToTail( );
SubdivVertex_t &vert = dest.m_Vertices[v];
vert.m_nValence = 4;
const SubdivVertex_t *pSrcVert = &src.m_Vertices[ edge.m_pVertex[0] ];
vert.m_vecPosition = pSrcVert->m_vecPosition;
vert.m_vecTexCoord = pSrcVert->m_vecTexCoord;
pSrcVert = &src.m_Vertices[ edge.m_pVertex[1] ];
vert.m_vecPosition += pSrcVert->m_vecPosition;
vert.m_vecTexCoord += pSrcVert->m_vecTexCoord;
// NOTE: We know that the first n vertices added to dest correspond to the src face midpoints
pSrcVert = &dest.m_Vertices[ edge.m_pFace[0] ];
vert.m_vecPosition += pSrcVert->m_vecPosition;
vert.m_vecTexCoord += pSrcVert->m_vecTexCoord;
pSrcVert = &dest.m_Vertices[ edge.m_pFace[1] ];
vert.m_vecPosition += pSrcVert->m_vecPosition;
vert.m_vecTexCoord += pSrcVert->m_vecTexCoord;
vert.m_vecPosition /= 4.0f;
vert.m_vecTexCoord /= 4.0f;
}
}
//-----------------------------------------------------------------------------
// Adds edge midpoints to a mesh
//-----------------------------------------------------------------------------
static void AddModifiedVerticesToMesh( const SubdivMesh_t &src, SubdivMesh_t &dest )
{
int nSrcVertexCount = src.m_Vertices.Count();
// This computes the equation v(i+1) = ((N-2)/N) * v(i) + (1/N^2) * sum( ei + fi )
int nFirstDestVertex = dest.m_Vertices.Count();
for ( int i = 0; i < nSrcVertexCount; ++i )
{
int v = dest.m_Vertices.AddToTail( );
SubdivVertex_t &vert = dest.m_Vertices[v];
int nValence = src.m_Vertices[i].m_nValence;
vert.m_nValence = nValence;
float flScale = (float)(nValence - 2) / nValence;
VectorScale( src.m_Vertices[i].m_vecPosition, flScale, vert.m_vecPosition );
VectorScale( src.m_Vertices[i].m_vecTexCoord, flScale, vert.m_vecTexCoord );
}
int nSrcEdgeCount = src.m_Edges.Count();
for ( int i = 0; i < nSrcEdgeCount; ++i )
{
const Edge_t &edge = src.m_Edges[i];
for ( int j = 0; j < 2; ++j )
{
int nDestVertIndex = nFirstDestVertex + edge.m_pVertex[j];
SubdivVertex_t &destVertex = dest.m_Vertices[nDestVertIndex];
float ooValenceSq = 1.0f / destVertex.m_nValence;
ooValenceSq *= ooValenceSq;
// This adds in the contribution from the source vertex at the opposite edge
const SubdivVertex_t &srcOtherVert = src.m_Vertices[ edge.m_pVertex[ 1 - j ] ];
VectorMA( destVertex.m_vecPosition, ooValenceSq, srcOtherVert.m_vecPosition, destVertex.m_vecPosition );
VectorMA( destVertex.m_vecTexCoord, ooValenceSq, srcOtherVert.m_vecTexCoord, destVertex.m_vecTexCoord );
// This adds in the contribution from the two faces it's part of
// NOTE: Usage of dest here is correct; this grabs the vertex that
// was created that was in the middle of the source mesh's face
const SubdivVertex_t *pSrcFace = &dest.m_Vertices[ edge.m_pFace[ 0 ] ];
VectorMA( destVertex.m_vecPosition, 0.5f * ooValenceSq, pSrcFace->m_vecPosition, destVertex.m_vecPosition );
VectorMA( destVertex.m_vecTexCoord, 0.5f * ooValenceSq, pSrcFace->m_vecTexCoord, destVertex.m_vecTexCoord );
pSrcFace = &dest.m_Vertices[ edge.m_pFace[ 1 ] ];
VectorMA( destVertex.m_vecPosition, 0.5f * ooValenceSq, pSrcFace->m_vecPosition, destVertex.m_vecPosition );
VectorMA( destVertex.m_vecTexCoord, 0.5f * ooValenceSq, pSrcFace->m_vecTexCoord, destVertex.m_vecTexCoord );
}
}
}
//-----------------------------------------------------------------------------
// Adds unique subdivided edges so they aren't repeated.
//-----------------------------------------------------------------------------
static void AddSubdividedEdges( const SubdivMesh_t &src, SubdivMesh_t &dest )
{
// NOTE: We iterate over each edge in sequence and add edges
// between face 0, then face 1, then vertex 0, then vertex 1.
// The vertex index for the vert at the center of original face N is N.
// The vertex index for the vert at the center of original edge N is nSrcFaceCount + N;
// The vertex index for the vert at original vertex N is nSrcFaceCount + nSrcEdgeCount + N;
int nSrcFaceCount = src.m_Faces.Count();
int nSrcEdgeCount = src.m_Edges.Count();
for ( int i = 0; i < nSrcEdgeCount; ++i )
{
const Edge_t &srcEdge = src.m_Edges[i];
int e = dest.m_Edges.AddMultipleToTail( 4 );
Edge_t *pDstEdge = &dest.m_Edges[e];
// Grab the two source faces
const Face_t *pFaces[2];
pFaces[0] = &src.m_Faces[ srcEdge.m_pFace[0] ];
pFaces[1] = &src.m_Faces[ srcEdge.m_pFace[1] ];
// Get the first subdivided face index + relative edge index
int pSubdividedFaceIndex[2];
pSubdividedFaceIndex[0] = pFaces[0]->m_nFirstSubdividedFace;
pSubdividedFaceIndex[1] = pFaces[1]->m_nFirstSubdividedFace;
// Get the relative edge index
int pRelativeEdgeIndex[2];
pRelativeEdgeIndex[0] = srcEdge.m_pRelativeEdgeIndex[0];
pRelativeEdgeIndex[1] = srcEdge.m_pRelativeEdgeIndex[1];
int pPrevRelativeEdgeIndex[2];
pPrevRelativeEdgeIndex[0] = (srcEdge.m_pRelativeEdgeIndex[0] - 1);
if ( pPrevRelativeEdgeIndex[0] < 0 )
{
pPrevRelativeEdgeIndex[0] = pFaces[0]->m_nEdgeCount - 1;
}
pPrevRelativeEdgeIndex[1] = (srcEdge.m_pRelativeEdgeIndex[1] - 1);
if ( pPrevRelativeEdgeIndex[1] < 0 )
{
pPrevRelativeEdgeIndex[1] = pFaces[1]->m_nEdgeCount - 1;
}
// This ordering maintains clockwise order
pDstEdge[0].m_pVertex[0] = srcEdge.m_pFace[0];
pDstEdge[0].m_pVertex[1] = nSrcFaceCount + i;
pDstEdge[0].m_pFace[0] = pSubdividedFaceIndex[0] + pPrevRelativeEdgeIndex[0];
pDstEdge[0].m_pFace[1] = pSubdividedFaceIndex[0] + pRelativeEdgeIndex[0];
pDstEdge[0].m_pRelativeEdgeIndex[0] = 3;
pDstEdge[0].m_pRelativeEdgeIndex[1] = 0;
pDstEdge[1].m_pVertex[0] = nSrcFaceCount + i;
pDstEdge[1].m_pVertex[1] = srcEdge.m_pFace[1];
pDstEdge[1].m_pFace[0] = pSubdividedFaceIndex[1] + pRelativeEdgeIndex[1];
pDstEdge[1].m_pFace[1] = pSubdividedFaceIndex[1] + pPrevRelativeEdgeIndex[1];
pDstEdge[1].m_pRelativeEdgeIndex[0] = 0;
pDstEdge[1].m_pRelativeEdgeIndex[1] = 3;
pDstEdge[2].m_pVertex[0] = nSrcFaceCount + nSrcEdgeCount + srcEdge.m_pVertex[0];
pDstEdge[2].m_pVertex[1] = nSrcFaceCount + i;
pDstEdge[2].m_pFace[0] = pSubdividedFaceIndex[0] + pRelativeEdgeIndex[0];
pDstEdge[2].m_pFace[1] = pSubdividedFaceIndex[1] + pPrevRelativeEdgeIndex[1];
pDstEdge[2].m_pRelativeEdgeIndex[0] = 1;
pDstEdge[2].m_pRelativeEdgeIndex[1] = 2;
pDstEdge[3].m_pVertex[0] = nSrcFaceCount + i;
pDstEdge[3].m_pVertex[1] = nSrcFaceCount + nSrcEdgeCount + srcEdge.m_pVertex[1];
pDstEdge[3].m_pFace[0] = pSubdividedFaceIndex[0] + pPrevRelativeEdgeIndex[0];
pDstEdge[3].m_pFace[1] = pSubdividedFaceIndex[1] + pRelativeEdgeIndex[1];
pDstEdge[3].m_pRelativeEdgeIndex[0] = 2;
pDstEdge[3].m_pRelativeEdgeIndex[1] = 1;
}
}
//-----------------------------------------------------------------------------
// Adds unique subdivided faces
//-----------------------------------------------------------------------------
static void AddSubdividedFaces( const SubdivMesh_t &src, SubdivMesh_t &dest )
{
dest.m_nTotalIndexCount = 0;
dest.m_nTotalLineCount = 0;
int nSrcFaceCount = src.m_Faces.Count();
for ( int i = 0; i < nSrcFaceCount; ++i )
{
int nEdgeCount = src.m_Faces[i].m_nEdgeCount;
const int *pSrcEdgeIndex = &src.m_EdgeIndices[ src.m_Faces[i].m_nFirstEdgeIndex ];
int ei = dest.m_EdgeIndices.AddMultipleToTail( nEdgeCount * 4 );
int *pDestEdgeIndex = &dest.m_EdgeIndices[ ei ];
int *pPrevDestEdgeIndex = &pDestEdgeIndex[(nEdgeCount - 1) * 4];
for ( int j = 0; j < nEdgeCount; ++j )
{
// Add another quad.
dest.m_nTotalIndexCount += 6;
dest.m_nTotalLineCount += 4;
// Add a face for every edge. Note that subdivided face N
// is the face whose goes through edge N.
int f = dest.m_Faces.AddToTail();
Face_t *pDestFace = &dest.m_Faces[f];
pDestFace->m_nEdgeCount = 4;
pDestFace->m_nFirstEdgeIndex = ei + (j * 4);
// Fill it with bogus data
pDestFace->m_nFirstSubdividedFace = -1;
// Now add in the edge indices to refer to the edges created in AddSubdividedEdges.
// Note that the new edge index == the old edge index * 4, since we always
// create 4 edges for every edge in the source list.
int *pCurrDestEdgeIndex = &pDestEdgeIndex[j*4];
int nSrcEdgeIndex = pSrcEdgeIndex[j];
if ( nSrcEdgeIndex >= 0 )
{
// This means this polygon is the '1' index in the edge; it's following this edge CCW.
int nDestEdgeIndex = nSrcEdgeIndex * 4;
pCurrDestEdgeIndex[0] = -1 - (nDestEdgeIndex + 1); // We're following this edge backwards
pCurrDestEdgeIndex[1] = nDestEdgeIndex + 3;
pPrevDestEdgeIndex[2] = nDestEdgeIndex + 2;
pPrevDestEdgeIndex[3] = nDestEdgeIndex + 1;
}
else
{
// This means this polygon is the '0' index in the edge; it's following this edge CW.
int nDestEdgeIndex = (-1 - nSrcEdgeIndex) * 4;
pCurrDestEdgeIndex[0] = nDestEdgeIndex;
pCurrDestEdgeIndex[1] = -1 - (nDestEdgeIndex + 2); // We're following this edge backwards
pPrevDestEdgeIndex[2] = -1 - (nDestEdgeIndex + 3); // We're following this edge backwards
pPrevDestEdgeIndex[3] = -1 - (nDestEdgeIndex); // We're following this edge backwards
}
pPrevDestEdgeIndex = pCurrDestEdgeIndex;
}
}
}
//-----------------------------------------------------------------------------
// Subdivides a mesh
//-----------------------------------------------------------------------------
static void SubdivideMesh( const SubdivMesh_t &src, SubdivMesh_t &dest )
{
// Preallocate space for dest data
int nSrcFaceCount = src.m_Faces.Count();
int nSrcEdgeCount = src.m_Edges.Count();
dest.m_Vertices.EnsureCapacity( nSrcFaceCount + nSrcEdgeCount + src.m_Vertices.Count() );
dest.m_Edges.EnsureCapacity( nSrcEdgeCount * 4 );
dest.m_EdgeIndices.EnsureCapacity( nSrcFaceCount * 16 );
dest.m_Faces.EnsureCapacity( nSrcFaceCount * 4 ); // This is only true if we have valence 4 everywhere.
// First, compute midpoints of each face, add them to the mesh
AddFaceMidpointsToMesh( src, dest );
// Next, for each edge, compute a new point which is the average of the edge points and the face midpoints
AddEdgeMidpointsToMesh( src, dest );
// Add modified versions of the vertices in the src mesh based on the new computed points and add them to the dest mesh
AddModifiedVerticesToMesh( src, dest );
// Add subdivided edges based on the previous edges
AddSubdividedEdges( src, dest );
// Add subdivided faces referencing the subdivided edges
AddSubdividedFaces( src, dest );
}
//-----------------------------------------------------------------------------
// Creates/destroys the subdiv control cage
//-----------------------------------------------------------------------------
void CDmeTestMesh::CreateControlCage( )
{
DestroyControlCage();
m_pControlCage = new SubdivMesh_t;
// Draw a simple cube
static Vector s_pPositions[8] =
{
Vector( -30, -30, -30 ),
Vector( 30, -30, -30 ),
Vector( -30, 30, -30 ),
Vector( 30, 30, -30 ),
Vector( -30, -30, 30 ),
Vector( 30, -30, 30 ),
Vector( -30, 30, 30 ),
Vector( 30, 30, 30 ),
};
static Vector2D s_pTexCoords[8] =
{
Vector2D( 0, 0 ),
Vector2D( 0.5, 0 ),
Vector2D( 0, 0.5 ),
Vector2D( 0.5, 0.5 ),
Vector2D( 0.5, 0.5 ),
Vector2D( 1, 0.5 ),
Vector2D( 0.5, 1 ),
Vector2D( 1, 1 ),
};
// Indices into the vertex array
static int s_pEdges[12][2] =
{
{ 0, 4 }, { 4, 6 }, { 6, 2 }, { 2, 0 }, // 0 -> -x
{ 1, 3 }, { 3, 7 }, { 7, 5 }, { 5, 1 }, // 1 -> +x
{ 0, 1 }, { 5, 4 }, // 2 -> -y
{ 6, 7 }, { 3, 2 }, // 3 -> +y
// 4 -> -z
// 5 -> +z
};
// Indices into the face array associated w/ the edges above
static int s_pEdgeFaces[12][2] =
{
{ 2, 0 }, { 5, 0 }, { 3, 0 }, { 4, 0 }, // 0 -> -x
{ 4, 1 }, { 3, 1 }, { 5, 1 }, { 2, 1 }, // 1 -> +x
{ 4, 2 }, { 5, 2 }, // 2 -> -y
{ 5, 3 }, { 4, 3 }, // 3 -> +y
// 4 -> -z
// 5 -> +z
};
// In what order does edge s_pEdges[i] appear on faces s_pEdgeFaces[i][0] and s_pEdgeFaces[i][1]
// in the list s_pIndices[s_pEdgeFaces[i][j]] below? Note the #s 0, 1, 2, and 3 should appear 6 times each in this array
// representing the fact that each face has a 0th,1st,2nd, and 3rd edge.
static int s_pRelativeEdgeIndex[12][2] =
{
{ 3, 0 }, { 3, 1 }, { 0, 2 }, { 0, 3 }, // 0 -> -x
{ 2, 0 }, { 2, 1 }, { 1, 2 }, { 1, 3 }, // 1 -> +x
{ 3, 0 }, { 0, 2 }, // 2 -> -y
{ 2, 1 }, { 1, 3 }, // 3 -> +y
// 4 -> -z
// 5 -> +z
};
static int s_pIndices[6][5] =
{
{ 0, 4, 6, 2, 0 }, // 0 -> -x
{ 1, 3, 7, 5, 1 }, // 1 -> +x
{ 0, 1, 5, 4, 0 }, // 2 -> -y
{ 2, 6, 7, 3, 2 }, // 3 -> +y
{ 0, 2, 3, 1, 0 }, // 4 -> -z
{ 4, 5, 7, 6, 4 }, // 5 -> +z
};
// Add vertices
int i;
for ( i = 0; i < 8; ++i )
{
int v = m_pControlCage->m_Vertices.AddToTail();
SubdivVertex_t &vert = m_pControlCage->m_Vertices[v];
vert.m_vecPosition = s_pPositions[i];
vert.m_vecNormal = vec3_origin;
vert.m_vecTexCoord.AsVector2D() = s_pTexCoords[i];
vert.m_nValence = 3;
}
// Add unique edges
for ( i = 0; i < 12; ++i )
{
int e = m_pControlCage->m_Edges.AddToTail();
Edge_t &edge = m_pControlCage->m_Edges[e];
edge.m_pVertex[0] = s_pEdges[i][0];
edge.m_pVertex[1] = s_pEdges[i][1];
edge.m_pFace[0] = s_pEdgeFaces[i][0];
edge.m_pFace[1] = s_pEdgeFaces[i][1];
edge.m_pRelativeEdgeIndex[0] = s_pRelativeEdgeIndex[i][0];
edge.m_pRelativeEdgeIndex[1] = s_pRelativeEdgeIndex[i][1];
}
m_pControlCage->m_nTotalIndexCount = 0;
m_pControlCage->m_nTotalLineCount = 0;
for ( i = 0; i < 6; ++i )
{
int f = m_pControlCage->m_Faces.AddToTail();
Face_t &face = m_pControlCage->m_Faces[f];
face.m_nFirstEdgeIndex = m_pControlCage->m_EdgeIndices.Count();
face.m_nEdgeCount = 4;
// Place an invalid value here
face.m_nFirstSubdividedFace = -1;
// Two triangles per quad
m_pControlCage->m_nTotalIndexCount += 6;
m_pControlCage->m_nTotalLineCount += 4;
for ( int j = 0; j < 4; ++j )
{
int k;
for ( k = 0; k < 12; ++k )
{
if ( (s_pIndices[i][j] == s_pEdges[k][0]) && (s_pIndices[i][j+1] == s_pEdges[k][1]) )
{
m_pControlCage->m_EdgeIndices.AddToTail( k );
break;
}
if ( (s_pIndices[i][j] == s_pEdges[k][1]) && (s_pIndices[i][j+1] == s_pEdges[k][0]) )
{
m_pControlCage->m_EdgeIndices.AddToTail( -1-k );
break;
}
}
Assert( k != 12 );
}
}
}
void CDmeTestMesh::DestroyControlCage( )
{
if ( m_pControlCage )
{
delete m_pControlCage;
m_pControlCage = NULL;
}
}
//-----------------------------------------------------------------------------
// Draws a subdiv mesh
//-----------------------------------------------------------------------------
void CDmeTestMesh::DrawSubdivMesh( const SubdivMesh_t &mesh )
{
if ( !g_pMaterialSystem )
return;
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
IMaterial *pMaterial = g_pMaterialSystem->FindMaterial( "debug/debugwireframe", NULL, false );
pRenderContext->Bind( pMaterial );
IMesh *pMesh = pRenderContext->GetDynamicMesh();
CMeshBuilder meshBuilder;
int nVertexCount = mesh.m_Vertices.Count();
// meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, nVertexCount, mesh.m_nTotalIndexCount );
meshBuilder.Begin( pMesh, MATERIAL_LINES, nVertexCount, mesh.m_nTotalLineCount * 2 );
for ( int i = 0; i < nVertexCount; ++i )
{
meshBuilder.Position3fv( mesh.m_Vertices[ i ].m_vecPosition.Base() );
meshBuilder.TexCoord2fv( 0, mesh.m_Vertices[ i ].m_vecTexCoord.Base() );
meshBuilder.TexCoord2f( 1, i, 0.0f );
meshBuilder.Color3ub( 255, 255, 255 );
meshBuilder.AdvanceVertex();
}
int nFaceCount = mesh.m_Faces.Count();
for ( int i = 0; i < nFaceCount; ++i )
{
int nEdgeCount = mesh.m_Faces[i].m_nEdgeCount;
const int *pEdgeIndex = &mesh.m_EdgeIndices[ mesh.m_Faces[i].m_nFirstEdgeIndex ];
int nPrevIndex = GetLeadingEdgeVertexIndex( mesh, pEdgeIndex[nEdgeCount-1] );
for ( int j = 0; j < nEdgeCount; ++j )
{
int nCurrIndex = GetLeadingEdgeVertexIndex( mesh, pEdgeIndex[j] );
meshBuilder.FastIndex( nPrevIndex );
meshBuilder.FastIndex( nCurrIndex );
nPrevIndex = nCurrIndex;
}
}
/*
int nFaceCount = mesh.m_Faces.Count();
for ( int i = 0; i < nFaceCount; ++i )
{
int nEdgeCount = mesh.m_Faces[i].m_nEdgeCount;
const int *pEdgeIndex = &mesh.m_EdgeIndices[ mesh.m_Faces[i].m_nFirstEdgeIndex ];
int nRootIndex = GetLeadingEdgeVertexIndex( mesh, pEdgeIndex[0] );
int nPrevIndex = GetLeadingEdgeVertexIndex( mesh, pEdgeIndex[1] );
for ( int j = 0; j < nEdgeCount - 2; ++j )
{
int nCurrIndex = GetLeadingEdgeVertexIndex( mesh, pEdgeIndex[j+2] );
meshBuilder.FastIndex( nRootIndex );
meshBuilder.FastIndex( nPrevIndex );
meshBuilder.FastIndex( nCurrIndex );
nPrevIndex = nCurrIndex;
}
}
*/
meshBuilder.End();
pMesh->Draw();
}
//-----------------------------------------------------------------------------
// Draws a subdivided box
//-----------------------------------------------------------------------------
void CDmeTestMesh::DrawSubdividedBox()
{
if ( !g_pMaterialSystem )
return;
if ( !m_pControlCage )
{
CreateControlCage( );
}
int nSubdivLevel = GetValue<int>( "subdivlevel" );
if ( nSubdivLevel == 0 )
{
DrawSubdivMesh( *m_pControlCage );
return;
}
// Construct the initial mesh
SubdivMesh_t subdivMesh[2];
SubdivideMesh( *m_pControlCage, subdivMesh[0] );
// Compute the subdivided vertices
int nCurrMesh = 0;
while ( --nSubdivLevel > 0 )
{
ClearMesh( subdivMesh[1 - nCurrMesh] );
SubdivideMesh( subdivMesh[nCurrMesh], subdivMesh[1 - nCurrMesh] );
if (( subdivMesh[1 - nCurrMesh].m_nTotalLineCount * 2 >= 32768 ) || ( subdivMesh[1 - nCurrMesh].m_Vertices.Count() >= 32768 ))
break;
nCurrMesh = 1 - nCurrMesh;
}
// Draw the subdivided mesh
DrawSubdivMesh( subdivMesh[nCurrMesh] );
}
//-----------------------------------------------------------------------------
// Draws the mesh
//-----------------------------------------------------------------------------
void CDmeTestMesh::DrawBox( CDmeTransform *pTransform )
{
if ( !g_pMaterialSystem )
return;
// FIXME: Hack!
if ( !m_pMorph || !m_pMesh )
return;
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
// Set up morph factors
float pMorphFactors[32];
for ( int i = 0; i < 32; ++i )
{
pMorphFactors[i] = 0.5f + 0.5f * sin( 2 * 3.14 * ( Plat_FloatTime() / 5.0f + (float)i / 32.0f ) );
}
pMorphFactors[1] = 1.0f - pMorphFactors[0];
pRenderContext->SetMorphTargetFactors( 0, pMorphFactors, 32 );
// FIXME: Should this call be made from the application rendering the mesh?
LoadModelMatrix( pTransform );
pRenderContext->BindMorph( m_pMorph );
pRenderContext->Bind( m_pMaterial );
m_pMesh->Draw();
pRenderContext->BindMorph( NULL );
}
//-----------------------------------------------------------------------------
// Draws the mesh
//-----------------------------------------------------------------------------
void CDmeTestMesh::Draw( const matrix3x4_t& shapeToWorld, CDmeDrawSettings *pDrawSettings )
{
if ( !g_pMaterialSystem || !g_pMDLCache || !g_pStudioRender )
return;
#if 0
// DrawSubdividedBox( pTransform );
DrawBox( pTransform );
return;
#elif 0
if ( m_MDLHandle == MDLHANDLE_INVALID )
return;
// Color + alpha modulation
Vector white(1.0f, 1.0f, 1.0f);
g_pStudioRender->SetColorModulation( white.Base() );
g_pStudioRender->SetAlphaModulation( 1.0f );
DrawModelInfo_t info;
info.m_pStudioHdr = g_pMDLCache->GetStudioHdr( m_MDLHandle );
info.m_pHardwareData = g_pMDLCache->GetHardwareData( m_MDLHandle );
info.m_Decals = STUDIORENDER_DECAL_INVALID;
info.m_Skin = GetAttributeValueInt( "skin" );
info.m_Body = GetAttributeValueInt( "body" );
info.m_HitboxSet = 0;
info.m_pClientEntity = NULL;
info.m_ppColorMeshes = NULL;
info.m_bStaticLighting = false;
info.m_Lod = GetAttributeValueInt( "lod" );
// FIXME: Deal with lighting
for ( int i = 0; i < 6; ++ i )
{
info.m_vecAmbientCube[i].Init( 1, 1, 1 );
}
info.m_nLocalLightCount = 0;
// info.m_LocalLightDescs;
matrix3x4_t *pBoneToWorld = g_pStudioRender->LockBoneMatrices( info.m_pStudioHdr->numbones );
SetUpBones( pTransform, info.m_pStudioHdr->numbones, pBoneToWorld );
g_pStudioRender->UnlockBoneMatrices();
// Root transform
matrix3x4_t rootToWorld;
pTransform->GetTransform( rootToWorld );
Vector vecModelOrigin;
MatrixGetColumn( rootToWorld, 3, vecModelOrigin );
g_pStudioRender->DrawModel( NULL, info, pBoneToWorld, vecModelOrigin, STUDIORENDER_DRAW_ENTIRE_MODEL );
#else
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
#if 1
matrix3x4_t mat;
if ( m_bones.size() == 1 )
{
pRenderContext->MatrixMode( MATERIAL_MODEL );
m_bones[0]->GetTransform( mat );
pRenderContext->LoadMatrix( mat );
// pRenderContext->LoadMatrix( m_bones[0] ); // m_PoseToWorld[0]
}
pRenderContext->SetNumBoneWeights( 2 ); // pStrip->numBones
uint bn = m_bones.size();
for ( uint bi = 0; bi < bn; ++bi )
{
m_bones[bi]->GetTransform( mat );
#if 0 // hack to see whether bones are actually affecting the model
float f = 100.0f;
Vector translation;
MatrixGetColumn( mat, 3, &translation );
translation.x += (bi&1) ? f : -f;
translation.y += (bi&2) ? f : -f;
translation.z += (bi&4) ? f : -f;
MatrixSetColumn( translation, 3, mat );
#endif
pRenderContext->LoadBoneMatrix( bi, mat );
}
#else
pRenderContext->MatrixMode( MATERIAL_MODEL );
matrix3x4_t mat;
Assert( !m_bones.empty() );
m_bones[0]->GetTransform( mat );
pRenderContext->LoadMatrix( mat );
#endif
IMaterial *pMaterial = g_pMaterialSystem->FindMaterial( "Models/shadertest/unlitgenericmodel", NULL, false );
// IMaterial *pMaterial = g_pMaterialSystem->FindMaterial( "debug/debugwireframevertexcolor", NULL, false );
// IMaterial *pMaterial = g_pMaterialSystem->FindMaterial( "debug/debugwireframe", NULL, false );
pRenderContext->Bind( pMaterial );
IMesh *pMesh = pRenderContext->GetDynamicMesh();
int mn = m_submeshes.size();
for ( int mi = 0; mi < mn; ++mi )
{
CMeshBuilder meshBuilder;
std::vector< int > &indices = m_submeshes[mi]->indices;
std::vector< vertex_t > &vertices = m_submeshes[mi]->vertices;
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLES, vertices.size(), indices.size() );
int vn = vertices.size();
for ( int vi = 0; vi < vn; ++vi )
{
vertex_t &vertex = vertices[vi];
meshBuilder.Position3fv( vertex.coord.Base() );
meshBuilder.Normal3fv ( vertex.normal.Base() );
meshBuilder.TexCoord2fv( 0, vertex.texcoord.Base() );
switch ( vertex.skinning[0].index )
{
case 0: meshBuilder.Color3f(1,0,0); break;
case 1: meshBuilder.Color3f(0,1,0); break;
case 2: meshBuilder.Color3f(0,0,1); break;
case 3: meshBuilder.Color3f(1,1,0); break;
case 4: meshBuilder.Color3f(0,1,1); break;
case 5: meshBuilder.Color3f(1,0,1); break;
case 6: meshBuilder.Color3f(0,0,0); break;
case 7: meshBuilder.Color3f(1,1,1); break;
default: meshBuilder.Color3f(0.5f,0.5f,0.5f); break;
}
int bn = vertex.skinning.size();
for ( int bi = 0; bi < bn; ++bi )
{
meshBuilder.BoneMatrix( bi, vertex.skinning[bi].index );
meshBuilder.BoneWeight( bi, vertex.skinning[bi].weight );
}
meshBuilder.AdvanceVertex();
}
int in = indices.size();
for ( int ii = 0; ii < in; ++ii )
{
meshBuilder.FastIndex( indices[ii] );
}
meshBuilder.End();
pMesh->Draw();
}
#endif
}
//-----------------------------------------------------------------------------
// Returns a mask indicating which bones to set up
//-----------------------------------------------------------------------------
int CDmeTestMesh::BoneMask( void )
{
int nLod = GetValue<int>( "lod" );
return BONE_USED_BY_VERTEX_AT_LOD( nLod );
}
void CDmeTestMesh::SetUpBones( CDmeTransform *pTransform, int nMaxBoneCount, matrix3x4_t *pBoneToWorld )
{
// Default to middle of the pose parameter range
float pPoseParameter[MAXSTUDIOPOSEPARAM];
for ( int i = 0; i < MAXSTUDIOPOSEPARAM; ++i )
{
pPoseParameter[i] = 0.5f;
}
CStudioHdr studioHdr( g_pMDLCache->GetStudioHdr( m_MDLHandle ), g_pMDLCache );
int nSequence = GetValue<int>( "sequence" );
float flPlaybackRate = GetValue<float>( "playbackrate" );
float flTime = GetValue<float>( "time" );
int nFrameCount = Studio_MaxFrame( &studioHdr, nSequence, pPoseParameter );
if ( nFrameCount == 0 )
{
nFrameCount = 1;
}
float flCycle = ( flTime * flPlaybackRate ) / nFrameCount;
// FIXME: We're always wrapping; may want to determing if we should clamp
flCycle -= (int)(flCycle);
Vector pos[MAXSTUDIOBONES];
Quaternion q[MAXSTUDIOBONES];
IBoneSetup boneSetup( &studioHdr, BoneMask(), pPoseParameter );
boneSetup.InitPose( pos, q );
boneSetup.AccumulatePose( pos, q, nSequence, flCycle, 1.0f, flTime, NULL );
// FIXME: Try enabling this?
// CalcAutoplaySequences( pStudioHdr, NULL, pos, q, pPoseParameter, BoneMask( ), flTime );
// Root transform
matrix3x4_t rootToWorld;
pTransform->GetTransform( rootToWorld );
if ( studioHdr.numBones() < nMaxBoneCount )
{
nMaxBoneCount = studioHdr.numBones();
}
for ( int i = 0; i < nMaxBoneCount; i++ )
{
// If it's not being used, fill with NAN for errors
#ifdef _DEBUG
if ( !(studioHdr.pBone( i )->flags & BoneMask()))
{
int j, k;
for (j = 0; j < 3; j++)
{
for (k = 0; k < 4; k++)
{
pBoneToWorld[i][j][k] = VEC_T_NAN;
}
}
continue;
}
#endif
matrix3x4_t boneMatrix;
QuaternionMatrix( q[i], boneMatrix );
MatrixSetColumn( pos[i], 3, boneMatrix );
if (studioHdr.pBone(i)->parent == -1)
{
ConcatTransforms (rootToWorld, boneMatrix, pBoneToWorld[ i ]);
}
else
{
ConcatTransforms ( pBoneToWorld[ studioHdr.pBone(i)->parent ], boneMatrix, pBoneToWorld[ i ] );
}
}
}
//-----------------------------------------------------------------------------
// FIXME: This trashy glue code is really not acceptable. Figure out a way of making it unnecessary.
//-----------------------------------------------------------------------------
const studiohdr_t *studiohdr_t::FindModel( void **cache, char const *pModelName ) const
{
MDLHandle_t handle = g_pMDLCache->FindMDL( pModelName );
*cache = (void*)handle;
return g_pMDLCache->GetStudioHdr( handle );
}
virtualmodel_t *studiohdr_t::GetVirtualModel( void ) const
{
return g_pMDLCache->GetVirtualModel( (MDLHandle_t)virtualModel );
}
byte *studiohdr_t::GetAnimBlock( int i ) const
{
return g_pMDLCache->GetAnimBlock( (MDLHandle_t)virtualModel, i );
}
int studiohdr_t::GetAutoplayList( unsigned short **pOut ) const
{
return g_pMDLCache->GetAutoplayList( (MDLHandle_t)virtualModel, pOut );
}
const studiohdr_t *virtualgroup_t::GetStudioHdr( void ) const
{
return g_pMDLCache->GetStudioHdr( (MDLHandle_t)cache );
}
//-----------------------------------------------------------------------------
// First attempt at making a hacky SMD loader - clean this up later
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// SMD format:
//
// format key:
// #n = integer
// .x = float
// 'a' = literal string
// $s = string
// " = the literal quote character
// // = comment - not in file!!!
//
// 'version' #version // right now, #version = 1
//
// 'nodes' // bone naming and hierarchy
// #bone "$bonename" #parent // one of these per bone - can be in any order, but generally sequential
// 'end'
//
// 'skeleton' // joint animation (and begin pose)
// 'time' #time // repeat time + joints block once per frame
// #bone .x .y .z .rx .ry .rz // bone/translation/rotation - can traverse bones in any order, and even skip them
// 'end'
//
// 'triangles' // actual vertex data - as non-indexed triangle lists
// $texturefilename // repeat texture + 3 vertex lines for each triangle
// #bone .x .y .z .nx .ny .nz .tu .tv #count #bone0 .weight0 // boneN & weightN may or may not exist for N={0..511}
// #bone .x .y .z .nx .ny .nz .tu .tv #count #bone0 .weight0 // boneN & weightN may or may not exist for N={0..511}
// #bone .x .y .z .nx .ny .nz .tu .tv #count #bone0 .weight0 // boneN & weightN may or may not exist for N={0..511}
// 'end'
//
// 'vertexanimation' // morph targets
// 'time' #time // repeat time + vertices block once per vertex
// #vertex .x .y .z .nx .ny .nz // vertex/position/normal
// 'end'
//
//-----------------------------------------------------------------------------
// TODO - check out lookup_index for whether it's looking for exact vertex matches, or within a float tolerance
// DONE - lookup_index checks materiaks, coords and texcoords for exact match, and normals for within 2 degrees
const int MAXNAME = 128;
const int MAXLINE = 4096;
const int MAXCMD = 1024;
const int MAXBONEWEIGHTS = 3;
const int MAXTEXNAME = 64;
void ReadBonesFromSMD( std::vector< CDmeTransform* > &bones, std::istream &is, DmFileId_t fileid )
{
uint index;
int parent;
char name[ MAXNAME ];
char line[ MAXLINE ];
while ( is.getline( line, MAXLINE ) )
{
if ( sscanf( line, "%d \"%[^\"]\" %d", &index, name, &parent ) == 3 )
{
if ( index != bones.size() )
{
Warning( "ReadBonesFromSMD: reading node %d out of order\n", index );
}
if ( index >= bones.size() )
{
bones.resize( index + 1 );
}
bones[index] = CreateElement< CDmeTransform >( name, fileid );
if ( parent > 0 )
{
if ( ( uint( parent ) >= bones.size() ) || ( bones[ parent ] == NULL ) )
{
Warning( "ReadBonesFromSMD: reading node %d before parent\n", index, parent );
}
else
{
Assert( 0 ); // this code is so badly bit-rotten...
// bones[parent]->AddChild( bones[index]->GetHandle() );
}
}
}
else
{
if ( strncmp( line, "end", 3 ) != 0 )
{
Warning( "ReadBonesFromSMD: expected 'end' or bone, found %s\n", line );
}
return;
}
}
}
void clip_rotations( RadianEuler& rot )
{
// remap rotations to [ -M_PI .. M_PI )
for ( int j = 0; j < 3; j++ ) {
if ( rot[j] != -M_PI ) // keep -M_PI as is
{
rot[j] = fmod( (double)rot[j], M_PI );
}
}
}
void ReadSkeletalAnimationFromSMD( std::vector< CDmeTransform* > &bones, std::istream &is )
{
char line[ MAXLINE ];
char cmd[ MAXCMD ];
int time = INT_MIN;
int startframe = -1;
int endframe = -1;
#if 1
// Root transform
matrix3x4_t rootToWorld;
SetIdentityMatrix( rootToWorld );
// GetTransform()->GetTransform( rootToWorld );
#endif
while ( is.getline( line, MAXLINE ) )
{
int index;
Vector pos;
RadianEuler rot;
if ( sscanf( line, "%d %f %f %f %f %f %f", &index, &pos[0], &pos[1], &pos[2], &rot[0], &rot[1], &rot[2] ) == 7 )
{
if ( startframe < 0 )
{
Warning( "ReadSkeletalAnimationFromSMD: missing frame start\n" );
}
// clip_rotations( rot );
Quaternion quat;
AngleQuaternion( rot, quat );
#if 0
matrix3x4_t boneMatrix;
QuaternionMatrix( quat, boneMatrix );
MatrixSetColumn( pos, 3, boneMatrix );
if ( bones[index]->NumParents() > 0 )
{
DmElementHandle_t hParent = bones[index]->GetParent( 0 );
CDmeTransform *parentXform = GetElement< CDmeTransform >( hParent );
matrix3x4_t parentMatrix, newMatrix;
parentXform->GetTransform( parentMatrix );
// ConcatTransforms( parentMatrix, boneMatrix, newMatrix );
SetIdentityMatrix( newMatrix );
MatrixAngles( newMatrix, quat, pos );
}
else
{
matrix3x4_t parentMatrix, newMatrix;
// ConcatTransforms( rootToWorld, boneMatrix, newMatrix );
SetIdentityMatrix( newMatrix );
MatrixAngles( newMatrix, quat, pos );
}
#endif
bones[index]->SetValue( "orientation", quat );
bones[index]->SetValue( "position", pos );
// TODO - save animation data - currently just overwriting w/ last frame
}
else if ( sscanf( line, "%1023s %d", cmd, &index ) )
{
if ( strcmp( cmd, "time" ) == 0 )
{
time = index;
if ( startframe == -1 )
{
startframe = index;
}
if ( time < startframe )
{
Error( "ReadSkeletalAnimationFromSMD: time %d found after time %d\n", time, startframe );
}
if ( time > endframe )
{
endframe = time;
}
time -= startframe;
/*
if ( time != anim.size() )
{
Warning( "ReadSkeletalAnimationFromSMD: reading keyframe %d out of order\n", time );
}
if ( time >= anim.size() )
{
anim.resize( time + 1 );
anim[time] = new bone_t[nodes.size()];
}
if ( time > 0 )
{
if ( anim[time-1] )
{
std::copy( anim[time-1], anim[time-1] + nodes.size(), anim[time] );
}
else
{
Warning( "ReadSkeletalAnimationFromSMD: missing skeletal keyframe %d\n", time-1 );
}
}
*/
}
else if ( strcmp( cmd, "end" ) == 0 )
{
// Build_Reference( nodes, anim, matrices ); // skip - leave this for dmemesh generation
return;
}
else
{
Warning( "ReadSkeletalAnimationFromSMD: expected bone, time or end, found %s\n", line );
}
}
else
{
Warning( "ReadSkeletalAnimationFromSMD: expected bone, time or end, found %s\n", line );
}
}
Error( "ReadSkeletalAnimationFromSMD: unexpected EOF\n" );
}
float vertex_t::normal_tolerance = cos( DEG2RAD( 2.0f ));
void SortAndBalanceBones( std::vector< skinning_info_t > &skinning )
{
// TODO - studiomdl collapses (sums) duplicate bone weights - is this necessary?!?!
std::sort( skinning.begin(), skinning.end() );
// throw away bone weights < 0.05f
while ( skinning.size() > 1 && skinning.back().weight >= 0.05f )
{
skinning.pop_back();
}
Assert( !skinning.empty() );
if ( skinning.size() > MAXBONEWEIGHTS )
{
skinning.resize( MAXBONEWEIGHTS );
}
float weightSum = 0.0f;
for ( uint i = 0; i < skinning.size(); ++i )
{
weightSum += skinning[i].weight;
}
if ( weightSum <= 0.0f )
{
for ( uint i = 0; i < skinning.size(); ++i )
{
skinning[i].weight = weightSum;
}
}
else
{
float weightScale = 1.0f / weightSum;
for ( uint i = 0; i < skinning.size(); ++i )
{
skinning[i].weight *= weightScale;
}
}
}
int ReadVertexFromSMD( std::vector< vertex_t > &vertices, int numbones, std::istream &is )
{
int boneIndex;
is >> boneIndex;
if ( boneIndex < 0 || boneIndex >= numbones )
{
Error( "ReadVertexFromSMD: invalid bone index: %d\n", boneIndex );
}
vertex_t vert;
is >> vert.coord.x >> vert.coord.y >> vert.coord.z;
is >> vert.normal.x >> vert.normal.y >> vert.normal.z;
is >> vert.texcoord.x >> vert.texcoord.y;
// invert v
vert.texcoord.y = 1.0f - vert.texcoord.y;
char line[MAXLINE];
is.getline( line, MAXLINE );
std::istrstream istr( line );
int nBones = 0;
istr >> nBones;
Assert( istr.good() || nBones == 0 );
if ( nBones == 0 )
{
vert.skinning.push_back( skinning_info_t( boneIndex, 1.0f ) );
}
else
{
vert.skinning.reserve( nBones );
for ( int i = 0; i < nBones; ++i )
{
skinning_info_t info;
istr >> info.index >> info.weight;
vert.skinning.push_back( info );
if ( info.index < 0 || info.index >= numbones )
{
Error( "ReadVertexFromSMD: invalid bone index: %d\n", info.index );
}
}
}
std::vector< vertex_t >::iterator vi = std::find( vertices.begin(), vertices.end(), vert );
if ( vi != vertices.end() )
return vi - vertices.begin();
SortAndBalanceBones( vert.skinning );
vertices.push_back( vert );
return vertices.size() - 1;
}
bool IsEnd( char const* pLine )
{
if ( strncmp( "end", pLine, 3 ) != 0 )
return false;
return ( pLine[3] == '\0' ) || ( pLine[3] == '\n' );
}
void ReadTrianglesFromSMD( std::vector< submesh_t* > &meshes, int numbones, std::istream &is )
{
Vector vmin( FLT_MAX, FLT_MAX, FLT_MAX );
Vector vmax( -FLT_MAX, -FLT_MAX, -FLT_MAX );
char line[ MAXLINE ];
char texname[ MAXTEXNAME ];
while ( is.getline( line, MAXLINE ) )
{
if ( IsEnd( line ) )
break;
int lineLen = is.gcount();
if ( lineLen >= MAXTEXNAME )
{
Warning( "ReadTrianglesFromSMD: expected a texture name, found %s\n", line );
continue;
}
// the studiomdl comment here is "strip off trailing smag" whatever smag is...
strncpy( texname, line, MAXTEXNAME );
int i;
for ( i = strlen( texname ) - 1; i >= 0 && ! isgraph( texname[i] ); i-- )
{
}
texname[i + 1] = '\0';
// Skip empty names (studiomdl comment: "weird source problem, skip them")
// Skip null texture references
if ( texname[0] == '\0' ||
stricmp( texname, "null.bmp" ) == 0 ||
stricmp( texname, "null.tga" ) == 0 )
{
is.getline( line, MAXLINE );
is.getline( line, MAXLINE );
is.getline( line, MAXLINE );
continue;
}
// find mesh with matching texture - starting with last one created
int mi;
for ( mi = meshes.size() - 1; mi >= 0; --mi )
{
if ( stricmp( meshes[mi]->texname.c_str(), texname ) == 0 )
break;
}
// if no mesh with texname found, create a new one
if ( mi < 0 )
{
mi = meshes.size();
meshes.push_back( new submesh_t( texname ) );
}
submesh_t *mesh = meshes[mi];
mesh->indices.push_back( ReadVertexFromSMD( mesh->vertices, numbones, is ) );
mesh->indices.push_back( ReadVertexFromSMD( mesh->vertices, numbones, is ) );
mesh->indices.push_back( ReadVertexFromSMD( mesh->vertices, numbones, is ) );
#if 0
// flip triangle - the default in studiomdl
int numIndices = mesh->indices.size();
std::swap( mesh->indices[numIndices-1], mesh->indices[numIndices-2] );
#endif
}
}
void RemapBonesOnSubmesh( submesh_t *pMesh, std::vector< CDmeTransform* > &bones )
{
std::vector<int> vertsPerBone( bones.size() ); // initializes all counts to 0
// find vertex-per-bone counts
int vn = pMesh->vertices.size();
for ( int vi = 0; vi < vn; ++vi )
{
vertex_t &vert = pMesh->vertices[vi];
int bn = vert.skinning.size();
for ( int bi = 0; bi < bn; ++bi )
{
++vertsPerBone[vert.skinning[bi].index];
}
}
std::vector<int> boneMap( bones.size() );
// copy only used bones into mesh's internal bone list and write mapping
int bn = vertsPerBone.size();
for ( int bi = 0; bi < bn; ++bi )
{
if ( vertsPerBone[bi] == 0 )
{
boneMap[bi] = -1;
}
else
{
boneMap[bi] = pMesh->bones.size();
pMesh->bones.push_back( bones[bi] );
}
}
// remap mesh's verts to use the interal bone indexing
for ( int vi = 0; vi < vn; ++vi )
{
vertex_t &vert = pMesh->vertices[vi];
int bn = vert.skinning.size();
for ( int bi = 0; bi < bn; ++bi )
{
vert.skinning[bi].index = boneMap[vert.skinning[bi].index];
}
}
}
CDmeTestMesh *CDmeTestMesh::ReadMeshFromSMD( char *pFilename, DmFileId_t fileid )
{
std::ifstream is( pFilename );
if ( !is )
{
Warning( "Unable to open file %s\n", pFilename );
return NULL;
}
CDmeTestMesh *pMesh = CreateElement< CDmeTestMesh >( "New Mesh", fileid );
char line[ MAXLINE ];
char cmd[ MAXCMD ];
int option;
while ( is.getline( line, MAXLINE ) )
{
int numRead = sscanf( line, "%1023s %d", cmd, &option );
if ( ( numRead == EOF ) || ( numRead == 0 ) )
continue; // blank line
if ( strcmp( cmd, "version" ) == 0 )
{
if ( option != 1 )
{
Error( "ReadMeshFromSMD: bad version\n" );
}
}
else if ( strcmp( cmd, "nodes" ) == 0 )
{
pMesh->m_bones.clear();
ReadBonesFromSMD( pMesh->m_bones, is, fileid );
}
else if ( strcmp( cmd, "skeleton" ) == 0 )
{
ReadSkeletalAnimationFromSMD( pMesh->m_bones, is );
}
else if ( strcmp( cmd, "triangles" ) == 0 )
{
ReadTrianglesFromSMD( pMesh->m_submeshes, pMesh->m_bones.size(), is );
}
else if ( strcmp( cmd, "vertexanimation" ) == 0 )
{
// Grab_Vertexanimation( psource );
return pMesh; // TODO - implement Grab_Vertexanimation!!!
}
else
{
Warning( "unknown studio command\n" );
}
}
#if 0
// remap only the needed bones to hopefully fit within maxbone contraints
int mn = pMesh->m_submeshes.size();
for ( int mi = 0; mi < mn; ++mi)
{
RemapBonesOnSubmesh( pMesh->m_submeshes[mi], pMesh->m_bones );
Msg( "remapping %d bones on mesh to %d bones on submesh %d\n",
pMesh->m_bones.size(),
pMesh->m_submeshes[mi]->bones.size(),
mi );
}
#endif
return pMesh;
}