Changeset 11109

Timestamp:

02/24/10 11:25:50 (3 years ago)

Author:

mplatings

Message:

 

Location:

OpenSceneGraph/trunk/src/osgPlugins/fbx

Files:

• CMakeLists.txt (modified) (2 diffs)
• ReaderWriterFBX.cpp (modified) (11 diffs)
• ReaderWriterFBX.h (modified) (2 diffs)
• WriterNodeVisitor.cpp (added)
• WriterNodeVisitor.h (added)
• fbxRAnimation.cpp (modified) (15 diffs)
• fbxRAnimation.h (modified) (1 diff)
• fbxRMesh.cpp (modified) (19 diffs)
• fbxRMesh.h (modified) (1 diff)
• fbxRNode.cpp (modified) (14 diffs)
• fbxRNode.h (modified) (2 diffs)

OpenSceneGraph/trunk/src/osgPlugins/fbx/CMakeLists.txt

@@ -8 +8 @@
     fbxRNode.cpp
     ReaderWriterFBX.cpp
+    WriterNodeVisitor.cpp
+    fbxMaterialToOsgStateSet.cpp
 )
 
@@ -17 +19 @@
     fbxRNode.h
     ReaderWriterFBX.h
+    WriterNodeVisitor.h
+    fbxMaterialToOsgStateSet.h
 )
 

OpenSceneGraph/trunk/src/osgPlugins/fbx/ReaderWriterFBX.cpp

@@ -5 +5 @@
 #include <osg/MatrixTransform>
 #include <osg/Material>
+#include <osg/PositionAttitudeTransform>
 #include <osg/Texture2D>
+#include <osgDB/ConvertUTF>
 
 #include <osgDB/FileNameUtils>
@@ -11 +13 @@
 #include <osgDB/ReadFile>
 #include <osgDB/Registry>
-
 #include <osgAnimation/AnimationManagerBase>
+#include <osgAnimation/Bone>
 #include <osgAnimation/Skeleton>
-
-#include <OpenThreads/ScopedLock>
 
 #if defined(_MSC_VER)
@@ -24 +24 @@
 #include "ReaderWriterFBX.h"
 #include "fbxRNode.h"
+#include "fbxMaterialToOsgStateSet.h"
+#include "WriterNodeVisitor.h"
+
+
+/// Returns true if the given node is a basic root group with no special information.
+/// Used in conjunction with UseFbxRoot option.
+/// Identity transforms are considered as basic root nodes.
+bool isBasicRootNode(const osg::Node& node)
+{
+    const osg::Group* osgGroup = node.asGroup();
+    if (!osgGroup)
+    {
+        // Geodes & such are not basic root nodes
+        return false;
+    }
+
+    // Test if we've got an empty transform (= a group!)
+    const osg::Transform* transform = osgGroup->asTransform();
+    if (transform)
+    {
+        if (const osg::MatrixTransform* matrixTransform = transform->asMatrixTransform())
+        {
+            if (!matrixTransform->getMatrix().isIdentity())
+            {
+                // Non-identity matrix transform
+                return false;
+            }
+        }
+        else if (const osg::PositionAttitudeTransform* pat = transform->asPositionAttitudeTransform())
+        {
+            if (pat->getPosition() != osg::Vec3d() ||
+                pat->getAttitude() != osg::Quat() ||
+                pat->getScale() != osg::Vec3d(1.0f, 1.0f, 1.0f) ||
+                pat->getPivotPoint() != osg::Vec3d())
+            {
+                // Non-identity position attribute transform
+                return false;
+            }
+        }
+        else
+        {
+            // Other transform (not identity or not predefined type)
+            return false;
+        }
+    }
+
+    // Test the presence of a non-empty stateset
+    if (node.getStateSet())
+    {
+        osg::ref_ptr<osg::StateSet> emptyStateSet = new osg::StateSet;
+        if (node.getStateSet()->compare(*emptyStateSet, true) != 0)
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+class CleanUpFbx
+{
+    KFbxSdkManager* m_pSdkManager;
+public:
+    explicit CleanUpFbx(KFbxSdkManager* pSdkManager) : m_pSdkManager(pSdkManager)
+    {}
+
+    ~CleanUpFbx()
+    {
+        KFbxIOSettings::IOSettingsRef().FreeIOSettings();
+        m_pSdkManager->Destroy();
+    }
+};
+
+class ConvertBindMatrixVisitor : public osg::NodeVisitor
+{
+public:
+    ConvertBindMatrixVisitor() : osg::NodeVisitor(TRAVERSE_ALL_CHILDREN) {}
+
+    virtual void apply(osg::MatrixTransform& node)
+    {
+        if (osgAnimation::Bone* bone = dynamic_cast<osgAnimation::Bone*>(&node))
+        {
+            bone->setInvBindMatrixInSkeletonSpace(osg::Matrix::inverse(bone->getMatrixInBoneSpace()));
+            if (const osgAnimation::Bone* parent = bone->getBoneParent())
+            {
+                bone->setInvBindMatrixInSkeletonSpace(parent->getInvBindMatrixInSkeletonSpace() * bone->getInvBindMatrixInSkeletonSpace());
+            }
+        }
+
+        traverse(node);
+    }
+};
 
 osgDB::ReaderWriter::ReadResult
-ReaderWriterFBX::readNode(const std::string& utf8filename,
-                          const osgDB::ReaderWriter::Options* options) const
+ReaderWriterFBX::readNode(const std::string& filenameInit,
+                          const Options* options) const
 {
-    OpenThreads::ScopedLock<OpenThreads::ReentrantMutex> lock(_serializerMutex);
-
     try
     {
-        std::string ext(osgDB::getLowerCaseFileExtension(utf8filename));
-        if(!acceptsExtension(ext)) return ReadResult::FILE_NOT_HANDLED;
-
-        std::string fileName(osgDB::findDataFile(utf8filename, options));
-        if( fileName.empty()) return ReadResult::FILE_NOT_FOUND;
+        std::string ext(osgDB::getLowerCaseFileExtension(filenameInit));
+        if (!acceptsExtension(ext)) return ReadResult::FILE_NOT_HANDLED;
+
+        std::string filename(osgDB::findDataFile(filenameInit, options));
+        if (filename.empty()) return ReadResult::FILE_NOT_FOUND;
 
         KFbxSdkManager* pSdkManager = KFbxSdkManager::Create();
@@ -46 +137 @@
         }
 
-        class CleanUpFbx
-        {
-            KFbxSdkManager* m_pSdkManager;
-        public:
-            CleanUpFbx(KFbxSdkManager* pSdkManager) : m_pSdkManager(pSdkManager)
-            {}
-
-            ~CleanUpFbx()
-            {
-                KFbxIOSettings::IOSettingsRef().FreeIOSettings();
-                m_pSdkManager->Destroy();
-            }
-        } cleanUpFbx(pSdkManager);
-
-        KFbxScene* pScene = KFbxScene::Create(pSdkManager,"");
+        CleanUpFbx cleanUpFbx(pSdkManager);
+
+        KFbxScene* pScene = KFbxScene::Create(pSdkManager, "");
+
+        // The FBX SDK interprets the filename as UTF-8
+#ifdef OSG_USE_UTF8_FILENAME
+        const std::string& utf8filename(filename);
+#else
+        std::string utf8filename(osgDB::convertStringFromCurrentCodePageToUTF8(filename));
+#endif
 
         int fileFormat;
@@ -67 +153 @@
             return ReadResult::FILE_NOT_HANDLED;
         }
-
-        KFbxImporter* lImporter = KFbxImporter::Create(pSdkManager,"");
+        KFbxImporter* lImporter = KFbxImporter::Create(pSdkManager, "");
         lImporter->SetFileFormat(fileFormat);
 
@@ -81 +166 @@
         }
 
-        for(int i = 0; i < lImporter->GetTakeCount(); i++)
+        for (int i = 0; i < lImporter->GetTakeCount(); i++)
         {
             KFbxTakeInfo* lTakeInfo = lImporter->GetTakeInfo(i);
@@ -93 +178 @@
         }
 
+        //KFbxAxisSystem::OpenGL.ConvertScene(pScene);        // Doesn't work as expected. Still need to transform vertices.
+
         if (KFbxNode* pNode = pScene->GetRootNode())
         {
+            bool useFbxRoot = false;
+            if (options)
+            {
+                std::istringstream iss(options->getOptionString());
+                std::string opt;
+                while (iss >> opt)
+                {
+                    if (opt == "UseFbxRoot")
+                    {
+                        useFbxRoot = true;
+                    }
+                }
+            }
+
             osg::ref_ptr<osgAnimation::AnimationManagerBase> pAnimationManager;
             bool bNeedSkeleton = false;
             int nLightCount = 0;
+            osg::ref_ptr<Options> localOptions = NULL;
+            if (options)
+                localOptions = options->cloneOptions();
+            else
+                localOptions = new osgDB::Options();
+            localOptions->setObjectCacheHint(osgDB::ReaderWriter::Options::CACHE_IMAGES);
+
+            std::string filePath = osgDB::getFilePath(filename);
+            FbxMaterialToOsgStateSet fbxMaterialToOsgStateSet(filePath, localOptions.get());
+           
             ReadResult res = readFbxNode(*pSdkManager, pNode, pAnimationManager,
-                osgDB::getFilePath(fileName), bNeedSkeleton, nLightCount);
+                bNeedSkeleton, nLightCount, fbxMaterialToOsgStateSet, localOptions.get());
+
             if (res.success())
             {
@@ -105 +217 @@
                 if (bNeedSkeleton)
                 {
+                    ConvertBindMatrixVisitor convertBindMatrixVisitor;
+                    osgNode->accept(convertBindMatrixVisitor);
                     osgAnimation::Skeleton* osgSkeleton = new osgAnimation::Skeleton;
                     osgSkeleton->setDefaultUpdateCallback();
@@ -121 +235 @@
                     //because the animations may be altered after registering
                     pAnimationManager->buildTargetReference();
-
                     osgNode->setUpdateCallback(pAnimationManager.get());
                 }
 
                 KFbxAxisSystem fbxAxis = pScene->GetGlobalSettings().GetAxisSystem();
-                int upSign;
-                KFbxAxisSystem::eUpVector eUp = fbxAxis.GetUpVector(upSign);
-                bool bLeftHanded = fbxAxis.GetCoorSystem() == KFbxAxisSystem::LeftHanded;
-                if (eUp != KFbxAxisSystem::YAxis || upSign < 0 || bLeftHanded)
-                {
+
+                if (fbxAxis != KFbxAxisSystem::OpenGL)
+                {
+                    int upSign;
+                    KFbxAxisSystem::eUpVector eUp = fbxAxis.GetUpVector(upSign);
+                    bool bLeftHanded = fbxAxis.GetCoorSystem() == KFbxAxisSystem::LeftHanded;
                     float fSign = upSign < 0 ? -1.0f : 1.0f;
                     float zScale = bLeftHanded ? -1.0f : 1.0f;
@@ -147 +261 @@
                         break;
                     }
-                    osg::MatrixTransform* pTransform = new osg::MatrixTransform(mat);
-                    pTransform->addChild(osgNode);
-                    osgNode = pTransform;
-                }
-
+
+                    osg::Transform* pTransformTemp = osgNode->asTransform();
+                    osg::MatrixTransform* pMatrixTransform = pTransformTemp ?
+                        pTransformTemp->asMatrixTransform() : NULL;
+                    if (pMatrixTransform)
+                    {
+                        pMatrixTransform->setMatrix(pMatrixTransform->getMatrix() * mat);
+                    }
+                    else
+                    {
+                        pMatrixTransform = new osg::MatrixTransform(mat);
+                        if (useFbxRoot && isBasicRootNode(*osgNode))
+                        {
+                            // If root node is a simple group, put all FBX elements under the OSG root
+                            osg::Group* osgGroup = osgNode->asGroup();
+                            for(unsigned int i = 0; i < osgGroup->getNumChildren(); ++i)
+                            {
+                                pMatrixTransform->addChild(osgGroup->getChild(i));
+                            }
+                            pMatrixTransform->setName(osgGroup->getName());
+                        }
+                        else
+                        {
+                            pMatrixTransform->addChild(osgNode);
+                        }
+                    }
+                    osgNode = pMatrixTransform;
+                }
+
+                osgNode->setName(filenameInit);
                 return osgNode;
             }
