void AssetLoader::createCamera(Ogre::SceneManager* sceneMgr, const aiScene* scene, Ogre::String camName)
{
for (size_t n = 0; n < scene->mNumCameras; n++)
{
// カメラを作成
Ogre::Camera* cam = sceneMgr->createCamera(scene->mCameras[n]->mName.data);
std::cout << "Create Camra " << cam->getName() << " " << scene->mCameras[n]->mHorizontalFOV << std::endl;
cam->setFOVy(Ogre::Radian(scene->mCameras[n]->mHorizontalFOV));
// 視点アニメーション用ノード
Ogre::SceneNode* camNode = sceneMgr->getRootSceneNode()->createChildSceneNode(cam->getName()+"CamNode");
camNode->attachObject(cam);
// アニメーションを走査
for (size_t na = 0; na < scene->mNumAnimations; na++) {
aiAnimation* aiani = scene->mAnimations[na];
for (size_t nc = 0; nc < aiani->mNumChannels; nc++) {
// カメラと同じ名前のチャネルを取得する
if (Ogre::String(scene->mCameras[n]->mName.data) == cam->getName()) {
//アニメーションを付けるトラックを作成しておく
Ogre::Animation* ogani = sceneMgr->createAnimation(cam->getName()+"Animation", aiani->mDuration);
std::cout << "Animation : " << ogani->getName() << std::endl;
Ogre::NodeAnimationTrack* track = ogani->createNodeTrack(0, camNode);
ogani->setInterpolationMode(Ogre::Animation::IM_LINEAR);
// アニメーションチャネルからキーフレームアニメーションを取得
aiNodeAnim* chan = aiani->mChannels[n];
for (size_t np = 0; np < chan->mNumPositionKeys; np++) {
aiVectorKey* vk = &(chan->mPositionKeys[np]);
Ogre::TransformKeyFrame* key = track->createNodeKeyFrame(vk->mTime);
key->setTranslate(Ogre::Vector3(vk->mValue[0], vk->mValue[1], vk->mValue[2]));
aiQuatKey* qk = &(chan->mRotationKeys[np]);
key->setRotation(Ogre::Quaternion(qk->mValue.w, qk->mValue.x, qk->mValue.y, qk->mValue.z));
}
// 管理するアニメーションの名前を付けておく
Ogre::AnimationState* aniState = sceneMgr->createAnimationState(ogani->getName());
aniState->setEnabled(true);
aniState->setLoop(true);
aniState->setTimePosition(0.0);
//ループを抜ける
na = scene->mNumAnimations;
break;
}
}
}
}
}
//We're not sure whether return a reference to a vector is such a great idea.
void
CinematicManager::createPerspectiveCamera(Ogre::Real windowW, Ogre::Real windowH, const Ogre::Vector3 &initialPos,
const Ogre::Quaternion &initialOrient, Control* control)
{
Ogre::Camera* cam = _scnMgr->createCamera(PERSP_CAM_NAME + Ogre::StringConverter::toString(_camCurId));
cam->setNearClipDistance(1.0f);
cam->setFarClipDistance(400.0f);
cam->setPosition(0.0f, 0.0f, 0.0f);
cam->setAspectRatio(windowW / windowH);
Ogre::SceneNode* defaultNode = _scnMgr->createSceneNode();
defaultNode->setPosition(initialPos); //It's in local space.
defaultNode->setOrientation(initialOrient);
defaultNode->attachObject(cam);
_camsVec.push_back(new ZCameraInfo(_camsVec.size(), "PERSPECTIVE", cam->getName(), control, cam));
}
void
CinematicManager::createOrthoCamera(Ogre::Real windowW, Ogre::Real windowH, const Ogre::Vector3 &initialPos,
const Ogre::Quaternion &initialOrient, Control* control)
{
Ogre::Camera* cam = _scnMgr->createCamera(ORTHO_CAM_NAME + Ogre::StringConverter::toString(_camCurId));
cam->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
cam->setOrthoWindow(100, 50);
cam->setNearClipDistance(1);
cam->setPosition(0.0f, 0.0f, 0.0f);
//cam->setFarClipDistance(100.0f);
cam->setFOVy(Ogre::Radian(Ogre::Math::PI / 2.0f));
Ogre::SceneNode* defaultNode = _scnMgr->createSceneNode();
defaultNode->setPosition(initialPos);
defaultNode->setOrientation(initialOrient);
defaultNode->attachObject(cam);
_camsVec.push_back(new ZCameraInfo(_camsVec.size(), "ORTHOGRAPHIC", cam->getName(), control, cam));
}
//-------------------------------------------------------------------------------------
void SampleApp::createScene(void)
{
mImpulse = btVector3(0,0,0);
mLoader = new DotSceneLoader();
mLoader->parseDotScene(mSceneFile, "General", mSceneMgr,0,"",Globals::phyWorld);
// Get rid of the initial camera
mSceneMgr->destroyCamera(mCamera);
//ENTITY DECLARATIONS
Ogre::SceneNode* headNode;
Ogre::Entity* head;
head = mSceneMgr->createEntity("Ex1.mesh");
headNode = mSceneMgr->createSceneNode();
mSceneMgr->getRootSceneNode()->addChild(headNode);
headNode->attachObject(head);
//headNode->scale(0.1,0.1,0.1);
//headNode->setPosition(0,25,0);
//Create shape.
BtOgre::StaticMeshToShapeConverter converter(head);
mCharacterShape = converter.createBox(); // Declare this btCollisionShape * pointer in SampleApp.h
//Calculate inertia tensor.
btScalar mass = 5;
btVector3 inertia;
mCharacterShape -> calculateLocalInertia(mass, inertia);
//Create BtOgre MotionState (connects Ogre and Bullet).
BtOgre::RigidBodyState *characterState = new BtOgre::RigidBodyState(headNode);
//Create the Body.
mCharacterBody = new btRigidBody(mass, characterState, mCharacterShape, inertia);
mCharacterBody ->setActivationState(DISABLE_DEACTIVATION);
//mCharacterBody->setCollisionFlags(mCharacterBody->getCollisionFlags() | btCollisionObject::CF_STATIC_OBJECT);
// Get bullet debug lines to show using F3
Globals::dbgdraw = new BtOgre::DebugDrawer(mSceneMgr -> getRootSceneNode(), Globals::phyWorld);
Globals::phyWorld->setDebugDrawer(Globals::dbgdraw);
Globals::phyWorld->addRigidBody(mCharacterBody);
//END OF ENTITY DECLARATIONS
// Loop through all cameras and grab their name and set their debug representation
Ogre::SceneManager::CameraIterator cameras = mSceneMgr->getCameraIterator();
while (cameras.hasMoreElements())
{
Ogre::Camera* camera = cameras.getNext();
mCamNames.push_back(camera->getName());
Ogre::Entity* debugEnt = mSceneMgr->createEntity(camera->getName() + Ogre::String("_debug"), "scbCamera.mesh");
try{
Ogre::SceneNode* sNode = mSceneMgr->getSceneNode(camera->getName());
sNode->attachObject(debugEnt);
sNode->scale(0.5, 0.5, 0.5);
}catch (...){
Ogre::SceneNode* pNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(camera->getName());
pNode->setPosition(camera->getPosition());
pNode->setOrientation(camera->getOrientation());
pNode->attachObject(debugEnt);
pNode->scale(0.5, 0.5, 0.5);
}
}
// Grab the first available camera, for now
Ogre::String cameraName = mCamNames[0];
try
{
mActiveCamera = mSceneMgr->getCamera(cameraName);
mWindow->getViewport(0)->setCamera(mActiveCamera);
mCameraMan->setCamera(mActiveCamera);
mSceneMgr->getEntity(mActiveCamera->getName() + Ogre::String("_debug"))->setVisible(false);
//for(unsigned int ij = 0;ij < mLoader->mPGHandles.size();ij++)
//{
// mLoader->mPGHandles[ij]->setCamera(mActiveCamera);
//}
}
catch (Ogre::Exception& e)
{
Ogre::LogManager::getSingleton().logMessage("SampleApp::createScene : setting the active camera to (\"" +
cameraName + ") failed: " + e.getFullDescription());
}
}
void CSaveSceneView::SceneNodeExplore(Ogre::SceneNode *SceneNode)
{
Ogre::Entity *Entity = NULL;
Ogre::Camera *Camera = NULL;
Ogre::Light *Light = NULL;
Ogre::ParticleSystem *ParticleSystem = NULL;
Ogre::ManualObject *ManualObject = NULL;
Ogre::BillboardSet *BillboardSet = NULL;
xmlTextWriterStartElement(m_XmlWriter, BAD_CAST "SceneNode");
Ogre::String SceneNodeName = SceneNode->getName();
xmlTextWriterWriteAttribute(m_XmlWriter,
BAD_CAST "SceneNodeName",
BAD_CAST SceneNodeName.c_str());
Ogre::SceneNode::ObjectIterator obji = SceneNode->getAttachedObjectIterator();
while (obji.hasMoreElements())
{
Ogre::MovableObject* mobj = obji.getNext();
Ogre::String Type = mobj->getMovableType();
if (Type == "Entity")
{
Entity = (Ogre::Entity *)(mobj);
Ogre::String EntityName = Entity->getName();
xmlTextWriterStartElement(m_XmlWriter, BAD_CAST "Entity");
xmlTextWriterWriteAttribute(m_XmlWriter,
BAD_CAST "EntityName",
BAD_CAST EntityName.c_str());
Ogre::MeshPtr Mesh = Entity->getMesh();
Ogre::String MeshName = Mesh->getName();
xmlTextWriterWriteAttribute(m_XmlWriter,
BAD_CAST "MeshName",
BAD_CAST MeshName.c_str());
xmlTextWriterEndElement(m_XmlWriter);
}
if (Type == "Camera")
{
Camera = (Ogre::Camera *)(mobj);
Ogre::String CameraName = Camera->getName();
xmlTextWriterStartElement(m_XmlWriter, BAD_CAST "Camera");
xmlTextWriterWriteAttribute(m_XmlWriter,
BAD_CAST "CameraName",
BAD_CAST CameraName.c_str());
Ogre::Vector3 CameraPosition = Camera->getPosition();
xmlTextWriterWriteFormatAttribute(m_XmlWriter,
BAD_CAST "XPosition",
"%f",CameraPosition.x);
xmlTextWriterWriteFormatAttribute(m_XmlWriter,
BAD_CAST "YPosition",
"%f",CameraPosition.y);
xmlTextWriterWriteFormatAttribute(m_XmlWriter,
BAD_CAST "ZPosition",
"%f",CameraPosition.z);
Ogre::Vector3 CameraDirection = Camera->getDirection();
xmlTextWriterWriteFormatAttribute(m_XmlWriter,
BAD_CAST "XDirection",
"%f",CameraDirection.x);
xmlTextWriterWriteFormatAttribute(m_XmlWriter,
BAD_CAST "YDirection",
"%f",CameraDirection.y);
xmlTextWriterWriteFormatAttribute(m_XmlWriter,
BAD_CAST "ZDirection",
"%f",CameraDirection.z);
xmlTextWriterEndElement(m_XmlWriter);
}
if (Type == "Light")
{
Light = (Ogre::Light *)(mobj);
}
if (Type == "ParticleSystem")
{
ParticleSystem = (Ogre::ParticleSystem *)(mobj);
}
if (Type == "ManualObject")
{
ManualObject = (Ogre::ManualObject *)(mobj);
}
if (Type == "BillboardSet")
{
BillboardSet = (Ogre::BillboardSet *)(mobj);
}
}
Ogre::Node::ChildNodeIterator nodei = SceneNode->getChildIterator();
while (nodei.hasMoreElements())
{
Ogre::SceneNode* node = (Ogre::SceneNode*)(nodei.getNext());
// Add this subnode and its children...
SceneNodeExplore(node);
}
xmlTextWriterEndElement(m_XmlWriter); //end SceneNode
}
void OgreInfo::diagnose(std::ostream& outputStream)
{
Ogre::SceneManagerEnumerator::SceneManagerIterator sceneManagerI = Ogre::Root::getSingleton().getSceneManagerIterator();
while (sceneManagerI.hasMoreElements()) {
Ogre::SceneManager* sceneManager = sceneManagerI.getNext();
outputStream << "Scenemanager(" << sceneManager->getTypeName() << ") " << sceneManager->getName() << std::endl;
outputStream << " Number of scene nodes: " << countNodes(sceneManager->getRootSceneNode()) << std::endl;
outputStream << " Movable objects:" << std::endl;
unsigned int movableObjectCounter = 0;
Ogre::Root::MovableObjectFactoryIterator movableObjectFactoryI = Ogre::Root::getSingleton().getMovableObjectFactoryIterator();
while (movableObjectFactoryI.hasMoreElements()) {
Ogre::MovableObjectFactory* factory = movableObjectFactoryI.getNext();
std::string type(factory->getType());
{
Ogre::SceneManager::MovableObjectIterator I = sceneManager->getMovableObjectIterator(type);
while (I.hasMoreElements()) {
movableObjectCounter++;
Ogre::MovableObject* movable = I.getNext();
if (movable->getMovableType() == "Light") {
Ogre::Light* light = static_cast<Ogre::Light*> (movable);
outputStream << " * Light " << light->getName() << "(" << (light->isInScene() ? "in scene" : "not in scene") << ")" << std::endl;
outputStream << " Pos: " << light->getDerivedPosition() << std::endl;
outputStream << " Direction: " << light->getDerivedDirection() << std::endl;
} else {
std::stringstream ssPosAndOrientation;
if (movable->getParentSceneNode() && movable->isInScene()) {
ssPosAndOrientation << " pos: " << movable->getParentSceneNode()->getPosition() << " orientation: " << movable->getParentSceneNode()->getOrientation();
}
outputStream << " * " << type << " " << movable->getName() << "(" << (movable->isInScene() ? "in scene" : "not in scene") << ")" << ssPosAndOrientation.str() << std::endl;
// outputStream << " Pos: " << light->getDerivedPosition() << std::endl;
// outputStream << " Direction: " << light->getDerivedDirection() << std::endl;
}
}
}
}
outputStream << " Number of movable objects: " << movableObjectCounter << std::endl;
outputStream << " Cameras:" << std::endl;
{
Ogre::SceneManager::CameraIterator I = sceneManager->getCameraIterator();
while (I.hasMoreElements()) {
Ogre::Camera* camera = I.getNext();
outputStream << " Camera " << camera->getName() << "(" << (camera->isInScene() ? "in scene" : "not in scene") << ")" << std::endl;
outputStream << " Pos: " << camera->getDerivedPosition() << std::endl;
outputStream << " Direction: " << camera->getDerivedDirection() << std::endl;
outputStream << " Clip distances: " << camera->getNearClipDistance() << " - " << camera->getFarClipDistance() << std::endl;
}
}
}
size_t resourceMemoryUsage = 0;
outputStream << "Resource Managers:" << std::endl;
Ogre::ResourceGroupManager::ResourceManagerIterator I = Ogre::ResourceGroupManager::getSingleton().getResourceManagerIterator();
while (I.hasMoreElements()) {
std::string name = I.peekNextKey();
Ogre::ResourceManager* manager = I.getNext();
outputStream << " Resource Manager: " << name << std::endl;
if (manager->getMemoryBudget() == std::numeric_limits<size_t>::max()) {
outputStream << " Memory budget: not set" << std::endl;
} else {
outputStream << " Memory budget: " << manager->getMemoryBudget() << " bytes" << std::endl;
}
outputStream << " Memory usage: " << manager->getMemoryUsage() << " bytes" << std::endl;
resourceMemoryUsage += manager->getMemoryUsage();
Ogre::ResourceManager::ResourceMapIterator resourceI = manager->getResourceIterator();
if (resourceI.hasMoreElements()) {
outputStream << " Resources: " << std::endl;
int resourceCount = 0;
int loadedResourceCount = 0;
while (resourceI.hasMoreElements()) {
Ogre::ResourcePtr resource = resourceI.getNext();
if (resource->isLoaded()) {
std::string reloadable = resource->isReloadable() ? " reloadable" : "";
outputStream << " " << resource->getName() << " ( " << resource->getSize() << " bytes)" << reloadable;
Ogre::Texture* texture = dynamic_cast<Ogre::Texture*>(resource.get());
if (texture) {
outputStream << texture->getWidth() << "x" << texture->getHeight() << " ";
}
outputStream << std::endl;
loadedResourceCount++;
}
resourceCount++;
}
outputStream << " Total number of resources: " << resourceCount << std::endl;
outputStream << " Number of loaded resources: " << loadedResourceCount << std::endl;
}
}
outputStream << "Total memory usage for all resource manager: " << resourceMemoryUsage << " bytes" << std::endl;
outputStream << std::flush;
}