void IKChain::PushOgreBone(Ogre::Bone* OgreBone)
{
Ogre::Bone* oBone = OgreBone;
Ogre::Vector3 vecBonePos = oBone->getPosition();
oBone->setManuallyControlled(true);
IKJoint* oJoint = NULL;
if ( mLastPush == NULL )
{
// Root
oJoint = new IKJoint(oBone, NULL, oBone->getPosition().x + mMeshNode->getPosition().x, oBone->getPosition().y + mMeshNode->getPosition().y, oBone->getPosition().z + mMeshNode->getPosition().z);
mIKRoot = oJoint;
mJointCount = 1;
}
else
{
// Not root
Ogre::Vector3 vecParent = mLastPush->GetOgreBone()->_getDerivedPosition();
Ogre::Vector3 vecDerived = oBone->_getDerivedPosition();
Ogre::Vector3 vecJointPos = oBone->_getDerivedPosition() + mMeshNode->getPosition();
oJoint = new IKJoint(oBone, mLastPush, vecJointPos.x, vecJointPos.y, vecJointPos.z);
mLastPush->SetChild(oJoint);
mJointCount++;
mChainLength += vecParent.distance(oBone->_getDerivedPosition());
}
mLastPush = oJoint;
mIKEffector = oJoint;
cout << "Joint count " << mJointCount << endl;
}
void PhysicsComponent::receiveEvent(Event* event)
{
if (event->getType() == Event::PHYSICS_UPDATE) {
btTransform transform;
transform.setIdentity();
Ogre::Vector3 position = parent->getNode()->_getDerivedPosition();
Ogre::Quaternion orientation = parent->getNode()->_getDerivedOrientation();
if (this->getParent()->getGraphicComponent()->isAnimated() && false) {
Ogre::Bone* bone = parent->getOgreEntity()->getSkeleton()->getBone(0);
Ogre::Vector3 bone_converted_pos = parent->getNode()
->convertLocalToWorldPosition(bone->_getDerivedPosition());
Ogre::Quaternion bone_converted_or = parent->getNode()
->convertLocalToWorldOrientation(bone->_getDerivedOrientation());
Ogre::Vector3 bonePos =
parent->getNode()->_getDerivedPosition() +
parent->getNode()->_getDerivedOrientation() *
bone_converted_pos;
Ogre::Quaternion boneRot = parent->getNode()->_getDerivedOrientation() * (bone
->getInitialOrientation().Inverse() * bone->_getDerivedOrientation());
position = bone_converted_pos;
orientation = boneRot;
}
transform.setOrigin(BtOgre::Convert::toBullet(position));
transform.setRotation(BtOgre::Convert::toBullet(orientation));
state->setKinematicPos(transform);
}
}
/** See Ogre::ParticleEmitter. */
void _initParticle(Ogre::Particle *particle)
{
Ogre::Vector3 xOff, yOff, zOff;
// Call superclass
ParticleEmitter::_initParticle(particle);
xOff = Ogre::Math::SymmetricRandom() * mXRange;
yOff = Ogre::Math::SymmetricRandom() * mYRange;
zOff = Ogre::Math::SymmetricRandom() * mZRange;
#if OGRE_VERSION >= (1 << 16 | 10 << 8 | 0)
Ogre::Vector3& position = particle->mPosition;
Ogre::Vector3& direction = particle->mDirection;
Ogre::ColourValue& colour = particle->mColour;
Ogre::Real& totalTimeToLive = particle->mTotalTimeToLive;
Ogre::Real& timeToLive = particle->mTimeToLive;
#else
Ogre::Vector3& position = particle->position;
Ogre::Vector3& direction = particle->direction;
Ogre::ColourValue& colour = particle->colour;
Ogre::Real& totalTimeToLive = particle->totalTimeToLive;
Ogre::Real& timeToLive = particle->timeToLive;
#endif
position = xOff + yOff + zOff +
mParticleBone->_getDerivedOrientation().Inverse() * (mEmitterBone->_getDerivedPosition()
- mParticleBone->_getDerivedPosition());
// Generate complex data by reference
genEmissionColour(colour);
// NOTE: We do not use mDirection/mAngle for the initial direction.
Ogre::Radian hdir = mHorizontalDir + mHorizontalAngle*Ogre::Math::SymmetricRandom();
Ogre::Radian vdir = mVerticalDir + mVerticalAngle*Ogre::Math::SymmetricRandom();
direction = (mParticleBone->_getDerivedOrientation().Inverse()
* mEmitterBone->_getDerivedOrientation() *
Ogre::Quaternion(hdir, Ogre::Vector3::UNIT_Z) *
Ogre::Quaternion(vdir, Ogre::Vector3::UNIT_X)) *
Ogre::Vector3::UNIT_Z;
genEmissionVelocity(direction);
// Generate simpler data
timeToLive = totalTimeToLive = genEmissionTTL();
}
Transform GfxBody::getBoneWorldTransform (unsigned n)
{
checkBone(n);
Ogre::Bone *bone = skeleton->getBone(n);
Transform t(from_ogre(bone->_getDerivedPosition()), from_ogre(bone->_getDerivedOrientation()), from_ogre(bone->_getDerivedScale()));
updateWorldTransform();
return worldTransform * t;
}
Vector3 CAnimatedEntity::getBoneWorldPosition(std::string boneName)
{
Ogre::Bone* bone = _entity->getSkeleton()->getBone(boneName);
Ogre::Quaternion parentQuat = _entityNode->_getDerivedOrientation();
Ogre::Vector3 parentPos = _entityNode->_getDerivedPosition();
Ogre::Vector3 bonePos = bone->_getDerivedPosition();
Ogre::Vector3 worldPos = parentQuat * bonePos + parentPos;
return worldPos;
}
void VLogicModel::_updateLocatorPos()
{
for (VLocatorMap::iterator itr = mLocators.begin(); itr != mLocators.end(); ++itr)
{
VLocatorValue &tempValue = itr->second;
// 只更新创建出来的（已经使用的）locator node
if (tempValue.mLocatorNode != VNULL)
{
if (!tempValue.mBoneName.empty())
{
Ogre::Bone *bone = VNULL;
try
{
bone = mSkeleton->getBone(tempValue.mBoneName);
}
catch (const Ogre::Exception &e)
{
Ogre::LogManager::getSingleton().logMessage("LogicModel::_updateLocatorPos " + mName + e.getDescription());
continue;
}
assert(bone != VNULL);
Ogre::SceneNode *locatorNode = tempValue.mLocatorNode;
assert(locatorNode != VNULL);
locatorNode->setPosition(bone->_getDerivedPosition());
locatorNode->setOrientation(bone->_getDerivedOrientation());
if (tempValue.mTranslateFirst)
{
// 先平移，再旋转
locatorNode->translate(tempValue.mPosition, Ogre::Node::TS_LOCAL);
locatorNode->rotate(tempValue.mOrientation, Ogre::Node::TS_LOCAL);
}
else
{
// 先旋转，再平移
locatorNode->rotate(tempValue.mOrientation, Ogre::Node::TS_LOCAL);
locatorNode->translate(tempValue.mPosition, Ogre::Node::TS_LOCAL);
}
}
}
}
if (mLocators.size() != 0)
{
mModelMainNode->_update(true, false);
}
}
void IKChain::Initialize()
{
// Get skeleton root Ogre::Bone
Ogre::Bone* oBoneRoot = mOgreSkeleton->getRootBone();
Ogre::Vector3 vecBonePos = oBoneRoot->getPosition();
oBoneRoot->setManuallyControlled(true);
// Create IK root
mIKRoot = new IKJoint(oBoneRoot, NULL, oBoneRoot->getPosition().x + mMeshNode->getPosition().x, oBoneRoot->getPosition().y + mMeshNode->getPosition().y, oBoneRoot->getPosition().z + mMeshNode->getPosition().z);
// Keep track of previously processed Ogre::Bone
IKJoint* oLastIKJoint = mIKRoot;
// Current Ogre::Bone
Ogre::Bone* oCurrentBone = oBoneRoot;
cout << "Current Ogre::Bone: " << oCurrentBone->getName() << endl;
mJointCount = 1;
// Ogre::Bone iterator
Ogre::Node::ChildNodeIterator oIterator = oCurrentBone->getChildIterator();
Ogre::Vector3 vecParent = oBoneRoot->_getDerivedPosition();
while ( oIterator.hasMoreElements() )
{
oCurrentBone = (Ogre::Bone*)oIterator.getNext();
oCurrentBone->setManuallyControlled(true);
cout << "Current Ogre::Bone: " << oCurrentBone->getName() << endl;
Ogre::Vector3 vecDerived = oCurrentBone->_getDerivedPosition();
Ogre::Vector3 vecJointPos = oCurrentBone->_getDerivedPosition() + mMeshNode->getPosition();
vecBonePos = oCurrentBone->getPosition();
IKJoint* oNewJoint = new IKJoint(oCurrentBone, oLastIKJoint, vecJointPos.x, vecJointPos.y, vecJointPos.z);
oLastIKJoint->SetChild(oNewJoint);
oLastIKJoint = oNewJoint;
oIterator = oCurrentBone->getChildIterator();
mJointCount++;
mChainLength += vecParent.distance(oCurrentBone->_getDerivedPosition());
vecParent = oCurrentBone->_getDerivedPosition();
}
mChainLength = mChainLength;
mIKEffector = oLastIKJoint;
cout << "Ogre::Bone count is " << mJointCount << endl;
}
static void updateBoneTree(const Ogre::SkeletonInstance *skelsrc, Ogre::Bone *bone)
{
if(skelsrc->hasBone(bone->getName()))
{
Ogre::Bone *srcbone = skelsrc->getBone(bone->getName());
if(!srcbone->getParent() || !bone->getParent())
{
bone->setOrientation(srcbone->getOrientation());
bone->setPosition(srcbone->getPosition());
bone->setScale(srcbone->getScale());
}
else
{
bone->_setDerivedOrientation(srcbone->_getDerivedOrientation());
bone->_setDerivedPosition(srcbone->_getDerivedPosition());
bone->setScale(Ogre::Vector3::UNIT_SCALE);
}
}
Ogre::Node::ChildNodeIterator boneiter = bone->getChildIterator();
while(boneiter.hasMoreElements())
updateBoneTree(skelsrc, static_cast<Ogre::Bone*>(boneiter.getNext()));
}
void Animation::handleShapes(std::vector<Nif::NiTriShapeCopy>* allshapes, Ogre::Entity* creaturemodel, Ogre::SkeletonInstance *skel){
shapeNumber = 0;
if (allshapes == NULL || creaturemodel == NULL || skel == NULL)
{
return;
}
std::vector<Nif::NiTriShapeCopy>::iterator allshapesiter;
for(allshapesiter = allshapes->begin(); allshapesiter != allshapes->end(); allshapesiter++)
{
//std::map<unsigned short, PosAndRot> vecPosRot;
Nif::NiTriShapeCopy& copy = *allshapesiter;
std::vector<Ogre::Vector3>* allvertices = ©.vertices;
//std::set<unsigned int> vertices;
//std::set<unsigned int> normals;
//std::vector<Nif::NiSkinData::BoneInfoCopy> boneinfovector = copy.boneinfo;
std::map<int, std::vector<Nif::NiSkinData::IndividualWeight> >* verticesToChange = ©.vertsToWeights;
//std::cout << "Name " << copy.sname << "\n";
Ogre::HardwareVertexBufferSharedPtr vbuf = creaturemodel->getMesh()->getSubMesh(copy.sname)->vertexData->vertexBufferBinding->getBuffer(0);
Ogre::Real* pReal = static_cast<Ogre::Real*>(vbuf->lock(Ogre::HardwareBuffer::HBL_NORMAL));
std::vector<Ogre::Vector3> initialVertices = copy.morph.getInitialVertices();
//Each shape has multiple indices
if(initialVertices.size() )
{
if(copy.vertices.size() == initialVertices.size())
{
//Create if it doesn't already exist
if(shapeIndexI.size() == static_cast<std::size_t> (shapeNumber))
{
std::vector<int> vec;
shapeIndexI.push_back(vec);
}
if(time >= copy.morph.getStartTime() && time <= copy.morph.getStopTime()){
float x;
for (unsigned int i = 0; i < copy.morph.getAdditionalVertices().size(); i++){
int j = 0;
if(shapeIndexI[shapeNumber].size() <= i)
shapeIndexI[shapeNumber].push_back(0);
if(timeIndex(time,copy.morph.getRelevantTimes()[i],(shapeIndexI[shapeNumber])[i], j, x)){
int indexI = (shapeIndexI[shapeNumber])[i];
std::vector<Ogre::Vector3> relevantData = (copy.morph.getRelevantData()[i]);
float v1 = relevantData[indexI].x;
float v2 = relevantData[j].x;
float t = v1 + (v2 - v1) * x;
if ( t < 0 ) t = 0;
if ( t > 1 ) t = 1;
if( t != 0 && initialVertices.size() == copy.morph.getAdditionalVertices()[i].size())
{
for (unsigned int v = 0; v < initialVertices.size(); v++){
initialVertices[v] += ((copy.morph.getAdditionalVertices()[i])[v]) * t;
}
}
}
}
allvertices = &initialVertices;
}
shapeNumber++;
}
}
if(verticesToChange->size() > 0){
for(std::map<int, std::vector<Nif::NiSkinData::IndividualWeight> >::iterator iter = verticesToChange->begin();
iter != verticesToChange->end(); iter++)
{
std::vector<Nif::NiSkinData::IndividualWeight> inds = iter->second;
int verIndex = iter->first;
Ogre::Vector3 currentVertex = (*allvertices)[verIndex];
Nif::NiSkinData::BoneInfoCopy* boneinfocopy = &(allshapesiter->boneinfo[inds[0].boneinfocopyindex]);
Ogre::Bone *bonePtr = 0;
Ogre::Vector3 vecPos;
Ogre::Quaternion vecRot;
std::map<Nif::NiSkinData::BoneInfoCopy*, PosAndRot>::iterator result = vecRotPos.find(boneinfocopy);
if(result == vecRotPos.end()){
bonePtr = skel->getBone(boneinfocopy->bonename);
vecPos = bonePtr->_getDerivedPosition() + bonePtr->_getDerivedOrientation() * boneinfocopy->trafo.trans;
vecRot = bonePtr->_getDerivedOrientation() * boneinfocopy->trafo.rotation;
PosAndRot both;
both.vecPos = vecPos;
both.vecRot = vecRot;
vecRotPos[boneinfocopy] = both;
}
else{
PosAndRot both = result->second;
vecPos = both.vecPos;
vecRot = both.vecRot;
}
Ogre::Vector3 absVertPos = (vecPos + vecRot * currentVertex) * inds[0].weight;
for(std::size_t i = 1; i < inds.size(); i++){
boneinfocopy = &(allshapesiter->boneinfo[inds[i].boneinfocopyindex]);
result = vecRotPos.find(boneinfocopy);
if(result == vecRotPos.end()){
bonePtr = skel->getBone(boneinfocopy->bonename);
vecPos = bonePtr->_getDerivedPosition() + bonePtr->_getDerivedOrientation() * boneinfocopy->trafo.trans;
vecRot = bonePtr->_getDerivedOrientation() * boneinfocopy->trafo.rotation;
PosAndRot both;
both.vecPos = vecPos;
both.vecRot = vecRot;
vecRotPos[boneinfocopy] = both;
}
else{
PosAndRot both = result->second;
vecPos = both.vecPos;
vecRot = both.vecRot;
}
absVertPos += (vecPos + vecRot * currentVertex) * inds[i].weight;
}
Ogre::Real* addr = (pReal + 3 * verIndex);
*addr = absVertPos.x;
*(addr+1) = absVertPos.y;
*(addr+2) = absVertPos.z;
}
}
else
{
//Ogre::Bone *bonePtr = creaturemodel->getSkeleton()->getBone(copy.bonename);
Ogre::Quaternion shaperot = copy.trafo.rotation;
Ogre::Vector3 shapetrans = copy.trafo.trans;
float shapescale = copy.trafo.scale;
std::vector<std::string> boneSequence = copy.boneSequence;
Ogre::Vector3 transmult;
Ogre::Quaternion rotmult;
float scale;
if(boneSequence.size() > 0){
std::vector<std::string>::iterator boneSequenceIter = boneSequence.begin();
if(skel->hasBone(*boneSequenceIter)){
Ogre::Bone *bonePtr = skel->getBone(*boneSequenceIter);
transmult = bonePtr->getPosition();
rotmult = bonePtr->getOrientation();
scale = bonePtr->getScale().x;
boneSequenceIter++;
for(; boneSequenceIter != boneSequence.end(); boneSequenceIter++)
{
if(skel->hasBone(*boneSequenceIter)){
Ogre::Bone *bonePtr = skel->getBone(*boneSequenceIter);
// Computes C = B + AxC*scale
transmult = transmult + rotmult * bonePtr->getPosition();
rotmult = rotmult * bonePtr->getOrientation();
scale = scale * bonePtr->getScale().x;
}
//std::cout << "Bone:" << *boneSequenceIter << " ";
}
transmult = transmult + rotmult * shapetrans;
rotmult = rotmult * shaperot;
scale = shapescale * scale;
//std::cout << "Position: " << transmult << "Rotation: " << rotmult << "\n";
}
}
else
{
transmult = shapetrans;
rotmult = shaperot;
scale = shapescale;
}
// Computes C = B + AxC*scale
// final_vector = old_vector + old_rotation*new_vector*old_scale/
for(unsigned int i = 0; i < allvertices->size(); i++){
Ogre::Vector3 current = transmult + rotmult * (*allvertices)[i];
Ogre::Real* addr = pReal + i * 3;
*addr = current.x;
*(addr+1) = current.y;
*(addr + 2) = current.z;
}/*
for(int i = 0; i < allnormals.size(); i++){
Ogre::Vector3 current =rotmult * allnormals[i];
Ogre::Real* addr = pRealNormal + i * 3;
*addr = current.x;
*(addr+1) = current.y;
*(addr + 2) = current.z;
}*/
}
vbuf->unlock();
}
}
Vector3 GfxBody::getBoneWorldPosition (unsigned n)
{
checkBone(n);
Ogre::Bone *bone = skeleton->getBone(n);
return from_ogre(bone->_getDerivedPosition());
}
void NPCCharacter::_actionLook(const Ogre::Vector3& target)
{
Ogre::Bone* headBone;
std::string n = _node->getName();
Ogre::Skeleton* skel = static_cast<Ogre::Entity*>(_movableObject)->getSkeleton();
headBone = skel->getBone("Bip01_Head");
headBone->setManuallyControlled(true);
headBone->setInheritOrientation(true);
int nAnim = skel->getNumAnimations();
//have to do this to allow the head to turn properly.
for(int i = 0; i < nAnim; ++i)
{
skel->getAnimation(i)->destroyNodeTrack(headBone->getHandle());
}
Ogre::Vector3 test = headBone->_getDerivedPosition() * CHARACTER_SCALE_FACTOR + _node->getPosition();
Ogre::Vector3 dir = target - test;
Ogre::Quaternion nodeRot,boneRot;
Ogre::Euler boneEuler; boneEuler.setDirection(dir,true,false);
/*boneRot = _node->convertLocalToWorldOrientation(_node->getOrientation()) * headBone->_getDerivedOrientation();
Ogre::Vector3 boneTest = boneRot * Ogre::Vector3::UNIT_Z;*/
//Ogre::Vector3 boneTest = headBone->getOrientation() * Ogre::Vector3::UNIT_Z;
//turns the direction vector into a 2D normalized vector on the X/Z axis.
dir.y = 0;
dir.normalise();
//All of this ray query stuff is to make sure that the AI can "see" the target before attempting to look at it.
Ogre::SceneManager* scene = _node->getCreator();
Ogre::Ray ray(headBone->_getDerivedPosition() * CHARACTER_SCALE_FACTOR + _node->getPosition(),dir);
Ogre::RaySceneQuery* query = scene->createRayQuery(ray);
query->setSortByDistance(true);
query->setQueryMask(CHARACTER_MASK | SCENERY_MASK);
Ogre::RaySceneQueryResult results = query->execute();
bool withinView = false;
if(results.size() == 0)
{
withinView = true;
}
else
{
if(results.begin()->movable->getParentNode()->getName() == getName())
{
if(results.size() == 1)
{
withinView = true;
}
}
if(!withinView && results.size() > 1 && std::next(results.begin())->distance > test.distance(target))
{
withinView = true;
}
}
scene->destroyQuery(query);
if(withinView)
{
Ogre::Euler node;
Ogre::Euler t = headOrientation.getRotationTo(dir);
t.limitYaw(Ogre::Radian(3.0));
t.limitPitch(Ogre::Radian(0.0));
headOrientation = headOrientation + t;
headOrientation.limitYaw(Ogre::Degree(100));
headOrientation.limitPitch(Ogre::Degree(60));
headBone->setOrientation(headOrientation);
/*headBone->rotate(boneTest.getRotationTo(dir),Ogre::Node::TS_WORLD);
Ogre::Quaternion boneRotation = _node->convertLocalToWorldOrientation(_node->getOrientation()) * headBone->_getDerivedOrientation() * (Ogre::Quaternion(Ogre::Degree(180),Ogre::Vector3::UNIT_Y));
Ogre::Quaternion nodeRotation = _node->_getDerivedOrientation();
Ogre::Quaternion diff = nodeRotation.Inverse() * boneRotation;*/
}
_isActFinished = true;
}
PhysicsRagDoll::RagBone* PhysicsRagDoll::_addAllBones(PhysicsRagDoll::RagBone* parent, TiXmlElement* boneElement, Actor* parentActor)
{
// get the information for the bone represented by this element.
Ogre::Vector3 dir = getAttributeValueAsVector3(boneElement, "dir");
Ogre::Real length = getAttributeValueAsReal(boneElement, "length");
Ogre::Vector3 size = getAttributeValueAsVector3(boneElement, "size");
Ogre::String skeleton_bone = getAttributeValueAsStdString(boneElement, "skeleton_bone");
Ogre::Bone* ogrebone = mSkeleton->getBone(skeleton_bone);
Ogre::String shapestr = getAttributeValueAsStdString(boneElement, "shape");
PhysicsRagDoll::RagBone::BoneShape shape = PhysicsRagDoll::RagBone::BS_BOX;
if (shapestr=="box")
shape = PhysicsRagDoll::RagBone::BS_BOX;
if (shapestr=="capsule")
shape = PhysicsRagDoll::RagBone::BS_CAPSULE;
if (shapestr=="cylinder")
shape = PhysicsRagDoll::RagBone::BS_CYLINDER;
if (shapestr=="cone")
shape = PhysicsRagDoll::RagBone::BS_CONE;
if (shapestr=="ellipsoid")
shape = PhysicsRagDoll::RagBone::BS_ELLIPSOID;
if (shapestr=="hull")
shape = PhysicsRagDoll::RagBone::BS_CONVEXHULL;
Ogre::Real mass = getAttributeValueAsReal(boneElement, "mass");
///////////////////////////////////////////////////////////////////////////////
RagBone* me = _addBone(mWorld, parent, dir, shape, size, mass, ogrebone, parentActor);
///////////////////////////////////////////////////////////////////////////////
// position the bone.
Ogre::Quaternion boneorient = mNode->_getDerivedOrientation() * ogrebone->_getDerivedOrientation();
Ogre::Vector3 bonepos;
if (shape != PhysicsRagDoll::RagBone::BS_CONVEXHULL)
bonepos = mNode->_getFullTransform() * ogrebone->_getDerivedPosition() + (boneorient * (dir * (length*0.5f)));
else
bonepos = mNode->_getFullTransform() * ogrebone->_getDerivedPosition();
if (me->getBody())
me->getBody()->setPositionOrientation(bonepos, boneorient);
// set offsets
if (!parent)
{
Ogre::Quaternion offsetorient = (boneorient.Inverse()) * mNode->_getDerivedOrientation();
Ogre::Vector3 offsetpos = boneorient.Inverse() * (mNode->_getDerivedPosition() - bonepos);
me->setOffset(offsetorient, offsetpos);
}
// get the joint to connect this bone with it's parent.
if (parent && me->getBody())
{
TiXmlElement* jointElement = getChildNamed(boneElement, "Joint");
if (!jointElement)
{
// error!
LOG_ERROR(Logger::CORE, " Joint not found while creating Ragdoll! ");
return me;
}
Ogre::Vector3 jointpin = getAttributeValueAsVector3(jointElement, "pin");
Ogre::String jointtypestr = getAttributeValueAsStdString(jointElement, "type");
PhysicsRagDoll::JointType jointtype = PhysicsRagDoll::JT_BALLSOCKET;
if (jointtypestr == "ballsocket")
jointtype = PhysicsRagDoll::JT_BALLSOCKET;
if (jointtypestr == "hinge")
jointtype = PhysicsRagDoll::JT_HINGE;
Ogre::Real limit1 = getAttributeValueAsReal(jointElement, "limit1");
Ogre::Real limit2 = getAttributeValueAsReal(jointElement, "limit2");
Ogre::Vector3 jpos = mNode->_getFullTransform() * ogrebone->_getDerivedPosition();
Ogre::Vector3 jpin = (mNode->_getDerivedOrientation() * parent->getOgreBone()->_getDerivedOrientation()) * jointpin;
_joinBones(jointtype, parent, me, jpos, jpin, limit1, limit2, mWorld);
}
LOG_MESSAGE(Logger::CORE, " added bone from '"+ogrebone->getName()+"'.");
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// add all children of this bone.
for (TiXmlNode* cur = boneElement->FirstChild(); cur; cur = cur->NextSibling())
{
if (cur->Type() == TiXmlNode::ELEMENT && hasNodeName(cur, "Bone"))
{
_addAllBones(me, cur->ToElement(), parentActor);
}
}
return me;
}