@@ -163 +302 @@
 }
 
+osgDB::ReaderWriter::WriteResult ReaderWriterFBX::writeNode(
+    const osg::Node& node,
+    const std::string& filename,
+    const Options* options) const
+{
+    try
+    {
+        std::string ext = osgDB::getLowerCaseFileExtension(filename);
+        if (!acceptsExtension(ext)) return WriteResult::FILE_NOT_HANDLED;
+
+        osg::ref_ptr<Options> localOptions = options ?
+            static_cast<Options*>(options->clone(osg::CopyOp::SHALLOW_COPY)) : new Options;
+        localOptions->getDatabasePathList().push_front(osgDB::getFilePath(filename));
+
+        KFbxSdkManager* pSdkManager = KFbxSdkManager::Create();
+
+        if (!pSdkManager)
+        {
+            return WriteResult::ERROR_IN_WRITING_FILE;
+        }
+
+        CleanUpFbx cleanUpFbx(pSdkManager);
+
+        bool useFbxRoot = false;
+        if (options)
+        {
+            std::istringstream iss(options->getOptionString());
+            std::string opt;
+            while (iss >> opt)
+            {
+                if (opt == "Embedded")
+                {
+                    IOSREF.SetBoolProp(EXP_FBX_EMBEDDED, true);
+                    if (KFbxIOSettings::IOSettingsRef().IsIOSettingsAllocated())
+                        KFbxIOSettings::IOSettingsRef().AllocateIOSettings(*pSdkManager);
+                }
+                else if (opt == "UseFbxRoot")
+                {
+                    useFbxRoot = true;
+                }
+            }
+        }
+
+        KFbxScene* pScene = KFbxScene::Create(pSdkManager, "");
+        WriterNodeVisitor writerNodeVisitor(pScene, pSdkManager, filename,
+            options, osgDB::getFilePath(node.getName().empty() ? filename : node.getName()));
+        if (useFbxRoot && isBasicRootNode(node))
+        {
+            // If root node is a simple group, put all elements under the FBX root
+            const osg::Group * osgGroup = node.asGroup();
+            for(unsigned int child=0; child<osgGroup->getNumChildren(); ++child) {
+                const_cast<osg::Node *>(osgGroup->getChild(child))->accept(writerNodeVisitor);
+            }
+        }
+        else {
+            // Normal scene
+            const_cast<osg::Node&>(node).accept(writerNodeVisitor);
+        }
+
+        KFbxExporter* lExporter = KFbxExporter::Create(pSdkManager, "");
+        pScene->GetGlobalSettings().SetAxisSystem(KFbxAxisSystem::eOpenGL);
+
+        // Ensure the directory exists or else the FBX SDK will fail
+        if (!osgDB::makeDirectoryForFile(filename)) {
+            osg::notify(osg::NOTICE) << "Can't create directory for file '" << filename << "'. FBX SDK may fail creating the file." << std::endl;
+        }
+
+        // The FBX SDK interprets the filename as UTF-8
+#ifdef OSG_USE_UTF8_FILENAME
+        std::string utf8filename(filename);
+#else
+        std::string utf8filename(osgDB::convertStringFromCurrentCodePageToUTF8(filename));
+#endif
+
+        if (!lExporter->Initialize(utf8filename.c_str()))
+        {
+            return std::string(lExporter->GetLastErrorString());
+        }
+        if (!lExporter->Export(pScene))
+        {
+            return std::string(lExporter->GetLastErrorString());
+        }
+
+        return WriteResult::FILE_SAVED;
+    }
+    catch (const std::string& s)
+    {
+        return s;
+    }
+    catch (const char* s)
+    {
+        return std::string(s);
+    }
+    catch (...)
+    {
+    }
+
+    return WriteResult::ERROR_IN_WRITING_FILE;
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // Add ourself to the Registry to instantiate the reader/writer.

OpenSceneGraph/trunk/src/osgPlugins/fbx/ReaderWriterFBX.h

@@ -2 +2 @@
 #define READERWRITERFBX_H
 
-#include <OpenThreads/ReentrantMutex>
 #include <osgDB/ReaderWriter>
 
@@ -15 +14 @@
     {
         supportsExtension("fbx", "FBX format");
+        supportsOption("Embedded", "Embed textures in FBX file when writing");
+        supportsOption("UseFbxRoot", "(Read/write option) If the source OSG root node is a simple group with no stateset, the writer will put its children directly under the FBX root, and vice-versa for reading");
     }
 
     const char* className() const { return "FBX reader/writer"; }
 
-    /// The FBX SDK interprets the filename as UTF-8
-    ReadResult readNode(const std::string& utf8filename, const Options*) const;
-  
-private:
-    mutable OpenThreads::ReentrantMutex _serializerMutex;
+    virtual ReadResult readNode(const std::string& filename, const Options*) const;
+    virtual WriteResult writeNode(const osg::Node&, const std::string& filename, const Options*) const;
 };
 

