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.
460 lines
13 KiB
460 lines
13 KiB
//============ Copyright (c) Valve Corporation, All rights reserved. ========== |
|
// |
|
// Function which do validation tests on UVs values at the s_source_t level |
|
// |
|
//============================================================================= |
|
|
|
|
|
#include "tier1/fmtstr.h" |
|
#include "tier1/utlmap.h" |
|
|
|
|
|
#include "studiomdl.h" |
|
#include "checkuv.h" |
|
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
CCheckUVCmd::CCheckUVCmd() |
|
{ |
|
Clear(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
void CCheckUVCmd::Clear() |
|
{ |
|
ClearCheck( CHECK_UV_ALL_FLAGS ); |
|
m_nOptGutterTexWidth = 512; |
|
m_nOptGutterTexHeight = 512; |
|
m_nOptGutterMin = 5; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Dumps an s_soruce_t as an OBJ file |
|
//----------------------------------------------------------------------------- |
|
static void WriteOBJ( const char *pszFilename, const s_source_t *pSource ) |
|
{ |
|
FILE *pFile = fopen( pszFilename, "w" ); |
|
|
|
fprintf( pFile, "#\n" ); |
|
fprintf( pFile, "# s_source_t: %s\n", pSource->filename ); |
|
fprintf( pFile, "# Bone Count: %d\n", pSource->numbones ); |
|
|
|
for ( int i = 0; i < pSource->numbones; ++i ) |
|
{ |
|
if ( pSource->localBone[i].parent >= 0 ) |
|
{ |
|
fprintf( pFile, "# Bone %3d: %s Parent %3d: %s\n", i, pSource->localBone[i].name, pSource->localBone[i].parent, pSource->localBone[pSource->localBone[i].parent].name ); |
|
} |
|
else |
|
{ |
|
fprintf( pFile, "# Bone %3d: %s\n", i, pSource->localBone[i].name ); |
|
} |
|
} |
|
|
|
fprintf( pFile, "# Mesh Count: %d\n", pSource->nummeshes ); |
|
fprintf( pFile, "# Vertex Count: %d\n", pSource->numvertices ); |
|
fprintf( pFile, "# Face Count: %d\n", pSource->numfaces ); |
|
|
|
fprintf( pFile, "#\n" ); |
|
fprintf( pFile, "# positions\n" ); |
|
fprintf( pFile, "#\n" ); |
|
|
|
for ( int i = 0; i < pSource->numvertices; ++i ) |
|
{ |
|
const s_vertexinfo_t &v = pSource->vertex[i]; |
|
fprintf( pFile, "v %.4f %.4f %.4f\n", v.position.x, v.position.y, v.position.z ); |
|
} |
|
|
|
fprintf( pFile, "#\n" ); |
|
fprintf( pFile, "# texture coordinates\n" ); |
|
fprintf( pFile, "#\n" ); |
|
|
|
for ( int i = 0; i < pSource->numvertices; ++i ) |
|
{ |
|
const s_vertexinfo_t &v = pSource->vertex[i]; |
|
fprintf( pFile, "vt %.4f %.4f\n", v.texcoord.x, v.texcoord.y ); |
|
} |
|
|
|
fprintf( pFile, "#\n" ); |
|
fprintf( pFile, "# normals\n" ); |
|
fprintf( pFile, "#\n" ); |
|
|
|
for ( int i = 0; i < pSource->numvertices; ++i ) |
|
{ |
|
const s_vertexinfo_t &v = pSource->vertex[i]; |
|
fprintf( pFile, "vn %.4f %.4f %.4f\n", v.normal.x, v.normal.y, v.normal.z ); |
|
} |
|
|
|
for ( int i = 0; i < pSource->nummeshes; ++i ) |
|
{ |
|
const s_mesh_t &m = pSource->mesh[i]; |
|
const s_texture_t &t = g_texture[pSource->meshindex[i]]; |
|
|
|
fprintf( pFile, "#\n" ); |
|
fprintf( pFile, "# mesh %d - %s\n", i, t.name ); |
|
fprintf( pFile, "# Face Count: %d\n", m.numfaces ); |
|
fprintf( pFile, "#\n" ); |
|
fprintf( pFile, "usemtl %s\n", t.name ); |
|
|
|
for ( int j = 0; j < m.numfaces; ++j ) |
|
{ |
|
const s_face_t &f = pSource->face[m.faceoffset + j]; |
|
fprintf( pFile, "f %d/%d/%d %d/%d/%d %d/%d/%d\n", |
|
f.a, f.a, f.a, |
|
f.b, f.b, f.b, |
|
f.c, f.c, f.c ); |
|
} |
|
} |
|
|
|
fclose( pFile ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
bool CCheckUVCmd::CheckUVs( const s_source_t *const *pSourceList, int nSourceCount ) const |
|
{ |
|
if ( !DoAnyCheck() || nSourceCount <= 0 ) |
|
return true; |
|
|
|
bool bRet = true; |
|
|
|
for ( int i = 0; i < nSourceCount; ++i ) |
|
{ |
|
const s_source_t *pSource = pSourceList[i]; |
|
|
|
bRet &= CheckNormalized( pSource ); |
|
bRet &= CheckOverlap( pSource ); |
|
bRet &= CheckInverse( pSource ); |
|
bRet &= CheckGutter( pSource ); |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Check that all UVs are in the [0, 1] range |
|
//----------------------------------------------------------------------------- |
|
bool CCheckUVCmd::CheckNormalized( const struct s_source_t *pSource ) const |
|
{ |
|
if ( !DoCheck( CHECK_UV_FLAG_NORMALIZED ) ) |
|
return true; |
|
|
|
CUtlRBTree< int > badVertexIndices( CDefOps< int >::LessFunc ); |
|
|
|
for ( int i = 0; i < pSource->numvertices; ++i ) |
|
{ |
|
const s_vertexinfo_t &v = pSource->vertex[i]; |
|
|
|
if ( |
|
v.texcoord.x < 0.0f || v.texcoord.x > 1.0f || |
|
v.texcoord.y < 0.0f || v.texcoord.y > 1.0f ) |
|
{ |
|
badVertexIndices.InsertIfNotFound( i ); |
|
} |
|
} |
|
|
|
if ( badVertexIndices.Count() <= 0 ) |
|
return true; |
|
|
|
Msg( "Error! %s\n", pSource->filename ); |
|
Msg( " UVs outside of [0, 1] range\n" ); |
|
|
|
for ( int i = 0; i < pSource->nummeshes; ++i ) |
|
{ |
|
const s_mesh_t &m = pSource->mesh[i]; |
|
const s_texture_t &t = g_texture[pSource->meshindex[i]]; |
|
|
|
CUtlRBTree< int > badMeshVertexIndices( CDefOps< int >::LessFunc ); |
|
|
|
for ( int j = 0; j < m.numfaces; ++j ) |
|
{ |
|
const s_face_t &f = pSource->face[m.faceoffset + j]; |
|
|
|
if ( badVertexIndices.HasElement( f.a ) ) |
|
{ |
|
badMeshVertexIndices.InsertIfNotFound( f.a ); |
|
} |
|
|
|
if ( badVertexIndices.HasElement( f.b ) ) |
|
{ |
|
badMeshVertexIndices.InsertIfNotFound( f.b ); |
|
} |
|
|
|
if ( badVertexIndices.HasElement( f.c ) ) |
|
{ |
|
badMeshVertexIndices.InsertIfNotFound( f.c ); |
|
} |
|
} |
|
|
|
for ( auto vIt = badMeshVertexIndices.FirstInorder(); badMeshVertexIndices.IsValidIndex( vIt ); vIt = badMeshVertexIndices.NextInorder( vIt ) ) |
|
{ |
|
PrintVertex( pSource->vertex[badMeshVertexIndices.Element( vIt )], t ); |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Check that all polygons in UV do not overlap |
|
//----------------------------------------------------------------------------- |
|
bool CCheckUVCmd::CheckOverlap( const struct s_source_t *pSource ) const |
|
{ |
|
if ( !DoCheck( CHECK_UV_FLAG_OVERLAP ) ) |
|
return true; |
|
|
|
bool bRet = true; |
|
|
|
CUtlVector< CUtlVector< int > > faceOverlapMap; |
|
faceOverlapMap.SetCount( pSource->numfaces ); |
|
|
|
for ( int i = 0; i < pSource->numfaces; ++i ) |
|
{ |
|
const s_face_t &fA = pSource->face[i]; |
|
|
|
const Vector2D &tAA = pSource->vertex[fA.a].texcoord; |
|
const Vector2D &tAB = pSource->vertex[fA.b].texcoord; |
|
const Vector2D &tAC = pSource->vertex[fA.c].texcoord; |
|
|
|
for ( int j = i + 1; j < pSource->numfaces; ++j ) |
|
{ |
|
const s_face_t &fB = pSource->face[j]; |
|
|
|
const Vector2D tB[] = { |
|
pSource->vertex[fB.a].texcoord, |
|
pSource->vertex[fB.b].texcoord, |
|
pSource->vertex[fB.c].texcoord }; |
|
|
|
for ( int k = 0; k < ARRAYSIZE( tB ); ++k ) |
|
{ |
|
const Vector vCheck = Barycentric( tB[k], tAA, tAB, tAC ); |
|
|
|
if ( vCheck.x > 0.0f && vCheck.y > 0.0f && vCheck.z > 0.0f ) |
|
{ |
|
if ( bRet ) |
|
{ |
|
Msg( "Error! %s\n", pSource->filename ); |
|
Msg( " Overlapping UV faces\n" ); |
|
|
|
bRet = false; |
|
} |
|
|
|
faceOverlapMap[i].AddToTail( j ); |
|
|
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
for ( int i = 0; i < faceOverlapMap.Count(); ++i ) |
|
{ |
|
const CUtlVector< int > &overlapList = faceOverlapMap[i]; |
|
|
|
if ( overlapList.IsEmpty() ) |
|
continue;; |
|
|
|
const int nFaceA = i; |
|
const int nMeshA = FindMeshIndex( pSource, nFaceA ); |
|
PrintFace( pSource, nMeshA, nFaceA ); |
|
Msg( " Overlaps\n" ); |
|
|
|
for ( int j = 0; j < overlapList.Count(); ++j ) |
|
{ |
|
const int nFaceB = overlapList[j]; |
|
const int nMeshB = FindMeshIndex( pSource, nFaceB ); |
|
PrintFace( pSource, nMeshB, nFaceB, " " ); |
|
} |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Check that all polygons in UV have the correct winding, i.e. the cross |
|
// product of edge AB x BC points the right direction |
|
//----------------------------------------------------------------------------- |
|
bool CCheckUVCmd::CheckInverse( const struct s_source_t *pSource ) const |
|
{ |
|
if ( !DoCheck( CHECK_UV_FLAG_INVERSE ) ) |
|
return true; |
|
|
|
bool bRetVal = true; |
|
|
|
for ( int i = 0; i < pSource->nummeshes; ++i ) |
|
{ |
|
const s_mesh_t &m = pSource->mesh[i]; |
|
|
|
for ( int j = 0; j < m.numfaces; ++j ) |
|
{ |
|
const int nFaceIndex = m.faceoffset + j; |
|
|
|
const s_face_t &f = pSource->face[nFaceIndex]; |
|
|
|
const Vector2D &tA = pSource->vertex[f.a].texcoord; |
|
const Vector2D &tB = pSource->vertex[f.b].texcoord; |
|
const Vector2D &tC = pSource->vertex[f.c].texcoord; |
|
|
|
const Vector vA( tA.x, tA.y, 0.0f ); |
|
const Vector vB( tB.x, tB.y, 0.0f ); |
|
const Vector vC( tC.x, tC.y, 0.0f ); |
|
|
|
const Vector vAB = vB - vA; |
|
const Vector vBC = vC - vB; |
|
|
|
const Vector vUVNormal = CrossProduct( vAB, vBC ); |
|
|
|
const float flDot = DotProduct( vUVNormal, Vector( 0.0f, 0.0f, 1.0f ) ); |
|
|
|
if ( flDot < 0.0f ) |
|
{ |
|
if ( bRetVal ) |
|
{ |
|
Msg( "Error! %s\n", pSource->filename ); |
|
Msg( " Inverse UV faces\n" ); |
|
|
|
bRetVal = false; |
|
} |
|
|
|
PrintFace( pSource, i, nFaceIndex ); |
|
} |
|
} |
|
} |
|
|
|
return bRetVal; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Check that the distance between edges in UV islands is a minimum number of pixels for a given texture size |
|
//----------------------------------------------------------------------------- |
|
bool CCheckUVCmd::CheckGutter( const struct s_source_t *pSource ) const |
|
{ |
|
if ( !DoCheck( CHECK_UV_FLAG_GUTTER ) ) |
|
return true; |
|
|
|
// TODO: Implement me! |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
Vector CCheckUVCmd::Barycentric( const Vector2D &vP, const Vector2D &vA, const Vector2D &vB, const Vector2D &vC ) |
|
{ |
|
const Vector2D v0 = vB - vA; |
|
const Vector2D v1 = vC - vA; |
|
const Vector2D v2 = vP - vA; |
|
|
|
const float d00 = DotProduct2D( v0, v0 ); |
|
const float d01 = DotProduct2D( v0, v1 ); |
|
const float d11 = DotProduct2D( v1, v1 ); |
|
const float d20 = DotProduct2D( v2, v0 ); |
|
const float d21 = DotProduct2D( v2, v1 ); |
|
|
|
const float flDenom = d00 * d11 - d01 * d01; |
|
|
|
const float flV = ( d11 * d20 - d01 * d21 ) / flDenom; |
|
const float flW = ( d00 * d21 - d01 * d20 ) / flDenom; |
|
const float flU = 1.0f - flV - flW; |
|
|
|
return Vector( flV, flW, flU ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
Vector CCheckUVCmd::Barycentric( const Vector &vP, const Vector &vA, const Vector &vB, const Vector &vC ) |
|
{ |
|
const Vector v0 = vB - vA; |
|
const Vector v1 = vC - vA; |
|
const Vector v2 = vP - vA; |
|
|
|
const float d00 = DotProduct( v0, v0 ); |
|
const float d01 = DotProduct( v0, v1 ); |
|
const float d11 = DotProduct( v1, v1 ); |
|
const float d20 = DotProduct( v2, v0 ); |
|
const float d21 = DotProduct( v2, v1 ); |
|
|
|
const float flDenom = d00 * d11 - d01 * d01; |
|
|
|
const float flV = ( d11 * d20 - d01 * d21 ) / flDenom; |
|
const float flW = ( d00 * d21 - d01 * d20 ) / flDenom; |
|
const float flU = 1.0f - flV - flW; |
|
|
|
return Vector( flV, flW, flU ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
int CCheckUVCmd::FindMeshIndex( const struct s_source_t *pSource, int nFaceIndex ) |
|
{ |
|
for ( int i = 1; i < pSource->nummeshes; ++i ) |
|
{ |
|
if ( nFaceIndex <= pSource->mesh[i].faceoffset ) |
|
return i; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
void CCheckUVCmd::PrintVertex( const s_vertexinfo_t &v, const char *pszPrefix /* = " " */ ) |
|
{ |
|
Msg( "%sP: %8.4f %8.4f %8.4f T: %8.4f %8.4f\n", |
|
pszPrefix, |
|
v.position.x, v.position.y, v.position.z, |
|
v.texcoord.x, v.texcoord.y ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
void CCheckUVCmd::PrintVertex( const s_vertexinfo_t &v, const s_texture_t &t, const char *pszPrefix /* = " " */ ) |
|
{ |
|
Msg( "%sP: %8.4f %8.4f %8.4f T: %8.4f %8.4f M: %s\n", |
|
pszPrefix, |
|
v.position.x, v.position.y, v.position.z, |
|
v.texcoord.x, v.texcoord.y, |
|
t.name ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
//----------------------------------------------------------------------------- |
|
void CCheckUVCmd::PrintFace( const s_source_t *pSource, const int nMesh, const int nFace, const char *pszPrefix /* = " " */ ) |
|
{ |
|
const s_texture_t &t = g_texture[pSource->meshindex[nMesh]]; |
|
const s_face_t &f = pSource->face[nFace]; |
|
|
|
Msg( "%sF: %4d %s\n", pszPrefix, nFace, t.name ); |
|
|
|
PrintVertex( pSource->vertex[f.a], pszPrefix ); |
|
PrintVertex( pSource->vertex[f.b], pszPrefix ); |
|
PrintVertex( pSource->vertex[f.c], pszPrefix ); |
|
} |