Extras/MayaPlugin/bt_mesh_shape.h

@@ -110,6 +110,8 @@ protected:
         gimpactShape->updateBound();
         set_shape(gimpactShape);
 
+        //std::cout << "construtor: " << m_center << std::endl;
+
        // gimpactShape->setMargin(0.05);
     }
 

Extras/MayaPlugin/collisionShapeNode.cpp

@@ -209,8 +209,8 @@ void collisionShapeNode::computeCollisionShape(const MPlug& plug, MDataBlock& da
                 MFloatVectorArray mnormals;
                 MIntArray mtrianglecounts;
                 MIntArray mtrianglevertices;
-                fnMesh.getPoints(mpoints, MSpace::kWorld);
+                fnMesh.getPoints(mpoints, MSpace::kObject);
-                fnMesh.getNormals(mnormals, MSpace::kWorld);
+                fnMesh.getNormals(mnormals, MSpace::kObject);
                 fnMesh.getTriangles(mtrianglecounts, mtrianglevertices);
 
                 std::vector<vec3f> vertices(mpoints.length());
@@ -246,8 +246,8 @@ void collisionShapeNode::computeCollisionShape(const MPlug& plug, MDataBlock& da
                 MFloatVectorArray mnormals;
                 MIntArray mtrianglecounts;
                 MIntArray mtrianglevertices;
-                fnMesh.getPoints(mpoints, MSpace::kWorld);
+                fnMesh.getPoints(mpoints, MSpace::kObject);
-                fnMesh.getNormals(mnormals, MSpace::kWorld);
+                fnMesh.getNormals(mnormals, MSpace::kObject);
                 fnMesh.getTriangles(mtrianglecounts, mtrianglevertices);
 
                 std::vector<vec3f> vertices(mpoints.length());

Extras/MayaPlugin/dSolverNode.cpp

@@ -39,6 +39,7 @@ Written by: Nicola Candussi <nicola@fluidinteractive.com>
 #include <maya/MFnField.h>
 #include <maya/MVectorArray.h>
 #include <maya/MItDag.h>
+#include <maya/MConditionMessage.h>
 
 #include <fstream>
 #include <sstream>
@@ -499,6 +500,39 @@ void dSolverNode::updateActiveRigidBodies(MPlugArray &rbConnections)
                 fnTransform.setTranslation(MVector(pos[0], pos[1], pos[2]), MSpace::kTransform);
             }
         } else if(fnDagNode.typeId() == rigidBodyArrayNode::typeId) {
+            rigidBodyArrayNode *rbNode = static_cast<rigidBodyArrayNode*>(fnDagNode.userNode()); 
+            std::vector<rigid_body_t::pointer>& rbs = rbNode->rigid_bodies();
+
+            MPlug plgActive(node, rigidBodyArrayNode::ia_active);
+            bool active = false;
+            plgActive.getValue(active);
+
+            //write the position and rotations 
+            if(active) {
+                MPlug plgPosition(node, rigidBodyArrayNode::io_position);
+                MPlug plgRotation(node, rigidBodyArrayNode::io_rotation);
+
+                MPlug plgElement;
+                for(size_t j = 0; j < rbs.size(); ++j) {
+                    vec3f pos;
+                    quatf rot;
+                    rbs[j]->get_transform(pos, rot); 
+
+                    MEulerRotation meuler(MQuaternion(rot[1], rot[2], rot[3], rot[0]).asEulerRotation());
+
+                    plgElement = plgPosition.elementByLogicalIndex(j);
+                    plgElement.child(0).setValue(pos[0]);
+                    plgElement.child(1).setValue(pos[1]);
+                    plgElement.child(2).setValue(pos[2]);
+
+                    plgElement = plgRotation.elementByLogicalIndex(j);
+                    plgElement.child(0).setValue(rad2deg(meuler.x));
+                    plgElement.child(1).setValue(rad2deg(meuler.y));
+                    plgElement.child(2).setValue(rad2deg(meuler.z));
+
+                }
+            }
+
             //check if we have to output the rigid bodies to a file
             MPlug plgFileIO(node, rigidBodyArrayNode::ia_fileIO);
             bool doIO;
@@ -600,42 +634,47 @@ void dSolverNode::computeRigidBodies(const MPlug& plug, MDataBlock& data)
         initRigidBodies(rbConnections);
         solver_t::set_split_impulse(splitImpulseEnabled);
         m_prevTime = time;
-    } else if(time > m_prevTime && ((time - m_prevTime).value() <= 1.0)) { 
+    } else {
-         //step the simulation forward,
+        double delta_frames = (time - m_prevTime).value();
-        //don't update if we are jumping more than one frame
+        bool playback = MConditionMessage::getConditionState("playingBack");
+        if(time > m_prevTime && 
+           ((delta_frames <= 1.0) || (playback && delta_frames < 100))) { 
+             //step the simulation forward,
+            //don't update if we are jumping more than one frame
+    
+            float dt = (time - m_prevTime).as(MTime::kSeconds);
+    
+            //gather start and end transform for passive rigid bodies, used for interpolation
+            std::vector<xforms_t> passiveXForms;
+            gatherPassiveTransforms(rbConnections, passiveXForms);
+    
+    
+            //set the gravity in the solver
+            MPlug plgGravity(thisObject, ia_gravity);
+            vec3f gravity;
+            plgGravity.child(0).getValue(gravity[0]);
+            plgGravity.child(1).getValue(gravity[1]);
+            plgGravity.child(2).getValue(gravity[2]);
+    
+            solver_t::set_gravity(gravity);
+    
+            solver_t::set_split_impulse(splitImpulseEnabled);
+    
+            for(int i = 1; i <= subSteps; ++i) {
+                //first update the passive rigid bodies
+                updatePassiveRigidBodies(rbConnections, passiveXForms, i * dt / subSteps);
+    
+                //fields
+                applyFields(rbConnections, dt / subSteps);
+    
+                //step the simulation
+                solver_t::step_simulation(dt / subSteps);
+            }
+    
+            m_prevTime = time;
 
-        float dt = (time - m_prevTime).as(MTime::kSeconds);
+            updateActiveRigidBodies(rbConnections);
-
-        //gather start and end transform for passive rigid bodies, used for interpolation
-        std::vector<xforms_t> passiveXForms;
-        gatherPassiveTransforms(rbConnections, passiveXForms);
-
-
-        //set the gravity in the solver
-        MPlug plgGravity(thisObject, ia_gravity);
-        vec3f gravity;
-        plgGravity.child(0).getValue(gravity[0]);
-        plgGravity.child(1).getValue(gravity[1]);
-        plgGravity.child(2).getValue(gravity[2]);
-
-        solver_t::set_gravity(gravity);
-
-        solver_t::set_split_impulse(splitImpulseEnabled);
-
-        for(int i = 1; i <= subSteps; ++i) {
-            //first update the passive rigid bodies
-            updatePassiveRigidBodies(rbConnections, passiveXForms, i * dt / subSteps);
-
-            //fields
-            applyFields(rbConnections, dt / subSteps);
-
-            //step the simulation
-            solver_t::step_simulation(dt / subSteps);
         }
-
-        m_prevTime = time;
-
-        updateActiveRigidBodies(rbConnections);
     } 
 
     data.outputValue(oa_rigidBodies).set(true);

Extras/MayaPlugin/rigidBodyArrayNode.cpp

@@ -166,25 +166,6 @@ MStatus rigidBodyArrayNode::initialize()
     status = addAttribute(ia_fioFiles);
     MCHECKSTATUS(status, "adding ia_fioFiles attribute")
 
- /*   ia_fioPositionAttribute = fnTypedAttr.create( "positionAttribute", "posa", MFnData::kString, 
-                                     fnStringData.create("position"), &status );
-    MCHECKSTATUS(status, "creating ia_fioPositionAttribute attribute")
-    fnTypedAttr.setKeyable(false);
-    status = addAttribute(ia_fioPositionAttribute);
-    MCHECKSTATUS(status, "adding ia_fioPositionAttribute attribute")
-
-    ia_fioRotationAttribute = fnTypedAttr.create( "rotationAttribute", "rota", MFnData::kString, 
-                                     fnStringData.create("rotation"), &status );
-    MCHECKSTATUS(status, "creating ia_fioRotationAttribute attribute")
-    fnTypedAttr.setKeyable(false);
-    status = addAttribute(ia_fioRotationAttribute);
-    MCHECKSTATUS(status, "adding ia_fioRotationAttribute attribute")*/
-
-    /*
-    MObject     rigidBodyArrayNode::ia_fioFiles;
-MObject     rigidBodyArrayNode::ia_fioPositionAttribute;
-MObject     rigidBodyArrayNode::ia_fioRotationAttribute;*/
-
     io_position = fnNumericAttr.createPoint("position", "pos", &status);
     MCHECKSTATUS(status, "creating position attribute")
     fnNumericAttr.setArray(true);
@@ -428,19 +409,16 @@ void rigidBodyArrayNode::computeRigidBodies(const MPlug& plug, MDataBlock& data)
     }
 
     m_rigid_bodies.resize(numBodies);