OpenSceneGraph/trunk/src/osgPlugins/fbx/fbxRAnimation.cpp

@@ -5 +5 @@
 #include <osgAnimation/Channel>
 #include <osgAnimation/Sampler>
-#include <osgAnimation/UpdateCallback>
 
 #if defined(_MSC_VER)
@@ -25 +24 @@
 
 void readKeys(KFCurve* curveX, KFCurve* curveY, KFCurve* curveZ,
-              float scalar, const osg::Vec3& baseValue, bool multiply,
-              std::vector<osgAnimation::TemplateKeyframe<osg::Vec3> >& keyFrameCntr)
+              std::vector<osgAnimation::TemplateKeyframe<osg::Vec3> >& keyFrameCntr, float scalar = 1.0f)
 {
     KFCurve* curves[3] = {curveX, curveY, curveZ};
@@ -59 +57 @@
     {
         float fTime = *it;
-        osg::Vec3 val(baseValue);
+        osg::Vec3 val;
         for (int i = 0; i < 3; ++i)
         {
@@ -66 +64 @@
             TimeFloatMap::iterator lb = curveTimeMap[i].lower_bound(fTime);
             if (lb == curveTimeMap[i].end()) --lb;
-            if (multiply)
-            {
-                val[i] *= lb->second;
-            }
-            else
-            {
-                val[i] += lb->second;
-            }
+            val[i] = lb->second;
         }
         keyFrameCntr.push_back(osgAnimation::Vec3Keyframe(fTime, val));
@@ -80 +71 @@
 
 osgAnimation::Channel* readFbxChannels(KFCurve* curveX, KFCurve* curveY,
-    KFCurve* curveZ, const char* targetName, const char* channelName,
-    float scalar, const osg::Vec3& baseValue, bool multiply)
-{
-    if (!curveX && !curveY && !curveZ)
-    {
-        return 0;
-    }
-
-    if (!curveX->KeyGetCount() && !curveY->KeyGetCount() && !curveZ->KeyGetCount())
+    KFCurve* curveZ, const char* targetName, const char* channelName)
+{
+    if (!(curveX && curveX->KeyGetCount()) &&
+        !(curveY && curveY->KeyGetCount()) &&
+        !(curveZ && curveZ->KeyGetCount()))
     {
         return 0;
@@ -99 +86 @@
     pChannel->setTargetName(targetName);
     pChannel->setName(channelName);
-    readKeys(curveX, curveY, curveZ, scalar, baseValue, multiply, *pKeyFrameCntr);
+    readKeys(curveX, curveY, curveZ, *pKeyFrameCntr);
 
     return pChannel;
@@ -106 +93 @@
 osgAnimation::Channel* readFbxChannels(
     KFbxTypedProperty<fbxDouble3>& fbxProp, const char* pTakeName,
-    const char* targetName, const char* channelName, const osg::Vec3& baseValue, float scalar, bool multiply)
+    const char* targetName, const char* channelName)
 {
     if (!fbxProp.IsValid()) return 0;
@@ -114 +101 @@
         fbxProp.GetKFCurve("Y", pTakeName),
         fbxProp.GetKFCurve("Z", pTakeName),
-        targetName, channelName, scalar,
-        baseValue * scalar, multiply);
+        targetName, channelName);
 }
 
 osgAnimation::Channel* readFbxChannelsQuat(
     KFCurve* curveX, KFCurve* curveY, KFCurve* curveZ, const char* targetName,
-    const osg::Quat& baseQuat, ERotationOrder rotOrder)
-{
-    if (!curveX && !curveY && !curveZ)
+    ERotationOrder rotOrder)
+{
+    if (!(curveX && curveX->KeyGetCount()) &&
+        !(curveY && curveY->KeyGetCount()) &&
+        !(curveZ && curveZ->KeyGetCount()))
     {
         return 0;
@@ -132 +120 @@
     typedef std::vector<osgAnimation::TemplateKeyframe<osg::Vec3> > KeyFrameCntr;
     KeyFrameCntr eulerFrameCntr;
-    readKeys(curveX, curveY, curveZ, static_cast<float>(osg::PI / 180.0), osg::Vec3(0,0,0), false, eulerFrameCntr);
+    readKeys(curveX, curveY, curveZ, eulerFrameCntr, static_cast<float>(osg::PI / 180.0));
 
     osgAnimation::QuatSphericalLinearSampler::KeyframeContainerType& quatFrameCntr =
@@ -143 +131 @@
         const osg::Vec3& euler = it->getValue();
         quatFrameCntr.push_back(osgAnimation::QuatKeyframe(
-            it->getTime(), makeQuat(euler, rotOrder) * baseQuat));
+            it->getTime(), makeQuat(euler, rotOrder)));
     }
 
@@ -153 +141 @@
     osgAnimation::Channel* pRotationChannel,
     osgAnimation::Channel* pScaleChannel,
-    osg::ref_ptr<osgAnimation::AnimationManagerBase> &pAnimManager,
+    osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimManager,
     const char* pTakeName)
 {
@@ -190 +178 @@
 }
 
