//-------------------------------------------------------------------------------------
void DeltaControl::createScene(void) {
mSceneMgr->setSkyBox(true, "StormySkyBox");
mControlCenter = new ControlCenter(mSceneMgr);
/* *********************************************************
* ENTITIES
* *********************************************************/
// Telephone* phone = new Telephone(mSceneMgr, "phone1");
// phone->init();
// Create entity from mesh and attach it to a scene node.
Ogre::SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
Ogre::Entity* ent = mSceneMgr->createEntity("Sinbad", "Sinbad.mesh");
node->attachObject(ent);
node->setPosition(0,50,0);
node->scale(10,10,10);
// Set animation blend mode to additive / cumulative.
ent->getSkeleton()->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
// Get the two halves of the idle animation
Ogre::AnimationState* baseAnim = ent->getAnimationState("IdleBase");
Ogre::AnimationState* topAnim = ent->getAnimationState("IdleTop");
// Enable both of them and set them to loop.
baseAnim->setLoop(true);
topAnim->setLoop(true);
baseAnim->setEnabled(true);
topAnim->setEnabled(true);
}
bool Pacman::heMuertoDelTodo() // :D :D
{
Ogre::Entity* pacmanEnt = static_cast<Ogre::Entity*>( node->getAttachedObject(PACMAN_NODE));
if (pacmanEnt->getAnimationState(PACMAN_DIES)->hasEnded())
{
pacmanEnt->getAnimationState(PACMAN_DIES)->setEnabled(false);
pacmanEnt->getAnimationState(PACMAN_EAT_ANIM)->setEnabled(true);
estoyMuriendo = false;
return true;
}
return false;
}
void Pacman::arrancaMuerte(Ogre::Real deltaT)
{
stop();
Ogre::AnimationState *anim;
Ogre::Entity* pacmanEnt = static_cast<Ogre::Entity*>( node->getAttachedObject(PACMAN_NODE));
anim = pacmanEnt->getAnimationState(PACMAN_EAT_ANIM);
anim->setEnabled(false);
anim = pacmanEnt->getAnimationState(PACMAN_DIES);
anim->addTime(deltaT);
anim->setEnabled(true);
anim->setLoop(false);
anim->setTimePosition(0.0);
estoyMuriendo = true;
}
void
PlayersManager::createPlayer(zappy::Player *player)
{
Ogre::Entity *ent;
Ogre::SceneNode *node;
Ogre::AnimationState *anim;
std::string id(NumberToString<unsigned int>(player->getId()));
OPlayer *toAdd;
ent = this->mSceneMgr->createEntity("Player" + id, "robot.mesh");
node = this->mSceneMgr->getRootSceneNode()->
createChildSceneNode(PLAYERNODENAME + id,
Ogre::Vector3(player->getX() * Constants::SquareSize,
0,
player->getY() * Constants::SquareSize));
ent->setQueryFlags(Constants::PLAYER_MASK);
anim = ent->getAnimationState("Idle");
anim->setLoop(true);
anim->setEnabled(true);
node->attachObject(ent);
player->setRendered(true);
toAdd = new OPlayer(ent, node);
toAdd->setSpell(this->mSceneMgr->createParticleSystem("Aureola" + id, "Examples/Aureola"));
toAdd->setBroad(this->mSceneMgr->createParticleSystem("Purple" + id, "Examples/PurpleFountain"));
this->mOPlayers.push_back(toAdd);
}
void Sample::setupScene()
{
mSceneMgr->setSkyBox(true, "spaceSkyBox");
// Set the scene's ambient light
mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f));
Ogre::Entity* pEntity = mSceneMgr->createEntity("SinbadInstance", "Sinbad.mesh");
Ogre::SceneNode* pNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
pNode->attachObject(pEntity);
pNode->setScale(Ogre::Vector3(3.0f));
mDance = pEntity->getAnimationState("Dance");
mDance->setEnabled(true);
mDance->setLoop(true);
mDance->setTimePosition(0);
Ogre::Light* pDirLight = mSceneMgr->createLight();
pDirLight->setDirection(Ogre::Vector3(0,-1,0));
pDirLight->setType(Ogre::Light::LT_DIRECTIONAL);
pNode->attachObject(pDirLight);
mCamera->setNearClipDistance(1.0f);
mCamera->setFarClipDistance(100000.0f);
mCamera->setPosition(0,0,30.0f);
mCamera->lookAt(0,0,0);
mCamera->setAutoAspectRatio(true);
Ogre::Viewport* vp = mWindow->addViewport(mCamera);
vp->setBackgroundColour(Ogre::ColourValue(1,0,0));
}
Barrel::Barrel(Ogre::Vector3 position, Ogre::Quaternion orientation,
const std::string& name, Ogre::SceneNode* sceneNode,
Ogre::Real speed, Ogre::Radian turnSpeed,
Ogre::Entity& entityMesh) :
MovableEntity(position, orientation, name, sceneNode, speed, turnSpeed),
selected(false),
node(NULL) {
animation = NULL;
loadAnimation();
for(unsigned int i = 0; i < numModels; ++i) {
modelNodes.push_back(sceneNode);
animationState = entityMesh.getAnimationState("Sneak");
animationState->setEnabled(true);
animationState->setLoop(true);
animationSpeeds.push_back(Ogre::Real(1.5f));
animationStates.push_back(animationState);
}
std::string selectid = Factory::getID() + "." + name + "/selected";
Ogre::Entity* pointerMesh = Game::getScene()->createEntity(selectid, "target.mesh");
pointerMesh->setMaterialName("target");
node = sceneNode->createChildSceneNode();
node->attachObject(pointerMesh);
node->setVisible(selected);
node->setPosition(position);
}
void *mesh_get_anim ( void *mesh, const char *name ) {
Ogre::Entity *e = static_cast<Ogre::Entity *> ( mesh );
Ogre::AnimationState *state = e->getAnimationState ( name );
//state->setEnabled(true);
//state->setLoop ( true );
return state;
}
ProfessorController(Root* root)
{
mProfessorNode = root->getSceneManager("main")->getSceneNode("Professor");
mProfessorEntity = root->getSceneManager("main")->getEntity("Professor");
mWalkSpeed = 80.0f;
mDirection = Vector3::ZERO;
mAnimationState = mProfessorEntity->getAnimationState("Walk");
mAnimationState->setEnabled(true);
mAnimationState->setLoop(true);
}
bool frameStarted(const FrameEvent &evt)
{
// Fill Here --------------------------------------------------------------
if (Vector3::ZERO == mDirection)
{
if (nextLocation())
{
mAnimationState = mProfessorEntity->getAnimationState("Walk");
mAnimationState->setLoop(true);
mAnimationState->setEnabled(true);
}
}
else // Vector3::ZERO != mDirection
{
Real move = mWalkSpeed * evt.timeSinceLastFrame;
mDistance -= move;
if (mDistance <= 0.f)
{ // 목표 지점에 다 왔으면
mProfessorNode->setPosition(mDestination);
mDestination = Vector3::ZERO;
if (!nextLocation())
{
mAnimationState->setEnabled(false);
mAnimationState = mProfessorEntity->getAnimationState("Idle");
mAnimationState->setLoop(true);
mAnimationState->setEnabled(true);
}
}
else
{
mProfessorNode->translate(mDirection * move);
}
}
// -------------------------------------------------------------------------
mAnimationState->addTime(evt.timeSinceLastFrame);
return true;
}
void OgreAppLogic::createScene(void)
{
// setup some basic lighting for our scene
mSceneMgr->setSkyDome(true, "Examples/CloudySky", 5, 8);
// make a cube to bounce around
Entity *ent1;
SceneNode *boxNode;
ManualObject *cmo = createCubeMesh("manual", "");
cmo->convertToMesh("cube");
ent1 = mSceneMgr->createEntity("Cube", "cube.mesh");
ent1->setCastShadows(true);
boxNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
boxNode->attachObject(ent1);
boxNode->setScale(Vector3(0.1,0.1,0.1)); // for some reason converttomesh multiplied dimensions by 10
mSceneMgr->setAmbientLight(ColourValue(0.3, 0.3, 0.3));
mSceneMgr->createLight()->setPosition(20, 80, 50);
// create a floor mesh resource
MeshManager::getSingleton().createPlane("floor", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Plane(Vector3::UNIT_Y, -30), 1000, 1000, 10, 10, true, 1, 8, 8, Vector3::UNIT_Z);
// create a floor entity, give it a material, and place it at the origin
Entity* floor = mSceneMgr->createEntity("Floor", "floor");
floor->setMaterialName("Examples/BumpyMetal");
mSceneMgr->getRootSceneNode()->attachObject(floor);
mSceneMgr->getRootSceneNode()->attachObject(mSceneMgr->createEntity("Head", "ogrehead.mesh"));
mSceneMgr->setSkyBox(true, "Examples/GridSkyBox");
Ogre::Entity* ent = mSceneMgr->createEntity("Sinbad.mesh"); //1x1_cube.mesh //Sinbad.mesh //axes.mesh
mObjectNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("cube");
mObjectNode->setOrientation(Quaternion(Degree(90.f), Vector3::UNIT_X));
Ogre::Real scale = 22;
mObjectNode->setPosition(10, 10, 10*scale);
mObjectNode->setScale(Ogre::Vector3::UNIT_SCALE*scale);
mObjectNode->attachObject(ent);
mObjectNode->setVisible(true);
// create swords and attach them to sinbad
Ogre::Entity* sword1 = mSceneMgr->createEntity("SinbadSword1", "Sword.mesh");
Ogre::Entity* sword2 = mSceneMgr->createEntity("SinbadSword2", "Sword.mesh");
ent->attachObjectToBone("Sheath.L", sword1);
ent->attachObjectToBone("Sheath.R", sword2);
mAnimState = ent->getAnimationState("Dance");
mAnimState->setLoop(true);
mAnimState->setEnabled(true);
}
bool frameStarted(const FrameEvent &evt)
{
if (mDirection == Vector3::ZERO)
{
if (nextLocation())
{
mAnimationState = mProfessorEntity->getAnimationState("Walk");
mAnimationState->setLoop(true);
mAnimationState->setEnabled(true);
}
}
else
{
Real move = mWalkSpeed * evt.timeSinceLastFrame; // 이동량 계산
mDistance -= move; // 남은 거리 계산
if (mDistance <= 0.0f)
{ // 목표 지점에 다 왔으면…
mProfessorNode->setPosition( mDestination ); // 목표 지점에 캐릭터를 위치
mDirection = Vector3::ZERO; // 정지 상태로 들어간다.
if (! nextLocation( ) )
{
mAnimationState->setEnabled(false);
mAnimationState = mProfessorEntity->getAnimationState( "Idle" );
mAnimationState->setLoop( true );
mAnimationState->setEnabled( true );
}
}
else
{
mProfessorNode->translate( mDirection * move );
}
}
mAnimationState->addTime(evt.timeSinceLastFrame);
return true;
}
Penguin::Penguin(Ogre::SceneManager* sceneMgr, std::string name) {
Ogre::Entity* entPenguin = sceneMgr->createEntity(name, "penguin.mesh");
mAnimationState = entPenguin->getAnimationState("amuse");
mAnimationState->setLoop(true);
mAnimationState->setEnabled(true);
entPenguin->setCastShadows(true);
Ogre::SceneNode* penguinNode = sceneMgr->getRootSceneNode()->createChildSceneNode(name, Ogre::Vector3(0,30,0));
penguinNode->attachObject(entPenguin);
penguinNode->scale(60 / 63.0057, 50 / 47.99059, 50 / 49.27139);
Ogre::Camera* cam = sceneMgr->getCamera("GameCam");
cameraNode = penguinNode->createChildSceneNode("CameraNode");
cameraNode->attachObject(cam);
setNode(penguinNode);
}
void
Player::stopAnimation(std::string anim)
{
Ogre::SceneManager::MovableObjectIterator iterator = SceneManager()->getMovableObjectIterator("Entity");
while(iterator.hasMoreElements())
{
Ogre::Entity* e = static_cast<Ogre::Entity*>(iterator.getNext());
if (e->hasSkeleton())
{
Ogre::AnimationState *animation = e->getAnimationState(anim);
animation->setEnabled(false);
animation->setTimePosition(0);
}
}
}
void createScene()
{
// Create the Entity
Ogre::Entity* robot = mSceneMgr->createEntity("Robot", "robot.mesh");
// Attach robot to scene graph
Ogre::SceneNode* RobotNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("Robot");
//RobotNode->setPosition((Ogre::Real)-0.3, (Ogre::Real)0.2, (Ogre::Real)0);
RobotNode->attachObject(robot);
RobotNode->scale((Ogre::Real)0.001,(Ogre::Real)0.001,(Ogre::Real)0.001);
RobotNode->pitch(Ogre::Degree(180));
RobotNode->yaw(Ogre::Degree(-90));
// The animation
// Set the good animation
mAnimationState = robot->getAnimationState( "Idle" );
// Start over when finished
mAnimationState->setLoop( true );
// Animation enabled
mAnimationState->setEnabled( true );
}
/* crouch_idle | crouch_to_stand | crouch_walk | fall_idle | fall_to_roll
* gangname_style | idle0 | idle1 | idle2 | jump | turnLeft | turnLeft90
* turnRight | turnRight90 | run | run_to_stop | samba | strafeLeft
* strafeRight | the_running_man | walkBackward | walkForward
* (Example: playAnimation("jump", time);)
*/
void
Player::playAnimation(std::string anim, float time)
{
disableAnimations();
Ogre::SceneManager::MovableObjectIterator iterator = SceneManager()->getMovableObjectIterator("Entity");
while(iterator.hasMoreElements())
{
Ogre::Entity* e = static_cast<Ogre::Entity*>(iterator.getNext());
if (e->hasSkeleton())
{
Ogre::AnimationState *animation = e->getAnimationState(anim);
/*if (animation->getAnimationName().compare("jump") == 0)
finishAnimation(animation, time);
*/
animation->setEnabled("true");
animation->addTime(time);
}
}
}
void OgreCharacterController::animate(Ogre::Real elapsedTime, OGRE_ANIMATION_STATE state)
{
Ogre::Entity * ent = getEntity();
Ogre::AnimationState * animTop = 0;
Ogre::AnimationState * animBase = 0;
if(animTimer > 0) {
if(lastTop != 0)
lastTop->addTime(elapsedTime);
if(lastBase != 0)
lastBase->addTime(elapsedTime);
animTimer -= elapsedTime;
return;
}
switch(state)
{
case IDLE:
animTop = ent->getAnimationState("IdleTop");
animBase = ent->getAnimationState("IdleBase");
break;
case RUN:
animTop = ent->getAnimationState("RunTop");
animBase = ent->getAnimationState("RunBase");
break;
case DRAWSWORDS:
drawSwords(animTop, ent);
animBase = lastBase;
break;
case SLICE:
animTop = lastTop;
if(swordsOut)
slice(animTop, ent);
animBase = lastBase;
break;
}
// Disable last set of animations
if(animTop != lastTop) {
if(lastTop != 0)
lastTop->setEnabled(false);
}
if(animBase != lastBase) {
if(lastBase != 0)
lastBase->setEnabled(false);
}
// Enable next set
if(animTop) {
animTop->setEnabled(true);
animTop->setLoop(true);
animTop->addTime(elapsedTime);
}
if(animBase) {
animBase->setEnabled(true);
animBase->setLoop(true);
animBase->addTime(elapsedTime);
}
// Book keeping
lastTop = animTop;
lastBase = animBase;
}
Ogre::Entity*
ModelFile::GetModel( const ModelInfo& info )
{
VectorTexForGen textures;
Ogre::MeshPtr mesh = Ogre::MeshManager::getSingleton().create( info.data.name + "export", "General" );
Ogre::SkeletonPtr skeleton = Ogre::SkeletonManager::getSingleton().create( info.data.name + "export", "General" );
int number_of_bones = GetU8( 0x02 );
int number_of_parts = GetU8( 0x03 );
int offset_to_bones = GetU32LE( 0x0c );
int offset_to_parts = GetU32LE( 0x10 );
Ogre::Bone* root1 = skeleton->createBone( "0", 0 );
Ogre::Bone* root2 = skeleton->createBone( "1", 1 );
root1->addChild( root2 );
for( int i = 0; i < number_of_bones; ++i )
{
Bone bone;
bone.parent_id = ( i != 0 ) ? ( s8 )GetU8( offset_to_bones + i * 0x04 + 0x03 ) : -1;
bone.length = ( s16 )GetU16LE( offset_to_bones + i * 0x04 + 0x00 );
m_Skeleton.push_back(bone);
Ogre::Bone* bone1 = skeleton->createBone( Ogre::StringConverter::toString( i * 2 + 2 ), i * 2 + 2 );
Ogre::Bone* bone2 = skeleton->createBone( Ogre::StringConverter::toString( i * 2 + 3 ), i * 2 + 3 );
LOGGER->Log( "Add skeleton bone: bone_id = " + Ogre::StringConverter::toString( i ) + ", length = " + Ogre::StringConverter::toString( bone.length ) + ", parent = " + Ogre::StringConverter::toString( bone.parent_id ) + ".\n" );
if( bone.parent_id == -1 )
{
skeleton->getBone( 1 )->addChild( bone1 );
}
else
{
skeleton->getBone( bone.parent_id * 2 + 3 )->addChild( bone1 );
}
bone1->addChild( bone2 );
}
AnimationExtractor( skeleton, info, m_Skeleton );
// draw skeleton
{
//DrawSkeleton( m_Skeleton, mesh );
}
for( int i = 0; i < number_of_parts; ++i )
{
MeshExtractor( info.data, "ffix/field_model/" + info.data.name, this, offset_to_parts + i * 0x28, textures, mesh );
}
// <OGRE> ///////////////////////////////
skeleton->optimiseAllAnimations();
Ogre::SkeletonSerializer skeleton_serializer;
skeleton_serializer.exportSkeleton( skeleton.getPointer(), "exported/models/field/units/" + info.data.name + ".skeleton" );
// Update bounds
Ogre::AxisAlignedBox aabb( -999, -999, -999, 999, 999, 999 );
mesh->_setBounds( aabb, false );
mesh->_setBoundingSphereRadius( 999 );
mesh->setSkeletonName( "models/field/units/" + info.data.name + ".skeleton" );
Ogre::MeshSerializer ser;
ser.exportMesh( mesh.getPointer(), "exported/models/field/units/" + info.data.name + ".mesh" );
// create and export textures for model
//if (textures.size() > 0)
{
Vram* vram = new Vram();
File* tex = new File( "./data/field/5/1b/2/4/1.tim" );
LoadTimFileToVram( tex, 0, vram );
delete tex;
tex = new File( "./data/field/5/1b/2/4/2.tim" );
LoadTimFileToVram( tex, 0, vram );
delete tex;
vram->Save( "1.jpg" );
CreateTexture( vram, info.data, "exported/models/field/units/" + info.data.name + ".png", textures );
delete vram;
}
CreateMaterial( "ffix/field_model/" + info.data.name, "exported/models/field/units/" + info.data.name + ".material", ( textures.size() > 0 ) ? "models/field/units/" + info.data.name + ".png" : "", "", "" );
Ogre::SceneManager* scene_manager = Ogre::Root::getSingleton().getSceneManager( "Scene" );
Ogre::Entity* thisEntity = scene_manager->createEntity( info.data.name, "models/field/units/" + info.data.name + ".mesh" );
//thisEntity->setDisplaySkeleton(true);
//thisEntity->setDebugDisplayEnabled(true);
thisEntity->setVisible( false );
thisEntity->getAnimationState( info.animations_name[ 0 ] )->setEnabled(true);
thisEntity->getAnimationState( info.animations_name[ 0 ] )->setLoop(true);
Ogre::SceneNode* thisSceneNode = scene_manager->getRootSceneNode()->createChildSceneNode();
thisSceneNode->setPosition( 0, 0, 0 );
thisSceneNode->roll( Ogre::Radian( Ogre::Degree( 180.0f ) ) );
thisSceneNode->yaw( Ogre::Radian( Ogre::Degree( 120.0f ) ) );
thisSceneNode->pitch( Ogre::Radian( Ogre::Degree(90.0f ) ) );
thisSceneNode->attachObject( thisEntity );
return thisEntity;
}
void Pacman::updateAnim(Ogre::Real deltaT){
Ogre::Entity* pacmanEnt = static_cast<Ogre::Entity*>( node->getAttachedObject(PACMAN_NODE));
pacmanEnt->getAnimationState(PACMAN_EAT_ANIM)->addTime(deltaT*2);
}
int initOgreAR(aruco::CameraParameters camParams, unsigned char* buffer, std::string resourcePath)
{
/// INIT OGRE FUNCTIONS
#ifdef _WIN32
root = new Ogre::Root(resourcePath + "plugins_win.cfg", resourcePath + "ogre_win.cfg");
#elif __x86_64__ || __ppc64__
root = new Ogre::Root(resourcePath + "plugins_x64.cfg", resourcePath + "ogre.cfg");
#else
root = new Ogre::Root(resourcePath + "plugins.cfg", resourcePath + "ogre.cfg");
#endif
if (!root->showConfigDialog()) return -1;
Ogre::SceneManager* smgr = root->createSceneManager(Ogre::ST_GENERIC);
/// CREATE WINDOW, CAMERA AND VIEWPORT
Ogre::RenderWindow* window = root->initialise(true);
Ogre::Camera *camera;
Ogre::SceneNode* cameraNode;
camera = smgr->createCamera("camera");
camera->setNearClipDistance(0.01f);
camera->setFarClipDistance(10.0f);
camera->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
camera->setPosition(0, 0, 0);
camera->lookAt(0, 0, 1);
double pMatrix[16];
camParams.OgreGetProjectionMatrix(camParams.CamSize,camParams.CamSize, pMatrix, 0.05,10, false);
Ogre::Matrix4 PM(pMatrix[0], pMatrix[1], pMatrix[2] , pMatrix[3],
pMatrix[4], pMatrix[5], pMatrix[6] , pMatrix[7],
pMatrix[8], pMatrix[9], pMatrix[10], pMatrix[11],
pMatrix[12], pMatrix[13], pMatrix[14], pMatrix[15]);
camera->setCustomProjectionMatrix(true, PM);
camera->setCustomViewMatrix(true, Ogre::Matrix4::IDENTITY);
window->addViewport(camera);
cameraNode = smgr->getRootSceneNode()->createChildSceneNode("cameraNode");
cameraNode->attachObject(camera);
/// CREATE BACKGROUND FROM CAMERA IMAGE
int width = camParams.CamSize.width;
int height = camParams.CamSize.height;
// create background camera image
mPixelBox = Ogre::PixelBox(width, height, 1, Ogre::PF_R8G8B8, buffer);
// Create Texture
mTexture = Ogre::TextureManager::getSingleton().createManual("CameraTexture",Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D,width,height,0,Ogre::PF_R8G8B8,Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
//Create Camera Material
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create("CameraMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::Technique *technique = material->createTechnique();
technique->createPass();
material->getTechnique(0)->getPass(0)->setLightingEnabled(false);
material->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
material->getTechnique(0)->getPass(0)->createTextureUnitState("CameraTexture");
Ogre::Rectangle2D* rect = new Ogre::Rectangle2D(true);
rect->setCorners(-1.0, 1.0, 1.0, -1.0);
rect->setMaterial("CameraMaterial");
// Render the background before everything else
rect->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND);
// Hacky, but we need to set the bounding box to something big, use infinite AAB to always stay visible
Ogre::AxisAlignedBox aabInf;
aabInf.setInfinite();
rect->setBoundingBox(aabInf);
// Attach background to the scene
Ogre::SceneNode* node = smgr->getRootSceneNode()->createChildSceneNode("Background");
node->attachObject(rect);
/// CREATE SIMPLE OGRE SCENE
// add sinbad.mesh
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(resourcePath + "Sinbad.zip", "Zip", "Popular");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
for(int i=0; i<MAX_MARKERS; i++) {
Ogre::String entityName = "Marker_" + Ogre::StringConverter::toString(i);
Ogre::Entity* ogreEntity = smgr->createEntity(entityName, "Sinbad.mesh");
Ogre::Real offset = ogreEntity->getBoundingBox().getHalfSize().y;
ogreNode[i] = smgr->getRootSceneNode()->createChildSceneNode();
// add entity to a child node to correct position (this way, entity axis is on feet of sinbad)
Ogre::SceneNode *ogreNodeChild = ogreNode[i]->createChildSceneNode();
ogreNodeChild->attachObject(ogreEntity);
// Sinbad is placed along Y axis, we need to rotate to put it along Z axis so it stands up over the marker
// first rotate along X axis, then add offset in Z dir so it is over the marker and not in the middle of it
ogreNodeChild->rotate(Ogre::Vector3(1,0,0), Ogre::Radian(Ogre::Degree(90)));
ogreNodeChild->translate(0,0,offset,Ogre::Node::TS_PARENT);
// mesh is too big, rescale!
const float scale = 0.006675f;
ogreNode[i]->setScale(scale, scale, scale);
// Init animation
ogreEntity->getSkeleton()->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE);
if(i==0)
{
baseAnim[i] = ogreEntity->getAnimationState("HandsClosed");
topAnim[i] = ogreEntity->getAnimationState("HandsRelaxed");
}
else if(i==1)
{
baseAnim[i] = ogreEntity->getAnimationState("Dance");
topAnim[i] = ogreEntity->getAnimationState("Dance");
}
else if(i==2)
{
baseAnim[i] = ogreEntity->getAnimationState("RunBase");
topAnim[i] = ogreEntity->getAnimationState("RunTop");
}
else
{
baseAnim[i] = ogreEntity->getAnimationState("IdleBase");
topAnim[i] = ogreEntity->getAnimationState("IdleTop");
}
baseAnim[i]->setLoop(true);
topAnim[i]->setLoop(true);
baseAnim[i]->setEnabled(true);
topAnim[i]->setEnabled(true);
}
/// KEYBOARD INPUT READING
size_t windowHnd = 0;
window->getCustomAttribute("WINDOW", &windowHnd);
im = OIS::InputManager::createInputSystem(windowHnd);
keyboard = static_cast<OIS::Keyboard*>(im->createInputObject(OIS::OISKeyboard, true));
return 1;
}
void Pacman::animaMuerte(Ogre::Real deltaT)
{
Ogre::Entity *pacmanEnt = static_cast<Ogre::Entity *>( node->getAttachedObject(PACMAN_NODE));
pacmanEnt->getAnimationState(PACMAN_DIES)->addTime(deltaT);
}
void CBlendingAnimationsView::EngineSetup(void)
{
Ogre::Root *Root = ((CBlendingAnimationsApp*)AfxGetApp())->m_Engine->GetRoot();
Ogre::SceneManager *SceneManager = NULL;
SceneManager = Root->createSceneManager(Ogre::ST_GENERIC, "Walking");
//
// Create a render window
// This window should be the current ChildView window using the externalWindowHandle
// value pair option.
//
Ogre::NameValuePairList parms;
parms["externalWindowHandle"] = Ogre::StringConverter::toString((long)m_hWnd);
parms["vsync"] = "true";
CRect rect;
GetClientRect(&rect);
Ogre::RenderTarget *RenderWindow = Root->getRenderTarget("Mouse Input");
if (RenderWindow == NULL)
{
try
{
m_RenderWindow = Root->createRenderWindow("Mouse Input", rect.Width(), rect.Height(), false, &parms);
}
catch(...)
{
MessageBox("Cannot initialize\nCheck that graphic-card driver is up-to-date", "Initialize Render System", MB_OK | MB_ICONSTOP);
exit(EXIT_SUCCESS);
}
}
// Load resources
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// Create the camera
m_Camera = SceneManager->createCamera("Camera");
m_Camera->setNearClipDistance(0.5);
m_Camera->setFarClipDistance(5000);
m_Camera->setCastShadows(false);
m_Camera->setUseRenderingDistance(true);
m_Camera->setPosition(Ogre::Vector3(/*20*/0.0, /*5*/0.0, 100.0));
Ogre::SceneNode *CameraNode = NULL;
CameraNode = SceneManager->getRootSceneNode()->createChildSceneNode("CameraNode");
Ogre::Viewport* Viewport = NULL;
if (0 == m_RenderWindow->getNumViewports())
{
Viewport = m_RenderWindow->addViewport(m_Camera);
Viewport->setBackgroundColour(Ogre::ColourValue(0.8f, 0.8f, 0.8f));
}
// Alter the camera aspect ratio to match the viewport
m_Camera->setAspectRatio(Ogre::Real(rect.Width()) / Ogre::Real(rect.Height()));
Ogre::SceneNode *RobotNode = SceneManager->getRootSceneNode()->createChildSceneNode("Robot", Ogre::Vector3(50,0,0));
Ogre::Entity *RobotEntity = SceneManager->createEntity("Robot", "robot.mesh");
Ogre::MeshPtr Mesh = RobotEntity->getMesh();
RobotNode->attachObject(RobotEntity);
RobotEntity->getParentNode()->scale(0.2,0.2,0.2);
m_Camera->lookAt(Ogre::Vector3(0.0, 0.0, 0.0));
RobotEntity->setDisplaySkeleton(true);
m_Camera->setPolygonMode(Ogre::PolygonMode::PM_WIREFRAME);
m_WalkAnimation = RobotEntity->getAnimationState("Walk");
m_WalkAnimation->setEnabled(true);
m_SlumpAnimation = RobotEntity->getAnimationState("Slump");
m_SlumpAnimation->setEnabled(true);
if (m_WeightDlg == NULL)
{
m_WeightDlg = new CWeightDlg();
m_WeightDlg->Create(IDD_WEIGHT_CONTROL);
}
m_WeightDlg->ShowWindow(SW_SHOW);
Root->renderOneFrame();
}
void CSceletalAnimationView::EngineSetup(void)
{
Ogre::Root *Root = ((CSceletalAnimationApp*)AfxGetApp())->m_Engine->GetRoot();
Ogre::SceneManager *SceneManager = NULL;
SceneManager = Root->createSceneManager(Ogre::ST_GENERIC, "Animation");
//
// Create a render window
// This window should be the current ChildView window using the externalWindowHandle
// value pair option.
//
Ogre::NameValuePairList parms;
parms["externalWindowHandle"] = Ogre::StringConverter::toString((long)m_hWnd);
parms["vsync"] = "true";
CRect rect;
GetClientRect(&rect);
Ogre::RenderTarget *RenderWindow = Root->getRenderTarget("Mouse Input");
if (RenderWindow == NULL)
{
try
{
m_RenderWindow = Root->createRenderWindow("Mouse Input", rect.Width(), rect.Height(), false, &parms);
}
catch(...)
{
MessageBox("Cannot initialize\nCheck that graphic-card driver is up-to-date", "Initialize Render System", MB_OK | MB_ICONSTOP);
exit(EXIT_SUCCESS);
}
}
// Load resources
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// Create the camera
m_Camera = SceneManager->createCamera("Camera");
m_Camera->setNearClipDistance(0.5);
m_Camera->setFarClipDistance(5000);
m_Camera->setCastShadows(false);
m_Camera->setUseRenderingDistance(true);
m_Camera->setPosition(Ogre::Vector3(5.0, 5.0, 10.0));
Ogre::SceneNode *CameraNode = NULL;
CameraNode = SceneManager->getRootSceneNode()->createChildSceneNode("CameraNode");
Ogre::Viewport* Viewport = NULL;
if (0 == m_RenderWindow->getNumViewports())
{
Viewport = m_RenderWindow->addViewport(m_Camera);
Viewport->setBackgroundColour(Ogre::ColourValue(0.8f, 0.8f, 0.8f));
}
// Alter the camera aspect ratio to match the viewport
m_Camera->setAspectRatio(Ogre::Real(rect.Width()) / Ogre::Real(rect.Height()));
m_Camera->lookAt(Ogre::Vector3(0.5, 0.5, 0.5));
m_Camera->setPolygonMode(Ogre::PolygonMode::PM_WIREFRAME);
Ogre::ManualObject* ManualObject = NULL;
ManualObject = SceneManager->createManualObject("Animation");
ManualObject->setDynamic(false);
ManualObject->begin("BaseWhiteNoLighting", Ogre::RenderOperation::OT_TRIANGLE_LIST);
//face 1
ManualObject->position(0, 0, 0);//0
ManualObject->position(1, 0, 0);//1
ManualObject->position(1, 1, 0);//2
ManualObject->triangle(0, 1, 2);//3
ManualObject->position(0, 0, 0);//4
ManualObject->position(1, 1, 0);//5
ManualObject->position(0, 1, 0);//6
ManualObject->triangle(3, 4, 5);//7
//face 2
ManualObject->position(0, 0, 1);//8
ManualObject->position(1, 0, 1);//9
ManualObject->position(1, 1, 1);//10
ManualObject->triangle(6, 7, 8);//11
ManualObject->position(0, 0, 1);//12
ManualObject->position(1, 1, 1);//13
ManualObject->position(0, 1, 1);//14
ManualObject->triangle(9, 10, 11);//15
//face 3
ManualObject->position(0, 0, 0);//16
ManualObject->position(1, 0, 0);//17
ManualObject->position(1, 0, 1);//18
ManualObject->triangle(12, 13, 14);//19
ManualObject->position(0, 0, 0);
ManualObject->position(1, 0, 1);
ManualObject->position(0, 1, 1);
ManualObject->triangle(15, 16, 17);
//face 4
ManualObject->position(1, 0, 0);
ManualObject->position(1, 1, 0);
ManualObject->position(1, 1, 1);
ManualObject->triangle(18, 19, 20);
ManualObject->position(1, 0, 0);
ManualObject->position(1, 1, 1);
ManualObject->position(1, 0, 1);
ManualObject->triangle(21, 22, 23);
//face 5
ManualObject->position(0, 1, 0);
ManualObject->position(1, 1, 0);
ManualObject->position(0, 1, 1);
ManualObject->triangle(24, 25, 26);
ManualObject->position(1, 1, 0);
ManualObject->position(1, 1, 1);
ManualObject->position(0, 1, 1);
ManualObject->triangle(27, 28, 29);
//face 6
ManualObject->position(0, 0, 0);
ManualObject->position(0, 1, 1);
ManualObject->position(0, 0, 1);
ManualObject->triangle(30, 31, 32);
ManualObject->position(0, 0, 0);
ManualObject->position(0, 1, 0);
ManualObject->position(0, 1, 1);
ManualObject->triangle(33, 34, 35);
ManualObject->end();
Ogre::MeshPtr MeshPtr = ManualObject->convertToMesh("Animation");
Ogre::SubMesh* sub = MeshPtr->getSubMesh(0);
Ogre::SkeletonPtr Skeleton = Ogre::SkeletonManager::getSingleton().create("Skeleton", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
MeshPtr.getPointer()->_notifySkeleton(Skeleton);
Ogre::Bone *Root1 = NULL;
Ogre::Bone *Child1 = NULL;
Ogre::Bone *Child2 = NULL;
Root1 = Skeleton.getPointer()->createBone("Root");
Root1->setPosition(Ogre::Vector3(0.0, 0.0, 0.0));
Root1->setOrientation(Ogre::Quaternion::IDENTITY);
Child1 = Root1->createChild(1);
Child1->setPosition(Ogre::Vector3(4.0, 0.0, 0.0));
Child1->setOrientation(Ogre::Quaternion::IDENTITY);
Child2 = Root1->createChild(2);
Child2->setPosition(Ogre::Vector3(5.0, 0.0, 0.0));
Child2->setOrientation(Ogre::Quaternion::IDENTITY);
Ogre::VertexBoneAssignment Assignment;
Assignment.boneIndex = 0;
Assignment.vertexIndex = 0;
Assignment.weight = 1.0;
Skeleton->setBindingPose();
sub->addBoneAssignment(Assignment);
Assignment.vertexIndex = 1;
sub->addBoneAssignment(Assignment);
Assignment.vertexIndex = 2;
sub->addBoneAssignment(Assignment);
Ogre::Animation *Animation = MeshPtr->createAnimation("HandAnimation", 100.0);
Ogre::NodeAnimationTrack *Track = Animation->createNodeTrack(0, Root1);
Ogre::TransformKeyFrame *KeyFrame = NULL;
for (float FrameTime = 0.0; FrameTime < 100.0; FrameTime += 0.1)
{
KeyFrame = Track->createNodeKeyFrame(FrameTime);
KeyFrame->setTranslate(Ogre::Vector3(10.0, 0.0, 0.0));
}
Root1->setManuallyControlled(true);
Child1->setManuallyControlled(true);
Child2->setManuallyControlled(true);
MeshPtr->load();
MeshPtr.getPointer()->_notifySkeleton(Skeleton);
// Ogre::SkeletonSerializer skeletonSerializer;
// skeletonSerializer.exportSkeleton(Skeleton.get(), "C:\\Users\\Ilya\\Documents\\Visual Studio 2010\\Projects\\Recipes\\media\\models\\testskeleton.skeleton");
// Ogre::MeshSerializer ser;
// ser.exportMesh(MeshPtr.get(), "C:\\Users\\Ilya\\Documents\\Visual Studio 2010\\Projects\\Recipes\\media\\models\\testskeleton.mesh");
Ogre::Entity *Entity = SceneManager->createEntity("Animation", "Animation"/*"testskeleton.mesh"*/);
Ogre::SceneNode *SceneNode = SceneManager->getRootSceneNode()->createChildSceneNode();
SceneNode->attachObject(Entity);
Entity->setDisplaySkeleton(true);
m_AnimationState = Entity->getAnimationState("HandAnimation");
m_AnimationState->setEnabled(true);
m_AnimationState->setLoop(true);
m_Camera->setPolygonMode(Ogre::PolygonMode::PM_WIREFRAME);
Root->renderOneFrame();
}
void World::Init()
{
using namespace Ogre;
SceneManager* sm = m_pRenderSystem->m_pSceneMgr;
Camera* cam = m_pRenderSystem->m_pMainCamera;
m_pSceneQuery = sm->createAABBQuery(AxisAlignedBox());
m_pRaySceneQuery = sm->createRayQuery(Ray());
m_pRaySceneQuery->setSortByDistance(true);
Ogre::MovableObject::setDefaultQueryFlags(eQueryType_Default);
m_cameraMan = new OgreBites::SdkCameraMan(cam);
m_cameraMan->setStyle(OgreBites::CS_FREELOOK);
//RTS锁死视角
cam->setPosition(0, 24, 0);
cam->lookAt(0, 0, 8);
//cam->setFOVy(Degree(30));
//初始化行为库
aiBehaviorTreeTemplateManager& btMgr = aiBehaviorTreeTemplateManager::GetSingleton();
btMgr.AddBehavior("Idle", new aiBehaviorIdle);
btMgr.AddBehavior("MoveToEnemyBase", new aiBehaviorMoveToEnemyBase);
//加载所有行为树模板
btMgr.LoadAll();
//测试两个AI
m_player[eGameRace_Terran] = new FactionAI(eGameRace_Terran);
m_player[eGameRace_Zerg] = new FactionAI(eGameRace_Zerg);
m_player[eGameRace_Terran]->SetEnemy(m_player[eGameRace_Zerg]);
m_player[eGameRace_Zerg]->SetEnemy(m_player[eGameRace_Terran]);
m_player[eGameRace_Terran]->SetTeamColor(COLOR::Blue);
m_player[eGameRace_Zerg]->SetTeamColor(COLOR::Red);
GameDataDefManager::GetSingleton().LoadAllData();
//初始化Recast库
OgreRecastConfigParams recastParams = OgreRecastConfigParams();
recastParams.setCellSize(1);
recastParams.setCellHeight(0.16f);
recastParams.setAgentMaxSlope(15);
recastParams.setAgentHeight(1.5f);
recastParams.setAgentMaxClimb(0.5f);
recastParams.setAgentRadius(0.4f);
recastParams.setEdgeMaxLen(2);
recastParams.setEdgeMaxError(1.3f);
recastParams.setVertsPerPoly(6);
recastParams.setRegionMinSize(2);
recastParams.setRegionMergeSize(3);
recastParams.setDetailSampleDist(6);
recastParams.setDetailSampleMaxError(1);
m_pRecast = new OgreRecast(sm, recastParams);
m_pDetourTileCache = new OgreDetourTileCache(m_pRecast);
//加载编辑器导出的导航网格数据
Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().openResource(
"NavMesh.Bin", "General", false);
assert(m_pDetourTileCache->loadAll(stream));
//m_pDetourTileCache->drawNavMesh();
//初始化Detour寻路库
m_pDetourCrowd = new OgreDetourCrowd(m_pRecast);
g_Environment.m_pRecast = m_pRecast;
g_Environment.m_pCrowd = m_pDetourCrowd;
//加载测试场景
m_pTestScene = new Kratos::Scene();
m_pTestScene->Load("MyStarCraft.Scene", "General", this);
//UI for test
Ogre::Entity* pEntConsole = m_pRenderSystem->CreateEntityWithTangent("ConsoleTerran_0.mesh", sm);
pEntConsole->setRenderQueueGroup(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_2);
pEntConsole->setCastShadows(false);
m_pUISceneNode1 = sm->getRootSceneNode()->createChildSceneNode("UIConsoleNode");
m_pUISceneNode1->attachObject(pEntConsole);
m_pConsoleAnim1 = pEntConsole->getAnimationState("Birth");
assert(m_pConsoleAnim1);
(const_cast<Ogre::AxisAlignedBox&>(pEntConsole->getMesh()->getBounds())).setInfinite();
pEntConsole = m_pRenderSystem->CreateEntityWithTangent("ConsoleTerran_1.mesh", sm);
pEntConsole->setRenderQueueGroup(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_2);
pEntConsole->setCastShadows(false);
m_pUISceneNode2 = m_pUISceneNode1->createChildSceneNode("InfoPanelNode");
m_pUISceneNode2->attachObject(pEntConsole);
m_pConsoleAnim2 = pEntConsole->getAnimationState("Birth");
assert(m_pConsoleAnim2);
(const_cast<Ogre::AxisAlignedBox&>(pEntConsole->getMesh()->getBounds())).setInfinite();
pEntConsole = m_pRenderSystem->CreateEntityWithTangent("ConsoleTerran_2.mesh", sm);
pEntConsole->setRenderQueueGroup(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_2);
pEntConsole->setCastShadows(false);
m_pUISceneNode3 = m_pUISceneNode1->createChildSceneNode("CmdPanelNode");
m_pUISceneNode3->attachObject(pEntConsole);
(const_cast<Ogre::AxisAlignedBox&>(pEntConsole->getMesh()->getBounds())).setInfinite();
pEntConsole = m_pRenderSystem->CreateEntityWithTangent("ConsoleProtoss_6.mesh", sm);
pEntConsole->setRenderQueueGroup(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_2);
pEntConsole->setCastShadows(false);
m_pUISceneNode4 = m_pUISceneNode1->createChildSceneNode("PortraitPanelNode");
m_pUISceneNode4->attachObject(pEntConsole);
(const_cast<Ogre::AxisAlignedBox&>(pEntConsole->getMesh()->getBounds())).setInfinite();
m_cmdPanel->Init();
m_infoPanel->Init();
m_portraitPanel->Init();
CEGUI::WindowManager& wndMgr = CEGUI::WindowManager::getSingleton();
CEGUI::Window* pRoot = wndMgr.getWindow("Root");
assert(pRoot);
GUIMANAGER.SetGUISheet(pRoot);
pRoot->addChildWindow(wndMgr.getWindow("InfoPanelFrame"));
}
void SherpaGUI::Init(){
this->engine = rendering::RenderEngine::Instance();
this->cam = gui::get_active_camera()->GetOgreCamera();
this->angle = 0.;
if(!engine || engine == NULL){
std::cerr << "could not access RenderEngine";
}
this->root = engine->root;
if(!root || root == NULL){
std::cerr << "could not access Ogre Root element";
}
root->addResourceLocation(resource ,"FileSystem","SHERPA");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
paused=false;
this->node = transport::NodePtr(new transport::Node());
this->node->Init(SHERPA_GAZEBO_NODE_NAME);
animationSubscriber = node->Subscribe(SHERPA_GAZEBO_ANIMATION_TOPIC,&SherpaGUI::OnChangePose,this);
positionSubscriber = node->Subscribe(SHERPA_GAZEBO_POSITION_TOPIC,&SherpaGUI::OnChangePosition,this);
Ogre::SceneManagerEnumerator::SceneManagerIterator si =root->getSceneManagerIterator();
Ogre::SceneManager * mSceneMgr = si.getNext();
walking = false;
Ogre::Entity * humanEntity = mSceneMgr->createEntity("human", "Sherpa_human.mesh");
mNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("HumanNode", Ogre::Vector3(0.0f, 0.0f, 0.0f));//,Ogre::Quaternion(1.0f,0.0f,1.0f,1.0f));
mNode->scale(2,2,2);
mNode->pitch(Ogre::Degree(90));
mNode->yaw(Ogre::Degree(-90));
mNode->attachObject(humanEntity);
mWalkList.push_back(Ogre::Vector3(550.0f, 0.0f, 50.0f ));
mWalkList.push_back(Ogre::Vector3(-100.0f, 0.0f, -200.0f));
walkAnim = humanEntity->getAnimationState("walk");
walkAnim->setLoop(true);
walkAnim->setEnabled(false);
idleAnim = humanEntity->getAnimationState("idle");
idleAnim->setLoop(true);
idleAnim->setEnabled(true);
pointAnim = humanEntity->getAnimationState("point");
pointAnim->setLoop(false);
pointAnim->setEnabled(false);
mAnimationState = idleAnim;
this->updateConnection = event::Events::ConnectRender(boost::bind(&SherpaGUI::OnUpdate, this));
animation_speed = IDLE_ANIM_SPEED;
this->pauseConnection = event::Events::ConnectStop(boost::bind(&SherpaGUI::OnPause, this));
lastTime = engine->root->getTimer()->getMilliseconds();
}
void CTerrainWalkingView::EngineSetup(void)
{
Ogre::Root *Root = ((CTerrainWalkingApp*)AfxGetApp())->m_Engine->GetRoot();
Ogre::SceneManager *SceneManager = NULL;
SceneManager = Root->createSceneManager(Ogre::ST_GENERIC, "Walking");
//
// Create a render window
// This window should be the current ChildView window using the externalWindowHandle
// value pair option.
//
Ogre::NameValuePairList parms;
parms["externalWindowHandle"] = Ogre::StringConverter::toString((long)m_hWnd);
parms["vsync"] = "true";
CRect rect;
GetClientRect(&rect);
Ogre::RenderTarget *RenderWindow = Root->getRenderTarget("Walking");
if (RenderWindow == NULL)
{
try
{
m_RenderWindow = Root->createRenderWindow("Walking", rect.Width(), rect.Height(), false, &parms);
}
catch(...)
{
MessageBox("Cannot initialize\nCheck that graphic-card driver is up-to-date", "Initialize Render System", MB_OK | MB_ICONSTOP);
exit(EXIT_SUCCESS);
}
}
// Load resources
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// Create the camera
m_Camera = SceneManager->createCamera("Camera");
m_Camera->setNearClipDistance(10);
m_Camera->setFarClipDistance(10000);
m_Camera->setCastShadows(false);
m_Camera->setUseRenderingDistance(true);
Ogre::SceneNode *CameraNode = NULL;
CameraNode = SceneManager->getRootSceneNode()->createChildSceneNode("CameraNode");
Ogre::Viewport* Viewport = NULL;
if (0 == m_RenderWindow->getNumViewports())
{
Viewport = m_RenderWindow->addViewport(m_Camera);
Viewport->setBackgroundColour(Ogre::ColourValue(0.8f, 0.8f, 0.8f));
}
// Alter the camera aspect ratio to match the viewport
m_Camera->setAspectRatio(Ogre::Real(rect.Width()) / Ogre::Real(rect.Height()));
Ogre::SceneNode *TopographyNode = SceneManager->getRootSceneNode()->createChildSceneNode("Topography");
Ogre::Entity *TopographyEntity = SceneManager->createEntity("Topography", "Topography.mesh");
TopographyNode->attachObject(TopographyEntity);
Ogre::AxisAlignedBox TopographyBox = TopographyEntity->getBoundingBox();
Ogre::Vector3 Minimum = TopographyBox.getMinimum();
Ogre::Vector3 Center = TopographyBox.getCenter();
Ogre::SceneNode *RobotNode = SceneManager->getRootSceneNode()->createChildSceneNode("Robot");
Ogre::Entity *RobotEntity = SceneManager->createEntity("Robot", "robot.mesh");
RobotNode->attachObject(RobotEntity);
RobotEntity->getParentNode()->scale(10,10,10);
Ogre::AxisAlignedBox RobotBox = RobotEntity->getBoundingBox();
RobotNode->setPosition(Ogre::Vector3(Minimum[0], Minimum[1] + RobotBox.getSize()[1], Minimum[2]));
m_Camera->setPosition(Ogre::Vector3(Minimum[0], Minimum[1] + 5000, Minimum[2]));
m_Camera->lookAt(Center);
m_Camera->setPolygonMode(Ogre::PolygonMode::PM_WIREFRAME);
m_Animation = RobotEntity->getAnimationState("Walk");
m_Animation->setEnabled(true);
m_CollisionTools = new MOC::CollisionTools(SceneManager);
Root->renderOneFrame();
}
void RoR::GfxCharacter::UpdateCharacterInScene()
{
// Actor coupling
if (xc_simbuf.simbuf_actor_coupling != xc_simbuf_prev.simbuf_actor_coupling)
{
if (xc_simbuf.simbuf_actor_coupling != nullptr)
{
// Entering/switching vehicle
if (xc_movable_text != nullptr)
{
xc_movable_text->setVisible(false);
}
xc_scenenode->getAttachedObject(0)->setCastShadows(false);
xc_scenenode->setVisible(xc_simbuf.simbuf_actor_coupling->GetGfxActor()->HasDriverSeatProp());
}
else if (xc_simbuf_prev.simbuf_actor_coupling != nullptr)
{
// Leaving vehicle
if (xc_movable_text != nullptr)
{
xc_movable_text->setVisible(true);
}
xc_scenenode->getAttachedObject(0)->setCastShadows(true);
xc_scenenode->setVisible(true);
xc_scenenode->resetOrientation();
}
}
// Position + Orientation
if (xc_simbuf.simbuf_actor_coupling != nullptr)
{
if (xc_simbuf.simbuf_actor_coupling->GetGfxActor()->HasDriverSeatProp())
{
Ogre::Vector3 pos;
Ogre::Quaternion rot;
xc_simbuf.simbuf_actor_coupling->GetGfxActor()->CalculateDriverPos(pos, rot);
xc_scenenode->setOrientation(rot);
// hack to position the character right perfect on the default seat (because the mesh has decentered origin)
xc_scenenode->setPosition(pos + (rot * Vector3(0.f, -0.6f, 0.f)));
}
}
else
{
xc_scenenode->resetOrientation();
xc_scenenode->yaw(-xc_simbuf.simbuf_character_rot);
xc_scenenode->setPosition(xc_simbuf.simbuf_character_pos);
}
// Animation
Ogre::Entity* entity = static_cast<Ogre::Entity*>(xc_scenenode->getAttachedObject(0));
if (xc_simbuf.simbuf_anim_name != xc_simbuf_prev.simbuf_anim_name)
{
// 'Classic' method - enable one anim, exterminate the others ~ only_a_ptr, 06/2018
AnimationStateIterator it = entity->getAllAnimationStates()->getAnimationStateIterator();
while (it.hasMoreElements())
{
AnimationState* as = it.getNext();
if (as->getAnimationName() == xc_simbuf.simbuf_anim_name)
{
as->setEnabled(true);
as->setWeight(1);
as->addTime(xc_simbuf.simbuf_anim_time);
}
else
{
as->setEnabled(false);
as->setWeight(0);
}
}
}
else
{
auto* as_cur = entity->getAnimationState(xc_simbuf.simbuf_anim_name);
as_cur->setTimePosition(xc_simbuf.simbuf_anim_time);
}
// SurveyMapEntity
if (xc_survey_map_entity == nullptr)
xc_survey_map_entity = App::GetSimController()->GetGfxScene().GetSurveyMap()->createMapEntity("person");
String caption = (App::mp_state.GetActive() == MpState::CONNECTED) ? xc_simbuf.simbuf_net_username : "";
App::GetSimController()->GetGfxScene().GetSurveyMap()->UpdateMapEntity(xc_survey_map_entity, caption,
xc_simbuf.simbuf_character_pos, xc_simbuf.simbuf_character_rot.valueRadians(),
-static_cast<int>(xc_simbuf.simbuf_is_remote), !xc_simbuf.simbuf_actor_coupling);
// Multiplayer label
#ifdef USE_SOCKETW
if (App::mp_state.GetActive() == MpState::CONNECTED)
{
// From 'updateCharacterNetworkColor()'
const String materialName = "tracks/" + xc_instance_name;
const int textureUnitStateNum = 2;
MaterialPtr mat = MaterialManager::getSingleton().getByName(materialName);
if (!mat.isNull() && mat->getNumTechniques() > 0 && mat->getTechnique(0)->getNumPasses() > 0 && textureUnitStateNum < mat->getTechnique(0)->getPass(0)->getNumTextureUnitStates())
{
auto state = mat->getTechnique(0)->getPass(0)->getTextureUnitState(textureUnitStateNum);
Ogre::ColourValue color = Networking::GetPlayerColor(xc_simbuf.simbuf_color_number);
state->setAlphaOperation(LBX_BLEND_CURRENT_ALPHA, LBS_MANUAL, LBS_CURRENT, 0.8);
state->setColourOperationEx(LBX_BLEND_CURRENT_ALPHA, LBS_MANUAL, LBS_CURRENT, color, color, 1);
}
if (xc_movable_text != nullptr)
{
float camDist = (xc_scenenode->getPosition() - gEnv->mainCamera->getPosition()).length();
xc_movable_text->setCaption(xc_simbuf.simbuf_net_username);
if (camDist > 1000.0f)
xc_movable_text->setCaption(xc_simbuf.simbuf_net_username + " (" + TOSTRING((float)(ceil(camDist / 100) / 10.0f)) + " km)");
else if (camDist > 20.0f && camDist <= 1000.0f)
xc_movable_text->setCaption(xc_simbuf.simbuf_net_username + " (" + TOSTRING((int)camDist) + " m)");
else
xc_movable_text->setCaption(xc_simbuf.simbuf_net_username);
float h = std::max(9.0f, camDist * 1.2f);
xc_movable_text->setCharacterHeight(h);
}
}
#endif // USE_SOCKETW
}
Ogre::Entity*
StageFile::GetModel( const StageInfo& info )
{
//DumpSettings("exported/" + info.data.name + ".lua");
VectorTexForGen textures;
Ogre::MeshPtr mesh = Ogre::MeshManager::getSingleton().create(info.data.name + "export", "General");
Ogre::SkeletonPtr skeleton = Ogre::SkeletonManager::getSingleton().create(info.data.name + "export", "General");
u32 number_of_files = GetU32LE(0);
LOGGER->Log("Number of file " + IntToString(number_of_files) + "\n");
Ogre::Bone* root1 = skeleton->createBone( "0", 0 );
Ogre::Bone* root2 = skeleton->createBone( "1", 1 );
root1->addChild( root2 );
Ogre::Animation* anim = skeleton->createAnimation( "Idle", 1 );
Ogre::NodeAnimationTrack* track1 = anim->createNodeTrack( 0, root1 );
track1->removeAllKeyFrames();
Ogre::TransformKeyFrame* frame1 = track1->createNodeKeyFrame( 0 );
Ogre::Matrix3 matrix;
matrix.FromEulerAnglesYXZ( Ogre::Radian( Ogre::Degree( 0 ) ), Ogre::Radian( Ogre::Degree( -90 ) ), Ogre::Radian( Ogre::Degree( 0 ) ) );
Ogre::Quaternion rot;
rot.FromRotationMatrix( matrix );
frame1->setRotation( rot );
for (u32 i = 1; i < number_of_files - 1; ++i)
{
int offset_to_vertex = GetU32LE(0x04 + i * 0x04);
MeshExtractor(info.data, "ffvii/battle_stage/" + info.data.name, this, offset_to_vertex, textures, mesh, Ogre::StringConverter::toString(i), 1);
}
// <OGRE> ///////////////////////////////
skeleton->optimiseAllAnimations();
Ogre::SkeletonSerializer skeleton_serializer;
skeleton_serializer.exportSkeleton(skeleton.getPointer(), "exported/models/ffvii/battle/stages/" + info.data.name + ".skeleton");
// Update bounds
Ogre::AxisAlignedBox aabb(-999, -999, -999, 999, 999, 999);
mesh->_setBounds(aabb, false);
mesh->_setBoundingSphereRadius(999);
mesh->setSkeletonName( "models/ffvii/battle/stages/" + info.data.name + ".skeleton" );
Ogre::MeshSerializer ser;
ser.exportMesh(mesh.getPointer(), "exported/models/ffvii/battle/stages/" + info.data.name + ".mesh");
// create and export textures for model
if( textures.size() > 0 )
{
int number_of_files = GetU32LE( 0x00 );
int offset_to_texture = GetU32LE( number_of_files * 0x04 );
Vram* vram = Vram::MakeInstance().release();
LoadTimFileToVram( this, offset_to_texture, vram );
//vram->Save( "qqq" );
CreateTexture( vram, info.data, "exported/models/ffvii/battle/stages/" + info.data.name + ".png", textures );
delete vram;
}
CreateMaterial("ffvii/battle_stage/" + info.data.name, "exported/models/ffvii/battle/stages/" + info.data.name + ".material", "models/ffvii/battle/stages/" + info.data.name + ".png", "", "");
Ogre::SceneManager* scene_manager = Ogre::Root::getSingleton().getSceneManager( "Scene" );
Ogre::Entity* thisEntity = scene_manager->createEntity( info.data.name, "models/ffvii/battle/stages/" + info.data.name + ".mesh" );
//thisEntity->setDisplaySkeleton(true);
//thisEntity->setDebugDisplayEnabled(true);
thisEntity->setVisible(false);
thisEntity->getAnimationState( "Idle" )->setEnabled( true );
thisEntity->getAnimationState( "Idle" )->setLoop( true );
Ogre::SceneNode* thisSceneNode = scene_manager->getRootSceneNode()->createChildSceneNode();
thisSceneNode->setPosition( 0, 0, 0 );
thisSceneNode->roll( Ogre::Radian( Ogre::Degree( 180.0f ) ) );
thisSceneNode->yaw( Ogre::Radian( Ogre::Degree( 120.0f ) ) );
thisSceneNode->pitch( Ogre::Radian( Ogre::Degree( 90.0f ) ) );
thisSceneNode->attachObject( thisEntity );
return thisEntity;
}