-	for(size_t i = 0; i < m_rigid_bodies.size(); ++i) {
+    for(size_t i = 0; i < m_rigid_bodies.size(); ++i) {
-        m_rigid_bodies[i] = solver_t::create_rigid_body(collision_shape);
+        m_rigid_bodies[i] = solver_t::create_rigid_body(collision_shape);
-		if (i < positions.size())
+	if (i < positions.size()) {
-		{
+            m_rigid_bodies[i]->set_transform(positions[i], rotations[i]);
-			m_rigid_bodies[i]->set_transform(positions[i], rotations[i]);
+	} else {
-		} else
+            m_rigid_bodies[i]->set_transform(vec3f(0.f,0.f,0.f),quatf(1.f,0.f,0.f,0.f));
-		{
+	}
-			m_rigid_bodies[i]->set_transform(vec3f(0.f,0.f,0.f),quatf(1.f,0.f,0.f,0.f));
+        solver_t::add_rigid_body(m_rigid_bodies[i]);
-		}
-        solver_t::add_rigid_body(m_rigid_bodies[i]);
     }
 
-
     data.outputValue(ca_rigidBodies).set(true);
     data.setClean(plug);
 }

Extras/MayaPlugin/rigidBodyNode.cpp

@@ -409,7 +409,7 @@ void rigidBodyNode::computeRigidBody(const MPlug& plug, MDataBlock& data)
 
 void rigidBodyNode::computeWorldMatrix(const MPlug& plug, MDataBlock& data)
 {
-   // std::cout << "rigidBodyNode::computeWorldMatrix" << std::endl;
+    //std::cout << "rigidBodyNode::computeWorldMatrix" << std::endl;
 
     MObject thisObject(thisMObject());
     MFnDagNode fnDagNode(thisObject);
@@ -428,8 +428,6 @@ void rigidBodyNode::computeWorldMatrix(const MPlug& plug, MDataBlock& data)
     double mscale[3];
     fnParentTransform.getScale(mscale);
 
-  // std::cout << mtranslation << std::endl;
-
     m_rigid_body->get_transform(pos, rot);
 
     MDataHandle hInitPos = data.outputValue(ia_initialPosition);