-osgAnimation::Animation* readFbxBoneAnimation(KFbxNode* pNode,
+osgAnimation::Animation* readFbxAnimation(KFbxNode* pNode,
     const char* pTakeName, const char* targetName,
     osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimManager)
@@ -200 +188 @@
 
     ERotationOrder rotOrder = pNode->RotationOrder.IsValid() ? pNode->RotationOrder.Get() : eEULER_XYZ;
-    osg::Quat inverseRot;
 
     osgAnimation::Channel* pTranslationChannel = 0;
@@ -207 +194 @@
     if (pNode->LclRotation.IsValid())
     {
-        inverseRot = makeQuat(pNode->LclRotation.Get(), rotOrder).inverse();
+        fbxDouble3 fbxBaseValue = pNode->LclRotation.Get();
 
         pRotationChannel = readFbxChannelsQuat(
@@ -213 +200 @@
             pNode->LclRotation.GetKFCurve(KFCURVENODE_R_Y, pTakeName),
             pNode->LclRotation.GetKFCurve(KFCURVENODE_R_Z, pTakeName),
-            targetName, inverseRot, rotOrder);
+            targetName, rotOrder);
     }
 
     if (pNode->LclTranslation.IsValid())
     {
-        fbxDouble3 fbxBaseValue = pNode->LclTranslation.Get();
-        osg::Vec3 offsetTranslation(
-            -static_cast<float>(fbxBaseValue[0]),
-            -static_cast<float>(fbxBaseValue[1]),
-            -static_cast<float>(fbxBaseValue[2]));
-
         pTranslationChannel = readFbxChannels(
             pNode->LclTranslation.GetKFCurve(KFCURVENODE_T_X, pTakeName),
             pNode->LclTranslation.GetKFCurve(KFCURVENODE_T_Y, pTakeName),
             pNode->LclTranslation.GetKFCurve(KFCURVENODE_T_Z, pTakeName),
-            targetName, "position", 1.0f, offsetTranslation, false);
-
-        if (pTranslationChannel)
-        {
-            osgAnimation::Vec3KeyframeContainer& keyFrameCntr =
-                dynamic_cast<osgAnimation::Vec3KeyframeContainer&>(
-                *pTranslationChannel->getSampler()->getKeyframeContainer());
-
-            for (int i = 0; i < keyFrameCntr.size(); ++i)
-            {
-                keyFrameCntr[i].setValue(inverseRot * keyFrameCntr[i].getValue());
-            }
-        }
+            targetName, "translate");
     }
 
     osgAnimation::Channel* pScaleChannel = readFbxChannels(
-        pNode->LclScaling, pTakeName, targetName, "scale", osg::Vec3(0,0,0), 1.0f, true);
+        pNode->LclScaling, pTakeName, targetName, "scale");
 
     return addChannels(pTranslationChannel, pRotationChannel, pScaleChannel, pAnimManager, pTakeName);
-}
-
-osgAnimation::Animation* readFbxAnimation(KFbxNode* pNode,
-    const char* pTakeName, const char* targetName,
-    osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimManager)
-{
-    if (!pTakeName) return 0;
-
-    osgAnimation::Channel* pTranslationChannel = readFbxChannels(
-        pNode->LclTranslation, pTakeName, targetName, "position", osg::Vec3(0,0,0), 1.0f, false);
-
-    //TODO: This will break if there are rotations in more than one of
-    // Pre/Lcl/Post so really they should each get their own MatrixTransform.
-    fbxDouble3 fbxPreRot = pNode->PreRotation.Get();
-    fbxDouble3 fbxPostRot = pNode->PostRotation.Get();
-    osg::Vec3 eulerOffset(
-        static_cast<float>(fbxPreRot[0] + fbxPostRot[0]),
-        static_cast<float>(fbxPreRot[1] + fbxPostRot[1]),
-        static_cast<float>(fbxPreRot[2] + fbxPostRot[2]));
-
-    osgAnimation::Channel* pRotationChannel = readFbxChannels(
-        pNode->LclRotation, pTakeName, targetName, "euler", eulerOffset, static_cast<float>(osg::PI / 180.0), false);
-
-    osgAnimation::Channel* pScaleChannel = readFbxChannels(
-        pNode->LclScaling, pTakeName, targetName, "scale", osg::Vec3(1,1,1), 1.0f, true);
-
-    return addChannels(pTranslationChannel, pRotationChannel, pScaleChannel, pAnimManager, pTakeName);
-}
-
-std::string readFbxBoneAnimation(KFbxNode* pNode,
-    osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimManager,
-    const char* targetName)
-{
-    std::string result;
-    for (int i = 1; i < pNode->GetTakeNodeCount(); ++i)
-    {
-        const char* pTakeName = pNode->GetTakeNodeName(i);
-        if (osgAnimation::Animation* pAnimation = readFbxBoneAnimation(
-            pNode, pTakeName, targetName, pAnimManager))
-        {
-            result = targetName;
-        }
-    }
-    return result;
 }
 

OpenSceneGraph/trunk/src/osgPlugins/fbx/fbxRAnimation.h

@@ -3 +3 @@
 
 #include <fbxfilesdk/fbxfilesdk_def.h>
