void MaxAWDExporter::ProcessGeoBlocks()
{
AWDTriGeom *geoBlock;
AWDBlockIterator *it;
int proccessed=0;
it = new AWDBlockIterator(awd->get_mesh_data_blocks());
UpdateProgressBar(MAXAWD_PHASE_PROCESS_GEOMETRY, (double)proccessed/(double)awd->get_mesh_data_blocks()->get_num_blocks());
INodeTab lNodes;
while ((geoBlock = (AWDTriGeom * ) it->next()) != NULL){
INode * node = (INode *)INodeToGeoBlockCache->Get(geoBlock);
if (node==NULL){
AWDMessageBlock * newWarning = new AWDMessageBlock(geoBlock->get_name(), "ERROR: Could not find the INode for this AWDGeometry.");
awd->get_message_blocks()->append(newWarning);
return;
}
lNodes.AppendNode( node );
}
IGameScene* _pIgame = NULL;
_pIgame = GetIGameInterface();
_pIgame->InitialiseIGame( lNodes );
it->reset();
while ((geoBlock = (AWDTriGeom * ) it->next()) != NULL){
INode * node = (INode *)INodeToGeoBlockCache->Get(geoBlock);
if (node==NULL){
AWDMessageBlock * newWarning = new AWDMessageBlock(geoBlock->get_name(), "ERROR: Could not find the INode for this AWDGeometry.");
awd->get_message_blocks()->append(newWarning);
}
else{
int exportThis=false;
IGameObject * gobj = NULL;
IGameMesh * igame_mesh = NULL;
gobj = GetIGameInterface()->GetIGameNode(node)->GetIGameObject();
if(gobj->GetIGameType()==IGameObject::IGAME_MESH){
igame_mesh = (IGameMesh*)gobj;
if (igame_mesh!=NULL){
igame_mesh->InitializeData();
if(igame_mesh->GetNumberOfFaces()>0){
exportThis=true;
}
}
}
if (exportThis){
Object *obj;
obj = node->GetObjectRef();
int skinIdx;
ObjectState os;
IDerivedObject *derivedObject = NULL;
skinIdx = IndexOfSkinMod(node->GetObjectRef(), &derivedObject);
if (skinIdx >= 0) {
// Flatten all modifiers up to but not including
// the skin modifier.
// to do: get the correct time for the neutral-pose
os = derivedObject->Eval(0, skinIdx + 1);
}
else {
// Flatten entire modifier stack
// to do: get the correct time for the neutral-pose
os = node->EvalWorldState(maxInterface->GetTime());
}
obj = os.obj;
ISkin *skin = NULL;
if (derivedObject != NULL && skinIdx >= 0) {
Modifier *mod = derivedObject->GetModifier(skinIdx);
skin = (ISkin *)mod->GetInterface(I_SKIN);
}
ExportTriGeom(geoBlock,obj,node,skin, igame_mesh);
RETURN_IF_ERROR;
}
}
proccessed++;
UpdateProgressBar(MAXAWD_PHASE_PROCESS_GEOMETRY, (double)proccessed/(double)awd->get_mesh_data_blocks()->get_num_blocks());
}
delete it;
_pIgame->ReleaseIGame();
}
static void extractTriangleGeometry( GmModel* gm, INode* node, Mesh* mesh, Mtl* material )
{
#ifdef SGEXPORT_PHYSIQUE
Modifier* phyMod = 0;
IPhysiqueExport* phyExport = 0;
IPhyContextExport* mcExport = 0;
#endif
Modifier* skinMod = 0;
ISkin* skin = 0;
String nodeName ( node->GetName() );
try
{
// vertex transform to left-handed system
Matrix3 pivot = TmUtil::getPivotTransform( node );
Matrix3 vertexTM = pivot * s_convtm;
bool insideOut = TmUtil::hasNegativeParity( pivot );
/*Matrix4x4 pm = TmUtil::toLH( vertexTM );
Debug::println( "Object {0} vertex local TM is", nodeName );
Debug::println( " {0,#.###} {1,#.###} {2,#.###} {3,#.###}", pm(0,0), pm(0,1), pm(0,2), pm(0,3) );
Debug::println( " {0,#.###} {1,#.###} {2,#.###} {3,#.###}", pm(1,0), pm(1,1), pm(1,2), pm(1,3) );
Debug::println( " {0,#.###} {1,#.###} {2,#.###} {3,#.###}", pm(2,0), pm(2,1), pm(2,2), pm(2,3) );
Debug::println( " {0,#.###} {1,#.###} {2,#.###} {3,#.###}", pm(3,0), pm(3,1), pm(3,2), pm(3,3) );*/
// add vertex positions
int vertices = mesh->getNumVerts();
for ( int vi = 0 ; vi < vertices ; ++vi )
{
Point3 v = vertexTM * mesh->verts[vi];
mb::Vertex* vert = gm->addVertex();
vert->setPosition( v.x, v.y, v.z );
}
// add vertex weights (from Physique modifier)
#ifdef SGEXPORT_PHYSIQUE
phyMod = PhyExportUtil::findPhysiqueModifier( node );
if ( phyMod )
{
Debug::println( " Found Physique modifier: {0}", gm->name );
// get (possibly shared) Physique export interface
phyExport = (IPhysiqueExport*)phyMod->GetInterface( I_PHYINTERFACE );
if( !phyExport )
throw Exception( Format("No Physique modifier export interface") );
// export from initial pose?
phyExport->SetInitialPose( false );
// get (unique) context dependent export inteface
mcExport = (IPhyContextExport*)phyExport->GetContextInterface( node );
if( !mcExport )
throw Exception( Format("No Physique modifier context export interface") );
// convert to rigid for time independent vertex assignment
mcExport->ConvertToRigid( true );
// allow blending to export multi-link assignments
mcExport->AllowBlending( true );
// list bones
Vector<INode*> bones( Allocator<INode*>(__FILE__,__LINE__) );
PhyExportUtil::listBones( mcExport, bones );
// add vertex weight maps
for ( int i = 0 ; i < bones.size() ; ++i )
{
INode* bone = bones[i];
String name = bone->GetName();
mb::VertexMap* vmap = gm->addVertexMap( 1, name, mb::VertexMapFormat::VERTEXMAP_WEIGHT );
PhyExportUtil::addWeights( vmap, bone, mcExport );
}
}
#endif // SGEXPORT_PHYSIQUE
// add vertex weights (from Skin modifier)
skinMod = SkinExportUtil::findSkinModifier( node );
if ( skinMod )
{
skin = (ISkin*)skinMod->GetInterface(I_SKIN);
require( skin );
ISkinContextData* skincx = skin->GetContextInterface( node );
require( skincx );
Debug::println( " Found Skin modifier: {0} ({1} bones, {2} points)", gm->name, skin->GetNumBones(), skincx->GetNumPoints() );
if ( skincx->GetNumPoints() != gm->vertices() )
throw Exception( Format("Only some vertices ({0}/{1}) of {2} are skinned", skincx->GetNumPoints(), gm->vertices(), gm->name) );
// list bones
Vector<INode*> bones( Allocator<INode*>(__FILE__,__LINE__) );
SkinExportUtil::listBones( skin, bones );
// add vertex weight maps
for ( int i = 0 ; i < bones.size() ; ++i )
{
INode* bone = bones[i];
String name = bone->GetName();
mb::VertexMap* vmap = gm->addVertexMap( 1, name, mb::VertexMapFormat::VERTEXMAP_WEIGHT );
SkinExportUtil::addWeights( vmap, bone, skin, skincx );
//Debug::println( " Bone {0} is affecting {1} vertices", name, vmap->size() );
}
// DEBUG: print skin node tm and initial object tm
/*Matrix3 tm;
int ok = skin->GetSkinInitTM( node, tm );
require( ok == SKIN_OK );
Debug::println( " NodeInitTM of {0}", nodeName );
TmUtil::println( tm, 4 );
ok = skin->GetSkinInitTM( node, tm, true );
require( ok == SKIN_OK );
Debug::println( " NodeObjectTM of {0}", nodeName );
TmUtil::println( tm, 4 );*/
// DEBUG: print bones
/*Debug::println( " bones of {0}:", nodeName );
for ( int i = 0 ; i < bones.size() ; ++i )
{
Debug::println( " bone ({0}): {1}", i, String(bones[i]->GetName()) );
skin->GetBoneInitTM( bones[i], tm );
Debug::println( " InitNodeTM:" );
TmUtil::println( tm, 6 );
skin->GetBoneInitTM( bones[i], tm, true );
Debug::println( " InitObjectTM:" );
TmUtil::println( tm, 6 );
}*/
// DEBUG: print bones used by the points
/*for ( int i = 0 ; i < skincx->GetNumPoints() ; ++i )
{
int bonec = skincx->GetNumAssignedBones(i);
Debug::println( " point {0} has {1} bones", i, bonec );
for ( int k = 0 ; k < bonec ; ++k )
{
int boneidx = skincx->GetAssignedBone( i, k );
float w = skincx->GetBoneWeight( i, k );
Debug::println( " point {0} boneidx ({1}): {2}, weight {3}", i, k, boneidx, w );
}
}*/
}
// ensure clockwise polygon vertex order
int vx[3] = {2,1,0};
if ( insideOut )
{
int tmp = vx[0];
vx[0] = vx[2];
vx[2] = tmp;
}
// list unique materials used by the triangles
Vector<ShellMaterial> usedMaterials( Allocator<ShellMaterial>(__FILE__,__LINE__) );
if ( material )
{
for ( int fi = 0 ; fi < mesh->getNumFaces() ; ++fi )
{
Face& face = mesh->faces[fi];
int mergesubmaterial = -1;
int originalsubmaterial = -1;
for ( int j = 0; j < material->NumSubMtls(); ++j)
{
// Get Sub Material Slot name
TSTR name = material->GetSubMtlSlotName(j);
// Light maps are stored in sub material slot named "Baked Material"
if ( strcmp( name, "Baked Material" ) == 0 )
mergesubmaterial = j;
else
originalsubmaterial = j;
}
if ( mergesubmaterial != -1 ) // A baked material was found, shell materials will be created
{
Mtl* mat = material->GetSubMtl( originalsubmaterial );
Mtl* bakedmtl = material->GetSubMtl( mergesubmaterial );
if ( mat->NumSubMtls() > 0 ) // Check for nested multi-material
{
for ( int j = 0; j < mat->NumSubMtls(); ++j)
usedMaterials.add( ShellMaterial( mat->GetSubMtl( face.getMatID() % mat->NumSubMtls() ), bakedmtl ) );
} else
usedMaterials.add( ShellMaterial( mat, bakedmtl ) );
}
else if ( material->NumSubMtls() > 0 ) // Multi-material without baked material
{
usedMaterials.add( ShellMaterial( material->GetSubMtl( face.getMatID() % material->NumSubMtls() ), 0 ) );
}
else // Single material without baked material
{
usedMaterials.add( ShellMaterial( material, 0 ) );
}
}
std::sort( usedMaterials.begin(), usedMaterials.end() );
usedMaterials.setSize( std::unique( usedMaterials.begin(), usedMaterials.end() ) - usedMaterials.begin() );
}
// create used materials
for ( int mi = 0 ; mi < usedMaterials.size() ; ++mi )
{
ShellMaterial shellmtl = usedMaterials[mi];
gm->materials.add( GmUtil::createGmMaterial( shellmtl.original, shellmtl.baked ) );
}
// add triangles
for ( int fi = 0 ; fi < mesh->getNumFaces() ; ++fi )
{
mb::Polygon* poly = gm->addPolygon();
// triangle indices
Face& face = mesh->faces[fi];
for ( int vxi = 0 ; vxi < 3 ; ++vxi )
{
int vi = face.v[ vx[vxi] ];
require( vi >= 0 && vi < gm->vertices() );
mb::Vertex* vert = gm->getVertex( vi );
poly->addVertex( vert );
}
// triangle material
int polyMaterialIndex = 0;
if ( material )
{
ShellMaterial mat( material, 0 );
int numsubmaterials = material->NumSubMtls();
if ( numsubmaterials > 0 )
{
mat.original = material->GetSubMtl( face.getMatID() % material->NumSubMtls() );
for ( int j = 0; j < numsubmaterials; ++j) // Is baked material present?
{
TSTR name = material->GetSubMtlSlotName(j);
if ( strcmp( name, "Baked Material" ) == 0 )
mat.baked = material->GetSubMtl( j );
if ( strcmp( name, "Original Material" ) == 0 )
mat.original = material->GetSubMtl( j );
}
if ( mat.original->NumSubMtls() > 0 ) // Is there a nested multi-material?
{
mat.original = mat.original->GetSubMtl( face.getMatID() % mat.original->NumSubMtls() );
}
}
for ( int mi = 0 ; mi < usedMaterials.size() ; ++mi )
{
if ( usedMaterials[mi] == mat )
{
polyMaterialIndex = mi;
break;
}
}
}
poly->setMaterial( polyMaterialIndex );
}
// add vertex colors
int mp = 0;
if ( mesh->mapSupport(mp) && mesh->getNumMapVerts(mp) > 0 )
{
mb::DiscontinuousVertexMap* vmad = gm->addDiscontinuousVertexMap( 3, "rgb", mb::VertexMapFormat::VERTEXMAP_RGB );
int tverts = mesh->getNumMapVerts( mp );
UVVert* tvert = mesh->mapVerts( mp );
TVFace* tface = mesh->mapFaces( mp );
//Debug::println( "Vertex colors:" );
for ( int fi = 0 ; fi < mesh->getNumFaces() ; ++fi )
{
Face& face = mesh->faces[fi];
mb::Polygon* poly = gm->getPolygon( fi );
for ( int vxi = 0 ; vxi < 3 ; ++vxi )
{
int vi = face.v[ vx[vxi] ];
mb::Vertex* vert = gm->getVertex( vi );
Point3 tc = tvert[ tface[fi].t[ vx[vxi] ] % tverts ];
float rgb[3] = {tc.x, tc.y, tc.z};
vmad->addValue( vert->index(), poly->index(), rgb, 3 );
//Debug::println( " vertex[{0}].rgb: {1} {2} {3}", vert->index(), rgb[0], rgb[1], rgb[2] );
}
}
}
// add texcoord layers
int lastCoords = MAX_MESHMAPS-2;
while ( lastCoords > 0 && (!mesh->mapSupport(lastCoords) || 0 == mesh->getNumMapVerts(lastCoords)) )
--lastCoords;
if ( lastCoords > 8 )
throw IOException( Format("Too many texture coordinate sets ({1}) in {0}", gm->name, lastCoords) );
for ( mp = 1 ; mp <= lastCoords ; ++mp )
{
mb::DiscontinuousVertexMap* vmad = gm->addDiscontinuousVertexMap( 2, "uv", mb::VertexMapFormat::VERTEXMAP_TEXCOORD );
if ( mesh->mapSupport(mp) && mesh->getNumMapVerts(mp) > 0 )
{
int tverts = mesh->getNumMapVerts( mp );
UVVert* tvert = mesh->mapVerts( mp );
TVFace* tface = mesh->mapFaces( mp );
for ( int fi = 0 ; fi < mesh->getNumFaces() ; ++fi )
{
Face& face = mesh->faces[fi];
mb::Polygon* poly = gm->getPolygon( fi );
for ( int vxi = 0 ; vxi < 3 ; ++vxi )
{
int vi = face.v[ vx[vxi] ];
mb::Vertex* vert = gm->getVertex( vi );
Point3 tc = tvert[ tface[fi].t[ vx[vxi] ] % tverts ];
float uv[2] = {tc.x, 1.f-tc.y};
vmad->addValue( vert->index(), poly->index(), uv, 2 );
}
}
}
}
// compute face vertex normals from smoothing groups
require( mesh->getNumFaces() == gm->polygons() );
mb::DiscontinuousVertexMap* vmad = gm->addDiscontinuousVertexMap( 3, "vnormals", mb::VertexMapFormat::VERTEXMAP_NORMALS );
for ( int fi = 0 ; fi < gm->polygons() ; ++fi )
{
mb::Polygon* poly = gm->getPolygon( fi );
require( poly );
require( poly->index() >= 0 && poly->index() < mesh->getNumFaces() );
Face& face = mesh->faces[ poly->index() ];
require( poly->vertices() == 3 );
for ( int j = 0 ; j < poly->vertices() ; ++j )
{
Vector3 vn(0,0,0);
mb::Vertex* vert = poly->getVertex( j );
// sum influencing normals
for ( int k = 0 ; k < vert->polygons() ; ++k )
{
mb::Polygon* vpoly = vert->getPolygon( k );
require( vpoly );
require( vpoly->index() >= 0 && vpoly->index() < mesh->getNumFaces() );
Face& vface = mesh->faces[ vpoly->index() ];
if ( 0 != (face.smGroup & vface.smGroup) || poly == vpoly )
{
Vector3 vpolyn;
vpoly->getNormal( &vpolyn.x, &vpolyn.y, &vpolyn.z );
vn += vpolyn;
}
}
// normalize
float lensqr = vn.lengthSquared();
if ( lensqr > Float::MIN_VALUE )
vn *= 1.f / Math::sqrt(lensqr);
else
vn = Vector3(0,0,0);
vmad->addValue( vert->index(), poly->index(), vn.begin(), 3 );
}
}
// re-export mesh points in non-deformed pose if Skin modifier present
// NOTE: 3ds Mesh must not be used after this, because collapsing can invalidate it
if ( skin )
{
// evaluate derived object before Skin modifier
TimeValue time = 0;
bool evalNext = false;
bool evalDone = false;
::ObjectState os;
::Object* obj = node->GetObjectRef();
while ( obj->SuperClassID() == GEN_DERIVOB_CLASS_ID && !evalDone )
{
IDerivedObject* derivedObj = static_cast<IDerivedObject*>(obj);
for ( int modStack = 0 ; modStack < derivedObj->NumModifiers() ; ++modStack )
{
if ( evalNext )
{
os = derivedObj->Eval( time, modStack );
evalDone = true;
break;
}
Modifier* mod = derivedObj->GetModifier(modStack);
if ( mod->ClassID() == SKIN_CLASSID )
evalNext = true;
}
obj = derivedObj->GetObjRef();
}
// evaluate possible non-derived object
if ( evalNext && !evalDone )
{
os = obj->Eval( time );
evalDone = true;
}
// convert to TriObject and get points
if ( evalDone && os.obj->CanConvertToType( Class_ID(TRIOBJ_CLASS_ID,0) ) )
{
Debug::println( " Evaluating object {0} before Skin modifier", nodeName );
// get TriObject
std::auto_ptr<TriObject> triAutoDel(0);
TriObject* tri = static_cast<TriObject*>( os.obj->ConvertToType( time, Class_ID(TRIOBJ_CLASS_ID,0) ) );
if ( tri != os.obj )
triAutoDel = std::auto_ptr<TriObject>( tri );
// get mesh points before Skin is applied
//Debug::println( " Original collapsed mesh has {0} points, before Skin modifier {1} points", mesh->getNumVerts(), tri->mesh.getNumVerts() );
require( gm->vertices() == tri->mesh.getNumVerts() );
Mesh* mesh = &tri->mesh;
int vertices = mesh->getNumVerts();
for ( int vi = 0 ; vi < vertices ; ++vi )
{
Point3 v = vertexTM * mesh->verts[vi];
mb::Vertex* vert = gm->getVertex( vi );
vert->setPosition( v.x, v.y, v.z );
}
}
}
// split vertices with discontinuous vertex map values
for ( int vmi = 0 ; vmi < gm->discontinuousVertexMaps() ; ++vmi )
{
mb::DiscontinuousVertexMap* vmad = gm->getDiscontinuousVertexMap( vmi );
gm->splitVertexDiscontinuities( vmad );
}
// find base texcoord layer
mb::DiscontinuousVertexMap* texcoords = 0;
for ( int i = 0 ; i < gm->discontinuousVertexMaps() ; ++i )
{
mb::DiscontinuousVertexMap* vmad = gm->getDiscontinuousVertexMap(i);
if ( vmad->dimensions() == 2 && vmad->format() == mb::VertexMapFormat::VERTEXMAP_TEXCOORD )
{
texcoords = vmad;
break;
}
}
if ( !texcoords )
Debug::printlnError( "Object {0} must have texture coordinates", gm->name );
// requires identification of footsteps in MySceneExport::isExportableGeometry
//throw IOException( Format("Object {0} must have texture coordinates", gm->name) );
// optimize
gm->removeUnusedVertices();
// cleanup export interfaces
#ifdef SGEXPORT_PHYSIQUE
if ( mcExport )
{
require( phyExport );
phyExport->ReleaseContextInterface( mcExport );
mcExport = 0;
}
if ( phyExport )
{
require( phyMod );
phyMod->ReleaseInterface( I_PHYINTERFACE, phyExport );
phyExport = 0;
}
#endif // SGEXPORT_PHYSIQUE
if ( skin )
{
skinMod->ReleaseInterface( I_SKIN, skin );
skin = 0;
skinMod = 0;
}
}
catch ( ... )
{
// cleanup export interfaces
#ifdef SGEXPORT_PHYSIQUE
if ( mcExport )
{
require( phyExport );
phyExport->ReleaseContextInterface( mcExport );
mcExport = 0;
}
if ( phyExport )
{
require( phyMod );
phyMod->ReleaseInterface( I_PHYINTERFACE, phyExport );
phyExport = 0;
}
#endif // SGEXPORT_PHYSIQUE
if ( skin )
{
skinMod->ReleaseInterface( I_SKIN, skin );
skin = 0;
skinMod = 0;
}
throw;
}
}
