more fixes

test vigourously

Engine/source/ts/assimp/assimpAppMesh.cpp

@@ -123,6 +123,10 @@ void AssimpAppMesh::lockMesh(F32 t, const MatrixF& objOffset)
 
    bool flipNormals = ColladaUtils::getOptions().invertNormals;
 
+   MatrixF normalMat(objOffset);
+   normalMat.inverse();
+   normalMat.transpose();
+
    bool noUVFound = false;
    for (U32 i = 0; i < mMeshData->mNumVertices; i++)
    {
@@ -144,6 +148,10 @@ void AssimpAppMesh::lockMesh(F32 t, const MatrixF& objOffset)
 
       objOffset.mulP(tmpVert);
 
+      normalMat.mulV(tmpNormal);
+      if (mMeshData->HasNormals())
+         tmpNormal.normalize();
+
       points.push_back(tmpVert);
 
       if (mMeshData->HasTextureCoords(0))

Engine/source/ts/assimp/assimpAppNode.cpp

@@ -131,7 +131,9 @@ void AssimpAppNode::getAnimatedTransform(MatrixF& mat, F32 t, aiAnimation* animS
    for (U32 k = 0; k < animSeq->mNumChannels; ++k)
    {
       const aiNodeAnim* nodeAnim = animSeq->mChannels[k];
-      if (dStrcmp(mName, nodeAnim->mNodeName.C_Str()) != 0)
+      String m_node_name = mName;
+      String ai_node_name = nodeAnim->mNodeName.C_Str();
+      if (!ai_node_name.equal(m_node_name))
          continue;
 
       Point3F translation(Point3F::Zero);
@@ -277,6 +279,37 @@ MatrixF AssimpAppNode::getNodeTransform(F32 time)
    }
 }
 
+MatrixF AssimpAppNode::getBoundsReferenceTransform(F32 time)
+{
+   // Deliberately independent of this node's own raw local data (rotation,
+   // scale) and of axisCorrectionMat
+   MatrixF mat(true);
+   mat.scale(ColladaUtils::getOptions().unit * ColladaUtils::getOptions().formatScaleFactor);
+
+   if (mScene && mScene->mRootNode)
+   {
+      MatrixF sceneRootMat(true);
+      assimpToTorqueMat(mScene->mRootNode->mTransformation, sceneRootMat);
+      mat.mulL(sceneRootMat);
+   }
+
+   return mat;
+}
+
+MatrixF AssimpAppNode::getOwnRotationOnly(F32 time)
+{
+   // This node's own raw mNodeTransform
+   MatrixF rotOnly(mNodeTransform);
+   Point3F rawScale = rotOnly.getScale();
+   Point3F invScale(
+      rawScale.x ? 1.0f / rawScale.x : 0.0f,
+      rawScale.y ? 1.0f / rawScale.y : 0.0f,
+      rawScale.z ? 1.0f / rawScale.z : 0.0f);
+   rotOnly.scale(invScale);
+   rotOnly.setPosition(Point3F::Zero);
+   return rotOnly;
+}
+
 void AssimpAppNode::assimpToTorqueMat(const aiMatrix4x4& inAssimpMat, MatrixF& outMat)
 {
    outMat.setRow(0, Point4F((F32)inAssimpMat.a1, (F32)inAssimpMat.a2,

Engine/source/ts/assimp/assimpAppNode.h

@@ -122,6 +122,8 @@ public:
    }
 
    MatrixF getNodeTransform(F32 time) override;
+   MatrixF getBoundsReferenceTransform(F32 time) override;
+   MatrixF getOwnRotationOnly(F32 time) override;
    bool animatesTransform(const AppSequence* appSeq) override;
    bool isParentRoot() override { return (appParent == NULL); }
 

Engine/source/ts/assimp/assimpShapeLoader.cpp

@@ -275,8 +275,6 @@ void AssimpShapeLoader::enumerateScene()
       }
    }
 
-   ColladaUtils::getOptions().upAxis = UPAXISTYPE_Z_UP;
-   // Compute & apply axis conversion matrix
    getRootAxisTransform();
 
    for (U32 i = 0; i < mScene->mNumTextures; ++i) {
@@ -311,11 +309,9 @@ void AssimpShapeLoader::enumerateScene()
       }
    }
 