-
-std::string readFbxBoneAnimation(
-    FBXFILESDK_NAMESPACE::KFbxNode*,
-    osg::ref_ptr<osgAnimation::AnimationManagerBase>&,
-    const char* targetName);
 
 std::string readFbxAnimation(

OpenSceneGraph/trunk/src/osgPlugins/fbx/fbxRMesh.cpp

@@ +1 @@
+#include <cassert>
+#include <sstream>
+
 #include <osg/Geode>
 #include <osg/Image>
@@ -133 +136 @@
 
 osg::Geometry* getGeometry(osg::Geode* pGeode, GeometryMap& geometryMap,
-    const std::vector<osg::ref_ptr<osg::Material>>& materialList,
-    const std::vector<osg::ref_ptr<osg::Texture>>& textureList,
-    GeometryType gt, unsigned mti, bool bNormal, bool bTexCoord, bool bColor)
+    std::vector<StateSetContent>& stateSetList,
+    GeometryType gt, unsigned int mti, bool bNormal, bool bTexCoord, bool bColor)
 {
     GeometryMap::iterator it = geometryMap.find(mti);
@@ -145 +147 @@
 
     osg::ref_ptr<osg::Geometry> pGeometry;
-    if (gt == GEOMETRY_RIG)
-    {
-        osgAnimation::RigGeometry* pRig = new osgAnimation::RigGeometry;
-        pRig->setInfluenceMap(new osgAnimation::VertexInfluenceMap);
-        pGeometry = pRig;
-    }
-    else if (gt == GEOMETRY_MORPH)
+    if (gt == GEOMETRY_MORPH)
     {
         pGeometry = new osgAnimation::MorphGeometry;
@@ -165 +161 @@
     if (bColor) pGeometry->setColorData(osg::Geometry::ArrayData(new osg::Vec4Array, osg::Geometry::BIND_PER_VERTEX));
 
-    if (mti < materialList.size())
-    {
-        pGeometry->getOrCreateStateSet()->setAttributeAndModes(materialList[mti].get());
-    }
-
-    if (mti < textureList.size())
-    {
-        pGeometry->getOrCreateStateSet()->setTextureAttributeAndModes(0, textureList[mti].get());
-    }
-
-    geometryMap.insert(std::pair<unsigned, osg::ref_ptr<osg::Geometry>>(mti, pGeometry));
+    if (mti < stateSetList.size())
+    {
+        const StateSetContent& ss = stateSetList[mti];
+        if(ss.first)
+            pGeometry->getOrCreateStateSet()->setAttributeAndModes(ss.first);
+        if(ss.second)
+            pGeometry->getOrCreateStateSet()->setTextureAttributeAndModes(0, ss.second);
+    }
+
+    geometryMap.insert(std::pair<unsigned, osg::ref_ptr<osg::Geometry> >(mti, pGeometry));
     pGeode->addDrawable(pGeometry.get());
 
@@ -196 +191 @@
 void addChannel(
     osgAnimation::Channel* pChannel,
-    osg::ref_ptr<osgAnimation::AnimationManagerBase> &pAnimManager,
+    osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimManager,
     const char* pTakeName)
 {
@@ -226 +221 @@
 }
 
-void readAnimation(KFbxNode* pNode, osg::Geode* pGeode,
+void readAnimation(KFbxNode* pNode, const std::string& targetName,
     osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimationManager,
     KFbxMesh* pMesh, int nShape)
@@ -234 +229 @@
         const char* pTakeName = pNode->GetTakeNodeName(i);
 
-        KFCurve* pCurve = pMesh->GetShapeChannel(nShape, true, pTakeName);
+        KFCurve* pCurve = pMesh->GetShapeChannel(nShape, false, pTakeName);
+        if (!pCurve)
+        {
+            continue;
+        }
+
+        int nKeys = pCurve->KeyGetCount();
+        if (!nKeys)
+        {
+            continue;
+        }
 
         osgAnimation::FloatLinearChannel* pChannel = new osgAnimation::FloatLinearChannel;
         std::vector<osgAnimation::TemplateKeyframe<float> >& keyFrameCntr = *pChannel->getOrCreateSampler()->getOrCreateKeyframeContainer();
-
-        int nKeys = pCurve->KeyGetCount();
-        if (!nKeys)
-        {
-            float fValue = static_cast<float>(pCurve->GetValue() * 0.01);
-            keyFrameCntr.push_back(osgAnimation::FloatKeyframe(0.0f,fValue));
-        }
 
         for (int k = 0; k < nKeys; ++k)
@@ -254 +252 @@
         }
 
-        pChannel->setTargetName(pGeode->getName());
-        pChannel->setName(pMesh->GetShapeName(nShape));
+        pChannel->setTargetName(targetName);
+        std::stringstream ss;
+        ss << nShape;
+        pChannel->setName(ss.str());
         addChannel(pChannel, pAnimationManager, pTakeName);
     }
@@ -262 +262 @@
 osgDB::ReaderWriter::ReadResult readMesh(KFbxNode* pNode, KFbxMesh* fbxMesh,
     osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimationManager,
-    const std::vector<osg::ref_ptr<osg::Material>>& materialList,
-    const std::vector<osg::ref_ptr<osg::Texture>>& textureList,
+    std::vector<StateSetContent>& stateSetList,
     const char* szName)
 {
@@ -321 +320 @@
 
         osg::Geometry* pGeometry = getGeometry(pGeode, geometryMap,
-            materialList, textureList, geomType, materialIndex,
+            stateSetList, geomType, materialIndex,
             pFbxNormals != 0, pFbxUVs != 0, pFbxColors != 0);
 
@@ -347 +346 @@
             fbxToOsgVertMap.insert(FbxToOsgVertexMap::value_type(v2, GIPair(pGeometry, pVertices->size() + 2)));
 
-
             pVertices->push_back(convertVec3(pFbxVertices[v0]));
             pVertices->push_back(convertVec3(pFbxVertices[v1]));
@@ -386 +384 @@
     {
         osg::Geometry* pGeometry = pGeode->getDrawable(i)->asGeometry();
-        pGeometry->setName(pGeode->getName());
+        if (pGeode->getNumDrawables() > 1)
+        {
+            std::stringstream ss;
+            ss << pGeode->getName() << " " << i + 1;
+            pGeometry->setName(ss.str());
+        }
+        else
+        {
+            pGeometry->setName(pGeode->getName());
+        }
 
         osg::DrawArrays* pDrawArrays = new osg::DrawArrays(
@@ -395 +402 @@
     if (geomType == GEOMETRY_RIG)
     {
+        typedef std::map<osg::ref_ptr<osg::Geometry>,
+            osg::ref_ptr<osgAnimation::RigGeometry> > GeometryRigGeometryMap;
+        GeometryRigGeometryMap old2newGeometryMap;
+
+        for (int i = 0; i < pGeode->getNumDrawables(); ++i)
+        {
+            osg::Geometry* pGeometry = pGeode->getDrawable(i)->asGeometry();
+            osgAnimation::RigGeometry* pRig = new osgAnimation::RigGeometry;
+            pRig->setSourceGeometry(pGeometry);
+            pRig->copyFrom(*pGeometry);
+            old2newGeometryMap.insert(GeometryRigGeometryMap::value_type(
+                pGeometry, pRig));
+            pRig->setDataVariance(osg::Object::DYNAMIC);
+            pRig->setUseDisplayList( false );
+            pGeode->setDrawable(i, pRig);
+
+            pRig->setInfluenceMap(new osgAnimation::VertexInfluenceMap);
+            pGeometry = pRig;
+        }
+
         for (int i = 0; i < nDeformerCount; ++i)
         {
@@ -419 +446 @@
                     {
                         GIPair gi = it->second;
-                        osgAnimation::RigGeometry& rig = dynamic_cast<osgAnimation::RigGeometry&>(*gi.first);
-                        osgAnimation::VertexInfluenceMap& vim = *rig.getInfluenceMap();
-                        osgAnimation::VertexInfluence& vi = getVertexInfluence(vim, pBone->GetName());
+                        osgAnimation::RigGeometry& rig =
+                            dynamic_cast<osgAnimation::RigGeometry&>(
+                            *old2newGeometryMap[gi.first]);
+                        osgAnimation::VertexInfluenceMap& vim =
+                            *rig.getInfluenceMap();
+                        osgAnimation::VertexInfluence& vi =
+                            getVertexInfluence(vim, pBone->GetName());
                         vi.push_back(osgAnimation::VertexIndexWeight(
                             gi.second, weight));
@@ -431 +462 @@
     else if (geomType == GEOMETRY_MORPH)
     {
-        pGeode->addUpdateCallback(new osgAnimation::UpdateMorph(pGeode->getName()));
-
-
         for (int i = 0; i < pGeode->getNumDrawables(); ++i)
         {
@@ -439 +467 @@
 
             osgAnimation::MorphGeometry& morph = dynamic_cast<osgAnimation::MorphGeometry&>(*pGeometry);
+
+            pGeode->addUpdateCallback(new osgAnimation::UpdateMorph(morph.getName()));
 
             //read morph geometry
@@ -464 +494 @@
                 }
                 pMorphTarget->setName(fbxMesh->GetShapeName(j));
-                KFCurve* pCurve = fbxMesh->GetShapeChannel(j);
-                double defaultWeight = pCurve->GetValue() * 0.01;
-                morph.addMorphTarget(pMorphTarget, static_cast<float>(defaultWeight));
-
-                readAnimation(pNode, pGeode, pAnimationManager, fbxMesh, j);
+                morph.addMorphTarget(pMorphTarget, 0.0f);
+
+                readAnimation(pNode, morph.getName(), pAnimationManager, fbxMesh, j);
             }
         }
@@ -535 +563 @@
 osgDB::ReaderWriter::ReadResult readFbxMesh(KFbxNode* pNode,
     osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimationManager,
-    const std::vector<osg::ref_ptr<osg::Material>>& materialList,
-    const std::vector<osg::ref_ptr<osg::Texture>>& textureList)
+    std::vector<StateSetContent>& stateSetList)
 {
     KFbxMesh* lMesh = dynamic_cast<KFbxMesh*>(pNode->GetNodeAttribute());
@@ -545 +572 @@
     }
 
-    return readMesh(pNode, lMesh, pAnimationManager, materialList, textureList, pNode->GetName());
-}
+    return readMesh(pNode, lMesh, pAnimationManager, stateSetList, pNode->GetName());
+}

OpenSceneGraph/trunk/src/osgPlugins/fbx/fbxRMesh.h

@@ -5 +5 @@
 #include <osgDB/ReaderWriter>
 #include <osg/Material>
-
+#include "fbxMaterialToOsgStateSet.h"
 osgDB::ReaderWriter::ReadResult readFbxMesh(
     FBXFILESDK_NAMESPACE::KFbxNode* pNode,
     osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimationManager,
-    const std::vector<osg::ref_ptr<osg::Material>>&,
-    const std::vector<osg::ref_ptr<osg::Texture>>&);
+    std::vector<StateSetContent> &);
 
 #endif

OpenSceneGraph/trunk/src/osgPlugins/fbx/fbxRNode.cpp

@@ +1 @@
+#include <cassert>
 #include <memory>
-
+#include <sstream>
+
+#include <osg/io_utils>
 #include <osg/Notify>
 #include <osg/MatrixTransform>
@@ -10 +13 @@
 
 #include <osgAnimation/AnimationManagerBase>
+#include <osgAnimation/Bone>
 #include <osgAnimation/Skeleton>
-#include <osgAnimation/UpdateCallback>
+#include <osgAnimation/StackedMatrixElement>
+#include <osgAnimation/StackedQuaternionElement>
+#include <osgAnimation/StackedScaleElement>
+#include <osgAnimation/StackedTranslateElement>
+#include <osgAnimation/UpdateBone>
 
 #if defined(_MSC_VER)
@@ -22 +30 @@
 #include "fbxRLight.h"
 #include "fbxRMesh.h"
-
-template <typename FbxT, typename OsgT, typename ConvertFunc>
-class FbxToOsgMap
-{
-    std::map<const FbxT*, osg::ref_ptr<OsgT>> m_map;
-public:
-    ConvertFunc m_convertFunc;
-
-    FbxToOsgMap(ConvertFunc convertFunc) : m_convertFunc(convertFunc) {}
-
-    osg::ref_ptr<OsgT> Get(const FbxT* fbx)
-    {
-        if (!fbx)
-            return 0;
-        std::map<const FbxT*, osg::ref_ptr<OsgT>>::iterator it = m_map.find(fbx);
-        if (it != m_map.end())
-        {
-            return it->second;
-        }
-        osg::ref_ptr<OsgT> osgObj = m_convertFunc(fbx);
-        m_map.insert(std::pair<const FbxT*, osg::ref_ptr<OsgT>>(fbx, osgObj));
-        return osgObj;
-    }
-};
-
-struct GetOsgTexture
-{
-    const std::string& m_dir;
-
-    GetOsgTexture(const std::string& dir) : m_dir(dir) {}
-
-    static osg::Texture::WrapMode convertWrap(KFbxTexture::EWrapMode wrap)
-    {
-        return wrap == KFbxTexture::eREPEAT ?
-            osg::Texture2D::REPEAT : osg::Texture2D::CLAMP_TO_EDGE;
-    }
-
-    osg::ref_ptr<osg::Texture2D> operator () (const KFbxTexture* fbx)
-    {
-        osg::Image* pImage;
-        if ((pImage = osgDB::readImageFile(osgDB::concatPaths(m_dir, fbx->GetRelativeFileName()))) ||
-            (pImage = osgDB::readImageFile(osgDB::concatPaths(m_dir, fbx->GetFileName()))))
-        {
-            osg::ref_ptr<osg::Texture2D> pOsgTex = new osg::Texture2D;
-
-            pOsgTex->setImage(pImage);
-            pOsgTex->setWrap(osg::Texture2D::WRAP_S, convertWrap(fbx->GetWrapModeU()));
-            pOsgTex->setWrap(osg::Texture2D::WRAP_T, convertWrap(fbx->GetWrapModeV()));
-
-            return pOsgTex;
-        }
-        else
-        {
-            return 0;
-        }
-    }
-};
-
-struct GetOsgMaterial
-{
-    typedef FbxToOsgMap<KFbxTexture, osg::Texture2D, GetOsgTexture> TextureMap;
-    TextureMap m_textureMap;
-
-public:
-    osg::ref_ptr<osg::Texture2D> m_pTexture;
-
-    GetOsgMaterial(const std::string& dir) : m_textureMap(GetOsgTexture(dir)){}
-
-    osg::ref_ptr<osg::Material> operator () (const KFbxSurfaceMaterial* pFbxMat)
-    {
-        osg::ref_ptr<osg::Material> pOsgMat = new osg::Material;
-
-        const KFbxSurfaceLambert* pFbxLambert = dynamic_cast<const KFbxSurfaceLambert*>(pFbxMat);
-
-        const KFbxProperty lProperty = pFbxMat->FindProperty(KFbxSurfaceMaterial::sDiffuse);
-        if(lProperty.IsValid()){
-            int lNbTex = lProperty.GetSrcObjectCount(KFbxTexture::ClassId);
-            for (int lTextureIndex = 0; lTextureIndex < lNbTex; lTextureIndex++)
-            {
-                const KFbxTexture* lTexture = KFbxCast<KFbxTexture>(lProperty.GetSrcObject(KFbxTexture::ClassId, lTextureIndex)); 
-                if(lTexture)
-                {
-                    m_pTexture = m_textureMap.Get(lTexture);
-                }
-
-                //For now only allow 1 texture
-                break;
-            }
-        }
-
-        if (pFbxLambert)
-        {
-            fbxDouble3 color = pFbxLambert->GetDiffuseColor().Get();
-            double factor = pFbxLambert->GetDiffuseFactor().Get();
-            pOsgMat->setDiffuse(osg::Material::FRONT_AND_BACK, osg::Vec4(
-                static_cast<float>(color[0] * factor),
-                static_cast<float>(color[1] * factor),
-                static_cast<float>(color[2] * factor),
-                static_cast<float>(1.0 - pFbxLambert->GetTransparencyFactor().Get())));
-
-            color = pFbxLambert->GetAmbientColor().Get();
-            factor = pFbxLambert->GetAmbientFactor().Get();
-            pOsgMat->setAmbient(osg::Material::FRONT_AND_BACK, osg::Vec4(
-                static_cast<float>(color[0] * factor),
-                static_cast<float>(color[1] * factor),
-                static_cast<float>(color[2] * factor),
-                1.0f));
-
-            color = pFbxLambert->GetEmissiveColor().Get();
-            factor = pFbxLambert->GetEmissiveFactor().Get();
-            pOsgMat->setEmission(osg::Material::FRONT_AND_BACK, osg::Vec4(
-                static_cast<float>(color[0] * factor),
-                static_cast<float>(color[1] * factor),
-                static_cast<float>(color[2] * factor),
-                1.0f));
-
-            if (const KFbxSurfacePhong* pFbxPhong = dynamic_cast<const KFbxSurfacePhong*>(pFbxLambert))
-            {
-                color = pFbxPhong->GetSpecularColor().Get();
-                factor = pFbxPhong->GetSpecularFactor().Get();
-                pOsgMat->setSpecular(osg::Material::FRONT_AND_BACK, osg::Vec4(
-                    static_cast<float>(color[0] * factor),
-                    static_cast<float>(color[1] * factor),
-                    static_cast<float>(color[2] * factor),
-                    1.0f));
-
-                pOsgMat->setShininess(osg::Material::FRONT_AND_BACK,
-                    static_cast<float>(pFbxPhong->GetShininess().Get()));
-            }
-        }
-
-        return pOsgMat;
-    }
-};
+#include "fbxRNode.h"
+#include "fbxMaterialToOsgStateSet.h"
 
 osg::Quat makeQuat(const fbxDouble3& degrees, ERotationOrder fbxRotOrder)
@@ -260 +136 @@
 }
 
-void getApproximateTransform(const KFbxNode* pNode, osg::Vec3& trans, osg::Quat& quat, osg::Vec3& scale)
-{
-    ERotationOrder fbxRotOrder = pNode->RotationOrder.Get();
-
-    fbxDouble3 fbxLclPos = pNode->LclTranslation.Get();
-    //fbxDouble3 fbxRotOff = pNode->RotationOffset.Get();
-    //fbxDouble3 fbxRotPiv = pNode->RotationPivot.Get();
-    fbxDouble3 fbxPreRot = pNode->PreRotation.Get();
-    fbxDouble3 fbxLclRot = pNode->LclRotation.Get();
-    fbxDouble3 fbxPostRot = pNode->PostRotation.Get();
-    //fbxDouble3 fbxSclOff = pNode->ScalingOffset.Get();
-    //fbxDouble3 fbxSclPiv = pNode->ScalingPivot.Get();
-    fbxDouble3 fbxLclScl = pNode->LclScaling.Get();
-
-    trans.set(
-        static_cast<float>(fbxLclPos[0]),
-        static_cast<float>(fbxLclPos[1]),
-        static_cast<float>(fbxLclPos[2]));
-
-    quat =
-        makeQuat(fbxPostRot, fbxRotOrder) *
-        makeQuat(fbxLclRot, fbxRotOrder) *
-        makeQuat(fbxPreRot, fbxRotOrder);
-
-    scale.set(
-        static_cast<float>(fbxLclScl[0]),
-        static_cast<float>(fbxLclScl[1]),
-        static_cast<float>(fbxLclScl[2]));
-}
-
-void getApproximateTransform(const KFbxNode* pNode, osg::Vec3& trans, osg::Vec3& euler, osg::Vec3& scale)
-{
-    //ERotationOrder fbxRotOrder = pNode->RotationOrder.Get();
-
-    fbxDouble3 fbxLclPos = pNode->LclTranslation.Get();
-    //fbxDouble3 fbxRotOff = pNode->RotationOffset.Get();
-    //fbxDouble3 fbxRotPiv = pNode->RotationPivot.Get();
-    fbxDouble3 fbxPreRot = pNode->PreRotation.Get();
-    fbxDouble3 fbxLclRot = pNode->LclRotation.Get();
-    fbxDouble3 fbxPostRot = pNode->PostRotation.Get();
-    //fbxDouble3 fbxSclOff = pNode->ScalingOffset.Get();
-    //fbxDouble3 fbxSclPiv = pNode->ScalingPivot.Get();
-    fbxDouble3 fbxLclScl = pNode->LclScaling.Get();
-
-    trans.set(
-        static_cast<float>(fbxLclPos[0]),
-        static_cast<float>(fbxLclPos[1]),
-        static_cast<float>(fbxLclPos[2]));
-
-    //TODO: Convert each rotation to a quaternion, concatenate them and extract euler from that.
-    euler.set(
-        osg::DegreesToRadians(static_cast<float>(fbxPreRot[0] + fbxLclRot[0] + fbxPostRot[0])),
-        osg::DegreesToRadians(static_cast<float>(fbxPreRot[1] + fbxLclRot[1] + fbxPostRot[1])),
-        osg::DegreesToRadians(static_cast<float>(fbxPreRot[2] + fbxLclRot[2] + fbxPostRot[2])));
-
-    scale.set(
-        static_cast<float>(fbxLclScl[0]),
-        static_cast<float>(fbxLclScl[1]),
-        static_cast<float>(fbxLclScl[2]));
-}
-
 bool readBindPose(KFbxSdkManager& pManager, KFbxNode* pNode,
-    osgAnimation::Bone* osgBone)
+                  osgAnimation::Bone* osgBone)
 {
     KArrayTemplate<KFbxPose*> pPoseList;
@@ -333 +148 @@
 
     const double* pMat = pPoseList[0]->GetMatrix(pIndex[0]);
-    osgBone->setBindMatrixInBoneSpace(osg::Matrix(pMat));
+    osgBone->setMatrix(osg::Matrix(pMat));
     return true;
+}
+
+void readTranslationElement(KFbxTypedProperty<fbxDouble3>& prop,
+                            osgAnimation::UpdateMatrixTransform* pUpdate,
+                            osg::Matrix& staticTransform)
+{
+    fbxDouble3 fbxPropValue = prop.Get();
+    osg::Vec3d val(
+        fbxPropValue[0],
+        fbxPropValue[1],
+        fbxPropValue[2]);
+
+    if (prop.GetKFCurve(KFCURVENODE_T_X) ||
+        prop.GetKFCurve(KFCURVENODE_T_Y) ||
+        prop.GetKFCurve(KFCURVENODE_T_Z))
+    {
+        if (!staticTransform.isIdentity())
+        {
+            pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedMatrixElement(staticTransform));
+            staticTransform.makeIdentity();
+        }
+        pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedTranslateElement("translate", val));
+    }
+    else
+    {
+        staticTransform.preMultTranslate(val);
+    }
+}
+
+void readRotationElement(KFbxTypedProperty<fbxDouble3>& prop,
+                         ERotationOrder fbxRotOrder,
+                         osgAnimation::UpdateMatrixTransform* pUpdate,
+                         osg::Matrix& staticTransform)
+{
+    osg::Quat quat = makeQuat(prop.Get(), fbxRotOrder);
+
+    if (prop.GetKFCurve(KFCURVENODE_R_X) ||
+        prop.GetKFCurve(KFCURVENODE_R_Y) ||
+        prop.GetKFCurve(KFCURVENODE_R_Z))
+    {
+        if (!staticTransform.isIdentity())
+        {
+            pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedMatrixElement(staticTransform));
+            staticTransform.makeIdentity();
+        }
+        pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedQuaternionElement("quaternion", quat));
+    }
+    else
+    {
+        staticTransform.preMultRotate(quat);
+    }
+}
+
+void readScaleElement(KFbxTypedProperty<fbxDouble3>& prop,
+                      osgAnimation::UpdateMatrixTransform* pUpdate,
+                      osg::Matrix& staticTransform)
+{
+    fbxDouble3 fbxPropValue = prop.Get();
+    osg::Vec3d val(
+        fbxPropValue[0],
+        fbxPropValue[1],
+        fbxPropValue[2]);
+
+    if (prop.GetKFCurve(KFCURVENODE_S_X) ||
+        prop.GetKFCurve(KFCURVENODE_S_Y) ||
+        prop.GetKFCurve(KFCURVENODE_S_Z))
+    {
+        if (!staticTransform.isIdentity())
+        {
+            pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedMatrixElement(staticTransform));
+            staticTransform.makeIdentity();
+        }
+        pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedScaleElement("scale", val));
+    }
+    else
+    {
+        staticTransform.preMultScale(val);
+    }
+}
+
+void readUpdateMatrixTransform(osgAnimation::UpdateMatrixTransform* pUpdate, KFbxNode* pNode)
+{
+    osg::Matrix staticTransform;
+
+    readTranslationElement(pNode->LclTranslation, pUpdate, staticTransform);
+
+    fbxDouble3 fbxRotOffset = pNode->RotationOffset.Get();
+    fbxDouble3 fbxRotPiv = pNode->RotationPivot.Get();
+    staticTransform.preMultTranslate(osg::Vec3d(
+        fbxRotPiv[0] + fbxRotOffset[0],
+        fbxRotPiv[1] + fbxRotOffset[1],
+        fbxRotPiv[2] + fbxRotOffset[2]));
+
+    ERotationOrder fbxRotOrder = pNode->RotationOrder.IsValid() ? pNode->RotationOrder.Get() : eEULER_XYZ;
+
+    staticTransform.preMultRotate(makeQuat(pNode->PreRotation.Get(), fbxRotOrder));
+
+    readRotationElement(pNode->LclRotation, fbxRotOrder, pUpdate, staticTransform);
+
+    staticTransform.preMultRotate(makeQuat(pNode->PostRotation.Get(), fbxRotOrder));
+
+    fbxDouble3 fbxSclOffset = pNode->ScalingOffset.Get();
+    fbxDouble3 fbxSclPiv = pNode->ScalingPivot.Get();
+    staticTransform.preMultTranslate(osg::Vec3d(
+        fbxSclOffset[0] + fbxSclPiv[0] - fbxRotPiv[0],
+        fbxSclOffset[1] + fbxSclPiv[1] - fbxRotPiv[1],
+        fbxSclOffset[2] + fbxSclPiv[2] - fbxRotPiv[2]));
+
+    readScaleElement(pNode->LclScaling, pUpdate, staticTransform);
+
+    staticTransform.preMultTranslate(osg::Vec3d(
+        -fbxSclPiv[0],
+        -fbxSclPiv[1],
+        -fbxSclPiv[2]));
+
+    if (!staticTransform.isIdentity())
+    {
+        pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedMatrixElement(staticTransform));
+    }
 }
 
