//---------------------------------------------------------------------
void SkeletonSerializer::importSkeleton(DataStreamPtr& stream, Skeleton* pSkel)
{
// Determine endianness (must be the first thing we do!)
determineEndianness(stream);
// Check header
readFileHeader(stream);
unsigned short streamID;
while(!stream->eof())
{
streamID = readChunk(stream);
switch (streamID)
{
case SKELETON_BONE:
readBone(stream, pSkel);
break;
case SKELETON_BONE_PARENT:
readBoneParent(stream, pSkel);
break;
case SKELETON_ANIMATION:
readAnimation(stream, pSkel);
break;
case SKELETON_ANIMATION_LINK:
readSkeletonAnimationLink(stream, pSkel);
break;
}
}
// Assume bones are stored in the binding pose
pSkel->setBindingPose();
}
Animation* SkeletonJson::readAnimationFile (const std::string &path, const SkeletonData *skeletonData) const {
unsigned long size;
char* data = reinterpret_cast<char*>(CCFileUtils::sharedFileUtils()->getFileData(
CCFileUtils::sharedFileUtils()->fullPathForFilename(path.c_str()).c_str(), "r", &size));
if (!data) throw runtime_error("Error reading animation file: " + path);
return readAnimation(data, data + size, skeletonData);
}
void SkeletonData::readAnimations(JsonTree animations, Joint * j){
readAnimation(animations.getChild("translateX"), j->translateX);
readAnimation(animations.getChild("translateY"), j->translateY);
readAnimation(animations.getChild("translateZ"), j->translateZ);
readAnimation(animations.getChild("rotate"), j->rotate);
readAnimation(animations.getChild("scaleX"), j->scaleX);
readAnimation(animations.getChild("scaleY"), j->scaleY);
readAnimation(animations.getChild("scaleZ"), j->scaleX);
}
HpCharactor* HpCharactorBinParser::parse(const char* p_file)
{
m_cur_chara = new HpCharactor();
HpBinaryReader* reader = NULL;
const string& full_path = CCFileUtils::sharedFileUtils()->fullPathForFilename(p_file);
unsigned long size = 0;
char* pBuffer = (char*)CCFileUtils::sharedFileUtils()->getFileData(full_path.c_str(), "rt", &size);
if (pBuffer != NULL && size > 0)
{
reader = new HpBinaryReader(pBuffer, size);
}
char buffer[128] = {0};
reader->ReadChars(buffer, 3);
if (strncasecmp(buffer, "CHR", 3) != 0) return NULL;
ChrReadingVersion = reader->ReadByte();
if (ChrReadingVersion > ChrReadingVersionMax) {
CCLOG("HpCharactorBinParser max reader version is %d, but the file version is %d", ChrReadingVersionMax, ChrReadingVersion);
CCAssert(0, "");
return NULL;
}
Byte plist_count = reader->ReadByte();
for(int i=0; i<plist_count;i++)
{
reader->ReadString(buffer);
char* p = strrchr(buffer, '\\');
m_cur_chara->getPLists()->addObject(CCString::create(p ? p+1 : buffer));
}
unsigned short anim_count = reader->ReadUInt16();
for(int i=0; i<anim_count; i++) {
readAnimation(reader, buffer);
}
reader->Close();
CC_SAFE_DELETE(reader);
CC_SAFE_DELETE_ARRAY(pBuffer);
return m_cur_chara;
}
//---------------------------------------------------------------------
void SkeletonSerializer::importSkeleton(DataStreamPtr& stream, Skeleton* pSkel)
{
// Determine endianness (must be the first thing we do!)
determineEndianness(stream);
// Check header
readFileHeader(stream);
pushInnerChunk(stream);
unsigned short streamID = readChunk(stream);
while(!stream->eof())
{
switch (streamID)
{
case SKELETON_BLENDMODE:
{
// Optional blend mode
uint16 blendMode;
readShorts(stream, &blendMode, 1);
pSkel->setBlendMode(static_cast<SkeletonAnimationBlendMode>(blendMode));
break;
}
case SKELETON_BONE:
readBone(stream, pSkel);
break;
case SKELETON_BONE_PARENT:
readBoneParent(stream, pSkel);
break;
case SKELETON_ANIMATION:
readAnimation(stream, pSkel);
break;
case SKELETON_ANIMATION_LINK:
readSkeletonAnimationLink(stream, pSkel);
break;
default:
break;
}
streamID = readChunk(stream);
}
// Assume bones are stored in the binding pose
pSkel->setBindingPose();
popInnerChunk(stream);
}
osgDB::ReaderWriter::ReadResult OsgFbxReader::readMesh(
KFbxNode* pNode,
KFbxMesh* fbxMesh,
std::vector<StateSetContent>& stateSetList,
const char* szName)
{
GeometryMap geometryMap;
osg::Geode* pGeode = new osg::Geode;
pGeode->setName(szName);
const KFbxLayerElementNormal* pFbxNormals = 0;
const KFbxLayerElementVertexColor* pFbxColors = 0;
const KFbxLayerElementMaterial* pFbxMaterials = 0;
const KFbxVector4* pFbxVertices = fbxMesh->GetControlPoints();
// scan layers for Normals, Colors and Materials elements (this will get the first available elements)...
for (int cLayerIndex = 0; cLayerIndex < fbxMesh->GetLayerCount(); cLayerIndex++)
{
const KFbxLayer* pFbxLayer = fbxMesh->GetLayer(cLayerIndex);
if (!pFbxLayer)
continue;
// get normals, colors and materials...
if (!pFbxNormals)
pFbxNormals = pFbxLayer->GetNormals();
if (!pFbxColors)
pFbxColors = pFbxLayer->GetVertexColors();
if (!pFbxMaterials)
pFbxMaterials = pFbxLayer->GetMaterials();
}
// look for UV elements (diffuse, opacity, reflection, emissive, ...) and get their channels names...
std::string diffuseChannel = getUVChannelForTextureMap(stateSetList, KFbxSurfaceMaterial::sDiffuse);
std::string opacityChannel = getUVChannelForTextureMap(stateSetList, KFbxSurfaceMaterial::sTransparentColor);
std::string emissiveChannel = getUVChannelForTextureMap(stateSetList, KFbxSurfaceMaterial::sEmissive);
// look for more UV elements here...
// UV elements...
const KFbxLayerElementUV* pFbxUVs_diffuse = getUVElementForChannel(diffuseChannel, KFbxLayerElement::eDIFFUSE_TEXTURES, fbxMesh);
const KFbxLayerElementUV* pFbxUVs_opacity = getUVElementForChannel(opacityChannel, KFbxLayerElement::eTRANSPARENT_TEXTURES, fbxMesh);
const KFbxLayerElementUV* pFbxUVs_emissive = getUVElementForChannel(emissiveChannel, KFbxLayerElement::eEMISSIVE_TEXTURES, fbxMesh);
// more UV elements here...
// check elements validity...
if (!layerElementValid(pFbxNormals)) pFbxNormals = 0;
if (!layerElementValid(pFbxColors)) pFbxColors = 0;
if (!layerElementValid(pFbxUVs_diffuse)) pFbxUVs_diffuse = 0;
if (!layerElementValid(pFbxUVs_opacity)) pFbxUVs_opacity = 0;
if (!layerElementValid(pFbxUVs_emissive)) pFbxUVs_emissive = 0;
// more here...
int nPolys = fbxMesh->GetPolygonCount();
int nDeformerCount = fbxMesh->GetDeformerCount(KFbxDeformer::eSKIN);
int nDeformerBlendShapeCount = fbxMesh->GetDeformerCount(KFbxDeformer::eBLENDSHAPE);
GeometryType geomType = GEOMETRY_STATIC;
//determine the type of geometry
if (nDeformerCount)
{
geomType = GEOMETRY_RIG;
}
else if (nDeformerBlendShapeCount)
{
geomType = GEOMETRY_MORPH;
}
FbxToOsgVertexMap fbxToOsgVertMap;
OsgToFbxNormalMap osgToFbxNormMap;
// First add only triangles and quads (easy to split into triangles without
// more processing)
// This is the reason we store polygons references:
PolygonRefList polygonRefList;
for (int i = 0, nVertex = 0; i < nPolys; ++i)
{
int lPolygonSize = fbxMesh->GetPolygonSize(i);
int materialIndex = getPolygonIndex(pFbxMaterials, i);
osg::Geometry* pGeometry = getGeometry(pGeode, geometryMap,
stateSetList, geomType, materialIndex,
pFbxNormals != 0,
pFbxUVs_diffuse != 0,
pFbxUVs_opacity != 0,
pFbxUVs_emissive != 0,
// more UV elements here...
pFbxColors != 0,
options,
lightmapTextures);
osg::Array* pVertices = pGeometry->getVertexArray();
osg::Array* pNormals = pGeometry->getNormalArray();
// get texture coordinates...
osg::Array* pTexCoords_diffuse = pGeometry->getTexCoordArray(StateSetContent::DIFFUSE_TEXTURE_UNIT);
osg::Array* pTexCoords_opacity = pGeometry->getTexCoordArray(StateSetContent::OPACITY_TEXTURE_UNIT);
osg::Array* pTexCoords_emissive = pGeometry->getTexCoordArray(StateSetContent::EMISSIVE_TEXTURE_UNIT);
// more texture coordinates here...
osg::Array* pColors = pGeometry->getColorArray();
if (lPolygonSize == 3)
{
// Triangle
readMeshTriangle(fbxMesh, i,
0, 1, 2,
nVertex, nVertex+1, nVertex+2,
fbxToOsgVertMap, osgToFbxNormMap,
pFbxVertices, pFbxNormals, pFbxUVs_diffuse, pFbxUVs_opacity, pFbxUVs_emissive, pFbxColors,
pGeometry,
pVertices, pNormals, pTexCoords_diffuse, pTexCoords_opacity, pTexCoords_emissive, pColors);
nVertex += 3;
}
else if (lPolygonSize == 4)
{
// Quad - Convert to triangles
// Use some fast specialized code to see how the should be decomposed
// Two cases : Split at '02' (012 and 023), or split at '13 (013 and 123)
bool split02 = quadSplit02(fbxMesh, i, 0, 1, 2, 3, pFbxVertices);
int p02 = split02 ? 2 : 3; // Triangle 0, point 2
int p10 = split02 ? 0 : 1; // Triangle 1, point 0
readMeshTriangle(fbxMesh, i,
0, 1, p02,
nVertex, nVertex+1, nVertex+p02,
fbxToOsgVertMap, osgToFbxNormMap,
pFbxVertices, pFbxNormals, pFbxUVs_diffuse, pFbxUVs_opacity, pFbxUVs_emissive, pFbxColors,
pGeometry,
pVertices, pNormals, pTexCoords_diffuse, pTexCoords_opacity, pTexCoords_emissive, pColors);
readMeshTriangle(fbxMesh, i,
p10, 2, 3,
nVertex+p10, nVertex+2, nVertex+3,
fbxToOsgVertMap, osgToFbxNormMap,
pFbxVertices, pFbxNormals, pFbxUVs_diffuse, pFbxUVs_opacity, pFbxUVs_emissive, pFbxColors,
pGeometry,
pVertices, pNormals, pTexCoords_diffuse, pTexCoords_opacity, pTexCoords_emissive, pColors);
nVertex += 4;
}
else if (tessellatePolygons)
{
// Polygons - Store to add after triangles
polygonRefList.push_back(PolygonRef(pGeometry, i, nVertex));
nVertex += lPolygonSize;
}
else
{
int nVertex0 = nVertex;
nVertex += (std::min)(2, lPolygonSize);
for (int j = 2; j < lPolygonSize; ++j, ++nVertex)
{
readMeshTriangle(fbxMesh, i,
0, j - 1, j,
nVertex0, nVertex - 1, nVertex,
fbxToOsgVertMap, osgToFbxNormMap,
pFbxVertices, pFbxNormals, pFbxUVs_diffuse, pFbxUVs_opacity, pFbxUVs_emissive, pFbxColors,
pGeometry,
pVertices, pNormals, pTexCoords_diffuse, pTexCoords_opacity, pTexCoords_emissive, pColors);
}
}
}
for (unsigned i = 0; i < pGeode->getNumDrawables(); ++i)
{
osg::Geometry* pGeometry = pGeode->getDrawable(i)->asGeometry();
osg::DrawArrays* pDrawArrays = new osg::DrawArrays(
GL_TRIANGLES, 0, pGeometry->getVertexArray()->getNumElements());
pGeometry->addPrimitiveSet(pDrawArrays);
}
// Now add polygons - Convert to triangles
// We put vertices in their own PrimitiveSet with Mode=POLYGON; then run the
// Tessellator on the Geometry which should tessellate the polygons
// automagically.
for (PolygonRefList::iterator it = polygonRefList.begin(), itEnd=polygonRefList.end();
it != itEnd; ++it)
{
int i = it->numPoly;
int lPolygonSize = fbxMesh->GetPolygonSize(i);
//int materialIndex = getPolygonIndex(pFbxMaterials, i);
osg::Geometry* pGeometry = it->pGeometry;
osg::Array* pVertices = pGeometry->getVertexArray();
osg::Array* pNormals = pGeometry->getNormalArray();
osg::Array* pTexCoords_diffuse = pGeometry->getTexCoordArray(StateSetContent::DIFFUSE_TEXTURE_UNIT);
osg::Array* pTexCoords_opacity = pGeometry->getTexCoordArray(StateSetContent::OPACITY_TEXTURE_UNIT);
osg::Array* pTexCoords_emissive = pGeometry->getTexCoordArray(StateSetContent::EMISSIVE_TEXTURE_UNIT);
osg::Array* pColors = pGeometry->getColorArray();
// Index of the 1st vertex of the polygon in the geometry
int osgVertex0 = pVertices->getNumElements();
for (int j = 0, nVertex = it->nVertex; j<lPolygonSize; ++j, ++nVertex)
{
int v0 = fbxMesh->GetPolygonVertex(i, j);
fbxToOsgVertMap.insert(FbxToOsgVertexMap::value_type(v0, GIPair(pGeometry, pVertices->getNumElements())));
addVec3ArrayElement(*pVertices, pFbxVertices[v0]);
if (pNormals)
{
int n0 = getVertexIndex(pFbxNormals, fbxMesh, i, j, nVertex);
osgToFbxNormMap.insert(OsgToFbxNormalMap::value_type(GIPair(pGeometry, pNormals->getNumElements()), n0));
addVec3ArrayElement(*pNormals, pFbxNormals->GetDirectArray().GetAt(n0));
}
// add texture maps data (avoid duplicates)...
if (pTexCoords_diffuse)
{
addVec2ArrayElement(*pTexCoords_diffuse, getElement(pFbxUVs_diffuse, fbxMesh, i, j, nVertex));
}
if (pTexCoords_opacity && (pTexCoords_opacity != pTexCoords_diffuse))
{
addVec2ArrayElement(*pTexCoords_opacity, getElement(pFbxUVs_opacity, fbxMesh, i, j, nVertex));
}
// Only spherical reflection maps are supported (so do not add coordinates for the reflection map)
if (pTexCoords_emissive && (pTexCoords_emissive != pTexCoords_opacity) && (pTexCoords_emissive != pTexCoords_diffuse))
{
addVec2ArrayElement(*pTexCoords_emissive, getElement(pFbxUVs_emissive, fbxMesh, i, j, nVertex));
}
// add more texture maps here...
if (pColors)
{
addColorArrayElement(*pColors, getElement(pFbxColors, fbxMesh, i, j, nVertex));
}
}
osg::DrawArrays* pDrawArrays = new osg::DrawArrays(
GL_POLYGON, osgVertex0, pGeometry->getVertexArray()->getNumElements() - osgVertex0);
pGeometry->addPrimitiveSet(pDrawArrays);
}
for (unsigned i = 0; i < pGeode->getNumDrawables(); ++i)
{
osg::Geometry* pGeometry = pGeode->getDrawable(i)->asGeometry();
// Now split polygons if necessary
osgUtil::Tessellator tessellator;
tessellator.retessellatePolygons(*pGeometry);
if (pGeode->getNumDrawables() > 1)
{
std::stringstream ss;
ss << pGeode->getName() << " " << i + 1;
pGeometry->setName(ss.str());
}
else
{
pGeometry->setName(pGeode->getName());
}
}
if (geomType == GEOMETRY_RIG)
{
typedef std::map<osg::ref_ptr<osg::Geometry>,
osg::ref_ptr<osgAnimation::RigGeometry> > GeometryRigGeometryMap;
GeometryRigGeometryMap old2newGeometryMap;
for (unsigned 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)
{
KFbxSkin* pSkin = (KFbxSkin*)fbxMesh->GetDeformer(i, KFbxDeformer::eSKIN);
int nClusters = pSkin->GetClusterCount();
for (int j = 0; j < nClusters; ++j)
{
KFbxCluster* pCluster = (KFbxCluster*)pSkin->GetCluster(j);
//assert(KFbxCluster::eNORMALIZE == pCluster->GetLinkMode());
KFbxNode* pBone = pCluster->GetLink();
KFbxXMatrix transformLink;
pCluster->GetTransformLinkMatrix(transformLink);
KFbxXMatrix transformLinkInverse = transformLink.Inverse();
const double* pTransformLinkInverse = transformLinkInverse;
osg::Matrix bindMatrix(pTransformLinkInverse);
int nIndices = pCluster->GetControlPointIndicesCount();
int* pIndices = pCluster->GetControlPointIndices();
double* pWeights = pCluster->GetControlPointWeights();
for (int k = 0; k < nIndices; ++k)
{
int fbxIndex = pIndices[k];
float weight = static_cast<float>(pWeights[k]);
for (FbxToOsgVertexMap::const_iterator it =
fbxToOsgVertMap.find(fbxIndex);
it != fbxToOsgVertMap.end() &&
it->first == fbxIndex; ++it)
{
GIPair gi = it->second;
osgAnimation::RigGeometry& rig =
dynamic_cast<osgAnimation::RigGeometry&>(
*old2newGeometryMap[gi.first]);
addBindMatrix(boneBindMatrices, pBone, bindMatrix, &rig);
osgAnimation::VertexInfluenceMap& vim =
*rig.getInfluenceMap();
osgAnimation::VertexInfluence& vi =
getVertexInfluence(vim, pBone->GetName());
vi.push_back(osgAnimation::VertexIndexWeight(
gi.second, weight));
}
}
}
}
}
else if (geomType == GEOMETRY_MORPH)
{
for (unsigned i = 0; i < pGeode->getNumDrawables(); ++i)
{
osg::Geometry* pGeometry = pGeode->getDrawable(i)->asGeometry();
osgAnimation::MorphGeometry& morph = dynamic_cast<osgAnimation::MorphGeometry&>(*pGeometry);
pGeode->addUpdateCallback(new osgAnimation::UpdateMorph(morph.getName()));
//read morph geometry
for (int nBlendShape = 0; nBlendShape < nDeformerBlendShapeCount; ++nBlendShape)
{
KFbxBlendShape* pBlendShape = KFbxCast<KFbxBlendShape>(fbxMesh->GetDeformer(nBlendShape, KFbxDeformer::eBLENDSHAPE));
const int nBlendShapeChannelCount = pBlendShape->GetBlendShapeChannelCount();
for (int nBlendShapeChannel = 0; nBlendShapeChannel < nBlendShapeChannelCount; ++nBlendShapeChannel)
{
KFbxBlendShapeChannel* pBlendShapeChannel = pBlendShape->GetBlendShapeChannel(nBlendShapeChannel);
if (!pBlendShapeChannel->GetTargetShapeCount()) continue;
//Assume one shape
if (pBlendShapeChannel->GetTargetShapeCount() > 1)
{
OSG_WARN << "Multiple FBX Target Shapes, only the first will be used" << std::endl;
}
const KFbxGeometryBase* pMorphShape = pBlendShapeChannel->GetTargetShape(0);
const KFbxLayerElementNormal* pFbxShapeNormals = 0;
if (const KFbxLayer* pFbxShapeLayer = pMorphShape->GetLayer(0))
{
pFbxShapeNormals = pFbxShapeLayer->GetNormals();
if (!layerElementValid(pFbxShapeNormals)) pFbxShapeNormals = 0;
}
osg::Geometry* pMorphTarget = new osg::Geometry(morph);
pMorphTarget->setVertexArray(static_cast<osg::Array*>(
pMorphTarget->getVertexArray()->clone(osg::CopyOp::DEEP_COPY_ARRAYS)));
if (pFbxShapeNormals)
{
if (osg::Array* pNormals = pMorphTarget->getNormalArray())
{
pMorphTarget->setNormalArray(static_cast<osg::Array*>(
pNormals->clone(osg::CopyOp::DEEP_COPY_ARRAYS)));
}
}
pMorphTarget->setName(pMorphShape->GetName());
morph.addMorphTarget(pMorphTarget, 0.0f);
readAnimation(pNode, fbxScene, morph.getName(), pAnimationManager, fbxMesh,
nBlendShape, nBlendShapeChannel, (int)morph.getMorphTargetList().size() - 1);
}
}
}
int nMorphTarget = 0;
for (int nBlendShape = 0; nBlendShape < nDeformerBlendShapeCount; ++nBlendShape)
{
KFbxBlendShape* pBlendShape = KFbxCast<KFbxBlendShape>(fbxMesh->GetDeformer(nBlendShape, KFbxDeformer::eBLENDSHAPE));
const int nBlendShapeChannelCount = pBlendShape->GetBlendShapeChannelCount();
for (int nBlendShapeChannel = 0; nBlendShapeChannel < nBlendShapeChannelCount; ++nBlendShapeChannel)
{
KFbxBlendShapeChannel* pBlendShapeChannel = pBlendShape->GetBlendShapeChannel(nBlendShapeChannel);
if (!pBlendShapeChannel->GetTargetShapeCount()) continue;
//Assume one shape again
const KFbxGeometryBase* pMorphShape = pBlendShapeChannel->GetTargetShape(0);
const KFbxLayerElementNormal* pFbxShapeNormals = 0;
if (const KFbxLayer* pFbxShapeLayer = pMorphShape->GetLayer(0))
{
pFbxShapeNormals = pFbxShapeLayer->GetNormals();
if (!layerElementValid(pFbxShapeNormals)) pFbxShapeNormals = 0;
}
const KFbxVector4* pControlPoints = pMorphShape->GetControlPoints();
int nControlPoints = pMorphShape->GetControlPointsCount();
for (int fbxIndex = 0; fbxIndex < nControlPoints; ++fbxIndex)
{
osg::Vec3d vPos = convertVec3(pControlPoints[fbxIndex]);
for (FbxToOsgVertexMap::const_iterator it =
fbxToOsgVertMap.find(fbxIndex);
it != fbxToOsgVertMap.end() &&
it->first == fbxIndex; ++it)
{
GIPair gi = it->second;
osgAnimation::MorphGeometry& morphGeom =
dynamic_cast<osgAnimation::MorphGeometry&>(*gi.first);
osg::Geometry* pGeometry = morphGeom.getMorphTarget(nMorphTarget).getGeometry();
if (pGeometry->getVertexArray()->getType() == osg::Array::Vec3dArrayType)
{
osg::Vec3dArray* pVertices = static_cast<osg::Vec3dArray*>(pGeometry->getVertexArray());
(*pVertices)[gi.second] = vPos;
}
else
{
osg::Vec3Array* pVertices = static_cast<osg::Vec3Array*>(pGeometry->getVertexArray());
(*pVertices)[gi.second] = vPos;
}
if (pFbxShapeNormals && pGeometry->getNormalArray())
{
if (pGeometry->getNormalArray()->getType() == osg::Array::Vec3dArrayType)
{
osg::Vec3dArray* pNormals = static_cast<osg::Vec3dArray*>(pGeometry->getNormalArray());
(*pNormals)[gi.second] = convertVec3(
pFbxShapeNormals->GetDirectArray().GetAt(osgToFbxNormMap[gi]));
}
else
{
osg::Vec3Array* pNormals = static_cast<osg::Vec3Array*>(pGeometry->getNormalArray());
(*pNormals)[gi.second] = convertVec3(
pFbxShapeNormals->GetDirectArray().GetAt(osgToFbxNormMap[gi]));
}
}
}
}
//don't put this in the for loop as we don't want to do it if the loop continues early
++nMorphTarget;
}
}
}
KFbxXMatrix fbxGeometricTransform;
fbxGeometricTransform.SetTRS(
pNode->GeometricTranslation.Get(),
pNode->GeometricRotation.Get(),
pNode->GeometricScaling.Get());
const double* pGeometricMat = fbxGeometricTransform;
osg::Matrix osgGeometricTransform(pGeometricMat);
if (geomType == GEOMETRY_RIG)
{
KFbxSkin* pSkin = (KFbxSkin*)fbxMesh->GetDeformer(0, KFbxDeformer::eSKIN);
if (pSkin->GetClusterCount())
{
KFbxXMatrix fbxTransformMatrix;
pSkin->GetCluster(0)->GetTransformMatrix(fbxTransformMatrix);
const double* pTransformMatrix = fbxTransformMatrix;
osgGeometricTransform.postMult(osg::Matrix(pTransformMatrix));
}
}
osg::Node* pResult = pGeode;
if (!osgGeometricTransform.isIdentity())
{
osg::MatrixTransform* pMatTrans = new osg::MatrixTransform(osgGeometricTransform);
pMatTrans->addChild(pGeode);
pResult = pMatTrans;
}
if (geomType == GEOMETRY_RIG)
{
//Add the geometry to the skeleton ancestor of one of the bones.
KFbxSkin* pSkin = (KFbxSkin*)fbxMesh->GetDeformer(0, KFbxDeformer::eSKIN);
if (pSkin->GetClusterCount())
{
osgAnimation::Skeleton* pSkeleton = getSkeleton(
pSkin->GetCluster(0)->GetLink(), fbxSkeletons, skeletonMap);
pSkeleton->addChild(pResult);
return osgDB::ReaderWriter::ReadResult::FILE_LOADED;
}
}
return osgDB::ReaderWriter::ReadResult(pResult);
}
