void Actor::update(float deltaTime)
{
assert(mNode);
if(mNode->numAttachedObjects() == 0)
{
return;
}
Ogre::Entity* entity = dynamic_cast<Ogre::Entity*>(mNode->getAttachedObject(0));
if(!entity)
{
return;
}
Ogre::AnimationStateSet* set = entity->getAllAnimationStates();
if(!set)
{
return;
}
Ogre::AnimationStateIterator it = set->getAnimationStateIterator();
while(it.hasMoreElements())
{
Ogre::AnimationState* state = it.getNext();
if(state->getEnabled())
{
state->addTime(deltaTime);
}
}
}
NifOgre::EntityList NpcAnimation::insertBoundedPart(const std::string &mesh, int group, const std::string &bonename)
{
NifOgre::EntityList entities = NifOgre::Loader::createEntities(mEntityList.mSkelBase, bonename,
mInsert, mesh);
std::vector<Ogre::Entity*> &parts = entities.mEntities;
for(size_t i = 0;i < parts.size();i++)
{
parts[i]->getUserObjectBindings().setUserAny(Ogre::Any(group));
if (mVisibilityFlags != 0)
parts[i]->setVisibilityFlags(mVisibilityFlags);
for(unsigned int j=0; j < parts[i]->getNumSubEntities(); ++j)
{
Ogre::SubEntity* subEnt = parts[i]->getSubEntity(j);
subEnt->setRenderQueueGroup(subEnt->getMaterial()->isTransparent() ? RQG_Alpha : RQG_Main);
}
}
if(entities.mSkelBase)
{
Ogre::AnimationStateSet *aset = entities.mSkelBase->getAllAnimationStates();
Ogre::AnimationStateIterator asiter = aset->getAnimationStateIterator();
while(asiter.hasMoreElements())
{
Ogre::AnimationState *state = asiter.getNext();
state->setEnabled(false);
state->setLoop(false);
}
Ogre::SkeletonInstance *skelinst = entities.mSkelBase->getSkeleton();
Ogre::Skeleton::BoneIterator boneiter = skelinst->getBoneIterator();
while(boneiter.hasMoreElements())
boneiter.getNext()->setManuallyControlled(true);
}
return entities;
}
void HOO::Character::defineAnimations(void){
// if the mesh is define add the existing animations, else set to NULL
if (_entity){
Ogre::AnimationStateSet* set = _entity->getAllAnimationStates();
Ogre::AnimationStateIterator iter = set->getAnimationStateIterator();
while (iter.hasMoreElements()){
std::cout<< iter.getNext()->getAnimationName()<<std::endl;
}
_idleAniState=NULL;
_idleAnimation=NULL;
_bottomAniState=NULL;
_BottomAnimation=NULL;
_topAniState=NULL;
_TopAnimation=NULL;
_fightAniState=NULL;
_fightAnimation=NULL;
_jumpAnimation=NULL;
_jumpAnimation=NULL;
}
else{
_idleAniState=NULL;
_idleAnimation=NULL;
_bottomAniState=NULL;
_BottomAnimation=NULL;
_topAniState=NULL;
_TopAnimation=NULL;
_fightAniState=NULL;
_fightAnimation=NULL;
_jumpAnimation=NULL;
_jumpAnimation=NULL;
}
}
int main(int argc, char **argv)
{
if(argc <= 1 || argc > 2)
{
std::cout << "Invalid argument, it sould be : ./ogre_show_animationstate /path/name.mesh !\n";
return -1;
}
std::string nameMesh(argv[1]);
std::string pathMesh;
int index = nameMesh.size();
while(nameMesh[index] != '/')
{
index--;
if(index == 0)
{
pathMesh = "./";
break;
}
}
if(index != 0)
{
pathMesh = nameMesh.substr(0, index);
}
// Init
Ogre::Root* mRoot = new Ogre::Root();
new Ogre::DefaultHardwareBufferManager();
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("./", "FileSystem", "General");
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(pathMesh, "FileSystem", "General");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// load mesh
Ogre::MeshPtr mesh =
Ogre::MeshManager::getSingleton().load(nameMesh, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
// create & load a SkeletonInstance
Ogre::SkeletonInstance* skelInst = new Ogre::SkeletonInstance(mesh->getSkeleton());
skelInst->load();
// create & load an AnimationStateSet
Ogre::AnimationStateSet* animStateSet = new Ogre::AnimationStateSet();
mesh->_initAnimationState(animStateSet);
// show animation state
std::cout << "Animation states : \n";
Ogre::AnimationStateIterator iter = animStateSet->getAnimationStateIterator();
while(iter.hasMoreElements())
{
Ogre::AnimationState* animationState = iter.getNext();
std::cout << "\t- " << animationState->getAnimationName() << "\n";
}
return 0;
}
CharacterAnimation::CharacterAnimation(Ogre::Entity* ent)
{
Ogre::AnimationStateSet * anims = ent->getAllAnimationStates();
Ogre::AnimationStateIterator it = anims->getAnimationStateIterator();
while(it.hasMoreElements())
{
Ogre::AnimationState * as = it.getNext();
as->setWeight(0);
Animations.insert(std::make_pair(as->getAnimationName(), AnimState(as, 0, 5, 5, 1)));
}
ent->getSkeleton()->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
}
CreatureAnimation::CreatureAnimation(const MWWorld::Ptr& ptr): Animation()
{
mInsert = ptr.getRefData().getBaseNode();
MWWorld::LiveCellRef<ESM::Creature> *ref = ptr.get<ESM::Creature>();
assert (ref->mBase != NULL);
if(!ref->mBase->mModel.empty())
{
std::string mesh = "meshes\\" + ref->mBase->mModel;
mEntityList = NifOgre::NIFLoader::createEntities(mInsert, &mTextKeys, mesh);
for(size_t i = 0; i < mEntityList.mEntities.size(); i++)
{
Ogre::Entity *ent = mEntityList.mEntities[i];
ent->setVisibilityFlags(RV_Actors);
bool transparent = false;
for (unsigned int j=0; j < ent->getNumSubEntities() && !transparent; ++j)
{
Ogre::MaterialPtr mat = ent->getSubEntity(j)->getMaterial();
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements() && !transparent)
{
Ogre::Technique* tech = techIt.getNext();
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements() && !transparent)
{
Ogre::Pass* pass = passIt.getNext();
if (pass->getDepthWriteEnabled() == false)
transparent = true;
}
}
}
ent->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
}
if(mEntityList.mSkelBase)
{
Ogre::AnimationStateSet *aset = mEntityList.mSkelBase->getAllAnimationStates();
Ogre::AnimationStateIterator as = aset->getAnimationStateIterator();
while(as.hasMoreElements())
{
Ogre::AnimationState *state = as.getNext();
state->setEnabled(true);
state->setLoop(false);
}
}
}
}
std::vector<std::string> GfxBody::getAnimationNames (void)
{
std::vector<std::string> r;
if (dead) THROW_DEAD(className);
if (skeleton == NULL) GRIT_EXCEPT("GfxBody has no skeleton");
Ogre::AnimationStateIterator it = animationState.getAnimationStateIterator();
while (it.hasMoreElements()) r.push_back(it.getNext()->getAnimationName());
return r;
}
void ObjProperties::updateListAnim(Ogre::AnimationStateSet* anims)
{
if(anims != 0)
{
Ogre::AnimationStateIterator animNames = anims->getAnimationStateIterator();
while(animNames.hasMoreElements())
{
listAnimCombo->addItem(animNames.getNext()->getAnimationName().c_str());
}
loopCheckBox->setEnabled(true);
playCheckBox->setEnabled(true);
}
else
{
loopCheckBox->setEnabled(false);
playCheckBox->setEnabled(false);
}
}
void Viewer::createMesh(QListWidgetItem *item)
{
animationed=false;
if(animState != 0)
{
animState->setEnabled(false);
animState=0;
}
mainNode->detachAllObjects();
if(mainEnt != 0)
{
ogreSceneManager->destroyEntity(mainEnt->getName());
mainEnt=0;
}
mainEnt = ogreSceneManager->createEntity(item->text().toAscii().constData(), item->text().toAscii().constData());
mainEnt->setCastShadows(true);
mainNode->attachObject(mainEnt);
Ogre::Real CHAR_HEIGHT=mainEnt->getBoundingBox().getMinimum().y;
Ogre::Vector3 pos = mainNode->getPosition();
if (CHAR_HEIGHT < 0)
{
// if we've hit the ground, change to landing state
pos.y = -CHAR_HEIGHT;
mainNode->setPosition(pos);
}
else
{
pos.y = CHAR_HEIGHT;
mainNode->setPosition(pos);
}
emit clearAnim();
Ogre::AnimationStateSet *set=mainEnt->getAllAnimationStates();
if(set != 0)
{
Ogre::AnimationStateIterator seci = set->getAnimationStateIterator();
while (seci.hasMoreElements())
{
Ogre::AnimationState *anim=seci.getNext();
emit sendAnimName(anim->getAnimationName().c_str());
}
set=0;
}
updateGL();
}
void CAnimatedEntity::moveBone(const std::string &bone, float pitch) {
Ogre::Bone * entityBone = _entity->getSkeleton()->getBone(bone);
entityBone->reset();
Ogre::Skeleton * skel = _entity->getSkeleton();
//entityBone->setManuallyControlled(true);
unsigned short boneHandle = entityBone->getHandle();
Ogre::AnimationStateIterator animStateIt = _entity->getAllAnimationStates()->getAnimationStateIterator();
while( animStateIt.hasMoreElements() )
{
Ogre::AnimationState *pAnimState = animStateIt.getNext();
// ignore disabled animations
skel->getAnimation(pAnimState->getAnimationName())->destroyNodeTrack(boneHandle);
}
entityBone->pitch(Ogre::Radian(pitch));
}
void RenderBoxWrap::setAnimation(const Ogre::String& _animation)
{
if (nullptr != mEntityState) {
mEntityState = nullptr;
FrameAdvise(false);
}
if (_animation.empty()) return;
if (nullptr == mEntity) return;
Ogre::SkeletonInstance * skeleton = mEntity->getSkeleton();
if (nullptr == skeleton) return;
Ogre::AnimationStateSet * anim_set = mEntity->getAllAnimationStates();
// FIXME почему вместо всего что под ним не написать как в закомментированнои коде? ¤ его добавил, но протестить немогу просто
// посмотрел код getAnimationState - он как раз провер¤ет по имени с которым ты сравниваешь
/*
Ogre::AnimationState * state = anim_set->getAnimationState(_animation);
if (state != nullptr)
{
// тут то что стоит внутри твоего ифа
}
*/
Ogre::AnimationStateIterator iter = anim_set->getAnimationStateIterator();
while (iter.hasMoreElements()) {
Ogre::AnimationState * state = iter.getNext();
if (_animation == state ->getAnimationName()) {
// подписываемс¤
FrameAdvise(true);
mEntityState = state;
mEntityState->setEnabled(true);
mEntityState->setLoop(true);
mEntityState->setWeight(1.0f);
return;
}
}
MYGUI_LOG(Warning, "Unable to to set animation '" << _animation << "' - current entity don't have such animation.");
}
void
Player::disableAnimations()
{
Ogre::SceneManager::MovableObjectIterator iterator = SceneManager()->getMovableObjectIterator("Entity");
while(iterator.hasMoreElements())
{
Ogre::Entity* e = static_cast<Ogre::Entity*>(iterator.getNext());
if (e->hasSkeleton())
{
Ogre::AnimationStateIterator iter = e->getAllAnimationStates()->getAnimationStateIterator();
while(iter.hasMoreElements())
{
Ogre::AnimationState *animState = iter.getNext();
animState->setEnabled(false);
}
}
}
}
void MeshPersonVisual::setAnimationState(const std::string& nameOfAnimationState) {
Ogre::AnimationStateSet *animationStates = entity_->getAllAnimationStates();
if(animationStates != NULL)
{
Ogre::AnimationStateIterator animationsIterator = animationStates->getAnimationStateIterator();
while (animationsIterator.hasMoreElements())
{
Ogre::AnimationState *animationState = animationsIterator.getNext();
if(animationState->getAnimationName() == nameOfAnimationState || nameOfAnimationState.empty()) {
animationState->setLoop(true);
animationState->setEnabled(true);
m_animationState = animationState;
return;
}
}
// Not found. Set first animation state then.
ROS_WARN_STREAM_ONCE("Person mesh animation state " << nameOfAnimationState << " does not exist in mesh!");
setAnimationState("");
}
}
void AnimationSystem::createAnimations()
{
Ogre::AnimationStateSet* animationStates = getAnimationStateSet();
// Although there is an assert for this condition in the constructor, added check for
// safety in a release build.
if ( animationStates == NULL )
{
return;
}
Ogre::AnimationStateIterator it = animationStates->getAnimationStateIterator();
while ( it.hasMoreElements() )
{
Ogre::AnimationState* animationState = it.getNext();
if ( 0 < animationState->getLength() )
{
Animation* animation = new Animation( animationState );
addAnimation( animation );
}
}
}
//!
//! Clones an Ogre::MovableObject.
//!
//! Is needed because OGRE does not provide clone functions for cameras and
//! lights.
//!
//! \param movableObject The object to clone.
//! \param name The name to use for the object.
//! \param sceneManager The scene manager to use for creating the object.
//! \return The cloned object.
//!
Ogre::MovableObject * OgreTools::cloneMovableObject ( Ogre::MovableObject *movableObject, const QString &name, Ogre::SceneManager *sceneManager /* = 0 */ )
{
// make sure the given object is valid
if (!movableObject) {
Log::error("The given movable object is invalid.", "OgreTools::cloneMovableObject");
return 0;
}
// make sure a valid scene manager is available
if (!sceneManager)
sceneManager = movableObject->_getManager();
if (!sceneManager) {
Log::error("No valid scene manager available.", "OgreTools::cloneMovableObject");
return 0;
}
Ogre::MovableObject *result = 0;
Ogre::String typeName = movableObject->getMovableType();
if (typeName == "Entity") {
// clone entity
Ogre::Entity *entity = dynamic_cast<Ogre::Entity *>(movableObject);
//movableObjectCopy = entity->clone(name.toStdString());
Ogre::Entity *entityCopy = sceneManager->createEntity(name.toStdString(), entity->getMesh()->getName());
Ogre::AnimationStateSet *animationStateSet = entity->getAllAnimationStates();
Ogre::AnimationStateSet *animationStateSetCopy = entityCopy->getAllAnimationStates();
// set the same blend mode on entity copy
if (entity && entityCopy) {
if (entity->hasSkeleton() && entityCopy->hasSkeleton()) {
Ogre::Skeleton *skeleton = entity->getSkeleton();
Ogre::Skeleton *skeletonCopy = entityCopy->getSkeleton();
skeletonCopy->setBlendMode(skeleton->getBlendMode());
}
}
// copy all animation states
if (animationStateSet && animationStateSetCopy) {
Ogre::AnimationStateIterator animationStateIter = animationStateSet->getAnimationStateIterator();
Ogre::AnimationStateIterator animationStateCopyIter = animationStateSetCopy->getAnimationStateIterator();
while (animationStateIter.hasMoreElements()) {
if (!animationStateCopyIter.hasMoreElements())
break;
Ogre::AnimationState *animationState = animationStateIter.getNext();
Ogre::AnimationState *animationStateCopy = animationStateCopyIter.getNext();
animationStateCopy->setLoop(animationState->getLoop());
//bool enabled = animationState->getEnabled();
//animationStateCopy->setEnabled(animationState->getEnabled());
animationStateCopy->setEnabled(true);
animationStateCopy->setTimePosition(animationState->getTimePosition());
}
}
// create a new container for the cloned entity
OgreContainer *entityCopyContainer = new OgreContainer(entityCopy);
entityCopy->setUserAny(Ogre::Any(entityCopyContainer));
if (!entity->getUserAny().isEmpty()) {
OgreContainer *entityContainer = Ogre::any_cast<OgreContainer *>(entity->getUserAny());
if (entityContainer) {
QObject::connect(entityContainer, SIGNAL(animationStateUpdated(const QString &, double)), entityCopyContainer, SLOT(updateAnimationState(const QString &, double)));
QObject::connect(entityContainer, SIGNAL(boneTransformUpdated(const QString &, double, double, double, double, double, double)), entityCopyContainer, SLOT(updateBoneTransform(const QString &, double, double, double, double, double, double)));
}
}
result = dynamic_cast<Ogre::MovableObject *>(entityCopy);
} else if (typeName == "Light") {
// clone light
Ogre::Light *light = dynamic_cast<Ogre::Light *>(movableObject);
Ogre::Light *lightCopy = sceneManager->createLight(name.toStdString());
lightCopy->setType(light->getType());
lightCopy->setDiffuseColour(light->getDiffuseColour());
lightCopy->setSpecularColour(light->getSpecularColour());
lightCopy->setAttenuation(light->getAttenuationRange(), light->getAttenuationConstant(), light->getAttenuationLinear(), light->getAttenuationQuadric());
lightCopy->setPosition(light->getPosition());
lightCopy->setDirection(light->getDirection());
if (lightCopy->getType() == Ogre::Light::LT_SPOTLIGHT)
lightCopy->setSpotlightRange(light->getSpotlightInnerAngle(), light->getSpotlightOuterAngle(), light->getSpotlightFalloff());
lightCopy->setPowerScale(light->getPowerScale());
lightCopy->setCastShadows(light->getCastShadows());
// create a new container for the cloned light
OgreContainer *lightCopyContainer = new OgreContainer(lightCopy);
lightCopy->setUserAny(Ogre::Any(lightCopyContainer));
if (!light->getUserAny().isEmpty()) {
OgreContainer *lightContainer = Ogre::any_cast<OgreContainer *>(light->getUserAny());
if (lightContainer)
QObject::connect(lightContainer, SIGNAL(sceneNodeUpdated()), lightCopyContainer, SLOT(updateLight()));
}
result = dynamic_cast<Ogre::MovableObject *>(lightCopy);
} else if (typeName == "Camera") {
// clone camera
Ogre::Camera *camera = dynamic_cast<Ogre::Camera *>(movableObject);
Ogre::Camera *cameraCopy = sceneManager->createCamera(name.toStdString());
//cameraCopy->setCustomParameter(0, camera->getCustomParameter(0));
cameraCopy->setAspectRatio(camera->getAspectRatio());
cameraCopy->setAutoAspectRatio(camera->getAutoAspectRatio());
//cameraCopy->setAutoTracking(...);
cameraCopy->setCastShadows(camera->getCastsShadows());
//cameraCopy->setCullingFrustum(camera->getCullingFrustum());
//cameraCopy->setCustomParameter(...);
//cameraCopy->setCustomProjectionMatrix(..);
//cameraCopy->setCustomViewMatrix(..);
//cameraCopy->setDebugDisplayEnabled(...);
//cameraCopy->setDefaultQueryFlags(...);
//cameraCopy->setDefaultVisibilityFlags(...);
cameraCopy->setDirection(camera->getDirection());
//cameraCopy->setFixedYawAxis(...);
cameraCopy->setFocalLength(camera->getFocalLength());
cameraCopy->setFOVy(camera->getFOVy());
//Ogre::Real left;
//Ogre::Real right;
//Ogre::Real top;
//Ogre::Real bottom;
//camera->getFrustumExtents(left, right, top, bottom);
//cameraCopy->setFrustumExtents(left, right, top, bottom);
//cameraCopy->setFrustumOffset(camera->getFrustumOffset());
//cameraCopy->setListener(camera->getListener());
cameraCopy->setLodBias(camera->getLodBias());
//cameraCopy->setLodCamera(camera->getLodCamera());
cameraCopy->setNearClipDistance(camera->getNearClipDistance());
cameraCopy->setFarClipDistance(camera->getFarClipDistance());
cameraCopy->setOrientation(camera->getOrientation());
//cameraCopy->setOrthoWindow(...);
//cameraCopy->setOrthoWindowHeight(...);
//cameraCopy->setOrthoWindowWidth(...);
cameraCopy->setPolygonMode(camera->getPolygonMode());
cameraCopy->setPolygonModeOverrideable(camera->getPolygonModeOverrideable());
cameraCopy->setPosition(camera->getPosition());
cameraCopy->setProjectionType(camera->getProjectionType());
cameraCopy->setQueryFlags(camera->getQueryFlags());
cameraCopy->setRenderingDistance(camera->getRenderingDistance());
cameraCopy->setRenderQueueGroup(camera->getRenderQueueGroup());
//cameraCopy->setRenderSystemData(camera->getRenderSystemData());
cameraCopy->setUseIdentityProjection(camera->getUseIdentityProjection());
cameraCopy->setUseIdentityView(camera->getUseIdentityView());
//cameraCopy->setUserAny(camera->getUserAny());
cameraCopy->setUseRenderingDistance(camera->getUseRenderingDistance());
//cameraCopy->setUserObject(camera->getUserObject());
cameraCopy->setVisibilityFlags(camera->getVisibilityFlags());
cameraCopy->setVisible(camera->getVisible());
//cameraCopy->setWindow(...);
if (!movableObject->getUserAny().isEmpty()) {
CameraInfo *sourceCameraInfo = Ogre::any_cast<CameraInfo *>(movableObject->getUserAny());
if (sourceCameraInfo) {
CameraInfo *targetCameraInfo = new CameraInfo();
targetCameraInfo->width = sourceCameraInfo->width;
targetCameraInfo->height = sourceCameraInfo->height;
dynamic_cast<Ogre::MovableObject *>(cameraCopy)->setUserAny(Ogre::Any(targetCameraInfo));
}
}
//// Setup connections for instances
//SceneNode *targetSceneNode = new SceneNode(cameraCopy);
//((Ogre::MovableObject *)cameraCopy)->setUserAny(Ogre::Any(targetSceneNode));
//if (!((Ogre::MovableObject *)camera)->getUserAny().isEmpty()) {
// SceneNode *sourceSceneNode = Ogre::any_cast<SceneNode *>(((Ogre::MovableObject *)camera)->getUserAny());
// if (sourceSceneNode) {
// QObject::connect(sourceSceneNode, SIGNAL(sceneNodeUpdated()), targetSceneNode, SLOT(updateSceneNode()));
// }
//}
result = dynamic_cast<Ogre::MovableObject *>(cameraCopy);
}
if (!result)
Log::error(QString("Could not clone movable object \"%1\" of type \"%2\".").arg(movableObject->getName().c_str()).arg(typeName.c_str()), "OgreTools::cloneMovableObject");
return result;
}
NpcAnimation::NpcAnimation(const MWWorld::Ptr& ptr, Ogre::SceneNode* node, MWWorld::InventoryStore& _inv, int visibilityFlags)
: Animation(), mStateID(-1), mInv(_inv), timeToChange(0), mVisibilityFlags(visibilityFlags),
robe(mInv.end()), helmet(mInv.end()), shirt(mInv.end()),
cuirass(mInv.end()), greaves(mInv.end()),
leftpauldron(mInv.end()), rightpauldron(mInv.end()),
boots(mInv.end()),
leftglove(mInv.end()), rightglove(mInv.end()), skirtiter(mInv.end()),
pants(mInv.end())
{
MWWorld::LiveCellRef<ESM::NPC> *ref = ptr.get<ESM::NPC>();
for (int init = 0; init < 27; init++)
{
mPartslots[init] = -1; //each slot is empty
mPartPriorities[init] = 0;
}
const ESMS::ESMStore &store = MWBase::Environment::get().getWorld()->getStore();
const ESM::Race *race = store.races.find(ref->base->mRace);
std::string hairID = ref->base->mHair;
std::string headID = ref->base->mHead;
headModel = "meshes\\" + store.bodyParts.find(headID)->mModel;
hairModel = "meshes\\" + store.bodyParts.find(hairID)->mModel;
npcName = ref->base->mName;
isFemale = !!(ref->base->mFlags&ESM::NPC::Female);
isBeast = !!(race->mData.mFlags&ESM::Race::Beast);
bodyRaceID = "b_n_"+ref->base->mRace;
std::transform(bodyRaceID.begin(), bodyRaceID.end(), bodyRaceID.begin(), ::tolower);
mInsert = node;
assert(mInsert);
std::string smodel = (!isBeast ? "meshes\\base_anim.nif" : "meshes\\base_animkna.nif");
mEntityList = NifOgre::NIFLoader::createEntities(mInsert, &mTextKeys, smodel);
for(size_t i = 0;i < mEntityList.mEntities.size();i++)
{
Ogre::Entity *base = mEntityList.mEntities[i];
base->getUserObjectBindings ().setUserAny (Ogre::Any(-1));
base->setVisibilityFlags(mVisibilityFlags);
bool transparent = false;
for(unsigned int j=0;j < base->getNumSubEntities();++j)
{
Ogre::MaterialPtr mat = base->getSubEntity(j)->getMaterial();
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements())
{
Ogre::Technique* tech = techIt.getNext();
Ogre::Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements())
{
Ogre::Pass* pass = passIt.getNext();
if (pass->getDepthWriteEnabled() == false)
transparent = true;
}
}
}
base->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
}
if(mEntityList.mSkelBase)
{
Ogre::AnimationStateSet *aset = mEntityList.mSkelBase->getAllAnimationStates();
Ogre::AnimationStateIterator as = aset->getAnimationStateIterator();
while(as.hasMoreElements())
{
Ogre::AnimationState *state = as.getNext();
state->setEnabled(true);
state->setLoop(false);
}
}
float scale = race->mData.mHeight.mMale;
if (isFemale) {
scale = race->mData.mHeight.mFemale;
}
mInsert->scale(scale, scale, scale);
updateParts();
}
void Animation::setObjectRoot(const std::string &model, bool baseonly)
{
OgreAssert(mAnimSources.empty(), "Setting object root while animation sources are set!");
mSkelBase = NULL;
mObjectRoot.setNull();
if(model.empty())
return;
std::string mdlname = Misc::StringUtils::lowerCase(model);
std::string::size_type p = mdlname.rfind('\\');
if(p == std::string::npos)
p = mdlname.rfind('/');
if(p != std::string::npos)
mdlname.insert(mdlname.begin()+p+1, 'x');
else
mdlname.insert(mdlname.begin(), 'x');
if(!Ogre::ResourceGroupManager::getSingleton().resourceExistsInAnyGroup(mdlname))
{
mdlname = model;
Misc::StringUtils::toLower(mdlname);
}
mObjectRoot = (!baseonly ? NifOgre::Loader::createObjects(mInsert, mdlname) :
NifOgre::Loader::createObjectBase(mInsert, mdlname));
if(mObjectRoot->mSkelBase)
{
mSkelBase = mObjectRoot->mSkelBase;
Ogre::AnimationStateSet *aset = mObjectRoot->mSkelBase->getAllAnimationStates();
Ogre::AnimationStateIterator asiter = aset->getAnimationStateIterator();
while(asiter.hasMoreElements())
{
Ogre::AnimationState *state = asiter.getNext();
state->setEnabled(false);
state->setLoop(false);
}
// Set the bones as manually controlled since we're applying the
// transformations manually
Ogre::SkeletonInstance *skelinst = mObjectRoot->mSkelBase->getSkeleton();
Ogre::Skeleton::BoneIterator boneiter = skelinst->getBoneIterator();
while(boneiter.hasMoreElements())
boneiter.getNext()->setManuallyControlled(true);
// Reattach any objects that have been attached to this one
ObjectAttachMap::iterator iter = mAttachedObjects.begin();
while(iter != mAttachedObjects.end())
{
if(!skelinst->hasBone(iter->second))
mAttachedObjects.erase(iter++);
else
{
mSkelBase->attachObjectToBone(iter->second, iter->first);
++iter;
}
}
}
else
mAttachedObjects.clear();
for(size_t i = 0;i < mObjectRoot->mControllers.size();i++)
{
if(mObjectRoot->mControllers[i].getSource().isNull())
mObjectRoot->mControllers[i].setSource(mAnimationTimePtr[0]);
}
}