@@ -345 +279 @@
         osgBone->setDataVariance(osg::Object::DYNAMIC);
         osgBone->setName(pNode->GetName());
-        osgBone->setDefaultUpdateCallback(animName);
+        osgAnimation::UpdateBone* pUpdate = new osgAnimation::UpdateBone(animName);
+        readUpdateMatrixTransform(pUpdate, pNode);
+        osgBone->setUpdateCallback(pUpdate);
 
         readBindPose(pSdkManager, pNode, osgBone);
@@ -363 +299 @@
         osg::MatrixTransform* pTransform = new osg::MatrixTransform(localMatrix);
         pTransform->setName(pNode->GetName());
+
         if (bAnimated)
         {
-            osgAnimation::UpdateTransform* pUpdate = new osgAnimation::UpdateTransform(animName);
-
-            osg::Vec3 trans, rot, scale;
-            getApproximateTransform(pNode, trans, rot, scale);
-
-            pUpdate->getPosition()->setValue(trans);
-            pUpdate->getEuler()->setValue(rot);
-            pUpdate->getScale()->setValue(scale);
+            osgAnimation::UpdateMatrixTransform* pUpdate = new osgAnimation::UpdateMatrixTransform(animName);
+            readUpdateMatrixTransform(pUpdate, pNode);
             pTransform->setUpdateCallback(pUpdate);
         }
