root/OpenSceneGraph/trunk/src/osgPlugins/fbx/fbxRNode.cpp @ 13466

Revision 13466, 20.6 kB (checked in by robert, 10 days ago)

Added shaders to support experimental shader based displacement mapping technique osgTerrain::ShaderTerrain?.

  • Property svn:eol-style set to native
Line 
1#include <cassert>
2#include <memory>
3#include <sstream>
4
5#include <osg/io_utils>
6#include <osg/Notify>
7#include <osg/MatrixTransform>
8#include <osg/Material>
9#include <osg/Texture2D>
10
11#include <osgDB/FileNameUtils>
12#include <osgDB/ReadFile>
13
14#include <osgAnimation/AnimationManagerBase>
15#include <osgAnimation/Bone>
16#include <osgAnimation/Skeleton>
17#include <osgAnimation/StackedMatrixElement>
18#include <osgAnimation/StackedQuaternionElement>
19#include <osgAnimation/StackedRotateAxisElement>
20#include <osgAnimation/StackedScaleElement>
21#include <osgAnimation/StackedTranslateElement>
22#include <osgAnimation/UpdateBone>
23
24#if defined(_MSC_VER)
25    #pragma warning( disable : 4505 )
26    #pragma warning( default : 4996 )
27#endif
28#include <fbxsdk.h>
29
30#include "fbxReader.h"
31
32bool isAnimated(FbxProperty& prop, FbxScene& fbxScene)
33{
34    for (int i = 0; i < fbxScene.GetSrcObjectCount<FbxAnimStack>(); ++i)
35    {
36        FbxAnimStack* pAnimStack = FbxCast<FbxAnimStack>(fbxScene.GetSrcObject<FbxAnimStack>(i));
37
38        const int nbAnimLayers = pAnimStack->GetMemberCount<FbxAnimLayer>();
39        for (int j = 0; j < nbAnimLayers; j++)
40        {
41            FbxAnimLayer* pAnimLayer = pAnimStack->GetMember<FbxAnimLayer>(j);
42            if (prop.GetCurveNode(pAnimLayer, false))
43            {
44                return true;
45            }
46        }
47    }
48    return false;
49}
50
51bool isAnimated(FbxProperty& prop, const char* channel, FbxScene& fbxScene)
52{
53    for (int i = 0; i < fbxScene.GetSrcObjectCount<FbxAnimStack>(); ++i)
54    {
55        FbxAnimStack* pAnimStack = FbxCast<FbxAnimStack>(fbxScene.GetSrcObject<FbxAnimStack>(i));
56
57        const int nbAnimLayers = pAnimStack->GetMemberCount<FbxAnimLayer>();
58        for (int j = 0; j < nbAnimLayers; j++)
59        {
60            FbxAnimLayer* pAnimLayer = pAnimStack->GetMember<FbxAnimLayer>(j);
61            if (prop.GetCurve(pAnimLayer, channel, false))
62            {
63                return true;
64            }
65        }
66    }
67    return false;
68}
69
70osg::Quat makeQuat(const FbxDouble3& degrees, EFbxRotationOrder fbxRotOrder)
71{
72    double radiansX = osg::DegreesToRadians(degrees[0]);
73    double radiansY = osg::DegreesToRadians(degrees[1]);
74    double radiansZ = osg::DegreesToRadians(degrees[2]);
75
76    switch (fbxRotOrder)
77    {
78    case eEulerXYZ:
79        return osg::Quat(
80            radiansX, osg::Vec3d(1,0,0),
81            radiansY, osg::Vec3d(0,1,0),
82            radiansZ, osg::Vec3d(0,0,1));
83    case eEulerXZY:
84        return osg::Quat(
85            radiansX, osg::Vec3d(1,0,0),
86            radiansZ, osg::Vec3d(0,0,1),
87            radiansY, osg::Vec3d(0,1,0));
88    case eEulerYZX:
89        return osg::Quat(
90            radiansY, osg::Vec3d(0,1,0),
91            radiansZ, osg::Vec3d(0,0,1),
92            radiansX, osg::Vec3d(1,0,0));
93    case eEulerYXZ:
94        return osg::Quat(
95            radiansY, osg::Vec3d(0,1,0),
96            radiansX, osg::Vec3d(1,0,0),
97            radiansZ, osg::Vec3d(0,0,1));
98    case eEulerZXY:
99        return osg::Quat(
100            radiansZ, osg::Vec3d(0,0,1),
101            radiansX, osg::Vec3d(1,0,0),
102            radiansY, osg::Vec3d(0,1,0));
103    case eEulerZYX:
104        return osg::Quat(
105            radiansZ, osg::Vec3d(0,0,1),
106            radiansY, osg::Vec3d(0,1,0),
107            radiansX, osg::Vec3d(1,0,0));
108    case eSphericXYZ:
109        {
110            //I don't know what eSPHERIC_XYZ means, so this is a complete guess.
111            osg::Quat quat;
112            quat.makeRotate(osg::Vec3d(1.0, 0.0, 0.0), osg::Vec3d(degrees[0], degrees[1], degrees[2]));
113            return quat;
114        }
115    default:
116        OSG_WARN << "Invalid FBX rotation mode." << std::endl;
117        return osg::Quat();
118    }
119}
120
121void makeLocalMatrix(const FbxNode* pNode, osg::Matrix& m)
122{
123    /*From http://area.autodesk.com/forum/autodesk-fbx/fbx-sdk/the-makeup-of-the-local-matrix-of-an-kfbxnode/
124
125    Local Matrix = LclTranslation * RotationOffset * RotationPivot *
126      PreRotation * LclRotation * PostRotation * RotationPivotInverse *
127      ScalingOffset * ScalingPivot * LclScaling * ScalingPivotInverse
128
129    LocalTranslation : translate (xform -query -translation)
130    RotationOffset: translation compensates for the change in the rotate pivot point (xform -q -rotateTranslation)
131    RotationPivot: current rotate pivot position (xform -q -rotatePivot)
132    PreRotation : joint orientation(pre rotation)
133    LocalRotation: rotate transform (xform -q -rotation & xform -q -rotateOrder)
134    PostRotation : rotate axis (xform -q -rotateAxis)
135    RotationPivotInverse: inverse of RotationPivot
136    ScalingOffset: translation compensates for the change in the scale pivot point (xform -q -scaleTranslation)
137    ScalingPivot: current scale pivot position (xform -q -scalePivot)
138    LocalScaling: scale transform (xform -q -scale)
139    ScalingPivotInverse: inverse of ScalingPivot
140    */
141
142    // When this flag is set to false, the RotationOrder, the Pre/Post rotation
143    // values and the rotation limits should be ignored.
144    bool rotationActive = pNode->RotationActive.Get();
145
146    EFbxRotationOrder fbxRotOrder = rotationActive ? pNode->RotationOrder.Get() : eEulerXYZ;
147
148    FbxDouble3 fbxLclPos = pNode->LclTranslation.Get();
149    FbxDouble3 fbxRotOff = pNode->RotationOffset.Get();
150    FbxDouble3 fbxRotPiv = pNode->RotationPivot.Get();
151    FbxDouble3 fbxPreRot = pNode->PreRotation.Get();
152    FbxDouble3 fbxLclRot = pNode->LclRotation.Get();
153    FbxDouble3 fbxPostRot = pNode->PostRotation.Get();
154    FbxDouble3 fbxSclOff = pNode->ScalingOffset.Get();
155    FbxDouble3 fbxSclPiv = pNode->ScalingPivot.Get();
156    FbxDouble3 fbxLclScl = pNode->LclScaling.Get();
157
158    m.makeTranslate(osg::Vec3d(
159        fbxLclPos[0] + fbxRotOff[0] + fbxRotPiv[0],
160        fbxLclPos[1] + fbxRotOff[1] + fbxRotPiv[1],
161        fbxLclPos[2] + fbxRotOff[2] + fbxRotPiv[2]));
162    if (rotationActive)
163    {
164        m.preMultRotate(
165            makeQuat(fbxPostRot, fbxRotOrder) *
166            makeQuat(fbxLclRot, fbxRotOrder) *
167            makeQuat(fbxPreRot, fbxRotOrder));
168    }
169    else
170    {
171        m.preMultRotate(makeQuat(fbxLclRot, fbxRotOrder));
172    }
173    m.preMultTranslate(osg::Vec3d(
174        fbxSclOff[0] + fbxSclPiv[0] - fbxRotPiv[0],
175        fbxSclOff[1] + fbxSclPiv[1] - fbxRotPiv[1],
176        fbxSclOff[2] + fbxSclPiv[2] - fbxRotPiv[2]));
177    m.preMultScale(osg::Vec3d(fbxLclScl[0], fbxLclScl[1], fbxLclScl[2]));
178    m.preMultTranslate(osg::Vec3d(
179        -fbxSclPiv[0],
180        -fbxSclPiv[1],
181        -fbxSclPiv[2]));
182}
183
184void readTranslationElement(FbxPropertyT<FbxDouble3>& prop,
185                            osgAnimation::UpdateMatrixTransform* pUpdate,
186                            osg::Matrix& staticTransform,
187                            FbxScene& fbxScene)
188{
189    FbxDouble3 fbxPropValue = prop.Get();
190    osg::Vec3d val(
191        fbxPropValue[0],
192        fbxPropValue[1],
193        fbxPropValue[2]);
194
195    if (isAnimated(prop, fbxScene))
196    {
197        if (!staticTransform.isIdentity())
198        {
199            pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedMatrixElement(staticTransform));
200            staticTransform.makeIdentity();
201        }
202        pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedTranslateElement("translate", val));
203    }
204    else
205    {
206        staticTransform.preMultTranslate(val);
207    }
208}
209
210void getRotationOrder(EFbxRotationOrder fbxRotOrder, int order[/*3*/])
211{
212    switch (fbxRotOrder)
213    {
214    case eEulerXZY:
215        order[0] = 0; order[1] = 2; order[2] = 1;
216        break;
217    case eEulerYZX:
218        order[0] = 1; order[1] = 2; order[2] = 0;
219        break;
220    case eEulerYXZ:
221        order[0] = 1; order[1] = 0; order[2] = 2;
222        break;
223    case eEulerZXY:
224        order[0] = 2; order[1] = 0; order[2] = 1;
225        break;
226    case eEulerZYX:
227        order[0] = 2; order[1] = 1; order[2] = 0;
228        break;
229    default:
230        order[0] = 0; order[1] = 1; order[2] = 2;
231    }
232}
233
234void readRotationElement(FbxPropertyT<FbxDouble3>& prop,
235                         EFbxRotationOrder fbxRotOrder,
236                         bool quatInterpolate,
237                         osgAnimation::UpdateMatrixTransform* pUpdate,
238                         osg::Matrix& staticTransform,
239                         FbxScene& fbxScene)
240{
241    if (isAnimated(prop, fbxScene))
242    {
243        if (quatInterpolate)
244        {
245            if (!staticTransform.isIdentity())
246            {
247                pUpdate->getStackedTransforms().push_back(
248                    new osgAnimation::StackedMatrixElement(staticTransform));
249                staticTransform.makeIdentity();
250            }
251            pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedQuaternionElement(
252                "quaternion", makeQuat(prop.Get(), fbxRotOrder)));
253        }
254        else
255        {
256            const char* curveNames[3] = {FBXSDK_CURVENODE_COMPONENT_X, FBXSDK_CURVENODE_COMPONENT_Y, FBXSDK_CURVENODE_COMPONENT_Z};
257            osg::Vec3 axes[3] = {osg::Vec3(1,0,0), osg::Vec3(0,1,0), osg::Vec3(0,0,1)};
258
259            FbxDouble3 fbxPropValue = prop.Get();
260            fbxPropValue[0] = osg::DegreesToRadians(fbxPropValue[0]);
261            fbxPropValue[1] = osg::DegreesToRadians(fbxPropValue[1]);
262            fbxPropValue[2] = osg::DegreesToRadians(fbxPropValue[2]);
263
264            int order[3] = {0, 1, 2};
265            getRotationOrder(fbxRotOrder, order);
266
267            for (int i = 0; i < 3; ++i)
268            {
269                int j = order[2-i];
270                if (isAnimated(prop, curveNames[j], fbxScene))
271                {
272                    if (!staticTransform.isIdentity())
273                    {
274                        pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedMatrixElement(staticTransform));
275                        staticTransform.makeIdentity();
276                    }
277
278                    pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedRotateAxisElement(
279                        std::string("rotate") + curveNames[j], axes[j], fbxPropValue[j]));
280                }
281                else
282                {
283                    staticTransform.preMultRotate(osg::Quat(fbxPropValue[j], axes[j]));
284                }
285            }
286        }
287    }
288    else
289    {
290        staticTransform.preMultRotate(makeQuat(prop.Get(), fbxRotOrder));
291    }
292}
293
294void readScaleElement(FbxPropertyT<FbxDouble3>& prop,
295                      osgAnimation::UpdateMatrixTransform* pUpdate,
296                      osg::Matrix& staticTransform,
297                      FbxScene& fbxScene)
298{
299    FbxDouble3 fbxPropValue = prop.Get();
300    osg::Vec3d val(
301        fbxPropValue[0],
302        fbxPropValue[1],
303        fbxPropValue[2]);
304
305    if (isAnimated(prop, fbxScene))
306    {
307        if (!staticTransform.isIdentity())
308        {
309            pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedMatrixElement(staticTransform));
310            staticTransform.makeIdentity();
311        }
312        pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedScaleElement("scale", val));
313    }
314    else
315    {
316        staticTransform.preMultScale(val);
317    }
318}
319
320void readUpdateMatrixTransform(osgAnimation::UpdateMatrixTransform* pUpdate, FbxNode* pNode, FbxScene& fbxScene)
321{
322    osg::Matrix staticTransform;
323
324    readTranslationElement(pNode->LclTranslation, pUpdate, staticTransform, fbxScene);
325
326    FbxDouble3 fbxRotOffset = pNode->RotationOffset.Get();
327    FbxDouble3 fbxRotPiv = pNode->RotationPivot.Get();
328    staticTransform.preMultTranslate(osg::Vec3d(
329        fbxRotPiv[0] + fbxRotOffset[0],
330        fbxRotPiv[1] + fbxRotOffset[1],
331        fbxRotPiv[2] + fbxRotOffset[2]));
332
333    // When this flag is set to false, the RotationOrder, the Pre/Post rotation
334    // values and the rotation limits should be ignored.
335    bool rotationActive = pNode->RotationActive.Get();
336
337    EFbxRotationOrder fbxRotOrder = (rotationActive && pNode->RotationOrder.IsValid()) ?
338        pNode->RotationOrder.Get() : eEulerXYZ;
339
340    if (rotationActive)
341    {
342        staticTransform.preMultRotate(makeQuat(pNode->PreRotation.Get(), fbxRotOrder));
343    }
344
345    readRotationElement(pNode->LclRotation, fbxRotOrder,
346        pNode->QuaternionInterpolate.IsValid() && pNode->QuaternionInterpolate.Get(),
347        pUpdate, staticTransform, fbxScene);
348
349    if (rotationActive)
350    {
351        staticTransform.preMultRotate(makeQuat(pNode->PostRotation.Get(), fbxRotOrder));
352    }
353
354    FbxDouble3 fbxSclOffset = pNode->ScalingOffset.Get();
355    FbxDouble3 fbxSclPiv = pNode->ScalingPivot.Get();
356    staticTransform.preMultTranslate(osg::Vec3d(
357        fbxSclOffset[0] + fbxSclPiv[0] - fbxRotPiv[0],
358        fbxSclOffset[1] + fbxSclPiv[1] - fbxRotPiv[1],
359        fbxSclOffset[2] + fbxSclPiv[2] - fbxRotPiv[2]));
360
361    readScaleElement(pNode->LclScaling, pUpdate, staticTransform, fbxScene);
362
363    staticTransform.preMultTranslate(osg::Vec3d(
364        -fbxSclPiv[0],
365        -fbxSclPiv[1],
366        -fbxSclPiv[2]));
367
368    if (!staticTransform.isIdentity())
369    {
370        pUpdate->getStackedTransforms().push_back(new osgAnimation::StackedMatrixElement(staticTransform));
371    }
372}
373
374osg::Group* createGroupNode(FbxManager& pSdkManager, FbxNode* pNode,
375    const std::string& animName, const osg::Matrix& localMatrix, bool bNeedSkeleton,
376    std::map<FbxNode*, osg::Node*>& nodeMap, FbxScene& fbxScene)
377{
378    if (bNeedSkeleton)
379    {
380        osgAnimation::Bone* osgBone = new osgAnimation::Bone;
381        osgBone->setDataVariance(osg::Object::DYNAMIC);
382        osgBone->setName(pNode->GetName());
383        osgAnimation::UpdateBone* pUpdate = new osgAnimation::UpdateBone(animName);
384        readUpdateMatrixTransform(pUpdate, pNode, fbxScene);
385        osgBone->setUpdateCallback(pUpdate);
386
387        nodeMap.insert(std::pair<FbxNode*, osg::Node*>(pNode, osgBone));
388
389        return osgBone;
390    }
391    else
392    {
393        bool bAnimated = !animName.empty();
394        if (!bAnimated && localMatrix.isIdentity())
395        {
396            osg::Group* pGroup = new osg::Group;
397            pGroup->setName(pNode->GetName());
398            return pGroup;
399        }
400
401        osg::MatrixTransform* pTransform = new osg::MatrixTransform(localMatrix);
402        pTransform->setName(pNode->GetName());
403
404        if (bAnimated)
405        {
406            osgAnimation::UpdateMatrixTransform* pUpdate = new osgAnimation::UpdateMatrixTransform(animName);
407            readUpdateMatrixTransform(pUpdate, pNode, fbxScene);
408            pTransform->setUpdateCallback(pUpdate);
409        }
410
411        return pTransform;
412    }
413}
414
415osgDB::ReaderWriter::ReadResult OsgFbxReader::readFbxNode(
416    FbxNode* pNode,
417    bool& bIsBone, int& nLightCount)
418{
419    if (FbxNodeAttribute* lNodeAttribute = pNode->GetNodeAttribute())
420    {
421        FbxNodeAttribute::EType attrType = lNodeAttribute->GetAttributeType();
422        switch (attrType)
423        {
424        case FbxNodeAttribute::eNurbs:
425        case FbxNodeAttribute::ePatch:
426        case FbxNodeAttribute::eNurbsCurve:
427        case FbxNodeAttribute::eNurbsSurface:
428            {
429                FbxGeometryConverter lConverter(&pSdkManager);
430#if FBXSDK_VERSION_MAJOR < 2014
431                if (!lConverter.TriangulateInPlace(pNode))
432#else
433                if (!lConverter.Triangulate(lNodeAttribute,true,false))
434#endif
435                {
436                    OSG_WARN << "Unable to triangulate FBX NURBS " << pNode->GetName() << std::endl;
437                }
438            }
439            break;
440        default:
441            break;
442        }
443    }
444
445    bIsBone = false;
446    bool bCreateSkeleton = false;
447
448    FbxNodeAttribute::EType lAttributeType = FbxNodeAttribute::eUnknown;
449    if (pNode->GetNodeAttribute())
450    {
451        lAttributeType = pNode->GetNodeAttribute()->GetAttributeType();
452        if (lAttributeType == FbxNodeAttribute::eSkeleton)
453        {
454            bIsBone = true;
455        }
456    }
457
458    if (!bIsBone && fbxSkeletons.find(pNode) != fbxSkeletons.end())
459    {
460        bIsBone = true;
461    }
462
463    unsigned nMaterials = pNode->GetMaterialCount();
464    std::vector<StateSetContent > stateSetList;
465
466    for (unsigned i = 0; i < nMaterials; ++i)
467    {
468        FbxSurfaceMaterial* fbxMaterial = pNode->GetMaterial(i);
469        assert(fbxMaterial);
470        stateSetList.push_back(fbxMaterialToOsgStateSet.convert(fbxMaterial));
471    }
472
473    osg::NodeList skeletal, children;
474
475    int nChildCount = pNode->GetChildCount();
476    for (int i = 0; i < nChildCount; ++i)
477    {
478        FbxNode* pChildNode = pNode->GetChild(i);
479
480        if (pChildNode->GetParent() != pNode)
481        {
482            //workaround for bug that occurs in some files exported from Blender
483            continue;
484        }
485
486        bool bChildIsBone = false;
487        osgDB::ReaderWriter::ReadResult childResult = readFbxNode(
488            pChildNode, bChildIsBone, nLightCount);
489        if (childResult.error())
490        {
491            return childResult;
492        }
493        else if (osg::Node* osgChild = childResult.getNode())
494        {
495            if (bChildIsBone)
496            {
497                if (!bIsBone) bCreateSkeleton = true;
498                skeletal.push_back(osgChild);
499            }
500            else
501            {
502                children.push_back(osgChild);
503            }
504        }
505    }
506
507    std::string animName = readFbxAnimation(pNode, pNode->GetName());
508
509    osg::Matrix localMatrix;
510    makeLocalMatrix(pNode, localMatrix);
511    bool bLocalMatrixIdentity = localMatrix.isIdentity();
512
513    osg::ref_ptr<osg::Group> osgGroup;
514
515    bool bEmpty = children.empty() && !bIsBone;
516
517    switch (lAttributeType)
518    {
519    case FbxNodeAttribute::eMesh:
520        {
521            size_t bindMatrixCount = boneBindMatrices.size();
522            osgDB::ReaderWriter::ReadResult meshRes = readFbxMesh(pNode, stateSetList);
523            if (meshRes.error())
524            {
525                return meshRes;
526            }
527            else if (osg::Node* node = meshRes.getNode())
528            {
529                bEmpty = false;
530
531                if (bindMatrixCount != boneBindMatrices.size())
532                {
533                    //The mesh is skinned therefore the bind matrix will handle all transformations.
534                    localMatrix.makeIdentity();
535                    bLocalMatrixIdentity = true;
536                }
537
538                if (animName.empty() &&
539                    children.empty() &&
540                    skeletal.empty() &&
541                    bLocalMatrixIdentity)
542                {
543                    return osgDB::ReaderWriter::ReadResult(node);
544                }
545
546                children.insert(children.begin(), node);
547            }
548        }
549        break;
550    case FbxNodeAttribute::eCamera:
551    case FbxNodeAttribute::eLight:
552        {
553            osgDB::ReaderWriter::ReadResult res =
554                lAttributeType == FbxNodeAttribute::eCamera ?
555                readFbxCamera(pNode) : readFbxLight(pNode, nLightCount);
556            if (res.error())
557            {
558                return res;
559            }
560            else if (osg::Group* resGroup = dynamic_cast<osg::Group*>(res.getObject()))
561            {
562                bEmpty = false;
563                if (animName.empty() &&
564                    bLocalMatrixIdentity)
565                {
566                    osgGroup = resGroup;
567                }
568                else
569                {
570                    children.insert(children.begin(), resGroup);
571                }
572            }
573        }
574        break;
575    default:
576        break;
577    }
578
579    if (bEmpty)
580    {
581        osgDB::ReaderWriter::ReadResult(0);
582    }
583
584    if (!osgGroup) osgGroup = createGroupNode(pSdkManager, pNode, animName, localMatrix, bIsBone, nodeMap, fbxScene);
585
586    osg::Group* pAddChildrenTo = osgGroup.get();
587    if (bCreateSkeleton)
588    {
589        osgAnimation::Skeleton* osgSkeleton = getSkeleton(pNode, fbxSkeletons, skeletonMap);
590        osgSkeleton->setDefaultUpdateCallback();
591        pAddChildrenTo->addChild(osgSkeleton);
592        pAddChildrenTo = osgSkeleton;
593    }
594
595    for (osg::NodeList::iterator it = skeletal.begin(); it != skeletal.end(); ++it)
596    {
597        pAddChildrenTo->addChild(it->get());
598    }
599    for (osg::NodeList::iterator it = children.begin(); it != children.end(); ++it)
600    {
601        pAddChildrenTo->addChild(it->get());
602    }
603
604
605    return osgDB::ReaderWriter::ReadResult(osgGroup.get());
606}
607
608osgAnimation::Skeleton* getSkeleton(FbxNode* fbxNode,
609    const std::set<const FbxNode*>& fbxSkeletons,
610    std::map<FbxNode*, osgAnimation::Skeleton*>& skeletonMap)
611{
612    //Find the first non-skeleton ancestor of the node.
613    while (fbxNode &&
614        ((fbxNode->GetNodeAttribute() &&
615        fbxNode->GetNodeAttribute()->GetAttributeType() == FbxNodeAttribute::eSkeleton) ||
616        fbxSkeletons.find(fbxNode) != fbxSkeletons.end()))
617    {
618        fbxNode = fbxNode->GetParent();
619    }
620
621    std::map<FbxNode*, osgAnimation::Skeleton*>::const_iterator it = skeletonMap.find(fbxNode);
622    if (it == skeletonMap.end())
623    {
624        osgAnimation::Skeleton* skel = new osgAnimation::Skeleton;
625        skel->setDefaultUpdateCallback();
626        skeletonMap.insert(std::pair<FbxNode*, osgAnimation::Skeleton*>(fbxNode, skel));
627        return skel;
628    }
629    else
630    {
631        return it->second;
632    }
633}
Note: See TracBrowser for help on using the browser.