void SkeletonDrawable::adjustVolume(Volume & volume)
{
Inherited::adjustVolume(volume);
//Extend the volume by all the Root Joints of Skeleton
if(getSkeleton() == NULL)
{
FWARNING(("SkeletonDrawable::drawPrimitives:: no skeleton!\n"));;
}
else
{
Pnt3f JointLocation(0.0,0.0,0.0);
for(UInt32 i(0) ; i<getSkeleton()->getNumJoints() ; ++i)
{
JointLocation.setValues(0.0,0.0,0.0);
if(getDrawPose())
{
getSkeleton()->getAbsoluteTransformation(i).mult(Pnt3f(0.0f,0.0f,0.0f),JointLocation);
volume.extendBy(JointLocation);
}
if(getDrawBindPose())
{
getSkeleton()->getAbsoluteBindTransformation(i).mult(Pnt3f(0.0f,0.0f,0.0f),JointLocation);
volume.extendBy(JointLocation);
}
}
}
}
void SkeletonDrawable::fill(DrawableStatsAttachment *pStat)
{
if(pStat == NULL)
{
FINFO(("SkeletonDrawable::fill(DrawableStatsAttachment *): "
"No attachment given.\n"));
return;
}
if(getSkeleton() == NULL)
{
FWARNING(("SkeletonDrawable::fill:: no skeleton!\n"));;
return;
}
UInt32 NumLines(0);
if(getDrawPose())
{
NumLines += getSkeleton()->getNumJoints()-1;
}
if(getDrawBindPose())
{
NumLines += getSkeleton()->getNumJoints()-1;
}
pStat->setLines (NumLines);
}
Eigen::VectorXd World::getState()
{
Eigen::VectorXd state(mIndices.back() * 2);
for (unsigned int i = 0; i < getNumSkeletons(); i++)
{
int start = mIndices[i] * 2;
int size = getSkeleton(i)->getNumDofs();
state.segment(start, size) = getSkeleton(i)->getPose();
state.segment(start + size, size) = getSkeleton(i)->getPoseVelocity();
}
return state;
}
//==============================================================================
size_t Joint::incrementVersion()
{
if(const auto& skel = getSkeleton())
return skel->incrementVersion();
return 0;
}
void Model::prepareSkinning()
{
if( !mesh->isAnimated() ) return;
size_t numBones = mesh->getSkeleton()->getBones().size();
bones.resize( numBones );
}
//==============================================================================
size_t Joint::getVersion() const
{
if(const auto& skel = getSkeleton())
return skel->getVersion();
return 0;
}
//==============================================================================
void Joint::notifyPositionUpdate()
{
if(mChildBodyNode)
{
mChildBodyNode->notifyTransformUpdate();
mChildBodyNode->notifyJacobianUpdate();
mChildBodyNode->notifyJacobianDerivUpdate();
}
mIsLocalJacobianDirty = true;
mIsLocalJacobianTimeDerivDirty = true;
mNeedPrimaryAccelerationUpdate = true;
mNeedTransformUpdate = true;
mNeedSpatialVelocityUpdate = true;
mNeedSpatialAccelerationUpdate = true;
SkeletonPtr skel = getSkeleton();
if(skel)
{
std::size_t tree = mChildBodyNode->mTreeIndex;
skel->notifyArticulatedInertiaUpdate(tree);
skel->mTreeCache[tree].mDirty.mExternalForces = true;
skel->mSkelCache.mDirty.mExternalForces = true;
}
}
Action::ResultE
CPUSkinningAlgorithm::intersectEnter(Action *action)
{
Action::ResultE res = Action::Continue;
SkinnedGeometry *skinGeo = getSkin ();
Skeleton *skel = getSkeleton();
IntersectAction *iact =
boost::polymorphic_downcast<IntersectAction *>(action);
CPUSkinningDataAttachmentUnrecPtr data = getCPUSkinningData(skinGeo);
if(data == NULL)
{
data = CPUSkinningDataAttachment::create();
skinGeo->addAttachment(data);
}
skel->intersectEnter(action, skinGeo);
if(data->getDataValid() == false)
{
transformGeometry(skinGeo, skel, data);
data->setDataValid(true);
}
intersectGeometry(iact, skinGeo, data);
return res;
}
Action::ResultE
CPUSkinningAlgorithm::renderEnter(Action *action)
{
Action::ResultE res = Action::Continue;
SkinnedGeometry *skinGeo = getSkin ();
Skeleton *skel = getSkeleton();
RenderAction *ract =
boost::polymorphic_downcast<RenderAction *>(action);
OSG_ASSERT(skinGeo != NULL);
OSG_ASSERT(skel != NULL);
CPUSkinningDataAttachmentUnrecPtr data = getCPUSkinningData(skinGeo);
if(data == NULL)
{
data = CPUSkinningDataAttachment::create();
skinGeo->addAttachment(data);
}
skel->renderEnter(action, skinGeo);
if(data->getDataValid() == false)
{
transformGeometry(skinGeo, skel, data);
data->setDataValid(true);
}
renderGeometry(ract, skinGeo, data);
return res;
}
void SkeletonStream::renderSkeleton()
{
Eigen::Matrix3Xd skeleton;
if (!getSkeleton(skeleton))
return;
renderSkeleton(skeleton);
}
bool Magic3D::Model::update()
{
bool needUpdate = Scene::getInstance()->getUniqueUpdateFlag() != uniqueUpdate;
bool result = Object::update();
if (needUpdate && (isInParentFrustum() || isInEffectFrustum()) && getSkeleton())
{
uniqueUpdate = !uniqueUpdate;
result = getSkeleton()->update() && result;
if (result)
{
result = updateMeshes() && result;
}
Object::updateBoundingBox(false);
box = Object::getBoundingBox();
}
return result;
}
Magic3D::XMLElement* Magic3D::Model::save(XMLElement* root)
{
Object::save(root);
if (root)
{
XMLElement* model = root->GetDocument()->NewElement(M3D_MODEL_XML);
root->LinkEndChild(model);
saveString(model, M3D_MODEL_XML_FILE, getFileName());
if (getSkeleton())
{
getSkeleton()->save(model);
}
}
return root;
}
Action::ResultE
SkeletonSkinningAlgorithm::renderLeave(Action *action)
{
SkinnedGeometry *skinGeo = getSkin();
Skeleton *skel = getSkeleton();
skel->renderLeave(action, skinGeo);
return Action::Continue;
}
//==============================================================================
void EndEffector::notifyTransformUpdate()
{
if(!mNeedTransformUpdate)
{
const SkeletonPtr& skel = getSkeleton();
if(skel)
skel->notifySupportUpdate(getTreeIndex());
}
Frame::notifyTransformUpdate();
}
Action::ResultE
GPUSkinningAlgorithm::renderLeave(Action *action)
{
Action::ResultE res = Action::Continue;
SkinnedGeometry *skinGeo = getSkin();
Skeleton *skel = getSkeleton();
skel->renderLeave(action, skinGeo);
res = skinGeo->SkinnedGeometry::Inherited::renderLeave(action);
return res;
}
Eigen::VectorXd World::evalDeriv()
{
// compute contact forces
mCollisionHandle->applyContactForces();
// compute derivatives for integration
Eigen::VectorXd deriv = Eigen::VectorXd::Zero(mIndices.back() * 2);
for (unsigned int i = 0; i < getNumSkeletons(); i++)
{
// skip immobile objects in forward simulation
if (mSkeletons[i]->getImmobileState())
continue;
int start = mIndices[i] * 2;
int size = getSkeleton(i)->getNumDofs();
Eigen::VectorXd qddot = mSkeletons[i]->getInvMassMatrix()
* (-mSkeletons[i]->getCombinedVector()
+ mSkeletons[i]->getExternalForces()
+ mSkeletons[i]->getInternalForces()
+ mCollisionHandle->getConstraintForce(i)
);
// Eigen::VectorXd qddot = mSkeletons[i]->getMassMatrix().ldlt().solve(
// -mSkeletons[i]->getCombinedVector()
// + mSkeletons[i]->getExternalForces()
// + mSkeletons[i]->getInternalForces()
// + mCollisionHandle->getConstraintForce(i)
// );
// set velocities
deriv.segment(start, size) = getSkeleton(i)->getPoseVelocity() + (qddot * mTimeStep);
// set qddot (accelerations)
deriv.segment(start + size, size) = qddot;
}
return deriv;
}
void Mapper::map(ofxOscMessage &_message) {
parser.setMessage(_message);
if(parser.isBody()) {
Skeleton* skeleton = getSkeleton(parser.parseBodyId());
if(parser.isJoint()) {
skeleton->setJoint(parser.parseJoint());
} else if(parser.isHand()) {
skeleton->setHand(parser.parseHand());
}
}
}
vector <Point2f> Frame::getPartPolygon(int partID) const
{
tree <BodyPart> partTree = getSkeleton().getPartTree();
tree <BodyPart>::iterator i;
for (i = partTree.begin(); i != partTree.end(); i++)
{
if (i->getPartID() == partID)
{
return i->getPartPolygon().asVector();
}
}
return vector <Point2f>();
}
//==============================================================================
bool BodyNodeDistanceFilter::needDistance(
const collision::CollisionObject* object1,
const collision::CollisionObject* object2) const
{
if (object1 == object2)
return false;
auto shapeNode1 = object1->getShapeFrame()->asShapeNode();
auto shapeNode2 = object2->getShapeFrame()->asShapeNode();
if (!shapeNode1 || !shapeNode2)
return true;
// We assume that non-ShapeNode is always being checked collision.
auto bodyNode1 = shapeNode1->getBodyNodePtr();
auto bodyNode2 = shapeNode2->getBodyNodePtr();
if (!bodyNode1->isCollidable() || !bodyNode2->isCollidable())
return false;
if (bodyNode1->getSkeleton() == bodyNode2->getSkeleton())
{
auto skeleton = bodyNode1->getSkeleton();
if (!skeleton->isEnabledSelfCollisionCheck())
return false;
if (!skeleton->isEnabledAdjacentBodyCheck())
{
if (areAdjacentBodies(bodyNode1, bodyNode2))
return false;
}
}
return true;
}
Magic3D::XMLElement* Magic3D::Model::load(XMLElement* root)
{
if (root)
{
XMLElement* model = root->FirstChildElement(M3D_MODEL_XML);
std::string name = loadString(model, M3D_MODEL_XML_FILE);
if (name.compare(M3D_XML_NULL) != 0)
{
setFileName(name);
}
if (getSkeleton())
{
getSkeleton()->load(model);
}
}
Object::load(root);
updateBoundingBox();
return root;
}
void Model::setAttachment(const String& boneName, const EntityPtr& node)
{
if( !mesh ) return;
Skeleton* skeleton = mesh->getSkeleton().get();
assert( skeleton != nullptr );
Bone* bone = skeleton->findBone(boneName).get();
if( !bone ) return;
Attachment* attachment = AllocateThis(Attachment);
attachment->bone = bone;
attachment->node = node;
attachments.push_back(attachment);
}
HandsHip *moduleCapture::formHandsHip(bool rightHanded)
{
NUI_SKELETON_DATA *skeleton = getSkeleton(); //Obtiene datos del esqueleto
if(skeleton == NULL){ // Si no recibimos datos, retorna NULL
return NULL;
}
HandsHip *h = new HandsHip;
h->hipPosition = skeleton->SkeletonPositions[NUI_SKELETON_POSITION_HIP_CENTER];
// Llenar los campos del handsHip con los datos del esqueleto teniendo en cuenta la lateralidad del usuario
if(rightHanded){
h->playingHandPosition = skeleton->SkeletonPositions[NUI_SKELETON_POSITION_WRIST_RIGHT];
h->chordHandPosition = skeleton->SkeletonPositions[NUI_SKELETON_POSITION_WRIST_LEFT];
} else {
h->playingHandPosition = skeleton->SkeletonPositions[NUI_SKELETON_POSITION_WRIST_LEFT];
h->chordHandPosition = skeleton->SkeletonPositions[NUI_SKELETON_POSITION_WRIST_RIGHT];
}
return h;
}
void Game::createScene()
{
sinbad = new GameObject("sinbad", "Sinbad.mesh", mSceneMgr->getRootSceneNode(), mSceneMgr);
sinbad->setVelocity(Ogre::Vector3(25, 0, 25));
auto ent = static_cast<Ogre::Entity*>(sinbad->getNode()->getAttachedObject("sinbad"));
ent->getSkeleton()->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
const auto setupAnimPair = [&](int i, const std::string& name) {
animStates[i] = ent->getAnimationState(name + "Base");
animStates[i + 1] = ent->getAnimationState(name + "Top");
for (int j = i; j < i + 1; ++j) {
animStates[j]->setLoop(true);
animStates[j]->setEnabled(false);
}
};
setupAnimPair(0, "Idle");
setupAnimPair(2, "Run");
}
bool Geom::Box::cropByAxisAlignedBox( Box other )
{
for (int i = 0; i < 3; i++)
{
// skeleton along axis[i]
Segment sklt = getSkeleton(i);
int other_aid = other.getAxisId(Axis[i]);
Segment other_sklt = other.getSkeleton(other_aid);
// point to same direction
if (dot(sklt.Direction, other_sklt.Direction) < 0)
other_sklt.flip();
// projection
double t0 = other_sklt.getProjCoordinates(sklt.P0);
double t1 = other_sklt.getProjCoordinates(sklt.P1);
double t0_crop = Max(-1, t0);
double t1_crop = Min(1, t1);
// no overlapping along this direction
if (t0_crop >= t1_crop)
{
return false;
}
// crop along this direction
else
{
// move center
Vector3 c = other_sklt.getPosition((t0+t1)/2);
Vector3 c_crop = other_sklt.getPosition((t0_crop+t1_crop)/2);
Center += c_crop - c;
// change extent
Vector3 p0 = other_sklt.getPosition(t0_crop);
Vector3 p1 = other_sklt.getPosition(t1_crop);
Extent[i] = (p0 - p1).norm()/2;
}
}
return true;
}
void Model::onDebugDraw( DebugDrawer& debug, DebugDrawFlags debugFlags )
{
const Skeleton* skeleton = mesh->getSkeleton().get();
if( !skeleton ) return;
if( bones.empty() ) return;
if( !debugRenderable )
debugRenderable = createDebugRenderable();
GeometryBuffer* gb = debugRenderable->getGeometryBuffer().get();
std::vector<Vector3> pos;
std::vector<Vector3> colors;
size_t numBones = skeleton->bones.size();
for( size_t i = 0; i < numBones; ++i )
{
Bone* bone = skeleton->bones[i].get();
Vector3 vertex;
Vector3 parentVertex;
if( bone->indexParent == -1 )
continue;
parentVertex = bones[bone->indexParent]*parentVertex;
pos.push_back( bones[bone->index]*vertex );
colors.push_back( Color::Blue );
pos.push_back( parentVertex);
colors.push_back( Color::Blue );
}
gb->set( VertexAttribute::Position, pos );
gb->set( VertexAttribute::Color, colors );
debug.renderables.push_back(debugRenderable.get());
}
void SkeletonDrawable::drawPrimitives (DrawEnv *pEnv)
{
if(getSkeleton() == NULL)
{
FWARNING(("SkeletonDrawable::drawPrimitives:: no skeleton!\n"));;
}
else
{
Pnt3f BoneStart(0.0,0.0,0.0),BoneEnd(0.0,0.0,0.0);
Int32 ParentIndex;
glBegin(GL_LINES);
for(UInt32 i(0) ; i<getSkeleton()->getNumJoints() ; ++i)
{
//Draw all Root Joints of Skeleton
ParentIndex = getSkeleton()->getJointParentIndex(i);
if(ParentIndex >= 0)
{
if(getDrawPose())
{
BoneStart.setValues(0.0,0.0,0.0);
BoneEnd.setValues(0.0,0.0,0.0);
getSkeleton()->getAbsoluteTransformation(i).mult(BoneEnd,BoneEnd);
getSkeleton()->getAbsoluteTransformation(ParentIndex).mult(BoneStart,BoneStart);
glColor4fv(getPoseColor().getValuesRGBA());
glVertex3fv(BoneStart.getValues());
glVertex3fv(BoneEnd.getValues());
}
if(getDrawBindPose())
{
BoneStart.setValues(0.0f,0.0f,0.0f);
BoneEnd.setValues(0.0f,0.0f,0.0f);
getSkeleton()->getAbsoluteBindTransformation(i).mult(BoneEnd,BoneEnd);
getSkeleton()->getAbsoluteBindTransformation(ParentIndex).mult(BoneStart,BoneStart);
glColor4fv(getBindPoseColor().getValuesRGBA());
glVertex3fv(BoneStart.getValues());
glVertex3fv(BoneEnd.getValues());
}
}
}
glEnd();
}
}
void getSkels(std::vector<mapping_msgs::PolygonalMap> &pmaps, body_msgs::Skeletons &skels){
XnUserID aUsers[15];
XnUInt16 nUsers = 15;
g_UserGenerator.GetUsers(aUsers, nUsers);
for (int i = 0; i < nUsers; ++i)
{
if (g_bDrawSkeleton && g_UserGenerator.GetSkeletonCap().IsTracking(aUsers[i]))
{
body_msgs::Skeleton skel;
getSkeleton(aUsers[i],skel);
skels.skeletons.push_back(skel);
mapping_msgs::PolygonalMap pmap;
getPolygon(aUsers[i], XN_SKEL_HEAD, XN_SKEL_NECK, pmap);
// printPt(aUsers[i], XN_SKEL_RIGHT_HAND);
getPolygon(aUsers[i], XN_SKEL_NECK, XN_SKEL_LEFT_SHOULDER, pmap);
getPolygon(aUsers[i], XN_SKEL_LEFT_SHOULDER, XN_SKEL_LEFT_ELBOW, pmap);
getPolygon(aUsers[i], XN_SKEL_LEFT_SHOULDER, XN_SKEL_RIGHT_SHOULDER, pmap);
// ptdist(pmap.polygons.back());
getPolygon(aUsers[i], XN_SKEL_LEFT_ELBOW, XN_SKEL_LEFT_HAND, pmap);
getPolygon(aUsers[i], XN_SKEL_NECK, XN_SKEL_RIGHT_SHOULDER, pmap);
getPolygon(aUsers[i], XN_SKEL_RIGHT_SHOULDER, XN_SKEL_RIGHT_ELBOW, pmap);
getPolygon(aUsers[i], XN_SKEL_RIGHT_ELBOW, XN_SKEL_RIGHT_HAND, pmap);
getPolygon(aUsers[i], XN_SKEL_LEFT_SHOULDER, XN_SKEL_TORSO, pmap);
getPolygon(aUsers[i], XN_SKEL_RIGHT_SHOULDER, XN_SKEL_TORSO, pmap);
getPolygon(aUsers[i], XN_SKEL_TORSO, XN_SKEL_LEFT_HIP, pmap);
getPolygon(aUsers[i], XN_SKEL_LEFT_HIP, XN_SKEL_LEFT_KNEE, pmap);
getPolygon(aUsers[i], XN_SKEL_LEFT_KNEE, XN_SKEL_LEFT_FOOT, pmap);
getPolygon(aUsers[i], XN_SKEL_TORSO, XN_SKEL_RIGHT_HIP, pmap);
getPolygon(aUsers[i], XN_SKEL_RIGHT_HIP, XN_SKEL_RIGHT_KNEE, pmap);
getPolygon(aUsers[i], XN_SKEL_RIGHT_KNEE, XN_SKEL_RIGHT_FOOT, pmap);
getPolygon(aUsers[i], XN_SKEL_LEFT_HIP, XN_SKEL_RIGHT_HIP, pmap);
// getSkel(aUsers[i],pmap);
pmaps.push_back(pmap);
}
}
}
void Model::setAnimation(Animation* animation)
{
assert( mesh != nullptr );
if( !mesh->isAnimated() ) return;
if( !animation ) return;
AnimationState state;
state.animation = animation;
state.animationTime = 0;
size_t numBones = mesh->getSkeleton()->getBones().size();
state.bonesMatrix.resize(numBones);
if( animations.empty() )
animations.push_back(state);
else
animations[0] = state;
animationEnabled = true;
}
void World::setState(const Eigen::VectorXd& _newState)
{
for (int i = 0; i < getNumSkeletons(); i++)
{
int start = mIndices[i] * 2;
int size = getSkeleton(i)->getNumDofs();
VectorXd pose = _newState.segment(start, size);
VectorXd qDot = _newState.segment(start + size, size);
getSkeleton(i)->clampRotation(pose, qDot);
if (getSkeleton(i)->getImmobileState())
{
// need to update node transformation for collision
getSkeleton(i)->setPose(pose, true, false);
}
else
{
// need to update first derivatives for collision
getSkeleton(i)->setPose(pose, false, true);
getSkeleton(i)->computeDynamics(mGravity, qDot, true);
}
}
}
osgDB::ReaderWriter::ReadResult OsgFbxReader::readFbxNode(
FbxNode* pNode,
bool& bIsBone, int& nLightCount)
{
if (FbxNodeAttribute* lNodeAttribute = pNode->GetNodeAttribute())
{
FbxNodeAttribute::EType attrType = lNodeAttribute->GetAttributeType();
switch (attrType)
{
case FbxNodeAttribute::eNurbs:
case FbxNodeAttribute::ePatch:
case FbxNodeAttribute::eNurbsCurve:
case FbxNodeAttribute::eNurbsSurface:
{
FbxGeometryConverter lConverter(&pSdkManager);
#if FBXSDK_VERSION_MAJOR < 2014
if (!lConverter.TriangulateInPlace(pNode))
#else
if (!lConverter.Triangulate(lNodeAttribute,true,false))
#endif
{
OSG_WARN << "Unable to triangulate FBX NURBS " << pNode->GetName() << std::endl;
}
}
break;
default:
break;
}
}
bIsBone = false;
bool bCreateSkeleton = false;
FbxNodeAttribute::EType lAttributeType = FbxNodeAttribute::eUnknown;
if (pNode->GetNodeAttribute())
{
lAttributeType = pNode->GetNodeAttribute()->GetAttributeType();
if (lAttributeType == FbxNodeAttribute::eSkeleton)
{
bIsBone = true;
}
}
if (!bIsBone && fbxSkeletons.find(pNode) != fbxSkeletons.end())
{
bIsBone = true;
}
unsigned nMaterials = pNode->GetMaterialCount();
std::vector<StateSetContent > stateSetList;
for (unsigned i = 0; i < nMaterials; ++i)
{
FbxSurfaceMaterial* fbxMaterial = pNode->GetMaterial(i);
assert(fbxMaterial);
stateSetList.push_back(fbxMaterialToOsgStateSet.convert(fbxMaterial));
}
osg::NodeList skeletal, children;
int nChildCount = pNode->GetChildCount();
for (int i = 0; i < nChildCount; ++i)
{
FbxNode* pChildNode = pNode->GetChild(i);
if (pChildNode->GetParent() != pNode)
{
//workaround for bug that occurs in some files exported from Blender
continue;
}
bool bChildIsBone = false;
osgDB::ReaderWriter::ReadResult childResult = readFbxNode(
pChildNode, bChildIsBone, nLightCount);
if (childResult.error())
{
return childResult;
}
else if (osg::Node* osgChild = childResult.getNode())
{
if (bChildIsBone)
{
if (!bIsBone) bCreateSkeleton = true;
skeletal.push_back(osgChild);
}
else
{
children.push_back(osgChild);
}
}
}
std::string animName = readFbxAnimation(pNode, pNode->GetName());
osg::Matrix localMatrix;
makeLocalMatrix(pNode, localMatrix);
bool bLocalMatrixIdentity = localMatrix.isIdentity();
osg::ref_ptr<osg::Group> osgGroup;
bool bEmpty = children.empty() && !bIsBone;
switch (lAttributeType)
{
case FbxNodeAttribute::eMesh:
{
size_t bindMatrixCount = boneBindMatrices.size();
osgDB::ReaderWriter::ReadResult meshRes = readFbxMesh(pNode, stateSetList);
if (meshRes.error())
{
return meshRes;
}
else if (osg::Node* node = meshRes.getNode())
{
bEmpty = false;
if (bindMatrixCount != boneBindMatrices.size())
{
//The mesh is skinned therefore the bind matrix will handle all transformations.
localMatrix.makeIdentity();
bLocalMatrixIdentity = true;
}
if (animName.empty() &&
children.empty() &&
skeletal.empty() &&
bLocalMatrixIdentity)
{
return osgDB::ReaderWriter::ReadResult(node);
}
children.insert(children.begin(), node);
}
}
break;
case FbxNodeAttribute::eCamera:
case FbxNodeAttribute::eLight:
{
osgDB::ReaderWriter::ReadResult res =
lAttributeType == FbxNodeAttribute::eCamera ?
readFbxCamera(pNode) : readFbxLight(pNode, nLightCount);
if (res.error())
{
return res;
}
else if (osg::Group* resGroup = dynamic_cast<osg::Group*>(res.getObject()))
{
bEmpty = false;
if (animName.empty() &&
bLocalMatrixIdentity)
{
osgGroup = resGroup;
}
else
{
children.insert(children.begin(), resGroup);
}
}
}
break;
default:
break;
}
if (bEmpty)
{
osgDB::ReaderWriter::ReadResult(0);
}
if (!osgGroup) osgGroup = createGroupNode(pSdkManager, pNode, animName, localMatrix, bIsBone, nodeMap, fbxScene);
osg::Group* pAddChildrenTo = osgGroup.get();
if (bCreateSkeleton)
{
osgAnimation::Skeleton* osgSkeleton = getSkeleton(pNode, fbxSkeletons, skeletonMap);
osgSkeleton->setDefaultUpdateCallback();
pAddChildrenTo->addChild(osgSkeleton);
pAddChildrenTo = osgSkeleton;
}
for (osg::NodeList::iterator it = skeletal.begin(); it != skeletal.end(); ++it)
{
pAddChildrenTo->addChild(it->get());
}
for (osg::NodeList::iterator it = children.begin(); it != children.end(); ++it)
{
pAddChildrenTo->addChild(it->get());
}
return osgDB::ReaderWriter::ReadResult(osgGroup.get());
}