+
         return pTransform;
     }
@@ -382 +314 @@
     KFbxSdkManager& pSdkManager, KFbxNode* pNode,
     osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimationManager,
-    const std::string& dir, bool& bNeedSkeleton, int& nLightCount)
+    bool& bNeedSkeleton, int& nLightCount,
+    FbxMaterialToOsgStateSet& fbxMaterialToOsgStateSet,
+    const osgDB::Options* options)
 {
     if (KFbxNodeAttribute* lNodeAttribute = pNode->GetNodeAttribute())
@@ -405 +339 @@
 
     unsigned nMaterials = pNode->GetMaterialCount();
-    std::vector<osg::ref_ptr<osg::Material>> materialList;
-    std::vector<osg::ref_ptr<osg::Texture>> textureList;
-    materialList.reserve(nMaterials);
-
-    typedef FbxToOsgMap<KFbxSurfaceMaterial, osg::Material, GetOsgMaterial> MaterialMap;
-    MaterialMap materialMap(dir);
+    std::vector<StateSetContent > stateSetList;
 
     for (unsigned i = 0; i < nMaterials; ++i)
     {
-        materialList.push_back(materialMap.Get(pNode->GetMaterial(i)));
-        textureList.push_back(materialMap.m_convertFunc.m_pTexture);
+        KFbxSurfaceMaterial* fbxMaterial = pNode->GetMaterial(i);
+        assert(fbxMaterial);
+        stateSetList.push_back(fbxMaterialToOsgStateSet.convert(fbxMaterial));
     }
 
@@ -433 +363 @@
         bool bChildNeedSkeleton = false;
         osgDB::ReaderWriter::ReadResult childResult = readFbxNode(
-            pSdkManager, pChildNode, pAnimationManager, dir,
-            bChildNeedSkeleton, nLightCount);
+            pSdkManager, pChildNode, pAnimationManager,
+            bChildNeedSkeleton, nLightCount, fbxMaterialToOsgStateSet, options);
         if (childResult.error())
         {
@@ -453 +383 @@
     }
 
