/*
Use the shape of node to create Bullet shape for the actor. ActorNode is the main Max node.
*/
btCollisionShape* MxActor::createShape(NxActorDesc& actorDesc, ccMaxNode* node, ccMaxNode* actorNode)
{
actorDesc.localPose.IdentityMatrix();
btCollisionShape* shape = NULL;
const TimeValue t = ccMaxWorld::MaxTime();
Matrix3 nodePose = node->PhysicsNodePoseTM;
// MaxMsgBox(NULL, _T("createShape"), _T("Error"), MB_OK);
int geomType = MxUserPropUtils::GetUserPropInt(m_node, "GeometryType",1);
NxShapeType type = node->ShapeType;
//first apply manual overrides
switch (geomType)
{
case 2:
{
type = NX_SHAPE_SPHERE;
break;
}
case 3:
{
type = NX_SHAPE_BOX;
break;
}
case 4:
{
type = NX_SHAPE_CAPSULE;
break;
}
case 5:
{
type = NX_SHAPE_CONVEX;
break;
}
case 6:
{
type = NX_SHAPE_MESH;
break;
}
default:
{
}
};
actorDesc.localPose = node->PhysicsNodePoseTM * actorNode->PhysicsNodePoseTMInv;
switch (type)
{
case NX_SHAPE_SPHERE:
{
btScalar radius = node->PrimaryShapePara.Radius;
shape = new btSphereShape(radius);
break;
};
case NX_SHAPE_BOX:
{
//adjust for difference in pivot points between 3ds max and Bullet (Bullet uses the box center)
Matrix3 offset;
offset.IdentityMatrix();
offset.SetTrans(2,node->PrimaryShapePara.BoxDimension.z());
actorDesc.localPose = actorDesc.localPose * offset;
shape = new btBoxShape(node->PrimaryShapePara.BoxDimension.absolute());
break;
}
case NX_SHAPE_CAPSULE:
{
char bla[1024];
sprintf(bla,"capsule not properly supported yet, radius=%f,height=%f",node->PrimaryShapePara.Radius,node->PrimaryShapePara.Height);
MaxMsgBox(NULL, _T(bla), _T("Error"), MB_OK);
shape = new btCapsuleShape(node->PrimaryShapePara.Radius,node->PrimaryShapePara.Height);
break;
}
case NX_SHAPE_CONVEX:
{
if(m_proxyNode)
{
MaxMsgBox(NULL, _T("Error: convex shape proxy not supported (yet)"), _T("Error"), MB_OK);
//d->meshData = MxUtils::nodeToNxConvexMesh(proxyMesh);
//Matrix3 pose = nodePose * actorNode->PhysicsNodePoseTMInv;
//d->localPose = MxMathUtils::MaxMatrixToNx(pose);
}
else
{
if(node->SimpleMesh.numFaces > 255)
{
MaxMsgBox(NULL, _T("Error: number of vertices in a convex shape should be less than 256"), _T("Error"), MB_OK);
//warning/Error
} else
{
BOOL needDel = FALSE;
TriObject* tri = MxUtils::GetTriObjectFromNode(node->GetMaxNode(),0.f,needDel);
if (tri)
{
int numVerts = tri->NumPoints();
btConvexHullShape* convexHull = new btConvexHullShape();
//for center of mass computation, simplify and assume mass is at the vertices
btCompoundShape* compound = new btCompoundShape();
btSphereShape sphere(0.1);
btTransform tr;
tr.setIdentity();
btAlignedObjectArray<btScalar> masses;
btScalar childMass = actorDesc.mass/(btScalar)numVerts;
for (int i=0;i<numVerts;i++)
{
btVector3 pt(tri->GetPoint(i).x,tri->GetPoint(i).y,tri->GetPoint(i).z);
convexHull->addPoint(pt);
tr.setOrigin(pt);
compound->addChildShape(tr,&sphere);
masses.push_back(childMass);
}
btTransform principal;
btVector3 inertia;
compound->calculatePrincipalAxisTransform(&masses[0],principal,inertia);
delete compound;
btTransform principalInv = principal.inverse();
compound = new btCompoundShape();
compound->addChildShape(principalInv,convexHull);
shape = compound;
Matrix3 offset;
bullet2Max(principal,offset);
actorDesc.localPose = actorDesc.localPose * offset;
if (needDel)
delete tri;
}
}
//d->meshData = MxUtils::nodeToNxConvexMesh(node->SimpleMesh);
//Matrix3 pose = nodePose * actorNode->PhysicsNodePoseTMInv;
//d->localPose = MxMathUtils::MaxMatrixToNx(pose);
}
break;
}
case NX_SHAPE_MESH:
{
BOOL needDel = FALSE;
TriObject* tri = MxUtils::GetTriObjectFromNode(node->GetMaxNode(),0.f,needDel);
if (tri)
{
int numVerts = tri->NumPoints();
btTriangleMesh* meshInterface = new btTriangleMesh();
Mesh& mesh = tri->GetMesh();
if (mesh.getNumFaces()>0)
{
for (int i=0;i<mesh.getNumFaces();i++)
{
Point3 p0=tri->GetPoint(mesh.faces[i].v[0]);
Point3 p1=tri->GetPoint(mesh.faces[i].v[1]);
Point3 p2=tri->GetPoint(mesh.faces[i].v[2]);
meshInterface->addTriangle( btVector3(p0.x,p0.y,p0.z),btVector3(p1.x,p1.y,p1.z),btVector3(p2.x,p2.y,p2.z));
}
if (actorDesc.mass>0)
{
// MaxMsgBox(NULL, _T("btGImpactMeshShape"), _T("Error"), MB_OK);
btGImpactMeshShape* trimesh = new btGImpactMeshShape(meshInterface);
shape = trimesh;
} else
{
// MaxMsgBox(NULL, _T("btBvhTriangleMeshShape"), _T("Error"), MB_OK);
btBvhTriangleMeshShape* trimesh = new btBvhTriangleMeshShape(meshInterface,true);
shape = trimesh;
}
} else
{
MaxMsgBox(NULL, _T("Error: no faces"), _T("Error"), MB_OK);
}
if (needDel)
delete tri;
} else
{
MaxMsgBox(NULL, _T("Error: couldn't GetTriObjectFromNode"), _T("Error"), MB_OK);
}
break;
}
default:
{
MaxMsgBox(NULL, _T("unknown shape type"), _T("Error"), MB_OK);
}
};
#if 0
NxShapeDesc* pd = NULL;
NxShapeType type = node->ShapeType;
PxSimpleMesh proxyMesh;
Matrix3 nodePose = node->PhysicsNodePoseTM;
if(m_proxyNode)
{
// for proxy, using mesh
//type = NX_SHAPE_MESH;
proxyMesh.clone(node->SimpleMesh);
Point3 pos = nodePose.GetRow(3);
pos = pos + ProxyDistance;
nodePose.SetRow(3, pos);
}
if((type == NX_SHAPE_MESH) && (Interactivity != RB_STATIC))
{
type = NX_SHAPE_CONVEX;
}
//
/*
bool NeedCCDSkeleton = (Interactivity != RB_STATIC) && (MxUserPropUtils::GetUserPropBool(node->GetMaxNode(), "EnableCCD", false));
if(NeedCCDSkeleton)
{
NxPhysicsSDK* psdk = gPluginData->getPhysicsSDK();
psdk->setParameter(NX_CONTINUOUS_CD, 1);
psdk->setParameter(NX_CCD_EPSILON, 0.01f);
}
*/
// create CCD skeleton for the shape
//TODO("implement CCD skeleton creation");
PX_CCD_SKELETON ccdType = (PX_CCD_SKELETON) MxUserPropUtils::GetUserPropInt(node->GetMaxNode(), "px_shape_ccdtype", 1);
switch(type)
{
default:
if (gCurrentstream) gCurrentstream->printf("Unable to create a shape of node \"%s\", unknown shape type: %d.\n", node->GetMaxNode()->GetName(), type);
return false;
}
// load property settings and material things.
//LoadShapeProperties(*pd, node->GetMaxNode());
//CCD flag
pd->name = node->GetMaxNode()->GetName();
pd->userData = node;
//
bool isvalid = pd->isValid();
actorDesc.shapes.push_back(pd);
#endif
return shape;
}
void RelaxMod::ModifyObject(TimeValue t, ModContext &mc, ObjectState * os, INode *node) {
// Get our personal validity interval...
Interval valid = GetValidity(t);
// and intersect it with the channels we use as input (see ChannelsUsed)
valid &= os->obj->ChannelValidity (t, GEOM_CHAN_NUM);
valid &= os->obj->ChannelValidity (t, TOPO_CHAN_NUM);
valid &= os->obj->ChannelValidity (t, SUBSEL_TYPE_CHAN_NUM);
valid &= os->obj->ChannelValidity (t, SELECT_CHAN_NUM);
Matrix3 modmat,minv;
if (mc.localData == NULL) mc.localData = new RelaxModData;
RelaxModData *rd = (RelaxModData *) mc.localData;
TriObject *triObj = NULL;
PatchObject *patchObj = NULL;
PolyObject *polyObj = NULL;
BOOL converted = FALSE;
// For version 4 and later, we process patch or poly meshes as they are and pass them on.
// Earlier versions converted to TriMeshes (done below).
// For adding other new types of objects, add them here!
#ifndef NO_PATCHES
if(version >= RELAXMOD_VER4 && os->obj->IsSubClassOf(patchObjectClassID)) {
patchObj = (PatchObject *)os->obj;
}
else // If it's a TriObject, process it
#endif // NO_PATCHES
if(os->obj->IsSubClassOf(triObjectClassID)) {
triObj = (TriObject *)os->obj;
}
else if (os->obj->IsSubClassOf (polyObjectClassID)) {
polyObj = (PolyObject *) os->obj;
}
else // If it can convert to a TriObject, do it
if(os->obj->CanConvertToType(triObjectClassID)) {
triObj = (TriObject *)os->obj->ConvertToType(t, triObjectClassID);
converted = TRUE;
}
else
return; // We can't deal with it!
Mesh *mesh = triObj ? &(triObj->GetMesh()) : NULL;
#ifndef NO_PATCHES
PatchMesh &pmesh = patchObj ? patchObj->GetPatchMesh(t) : *((PatchMesh *)NULL);
#else
PatchMesh &pmesh = *((PatchMesh *)NULL);
#endif // NO_PATCHES
float relax, wtdRelax; // mjm - 4.8.99
int iter;
BOOL boundary, saddle;
pblock->GetValue (PB_RELAX, t, relax, FOREVER);
pblock->GetValue (PB_ITER, t, iter, FOREVER);
pblock->GetValue (PB_BOUNDARY, t, boundary, FOREVER);
pblock->GetValue (PB_SADDLE, t, saddle, FOREVER);
LimitValue (relax, MIN_RELAX, MAX_RELAX);
LimitValue (iter, MIN_ITER, MAX_ITER);
if(triObj) {
int i, j, max;
DWORD selLevel = mesh->selLevel;
// mjm - 4.8.99 - add support for soft selection
// sca - 4.29.99 - extended soft selection support to cover EDGE and FACE selection levels.
float *vsw = (selLevel!=MESH_OBJECT) ? mesh->getVSelectionWeights() : NULL;
if (rd->ivalid.InInterval(t) && (mesh->numVerts != rd->vnum)) {
// Shouldn't happen, but does with Loft bug and may with other bugs.
rd->ivalid.SetEmpty ();
}
if (!rd->ivalid.InInterval(t)) {
rd->SetVNum (mesh->numVerts);
for (i=0; i<rd->vnum; i++) {
rd->fnum[i]=0;
rd->nbor[i].ZeroCount();
}
rd->sel.ClearAll ();
DWORD *v;
int k1, k2, origmax;
for (i=0; i<mesh->numFaces; i++) {
v = mesh->faces[i].v;
for (j=0; j<3; j++) {
if ((selLevel==MESH_FACE) && mesh->faceSel[i]) rd->sel.Set(v[j]);
if ((selLevel==MESH_EDGE) && mesh->edgeSel[i*3+j]) rd->sel.Set(v[j]);
if ((selLevel==MESH_EDGE) && mesh->edgeSel[i*3+(j+2)%3]) rd->sel.Set(v[j]);
origmax = max = rd->nbor[v[j]].Count();
rd->fnum[v[j]]++;
for (k1=0; k1<max; k1++) if (rd->nbor[v[j]][k1] == v[(j+1)%3]) break;
if (k1==max) { rd->nbor[v[j]].Append (1, v+(j+1)%3, 1); max++; }
for (k2=0; k2<max; k2++) if (rd->nbor[v[j]][k2] == v[(j+2)%3]) break;
if (k2==max) { rd->nbor[v[j]].Append (1, v+(j+2)%3, 1); max++; }
if (max>origmax) rd->vis[v[j]].SetSize (max, TRUE);
if (mesh->faces[i].getEdgeVis (j)) rd->vis[v[j]].Set (k1);
else if (k1>=origmax) rd->vis[v[j]].Clear (k1);
if (mesh->faces[i].getEdgeVis ((j+2)%3)) rd->vis[v[j]].Set (k2);
else if (k2>= origmax) rd->vis[v[j]].Clear (k2);
}
}
// mjm - begin - 4.8.99
// if (selLevel==MESH_VERTEX) rd->sel = mesh->vertSel;
if (selLevel==MESH_VERTEX)
rd->sel = mesh->vertSel;
else if (selLevel==MESH_OBJECT)
rd->sel.SetAll ();
// mjm - end
rd->ivalid = os->obj->ChannelValidity (t, TOPO_CHAN_NUM);
rd->ivalid &= os->obj->ChannelValidity (t, SUBSEL_TYPE_CHAN_NUM);
rd->ivalid &= os->obj->ChannelValidity (t, SELECT_CHAN_NUM);
}
Tab<float> vangles;
if (saddle) vangles.SetCount (rd->vnum);
Point3 *hold = new Point3[rd->vnum];
int act;
for (int k=0; k<iter; k++) {
for (i=0; i<rd->vnum; i++) hold[i] = triObj->GetPoint(i);
if (saddle) mesh->FindVertexAngles (vangles.Addr(0));
for (i=0; i<rd->vnum; i++) {
// mjm - begin - 4.8.99
// if ((selLevel!=MESH_OBJECT) && (!rd->sel[i])) continue;
if ( (!rd->sel[i] ) && (!vsw || vsw[i] == 0) ) continue;
// mjm - end
if (saddle && (vangles[i] <= 2*PI*.99999f)) continue;
max = rd->nbor[i].Count();
if (boundary && (rd->fnum[i] < max)) continue;
if (max<1) continue;
Point3 avg(0.0f, 0.0f, 0.0f);
for (j=0,act=0; j<max; j++) {
if (!rd->vis[i][j]) continue;
act++;
avg += hold[rd->nbor[i][j]];
}
if (act<1) continue;
// mjm - begin - 4.8.99
wtdRelax = (!rd->sel[i]) ? relax * vsw[i] : relax;
triObj->SetPoint (i, hold[i]*(1-wtdRelax) + avg*wtdRelax/((float)act));
// triObj->SetPoint (i, hold[i]*(1-relax) + avg*relax/((float)act));
// mjm - end
}
}
delete [] hold;
}
if (polyObj) {
int i, j, max;
MNMesh & mm = polyObj->mm;
float *vsw = (mm.selLevel!=MNM_SL_OBJECT) ? mm.getVSelectionWeights() : NULL;
if (rd->ivalid.InInterval(t) && (mm.numv != rd->vnum)) {
// Shouldn't happen, but does with Loft bug and may with other bugs.
rd->ivalid.SetEmpty ();
}
if (!rd->ivalid.InInterval(t)) {
rd->SetVNum (mm.numv);
for (i=0; i<rd->vnum; i++) {
rd->fnum[i]=0;
rd->nbor[i].ZeroCount();
}
rd->sel = mm.VertexTempSel ();
int k1, k2, origmax;
for (i=0; i<mm.numf; i++) {
int deg = mm.f[i].deg;
int *vtx = mm.f[i].vtx;
for (j=0; j<deg; j++) {
Tab<DWORD> & nbor = rd->nbor[vtx[j]];
origmax = max = nbor.Count();
rd->fnum[vtx[j]]++;
DWORD va = vtx[(j+1)%deg];
DWORD vb = vtx[(j+deg-1)%deg];
for (k1=0; k1<max; k1++) if (nbor[k1] == va) break;
if (k1==max) { nbor.Append (1, &va, 1); max++; }
for (k2=0; k2<max; k2++) if (nbor[k2] == vb) break;
if (k2==max) { nbor.Append (1, &vb, 1); max++; }
}
}
rd->ivalid = os->obj->ChannelValidity (t, TOPO_CHAN_NUM);
rd->ivalid &= os->obj->ChannelValidity (t, SUBSEL_TYPE_CHAN_NUM);
rd->ivalid &= os->obj->ChannelValidity (t, SELECT_CHAN_NUM);
}
Tab<float> vangles;
if (saddle) vangles.SetCount (rd->vnum);
Tab<Point3> hold;
hold.SetCount (rd->vnum);
int act;
for (int k=0; k<iter; k++) {
for (i=0; i<rd->vnum; i++) hold[i] = mm.P(i);
if (saddle) FindVertexAngles (mm, vangles.Addr(0));
for (i=0; i<rd->vnum; i++) {
if ((!rd->sel[i]) && (!vsw || vsw[i] == 0) ) continue;
if (saddle && (vangles[i] <= 2*PI*.99999f)) continue;
max = rd->nbor[i].Count();
if (boundary && (rd->fnum[i] < max)) continue;
if (max<1) continue;
Point3 avg(0.0f, 0.0f, 0.0f);
for (j=0,act=0; j<max; j++) {
act++;
avg += hold[rd->nbor[i][j]];
}
if (act<1) continue;
wtdRelax = (!rd->sel[i]) ? relax * vsw[i] : relax;
polyObj->SetPoint (i, hold[i]*(1-wtdRelax) + avg*wtdRelax/((float)act));
}
}
}
#ifndef NO_PATCHES
else
if(patchObj) {
int i, j, max;
DWORD selLevel = pmesh.selLevel;
// mjm - 4.8.99 - add support for soft selection
// sca - 4.29.99 - extended soft selection support to cover EDGE and FACE selection levels.
float *vsw = (selLevel!=PATCH_OBJECT) ? pmesh.GetVSelectionWeights() : NULL;
if (rd->ivalid.InInterval(t) && (pmesh.numVerts != rd->vnum)) {
// Shouldn't happen, but does with Loft bug and may with other bugs.
rd->ivalid.SetEmpty ();
}
if (!rd->ivalid.InInterval(t)) {
int vecBase = pmesh.numVerts;
rd->SetVNum (pmesh.numVerts + pmesh.numVecs);
for (i=0; i<rd->vnum; i++) {
rd->fnum[i]=1; // For patches, this means it's not a boundary
rd->nbor[i].ZeroCount();
}
rd->sel.ClearAll ();
for (i=0; i<pmesh.numPatches; i++) {
Patch &p = pmesh.patches[i];
int vecLimit = p.type * 2;
for (j=0; j<p.type; j++) {
PatchEdge &e = pmesh.edges[p.edge[j]];
BOOL isBoundary = (e.patches.Count() < 2) ? TRUE : FALSE;
int theVert = p.v[j];
int nextVert = p.v[(j+1)%p.type];
int nextVec = p.vec[j*2] + vecBase;
int nextVec2 = p.vec[j*2+1] + vecBase;
int prevEdge = (j+p.type-1)%p.type;
int prevVec = p.vec[prevEdge*2+1] + vecBase;
int prevVec2 = p.vec[prevEdge*2] + vecBase;
int theInterior = p.interior[j] + vecBase;
// Establish selection bits
if ((selLevel==PATCH_PATCH) && pmesh.patchSel[i]) {
rd->sel.Set(theVert);
rd->sel.Set(nextVec);
rd->sel.Set(prevVec);
rd->sel.Set(theInterior);
}
else
if ((selLevel==PATCH_EDGE) && pmesh.edgeSel[p.edge[j]]) {
rd->sel.Set(e.v1);
rd->sel.Set(e.vec12 + vecBase);
rd->sel.Set(e.vec21 + vecBase);
rd->sel.Set(e.v2);
}
else
if ((selLevel==PATCH_VERTEX) && pmesh.vertSel[theVert]) {
rd->sel.Set(theVert);
rd->sel.Set(nextVec);
rd->sel.Set(prevVec);
rd->sel.Set(theInterior);
}
// Set boundary flags if necessary
if(isBoundary) {
rd->fnum[theVert] = 0;
rd->fnum[nextVec] = 0;
rd->fnum[nextVec2] = 0;
rd->fnum[nextVert] = 0;
}
// First process the verts
int work = theVert;
max = rd->nbor[work].Count();
// Append the neighboring vectors
rd->MaybeAppendNeighbor(work, nextVec, max);
rd->MaybeAppendNeighbor(work, prevVec, max);
rd->MaybeAppendNeighbor(work, theInterior, max);
// Now process the edge vectors
work = nextVec;
max = rd->nbor[work].Count();
// Append the neighboring points
rd->MaybeAppendNeighbor(work, theVert, max);
rd->MaybeAppendNeighbor(work, theInterior, max);
rd->MaybeAppendNeighbor(work, prevVec, max);
rd->MaybeAppendNeighbor(work, nextVec2, max);
rd->MaybeAppendNeighbor(work, p.interior[(j+1)%p.type] + vecBase, max);
work = prevVec;
max = rd->nbor[work].Count();
// Append the neighboring points
rd->MaybeAppendNeighbor(work, theVert, max);
rd->MaybeAppendNeighbor(work, theInterior, max);
rd->MaybeAppendNeighbor(work, nextVec, max);
rd->MaybeAppendNeighbor(work, prevVec2, max);
rd->MaybeAppendNeighbor(work, p.interior[(j+p.type-1)%p.type] + vecBase, max);
// Now append the interior, if not auto
if(!p.IsAuto()) {
work = theInterior;
max = rd->nbor[work].Count();
// Append the neighboring points
rd->MaybeAppendNeighbor(work, p.v[j], max);
rd->MaybeAppendNeighbor(work, nextVec, max);
rd->MaybeAppendNeighbor(work, nextVec2, max);
rd->MaybeAppendNeighbor(work, prevVec, max);
rd->MaybeAppendNeighbor(work, prevVec2, max);
for(int k = 1; k < p.type; ++k)
rd->MaybeAppendNeighbor(work, p.interior[(j+k)%p.type] + vecBase, max);
}
}
}
// mjm - begin - 4.8.99
if (selLevel==PATCH_VERTEX) {
for (int i=0; i<pmesh.numVerts; ++i) {
if (pmesh.vertSel[i]) rd->sel.Set(i);
}
}
else if (selLevel==PATCH_OBJECT) rd->sel.SetAll();
// mjm - end
rd->ivalid = os->obj->ChannelValidity (t, TOPO_CHAN_NUM);
rd->ivalid &= os->obj->ChannelValidity (t, SUBSEL_TYPE_CHAN_NUM);
rd->ivalid &= os->obj->ChannelValidity (t, SELECT_CHAN_NUM);
}
Tab<float> vangles;
if (saddle) vangles.SetCount (rd->vnum);
Point3 *hold = new Point3[rd->vnum];
int act;
for (int k=0; k<iter; k++) {
for (i=0; i<rd->vnum; i++) hold[i] = patchObj->GetPoint(i);
if (saddle)
FindVertexAngles(pmesh, vangles.Addr(0));
for (i=0; i<rd->vnum; i++) {
// mjm - begin - 4.8.99
// if ((selLevel!=MESH_OBJECT) && (!rd->sel[i])) continue;
if ( (!rd->sel[i] ) && (!vsw || vsw[i] == 0) ) continue;
// mjm - end
if (saddle && (i < pmesh.numVerts) && (vangles[i] <= 2*PI*.99999f)) continue;
max = rd->nbor[i].Count();
if (boundary && !rd->fnum[i]) continue;
if (max<1)
continue;
Point3 avg(0.0f, 0.0f, 0.0f);
for (j=0,act=0; j<max; j++) {
act++;
avg += hold[rd->nbor[i][j]];
}
if (act<1)
continue;
// mjm - begin - 4.8.99
wtdRelax = (!rd->sel[i]) ? relax * vsw[i] : relax;
patchObj->SetPoint (i, hold[i]*(1-wtdRelax) + avg*wtdRelax/((float)act));
// patchObj->SetPoint (i, hold[i]*(1-relax) + avg*relax/((float)act));
// mjm - end
}
}
delete [] hold;
patchObj->patch.computeInteriors();
patchObj->patch.ApplyConstraints();
}
#endif // NO_PATCHES
if(!converted) {
os->obj->SetChannelValidity(GEOM_CHAN_NUM, valid);
} else {
// Stuff converted object into the pipeline!
triObj->SetChannelValidity(TOPO_CHAN_NUM, valid);
triObj->SetChannelValidity(GEOM_CHAN_NUM, valid);
triObj->SetChannelValidity(TEXMAP_CHAN_NUM, valid);
triObj->SetChannelValidity(MTL_CHAN_NUM, valid);
triObj->SetChannelValidity(SELECT_CHAN_NUM, valid);
triObj->SetChannelValidity(SUBSEL_TYPE_CHAN_NUM, valid);
triObj->SetChannelValidity(DISP_ATTRIB_CHAN_NUM, valid);
os->obj = triObj;
}
}
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;
}
