void FvXMLAnimationModelSerializerImpl::ReadAnimation( FvXMLSectionPtr spSection, Ogre::SceneNode* pkNode, FvAnimationModel* pkDest ) { Ogre::SceneManager *pkSceneManager = Ogre::Root::getSingleton(). _getCurrentSceneManager(); FV_ASSERT(pkSceneManager); FvString kAnimationName = spSection->ReadString("name"); bool bEnable = spSection->ReadBool("enable"); bool bLoop = spSection->ReadBool("loop"); FvString kIterpolationMode = spSection->ReadString("interpolationMode"); FvString kRotationIterpolationMode = spSection->ReadString("rotationInterpolationMode"); float fLength = spSection->ReadFloat("length"); if(!pkSceneManager->hasAnimation(pkNode->getName() + kAnimationName)) { std::vector<FvXMLSectionPtr> kKeyFrames; spSection->OpenSections("keyframe",kKeyFrames); Animation *pkAnimation = pkSceneManager->createAnimation(pkNode->getName() + kAnimationName, fLength); if(strcmp(kIterpolationMode.c_str(),"spline") == 0) pkAnimation->setInterpolationMode(Animation::IM_SPLINE); else pkAnimation->setInterpolationMode(Animation::IM_LINEAR); if(strcmp(kRotationIterpolationMode.c_str(),"spherical") == 0) pkAnimation->setRotationInterpolationMode(Animation::RIM_SPHERICAL); else pkAnimation->setRotationInterpolationMode(Animation::RIM_LINEAR); NodeAnimationTrack *pkAnimationTrack = pkAnimation->createNodeTrack( pkAnimation->getNumNodeTracks() + 1, pkNode); for (size_t stKeyframeIndex = 0; stKeyframeIndex < kKeyFrames.size(); stKeyframeIndex++) { float fTime = kKeyFrames[stKeyframeIndex]->ReadFloat("time"); FvVector3 kPosition = kKeyFrames[stKeyframeIndex]->ReadVector3("translation"); FvVector3 kScale = kKeyFrames[stKeyframeIndex]->ReadVector3("scale"); FvQuaternion kQuaternion = kKeyFrames[stKeyframeIndex]->ReadQuaternion("rotation"); TransformKeyFrame *pkKeyFrame = pkAnimationTrack->createNodeKeyFrame(fTime); pkKeyFrame->setTranslate(Vector3(kPosition.x,kPosition.y,kPosition.z)); pkKeyFrame->setRotation(Quaternion(kQuaternion.w,kQuaternion.x,kQuaternion.y,kQuaternion.z)); pkKeyFrame->setScale(Vector3(kScale.x,kScale.y,kScale.z)); } AnimationState *pkAnimationState = pkSceneManager->createAnimationState(pkNode->getName() + kAnimationName); pkAnimationState->setEnabled(bEnable); pkAnimationState->setLoop(bLoop); pkDest->m_kModelAnimations.insert(std::make_pair(kAnimationName,pkAnimationState)); } }
void OgreSample19App::tweakSneakAnim() { SkeletonPtr skel = SkeletonManager::getSingleton().load("jaiqua.skeleton",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Animation * anim = skel->getAnimation("Sneak"); Animation::NodeTrackIterator tracks = anim->getNodeTrackIterator(); while(tracks.hasMoreElements()) { NodeAnimationTrack * track = tracks.getNext(); TransformKeyFrame oldKf(0,0); track->getInterpolatedKeyFrame(ANIM_CHOP,&oldKf); while (track->getKeyFrame(track->getNumKeyFrames()-1)->getTime() >= ANIM_CHOP - 0.3f) { track->removeKeyFrame(track->getNumKeyFrames()-1); } TransformKeyFrame * newKf = track->createNodeKeyFrame(ANIM_CHOP); TransformKeyFrame * startKf = track->getNodeKeyFrame(0); Bone * bone = skel->getBone(track->getHandle()); if (bone->getName() == "Spineroot") { mSneakStartPos = startKf->getTranslate() + bone->getInitialPosition(); mSneakEndPos = oldKf.getTranslate() + bone->getInitialPosition(); mSneakStartPos.y = mSneakEndPos.y; newKf->setTranslate(oldKf.getTranslate()); newKf->setRotation(oldKf.getRotation()); newKf->setScale(oldKf.getScale()); } else { newKf->setTranslate(startKf->getTranslate()); newKf->setRotation(startKf->getRotation()); newKf->setScale(startKf->getScale()); } } }
// Just override the mandatory create scene method void createScene(void) { sceneMgr = mSceneMgr ; // Set ambient light mSceneMgr->setAmbientLight(ColourValue(0.75, 0.75, 0.75)); // Create a light Light* l = mSceneMgr->createLight("MainLight"); // Accept default settings: point light, white diffuse, just set position // NB I could attach the light to a SceneNode if I wanted it to move automatically with // other objects, but I don't l->setPosition(200,300,100); // Create water mesh and entity waterMesh = new WaterMesh(MESH_NAME, PLANE_SIZE, COMPLEXITY); waterEntity = mSceneMgr->createEntity(ENTITY_NAME, MESH_NAME); //~ waterEntity->setMaterialName(MATERIAL_NAME); SceneNode *waterNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(); waterNode->attachObject(waterEntity); // Add a head, give it it's own node headNode = waterNode->createChildSceneNode(); Entity *ent = mSceneMgr->createEntity("head", "ogrehead.mesh"); headNode->attachObject(ent); // Make sure the camera track this node //~ mCamera->setAutoTracking(true, headNode); // Create the camera node, set its position & attach camera SceneNode* camNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(); camNode->translate(0, 500, PLANE_SIZE); camNode->yaw(Degree(-45)); camNode->attachObject(mCamera); // Create light node SceneNode* lightNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(); lightNode->attachObject(l); // set up spline animation of light node Animation* anim = mSceneMgr->createAnimation("WaterLight", 20); NodeAnimationTrack *track ; TransformKeyFrame *key ; // create a random spline for light track = anim->createNodeTrack(0, lightNode); key = track->createNodeKeyFrame(0); for(int ff=1;ff<=19;ff++) { key = track->createNodeKeyFrame(ff); Vector3 lpos ( rand()%(int)PLANE_SIZE , //- PLANE_SIZE/2, rand()%300+100, rand()%(int)PLANE_SIZE //- PLANE_SIZE/2 ); key->setTranslate(lpos); } key = track->createNodeKeyFrame(20); // Create a new animation state to track this mAnimState = mSceneMgr->createAnimationState("WaterLight"); mAnimState->setEnabled(true); // Put in a bit of fog for the hell of it //mSceneMgr->setFog(FOG_EXP, ColourValue::White, 0.0002); // show overlay waterOverlay = OverlayManager::getSingleton().getByName("Example/WaterOverlay"); waterOverlay->show(); // Let there be rain particleSystem = mSceneMgr->createParticleSystem("rain", "Examples/Water/Rain"); particleEmitter = particleSystem->getEmitter(0); SceneNode* rNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(); rNode->translate(PLANE_SIZE/2.0f, 3000, PLANE_SIZE/2.0f); rNode->attachObject(particleSystem); // Fast-forward the rain so it looks more natural particleSystem->fastForward(20); // It can't be set in .particle file, and we need it ;) static_cast<BillboardParticleRenderer*>(particleSystem->getRenderer())->setBillboardOrigin(BBO_BOTTOM_CENTER); prepareCircleMaterial(); }
void Skeleton::_mergeSkeletonAnimations(const Skeleton* src, const BoneHandleMap& boneHandleMap, const StringVector& animations) { ushort handle; ushort numSrcBones = src->getNumBones(); ushort numDstBones = this->getNumBones(); if (boneHandleMap.size() != numSrcBones) { OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Number of bones in the bone handle map must equal to " "number of bones in the source skeleton.", "Skeleton::_mergeSkeletonAnimations"); } bool existsMissingBone = false; // Check source skeleton structures compatible with ourself (that means // identically bones with identical handles, and with same hierarchy, but // not necessary to have same number of bones and bone names). for (handle = 0; handle < numSrcBones; ++handle) { const Bone* srcBone = src->getBone(handle); ushort dstHandle = boneHandleMap[handle]; // Does it exists in target skeleton? if (dstHandle < numDstBones) { Bone* destBone = this->getBone(dstHandle); // Check both bones have identical parent, or both are root bone. const Bone* srcParent = static_cast<Bone*>(srcBone->getParent()); Bone* destParent = static_cast<Bone*>(destBone->getParent()); if ((srcParent || destParent) && (!srcParent || !destParent || boneHandleMap[srcParent->getHandle()] != destParent->getHandle())) { OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Source skeleton incompatible with this skeleton: " "difference hierarchy between bone '" + srcBone->getName() + "' and '" + destBone->getName() + "'.", "Skeleton::_mergeSkeletonAnimations"); } } else { existsMissingBone = true; } } // Clone bones if need if (existsMissingBone) { // Create missing bones for (handle = 0; handle < numSrcBones; ++handle) { const Bone* srcBone = src->getBone(handle); ushort dstHandle = boneHandleMap[handle]; // The bone is missing in target skeleton? if (dstHandle >= numDstBones) { Bone* dstBone = this->createBone(srcBone->getName(), dstHandle); // Sets initial transform dstBone->setPosition(srcBone->getInitialPosition()); dstBone->setOrientation(srcBone->getInitialOrientation()); dstBone->setScale(srcBone->getInitialScale()); dstBone->setInitialState(); } } // Link new bones to parent for (handle = 0; handle < numSrcBones; ++handle) { const Bone* srcBone = src->getBone(handle); ushort dstHandle = boneHandleMap[handle]; // Is new bone? if (dstHandle >= numDstBones) { const Bone* srcParent = static_cast<Bone*>(srcBone->getParent()); if (srcParent) { Bone* destParent = this->getBone(boneHandleMap[srcParent->getHandle()]); Bone* dstBone = this->getBone(dstHandle); destParent->addChild(dstBone); } } } // Derive root bones in case it was changed this->deriveRootBone(); // Reset binding pose for new bones this->reset(true); this->setBindingPose(); } // // We need to adapt animations from source to target skeleton, but since source // and target skeleton bones bind transform might difference, so we need to alter // keyframes in source to suit to target skeleton. // // For any given animation time, formula: // // LocalTransform = BindTransform * KeyFrame; // DerivedTransform = ParentDerivedTransform * LocalTransform // // And all derived transforms should be keep identically after adapt to // target skeleton, Then: // // DestDerivedTransform == SrcDerivedTransform // DestParentDerivedTransform == SrcParentDerivedTransform // ==> // DestLocalTransform = SrcLocalTransform // ==> // DestBindTransform * DestKeyFrame = SrcBindTransform * SrcKeyFrame // ==> // DestKeyFrame = inverse(DestBindTransform) * SrcBindTransform * SrcKeyFrame // // We define (inverse(DestBindTransform) * SrcBindTransform) as 'delta-transform' here. // // Calculate delta-transforms for all source bones. vector<DeltaTransform>::type deltaTransforms(numSrcBones); for (handle = 0; handle < numSrcBones; ++handle) { const Bone* srcBone = src->getBone(handle); DeltaTransform& deltaTransform = deltaTransforms[handle]; ushort dstHandle = boneHandleMap[handle]; if (dstHandle < numDstBones) { // Common bone, calculate delta-transform Bone* dstBone = this->getBone(dstHandle); deltaTransform.translate = srcBone->getInitialPosition() - dstBone->getInitialPosition(); deltaTransform.rotate = dstBone->getInitialOrientation().Inverse() * srcBone->getInitialOrientation(); deltaTransform.scale = srcBone->getInitialScale() / dstBone->getInitialScale(); // Check whether or not delta-transform is identity const Real tolerance = 1e-3f; Vector3 axis; Radian angle; deltaTransform.rotate.ToAngleAxis(angle, axis); deltaTransform.isIdentity = deltaTransform.translate.positionEquals(Vector3::ZERO, tolerance) && deltaTransform.scale.positionEquals(Vector3::UNIT_SCALE, tolerance) && Math::RealEqual(angle.valueRadians(), 0.0f, tolerance); } else { // New bone, the delta-transform is identity deltaTransform.translate = Vector3::ZERO; deltaTransform.rotate = Quaternion::IDENTITY; deltaTransform.scale = Vector3::UNIT_SCALE; deltaTransform.isIdentity = true; } } // Now copy animations ushort numAnimations; if (animations.empty()) numAnimations = src->getNumAnimations(); else numAnimations = static_cast<ushort>(animations.size()); for (ushort i = 0; i < numAnimations; ++i) { const Animation* srcAnimation; if (animations.empty()) { // Get animation of source skeleton by the given index srcAnimation = src->getAnimation(i); } else { // Get animation of source skeleton by the given name const LinkedSkeletonAnimationSource* linker; srcAnimation = src->_getAnimationImpl(animations[i], &linker); if (!srcAnimation || linker) { OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "No animation entry found named " + animations[i], "Skeleton::_mergeSkeletonAnimations"); } } // Create target animation Animation* dstAnimation = this->createAnimation(srcAnimation->getName(), srcAnimation->getLength()); // Copy interpolation modes dstAnimation->setInterpolationMode(srcAnimation->getInterpolationMode()); dstAnimation->setRotationInterpolationMode(srcAnimation->getRotationInterpolationMode()); // Copy track for each bone for (handle = 0; handle < numSrcBones; ++handle) { const DeltaTransform& deltaTransform = deltaTransforms[handle]; ushort dstHandle = boneHandleMap[handle]; if (srcAnimation->hasNodeTrack(handle)) { // Clone track from source animation const NodeAnimationTrack* srcTrack = srcAnimation->getNodeTrack(handle); NodeAnimationTrack* dstTrack = dstAnimation->createNodeTrack(dstHandle, this->getBone(dstHandle)); dstTrack->setUseShortestRotationPath(srcTrack->getUseShortestRotationPath()); ushort numKeyFrames = srcTrack->getNumKeyFrames(); for (ushort k = 0; k < numKeyFrames; ++k) { const TransformKeyFrame* srcKeyFrame = srcTrack->getNodeKeyFrame(k); TransformKeyFrame* dstKeyFrame = dstTrack->createNodeKeyFrame(srcKeyFrame->getTime()); // Adjust keyframes to match target binding pose if (deltaTransform.isIdentity) { dstKeyFrame->setTranslate(srcKeyFrame->getTranslate()); dstKeyFrame->setRotation(srcKeyFrame->getRotation()); dstKeyFrame->setScale(srcKeyFrame->getScale()); } else { dstKeyFrame->setTranslate(deltaTransform.translate + srcKeyFrame->getTranslate()); dstKeyFrame->setRotation(deltaTransform.rotate * srcKeyFrame->getRotation()); dstKeyFrame->setScale(deltaTransform.scale * srcKeyFrame->getScale()); } } } else if (!deltaTransform.isIdentity) { // Create 'static' track for this bone NodeAnimationTrack* dstTrack = dstAnimation->createNodeTrack(dstHandle, this->getBone(dstHandle)); TransformKeyFrame* dstKeyFrame; dstKeyFrame = dstTrack->createNodeKeyFrame(0); dstKeyFrame->setTranslate(deltaTransform.translate); dstKeyFrame->setRotation(deltaTransform.rotate); dstKeyFrame->setScale(deltaTransform.scale); dstKeyFrame = dstTrack->createNodeKeyFrame(dstAnimation->getLength()); dstKeyFrame->setTranslate(deltaTransform.translate); dstKeyFrame->setRotation(deltaTransform.rotate); dstKeyFrame->setScale(deltaTransform.scale); } } } }
void createSampleLights() { // Create some lights std::vector<MLight*> lights; SceneNode *parentNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("LightsParent"); // Create light nodes std::vector<Node*> nodes; MLight *a = mSystem->createMLight(); SceneNode *an = parentNode->createChildSceneNode(); an->attachObject(a); a->setAttenuation(1.0f, 0.001f, 0.002f); //a->setAttenuation(1.0f, 0.000f, 0.000f); an->setPosition(0,0,25); a->setDiffuseColour(1,0,0); //a->setSpecularColour(0.5,0,0); lights.push_back(a); nodes.push_back(an); MLight *b = mSystem->createMLight(); SceneNode *bn = parentNode->createChildSceneNode(); bn->attachObject(b); b->setAttenuation(1.0f, 0.001f, 0.003f); bn->setPosition(25,0,0); b->setDiffuseColour(1,1,0); //b->setSpecularColour(0.5,0.5,0); lights.push_back(b); nodes.push_back(bn); MLight *c = mSystem->createMLight(); SceneNode *cn = parentNode->createChildSceneNode(); cn->attachObject(c); c->setAttenuation(1.0f, 0.001f, 0.004f); cn->setPosition(0,0,-25); c->setDiffuseColour(0,1,1); c->setSpecularColour(0.25,1.0,1.0); // Cyan light has specular component lights.push_back(c); nodes.push_back(cn); MLight *d = mSystem->createMLight(); SceneNode *dn = parentNode->createChildSceneNode(); dn->attachObject(d); d->setAttenuation(1.0f, 0.002f, 0.002f); dn->setPosition(-25,0,0); d->setDiffuseColour(1,0,1); d->setSpecularColour(0.0,0,0.0); lights.push_back(d); nodes.push_back(dn); MLight *e = mSystem->createMLight(); SceneNode *en = parentNode->createChildSceneNode(); en->attachObject(e); e->setAttenuation(1.0f, 0.002f, 0.0025f); en->setPosition(25,0,25); e->setDiffuseColour(0,0,1); e->setSpecularColour(0,0,0); lights.push_back(e); nodes.push_back(en); MLight *f = mSystem->createMLight(); SceneNode *fn = parentNode->createChildSceneNode(); fn->attachObject(f); f->setAttenuation(1.0f, 0.0015f, 0.0021f); fn->setPosition(-25,0,-25); f->setDiffuseColour(0,1,0); f->setSpecularColour(0,0.0,0.0); lights.push_back(f); nodes.push_back(fn); // Create marker meshes to show user where the lights are Entity *ent; GeomUtils::createSphere("PointLightMesh", 1.0f, 5, 5, true, true); for(std::vector<MLight*>::iterator i=lights.begin(); i!=lights.end(); ++i) { MLight* light = *i; ent = mSceneMgr->createEntity(light->getName()+"v", "PointLightMesh"); String matname = light->getName()+"m"; // Create coloured material MaterialPtr mat = MaterialManager::getSingleton().create(matname, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Pass* pass = mat->getTechnique(0)->getPass(0); pass->setDiffuse(0.0f,0.0f,0.0f,1.0f); pass->setAmbient(0.0f,0.0f,0.0f); pass->setSelfIllumination(light->getDiffuseColour()); ent->setMaterialName(matname); ent->setRenderQueueGroup(light->getRenderQueueGroup()); static_cast<SceneNode*>(light->getParentNode())->attachObject(ent); } // Store nodes for hiding/showing SharedData::getSingleton().mLightNodes = nodes; // Do some animation for node a-f // Generate helix structure float seconds_per_station = 1.0f; float r=35; //Vector3 base(0,-30,0); Vector3 base(-100, -30, 85); float h=120; const size_t s_to_top = 16; const size_t stations = s_to_top*2-1; float ascend = h/((float)s_to_top); float stations_per_revolution = 3.5f; size_t skip = 2; // stations between lights Vector3 station_pos[stations]; for(int x=0; x<s_to_top; ++x) { float theta = ((float)x/stations_per_revolution)*2.0f*Math::PI; station_pos[x] = base+Vector3(Math::Sin(theta)*r, ascend*x, Math::Cos(theta)*r); } for(int x=s_to_top; x<stations; ++x) { float theta = ((float)x/stations_per_revolution)*2.0f*Math::PI; station_pos[x] = base+Vector3(Math::Sin(theta)*r, h-ascend*(x-s_to_top), Math::Cos(theta)*r); } // Create a track for the light swarm Animation* anim = mSceneMgr->createAnimation("LightSwarmTrack", stations*seconds_per_station); // Spline it for nice curves anim->setInterpolationMode(Animation::IM_SPLINE); for(unsigned int x=0; x<nodes.size(); ++x) { // Create a track to animate the camera's node NodeAnimationTrack* track = anim->createNodeTrack(x, nodes[x]); for(int y=0; y<=stations; ++y) { // Setup keyframes TransformKeyFrame* key = track->createNodeKeyFrame(y*seconds_per_station); // A start position key->setTranslate(station_pos[(x*skip+y)%stations]); // Make sure size of light doesn't change key->setScale(nodes[x]->getScale()); } } // Create a new animation state to track this SharedData::getSingleton().mMLAnimState = mSceneMgr->createAnimationState("LightSwarmTrack"); SharedData::getSingleton().mMLAnimState->setEnabled(true); }
// Just override the mandatory create scene method void createScene(void) { RenderSystem *rs = Root::getSingleton().getRenderSystem(); const RenderSystemCapabilities* caps = rs->getCapabilities(); if (!caps->hasCapability(RSC_VERTEX_PROGRAM) || !(caps->hasCapability(RSC_FRAGMENT_PROGRAM))) { OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "Your card does not support vertex and fragment programs, so cannot " "run this demo. Sorry!", "DeferredShading::createScene"); } if (caps->getNumMultiRenderTargets()<2) { OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED, "Your card does not support at least two simultaneous render targets, so cannot " "run this demo. Sorry!", "DeferredShading::createScene"); } // Prepare athene mesh for normalmapping MeshPtr pAthene = MeshManager::getSingleton().load("athene.mesh", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); unsigned short src, dest; if (!pAthene->suggestTangentVectorBuildParams(VES_TANGENT, src, dest)) pAthene->buildTangentVectors(VES_TANGENT, src, dest); // Prepare knot mesh for normal mapping pAthene = MeshManager::getSingleton().load("knot.mesh", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); if (!pAthene->suggestTangentVectorBuildParams(VES_TANGENT, src, dest)) pAthene->buildTangentVectors(VES_TANGENT, src, dest); // Set ambient light mSceneMgr->setAmbientLight(ColourValue(0.2, 0.2, 0.15)); // Skybox mSceneMgr->setSkyBox(true, "DeferredDemo/SkyBox"); // Create "root" node SceneNode* rootNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(); Entity* athena = mSceneMgr->createEntity("Athena", "athene.mesh"); athena->setMaterialName("DeferredDemo/DeferredAthena"); SceneNode *aNode = rootNode->createChildSceneNode(); aNode->attachObject( athena ); aNode->setPosition(-100, 40, 100); // Create a prefab plane mPlane = new MovablePlane("ReflectPlane"); mPlane->d = 0; mPlane->normal = Vector3::UNIT_Y; MeshManager::getSingleton().createCurvedPlane("ReflectionPlane", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, *mPlane, 2000, 2000, -1000, 20, 20, true, 1, 10, 10, Vector3::UNIT_Z); mPlaneEnt = mSceneMgr->createEntity( "Plane", "ReflectionPlane" ); mPlaneNode = rootNode->createChildSceneNode(); mPlaneNode->attachObject(mPlaneEnt); mPlaneNode->translate(-5, -30, 0); //mPlaneNode->roll(Degree(5)); mPlaneEnt->setMaterialName("DeferredDemo/Ground"); // Create an entity from a model (will be loaded automatically) Entity* knotEnt = mSceneMgr->createEntity("Knot", "knot.mesh"); knotEnt->setMaterialName("DeferredDemo/RockWall"); knotEnt->setMeshLodBias(0.25f); // Create an entity from a model (will be loaded automatically) Entity* ogreHead = mSceneMgr->createEntity("Head", "ogrehead.mesh"); ogreHead->getSubEntity(0)->setMaterialName("DeferredDemo/Ogre/Eyes");// eyes ogreHead->getSubEntity(1)->setMaterialName("DeferredDemo/Ogre/Skin"); ogreHead->getSubEntity(2)->setMaterialName("DeferredDemo/Ogre/EarRing"); // earrings ogreHead->getSubEntity(3)->setMaterialName("DeferredDemo/Ogre/Tusks"); // tusks rootNode->createChildSceneNode( "Head" )->attachObject( ogreHead ); // Add a whole bunch of extra entities to fill the scene a bit Entity *cloneEnt; int N=4; for (int n = 0; n < N; ++n) { float theta = 2.0f*Math::PI*(float)n/(float)N; // Create a new node under the root SceneNode* node = mSceneMgr->createSceneNode(); // Random translate Vector3 nodePos; nodePos.x = Math::SymmetricRandom() * 40.0 + Math::Sin(theta) * 500.0; nodePos.y = Math::SymmetricRandom() * 20.0 - 40.0; nodePos.z = Math::SymmetricRandom() * 40.0 + Math::Cos(theta) * 500.0; node->setPosition(nodePos); Quaternion orientation(Math::SymmetricRandom(),Math::SymmetricRandom(),Math::SymmetricRandom(),Math::SymmetricRandom()); orientation.normalise(); node->setOrientation(orientation); rootNode->addChild(node); // Clone knot char cloneName[12]; sprintf(cloneName, "Knot%d", n); cloneEnt = knotEnt->clone(cloneName); // Attach to new node node->attachObject(cloneEnt); } mCamera->setPosition(-50, 100, 500); mCamera->lookAt(0,0,0); // show overlay Overlay* overlay = OverlayManager::getSingleton().getByName("Example/ShadowsOverlay"); overlay->show(); mSystem = new DeferredShadingSystem(mWindow->getViewport(0), mSceneMgr, mCamera); // Create main, moving light MLight* l1 = mSystem->createMLight();//"MainLight"); l1->setDiffuseColour(0.75f, 0.7f, 0.8f); l1->setSpecularColour(0.85f, 0.9f, 1.0f); SceneNode *lightNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(); lightNode->attachObject(l1); // Create a track for the light Animation* anim = mSceneMgr->createAnimation("LightTrack", 16); // Spline it for nice curves anim->setInterpolationMode(Animation::IM_SPLINE); // Create a track to animate the camera's node NodeAnimationTrack* track = anim->createNodeTrack(0, lightNode); // Setup keyframes TransformKeyFrame* key = track->createNodeKeyFrame(0); // A start position key->setTranslate(Vector3(300,300,-300)); key = track->createNodeKeyFrame(4);//B key->setTranslate(Vector3(300,300,300)); key = track->createNodeKeyFrame(8);//C key->setTranslate(Vector3(-300,300,300)); key = track->createNodeKeyFrame(12);//D key->setTranslate(Vector3(-300,300,-300)); key = track->createNodeKeyFrame(16);//D key->setTranslate(Vector3(300,300,-300)); // Create a new animation state to track this SharedData::getSingleton().mAnimState = mSceneMgr->createAnimationState("LightTrack"); SharedData::getSingleton().mAnimState->setEnabled(true); // Create some happy little lights createSampleLights(); // safely setup application's (not postfilter!) shared data SharedData::getSingleton().iCamera = mCamera; SharedData::getSingleton().iRoot = mRoot; SharedData::getSingleton().iWindow = mWindow; SharedData::getSingleton().iActivate = true; SharedData::getSingleton().iGlobalActivate = true; SharedData::getSingleton().iSystem = mSystem; SharedData::getSingleton().iMainLight = l1; }
void OgreSample14App::createLights() { mSceneMgr->setAmbientLight(ColourValue(0.1f, 0.1f, 0.1f)); NameValuePairList params; params["numberOfChains"] = "2"; params["maxElements"] = "80"; RibbonTrail * trail = (RibbonTrail*)mSceneMgr->createMovableObject("RibbonTrail",¶ms); mSceneMgr->getRootSceneNode()->attachObject(trail); trail->setMaterialName("Examples/LightRibbonTrail"); trail->setTrailLength(400); SceneNode* node; Animation* anim; NodeAnimationTrack* track; Light* light; BillboardSet* bbs; // create a light node node = mSceneMgr->getRootSceneNode()->createChildSceneNode(Vector3(50, 30, 0)); // create a 14 second animation with spline interpolation anim = mSceneMgr->createAnimation("Path1", 14); anim->setInterpolationMode(Animation::IM_SPLINE); track = anim->createNodeTrack(1, node); // create a node track for our animation // enter keyframes for our track to define a path for the light to follow track->createNodeKeyFrame(0)->setTranslate(Vector3(50, 30, 0)); track->createNodeKeyFrame(2)->setTranslate(Vector3(100, -30, 0)); track->createNodeKeyFrame(4)->setTranslate(Vector3(120, -80, 150)); track->createNodeKeyFrame(6)->setTranslate(Vector3(30, -80, 50)); track->createNodeKeyFrame(8)->setTranslate(Vector3(-50, 30, -50)); track->createNodeKeyFrame(10)->setTranslate(Vector3(-150, -20, -100)); track->createNodeKeyFrame(12)->setTranslate(Vector3(-50, -30, 0)); track->createNodeKeyFrame(14)->setTranslate(Vector3(50, 30, 0)); // create an animation state from the animation and enable it mYellowLightAnimState = mSceneMgr->createAnimationState("Path1"); mYellowLightAnimState->setEnabled(true); // set initial settings for the ribbon trail and add the light node trail->setInitialColour(0, 1.0f, 0.8f, 0); trail->setColourChange(0, 0.5f, 0.5f, 0.5f, 0.5f); trail->setInitialWidth(0, 5); trail->addNode(node); // attach a light with the same colour to the light node light = mSceneMgr->createLight(); light->setDiffuseColour(trail->getInitialColour(0)); node->attachObject(light); // attach a flare with the same colour to the light node bbs = mSceneMgr->createBillboardSet(1); bbs->createBillboard(Vector3::ZERO, trail->getInitialColour(0)); bbs->setMaterialName("Examples/Flare"); node->attachObject(bbs); // create a second light node node = mSceneMgr->getRootSceneNode()->createChildSceneNode(Vector3(-50, 100, 0)); // create a 10 second animation with spline interpolation anim = mSceneMgr->createAnimation("Path2", 10); anim->setInterpolationMode(Animation::IM_SPLINE); track = anim->createNodeTrack(1, node); // create a node track for our animation // enter keyframes for our track to define a path for the light to follow track->createNodeKeyFrame(0)->setTranslate(Vector3(-50, 100, 0)); track->createNodeKeyFrame(2)->setTranslate(Vector3(-100, 150, -30)); track->createNodeKeyFrame(4)->setTranslate(Vector3(-200, 0, 40)); track->createNodeKeyFrame(6)->setTranslate(Vector3(0, -150, 70)); track->createNodeKeyFrame(8)->setTranslate(Vector3(50, 0, 30)); track->createNodeKeyFrame(10)->setTranslate(Vector3(-50, 100, 0)); // create an animation state from the animation and enable it mGreenLightAnimState = mSceneMgr->createAnimationState("Path2"); mGreenLightAnimState->setEnabled(true); trail->setInitialColour(1,0.0f,1.0f,0.4f); trail->setColourChange(1,0.5f,0.5f,0.5f,0.5f); trail->addNode(node); // attach a light with the same colour to the light node light = mSceneMgr->createLight(); light->setDiffuseColour(trail->getInitialColour(1)); node->attachObject(light); // attach a flare with the same colour to the light node bbs = mSceneMgr->createBillboardSet(1); bbs->createBillboard(Vector3::ZERO, trail->getInitialColour(1)); bbs->setMaterialName("Examples/Flare"); node->attachObject(bbs); }
//----------------------------------------------------------------------------- void XsiSkeletonExporter::sampleAllBones(DeformerMap& deformers, std::vector<NodeAnimationTrack*> deformerTracks, double frame, Real time, float fps, AxisAlignedBox& AABBPadding) { CValueArray args; CValue dummy; args.Resize(2); // set the playcontrol args[0] = L"PlayControl.Key"; args[1] = frame; mXsiApp.ExecuteCommand(L"SetValue", args, dummy); args[0] = L"PlayControl.Current"; mXsiApp.ExecuteCommand(L"SetValue", args, dummy); // Refresh mXsiApp.ExecuteCommand(L"Refresh", CValueArray(), dummy); // Sample all bones for (DeformerMap::iterator di = deformers.begin(); di != deformers.end(); ++di) { DeformerEntry* deformer = di->second; NodeAnimationTrack* track = deformerTracks[deformer->boneID]; double initposx, initposy, initposz; deformer->initialXform.GetTranslationValues(initposx, initposy, initposz); double initrotx, initroty, initrotz; deformer->initialXform.GetRotation().GetXYZAngles(initrotx, initroty, initrotz); double initsclx, initscly, initsclz; deformer->initialXform.GetScalingValues(initsclx, initscly, initsclz); XSI::MATH::CMatrix4 invTrans = deformer->initialXform.GetMatrix4(); invTrans.InvertInPlace(); XSI::MATH::CTransformation transformation; if (deformer->pBone->getParent() == 0) { // Based on global transformation = deformer->obj.GetKinematics().GetGlobal().GetTransform(); } else { // Based on local transformation = deformer->obj.GetKinematics().GetLocal().GetTransform(); } double posx, posy, posz; transformation.GetTranslationValues(posx, posy, posz); double sclx, scly, sclz; transformation.GetScalingValues(sclx, scly, sclz); // Make relative to initial XSI::MATH::CMatrix4 transformationMatrix = transformation.GetMatrix4(); transformationMatrix.MulInPlace(invTrans); transformation.SetMatrix4(transformationMatrix); // create keyframe TransformKeyFrame* kf = track->createNodeKeyFrame(time); // not sure why inverted transform doesn't work for position, but it doesn't // I thought XSI used same transform order as OGRE kf->setTranslate(Vector3(posx - initposx, posy - initposy, posz - initposz)); kf->setRotation(XSItoOgre(transformation.GetRotationQuaternion())); kf->setScale(Vector3(sclx / initsclx, scly / initscly, sclz / initsclz)); // Derive AABB of bone positions, for padding animated mesh AABB XSI::MATH::CVector3 bonePos = deformer->obj.GetKinematics().GetGlobal().GetTransform().GetTranslation(); AABBPadding.merge(XSItoOgre(bonePos)); } }
void Sample_VolumeTex::setupContent() { // Create dynamic texture ptex = TextureManager::getSingleton().createManual( "DynaTex","General", TEX_TYPE_3D, 64, 64, 64, 0, PF_A8R8G8B8); // Set ambient light mSceneMgr->setAmbientLight(ColourValue(0.6, 0.6, 0.6)); mSceneMgr->setSkyBox(true, "Examples/MorningSkyBox", 50 ); //mRoot->getRenderSystem()->clearFrameBuffer(FBT_COLOUR, ColourValue(255,255,255,0)); // Create a light Light* l = mSceneMgr->createLight("MainLight"); l->setDiffuseColour(0.75, 0.75, 0.80); l->setSpecularColour(0.9, 0.9, 1); l->setPosition(-100,80,50); mSceneMgr->getRootSceneNode()->attachObject(l); // Create volume renderable snode = mSceneMgr->getRootSceneNode()->createChildSceneNode(Vector3(0,0,0)); vrend = new VolumeRenderable(32, 750.0f, "DynaTex"); snode->attachObject( vrend ); trend = new ThingRenderable(90.0f, 32, 7.5f); trend->setMaterial("Examples/VTDarkStuff"); snode->attachObject(trend); // Ogre head node fnode = mSceneMgr->getRootSceneNode()->createChildSceneNode(Vector3(0,0,0)); // Load ogre head Entity* head = mSceneMgr->createEntity("head", "ogrehead.mesh"); fnode->attachObject(head); // Animation for ogre head // Create a track for the light Animation* anim = mSceneMgr->createAnimation("OgreTrack", 10); // Spline it for nice curves anim->setInterpolationMode(Animation::IM_SPLINE); // Create a track to animate the camera's node NodeAnimationTrack* track = anim->createNodeTrack(0, fnode); // Setup keyframes TransformKeyFrame* key = track->createNodeKeyFrame(0); // A startposition key->setTranslate(Vector3(0.0f, -15.0f, 0.0f)); key = track->createNodeKeyFrame(5);//B key->setTranslate(Vector3(0.0f, 15.0f, 0.0f)); key = track->createNodeKeyFrame(10);//C key->setTranslate(Vector3(0.0f, -15.0f, 0.0f)); // Create a new animation state to track this mOgreAnimState = mSceneMgr->createAnimationState("OgreTrack"); mOgreAnimState->setEnabled(true); //mFountainNode->attachObject(pSys2); //Setup defaults global_real = 0.4f; global_imag = 0.6f; global_theta = 0.0f; // show GUI createControls(); setDragLook(true); generate(); }
void OgreSample18App::createScene() { mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE); mCurrentShadowTechnique = SHADOWTYPE_STENCIL_ADDITIVE; // Set ambient light off mSceneMgr->setAmbientLight(ColourValue(0.0, 0.0, 0.0)); // Fixed light, dim mSunLight = mSceneMgr->createLight("SunLight"); mSunLight->setType(Light::LT_SPOTLIGHT); mSunLight->setPosition(1500,1750,1300); mSunLight->setSpotlightRange(Degree(30), Degree(50)); Ogre::Vector3 dir; dir = -mSunLight->getPosition(); dir.normalise(); mSunLight->setDirection(dir); mSunLight->setDiffuseColour(0.35, 0.35, 0.38); mSunLight->setSpecularColour(0.9, 0.9, 1); // Point light, movable, reddish mLight = mSceneMgr->createLight("Light2"); mLight->setDiffuseColour(mMinLightColour); mLight->setSpecularColour(1, 1, 1); mLight->setAttenuation(8000,1,0.0005,0); // Create light node mLightNode = mSceneMgr->getRootSceneNode()->createChildSceneNode( "MovingLightNode"); mLightNode->attachObject(mLight); // create billboard set BillboardSet* bbs = mSceneMgr->createBillboardSet("lightbbs", 1); bbs->setMaterialName("Examples/Flare"); Billboard* bb = bbs->createBillboard(0,0,0,mMinLightColour); // attach mLightNode->attachObject(bbs); ControllerFunctionRealPtr func = ControllerFunctionRealPtr(new WaveformControllerFunction(Ogre::WFT_SINE,0.75f,0.5f)); ControllerManager& contMgr = ControllerManager::getSingleton(); ControllerValueRealPtr val = ControllerValueRealPtr(new LightWibbler(mLight,bb,mMinLightColour,mMaxLightColour,mMinFlareSize,mMaxFlareSize)); mController = contMgr.createController(contMgr.getFrameTimeSource(),val,func); mLightNode->setPosition(Vector3(300,1750,-700)); Animation* anim = mSceneMgr->createAnimation("LightTrack", 20); // Spline it for nice curves anim->setInterpolationMode(Animation::IM_SPLINE); // Create a track to animate the camera's node NodeAnimationTrack* track = anim->createNodeTrack(0, mLightNode); // Setup keyframes TransformKeyFrame* key = track->createNodeKeyFrame(0); // A startposition key->setTranslate(Vector3(300,750,-700)); key = track->createNodeKeyFrame(2);//B key->setTranslate(Vector3(150,800,-250)); key = track->createNodeKeyFrame(4);//C key->setTranslate(Vector3(-150,850,-100)); key = track->createNodeKeyFrame(6);//D key->setTranslate(Vector3(-400,700,-200)); key = track->createNodeKeyFrame(8);//E key->setTranslate(Vector3(-200,700,-400)); key = track->createNodeKeyFrame(10);//F key->setTranslate(Vector3(-100,850,-200)); key = track->createNodeKeyFrame(12);//G key->setTranslate(Vector3(-100,575,180)); key = track->createNodeKeyFrame(14);//H key->setTranslate(Vector3(0,750,300)); key = track->createNodeKeyFrame(16);//I key->setTranslate(Vector3(100,850,100)); key = track->createNodeKeyFrame(18);//J key->setTranslate(Vector3(250,800,0)); key = track->createNodeKeyFrame(20);//K == A key->setTranslate(Vector3(300,750,-700)); // Create a new animation state to track this mAnimState = mSceneMgr->createAnimationState("LightTrack"); mAnimState->setEnabled(true); mLightNode->setAutoTracking(true,mSceneMgr->getRootSceneNode()); MeshPtr pAthene = MeshManager::getSingleton().load("athene.mesh", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); unsigned short src, dest; if (!pAthene->suggestTangentVectorBuildParams(VES_TANGENT, src, dest)) { pAthene->buildTangentVectors(VES_TANGENT, src, dest); } SceneNode* node; node = mSceneMgr->getRootSceneNode()->createChildSceneNode(); mAthene = mSceneMgr->createEntity( "athene", "athene.mesh" ); mAthene->setMaterialName(BASIC_ATHENE_MATERIAL); node->attachObject( mAthene ); node->yaw(Degree(90)); Entity* pEnt; // Columns for (int x = -2; x <= 2; ++x) { for (int z = -2; z <= 2; ++z) { if (x != 0 || z != 0) { StringUtil::StrStreamType str; str << "col" << x << "_" << z; node = mSceneMgr->getRootSceneNode()->createChildSceneNode(); pEnt = mSceneMgr->createEntity( str.str(), "column.mesh" ); pEnt->setMaterialName(BASIC_ROCKWALL_MATERIAL); pColumns.push_back(pEnt); node->attachObject( pEnt ); node->translate(x*300,0, z*300); } } } // Skybox mSceneMgr->setSkyBox(true, "Examples/StormySkyBox"); // Floor plane (use POSM plane def) mPlane = new MovablePlane("*mPlane"); mPlane->normal = Vector3::UNIT_Y; mPlane->d = 107; MeshManager::getSingleton().createPlane("Myplane", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, *mPlane, 1500,1500,50,50,true,1,5,5,Vector3::UNIT_Z); pPlaneEnt = mSceneMgr->createEntity( "plane", "Myplane" ); pPlaneEnt->setMaterialName(BASIC_ROCKWALL_MATERIAL); pPlaneEnt->setCastShadows(false); mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt); if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_HWRENDER_TO_TEXTURE)) { mSceneMgr->setShadowTextureSettings(1024,2); } else { mSceneMgr->setShadowTextureSettings(512,2); } mSceneMgr->setShadowColour(ColourValue(0.5f,0.5f,0.5f)); //handles; resetMaterials(); materialChanged(0); configureLights(ShadowTechnique::SHADOWTYPE_STENCIL_MODULATIVE); }
SkeletonPtr MergeSkeleton::bake() { MeshCombiner::getSingleton().log( "Baking: New Skeleton started" ); SkeletonPtr sp = SkeletonManager::getSingleton().create( "mergeSkeleton", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true ); for( std::vector< Ogre::SkeletonPtr >::iterator it = m_Skeletons.begin(); it != m_Skeletons.end(); ++it ) { if( it == m_Skeletons.begin() ) { MeshCombiner::getSingleton().log( "Baking: using " + (*it)->getName() + " as the base skeleton" ); MeshCombiner::getSingleton().log( "Baking: adding bones" ); Skeleton::BoneIterator bit = (*it)->getBoneIterator(); while( bit.hasMoreElements() ) { Bone* bone = bit.getNext(); Bone* newbone = sp->createBone( bone->getName(), bone->getHandle() ); newbone->setScale( bone->getScale() ); newbone->setOrientation( bone->getOrientation() ); newbone->setPosition( bone->getPosition() ); } MeshCombiner::getSingleton().log( "Baking: building bone hierarchy" ); // bone hierarchy bit = (*it)->getBoneIterator(); while( bit.hasMoreElements() ) { Bone* bone = bit.getNext(); Node* pnode = bone->getParent(); if( pnode != NULL ) { Bone* pbone = static_cast<Bone*>( pnode ); sp->getBone( pbone->getHandle() )->addChild( sp->getBone( bone->getHandle() ) ); } } } MeshCombiner::getSingleton().log( "Baking: adding animations for " + (*it)->getName() ); // insert all animations for (unsigned short a=0; a < (*it)->getNumAnimations(); ++a ) { Animation* anim = (*it)->getAnimation( a ); Animation* newanim = sp->createAnimation( anim->getName(), anim->getLength() ); if( anim->getNumNodeTracks() > 0 ) MeshCombiner::getSingleton().log( "Baking: adding node tracks" ); for( unsigned short na=0; na < anim->getNumNodeTracks(); ++na ) { if( anim->hasNodeTrack( na ) ) { NodeAnimationTrack* nat = anim->getNodeTrack( na ); NodeAnimationTrack* newnat = newanim->createNodeTrack( na ); // all key frames for( unsigned short nf=0; nf < nat->getNumKeyFrames(); ++nf ) { TransformKeyFrame* tkf = nat->getNodeKeyFrame( nf ); TransformKeyFrame* newtkf = newnat->createNodeKeyFrame( tkf->getTime() ); newtkf->setRotation( tkf->getRotation() ); newtkf->setTranslate( tkf->getTranslate() ); newtkf->setScale( tkf->getScale() ); } newnat->setAssociatedNode( sp->getBone( nat->getHandle() ) ); } } if( anim->getNumNumericTracks() > 0 ) MeshCombiner::getSingleton().log( "Baking: adding numeric tracks" ); for( unsigned short na=0; na < anim->getNumNumericTracks(); ++na ) { if( anim->hasNumericTrack( na ) ) { NumericAnimationTrack* nat = anim->getNumericTrack( na ); NumericAnimationTrack* newnat = newanim->createNumericTrack( na ); // all key frames for( unsigned short nf=0; nf < nat->getNumKeyFrames(); ++nf ) { NumericKeyFrame* nkf = nat->getNumericKeyFrame( nf ); NumericKeyFrame* newnkf = newnat->createNumericKeyFrame( nkf->getTime() ); newnkf->setValue( nkf->getValue() ); } } } if( anim->getNumVertexTracks() > 0 ) MeshCombiner::getSingleton().log( "Baking: adding vertex tracks" ); for( unsigned short va=0; va < anim->getNumVertexTracks(); ++va ) { if( anim->hasVertexTrack( va ) ) { VertexAnimationTrack* vat = anim->getVertexTrack( va ); VertexAnimationTrack* newvat = newanim->createVertexTrack( va, vat->getAnimationType() ); // all key frames for( unsigned short nf=0; nf < vat->getNumKeyFrames(); ++nf ) { // all morphs VertexMorphKeyFrame* vmkf = vat->getVertexMorphKeyFrame( nf ); if( vmkf != NULL ) { VertexMorphKeyFrame* newvmkf = newvat->createVertexMorphKeyFrame( vmkf->getTime() ); // @todo vertex buffer copying correct?? HardwareVertexBufferSharedPtr buf = vmkf->getVertexBuffer(); HardwareVertexBufferSharedPtr newbuf = HardwareBufferManager::getSingleton().createVertexBuffer( buf->getVertexSize(), buf->getNumVertices(), buf->getUsage(), buf->hasShadowBuffer() ); newbuf->copyData( *buf.getPointer(), 0, 0, buf->getSizeInBytes() ); } // all poses VertexPoseKeyFrame* vpkf = vat->getVertexPoseKeyFrame( nf ); if( vpkf != NULL ) { VertexPoseKeyFrame* newvpkf = newvat->createVertexPoseKeyFrame( vpkf->getTime() ); VertexPoseKeyFrame::PoseRefIterator pit = vpkf->getPoseReferenceIterator(); while( pit.hasMoreElements() ) { VertexPoseKeyFrame::PoseRef pr = pit.getNext(); newvpkf->addPoseReference( pr.poseIndex, pr.influence ); } } } } } } } return sp; }