-    std::string animName;
-    
-    if (bNeedSkeleton)
-    {
-        animName = readFbxBoneAnimation(pNode, pAnimationManager,
-            pNode->GetName());
-    }
-    else
-    {
-        animName = readFbxAnimation(pNode, pAnimationManager, pNode->GetName());
-    }
+    std::string animName = readFbxAnimation(pNode, pAnimationManager, pNode->GetName());
 
     osg::Matrix localMatrix;
@@ -476 +396 @@
     {
     case KFbxNodeAttribute::eUNIDENTIFIED:
-        if (children.size() + skeletal.size() == 1)
+        if (bLocalMatrixIdentity && children.size() + skeletal.size() == 1)
         {
             if (children.size() == 1)
@@ -491 +411 @@
         {
             osgDB::ReaderWriter::ReadResult meshRes = readFbxMesh(pNode,
-                pAnimationManager, materialList, textureList);
+                pAnimationManager, stateSetList);
             if (meshRes.error())
             {
@@ -507 +427 @@
                 }
                 osgGroup = createGroupNode(pSdkManager, pNode, animName, localMatrix, bNeedSkeleton);
+                assert(osgGroup->getStateSet() == NULL);
                 osgGroup->getOrCreateStateSet()->setMode(GL_RESCALE_NORMAL,osg::StateAttribute::ON);
 

OpenSceneGraph/trunk/src/osgPlugins/fbx/fbxRNode.h

@@ -2 +2 @@
 #define FBXRNODE_H
 
+#include "fbxMaterialToOsgStateSet.h"
 namespace osgAnimation
 {
@@ -11 +12 @@
     FBXFILESDK_NAMESPACE::KFbxNode* pNode,
     osg::ref_ptr<osgAnimation::AnimationManagerBase>& pAnimationManager,
-    const std::string& dir,
     bool& bNeedSkeleton,
-    int& nLightCount);
+    int& nLightCount,
+    FbxMaterialToOsgStateSet& fbxMaterialToOsgStateSet,
+    const osgDB::Options* options = NULL);
 
 #endif