460 lines
13 KiB
C++
460 lines
13 KiB
C++
//============ 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 );
|
|
} |