/**
* This method will sample the node at each frame to get any possible change
* of position, rotation and scaling. The posible changes is inserted into an
* OSG AnimationPath and returned.
*/
osg::AnimationPath* OSGExp::sampleNode(INode* node){
// Create the animation path.
osg::AnimationPath* animationPath = new osg::AnimationPath();
animationPath->setLoopMode(osg::AnimationPath::LOOP);
TimeValue start = _ip->GetAnimRange().Start();
TimeValue end = _ip->GetAnimRange().End();
int val;
if (node->GetUserPropInt("startFrame",val))
start= val;
if (node->GetUserPropInt("endFrame",val))
end= val;
TimeValue t;
int delta = GetTicksPerFrame();
Matrix3 tm;
AffineParts ap;
for (t=start; t<=end; t+=delta) {
tm = node->GetNodeTM(t) * Inverse(node->GetParentTM(t));
decomp_affine(tm, &ap);
Point3 pos = ap.t;
Point3 sca = ap.k;
// Note: OSG wants absolute rotations
Quat rot = ap.q;
// Convert from Max's left-handed rotation to right-handed
float ang;
Point3 axis;
AngAxisFromQ(rot, &ang, axis);
ang = -ang;
rot = QFromAngAxis(ang, axis);
// Insert the sample point into animation path
addControlPoint(animationPath, (t/(float)TIME_TICKSPERSEC), pos, rot, sca);
}
return animationPath;
}
void BombMod::ModifyObject(
TimeValue t, ModContext &mc, ObjectState *os, INode *node)
{
BombObject *bobj = GetWSMObject(t);
if (bobj && nodeRef && (bobj->ClassID() == Class_ID(BOMB_OBJECT_CLASS_ID,0))) {
assert(os->obj->IsSubClassOf(triObjectClassID));
TriObject *triOb = (TriObject *)os->obj;
Interval valid = FOREVER;
if (os->GetTM()) {
Matrix3 tm = *(os->GetTM());
for (int i=0; i<triOb->GetMesh().getNumVerts(); i++) {
triOb->GetMesh().verts[i] = triOb->GetMesh().verts[i] * tm;
}
os->obj->UpdateValidity(GEOM_CHAN_NUM,os->tmValid());
os->SetTM(NULL,FOREVER);
}
if (waitPostLoad) {
valid.SetInstant(t);
triOb->UpdateValidity(GEOM_CHAN_NUM,valid);
triOb->UpdateValidity(TOPO_CHAN_NUM,valid);
return;
}
Matrix3 tm;
TimeValue det = bobj->GetDetonation(t,valid);
float strength = bobj->GetStrength(t,valid) * STRENGTH_CONSTANT;
float grav = bobj->GetGravity(t,valid);
float chaos = bobj->GetChaos(t,valid);
float chaosBase = (float(1)-chaos/2);
float rotSpeed = bobj->GetSpin(t,valid) * TWOPI/float(TIME_TICKSPERSEC);
int minClust = bobj->GetMinFrag(t,valid), maxClust = bobj->GetMaxFrag(t,valid);
if (minClust<1) minClust = 1;
if (maxClust<1) maxClust = 1;
int clustVar = maxClust-minClust+1;
float falloff = bobj->GetFalloff(t,valid);
int useFalloff = bobj->GetFalloffOn(t,valid);
int seed = bobj->GetSeed(t,valid);
//tm = nodeRef->GetNodeTM(t,&valid);
tm = nodeRef->GetObjectTM(t,&valid);
if (t<det) {
valid.Set(TIME_NegInfinity,det-1);
triOb->UpdateValidity(GEOM_CHAN_NUM,valid);
triOb->UpdateValidity(TOPO_CHAN_NUM,valid);
triOb->PointsWereChanged();
return;
}
float dt = float(t-det);
valid.SetInstant(t);
int n0=0,n1=1,n2=2,nv;
Point3 v, p0, p1, g(0.0f,0.0f,grav*GRAVITY_CONSTANT);
Tab<Point3> l_newVerts ;
Face *f = triOb->GetMesh().faces;
float dot;
Mesh &mesh = triOb->GetMesh();
// First, segment the faces.
srand((unsigned int)seed);
Tab<DWORD> vclust;
Tab<DWORD> vmap;
Tab<Point3> nverts;
vclust.SetCount(mesh.getNumVerts());
vmap.SetCount(mesh.getNumVerts());
int numClust = 0;
if (minClust==1 && maxClust==1) {
// Simple case... 1 face per cluster
nv = triOb->GetMesh().getNumFaces() * 3;
l_newVerts.SetCount(nv);
vclust.SetCount(nv);
for (int i=0; i<nv; i++) {
vclust[i] = i/3;
}
for (int i=0,j=0; i<mesh.getNumFaces(); i++) {
l_newVerts[j] = mesh.verts[mesh.faces[i].v[0]];
l_newVerts[j+1] = mesh.verts[mesh.faces[i].v[1]];
l_newVerts[j+2] = mesh.verts[mesh.faces[i].v[2]];
mesh.faces[i].v[0] = j;
mesh.faces[i].v[1] = j+1;
mesh.faces[i].v[2] = j+2;
j += 3;
}
numClust = triOb->GetMesh().getNumFaces();
} else {
// More complex case... clusters are randomely sized
for (int i=0; i<mesh.getNumVerts(); i++) {
vclust[i] = UNDEFINED;
vmap[i] = i;
}
int cnum = 0;
for (int i=0; i<mesh.getNumFaces(); ) {
int csize = int(Rand1()*float(clustVar)+float(minClust));
if (i+csize>mesh.getNumFaces()) {
csize = mesh.getNumFaces()-i;
}
// Make sure each face in the cluster has at least 2 verts in common with another face.
BOOL verified = FALSE;
while (!verified) {
verified = TRUE;
if (csize<2) break;
for (int j=0; j<csize; j++) {
BOOL match = FALSE;
for (int k=0; k<csize; k++) {
if (k==j) continue;
int common = 0;
for (int i1=0; i1<3; i1++) {
for (int i2=0; i2<3; i2++) {
if (mesh.faces[i+j].v[i1]==
mesh.faces[i+k].v[i2]) common++;
}
}
if (common>=2) {
match = TRUE;
break;
}
}
if (!match) {
csize = j;
verified = FALSE; // Have to check again
break;
}
}
}
if (csize==0) csize = 1;
// Clear the vert map
for (int j=0; j<mesh.getNumVerts(); j++) vmap[j] = UNDEFINED;
// Go through the cluster and remap verts.
for (int j=0;j<csize; j++) {
for (int k=0; k<3; k++) {
if (vclust[mesh.faces[i+j].v[k]]==UNDEFINED) {
vclust[mesh.faces[i+j].v[k]] = cnum;
} else
if (vclust[mesh.faces[i+j].v[k]]!=(DWORD)cnum) {
if (vmap[mesh.faces[i+j].v[k]]==UNDEFINED) {
vclust.Append(1,(DWORD*)&cnum,50);
nverts.Append(1,&mesh.verts[mesh.faces[i+j].v[k]],50);
mesh.faces[i+j].v[k] =
vmap[mesh.faces[i+j].v[k]] =
mesh.getNumVerts()+nverts.Count()-1;
} else {
mesh.faces[i+j].v[k] =
vmap[mesh.faces[i+j].v[k]];
}
}
}
}
cnum++;
numClust++;
i += csize;
}
nv = mesh.getNumVerts() + nverts.Count();
l_newVerts.SetCount(nv);
int i;
for (i=0; i<mesh.getNumVerts(); i++)
l_newVerts[i] = mesh.verts[i];
for ( ; i<mesh.getNumVerts()+nverts.Count(); i++)
l_newVerts[i] = nverts[i-mesh.getNumVerts()];
}
// Find the center of all clusters
Tab<Point3> clustCent;
Tab<DWORD> clustCounts;
clustCent.SetCount(numClust);
clustCounts.SetCount(numClust);
for (int i=0; i<numClust; i++) {
clustCent[i] = Point3(0,0,0);
clustCounts[i] = 0;
}
for (int i=0; i<nv; i++) {
if (vclust[i]==UNDEFINED) continue;
clustCent[vclust[i]] += l_newVerts[i];
clustCounts[vclust[i]]++;
}
// Build transformations for all clusters
Tab<Matrix3> mats;
mats.SetCount(numClust);
srand((unsigned int)seed);
for (int i=0; i<numClust; i++) {
if (clustCounts[i]) clustCent[i] /= float(clustCounts[i]);
v = clustCent[i] - tm.GetTrans();
float u = 1.0f;
if (useFalloff) {
u = 1.0f - Length(v)/falloff;
if (u<0.0f) u = 0.0f;
}
dot = DotProd(v,v);
if (dot==0.0f) dot = 0.000001f;
v = v / dot * strength * u;
v.x *= chaosBase + chaos * Rand1();
v.y *= chaosBase + chaos * Rand1();
v.z *= chaosBase + chaos * Rand1();
p1 = v*dt + 0.5f*g*dt*dt; // projectile motion
// Set rotation
Point3 axis;
axis.x = -1.0f + 2.0f*Rand1();
axis.y = -1.0f + 2.0f*Rand1();
axis.z = -1.0f + 2.0f*Rand1();
axis = Normalize(axis);
float angle = dt*rotSpeed*(chaosBase + chaos * Rand1())*u;
Quat q = QFromAngAxis(angle, axis);
q.MakeMatrix(mats[i]);
mats[i].PreTranslate(-clustCent[i]);
mats[i].Translate(clustCent[i]+p1);
}
// Now transform the clusters
for (int i=0; i<nv; i++) {
if (vclust[i]==UNDEFINED) continue;
l_newVerts[i] = l_newVerts[i] * mats[vclust[i]];
}
triOb->UpdateValidity(GEOM_CHAN_NUM,valid);
triOb->UpdateValidity(TOPO_CHAN_NUM,valid);
triOb->PointsWereChanged();
triOb->GetMesh().setNumVerts(nv,FALSE,TRUE);
//assign the new vertices to the mesh
for ( int i=0; i < nv; i++)
triOb->GetMesh().setVert( i,l_newVerts[i]);
}
}
