mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-02 08:51:57 +00:00
1314 lines
29 KiB
C++
1314 lines
29 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#pragma hdrstop
|
|
#include "precompiled.h"
|
|
|
|
#include "Model_ma.h"
|
|
|
|
/*
|
|
======================================================================
|
|
|
|
Parses Maya ASCII files.
|
|
|
|
======================================================================
|
|
*/
|
|
|
|
|
|
#define MA_VERBOSE( x ) { if ( maGlobal.verbose ) { common->Printf x ; } }
|
|
|
|
// working variables used during parsing
|
|
typedef struct
|
|
{
|
|
bool verbose;
|
|
maModel_t* model;
|
|
maObject_t* currentObject;
|
|
} ma_t;
|
|
|
|
static ma_t maGlobal;
|
|
|
|
|
|
void MA_ParseNodeHeader( idParser& parser, maNodeHeader_t* header )
|
|
{
|
|
|
|
memset( header, 0, sizeof( maNodeHeader_t ) );
|
|
|
|
idToken token;
|
|
while( parser.ReadToken( &token ) )
|
|
{
|
|
if( !token.Icmp( "-" ) )
|
|
{
|
|
parser.ReadToken( &token );
|
|
if( !token.Icmp( "n" ) )
|
|
{
|
|
parser.ReadToken( &token );
|
|
strcpy( header->name, token.c_str() );
|
|
}
|
|
else if( !token.Icmp( "p" ) )
|
|
{
|
|
parser.ReadToken( &token );
|
|
strcpy( header->parent, token.c_str() );
|
|
}
|
|
}
|
|
else if( !token.Icmp( ";" ) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool MA_ParseHeaderIndex( maAttribHeader_t* header, int& minIndex, int& maxIndex, const char* headerType, const char* skipString )
|
|
{
|
|
|
|
idParser miniParse;
|
|
idToken token;
|
|
|
|
miniParse.LoadMemory( header->name, strlen( header->name ), headerType );
|
|
if( skipString )
|
|
{
|
|
miniParse.SkipUntilString( skipString );
|
|
}
|
|
|
|
if( !miniParse.SkipUntilString( "[" ) )
|
|
{
|
|
//This was just a header
|
|
return false;
|
|
}
|
|
minIndex = miniParse.ParseInt();
|
|
miniParse.ReadToken( &token );
|
|
if( !token.Icmp( "]" ) )
|
|
{
|
|
maxIndex = minIndex;
|
|
}
|
|
else
|
|
{
|
|
maxIndex = miniParse.ParseInt();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool MA_ParseAttribHeader( idParser& parser, maAttribHeader_t* header )
|
|
{
|
|
|
|
idToken token;
|
|
|
|
memset( header, 0, sizeof( maAttribHeader_t ) );
|
|
|
|
parser.ReadToken( &token );
|
|
if( !token.Icmp( "-" ) )
|
|
{
|
|
parser.ReadToken( &token );
|
|
if( !token.Icmp( "s" ) )
|
|
{
|
|
header->size = parser.ParseInt();
|
|
parser.ReadToken( &token );
|
|
}
|
|
}
|
|
strcpy( header->name, token.c_str() );
|
|
return true;
|
|
}
|
|
|
|
bool MA_ReadVec3( idParser& parser, idVec3& vec )
|
|
{
|
|
idToken token;
|
|
if( !parser.SkipUntilString( "double3" ) )
|
|
{
|
|
throw idException( va( "Maya Loader '%s': Invalid Vec3", parser.GetFileName() ) );
|
|
}
|
|
|
|
|
|
//We need to flip y and z because of the maya coordinate system
|
|
vec.x = parser.ParseFloat();
|
|
vec.z = parser.ParseFloat();
|
|
vec.y = parser.ParseFloat();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool IsNodeComplete( idToken& token )
|
|
{
|
|
if( !token.Icmp( "createNode" ) || !token.Icmp( "connectAttr" ) || !token.Icmp( "select" ) )
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool MA_ParseTransform( idParser& parser )
|
|
{
|
|
|
|
maNodeHeader_t header;
|
|
maTransform_t* transform;
|
|
memset( &header, 0, sizeof( header ) );
|
|
|
|
//Allocate room for the transform
|
|
transform = ( maTransform_t* )Mem_Alloc( sizeof( maTransform_t ), TAG_MODEL );
|
|
memset( transform, 0, sizeof( maTransform_t ) );
|
|
transform->scale.x = transform->scale.y = transform->scale.z = 1;
|
|
|
|
//Get the header info from the transform
|
|
MA_ParseNodeHeader( parser, &header );
|
|
|
|
//Read the transform attributes
|
|
idToken token;
|
|
while( parser.ReadToken( &token ) )
|
|
{
|
|
if( IsNodeComplete( token ) )
|
|
{
|
|
parser.UnreadToken( &token );
|
|
break;
|
|
}
|
|
if( !token.Icmp( "setAttr" ) )
|
|
{
|
|
parser.ReadToken( &token );
|
|
if( !token.Icmp( ".t" ) )
|
|
{
|
|
if( !MA_ReadVec3( parser, transform->translate ) )
|
|
{
|
|
return false;
|
|
}
|
|
transform->translate.y *= -1;
|
|
}
|
|
else if( !token.Icmp( ".r" ) )
|
|
{
|
|
if( !MA_ReadVec3( parser, transform->rotate ) )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if( !token.Icmp( ".s" ) )
|
|
{
|
|
if( !MA_ReadVec3( parser, transform->scale ) )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parser.SkipRestOfLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
if( header.parent[0] != 0 )
|
|
{
|
|
//Find the parent
|
|
maTransform_t** parent;
|
|
maGlobal.model->transforms.Get( header.parent, &parent );
|
|
if( parent )
|
|
{
|
|
transform->parent = *parent;
|
|
}
|
|
}
|
|
|
|
//Add this transform to the list
|
|
maGlobal.model->transforms.Set( header.name, transform );
|
|
return true;
|
|
}
|
|
|
|
bool MA_ParseVertex( idParser& parser, maAttribHeader_t* header )
|
|
{
|
|
|
|
maMesh_t* pMesh = &maGlobal.currentObject->mesh;
|
|
idToken token;
|
|
|
|
//Allocate enough space for all the verts if this is the first attribute for verticies
|
|
if( !pMesh->vertexes )
|
|
{
|
|
pMesh->numVertexes = header->size;
|
|
pMesh->vertexes = ( idVec3* )Mem_Alloc( sizeof( idVec3 ) * pMesh->numVertexes, TAG_MODEL );
|
|
}
|
|
|
|
//Get the start and end index for this attribute
|
|
int minIndex, maxIndex;
|
|
if( !MA_ParseHeaderIndex( header, minIndex, maxIndex, "VertexHeader", NULL ) )
|
|
{
|
|
//This was just a header
|
|
return true;
|
|
}
|
|
|
|
//Read each vert
|
|
for( int i = minIndex; i <= maxIndex; i++ )
|
|
{
|
|
pMesh->vertexes[i].x = parser.ParseFloat();
|
|
pMesh->vertexes[i].z = parser.ParseFloat();
|
|
pMesh->vertexes[i].y = -parser.ParseFloat();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool MA_ParseVertexTransforms( idParser& parser, maAttribHeader_t* header )
|
|
{
|
|
|
|
maMesh_t* pMesh = &maGlobal.currentObject->mesh;
|
|
idToken token;
|
|
|
|
//Allocate enough space for all the verts if this is the first attribute for verticies
|
|
if( !pMesh->vertTransforms )
|
|
{
|
|
if( header->size == 0 )
|
|
{
|
|
header->size = 1;
|
|
}
|
|
|
|
pMesh->numVertTransforms = header->size;
|
|
pMesh->vertTransforms = ( idVec4* )Mem_Alloc( sizeof( idVec4 ) * pMesh->numVertTransforms, TAG_MODEL );
|
|
pMesh->nextVertTransformIndex = 0;
|
|
}
|
|
|
|
//Get the start and end index for this attribute
|
|
int minIndex, maxIndex;
|
|
if( !MA_ParseHeaderIndex( header, minIndex, maxIndex, "VertexTransformHeader", NULL ) )
|
|
{
|
|
//This was just a header
|
|
return true;
|
|
}
|
|
|
|
parser.ReadToken( &token );
|
|
if( !token.Icmp( "-" ) )
|
|
{
|
|
idToken tk2;
|
|
parser.ReadToken( &tk2 );
|
|
if( !tk2.Icmp( "type" ) )
|
|
{
|
|
parser.SkipUntilString( "float3" );
|
|
}
|
|
else
|
|
{
|
|
parser.UnreadToken( &tk2 );
|
|
parser.UnreadToken( &token );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parser.UnreadToken( &token );
|
|
}
|
|
|
|
//Read each vert
|
|
for( int i = minIndex; i <= maxIndex; i++ )
|
|
{
|
|
pMesh->vertTransforms[pMesh->nextVertTransformIndex].x = parser.ParseFloat();
|
|
pMesh->vertTransforms[pMesh->nextVertTransformIndex].z = parser.ParseFloat();
|
|
pMesh->vertTransforms[pMesh->nextVertTransformIndex].y = -parser.ParseFloat();
|
|
|
|
//w hold the vert index
|
|
pMesh->vertTransforms[pMesh->nextVertTransformIndex].w = i;
|
|
|
|
pMesh->nextVertTransformIndex++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool MA_ParseEdge( idParser& parser, maAttribHeader_t* header )
|
|
{
|
|
|
|
maMesh_t* pMesh = &maGlobal.currentObject->mesh;
|
|
idToken token;
|
|
|
|
//Allocate enough space for all the verts if this is the first attribute for verticies
|
|
if( !pMesh->edges )
|
|
{
|
|
pMesh->numEdges = header->size;
|
|
pMesh->edges = ( idVec3* )Mem_Alloc( sizeof( idVec3 ) * pMesh->numEdges, TAG_MODEL );
|
|
}
|
|
|
|
//Get the start and end index for this attribute
|
|
int minIndex, maxIndex;
|
|
if( !MA_ParseHeaderIndex( header, minIndex, maxIndex, "EdgeHeader", NULL ) )
|
|
{
|
|
//This was just a header
|
|
return true;
|
|
}
|
|
|
|
//Read each vert
|
|
for( int i = minIndex; i <= maxIndex; i++ )
|
|
{
|
|
pMesh->edges[i].x = parser.ParseFloat();
|
|
pMesh->edges[i].y = parser.ParseFloat();
|
|
pMesh->edges[i].z = parser.ParseFloat();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool MA_ParseNormal( idParser& parser, maAttribHeader_t* header )
|
|
{
|
|
|
|
maMesh_t* pMesh = &maGlobal.currentObject->mesh;
|
|
idToken token;
|
|
|
|
//Allocate enough space for all the verts if this is the first attribute for verticies
|
|
if( !pMesh->normals )
|
|
{
|
|
pMesh->numNormals = header->size;
|
|
pMesh->normals = ( idVec3* )Mem_Alloc( sizeof( idVec3 ) * pMesh->numNormals, TAG_MODEL );
|
|
}
|
|
|
|
//Get the start and end index for this attribute
|
|
int minIndex, maxIndex;
|
|
if( !MA_ParseHeaderIndex( header, minIndex, maxIndex, "NormalHeader", NULL ) )
|
|
{
|
|
//This was just a header
|
|
return true;
|
|
}
|
|
|
|
|
|
parser.ReadToken( &token );
|
|
if( !token.Icmp( "-" ) )
|
|
{
|
|
idToken tk2;
|
|
parser.ReadToken( &tk2 );
|
|
if( !tk2.Icmp( "type" ) )
|
|
{
|
|
parser.SkipUntilString( "float3" );
|
|
}
|
|
else
|
|
{
|
|
parser.UnreadToken( &tk2 );
|
|
parser.UnreadToken( &token );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parser.UnreadToken( &token );
|
|
}
|
|
|
|
|
|
//Read each vert
|
|
for( int i = minIndex; i <= maxIndex; i++ )
|
|
{
|
|
pMesh->normals[i].x = parser.ParseFloat();
|
|
|
|
//Adjust the normals for the change in coordinate systems
|
|
pMesh->normals[i].z = parser.ParseFloat();
|
|
pMesh->normals[i].y = -parser.ParseFloat();
|
|
|
|
pMesh->normals[i].Normalize();
|
|
|
|
}
|
|
|
|
pMesh->normalsParsed = true;
|
|
pMesh->nextNormal = 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
bool MA_ParseFace( idParser& parser, maAttribHeader_t* header )
|
|
{
|
|
|
|
maMesh_t* pMesh = &maGlobal.currentObject->mesh;
|
|
idToken token;
|
|
|
|
//Allocate enough space for all the verts if this is the first attribute for verticies
|
|
if( !pMesh->faces )
|
|
{
|
|
pMesh->numFaces = header->size;
|
|
pMesh->faces = ( maFace_t* )Mem_Alloc( sizeof( maFace_t ) * pMesh->numFaces, TAG_MODEL );
|
|
}
|
|
|
|
//Get the start and end index for this attribute
|
|
int minIndex, maxIndex;
|
|
if( !MA_ParseHeaderIndex( header, minIndex, maxIndex, "FaceHeader", NULL ) )
|
|
{
|
|
//This was just a header
|
|
return true;
|
|
}
|
|
|
|
//Read the face data
|
|
int currentFace = minIndex - 1;
|
|
while( parser.ReadToken( &token ) )
|
|
{
|
|
if( IsNodeComplete( token ) )
|
|
{
|
|
parser.UnreadToken( &token );
|
|
break;
|
|
}
|
|
|
|
if( !token.Icmp( "f" ) )
|
|
{
|
|
int count = parser.ParseInt();
|
|
if( count != 3 )
|
|
{
|
|
throw idException( va( "Maya Loader '%s': Face is not a triangle.", parser.GetFileName() ) );
|
|
}
|
|
//Increment the face number because a new face always starts with an "f" token
|
|
currentFace++;
|
|
|
|
//We cannot reorder edges until later because the normal processing
|
|
//assumes the edges are in the original order
|
|
pMesh->faces[currentFace].edge[0] = parser.ParseInt();
|
|
pMesh->faces[currentFace].edge[1] = parser.ParseInt();
|
|
pMesh->faces[currentFace].edge[2] = parser.ParseInt();
|
|
|
|
//Some more init stuff
|
|
pMesh->faces[currentFace].vertexColors[0] = pMesh->faces[currentFace].vertexColors[1] = pMesh->faces[currentFace].vertexColors[2] = -1;
|
|
|
|
}
|
|
else if( !token.Icmp( "mu" ) )
|
|
{
|
|
int uvstIndex = parser.ParseInt();
|
|
uvstIndex;
|
|
int count = parser.ParseInt();
|
|
if( count != 3 )
|
|
{
|
|
throw idException( va( "Maya Loader '%s': Invalid texture coordinates.", parser.GetFileName() ) );
|
|
}
|
|
pMesh->faces[currentFace].tVertexNum[0] = parser.ParseInt();
|
|
pMesh->faces[currentFace].tVertexNum[1] = parser.ParseInt();
|
|
pMesh->faces[currentFace].tVertexNum[2] = parser.ParseInt();
|
|
|
|
}
|
|
else if( !token.Icmp( "mf" ) )
|
|
{
|
|
int count = parser.ParseInt();
|
|
if( count != 3 )
|
|
{
|
|
throw idException( va( "Maya Loader '%s': Invalid texture coordinates.", parser.GetFileName() ) );
|
|
}
|
|
pMesh->faces[currentFace].tVertexNum[0] = parser.ParseInt();
|
|
pMesh->faces[currentFace].tVertexNum[1] = parser.ParseInt();
|
|
pMesh->faces[currentFace].tVertexNum[2] = parser.ParseInt();
|
|
|
|
}
|
|
else if( !token.Icmp( "fc" ) )
|
|
{
|
|
|
|
int count = parser.ParseInt();
|
|
if( count != 3 )
|
|
{
|
|
throw idException( va( "Maya Loader '%s': Invalid vertex color.", parser.GetFileName() ) );
|
|
}
|
|
pMesh->faces[currentFace].vertexColors[0] = parser.ParseInt();
|
|
pMesh->faces[currentFace].vertexColors[1] = parser.ParseInt();
|
|
pMesh->faces[currentFace].vertexColors[2] = parser.ParseInt();
|
|
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool MA_ParseColor( idParser& parser, maAttribHeader_t* header )
|
|
{
|
|
|
|
maMesh_t* pMesh = &maGlobal.currentObject->mesh;
|
|
idToken token;
|
|
|
|
//Allocate enough space for all the verts if this is the first attribute for verticies
|
|
if( !pMesh->colors )
|
|
{
|
|
pMesh->numColors = header->size;
|
|
pMesh->colors = ( byte* )Mem_Alloc( sizeof( byte ) * pMesh->numColors * 4, TAG_MODEL );
|
|
}
|
|
|
|
//Get the start and end index for this attribute
|
|
int minIndex, maxIndex;
|
|
if( !MA_ParseHeaderIndex( header, minIndex, maxIndex, "ColorHeader", NULL ) )
|
|
{
|
|
//This was just a header
|
|
return true;
|
|
}
|
|
|
|
//Read each vert
|
|
for( int i = minIndex; i <= maxIndex; i++ )
|
|
{
|
|
pMesh->colors[i * 4] = parser.ParseFloat() * 255;
|
|
pMesh->colors[i * 4 + 1] = parser.ParseFloat() * 255;
|
|
pMesh->colors[i * 4 + 2] = parser.ParseFloat() * 255;
|
|
pMesh->colors[i * 4 + 3] = parser.ParseFloat() * 255;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool MA_ParseTVert( idParser& parser, maAttribHeader_t* header )
|
|
{
|
|
|
|
maMesh_t* pMesh = &maGlobal.currentObject->mesh;
|
|
idToken token;
|
|
|
|
//This is not the texture coordinates. It is just the name so ignore it
|
|
if( strstr( header->name, "uvsn" ) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//Allocate enough space for all the data
|
|
if( !pMesh->tvertexes )
|
|
{
|
|
pMesh->numTVertexes = header->size;
|
|
pMesh->tvertexes = ( idVec2* )Mem_Alloc( sizeof( idVec2 ) * pMesh->numTVertexes, TAG_MODEL );
|
|
}
|
|
|
|
//Get the start and end index for this attribute
|
|
int minIndex, maxIndex;
|
|
if( !MA_ParseHeaderIndex( header, minIndex, maxIndex, "TextureCoordHeader", "uvsp" ) )
|
|
{
|
|
//This was just a header
|
|
return true;
|
|
}
|
|
|
|
parser.ReadToken( &token );
|
|
if( !token.Icmp( "-" ) )
|
|
{
|
|
idToken tk2;
|
|
parser.ReadToken( &tk2 );
|
|
if( !tk2.Icmp( "type" ) )
|
|
{
|
|
parser.SkipUntilString( "float2" );
|
|
}
|
|
else
|
|
{
|
|
parser.UnreadToken( &tk2 );
|
|
parser.UnreadToken( &token );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
parser.UnreadToken( &token );
|
|
}
|
|
|
|
//Read each tvert
|
|
for( int i = minIndex; i <= maxIndex; i++ )
|
|
{
|
|
pMesh->tvertexes[i].x = parser.ParseFloat();
|
|
pMesh->tvertexes[i].y = 1.0f - parser.ParseFloat();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Quick check to see if the vert participates in a shared normal
|
|
*/
|
|
bool MA_QuickIsVertShared( int faceIndex, int vertIndex )
|
|
{
|
|
|
|
maMesh_t* pMesh = &maGlobal.currentObject->mesh;
|
|
int vertNum = pMesh->faces[faceIndex].vertexNum[vertIndex];
|
|
|
|
for( int i = 0; i < 3; i++ )
|
|
{
|
|
int edge = pMesh->faces[faceIndex].edge[i];
|
|
if( edge < 0 )
|
|
{
|
|
edge = idMath::Fabs( edge ) - 1;
|
|
}
|
|
if( pMesh->edges[edge].z == 1 && ( pMesh->edges[edge].x == vertNum || pMesh->edges[edge].y == vertNum ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void MA_GetSharedFace( int faceIndex, int vertIndex, int& sharedFace, int& sharedVert )
|
|
{
|
|
|
|
maMesh_t* pMesh = &maGlobal.currentObject->mesh;
|
|
int vertNum = pMesh->faces[faceIndex].vertexNum[vertIndex];
|
|
|
|
sharedFace = -1;
|
|
sharedVert = -1;
|
|
|
|
//Find a shared edge on this face that contains the specified vert
|
|
for( int edgeIndex = 0; edgeIndex < 3; edgeIndex++ )
|
|
{
|
|
|
|
int edge = pMesh->faces[faceIndex].edge[edgeIndex];
|
|
if( edge < 0 )
|
|
{
|
|
edge = idMath::Fabs( edge ) - 1;
|
|
}
|
|
|
|
if( pMesh->edges[edge].z == 1 && ( pMesh->edges[edge].x == vertNum || pMesh->edges[edge].y == vertNum ) )
|
|
{
|
|
|
|
for( int i = 0; i < faceIndex; i++ )
|
|
{
|
|
|
|
for( int j = 0; j < 3; j++ )
|
|
{
|
|
if( pMesh->faces[i].vertexNum[j] == vertNum )
|
|
{
|
|
sharedFace = i;
|
|
sharedVert = j;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if( sharedFace != -1 )
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
void MA_ParseMesh( idParser& parser )
|
|
{
|
|
|
|
maObject_t* object;
|
|
object = ( maObject_t* )Mem_Alloc( sizeof( maObject_t ), TAG_MODEL );
|
|
memset( object, 0, sizeof( maObject_t ) );
|
|
maGlobal.model->objects.Append( object );
|
|
maGlobal.currentObject = object;
|
|
object->materialRef = -1;
|
|
|
|
|
|
//Get the header info from the mesh
|
|
maNodeHeader_t header;
|
|
MA_ParseNodeHeader( parser, &header );
|
|
|
|
//Find my parent
|
|
if( header.parent[0] != 0 )
|
|
{
|
|
//Find the parent
|
|
maTransform_t** parent;
|
|
maGlobal.model->transforms.Get( header.parent, &parent );
|
|
if( parent )
|
|
{
|
|
maGlobal.currentObject->mesh.transform = *parent;
|
|
}
|
|
}
|
|
|
|
strcpy( object->name, header.name );
|
|
|
|
//Read the transform attributes
|
|
idToken token;
|
|
while( parser.ReadToken( &token ) )
|
|
{
|
|
if( IsNodeComplete( token ) )
|
|
{
|
|
parser.UnreadToken( &token );
|
|
break;
|
|
}
|
|
if( !token.Icmp( "setAttr" ) )
|
|
{
|
|
maAttribHeader_t header;
|
|
MA_ParseAttribHeader( parser, &header );
|
|
|
|
if( strstr( header.name, ".vt" ) )
|
|
{
|
|
MA_ParseVertex( parser, &header );
|
|
}
|
|
else if( strstr( header.name, ".ed" ) )
|
|
{
|
|
MA_ParseEdge( parser, &header );
|
|
}
|
|
else if( strstr( header.name, ".pt" ) )
|
|
{
|
|
MA_ParseVertexTransforms( parser, &header );
|
|
}
|
|
else if( strstr( header.name, ".n" ) )
|
|
{
|
|
MA_ParseNormal( parser, &header );
|
|
}
|
|
else if( strstr( header.name, ".fc" ) )
|
|
{
|
|
MA_ParseFace( parser, &header );
|
|
}
|
|
else if( strstr( header.name, ".clr" ) )
|
|
{
|
|
MA_ParseColor( parser, &header );
|
|
}
|
|
else if( strstr( header.name, ".uvst" ) )
|
|
{
|
|
MA_ParseTVert( parser, &header );
|
|
}
|
|
else
|
|
{
|
|
parser.SkipRestOfLine();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
maMesh_t* pMesh = &maGlobal.currentObject->mesh;
|
|
|
|
//Get the verts from the edge
|
|
for( int i = 0; i < pMesh->numFaces; i++ )
|
|
{
|
|
for( int j = 0; j < 3; j++ )
|
|
{
|
|
int edge = pMesh->faces[i].edge[j];
|
|
if( edge < 0 )
|
|
{
|
|
edge = idMath::Fabs( edge ) - 1;
|
|
pMesh->faces[i].vertexNum[j] = pMesh->edges[edge].y;
|
|
}
|
|
else
|
|
{
|
|
pMesh->faces[i].vertexNum[j] = pMesh->edges[edge].x;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Get the normals
|
|
if( pMesh->normalsParsed )
|
|
{
|
|
for( int i = 0; i < pMesh->numFaces; i++ )
|
|
{
|
|
for( int j = 0; j < 3; j++ )
|
|
{
|
|
|
|
//Is this vertex shared
|
|
int sharedFace = -1;
|
|
int sharedVert = -1;
|
|
|
|
if( MA_QuickIsVertShared( i, j ) )
|
|
{
|
|
MA_GetSharedFace( i, j, sharedFace, sharedVert );
|
|
}
|
|
|
|
if( sharedFace != -1 )
|
|
{
|
|
//Get the normal from the share
|
|
pMesh->faces[i].vertexNormals[j] = pMesh->faces[sharedFace].vertexNormals[sharedVert];
|
|
|
|
}
|
|
else
|
|
{
|
|
//The vertex is not shared so get the next normal
|
|
if( pMesh->nextNormal >= pMesh->numNormals )
|
|
{
|
|
//We are using more normals than exist
|
|
throw idException( va( "Maya Loader '%s': Invalid Normals Index.", parser.GetFileName() ) );
|
|
}
|
|
pMesh->faces[i].vertexNormals[j] = pMesh->normals[pMesh->nextNormal];
|
|
pMesh->nextNormal++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Now that the normals are good...lets reorder the verts to make the tris face the right way
|
|
for( int i = 0; i < pMesh->numFaces; i++ )
|
|
{
|
|
int tmp = pMesh->faces[i].vertexNum[1];
|
|
pMesh->faces[i].vertexNum[1] = pMesh->faces[i].vertexNum[2];
|
|
pMesh->faces[i].vertexNum[2] = tmp;
|
|
|
|
idVec3 tmpVec = pMesh->faces[i].vertexNormals[1];
|
|
pMesh->faces[i].vertexNormals[1] = pMesh->faces[i].vertexNormals[2];
|
|
pMesh->faces[i].vertexNormals[2] = tmpVec;
|
|
|
|
tmp = pMesh->faces[i].tVertexNum[1];
|
|
pMesh->faces[i].tVertexNum[1] = pMesh->faces[i].tVertexNum[2];
|
|
pMesh->faces[i].tVertexNum[2] = tmp;
|
|
|
|
tmp = pMesh->faces[i].vertexColors[1];
|
|
pMesh->faces[i].vertexColors[1] = pMesh->faces[i].vertexColors[2];
|
|
pMesh->faces[i].vertexColors[2] = tmp;
|
|
}
|
|
|
|
//Now apply the pt transformations
|
|
for( int i = 0; i < pMesh->numVertTransforms; i++ )
|
|
{
|
|
pMesh->vertexes[( int )pMesh->vertTransforms[i].w] += pMesh->vertTransforms[i].ToVec3();
|
|
}
|
|
|
|
MA_VERBOSE( ( va( "MESH %s - parent %s\n", header.name, header.parent ) ) );
|
|
MA_VERBOSE( ( va( "\tverts:%d\n", maGlobal.currentObject->mesh.numVertexes ) ) );
|
|
MA_VERBOSE( ( va( "\tfaces:%d\n", maGlobal.currentObject->mesh.numFaces ) ) );
|
|
}
|
|
|
|
void MA_ParseFileNode( idParser& parser )
|
|
{
|
|
|
|
//Get the header info from the node
|
|
maNodeHeader_t header;
|
|
MA_ParseNodeHeader( parser, &header );
|
|
|
|
//Read the transform attributes
|
|
idToken token;
|
|
while( parser.ReadToken( &token ) )
|
|
{
|
|
if( IsNodeComplete( token ) )
|
|
{
|
|
parser.UnreadToken( &token );
|
|
break;
|
|
}
|
|
if( !token.Icmp( "setAttr" ) )
|
|
{
|
|
maAttribHeader_t attribHeader;
|
|
MA_ParseAttribHeader( parser, &attribHeader );
|
|
|
|
if( strstr( attribHeader.name, ".ftn" ) )
|
|
{
|
|
parser.SkipUntilString( "string" );
|
|
parser.ReadToken( &token );
|
|
if( !token.Icmp( "(" ) )
|
|
{
|
|
parser.ReadToken( &token );
|
|
}
|
|
|
|
maFileNode_t* fileNode;
|
|
fileNode = ( maFileNode_t* )Mem_Alloc( sizeof( maFileNode_t ), TAG_MODEL );
|
|
strcpy( fileNode->name, header.name );
|
|
strcpy( fileNode->path, token.c_str() );
|
|
|
|
maGlobal.model->fileNodes.Set( fileNode->name, fileNode );
|
|
}
|
|
else
|
|
{
|
|
parser.SkipRestOfLine();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MA_ParseMaterialNode( idParser& parser )
|
|
{
|
|
|
|
//Get the header info from the node
|
|
maNodeHeader_t header;
|
|
MA_ParseNodeHeader( parser, &header );
|
|
|
|
maMaterialNode_t* matNode;
|
|
matNode = ( maMaterialNode_t* )Mem_Alloc( sizeof( maMaterialNode_t ), TAG_MODEL );
|
|
memset( matNode, 0, sizeof( maMaterialNode_t ) );
|
|
|
|
strcpy( matNode->name, header.name );
|
|
|
|
maGlobal.model->materialNodes.Set( matNode->name, matNode );
|
|
}
|
|
|
|
void MA_ParseCreateNode( idParser& parser )
|
|
{
|
|
|
|
idToken token;
|
|
parser.ReadToken( &token );
|
|
|
|
if( !token.Icmp( "transform" ) )
|
|
{
|
|
MA_ParseTransform( parser );
|
|
}
|
|
else if( !token.Icmp( "mesh" ) )
|
|
{
|
|
MA_ParseMesh( parser );
|
|
}
|
|
else if( !token.Icmp( "file" ) )
|
|
{
|
|
MA_ParseFileNode( parser );
|
|
}
|
|
else if( !token.Icmp( "shadingEngine" ) || !token.Icmp( "lambert" ) || !token.Icmp( "phong" ) || !token.Icmp( "blinn" ) )
|
|
{
|
|
MA_ParseMaterialNode( parser );
|
|
}
|
|
}
|
|
|
|
|
|
int MA_AddMaterial( const char* materialName )
|
|
{
|
|
|
|
|
|
maMaterialNode_t** destNode;
|
|
maGlobal.model->materialNodes.Get( materialName, &destNode );
|
|
if( destNode )
|
|
{
|
|
maMaterialNode_t* matNode = *destNode;
|
|
|
|
//Iterate down the tree until we get a file
|
|
while( matNode && !matNode->file )
|
|
{
|
|
matNode = matNode->child;
|
|
}
|
|
if( matNode && matNode->file )
|
|
{
|
|
|
|
//Got the file
|
|
maMaterial_t* material;
|
|
material = ( maMaterial_t* )Mem_Alloc( sizeof( maMaterial_t ), TAG_MODEL );
|
|
memset( material, 0, sizeof( maMaterial_t ) );
|
|
|
|
//Remove the OS stuff
|
|
idStr qPath;
|
|
qPath = fileSystem->OSPathToRelativePath( matNode->file->path );
|
|
|
|
strcpy( material->name, qPath.c_str() );
|
|
|
|
maGlobal.model->materials.Append( material );
|
|
return maGlobal.model->materials.Num() - 1;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
bool MA_ParseConnectAttr( idParser& parser )
|
|
{
|
|
|
|
idStr temp;
|
|
idStr srcName;
|
|
idStr srcType;
|
|
idStr destName;
|
|
idStr destType;
|
|
|
|
idToken token;
|
|
parser.ReadToken( &token );
|
|
temp = token;
|
|
int dot = temp.Find( "." );
|
|
if( dot == -1 )
|
|
{
|
|
throw idException( va( "Maya Loader '%s': Invalid Connect Attribute.", parser.GetFileName() ) );
|
|
}
|
|
srcName = temp.Left( dot );
|
|
srcType = temp.Right( temp.Length() - dot - 1 );
|
|
|
|
parser.ReadToken( &token );
|
|
temp = token;
|
|
dot = temp.Find( "." );
|
|
if( dot == -1 )
|
|
{
|
|
throw idException( va( "Maya Loader '%s': Invalid Connect Attribute.", parser.GetFileName() ) );
|
|
}
|
|
destName = temp.Left( dot );
|
|
destType = temp.Right( temp.Length() - dot - 1 );
|
|
|
|
if( srcType.Find( "oc" ) != -1 )
|
|
{
|
|
|
|
//Is this attribute a material node attribute
|
|
maMaterialNode_t** matNode;
|
|
maGlobal.model->materialNodes.Get( srcName, &matNode );
|
|
if( matNode )
|
|
{
|
|
maMaterialNode_t** destNode;
|
|
maGlobal.model->materialNodes.Get( destName, &destNode );
|
|
if( destNode )
|
|
{
|
|
( *destNode )->child = *matNode;
|
|
}
|
|
}
|
|
|
|
//Is this attribute a file node
|
|
maFileNode_t** fileNode;
|
|
maGlobal.model->fileNodes.Get( srcName, &fileNode );
|
|
if( fileNode )
|
|
{
|
|
maMaterialNode_t** destNode;
|
|
maGlobal.model->materialNodes.Get( destName, &destNode );
|
|
if( destNode )
|
|
{
|
|
( *destNode )->file = *fileNode;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( srcType.Find( "iog" ) != -1 )
|
|
{
|
|
//Is this an attribute for one of our meshes
|
|
for( int i = 0; i < maGlobal.model->objects.Num(); i++ )
|
|
{
|
|
if( !strcmp( maGlobal.model->objects[i]->name, srcName ) )
|
|
{
|
|
//maGlobal.model->objects[i]->materialRef = MA_AddMaterial(destName);
|
|
strcpy( maGlobal.model->objects[i]->materialName, destName );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void MA_BuildScale( idMat4& mat, float x, float y, float z )
|
|
{
|
|
mat.Identity();
|
|
mat[0][0] = x;
|
|
mat[1][1] = y;
|
|
mat[2][2] = z;
|
|
}
|
|
|
|
void MA_BuildAxisRotation( idMat4& mat, float ang, int axis )
|
|
{
|
|
|
|
float sinAng = idMath::Sin( ang );
|
|
float cosAng = idMath::Cos( ang );
|
|
|
|
mat.Identity();
|
|
switch( axis )
|
|
{
|
|
case 0: //x
|
|
mat[1][1] = cosAng;
|
|
mat[1][2] = sinAng;
|
|
mat[2][1] = -sinAng;
|
|
mat[2][2] = cosAng;
|
|
break;
|
|
case 1: //y
|
|
mat[0][0] = cosAng;
|
|
mat[0][2] = -sinAng;
|
|
mat[2][0] = sinAng;
|
|
mat[2][2] = cosAng;
|
|
break;
|
|
case 2://z
|
|
mat[0][0] = cosAng;
|
|
mat[0][1] = sinAng;
|
|
mat[1][0] = -sinAng;
|
|
mat[1][1] = cosAng;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void MA_ApplyTransformation( maModel_t* model )
|
|
{
|
|
|
|
for( int i = 0; i < model->objects.Num(); i++ )
|
|
{
|
|
maMesh_t* mesh = &model->objects[i]->mesh;
|
|
maTransform_t* transform = mesh->transform;
|
|
|
|
|
|
|
|
while( transform )
|
|
{
|
|
|
|
idMat4 rotx, roty, rotz;
|
|
idMat4 scale;
|
|
|
|
rotx.Identity();
|
|
roty.Identity();
|
|
rotz.Identity();
|
|
|
|
if( fabs( transform->rotate.x ) > 0.0f )
|
|
{
|
|
MA_BuildAxisRotation( rotx, DEG2RAD( -transform->rotate.x ), 0 );
|
|
}
|
|
if( fabs( transform->rotate.y ) > 0.0f )
|
|
{
|
|
MA_BuildAxisRotation( roty, DEG2RAD( transform->rotate.y ), 1 );
|
|
}
|
|
if( fabs( transform->rotate.z ) > 0.0f )
|
|
{
|
|
MA_BuildAxisRotation( rotz, DEG2RAD( -transform->rotate.z ), 2 );
|
|
}
|
|
|
|
MA_BuildScale( scale, transform->scale.x, transform->scale.y, transform->scale.z );
|
|
|
|
//Apply the transformation to each vert
|
|
for( int j = 0; j < mesh->numVertexes; j++ )
|
|
{
|
|
mesh->vertexes[j] = scale * mesh->vertexes[j];
|
|
|
|
mesh->vertexes[j] = rotx * mesh->vertexes[j];
|
|
mesh->vertexes[j] = rotz * mesh->vertexes[j];
|
|
mesh->vertexes[j] = roty * mesh->vertexes[j];
|
|
|
|
mesh->vertexes[j] = mesh->vertexes[j] + transform->translate;
|
|
}
|
|
|
|
transform = transform->parent;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
MA_Parse
|
|
=================
|
|
*/
|
|
maModel_t* MA_Parse( const char* buffer, const char* filename, bool verbose )
|
|
{
|
|
memset( &maGlobal, 0, sizeof( maGlobal ) );
|
|
|
|
maGlobal.verbose = verbose;
|
|
|
|
|
|
|
|
|
|
maGlobal.currentObject = NULL;
|
|
|
|
// NOTE: using new operator because aseModel_t contains idList class objects
|
|
maGlobal.model = new( TAG_MODEL ) maModel_t;
|
|
maGlobal.model->objects.Resize( 32, 32 );
|
|
maGlobal.model->materials.Resize( 32, 32 );
|
|
|
|
|
|
idParser parser;
|
|
parser.SetFlags( LEXFL_NOSTRINGCONCAT );
|
|
parser.LoadMemory( buffer, strlen( buffer ), filename );
|
|
|
|
idToken token;
|
|
while( parser.ReadToken( &token ) )
|
|
{
|
|
|
|
if( !token.Icmp( "createNode" ) )
|
|
{
|
|
MA_ParseCreateNode( parser );
|
|
}
|
|
else if( !token.Icmp( "connectAttr" ) )
|
|
{
|
|
MA_ParseConnectAttr( parser );
|
|
}
|
|
}
|
|
|
|
//Resolve The Materials
|
|
for( int i = 0; i < maGlobal.model->objects.Num(); i++ )
|
|
{
|
|
maGlobal.model->objects[i]->materialRef = MA_AddMaterial( maGlobal.model->objects[i]->materialName );
|
|
}
|
|
|
|
|
|
|
|
//Apply Transformation
|
|
MA_ApplyTransformation( maGlobal.model );
|
|
|
|
return maGlobal.model;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
MA_Load
|
|
=================
|
|
*/
|
|
maModel_t* MA_Load( const char* fileName )
|
|
{
|
|
char* buf;
|
|
ID_TIME_T timeStamp;
|
|
maModel_t* ma;
|
|
|
|
fileSystem->ReadFile( fileName, ( void** )&buf, &timeStamp );
|
|
if( !buf )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
try
|
|
{
|
|
ma = MA_Parse( buf, fileName, false );
|
|
ma->timeStamp = timeStamp;
|
|
}
|
|
catch( idException& e )
|
|
{
|
|
common->Warning( "%s", e.GetError() );
|
|
if( maGlobal.model )
|
|
{
|
|
MA_Free( maGlobal.model );
|
|
}
|
|
ma = NULL;
|
|
}
|
|
|
|
fileSystem->FreeFile( buf );
|
|
|
|
return ma;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
MA_Free
|
|
=================
|
|
*/
|
|
void MA_Free( maModel_t* ma )
|
|
{
|
|
int i;
|
|
maObject_t* obj;
|
|
maMesh_t* mesh;
|
|
maMaterial_t* material;
|
|
|
|
if( !ma )
|
|
{
|
|
return;
|
|
}
|
|
for( i = 0; i < ma->objects.Num(); i++ )
|
|
{
|
|
obj = ma->objects[i];
|
|
|
|
// free the base nesh
|
|
mesh = &obj->mesh;
|
|
|
|
if( mesh->vertexes )
|
|
{
|
|
Mem_Free( mesh->vertexes );
|
|
}
|
|
if( mesh->vertTransforms )
|
|
{
|
|
Mem_Free( mesh->vertTransforms );
|
|
}
|
|
if( mesh->normals )
|
|
{
|
|
Mem_Free( mesh->normals );
|
|
}
|
|
if( mesh->tvertexes )
|
|
{
|
|
Mem_Free( mesh->tvertexes );
|
|
}
|
|
if( mesh->edges )
|
|
{
|
|
Mem_Free( mesh->edges );
|
|
}
|
|
if( mesh->colors )
|
|
{
|
|
Mem_Free( mesh->colors );
|
|
}
|
|
if( mesh->faces )
|
|
{
|
|
Mem_Free( mesh->faces );
|
|
}
|
|
Mem_Free( obj );
|
|
}
|
|
ma->objects.Clear();
|
|
|
|
for( i = 0; i < ma->materials.Num(); i++ )
|
|
{
|
|
material = ma->materials[i];
|
|
Mem_Free( material );
|
|
}
|
|
ma->materials.Clear();
|
|
|
|
maTransform_t** trans;
|
|
for( i = 0; i < ma->transforms.Num(); i++ )
|
|
{
|
|
trans = ma->transforms.GetIndex( i );
|
|
Mem_Free( *trans );
|
|
}
|
|
ma->transforms.Clear();
|
|
|
|
|
|
maFileNode_t** fileNode;
|
|
for( i = 0; i < ma->fileNodes.Num(); i++ )
|
|
{
|
|
fileNode = ma->fileNodes.GetIndex( i );
|
|
Mem_Free( *fileNode );
|
|
}
|
|
ma->fileNodes.Clear();
|
|
|
|
maMaterialNode_t** matNode;
|
|
for( i = 0; i < ma->materialNodes.Num(); i++ )
|
|
{
|
|
matNode = ma->materialNodes.GetIndex( i );
|
|
Mem_Free( *matNode );
|
|
}
|
|
ma->materialNodes.Clear();
|
|
delete ma;
|
|
}
|