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.

1758 lines
52 KiB

5 years ago
//========= 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;
}