float plMaxNodeBase::RegionPriority()
{
TimeValue currTime = 0;//hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(currTime).obj;
if( !obj )
return 0;
Matrix3 l2w = GetObjectTM(currTime);
if( obj->ClassID() == Class_ID(DUMMY_CLASS_ID,0) )
{
DummyObject* dummy = (DummyObject*)obj;
Box3 bnd = dummy->GetBox();
return BoxVolume(bnd, l2w);
}
if( obj->CanConvertToType(triObjectClassID) )
{
TriObject *meshObj = (TriObject *)obj->ConvertToType(currTime, triObjectClassID);
if( !meshObj )
return 0;
Mesh& mesh = meshObj->mesh;
Box3 bnd = mesh.getBoundingBox();
if( meshObj != obj )
meshObj->DeleteThis();
return BoxVolume(bnd, l2w);
}
// Don't know how to interpret other, it's not contained.
return 0;
}
//----------------------------------------------------------------------------
TriObject *SceneBuilder::GetTriObject(INode* maxNode, bool *needDel)
{
// 确定Max的节点是否有Mesh物体。
//
// pkNode:
// 要检测的节点。
// pbNeedDel:
// true，在使用完之后，调用者需要删除返回的TriObject*；false，不需要。
// 返回mesh物体指针，如果没有与节点相关的mesh，返回0。
Object *obj = maxNode->EvalWorldState(mTimeStart).obj;
if (!obj)
return 0;
if (!obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
return 0;
TriObject *triObject = (TriObject*)obj->ConvertToType(mTimeStart,
Class_ID(TRIOBJ_CLASS_ID,0));
if (triObject == 0)
return 0;
*needDel = (triObject!=obj ? true : false);
return triObject;
}
static Mesh* ExtractMesh(INode* pNode, TriObject** ppDeleteMe)
{
Object *obj = pNode->EvalWorldState(0).obj;
Mesh *pRetMesh = nil;
if( obj ) {
if( obj->CanConvertToType(triObjectClassID) ) {
// Convert to triangle object
TriObject *tri = (TriObject*)obj->ConvertToType(0, triObjectClassID);
if (tri != obj) *ppDeleteMe = tri; // if Convert allocated, pass back so caller can delete.
if( tri ) {
Mesh *pTMesh = &tri->mesh;
if( pTMesh->getNumFaces() ) {
pRetMesh = pTMesh;
}
}
}
}
return pRetMesh;
}
TriObject* MaxExportPlugin::GetTriObjFromNode(INode* node, BOOL &deleteIt)
{
if (node->IsObjectHidden())
return 0;
deleteIt = FALSE;
Object *obj;
//obj = node->GetObjectRef();
obj = node->EvalWorldState(IP->GetTime()).obj;
if (obj->ClassID() == BONE_OBJ_CLASSID)
return 0;
//file << "OBJCLASS: " << std::to_wstring(obj->ClassID().PartA()) << " " << std::to_wstring(obj->ClassID().PartB()) << "\n";
if (obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
{
TriObject *tri = (TriObject *)obj->ConvertToType(IP->GetTime(),
Class_ID(TRIOBJ_CLASS_ID, 0));
// Note that the TriObject should only be deleted
// if the pointer to it is not equal to the object
// pointer that called ConvertToType()
if (obj != tri) deleteIt = TRUE;
return tri;
}
else
{
return NULL;
}
}
Mesh* SGP_MaxInterface::GetMesh( INode* pNode )
{
if( !IsMesh( pNode ) )
return NULL;
TimeValue time = 0;
// get max mesh instance
ObjectState os;
os = pNode->EvalWorldState(time);
Object* obj = os.obj;
if( !os.obj )
{
assert( false );
return NULL;
}
TriObject* triObj = (TriObject *)obj->ConvertToType( time, triObjectClassID );
if( !triObj )
{
assert( false );
return NULL;
}
Mesh* pMesh = &triObj->GetMesh();
return pMesh;
}
hsBool plMaxNodeBase::Contains(const Point3& worldPt)
{
TimeValue currTime = 0;//hsConverterUtils::Instance().GetTime(GetInterface());
Object *obj = EvalWorldState(currTime).obj;
if( !obj )
return false;
Matrix3 l2w = GetObjectTM(currTime);
Matrix3 w2l = Inverse(l2w);
Point3 pt = w2l * worldPt;
if( obj->ClassID() == Class_ID(DUMMY_CLASS_ID,0) )
{
DummyObject* dummy = (DummyObject*)obj;
Box3 bnd = dummy->GetBox();
return bnd.Contains(pt);
}
if( obj->CanConvertToType(triObjectClassID) )
{
TriObject *meshObj = (TriObject *)obj->ConvertToType(currTime, triObjectClassID);
if( !meshObj )
return false;
Mesh& mesh = meshObj->mesh;
Box3 bnd = mesh.getBoundingBox();
if( !bnd.Contains(pt) )
{
if( meshObj != obj )
meshObj->DeleteThis();
return false;
}
hsBool retVal = true;
int i;
for( i = 0; i < mesh.getNumFaces(); i++ )
{
Face& face = mesh.faces[i];
Point3 p0 = mesh.verts[face.v[0]];
Point3 p1 = mesh.verts[face.v[1]];
Point3 p2 = mesh.verts[face.v[2]];
Point3 n = CrossProd(p1 - p0, p2 - p0);
if( DotProd(pt, n) > DotProd(p0, n) )
{
retVal = false;
break;
}
}
if( meshObj != obj )
meshObj->DeleteThis();
return retVal;
}
// If we can't figure out what it is, the point isn't inside it.
return false;
}
int PhyExporter::callback(INode *node)
{
switch (pass)
{
case exportPass:
if (node->Selected())
{
Object* obj = node->EvalWorldState(0).obj;
if (obj->SuperClassID() == GEOMOBJECT_CLASS_ID && obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
{
TriObject *triObj = (TriObject*)obj->ConvertToType(0, Class_ID(TRIOBJ_CLASS_ID, 0));
Mesh* mesh = &triObj->mesh;
int numFaces = mesh->numFaces;
Face* faces = mesh->faces;
Point3* verts = mesh->verts;
Matrix3 worldMat = node->GetObjTMAfterWSM(0);
indices.reserve(numFaces * 3);
for (int faceIdx = 0; faceIdx < numFaces; faceIdx++)
{
Face* face = &faces[faceIdx];
for (int corner = 0; corner < 3; corner++)
{
int vertIdx = face->v[corner];
Point3 vert = verts[vertIdx] * worldMat;
int i = 0;
for (; i < numVertices; i++)
{
if (vert != pos[i]) continue;
break;
}
if (i == numVertices)
{
pos[i] = vert;
numVertices++;
}
indices.push_back(i);
}
}
}
return TREE_CONTINUE;
}
return TREE_IGNORECHILDREN;
};
return TREE_IGNORECHILDREN;
}
// Return a pointer to a TriObject given an INode or return NULL
// if the node cannot be converted to a TriObject
TriObject *GetTriObjectFromNode(INode *node, int &deleteIt)
{
deleteIt = FALSE;
Object *obj = node->EvalWorldState(0).obj;
if (obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
{
TriObject *tri = (TriObject *) obj->ConvertToType(0, Class_ID(TRIOBJ_CLASS_ID, 0));
// Note that the TriObject should only be deleted
// if the pointer to it is not equal to the object
// pointer that called ConvertToType()
if (obj != tri) deleteIt = TRUE;
return tri;
}
else return NULL;
}
TriObject* Building_collision_exp::GetTriObjectFromNode(INode *node, TimeValue t, BOOL &deleteIt)
{
deleteIt = FALSE;
Object *obj = node->EvalWorldState(t).obj;
if (obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
{
TriObject *tri = (TriObject *) obj->ConvertToType(t, Class_ID(TRIOBJ_CLASS_ID, 0));
if (obj != tri)
{
deleteIt = TRUE;
}
return tri;
}
else
{
return NULL;
}
}
BOOL plDistributor::IGetMesh(INode* node, TriObject*& objToDelete, Mesh*& retMesh) const
{
if( objToDelete )
objToDelete->DeleteThis();
retMesh = nil;
objToDelete = nil;
// Get da object
Object *obj = node->EvalWorldState(TimeValue(0)).obj;
if( !obj )
return false;
if( !obj->CanConvertToType( triObjectClassID ) )
return false;
// Convert to triMesh object
TriObject *meshObj = (TriObject*)obj->ConvertToType(TimeValue(0), triObjectClassID);
if( !meshObj )
return false;
if( meshObj != obj )
objToDelete = meshObj;
// Get the mesh
Mesh* mesh = &(meshObj->mesh);
if( !mesh->getNumFaces() )
{
if( objToDelete )
objToDelete->DeleteThis();
objToDelete = nil;
return false;
}
retMesh = mesh;
retMesh->checkNormals(true);
return true;
}
TriObject* GetTriObjectFromNode(INode *Node, TimeValue T, bool &Delete)
{
Delete = false;
Object *Obj = Node->EvalWorldState(T).obj;
if(Obj && Obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID,0)))
{
TriObject *Tri = (TriObject *)Obj->ConvertToType(T,Class_ID(TRIOBJ_CLASS_ID,0));
if(Obj != Tri)
{
Delete = true;
}
return(Tri);
}
else
{
return(NULL);
}
}
//=================================================================
// Methods for CollectModelTEP
//
int CollectModelTEP::callback(INode *pnode)
{
if (::FNodeMarkedToSkip(pnode))
return TREE_CONTINUE;
if ( !pnode->Selected())
return TREE_CONTINUE;
// clear physique export parameters
m_mcExport = NULL;
m_phyExport = NULL;
m_phyMod = NULL;
m_bonesProMod = NULL;
ASSERT_MBOX(!(pnode)->IsRootNode(), "Encountered a root node!");
int iNode = ::GetIndexOfINode(pnode);
TSTR strNodeName(pnode->GetName());
// The Footsteps node apparently MUST have a dummy mesh attached! Ignore it explicitly.
if (FStrEq((char*)strNodeName, "Bip01 Footsteps"))
return TREE_CONTINUE;
// Helper nodes don't have meshes
Object *pobj = pnode->GetObjectRef();
if (pobj->SuperClassID() == HELPER_CLASS_ID)
return TREE_CONTINUE;
// Get Node's object, convert to a triangle-mesh object, so I can access the Faces
ObjectState os = pnode->EvalWorldState(m_tvToDump);
pobj = os.obj;
// Shouldn't have gotten this far if it's a helper object
if (pobj->SuperClassID() == HELPER_CLASS_ID)
{
sprintf(st_szDBG, "ERROR--Helper node %s has an attached mesh, and it shouldn't.", (char*)strNodeName);
ASSERT_AND_ABORT(FALSE, st_szDBG);
}
// convert mesh to triobject
if (!pobj->CanConvertToType(triObjectClassID))
return TREE_CONTINUE;
TriObject *ptriobj = (TriObject*)pobj->ConvertToType(m_tvToDump, triObjectClassID);
if (ptriobj == NULL)
return TREE_CONTINUE;
Mesh *pmesh = &ptriobj->mesh;
// We want the vertex coordinates in World-space, not object-space
Matrix3 mat3ObjectTM = pnode->GetObjectTM(m_tvToDump);
// initialize physique export parameters
m_phyMod = FindPhysiqueModifier(pnode);
if (m_phyMod)
{
// Physique Modifier exists for given Node
m_phyExport = (IPhysiqueExport *)m_phyMod->GetInterface(I_PHYINTERFACE);
if (m_phyExport)
{
// create a ModContext Export Interface for the specific node of the Physique Modifier
m_mcExport = (IPhyContextExport *)m_phyExport->GetContextInterface(pnode);
if (m_mcExport)
{
// convert all vertices to Rigid
m_mcExport->ConvertToRigid(TRUE);
}
}
}
// initialize bones pro export parameters
m_wa = NULL;
m_bonesProMod = FindBonesProModifier(pnode);
if (m_bonesProMod)
{
m_bonesProMod->SetProperty( BP_PROPID_GET_WEIGHTS, &m_wa );
}
int cVerts = pmesh->getNumVerts();
// Dump the triangle face info
int cFaces = pmesh->getNumFaces();
int *iUsed = new int[cVerts];
for (int iVert = 0; iVert < cVerts; iVert++)
{
iUsed[iVert] = 0;
}
for (int iFace = 0; iFace < cFaces; iFace++)
{
if (pmesh->faces[iFace].flags & HAS_TVERTS)
{
iUsed[pmesh->faces[iFace].getVert(0)] = 1;
iUsed[pmesh->faces[iFace].getVert(1)] = 1;
iUsed[pmesh->faces[iFace].getVert(2)] = 1;
}
}
for (iVert = 0; iVert < cVerts; iVert++)
{
MaxVertWeight *pweight = m_phec->m_MaxVertex[m_phec->m_cMaxVertex] = new MaxVertWeight [m_phec->m_cMaxNode];
Point3 pt3Vertex1 = pmesh->getVert(iVert);
Point3 v1 = pt3Vertex1 * mat3ObjectTM;
GetUnifiedCoord( v1, pweight, m_phec->m_MaxNode, m_phec->m_cMaxNode );
if (CollectWeights( iVert, pweight ))
{
m_phec->m_cMaxVertex++;
}
}
// fflush( m_pfile );
return TREE_CONTINUE;
}
bool AlembicPoints::Save(double time, bool bLastFrame)
{
ESS_PROFILE_FUNC();
// Note: Particles are always considered to be animated even though
// the node does not have the IsAnimated() flag.
// Extract our particle emitter at the given time
TimeValue ticks = GetTimeValueFromFrame(time);
Object *obj = mMaxNode->EvalWorldState(ticks).obj;
SaveMetaData(mMaxNode, this);
SimpleParticle* pSimpleParticle = (SimpleParticle*)obj->GetInterface(I_SIMPLEPARTICLEOBJ);
IPFSystem* ipfSystem = GetPFSystemInterface(obj);
IParticleObjectExt* particlesExt = GetParticleObjectExtInterface(obj);
#ifdef THINKING_PARTICLES
ParticleMat* pThinkingParticleMat = NULL;
TP_MasterSystemInterface* pTPMasterSystemInt = NULL;
if(obj->CanConvertToType(MATTERWAVES_CLASS_ID))
{
pThinkingParticleMat = reinterpret_cast<ParticleMat*>(obj->ConvertToType(ticks, MATTERWAVES_CLASS_ID));
pTPMasterSystemInt = reinterpret_cast<TP_MasterSystemInterface*>(obj->GetInterface(IID_TP_MASTERSYSTEM));
}
#endif
const bool bAutomaticInstancing = GetCurrentJob()->GetOption("automaticInstancing");
if(
#ifdef THINKING_PARTICLES
!pThinkingParticleMat &&
#endif
!particlesExt && !pSimpleParticle){
return false;
}
//We have to put the particle system into the renders state so that PFOperatorMaterialFrequency::Proceed will set the materialID channel
//Note: settting the render state to true breaks the shape node instancing export
bool bRenderStateForced = false;
if(bAutomaticInstancing && ipfSystem && !ipfSystem->IsRenderState()){
ipfSystem->SetRenderState(true);
bRenderStateForced = true;
}
int numParticles = 0;
#ifdef THINKING_PARTICLES
if(pThinkingParticleMat){
numParticles = pThinkingParticleMat->NumParticles();
}
else
#endif
if(particlesExt){
particlesExt->UpdateParticles(mMaxNode, ticks);
numParticles = particlesExt->NumParticles();
}
else if(pSimpleParticle){
pSimpleParticle->Update(ticks, mMaxNode);
numParticles = pSimpleParticle->parts.points.Count();
}
// Store positions, velocity, width/size, scale, id, bounding box
std::vector<Abc::V3f> positionVec;
std::vector<Abc::V3f> velocityVec;
std::vector<Abc::V3f> scaleVec;
std::vector<float> widthVec;
std::vector<float> ageVec;
std::vector<float> massVec;
std::vector<float> shapeTimeVec;
std::vector<Abc::uint64_t> idVec;
std::vector<Abc::uint16_t> shapeTypeVec;
std::vector<Abc::uint16_t> shapeInstanceIDVec;
std::vector<Abc::Quatf> orientationVec;
std::vector<Abc::Quatf> angularVelocityVec;
std::vector<Abc::C4f> colorVec;
positionVec.reserve(numParticles);
velocityVec.reserve(numParticles);
scaleVec.reserve(numParticles);
widthVec.reserve(numParticles);
ageVec.reserve(numParticles);
massVec.reserve(numParticles);
shapeTimeVec.reserve(numParticles);
idVec.reserve(numParticles);
shapeTypeVec.reserve(numParticles);
shapeInstanceIDVec.reserve(numParticles);
orientationVec.reserve(numParticles);
angularVelocityVec.reserve(numParticles);
colorVec.reserve(numParticles);
//std::vector<std::string> instanceNamesVec;
Abc::Box3d bbox;
bool constantPos = true;
bool constantVel = true;
bool constantScale = true;
bool constantWidth = true;
bool constantAge = true;
bool constantOrientation = true;
bool constantAngularVel = true;
bool constantColor = true;
if(bAutomaticInstancing){
SetMaxSceneTime(ticks);
}
//The MAX interfaces return everything in world coordinates,
//so we need to multiply the inverse the node world transform matrix
Matrix3 nodeWorldTM = mMaxNode->GetObjTMAfterWSM(ticks);
// Convert the max transform to alembic
Matrix3 alembicMatrix;
ConvertMaxMatrixToAlembicMatrix(nodeWorldTM, alembicMatrix);
Abc::M44d nodeWorldTrans( alembicMatrix.GetRow(0).x, alembicMatrix.GetRow(0).y, alembicMatrix.GetRow(0).z, 0,
alembicMatrix.GetRow(1).x, alembicMatrix.GetRow(1).y, alembicMatrix.GetRow(1).z, 0,
alembicMatrix.GetRow(2).x, alembicMatrix.GetRow(2).y, alembicMatrix.GetRow(2).z, 0,
alembicMatrix.GetRow(3).x, alembicMatrix.GetRow(3).y, alembicMatrix.GetRow(3).z, 1);
Abc::M44d nodeWorldTransInv = nodeWorldTrans.inverse();
//ESS_LOG_WARNING("tick: "<<ticks<<" numParticles: "<<numParticles<<"\n");
ExoNullView nullView;
particleGroupInterface groupInterface(particlesExt, obj, mMaxNode, &nullView);
{
ESS_PROFILE_SCOPE("AlembicPoints::SAVE - numParticlesLoop");
for (int i = 0; i < numParticles; ++i)
{
Abc::V3f pos(0.0);
Abc::V3f vel(0.0);
Abc::V3f scale(1.0);
Abc::C4f color(0.5, 0.5, 0.5, 1.0);
float age = 0;
Abc::uint64_t id = 0;
Abc::Quatd orientation(0.0, 0.0, 1.0, 0.0);
Abc::Quatd spin(0.0, 0.0, 1.0, 0.0);
// Particle size is a uniform scale multiplier in XSI. In Max, I need to learn where to get this
// For now, we'll just default to 1
float width = 1.0f;
ShapeType shapetype = ShapeType_Point;
float shapeInstanceTime = (float)time;
Abc::uint16_t shapeInstanceId = 0;
#ifdef THINKING_PARTICLES
if(pThinkingParticleMat){
if(pTPMasterSystemInt->IsAlive(i) == FALSE){
continue;
}
//TimeValue ageValue = particlesExt->GetParticleAgeByIndex(i);
TimeValue ageValue = pTPMasterSystemInt->Age(i);
if(ageValue == -1){
continue;
}
ESS_PROFILE_SCOPE("AlembicPoints::SAVE - numParticlesLoop - ThinkingParticles");
age = (float)GetSecondsFromTimeValue(ageValue);
//pos = ConvertMaxPointToAlembicPoint(*particlesExt->GetParticlePositionByIndex(i));
pos = ConvertMaxPointToAlembicPoint(pTPMasterSystemInt->Position(i));
//vel = ConvertMaxVectorToAlembicVector(*particlesExt->GetParticleSpeedByIndex(i) * TIME_TICKSPERSEC);
vel = ConvertMaxVectorToAlembicVector(pTPMasterSystemInt->Velocity(i) * TIME_TICKSPERSEC);
scale = ConvertMaxScaleToAlembicScale(pTPMasterSystemInt->Scale(i));
scale *= pTPMasterSystemInt->Size(i);
//ConvertMaxEulerXYZToAlembicQuat(*particlesExt->GetParticleOrientationByIndex(i), orientation);
Matrix3 alignmentMatMax = pTPMasterSystemInt->Alignment(i);
Abc::M44d alignmentMat;
ConvertMaxMatrixToAlembicMatrix(alignmentMatMax, alignmentMat);
/*alignmentMat = Abc::M44d( alignmentMatMax.GetRow(0).x, alignmentMatMax.GetRow(0).y, alignmentMatMax.GetRow(0).z, 0,
alignmentMatMax.GetRow(1).x, alignmentMatMax.GetRow(1).y, alignmentMatMax.GetRow(1).z, 0,
alignmentMatMax.GetRow(2).x, alignmentMatMax.GetRow(2).y, alignmentMatMax.GetRow(2).z, 0,
alignmentMatMax.GetRow(3).x, alignmentMatMax.GetRow(3).y, alignmentMatMax.GetRow(3).z, 1);*/
//orientation = ConvertMaxQuatToAlembicQuat(extracctuat(alignmentMat), true);
alignmentMat = alignmentMat * nodeWorldTransInv;
orientation = extractQuat(alignmentMat);
//ConvertMaxAngAxisToAlembicQuat(*particlesExt->GetParticleSpinByIndex(i), spin);
ConvertMaxAngAxisToAlembicQuat(pTPMasterSystemInt->Spin(i), spin);
id = particlesExt->GetParticleBornIndex(i);
//seems to always return 0
//int nPid = pThinkingParticleMat->ParticleID(i);
int nMatId = -1;
Matrix3 meshTM;
meshTM.IdentityMatrix();
BOOL bNeedDelete = FALSE;
BOOL bChanged = FALSE;
Mesh* pMesh = NULL;
{
ESS_PROFILE_SCOPE("AlembicPoints::SAVE - numParticlesLoop - ThinkingParticles - GetParticleRenderMesh");
pMesh = pThinkingParticleMat->GetParticleRenderMesh(ticks, mMaxNode, nullView, bNeedDelete, i, meshTM, bChanged);
}
if(pMesh){
ESS_PROFILE_SCOPE("AlembicPoints::SAVE - numParticlesLoop - ThinkingParticles - CacheShapeMesh");
meshInfo mi = CacheShapeMesh(pMesh, bNeedDelete, meshTM, nMatId, i, ticks, shapetype, shapeInstanceId, shapeInstanceTime);
Abc::V3d min = pos + mi.bbox.min;
Abc::V3d max = pos + mi.bbox.max;
bbox.extendBy(min);
bbox.extendBy(max);
}
else{
shapetype = ShapeType_Point;
}
}
else
#endif
if(particlesExt && ipfSystem){
TimeValue ageValue = particlesExt->GetParticleAgeByIndex(i);
if(ageValue == -1){
continue;
}
age = (float)GetSecondsFromTimeValue(ageValue);
pos = ConvertMaxPointToAlembicPoint(*particlesExt->GetParticlePositionByIndex(i));
vel = ConvertMaxVectorToAlembicVector(*particlesExt->GetParticleSpeedByIndex(i) * TIME_TICKSPERSEC);
scale = ConvertMaxScaleToAlembicScale(*particlesExt->GetParticleScaleXYZByIndex(i));
ConvertMaxEulerXYZToAlembicQuat(*particlesExt->GetParticleOrientationByIndex(i), orientation);
ConvertMaxAngAxisToAlembicQuat(*particlesExt->GetParticleSpinByIndex(i), spin);
//age = (float)GetSecondsFromTimeValue(particlesExt->GetParticleAgeByIndex(i));
id = particlesExt->GetParticleBornIndex(i);
if(bAutomaticInstancing){
int nMatId = -1;
if(ipfSystem){
if( groupInterface.setCurrentParticle(ticks, i) ){
nMatId = groupInterface.getCurrentMtlId();
}
else{
ESS_LOG_WARNING("Error: cound retrieve material ID for particle mesh "<<i);
}
}
Matrix3 meshTM;
meshTM.IdentityMatrix();
BOOL bNeedDelete = FALSE;
BOOL bChanged = FALSE;
Mesh* pMesh = pMesh = particlesExt->GetParticleShapeByIndex(i);
if(pMesh){
meshInfo mi = CacheShapeMesh(pMesh, bNeedDelete, meshTM, nMatId, i, ticks, shapetype, shapeInstanceId, shapeInstanceTime);
Abc::V3d min = pos + mi.bbox.min;
Abc::V3d max = pos + mi.bbox.max;
bbox.extendBy(min);
bbox.extendBy(max);
}
else{
shapetype = ShapeType_Point;
}
}
else{
GetShapeType(particlesExt, i, ticks, shapetype, shapeInstanceId, shapeInstanceTime);
}
color = GetColor(particlesExt, i, ticks);
}
else if(pSimpleParticle){
if( ! pSimpleParticle->parts.Alive( i ) ) {
continue;
}
pos = ConvertMaxPointToAlembicPoint(pSimpleParticle->ParticlePosition(ticks, i));
vel = ConvertMaxVectorToAlembicVector(pSimpleParticle->ParticleVelocity(ticks, i));
//simple particles have no scale?
//simple particles have no orientation?
age = (float)GetSecondsFromTimeValue( pSimpleParticle->ParticleAge(ticks, i) );
//simple particles have born index
width = pSimpleParticle->ParticleSize(ticks, i);
Abc::V3d min(pos.x - width/2, pos.y - width/2, pos.z - width/2);
Abc::V3d max(pos.x + width/2, pos.y + width/2, pos.z + width/2);
bbox.extendBy(min);
bbox.extendBy(max);
}
{
ESS_PROFILE_SCOPE("AlembicPoints::SAVE - numParticlesLoop - end loop save");
//move everything from world space to local space
pos = pos * nodeWorldTransInv;
Abc::V4f vel4(vel.x, vel.y, vel.z, 0.0);
vel4 = vel4 * nodeWorldTransInv;
vel.setValue(vel4.x, vel4.y, vel4.z);
//scale = scale * nodeWorldTransInv;
//orientation = Abc::extractQuat(orientation.toMatrix44() * nodeWorldTransInv);
//spin = Abc::extractQuat(spin.toMatrix44() * nodeWorldTransInv);
bbox.extendBy( pos );
positionVec.push_back( pos );
velocityVec.push_back( vel );
scaleVec.push_back( scale );
widthVec.push_back( width );
ageVec.push_back( age );
idVec.push_back( id );
orientationVec.push_back( orientation );
angularVelocityVec.push_back( spin );
shapeTypeVec.push_back( shapetype );
shapeInstanceIDVec.push_back( shapeInstanceId );
shapeTimeVec.push_back( shapeInstanceTime );
colorVec.push_back( color );
constantPos &= (pos == positionVec[0]);
constantVel &= (vel == velocityVec[0]);
constantScale &= (scale == scaleVec[0]);
constantWidth &= (width == widthVec[0]);
constantAge &= (age == ageVec[0]);
constantOrientation &= (orientation == orientationVec[0]);
constantAngularVel &= (spin == angularVelocityVec[0]);
constantColor &= (color == colorVec[0]);
// Set the archive bounding box
// Positions for particles are already cnsider to be in world space
if (mJob)
{
mJob->GetArchiveBBox().extendBy(pos);
}
}
}
}
// if (numParticles > 1)
// {
// ESS_PROFILE_SCOPE("AlembicPoints::Save - vectorResize");
// if (constantPos) { positionVec.resize(1); }
// if (constantVel) { velocityVec.resize(1); }
// if (constantScale) { scaleVec.resize(1); }
// if (constantWidth) { widthVec.resize(1); }
// if (constantAge) { ageVec.resize(1); }
// if (constantOrientation){ orientationVec.resize(1); }
// if (constantAngularVel) { angularVelocityVec.resize(1); }
//if (constantColor) { colorVec.resize(1); }
// }
{
ESS_PROFILE_SCOPE("AlembicPoints::Save - sample writing");
// Store the information into our properties and points schema
Abc::P3fArraySample positionSample( positionVec);
Abc::P3fArraySample velocitySample(velocityVec);
Abc::P3fArraySample scaleSample(scaleVec);
Abc::FloatArraySample widthSample(widthVec);
Abc::FloatArraySample ageSample(ageVec);
Abc::FloatArraySample massSample(massVec);
Abc::FloatArraySample shapeTimeSample(shapeTimeVec);
Abc::UInt64ArraySample idSample(idVec);
Abc::UInt16ArraySample shapeTypeSample(shapeTypeVec);
Abc::UInt16ArraySample shapeInstanceIDSample(shapeInstanceIDVec);
Abc::QuatfArraySample orientationSample(orientationVec);
Abc::QuatfArraySample angularVelocitySample(angularVelocityVec);
Abc::C4fArraySample colorSample(colorVec);
mScaleProperty.set(scaleSample);
mAgeProperty.set(ageSample);
mMassProperty.set(massSample);
mShapeTimeProperty.set(shapeTimeSample);
mShapeTypeProperty.set(shapeTypeSample);
mShapeInstanceIDProperty.set(shapeInstanceIDSample);
mOrientationProperty.set(orientationSample);
mAngularVelocityProperty.set(angularVelocitySample);
mColorProperty.set(colorSample);
mPointsSample.setPositions(positionSample);
mPointsSample.setVelocities(velocitySample);
mPointsSample.setWidths(AbcG::OFloatGeomParam::Sample(widthSample, AbcG::kVertexScope));
mPointsSample.setIds(idSample);
mPointsSample.setSelfBounds(bbox);
mPointsSchema.getChildBoundsProperty().set( bbox);
mPointsSchema.set(mPointsSample);
}
mNumSamples++;
//mInstanceNames.pop_back();
if(bAutomaticInstancing){
saveCurrentFrameMeshes();
}
if(bRenderStateForced){
ipfSystem->SetRenderState(false);
}
if(bLastFrame){
ESS_PROFILE_SCOPE("AlembicParticles::Save - save instance names property");
std::vector<std::string> instanceNames(mNumShapeMeshes);
for(faceVertexHashToShapeMap::iterator it = mShapeMeshCache.begin(); it != mShapeMeshCache.end(); it++){
std::stringstream pathStream;
pathStream << "/" << it->second.name<< "/" << it->second.name <<"Shape";
instanceNames[it->second.nMeshInstanceId] = pathStream.str();
}
//for some reason the .dims property is not written when there is exactly one entry if we don't push an empty string
//having an extra unreferenced entry seems to be harmless
instanceNames.push_back("");
mInstanceNamesProperty.set(Abc::StringArraySample(instanceNames));
}
return true;
}
bool AlembicCamera::Save(double time, bool bLastFrame)
{
TimeValue ticks = GetTimeValueFromFrame(time);
Object *obj = mMaxNode->EvalWorldState(ticks).obj;
if (mNumSamples == 0) {
bForever = CheckIfObjIsValidForever(obj, ticks);
}
else {
bool bNewForever = CheckIfObjIsValidForever(obj, ticks);
if (bForever && bNewForever != bForever) {
ESS_LOG_INFO("bForever has changed");
}
}
bForever = false;
SaveMetaData(mMaxNode, this);
// Set the xform sample
Matrix3 wm = mMaxNode->GetObjTMAfterWSM(ticks);
if (mJob) {
Point3 worldMaxPoint = wm.GetTrans();
Abc::V3f alembicWorldPoint = ConvertMaxPointToAlembicPoint(worldMaxPoint);
mJob->GetArchiveBBox().extendBy(alembicWorldPoint);
}
// check if the camera is animated
if (mNumSamples > 0) {
if (bForever) {
return true;
}
}
// Return a pointer to a Camera given an INode or return false if the node
// cannot be converted to a Camera
CameraObject *cam = NULL;
if (obj->CanConvertToType(Class_ID(SIMPLE_CAM_CLASS_ID, 0))) {
cam = reinterpret_cast<CameraObject *>(
obj->ConvertToType(ticks, Class_ID(SIMPLE_CAM_CLASS_ID, 0)));
}
else if (obj->CanConvertToType(Class_ID(LOOKAT_CAM_CLASS_ID, 0))) {
cam = reinterpret_cast<CameraObject *>(
obj->ConvertToType(ticks, Class_ID(LOOKAT_CAM_CLASS_ID, 0)));
}
else {
return false;
}
CameraState cs;
Interval valid = FOREVER;
cam->EvalCameraState(ticks, valid, &cs);
float tDist = cam->GetTDist(ticks);
float ratio = GetCOREInterface()->GetRendImageAspect();
float aperatureWidth =
GetCOREInterface()->GetRendApertureWidth(); // this may differ from the
// imported value
// unfortunately
float focalLength =
(float)((aperatureWidth / 2.0) /
tan(cs.fov / 2.0)); // alembic wants this one in millimeters
aperatureWidth /= 10.0f; // convert to centimeters
IMultiPassCameraEffect *pCameraEffect = cam->GetIMultiPassCameraEffect();
Interval interval = FOREVER;
BOOL bUseTargetDistance = FALSE;
const int TARGET_DISTANCE = 0;
pCameraEffect->GetParamBlockByID(0)->GetValue(TARGET_DISTANCE, ticks,
bUseTargetDistance, interval);
float fFocalDepth = 0.0f;
const int FOCAL_DEPTH = 1;
pCameraEffect->GetParamBlockByID(0)->GetValue(FOCAL_DEPTH, ticks, fFocalDepth,
interval);
// store the camera data
mCameraSample.setNearClippingPlane(cs.hither);
mCameraSample.setFarClippingPlane(cs.yon);
// mCameraSample.setLensSqueezeRatio(ratio);
// should set to 1.0 according the article "Maya to Softimage: Camera
// Interoperability"
mCameraSample.setLensSqueezeRatio(1.0);
mCameraSample.setFocalLength(focalLength);
mCameraSample.setHorizontalAperture(aperatureWidth);
mCameraSample.setVerticalAperture(aperatureWidth / ratio);
if (bUseTargetDistance) {
mCameraSample.setFocusDistance(tDist);
}
else {
mCameraSample.setFocusDistance(fFocalDepth);
}
// save the samples
mCameraSchema.set(mCameraSample);
mNumSamples++;
// Note that the CamObject should only be deleted if the pointer to it is not
// equal to the object pointer that called ConvertToType()
if (cam != NULL && obj != cam) {
delete cam;
cam = NULL;
return false;
}
return true;
}
// Load blend shape poses
bool BlendShape::loadPoses(ParamList ¶ms, std::vector<vertex> &vertices,long numVertices,long offset,long targetIndex)
{
if (params.useSharedGeom)
{
assert(targetIndex == 0);
m_target = T_MESH;
}
else
{
assert(offset == 0);
poseGroup new_pg;
m_target = T_SUBMESH;
new_pg.targetIndex = targetIndex;
m_poseGroups.insert(std::pair<int,poseGroup>(targetIndex,new_pg));
}
poseGroup& pg = m_poseGroups.find(targetIndex)->second;
if(m_pGameNode && m_pMorphR3)
{
// Disable all skin Modifiers.
std::vector<Modifier*> disabledSkinModifiers;
IGameObject* pGameObject = m_pGameNode->GetIGameObject();
if( pGameObject )
{
int numModifiers = pGameObject->GetNumModifiers();
for( int i = 0; i < numModifiers; ++i )
{
IGameModifier* pGameModifier = pGameObject->GetIGameModifier(i);
if( pGameModifier )
{
if( pGameModifier->IsSkin() )
{
Modifier* pModifier = pGameModifier->GetMaxModifier();
if( pModifier )
{
if( pModifier->IsEnabled() )
{
disabledSkinModifiers.push_back(pModifier);
pModifier->DisableMod();
}
}
}
}
}
}
// Get the original mesh from the IGameNode. Not using IGame here
// since MorphR3 doesn't allow for it. Also we don't know if our vertices
// are in object or world space, so we'll just calculate diffs directly from
// the Max meshes and modify the coordinate system manually.
// Obtained method of getting mesh from 3D Studio Max SDK Training session by
// David Lanier.
bool DeleteObjectWhenDone;
const ObjectState& objectState = m_pGameNode->GetMaxNode()->EvalWorldState(GetCOREInterface()->GetTime());
Object *origMeshObj = objectState.obj;
if (!origMeshObj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
{
FxOgreMaxExporterLog( "Could not access original mesh for morph target comparison.");
return false;
}
// Calculate the DiffTM matrix. This is the difference between the INode's world transform
// which is used to calculate the morph verticies, and the IGameNode's world transform, which is used
// to calculate the Ogre mesh's verticies.
Matrix3 DiffTM = m_pGameNode->GetObjectTM(GetCOREInterface()->GetTime()).ExtractMatrix3();
// The below code is not well tested as FaceFX needs content in the native coordinates.
// I've seen the direction of the morph movement flipped on some content when in Y-up mode
// which sets the coordinate system to IGAME_OGL.
// I can't get this to work on all the morph examples I have however.
IGameConversionManager* pConversionManager = GetConversionManager();
if(IGameConversionManager::IGAME_OGL == pConversionManager->GetCoordSystem())
{
Matrix3 conv = Matrix3(Point3(1,0,0), Point3(0,0,1), Point3(0,-1,0), Point3(0,0,0));
DiffTM = DiffTM * conv;
}
TriObject *origMeshTriObj = (TriObject *) origMeshObj->ConvertToType(GetCOREInterface()->GetTime(), Class_ID(TRIOBJ_CLASS_ID, 0));
if (origMeshObj != origMeshTriObj) DeleteObjectWhenDone = true;
Mesh& origMesh = origMeshTriObj->GetMesh();
const int NumVerts = origMesh.getNumVerts();
for( int i = 0; i < m_pMorphR3->chanBank.size() && i < MR3_NUM_CHANNELS; ++i )
{
if( m_pMorphR3->chanBank[i].mActive )
{
morphChannel* pMorphChannel = &m_pMorphR3->chanBank[i];
if( pMorphChannel )
{
pMorphChannel->rebuildChannel();
std::string posename = string_tools::string_cast<ogre_string_type>(pMorphChannel->mName.data());
int numMorphVertices = pMorphChannel->mNumPoints;
if( numMorphVertices != origMesh.getNumVerts() )
{
MessageBox(GetCOREInterface()->GetMAXHWnd(), _T("Morph targets have failed to export becuase the morph vertex count did not match the base mesh. Collapse the modifier stack prior to export, as smoothing is not supported with morph target export."), _T("Morph Target Export Failed."), MB_OK);
return false;
}
else
{
FxOgreMaxExporterLog( "Exporting Morph target: %s with %d vertices.\n", posename.c_str(), numMorphVertices);
FxOgreMaxExporterLog( "Mesh has %d vertices.\n", numVertices);
FxOgreMaxExporterLog( "%d total vertices.\n", vertices.size());
assert(offset+numVertices <= vertices.size());
// create a new pose
pose p;
p.poseTarget = m_target;
p.index = targetIndex;
p.blendShapeIndex = i;
p.name = posename;
p.pMChannel = pMorphChannel;
size_t numPoints = pMorphChannel->mPoints.size();
std::vector<Point3> vmPoints;
vmPoints.reserve(numPoints);
for( size_t k = 0; k < numPoints; ++k )
{
vmPoints.push_back(pMorphChannel->mPoints[k]);
}
Box3 morphBoundingBox;
// calculate vertex offsets
for (int k=0; k<numVertices; k++)
{
vertexOffset vo;
assert ((offset+k)<vertices.size());
vertex v = vertices[offset+k];
assert(v.index < numMorphVertices);
assert(v.index < origMesh.getNumVerts());
Point3 meshVert = origMesh.getVert(v.index);
Point3 morphVert = vmPoints[v.index];
Point3 diff = morphVert - meshVert;
// Transform our morph vertex movements by whatever
// scaling/rotation is being done by IGame..
Point3 ogreSpacediff = DiffTM.VectorTransform(diff);
// Add this point to the bounding box
morphBoundingBox += morphVert;
vo.x = ogreSpacediff.x * params.lum;
vo.y = ogreSpacediff.y * params.lum;
vo.z = ogreSpacediff.z * params.lum;
vo.index = offset+k;
if (fabs(vo.x) < PRECISION)
vo.x = 0;
if (fabs(vo.y) < PRECISION)
vo.y = 0;
if (fabs(vo.z) < PRECISION)
vo.z = 0;
if ((vo.x!=0) || (vo.y!=0) || (vo.z!=0))
p.offsets.push_back(vo);
}
// add pose to pose list
if (p.offsets.size() > 0)
{
pg.poses.push_back(p);
}
if (params.bsBB)
{
// update bounding boxes of loaded submeshes
for (int j=0; j<params.loadedSubmeshes.size(); j++)
{
Point3 min = morphBoundingBox.Min() * params.lum;
Point3 max = morphBoundingBox.Max() * params.lum;
// Update coordinate system here.
Point3 newMin, newMax;
newMin.x = min.x;
newMin.y = min.z;
newMin.z = min.y;
Box3 newBox(newMin, newMax);
if (params.exportWorldCoords)
newBox = newBox * m_pGameNode->GetWorldTM(GetCOREInterface()->GetTime()).ExtractMatrix3();
params.loadedSubmeshes[j]->m_boundingBox += newBox;
}
}
}
}
}
}
// Re-enable skin modifiers.
for( int i = 0; i < disabledSkinModifiers.size(); ++i )
{
disabledSkinModifiers[i]->EnableMod();
}
// According to David Lanier, this should be deleted, but I get crashes when exporting blendShapes
// without shared geometry when I use the object for the second time. Perhaps it
// can only be used/deleted once. Even without shared geometry, I'll get a strange crash
// a few seconds after successful export with this here.
// if (DeleteObjectWhenDone)
// origMeshTriObj->DeleteMe();
}
return true;
}
int AlembicImport_Camera(const std::string& path, AbcG::IObject& iObj,
alembic_importoptions& options, INode** pMaxNode)
{
const std::string& identifier = iObj.getFullName();
if (!AbcG::ICamera::matches(iObj.getMetaData())) {
return alembic_failure;
}
AbcG::ICamera objCamera = AbcG::ICamera(iObj, Abc::kWrapExisting);
if (!objCamera.valid()) {
return alembic_failure;
}
bool isConstant = objCamera.getSchema().isConstant();
TimeValue zero(0);
INode* pNode = *pMaxNode;
CameraObject* pCameraObj = NULL;
if (!pNode) {
// Create the camera object and place it in the scene
GenCamera* pGenCameraObj =
GET_MAX_INTERFACE()->CreateCameraObject(FREE_CAMERA);
if (pGenCameraObj == NULL) {
return alembic_failure;
}
pGenCameraObj->Enable(TRUE);
pGenCameraObj->SetConeState(TRUE);
pGenCameraObj->SetManualClip(TRUE);
IMultiPassCameraEffect* pCameraEffect =
pGenCameraObj->GetIMultiPassCameraEffect();
const int TARGET_DISTANCE = 0;
pCameraEffect->GetParamBlockByID(0)->SetValue(TARGET_DISTANCE, zero, FALSE);
pCameraObj = pGenCameraObj;
Abc::IObject parent = iObj.getParent();
std::string name = removeXfoSuffix(parent.getName().c_str());
pNode = GET_MAX_INTERFACE()->CreateObjectNode(
pGenCameraObj, EC_UTF8_to_TCHAR(name.c_str()));
if (pNode == NULL) {
return alembic_failure;
}
*pMaxNode = pNode;
}
else {
Object* obj = pNode->EvalWorldState(zero).obj;
if (obj->CanConvertToType(Class_ID(SIMPLE_CAM_CLASS_ID, 0))) {
pCameraObj = reinterpret_cast<CameraObject*>(
obj->ConvertToType(zero, Class_ID(SIMPLE_CAM_CLASS_ID, 0)));
}
else if (obj->CanConvertToType(Class_ID(LOOKAT_CAM_CLASS_ID, 0))) {
pCameraObj = reinterpret_cast<CameraObject*>(
obj->ConvertToType(zero, Class_ID(LOOKAT_CAM_CLASS_ID, 0)));
}
else {
return alembic_failure;
}
}
// Fill in the mesh
// alembic_fillcamera_options dataFillOptions;
// dataFillOptions.pIObj = &iObj;
// dataFillOptions.pCameraObj = pCameraObj;
// dataFillOptions.dTicks = GET_MAX_INTERFACE()->GetTime();
// AlembicImport_FillInCamera(dataFillOptions);
// printAnimatables(pCameraObj);
Interval interval = FOREVER;
AlembicFloatController* pControl = NULL;
{
std::string prop("horizontalFOV");
if (options.attachToExisting) {
pControl = getController(pCameraObj, identifier, prop, 0, 0);
}
if (pControl) {
pControl->GetParamBlockByID(0)->SetValue(
GetParamIdByName(pControl, 0, "path"), zero,
EC_UTF8_to_TCHAR(path.c_str()));
}
else if (assignController(createFloatController(path, identifier, prop),
pCameraObj, 0, 0) &&
!isConstant) {
std::stringstream controllerName;
controllerName << GET_MAXSCRIPT_NODE(pNode);
controllerName << "mynode2113.FOV.controller.time";
AlembicImport_ConnectTimeControl(controllerName.str().c_str(), options);
}
}
{
std::string prop("FocusDistance");
if (options.attachToExisting) {
pControl = getController(pCameraObj, identifier, prop, 1, 0, 1);
}
if (pControl) {
pControl->GetParamBlockByID(0)->SetValue(
GetParamIdByName(pControl, 0, "path"), zero,
EC_UTF8_to_TCHAR(path.c_str()));
}
else if (assignController(createFloatController(path, identifier, prop),
pCameraObj, 1, 0, 1) &&
!isConstant) {
std::stringstream controllerName;
controllerName << GET_MAXSCRIPT_NODE(pNode);
controllerName
<< "mynode2113.MultiPass_Effect.focalDepth.controller.time";
AlembicImport_ConnectTimeControl(controllerName.str().c_str(), options);
}
}
{
std::string prop("NearClippingPlane");
if (options.attachToExisting) {
pControl = getController(pCameraObj, identifier, prop, 0, 2);
}
if (pControl) {
pControl->GetParamBlockByID(0)->SetValue(
GetParamIdByName(pControl, 0, "path"), zero,
EC_UTF8_to_TCHAR(path.c_str()));
}
else if (assignController(createFloatController(path, identifier, prop),
pCameraObj, 0, 2) &&
!isConstant) {
std::stringstream controllerName;
controllerName << GET_MAXSCRIPT_NODE(pNode);
controllerName << "mynode2113.nearclip.controller.time";
AlembicImport_ConnectTimeControl(controllerName.str().c_str(), options);
}
}
{
std::string prop("FarClippingPlane");
if (options.attachToExisting) {
pControl = getController(pCameraObj, identifier, prop, 0, 3);
}
if (pControl) {
pControl->GetParamBlockByID(0)->SetValue(
GetParamIdByName(pControl, 0, "path"), zero,
EC_UTF8_to_TCHAR(path.c_str()));
}
else if (assignController(createFloatController(path, identifier, prop),
pCameraObj, 0, 3) &&
!isConstant) {
std::stringstream controllerName;
controllerName << GET_MAXSCRIPT_NODE(pNode);
controllerName << "mynode2113.farclip.controller.time";
AlembicImport_ConnectTimeControl(controllerName.str().c_str(), options);
}
}
// if(assignControllerToLevel1SubAnim(createFloatController(path, identifier,
// std::string("FocusDistance")), pCameraObj, 0, 1) && !isConstant){
// AlembicImport_ConnectTimeControl( "$.targetDistance.controller.time",
// options );
//}
createCameraModifier(path, identifier, pNode);
// Add the new inode to our current scene list
SceneEntry* pEntry = options.sceneEnumProc.Append(
pNode, pCameraObj, OBTYPE_CAMERA, &std::string(iObj.getFullName()));
options.currentSceneList.Append(pEntry);
// Set the visibility controller
AlembicImport_SetupVisControl(path, identifier, iObj, pNode, options);
importMetadata(pNode, iObj);
return 0;
}
//=================================================================
// Methods for DumpModelTEP
//
int DumpModelTEP::callback(INode *pnode)
{
Object* pobj;
int fHasMat = TRUE;
// clear physique export parameters
m_mcExport = NULL;
m_phyExport = NULL;
m_phyMod = NULL;
ASSERT_MBOX(!(pnode)->IsRootNode(), "Encountered a root node!");
if (::FNodeMarkedToSkip(pnode))
return TREE_CONTINUE;
int iNode = ::GetIndexOfINode(pnode);
TSTR strNodeName(pnode->GetName());
// The Footsteps node apparently MUST have a dummy mesh attached! Ignore it explicitly.
if (FStrEq((char*)strNodeName, "Bip01 Footsteps"))
return TREE_CONTINUE;
// Helper nodes don't have meshes
pobj = pnode->GetObjectRef();
if (pobj->SuperClassID() == HELPER_CLASS_ID)
return TREE_CONTINUE;
// The model's root is a child of the real "scene root"
INode *pnodeParent = pnode->GetParentNode();
BOOL fNodeIsRoot = pnodeParent->IsRootNode( );
// Get node's material: should be a multi/sub (if it has a material at all)
Mtl *pmtlNode = pnode->GetMtl();
if (pmtlNode == NULL)
{
return TREE_CONTINUE;
fHasMat = FALSE;
}
else if (!(pmtlNode->ClassID() == Class_ID(MULTI_CLASS_ID, 0) && pmtlNode->IsMultiMtl()))
{
// sprintf(st_szDBG, "ERROR--Material on node %s isn't a Multi/Sub-Object", (char*)strNodeName);
// ASSERT_AND_ABORT(FALSE, st_szDBG);
fHasMat = FALSE;
}
// Get Node's object, convert to a triangle-mesh object, so I can access the Faces
ObjectState os = pnode->EvalWorldState(m_tvToDump);
pobj = os.obj;
TriObject *ptriobj;
BOOL fConvertedToTriObject =
pobj->CanConvertToType(triObjectClassID) &&
(ptriobj = (TriObject*)pobj->ConvertToType(m_tvToDump, triObjectClassID)) != NULL;
if (!fConvertedToTriObject)
return TREE_CONTINUE;
Mesh *pmesh = &ptriobj->mesh;
// Shouldn't have gotten this far if it's a helper object
if (pobj->SuperClassID() == HELPER_CLASS_ID)
{
sprintf(st_szDBG, "ERROR--Helper node %s has an attached mesh, and it shouldn't.", (char*)strNodeName);
ASSERT_AND_ABORT(FALSE, st_szDBG);
}
// Ensure that the vertex normals are up-to-date
pmesh->buildNormals();
// We want the vertex coordinates in World-space, not object-space
Matrix3 mat3ObjectTM = pnode->GetObjectTM(m_tvToDump);
// initialize physique export parameters
m_phyMod = FindPhysiqueModifier(pnode);
if (m_phyMod)
{
// Physique Modifier exists for given Node
m_phyExport = (IPhysiqueExport *)m_phyMod->GetInterface(I_PHYINTERFACE);
if (m_phyExport)
{
// create a ModContext Export Interface for the specific node of the Physique Modifier
m_mcExport = (IPhyContextExport *)m_phyExport->GetContextInterface(pnode);
if (m_mcExport)
{
// convert all vertices to Rigid
m_mcExport->ConvertToRigid(TRUE);
}
}
}
// Dump the triangle face info
int cFaces = pmesh->getNumFaces();
for (int iFace = 0; iFace < cFaces; iFace++)
{
Face* pface = &pmesh->faces[iFace];
TVFace* ptvface = &pmesh->tvFace[iFace];
DWORD smGroupFace = pface->getSmGroup();
// Get face's 3 indexes into the Mesh's vertex array(s).
DWORD iVertex0 = pface->getVert(0);
DWORD iVertex1 = pface->getVert(1);
DWORD iVertex2 = pface->getVert(2);
ASSERT_AND_ABORT((int)iVertex0 < pmesh->getNumVerts(), "Bogus Vertex 0 index");
ASSERT_AND_ABORT((int)iVertex1 < pmesh->getNumVerts(), "Bogus Vertex 1 index");
ASSERT_AND_ABORT((int)iVertex2 < pmesh->getNumVerts(), "Bogus Vertex 2 index");
// Get the 3 Vertex's for this face
Point3 pt3Vertex0 = pmesh->getVert(iVertex0);
Point3 pt3Vertex1 = pmesh->getVert(iVertex1);
Point3 pt3Vertex2 = pmesh->getVert(iVertex2);
// Get the 3 RVertex's for this face
// NOTE: I'm using getRVertPtr instead of getRVert to work around a 3DSMax bug
RVertex *prvertex0 = pmesh->getRVertPtr(iVertex0);
RVertex *prvertex1 = pmesh->getRVertPtr(iVertex1);
RVertex *prvertex2 = pmesh->getRVertPtr(iVertex2);
// Find appropriate normals for each RVertex
// A vertex can be part of multiple faces, so the "smoothing group"
// is used to locate the normal for this face's use of the vertex.
Point3 pt3Vertex0Normal;
Point3 pt3Vertex1Normal;
Point3 pt3Vertex2Normal;
if (smGroupFace)
{
pt3Vertex0Normal = Pt3GetRVertexNormal(prvertex0, smGroupFace);
pt3Vertex1Normal = Pt3GetRVertexNormal(prvertex1, smGroupFace);
pt3Vertex2Normal = Pt3GetRVertexNormal(prvertex2, smGroupFace);
}
else
{
pt3Vertex0Normal = pmesh->getFaceNormal( iFace );
pt3Vertex1Normal = pmesh->getFaceNormal( iFace );
pt3Vertex2Normal = pmesh->getFaceNormal( iFace );
}
ASSERT_AND_ABORT( Length( pt3Vertex0Normal ) <= 1.1, "bogus orig normal 0" );
ASSERT_AND_ABORT( Length( pt3Vertex1Normal ) <= 1.1, "bogus orig normal 1" );
ASSERT_AND_ABORT( Length( pt3Vertex2Normal ) <= 1.1, "bogus orig normal 2" );
// Get Face's sub-material from node's material, to get the bitmap name.
// And no, there isn't a simpler way to get the bitmap name, you have to
// dig down through all these levels.
TCHAR szBitmapName[256] = "null.bmp";
if (fHasMat)
{
MtlID mtlidFace = pface->getMatID();
if (mtlidFace >= pmtlNode->NumSubMtls())
{
sprintf(st_szDBG, "ERROR--Bogus sub-material index %d in node %s; highest valid index is %d",
mtlidFace, (char*)strNodeName, pmtlNode->NumSubMtls()-1);
// ASSERT_AND_ABORT(FALSE, st_szDBG);
mtlidFace = 0;
}
Mtl *pmtlFace = pmtlNode->GetSubMtl(mtlidFace);
ASSERT_AND_ABORT(pmtlFace != NULL, "NULL Sub-material returned");
if ((pmtlFace->ClassID() == Class_ID(MULTI_CLASS_ID, 0) && pmtlFace->IsMultiMtl()))
{
// it's a sub-sub material. Gads.
pmtlFace = pmtlFace->GetSubMtl(mtlidFace);
ASSERT_AND_ABORT(pmtlFace != NULL, "NULL Sub-material returned");
}
if (!(pmtlFace->ClassID() == Class_ID(DMTL_CLASS_ID, 0)))
{
sprintf(st_szDBG,
"ERROR--Sub-material with index %d (used in node %s) isn't a 'default/standard' material [%x].",
mtlidFace, (char*)strNodeName, pmtlFace->ClassID());
ASSERT_AND_ABORT(FALSE, st_szDBG);
}
StdMat *pstdmtlFace = (StdMat*)pmtlFace;
Texmap *ptexmap = pstdmtlFace->GetSubTexmap(ID_DI);
// ASSERT_AND_ABORT(ptexmap != NULL, "NULL diffuse texture")
if (ptexmap != NULL)
{
if (!(ptexmap->ClassID() == Class_ID(BMTEX_CLASS_ID, 0)))
{
sprintf(st_szDBG,
"ERROR--Sub-material with index %d (used in node %s) doesn't have a bitmap as its diffuse texture.",
mtlidFace, (char*)strNodeName);
ASSERT_AND_ABORT(FALSE, st_szDBG);
}
BitmapTex *pbmptex = (BitmapTex*)ptexmap;
strcpy(szBitmapName, pbmptex->GetMapName());
TSTR strPath, strFile;
SplitPathFile(TSTR(szBitmapName), &strPath, &strFile);
strcpy(szBitmapName,strFile);
}
}
UVVert UVvertex0( 0, 0, 0 );
UVVert UVvertex1( 1, 0, 0 );
UVVert UVvertex2( 0, 1, 0 );
// All faces must have textures assigned to them
if (pface->flags & HAS_TVERTS)
{
// Get TVface's 3 indexes into the Mesh's TVertex array(s).
DWORD iTVertex0 = ptvface->getTVert(0);
DWORD iTVertex1 = ptvface->getTVert(1);
DWORD iTVertex2 = ptvface->getTVert(2);
ASSERT_AND_ABORT((int)iTVertex0 < pmesh->getNumTVerts(), "Bogus TVertex 0 index");
ASSERT_AND_ABORT((int)iTVertex1 < pmesh->getNumTVerts(), "Bogus TVertex 1 index");
ASSERT_AND_ABORT((int)iTVertex2 < pmesh->getNumTVerts(), "Bogus TVertex 2 index");
// Get the 3 TVertex's for this TVFace
// NOTE: I'm using getRVertPtr instead of getRVert to work around a 3DSMax bug
UVvertex0 = pmesh->getTVert(iTVertex0);
UVvertex1 = pmesh->getTVert(iTVertex1);
UVvertex2 = pmesh->getTVert(iTVertex2);
}
else
{
//sprintf(st_szDBG, "ERROR--Node %s has a textureless face. All faces must have an applied texture.", (char*)strNodeName);
//ASSERT_AND_ABORT(FALSE, st_szDBG);
}
/*
const char *szExpectedExtension = ".bmp";
if (stricmp(szBitmapName+strlen(szBitmapName)-strlen(szExpectedExtension), szExpectedExtension) != 0)
{
sprintf(st_szDBG, "Node %s uses %s, which is not a %s file", (char*)strNodeName, szBitmapName, szExpectedExtension);
ASSERT_AND_ABORT(FALSE, st_szDBG);
}
*/
// Determine owning bones for the vertices.
int iNodeV0, iNodeV1, iNodeV2;
if (m_mcExport)
{
// The Physique add-in allows vertices to be assigned to bones arbitrarily
iNodeV0 = InodeOfPhyVectex( iVertex0 );
iNodeV1 = InodeOfPhyVectex( iVertex1 );
iNodeV2 = InodeOfPhyVectex( iVertex2 );
}
else
{
// Simple 3dsMax model: the vertices are owned by the object, and hence the node
iNodeV0 = iNode;
iNodeV1 = iNode;
iNodeV2 = iNode;
}
// Rotate the face vertices out of object-space, and into world-space space
Point3 v0 = pt3Vertex0 * mat3ObjectTM;
Point3 v1 = pt3Vertex1 * mat3ObjectTM;
Point3 v2 = pt3Vertex2 * mat3ObjectTM;
Matrix3 mat3ObjectNTM = mat3ObjectTM;
mat3ObjectNTM.NoScale( );
ASSERT_AND_ABORT( Length( pt3Vertex0Normal ) <= 1.1, "bogus pre normal 0" );
pt3Vertex0Normal = VectorTransform(mat3ObjectNTM, pt3Vertex0Normal);
ASSERT_AND_ABORT( Length( pt3Vertex0Normal ) <= 1.1, "bogus post normal 0" );
ASSERT_AND_ABORT( Length( pt3Vertex1Normal ) <= 1.1, "bogus pre normal 1" );
pt3Vertex1Normal = VectorTransform(mat3ObjectNTM, pt3Vertex1Normal);
ASSERT_AND_ABORT( Length( pt3Vertex1Normal ) <= 1.1, "bogus post normal 1" );
ASSERT_AND_ABORT( Length( pt3Vertex2Normal ) <= 1.1, "bogus pre normal 2" );
pt3Vertex2Normal = VectorTransform(mat3ObjectNTM, pt3Vertex2Normal);
ASSERT_AND_ABORT( Length( pt3Vertex2Normal ) <= 1.1, "bogus post normal 2" );
// Finally dump the bitmap name and 3 lines of face info
fprintf(m_pfile, "%s\n", szBitmapName);
fprintf(m_pfile, "%3d %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f\n",
iNodeV0, v0.x, v0.y, v0.z,
pt3Vertex0Normal.x, pt3Vertex0Normal.y, pt3Vertex0Normal.z,
UVvertex0.x, UVvertex0.y);
fprintf(m_pfile, "%3d %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f\n",
iNodeV1, v1.x, v1.y, v1.z,
pt3Vertex1Normal.x, pt3Vertex1Normal.y, pt3Vertex1Normal.z,
UVvertex1.x, UVvertex1.y);
fprintf(m_pfile, "%3d %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f %8.4f\n",
iNodeV2, v2.x, v2.y, v2.z,
pt3Vertex2Normal.x, pt3Vertex2Normal.y, pt3Vertex2Normal.z,
UVvertex2.x, UVvertex2.y);
}
cleanup( );
return TREE_CONTINUE;
}
// Here we process mesh geometry for given node.
// Vertices for the geometry from the all meshes of the scene are allocated in
// one big vertex pool. One vertex can occur several times in this pool, because
// we add 3 new vertices for every face.
// After all meshes in the scene are processed, this pool is collapsed to remove
// duplicate vertices.
void RBExport::ProcessMesh( INode* node )
{
if (!node->Renderable() || node->IsNodeHidden())
{
return;
}
ObjectState os = node->EvalWorldState( m_CurTime );
Object* pObject = os.obj;
if (!pObject)
{
Warn( "Could not evaluate object state in node <%s>. Mesh was skipped.", node->GetName() );
return;
}
Matrix3 nodeTM = node->GetNodeTM( m_CurTime );
Matrix3 nodeTMAfterWSM = node->GetObjTMAfterWSM( m_CurTime );
Matrix3 mOffs = nodeTMAfterWSM*Inverse( nodeTM );
// triangulate
TriObject* pTriObj = 0;
if (pObject->CanConvertToType( Class_ID( TRIOBJ_CLASS_ID, 0 ) ))
{
pTriObj = (TriObject*)pObject->ConvertToType( m_CurTime, Class_ID( TRIOBJ_CLASS_ID, 0 ) );
}
bool bReleaseTriObj = (pTriObj != pObject);
if (!pTriObj)
{
Warn( "Could not triangulate mesh in node <%s>. Node was skipped", node->GetName() );
return;
}
if (!MeshModStackIsValid( node ))
{
Warn( "Modifier stack for node %s should be collapsed or contain only Skin modifier.",
node->GetName() );
}
// ensure, that vertex winding direction in polygon is CCW
Matrix3 objTM = node->GetObjTMAfterWSM( m_CurTime );
bool bNegScale = (DotProd( CrossProd( objTM.GetRow(0), objTM.GetRow(1) ), objTM.GetRow(2) ) >= 0.0);
int vx[3];
if (bNegScale)
{
vx[0] = 0;
vx[1] = 1;
vx[2] = 2;
}
else
{
vx[0] = 2;
vx[1] = 1;
vx[2] = 0;
}
Mesh& mesh = pTriObj->GetMesh();
bool bHasTexCoord = (mesh.numTVerts != 0);
bool bHasVertexColor = (mesh.numCVerts != 0) && m_pConfig->m_bExportVertexColors;
bool bHasNormal = m_pConfig->m_bExportNormals;
bool bHasSkin = ProcessSkin( node );
// some cosmetics
BOOL res = mesh.RemoveDegenerateFaces();
if (res)
{
Spam( "Degenerate faces were fixed." );
}
res = mesh.RemoveIllegalFaces();
if (res)
{
Spam( "Degenerate indices were fixed." );
}
ExpNode* pExpNode = GetExportedNode( node );
if (!pExpNode)
{
return;
}
int numPri = mesh.getNumFaces();
int numVert = mesh.numVerts;
// initialize helper array for building vertices' 0-circles
VertexPtrArray vertexEntry;
vertexEntry.resize( numVert );
memset( &vertexEntry[0], 0, sizeof( ExpVertex* )*numVert );
Spam( "Original mesh has %d vertices and %d faces.", numVert, numPri );
bool bHasVoidFaces = false;
// loop on mesh faces
for (int i = 0; i < numPri; i++)
{
Face& face = mesh.faces[i];
// calculate face normal
const Point3& v0 = mesh.verts[face.v[vx[0]]];
const Point3& v1 = mesh.verts[face.v[vx[1]]];
const Point3& v2 = mesh.verts[face.v[vx[2]]];
Point3 normal = -Normalize( (v1 - v0)^(v2 - v1) );
normal = mOffs.VectorTransform( normal );
normal = c_FlipTM.VectorTransform( normal );
// loop on face vertices
ExpVertex* pFaceVertex[3];
for (int j = 0; j < 3; j++)
{
ExpVertex v;
v.mtlID = pExpNode->GetMaterialIdx( face.getMatID() );
v.nodeID = pExpNode->m_Index;
if (v.mtlID < 0)
{
bHasVoidFaces = true;
}
// extract vertex position and apply world-space modifier to it
int vIdx = face.v[vx[j]];
Point3 pt = mesh.verts[vIdx];
pt = mOffs.PointTransform( pt );
pt = c_FlipTM.PointTransform( pt );
v.index = vIdx;
v.pos = Vec3( pt.x, pt.y, pt.z );
//v.pos *= m_WorldScale;
// extract skinning info
if (bHasSkin)
{
GetSkinInfo( v );
}
// assign normal
if (bHasNormal)
{
v.normal = Vec3( normal.x, normal.y, normal.z );
v.smGroup = face.smGroup;
}
// extract vertex colors
if (bHasVertexColor)
{
const VertColor& vcol = mesh.vertCol[mesh.vcFace[i].t[vx[j]]];
v.color = ColorToDWORD( Color( vcol.x, vcol.y, vcol.z ) );
}
// extract texture coordinates
if (bHasTexCoord)
{
const Point3& texCoord = mesh.tVerts[mesh.tvFace[i].t[vx[j]]];
v.uv.x = texCoord.x;
v.uv.y = 1.0f - texCoord.y;
// second texture coordinate channel
if (mesh.getNumMaps() > 1 && mesh.mapSupport( 2 ))
{
UVVert* pUVVert = mesh.mapVerts( 2 );
TVFace* pTVFace = mesh.mapFaces( 2 );
if (pUVVert && pTVFace)
{
const Point3& tc2 = pUVVert[pTVFace[i].t[vx[j]]];
v.uv2.x = tc2.x;
v.uv2.y = 1.0f - tc2.y;
}
}
}
// allocate new vertex
pFaceVertex[j] = AddVertex( v );
// we want vertices in the 0-ring neighborhood to be linked into closed linked list
if (vertexEntry[vIdx] == NULL)
{
vertexEntry[vIdx] = pFaceVertex[j];
pFaceVertex[j]->pNext = pFaceVertex[j];
}
else
{
vertexEntry[vIdx]->AddToZeroRing( pFaceVertex[j] );
}
}
AddPolygon( pFaceVertex[0], pFaceVertex[1], pFaceVertex[2] );
if (IsCanceled())
{
return;
}
}
// correct normals at vertices corresponding to smoothing groups
SmoothNormals( vertexEntry );
// put vertices into set (this removes duplicate vertices)
for (int i = 0; i < numVert; i++)
{
ExpVertex::ZeroRingIterator it( vertexEntry[i] );
while (it)
{
VertexSet::iterator sIt = m_VertexSet.find( it );
if (sIt == m_VertexSet.end())
{
m_VertexSet.insert( it );
}
else
{
it->pBase = (*sIt);
}
++it;
}
}
if (bReleaseTriObj)
{
delete pTriObj;
}
if (bHasVoidFaces)
{
Warn( "Mesh %s has faces with no material assigned.", node->GetName() );
}
} // RBExport::ProcessMesh
ColMesh* RBExport::GetColMesh( INode* node )
{
ObjectState os = node->EvalWorldState( m_CurTime );
Object* pObject = os.obj;
if (!pObject)
{
Warn( "Could not evaluate object state. Collision mesh %s was skipped.", node->GetName() );
return NULL;
}
Matrix3 nodeTM = node->GetNodeTM( m_CurTime );
Matrix3 nodeTMAfterWSM = node->GetObjTMAfterWSM( m_CurTime );
Matrix3 mOffs = nodeTMAfterWSM*Inverse( nodeTM );
// triangulate
TriObject* pTriObj = NULL;
if (pObject->CanConvertToType( Class_ID( TRIOBJ_CLASS_ID, 0 ) ))
{
pTriObj = (TriObject*)pObject->ConvertToType( m_CurTime, Class_ID( TRIOBJ_CLASS_ID, 0 ) );
}
bool bReleaseTriObj = (pTriObj != pObject);
if (!pTriObj)
{
Warn( "Could not triangulate mesh in node. Collision mesh %s was skipped.", node->GetName() );
return NULL;
}
// ensure, that vertex winding direction in polygon is CCW
Matrix3 objTM = node->GetObjTMAfterWSM( m_CurTime );
bool bNegScale = (DotProd( CrossProd( objTM.GetRow(0), objTM.GetRow(1) ), objTM.GetRow(2) ) >= 0.0);
int vx[3];
vx[0] = bNegScale ? 2 : 0;
vx[1] = bNegScale ? 1 : 1;
vx[2] = bNegScale ? 0 : 2;
Mesh& mesh = pTriObj->GetMesh();
// some cosmetics
mesh.RemoveDegenerateFaces();
mesh.RemoveIllegalFaces();
// create collision mesh
ColMesh* pMesh = new ColMesh();
int numPri = mesh.getNumFaces();
int numVert = mesh.numVerts;
// copy vertices
for (int i = 0; i < numVert; i++)
{
Point3 pt = mesh.verts[i];
pt = mOffs.PointTransform( pt );
pt = c_FlipTM.PointTransform( pt );
pMesh->AddVertex( Vec3( pt.x, pt.y, pt.z ) );
}
// loop on mesh faces
for (int i = 0; i < numPri; i++)
{
Face& face = mesh.faces[i];
pMesh->AddPoly( face.v[vx[0]], face.v[vx[1]], face.v[vx[2]] );
}
Msg( LogType_Stats, "Physics collision trimesh has %d vertices and %d faces.", numVert, numPri );
return pMesh;
} // RBExport::GetColMesh
/*
====================
GatherSkin
====================
*/
void G3DSExport::GatherSkin(INode* i_node)
{
SKIN skin;
// get the name of the node
skin.name = i_node->GetName();
// get the skin interface
Modifier *modifier = GetModifier(i_node,SKIN_CLASSID);
ISkin* i_skin = (ISkin*)modifier->GetInterface(I_SKIN);
MAX_CHECK(i_skin);
// convert to the triangle type
Mesh* i_mesh = NULL;
Object* obj = i_node->EvalWorldState(mTime).obj;
if(obj && ( obj->SuperClassID() == GEOMOBJECT_CLASS_ID ))
{
if(obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
{
TriObject *tri_obj = (TriObject*)obj->ConvertToType(mTime, Class_ID(TRIOBJ_CLASS_ID, 0)); MAX_CHECK(tri_obj);
i_mesh = &tri_obj->mesh;
}
}
MAX_CHECK(i_mesh&&i_mesh->getNumFaces()&&i_mesh->getNumVerts());
// get the material
skin.texture = "textures/default.tga";
Mtl* mtl = i_node->GetMtl();
if(mtl && (mtl->ClassID()==Class_ID(DMTL_CLASS_ID, 0)) && ((StdMat*)mtl)->MapEnabled(ID_DI))
{
Texmap *texmap = mtl->GetSubTexmap(ID_DI);
if(texmap && texmap->ClassID() == Class_ID(BMTEX_CLASS_ID, 0x00))
{
skin.texture = UnifySlashes(((BitmapTex *)texmap)->GetMapName());
if( !strstr( skin.texture.c_str(), mPath.c_str() ) )
{
G3DAssert("The material(%s) is error : the texture path(%s) is illegal!",mtl->GetName(), skin.texture.c_str());
}
else
{
skin.texture = strstr(skin.texture.c_str(),mPath.c_str()) + strlen(mPath.c_str());
}
}
}
// if it has uvs
int map_count = i_mesh->getNumMaps();
bool has_uvs = i_mesh->getNumTVerts() && i_mesh->tvFace;
if(!(has_uvs&&map_count)) { G3DAssert("The skin(%s) has not the uv coordinates.",skin.name.c_str()); return; }
// get the transform
Matrix3 mesh_matrix = i_node->GetObjectTM(mTime);
Matrix3 node_matrix = i_node->GetNodeTM(mTime);
Matrix3 transform = mesh_matrix * Inverse(node_matrix);
// get the points
skin.points.assign(i_mesh->verts, i_mesh->verts+i_mesh->getNumVerts());
// get the triangles
for(int i = 0; i < i_mesh->getNumFaces(); i++)
{
Face& face = i_mesh->faces[i];
TRIANGLE tri;
tri.smoothing = face.smGroup;
for(int j = 0; j < 3; j++)
{
VPTNIS v;
v.pos = transform * i_mesh->verts[face.v[j]];
// get the uv
UVVert * map_verts = i_mesh->mapVerts(1);
TVFace * map_faces = i_mesh->mapFaces(1);
v.uv = reinterpret_cast<Point2&>(map_verts[map_faces[i].t[j]]);
v.uv.y = 1 - v.uv.y;
// initialize the normal
v.normal = Point3::Origin;
// get the vertex index
v.index = face.v[j];
// get the smoothing group
v.smoothing = face.smGroup;
// set the index for the triangle
tri.index0[j] = v.index;
// reassemble the vertex list
tri.index1[j] = AddVertex(skin, v);
}
// add the triangle to the table
skin.triangles.push_back(tri);
}
// build the index map
for( int i = 0; i < skin.vertexes.size(); i++ )
{
skin.vertex_index_map[skin.vertexes[i].index].push_back(i);
}
// get the skin context data
ISkinContextData* i_skin_context_data = i_skin->GetContextInterface(i_node);
if(i_skin_context_data == NULL) { G3DAssert("The skin(%s) has not the weight.",skin.name.c_str()); return; }
// gets the initial matrix of the skinned object
Matrix3 initial_object_transform;
i_skin->GetSkinInitTM(i_node, initial_object_transform, true);
// process the points
int num_points = i_skin_context_data->GetNumPoints();
for(int i = 0; i < num_points; i++)
{
MAX_CHECK(i < skin.points.size());
VPIW viw;
// get the initial point
viw.pos = initial_object_transform * skin.points[i];
// process the weights
std::multimap< float, int > weights;
// get the number of bones that control this vertex
int num_bones = i_skin_context_data->GetNumAssignedBones(i);
if(num_bones>0)
{
for (int j = 0; j < num_bones; j++)
{
Matrix3 transform;
// get the assigned bone of the point
INode* i_bone_node = i_skin->GetBone(i_skin_context_data->GetAssignedBone(i, j));
MAX_CHECK(i_bone_node != NULL);
// get the weight of the bone
float weight = i_skin_context_data->GetBoneWeight(i, j);
// add the weight to the table
weights.insert(std::make_pair(weight, AddBone(skin,i_bone_node)));
}
}
else
{
// add the weight to the table
weights.insert(std::make_pair(1.f, AddBone(skin,i_node)));
}
// recalculate the weights
float weight0 = 0.f, weight1 = 0.f, weight2 = 0.f;
int index0 = 0, index1 = 0, index2 = 0;
std::multimap< float, int >::iterator it = weights.end();
it--;
weight0 = it->first;
index0 = it->second;
if(it != weights.begin())
{
it--;
weight1 = it->first;
index1 = it->second;
if(it != weights.begin())
{
it--;
weight2 = it->first;
index2 = it->second;
}
}
float sum_weights = weight0 + weight1 + weight2;
// store the skin weights
viw.weight[0] = weight0/sum_weights;
viw.index[0] = index0;
viw.weight[1] = weight1/sum_weights;
viw.index[1] = index1;
viw.weight[2] = weight2/sum_weights;
viw.index[2] = index2;
skin.weights.push_back(viw);
}
// get the initial transforms
skin.transforms.resize(skin.bones.size());
for(int i = 0; i < skin.bones.size(); i++)
{
INode* node = skin.bones[i];
Matrix3 mat;
if (SKIN_INVALID_NODE_PTR == i_skin->GetBoneInitTM( node, mat ))
{
if (SKIN_INVALID_NODE_PTR == i_skin->GetSkinInitTM( node, mat ))
{
mat.IdentityMatrix();
}
}
skin.transforms[i] = Inverse(mat);
}
// there is a 75 bone limit for each skinned object.
if(skin.bones.size()>75)
{
G3DAssert("There are more %d bones in the skin(%s).",skin.bones.size(), i_node->GetName());
return;
}
// reset the skin vertex position
for(int i = 0; i < skin.vertexes.size(); i++)
{
VPTNIS& v0 = skin.vertexes[i];
VPIW& v1 = skin.weights[v0.index];
v0.pos = v1.pos;
}
// build the normal space
BuildNormal(skin);
// calculate the bounding box
skin.box.Init();
for(int i = 0; i < skin.vertexes.size(); i++)
{
Point3 pt = node_matrix * skin.vertexes[i].pos;
skin.box += pt;
}
// add the skin to the table
mSkins.push_back(skin);
}
/*
====================
GatherMesh
====================
*/
void G3DMExport::GatherMesh(INode* i_node)
{
// convert to the triangle type
Mesh* i_mesh = NULL;
Object* obj = i_node->EvalWorldState(mTime).obj;
if(obj && ( obj->SuperClassID() == GEOMOBJECT_CLASS_ID ))
{
if(obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
{
TriObject *tri_obj = (TriObject*)obj->ConvertToType(mTime, Class_ID(TRIOBJ_CLASS_ID, 0)); MAX_CHECK(tri_obj);
i_mesh = &tri_obj->mesh;
}
}
if(i_mesh==NULL||i_mesh->getNumFaces()==0||i_mesh->getNumVerts()==0) return;
MESH mesh;
// get the mesh name
mesh.name = i_node->GetName();
// get the material
mesh.texture = "textures/default.tga";
Mtl* mtl = i_node->GetMtl();
if(mtl && (mtl->ClassID()==Class_ID(DMTL_CLASS_ID, 0)) && ((StdMat*)mtl)->MapEnabled(ID_DI))
{
Texmap *texmap = mtl->GetSubTexmap(ID_DI);
if(texmap && texmap->ClassID() == Class_ID(BMTEX_CLASS_ID, 0x00))
{
mesh.texture = UnifySlashes(((BitmapTex *)texmap)->GetMapName());
if( !strstr( mesh.texture.c_str(), mPath.c_str() ) )
{
G3DAssert("The material(%s) is error : the texture path(%s) is illegal!",mtl->GetName(), mesh.texture.c_str());
return;
}
else
{
mesh.texture = strstr(mesh.texture.c_str(),mPath.c_str()) + strlen(mPath.c_str());
}
}
}
// if it has uvs
int map_count = i_mesh->getNumMaps();
bool has_uvs = i_mesh->getNumTVerts() && i_mesh->tvFace;
if(!(has_uvs&&map_count)) return;
// get the transform
Matrix3 transform = i_node->GetObjectTM(mTime);
// get the points
mesh.points.assign(i_mesh->verts, i_mesh->verts+i_mesh->getNumVerts());
// get the triangles
for(int i = 0; i < i_mesh->getNumFaces(); i++)
{
Face& face = i_mesh->faces[i];
TRIANGLE tri;
tri.smoothing = face.smGroup;
for(int j = 0; j < 3; j++)
{
VTNIS v;
v.pos = transform * i_mesh->verts[face.v[j]];
// get the uv
UVVert * map_verts = i_mesh->mapVerts(1);
TVFace * map_faces = i_mesh->mapFaces(1);
v.uv = reinterpret_cast<Point2&>(map_verts[map_faces[i].t[j]]);
v.uv.y = 1 - v.uv.y;
// initialize the normal
v.normal = Point3::Origin;
// get the vertex index
v.index = face.v[j];
// get the smoothing group
v.smoothing = face.smGroup;
// set the index for the triangle
tri.index0[j] = v.index;
// reassemble the vertex list
tri.index1[j] = AddVertex(mesh, v);
}
// add the triangle to the table
mesh.triangles.push_back(tri);
}
// build the index map
for( int i = 0; i < mesh.vertexes.size(); i++ )
{
mesh.vertex_index_map[mesh.vertexes[i].index].push_back(i);
}
// build the normal space
BuildNormal(mesh);
// calculate the bounding box
mesh.box.Init();
for(int i = 0; i < mesh.vertexes.size(); i++)
{
mesh.box += mesh.vertexes[i].pos;
}
// add the mesh to the table
mMeshes.push_back(mesh);
}
bool CExportNel::mirrorPhysiqueSelection(INode &node, TimeValue tvTime, const std::vector<uint> &vertIn,
float threshold)
{
bool ok;
uint i;
// no vertices selected?
if(vertIn.empty())
return true;
// **** Get all the skeleton node
std::vector<INode*> skeletonNodes;
INode *skelRoot= getSkeletonRootBone(node);
if(!skelRoot)
return false;
getObjectNodes(skeletonNodes, tvTime, skelRoot);
// **** Build the Vector (world) part
std::vector<CTempSkinVertex> tempVertex;
uint vertCount;
// Get a pointer on the object's node.
ObjectState os = node.EvalWorldState(tvTime);
Object *obj = os.obj;
// Check if there is an object
ok= false;
if (obj)
{
// Object can be converted in triObject ?
if (obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0)))
{
// Get a triobject from the node
TriObject *tri = (TriObject*)obj->ConvertToType(tvTime, Class_ID(TRIOBJ_CLASS_ID, 0));
if (tri)
{
// Note that the TriObject should only be deleted
// if the pointer to it is not equal to the object
// pointer that called ConvertToType()
bool deleteIt=false;
if (obj != tri)
deleteIt = true;
// Get the node matrix. TODO: Matrix headhache?
/*Matrix3 nodeMatrixMax;
CMatrix nodeMatrix;
getLocalMatrix (nodeMatrixMax, node, tvTime);
convertMatrix (nodeMatrix, nodeMatrixMax);*/
// retrive Position geometry
vertCount= tri->NumPoints();
tempVertex.resize(vertCount);
for(uint i=0;i<vertCount;i++)
{
Point3 v= tri->GetPoint(i);
tempVertex[i].Pos.set(v.x, v.y, v.z);
}
// Delete the triObject if we should...
if (deleteIt)
tri->MaybeAutoDelete();
tri = NULL;
// ok!
ok= true;
}
}
}
if(!ok)
return false;
// no vertices? abort
if(vertCount==0)
return true;
// **** Mark all Input vertices
for(i=0;i<vertIn.size();i++)
{
nlassert(vertIn[i]<vertCount);
tempVertex[vertIn[i]].Input= true;
}
// **** Build the output vertices
std::vector<uint> vertOut;
vertOut.reserve(tempVertex.size());
// Build the in bbox
CAABBox bbox;
bbox.setCenter(tempVertex[vertIn[0]].Pos);
for(i=0;i<vertIn.size();i++)
{
bbox.extend(tempVertex[vertIn[i]].Pos);
}
bbox.setHalfSize(bbox.getHalfSize()+CVector(threshold, threshold, threshold));
// mirror in X
CVector vMin= bbox.getMin();
CVector vMax= bbox.getMax();
vMin.x= -vMin.x;
vMax.x= -vMax.x;
std::swap(vMin.x, vMax.x);
bbox.setMinMax(vMin, vMax);
// get all out vertices in the mirrored bbox.
for(i=0;i<tempVertex.size();i++)
{
if(bbox.include(tempVertex[i].Pos))
{
vertOut.push_back(i);
}
}
// **** Build the skin information
// Get the skin modifier
Modifier* skin=getModifier (&node, PHYSIQUE_CLASS_ID);
// Found it ?
ok= false;
if (skin)
{
// Get a com_skin2 interface
IPhysiqueExport *physiqueInterface=(IPhysiqueExport *)skin->GetInterface (I_PHYINTERFACE);
// Found com_skin2 ?
if (physiqueInterface)
{
// Get local data
IPhyContextExport *localData= physiqueInterface->GetContextInterface(&node);
// Found ?
if (localData)
{
// Use rigid export
localData->ConvertToRigid (TRUE);
// Allow blending
localData->AllowBlending (TRUE);
// Skinned
ok=true;
// TODO?
nlassert(tempVertex.size()<=(uint)localData->GetNumberVertices());
// For each vertex
for (uint vert=0; vert<vertCount; vert++)
{
// Get a vertex interface
IPhyVertexExport *vertexInterface= localData->GetVertexInterface (vert);
// Check if it is a rigid vertex or a blended vertex
IPhyRigidVertex *rigidInterface=NULL;
IPhyBlendedRigidVertex *blendedInterface=NULL;
int type=vertexInterface->GetVertexType ();
if (type==RIGID_TYPE)
{
// this is a rigid vertex
rigidInterface=(IPhyRigidVertex*)vertexInterface;
}
else
{
// It must be a blendable vertex
nlassert (type==RIGID_BLENDED_TYPE);
blendedInterface=(IPhyBlendedRigidVertex*)vertexInterface;
}
// Get bones count for this vertex
uint boneCount;
if (blendedInterface)
{
// If blenvertex, only one bone
boneCount=blendedInterface->GetNumberNodes();
}
else
{
// If rigid vertex, only one bone
boneCount=1;
}
if(boneCount>TEMP_MAX_WEIGHT)
boneCount= TEMP_MAX_WEIGHT;
// NB: if input 0, won't be mirrored
tempVertex[vert].NumWeight= boneCount;
for(uint bone=0;bone<boneCount;bone++)
{
if (blendedInterface)
{
tempVertex[vert].Bone[bone]= blendedInterface->GetNode(bone);
nlassert(tempVertex[vert].Bone[bone]);
tempVertex[vert].Weight[bone]= blendedInterface->GetWeight(bone);
}
else
{
tempVertex[vert].Bone[bone]= rigidInterface->GetNode();
tempVertex[vert].Weight[bone]= 1;
}
}
// Release vertex interfaces
localData->ReleaseVertexInterface (vertexInterface);
}
}
// release context interface
physiqueInterface->ReleaseContextInterface(localData);
}
// Release the interface
skin->ReleaseInterface (I_PHYINTERFACE, physiqueInterface);
}
if(!ok)
return false;
// **** Real Algo stuff:
// For all vertices wanted to be mirrored
std::vector<CSortVertex> sortVert;
sortVert.reserve(tempVertex.size());
for(i=0;i<vertIn.size();i++)
{
CTempSkinVertex &svIn= tempVertex[vertIn[i]];
// if it still has no bones set, skip
if(svIn.NumWeight==0)
continue;
// mirror vert to test
CVector vertTest= svIn.Pos;
vertTest.x*= -1;
// get the best vertex
sortVert.clear();
// Search for all output vertices if ones match
for(uint j=0;j<vertOut.size();j++)
{
uint dstIdx= vertOut[j];
nlassert(dstIdx<tempVertex.size());
CTempSkinVertex &skinv= tempVertex[dstIdx];
// take only if not an input, and if not already mirrored
if(!skinv.Input && !skinv.Mirrored)
{
CSortVertex sortv;
sortv.Index= dstIdx;
sortv.SqrDist= (skinv.Pos - vertTest).sqrnorm();
// Finally, take it only if sufficiently near
if(sortv.SqrDist <= threshold*threshold)
sortVert.push_back(sortv);
}
}
// if some found.
if(!sortVert.empty())
{
// sort array.
std::sort(sortVert.begin(), sortVert.end());
// take the first, mirror setup
uint dstIdx= sortVert[0].Index;
tempVertex[dstIdx].NumWeight= svIn.NumWeight;
for(uint k=0;k<svIn.NumWeight;k++)
{
tempVertex[dstIdx].Weight[k]= svIn.Weight[k];
tempVertex[dstIdx].Bone[k]= getMirrorBone( skeletonNodes, svIn.Bone[k] );
}
// mark as mirrored!
tempVertex[dstIdx].Mirrored= true;
}
}
// **** Write the result to the skin.
ok= false;
if (skin)
{
// Get a com_skin2 interface
IPhysiqueImport *physiqueInterface=(IPhysiqueImport *)skin->GetInterface (I_PHYIMPORT);
// Found com_skin2 ?
if (physiqueInterface)
{
// Get local data
IPhyContextImport *localData= physiqueInterface->GetContextInterface(&node);
// TODO?
nlassert(tempVertex.size()<=(uint)localData->GetNumberVertices());
// Found ?
if (localData)
{
// Skinned
ok=true;
for(uint i=0;i<tempVertex.size();i++)
{
CTempSkinVertex &sv= tempVertex[i];
// if its a mirrored output vertex
if(sv.Mirrored)
{
IPhyBlendedRigidVertexImport *blendedInterface= NULL;
blendedInterface= (IPhyBlendedRigidVertexImport*)localData->SetVertexInterface(i, RIGID_BLENDED_TYPE);
if(blendedInterface)
{
// set the vertex data
for(uint bone=0;bone<sv.NumWeight;bone++)
{
blendedInterface->SetWeightedNode(sv.Bone[bone], sv.Weight[bone], bone==0);
}
// UI bonus: lock it
blendedInterface->LockVertex(TRUE);
// release
localData->ReleaseVertexInterface(blendedInterface);
}
}
}
}
// release
physiqueInterface->ReleaseContextInterface(localData);
}
// release
skin->ReleaseInterface(I_PHYIMPORT, physiqueInterface);
}
return ok;
}
