1758 lines
52 KiB
C++
1758 lines
52 KiB
C++
|
//========= 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;
|
||
|
|
}
|