-   // Add a bounds node if none exists
    if (!boundsNode) {
-      
       aiNode* reqNode = new aiNode("bounds");
-      reqNode->mTransformation = aiMatrix4x4();// *sceneRoot;
+      reqNode->mTransformation = aiMatrix4x4();
       AssimpAppNode* appBoundsNode = new AssimpAppNode(mScene, reqNode);
       if (!processNode(appBoundsNode)) {
          delete appBoundsNode;
@@ -383,34 +379,42 @@ void AssimpShapeLoader::configureImportUnits() {
 
 void AssimpShapeLoader::getRootAxisTransform()
 {
-   aiMetadata* meta = mScene->mMetaData;
-   if (!meta)
-   {
-      // assume y up
-      ColladaUtils::getOptions().upAxis = UPAXISTYPE_Y_UP;
-      return;
-   }
-
-   // Fetch metadata values
    int upAxis = 1, upSign = 1;
    int frontAxis = 2, frontSign = -1;
    int coordAxis = 0, coordSign = 1;
 
+   aiMetadata* meta = mScene->mMetaData;
+   if (meta)
+   {
       meta->Get("UpAxis", upAxis);
       meta->Get("UpAxisSign", upSign);
       meta->Get("FrontAxis", frontAxis);
       meta->Get("FrontAxisSign", frontSign);
       meta->Get("CoordAxis", coordAxis);
       meta->Get("CoordAxisSign", coordSign);
-
-   switch (upAxis)
-   {
-      case 0: ColladaUtils::getOptions().upAxis = UPAXISTYPE_X_UP; break;
-      case 1: ColladaUtils::getOptions().upAxis = UPAXISTYPE_Y_UP; break;
-      case 2: ColladaUtils::getOptions().upAxis = UPAXISTYPE_Z_UP; break;
-      default: ColladaUtils::getOptions().upAxis = UPAXISTYPE_Y_UP; break;
    }
 
+   if (ColladaUtils::getOptions().upAxis != UPAXISTYPE_COUNT)
+   {
+      switch (ColladaUtils::getOptions().upAxis)
+      {
+      case UPAXISTYPE_X_UP: upAxis = 0; break;
+      case UPAXISTYPE_Y_UP: upAxis = 1; break;
+      case UPAXISTYPE_Z_UP: upAxis = 2; break;
+      default: break;
+      }
+   }
+
+   domUpAxisType canonicalAxis;
+   switch (upAxis)
+   {
+   case 0: canonicalAxis = UPAXISTYPE_X_UP; break;
+   case 1: canonicalAxis = UPAXISTYPE_Y_UP; break;
+   case 2: canonicalAxis = UPAXISTYPE_Z_UP; break;
+   default: canonicalAxis = UPAXISTYPE_Y_UP; break;
+   }
+
+   ColladaUtils::getOptions().upAxis = canonicalAxis;
    MatrixF rot(true);
 
    // Build source basis
@@ -991,11 +995,9 @@ static bool sReadAssimp(const Torque::Path &path, TSShape*& res_shape)
    AssimpShapeLoader loader;
    TSShape* tss = loader.generateShape(path);
 
+   // override default options with the ones provided by the assimp import.
    if (tscon && autoDetectUpAxis)
-   {
       tscon->mOptions = ColladaUtils::getOptions();
-   }
-
    if (tss)
    {
       TSShapeLoader::updateProgress(TSShapeLoader::Load_Complete, "Import complete");

Engine/source/ts/loader/appNode.h

@@ -65,6 +65,14 @@ public:
 
    virtual MatrixF getNodeTransform(F32 time) = 0;
 
+   /// The transform TSShapeLoader::getLocalNodeMatrix() uses as the bounds
+	/// reference frame when this node is the shape's bounds node. 
+   virtual MatrixF getBoundsReferenceTransform(F32 time) { return getNodeTransform(time); }
+
+   /// This node's own raw local rotation only (no parent chain, no axis
+   /// correction, scale zapped out).
+   virtual MatrixF getOwnRotationOnly(F32 time) { return MatrixF(true); }
+
    virtual bool isEqual(AppNode* node) = 0;
 
    virtual bool animatesTransform(const AppSequence* appSeq) = 0;