/* Set default values for the variables */

animating_ = false;

space_down_ = false;

animation_state_ = NULL;

input_manager_ = NULL;

keyboard_ = NULL;

mouse_ = NULL;

/* Run all initialization steps */

InitRootNode();

InitPlugins();

InitRenderSystem();

InitWindow();

InitViewport();

InitEvents();

InitOIS();

LoadMaterials();

try {

/* We need to have an Ogre root to be able to access all Ogre functions */

ogre_root_ = std::auto_ptr<Ogre::Root>(new Ogre::Root(config_filename_g, plugins_filename_g, log_filename_g));

//ogre_root_->showConfigDialog();

}

catch (Ogre::Exception &e){

throw(OgreAppException(std::string("Ogre::Exception: ") + std::string(e.what())));

}

catch(std::exception &e){

throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what())));

}

try {

/* Load plugin responsible for OpenGL render system */

Strings plugin_names;

plugin_names.push_back("RenderSystem_GL");

Strings::iterator iter = plugin_names.begin();

Strings::iterator iter_end = plugin_names.end();

for (; iter != iter_end; iter++){

Ogre::String& plugin_name = (*iter);

if (OGRE_DEBUG_MODE){

plugin_name.append("_d");

}

ogre_root_->loadPlugin(plugin_name);

}

}

catch (Ogre::Exception &e){

throw(OgreAppException(std::string("Ogre::Exception: ") + std::string(e.what())));

}

catch(std::exception &e){

throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what())));

}

try {

const Ogre::RenderSystemList& render_system_list = ogre_root_->getAvailableRenderers();

if (render_system_list.size() == 0)

{

throw(OgreAppException(std::string("OgreApp::Exception: Sorry, no rendersystem was found.")));

}

Ogre::RenderSystem *render_system = render_system_list.at(0);

ogre_root_->setRenderSystem(render_system);

}

catch (Ogre::Exception &e){

throw(OgreAppException(std::string("Ogre::Exception: ") + std::string(e.what())));

}

catch(std::exception &e){

throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what())));

}

try {

/* Create main window for the application */

bool create_window_automatically = false;

ogre_root_->initialise(create_window_automatically, window_title_g, custom_window_capacities_g);

Ogre::NameValuePairList params;

params["FSAA"] = "0";

params["vsync"] = "true";

ogre_window_ = ogre_root_->createRenderWindow(window_title_g, window_width_g, window_height_g, window_full_screen_g, &params);

ogre_window_->setActive(true);

ogre_window_->setAutoUpdated(false);

}

catch (Ogre::Exception &e){

throw(OgreAppException(std::string("Ogre::Exception: ") + std::string(e.what())));

}

catch(std::exception &e){

throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what())));

}

try {

/* Retrieve scene manager and root scene node */

Ogre::SceneManager* scene_manager = ogre_root_->createSceneManager(Ogre::ST_GENERIC, "MySceneManager");

Ogre::SceneNode* root_scene_node = scene_manager->getRootSceneNode();

/* Create camera object */

Ogre::Camera* camera = scene_manager->createCamera("MyCamera");

Ogre::SceneNode* camera_scene_node = root_scene_node->createChildSceneNode("MyCameraNode");

camera_scene_node->attachObject(camera);

camera->setNearClipDistance(camera_near_clip_distance_g);

camera->setFarClipDistance(camera_far_clip_distance_g);

camera->setPosition(camera_position_g);

camera->lookAt(camera_look_at_g);

camera->setFixedYawAxis(true, camera_up_g);

/* Create viewport */

Ogre::Viewport *viewport = ogre_window_->addViewport(camera, viewport_z_order_g, viewport_left_g, viewport_top_g, viewport_width_g, viewport_height_g);

viewport->setAutoUpdated(true);

viewport->setBackgroundColour(viewport_background_color_g);

/* Set aspect ratio */

float ratio = float(viewport->getActualWidth()) / float(viewport->getActualHeight());

camera->setAspectRatio(ratio);

}

catch (Ogre::Exception &e){

throw(OgreAppException(std::string("Ogre::Exception: ") + std::string(e.what())));

}

catch(std::exception &e){

throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what())));

}

try {

/* Add this object as a FrameListener (see frameRenderingQueued event) */

ogre_root_->addFrameListener(this);

/* Add this object as a WindowEventListener to handle the window resize event */

Ogre::WindowEventUtilities::addWindowEventListener(ogre_window_, this);

}

catch (Ogre::Exception &e){

throw(OgreAppException(std::string("Ogre::Exception: ") + std::string(e.what())));

}

catch(std::exception &e){

throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what())));

}

/* Initialize the Object Oriented Input System (OIS) */

try {

/* Initialize input manager */

OIS::ParamList pl; // Parameter list passed to the input manager initialization

size_t windowHnd = 0;

std::ostringstream windowHndStr;

ogre_window_->getCustomAttribute("WINDOW", &windowHnd);

windowHndStr << windowHnd;

pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));

pl.insert(std::make_pair(std::string("w32_mouse"),

std::string("DISCL_FOREGROUND" )));

pl.insert(std::make_pair(std::string("w32_mouse"),

std::string("DISCL_NONEXCLUSIVE")));

input_manager_ = OIS::InputManager::createInputSystem(pl);

/*size_t hWnd = 0;

ogre_window_->getCustomAttribute("WINDOW", &hWnd);

input_manager_ = OIS::InputManager::createInputSystem(hWnd);*/

/* Initialize keyboard and mouse */

keyboard_ = static_cast<OIS::Keyboard*>(input_manager_->createInputObject(OIS::OISKeyboard, false));

mouse_ = static_cast<OIS::Mouse*>(input_manager_->createInputObject(OIS::OISMouse, false));

unsigned int width, height, depth;

int top, left;

ogre_window_->getMetrics(width, height, depth, left, top);

const OIS::MouseState &ms = mouse_->getMouseState();

ms.width = width;

ms.height = height;

}

catch(std::exception &e){

throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what())));

}

try {

/* Load materials that can then be assigned to objects in the scene */

Ogre::String resource_group_name = "MyGame";

Ogre::ResourceGroupManager& resource_group_manager = Ogre::ResourceGroupManager::getSingleton();

resource_group_manager.createResourceGroup(resource_group_name);

bool is_recursive = false;

resource_group_manager.addResourceLocation(material_directory_g, "FileSystem", resource_group_name, is_recursive);

resource_group_manager.initialiseResourceGroup(resource_group_name);

resource_group_manager.loadResourceGroup(resource_group_name);

}

catch (Ogre::Exception &e){

throw(OgreAppException(std::string("Ogre::Exception: ") + std::string(e.what())));

}

catch(std::exception &e){

throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what())));

}

try {

/* Create two rectangles */

/* Retrieve scene manager and root scene node */

Ogre::SceneManager* scene_manager = ogre_root_->getSceneManager("MySceneManager");

Ogre::SceneNode* root_scene_node = scene_manager->getRootSceneNode();

/* Create the 3D object */

Ogre::ManualObject* object = NULL;

Ogre::String object_name = "Wall";

object = scene_manager->createManualObject(object_name);

object->setDynamic(false);

/* Create triangle list for the object */

object->begin(material_name, Ogre::RenderOperation::OT_TRIANGLE_LIST);

/* Add vertices */

/* One side of the "wall" */

object->position(-1.0,-1.0,0.0);

object->normal(0.0, 0.0, -1.0);

object->tangent(-1.0, 0.0, 0.0);

object->textureCoord(1.0, 0.0);

object->position(-1.0,1.0,0.0);

object->normal(0.0, 0.0, -1.0);

object->tangent(-1.0, 0.0, 0.0);

object->textureCoord(1.0, 1.0);

object->position(1.0,1.0,0.0);

object->normal(0.0, 0.0, -1.0);

object->tangent(-1.0, 0.0, 0.0);

object->textureCoord(0.0, 1.0);

object->position(1.0,-1.0,0.0);

object->normal(0.0, 0.0, -1.0);

object->tangent(-1.0, 0.0, 0.0);

object->textureCoord(0.0, 0.0);

/* The other side of the "wall" */

object->position(-1.0,-1.0,0.0);

object->normal(0.0, 0.0, 1.0);

object->tangent(1.0, 0.0, 0.0);

object->textureCoord(0.0, 0.0);

object->position(-1.0,1.0,0.0);

object->normal(0.0, 0.0, 1.0);

object->tangent(1.0, 0.0, 0.0);

object->textureCoord(0.0, 1.0);

object->position(1.0,1.0,0.0);

object->normal(0.0, 0.0, 1.0);

object->tangent(1.0, 0.0, 0.0);

object->textureCoord(1.0, 1.0);

object->position(1.0,-1.0,0.0);

object->normal(0.0, 0.0, 1.0);

object->tangent(1.0, 0.0, 0.0);

object->textureCoord(1.0, 0.0);

/* Add triangles */

/* One side */

object->triangle(0, 1, 2);

object->triangle(0, 2, 3);

/* The other side */

object->triangle(4, 7, 6);

object->triangle(4, 6, 5);

/* We finished the object */

object->end();

/* Convert triangle list to a mesh */

Ogre::String mesh_name = "Wall";

object->convertToMesh(mesh_name);

/* Create one instance of the sphere (one entity) */

/* The same object can have multiple instances or entities */

Ogre::Entity* entity = scene_manager->createEntity(mesh_name);

/* Apply a material to the entity to give it color */

/* We already did that above, so we comment it out here */

/* entity->setMaterialName(material_name); */

/* But, this call is useful if we have multiple entities with different materials */

/* Create a scene node for the entity */

/* The scene node keeps track of the entity's position */

Ogre::SceneNode* scene_node = root_scene_node->createChildSceneNode(mesh_name);

scene_node->attachObject(entity);

/* Position and rotate the entity with the scene node */

//scene_node->rotate(Ogre::Vector3(0, 1, 0), Ogre::Degree(60));

//scene_node->rotate(Ogre::Vector3(1, 0, 0), Ogre::Degree(30));

//scene_node->rotate(Ogre::Vector3(1, 0, 0), Ogre::Degree(-90));

//scene_node->translate(0.0, 0.0, 0.0);

scene_node->scale(0.5, 0.5, 0.5);

}

catch (Ogre::Exception &e){

throw(OgreAppException(std::string("Ogre::Exception: ") + std::string(e.what())));

}

catch(std::exception &e){

throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what())));

}

try {

/* Main loop to keep the application going */

ogre_root_->clearEventTimes();

while(!ogre_window_->isClosed()){

ogre_window_->update(false);

ogre_window_->swapBuffers();

ogre_root_->renderOneFrame();

Ogre::WindowEventUtilities::messagePump();

}

}

catch (Ogre::Exception &e){

throw(OgreAppException(std::string("Ogre::Exception: ") + std::string(e.what())));

}

catch(std::exception &e){

throw(OgreAppException(std::string("std::Exception: ") + std::string(e.what())));

}

/* Retrieve scene manager and root scene node */

Ogre::SceneManager* scene_manager = ogre_root_->getSceneManager("MySceneManager");

Ogre::SceneNode* root_scene_node = scene_manager->getRootSceneNode();

/* Set up animation */

Ogre::Real duration = Ogre::Math::TWO_PI;

Ogre::Real num_steps = 36;

Ogre::Real step = duration/num_steps;

Ogre::Animation* animation = scene_manager->createAnimation("Animation", duration);

animation->setInterpolationMode(Ogre::Animation::IM_LINEAR);

Ogre::Node *object_scene_node = root_scene_node->getChild(object_name);

Ogre::NodeAnimationTrack* track = animation->createNodeTrack(0, object_scene_node);

/* Set up frames for animation */

Ogre::TransformKeyFrame* key;

Ogre::Quaternion quat;

for (int i = 0; i < num_steps; i++){

Ogre::Real current = ((float) i) * step;

key = track->createNodeKeyFrame(current);

quat.FromAngleAxis(Ogre::Radian(-current), Ogre::Vector3(0, 1, 0));

key->setRotation(quat);

key->setScale(Ogre::Vector3(0.5, 0.5, 0.5));

}

/* Create animation state */

animation_state_ = scene_manager->createAnimationState("Animation");

animation_state_->setEnabled(true);

animation_state_->setLoop(true);

/* Turn on animating flag */

animating_ = true;

/* This event is called after a frame is queued for rendering */

/* Do stuff in this event since the GPU is rendering and the CPU is idle */

/* Keep animating if flag is on */

if (animating_){

animation_state_->addTime(fe.timeSinceLastFrame);

}

/* Capture input */

keyboard_->capture();

mouse_->capture();

/* Handle specific key events */

if (keyboard_->isKeyDown(OIS::KC_SPACE)){

space_down_ = true;

}

if ((!keyboard_->isKeyDown(OIS::KC_SPACE)) && space_down_){

animating_ = !animating_;

space_down_ = false;

}

if (keyboard_->isKeyDown(OIS::KC_ESCAPE)){

animation_state_->setTimePosition(0);

}

if (keyboard_->isKeyDown(OIS::KC_S)){

ogre_window_->writeContentsToFile("normal_map.png");

}

return true;

/* Update the window and aspect ratio when the window is resized */

int width = rw->getWidth();

int height = rw->getHeight();

Ogre::SceneManager* scene_manager = ogre_root_->getSceneManager("MySceneManager");

Ogre::Camera* camera = scene_manager->getCamera("MyCamera");

if (camera != NULL){

//std::cout << "1 " << (double)width/height << std::endl;

camera->setAspectRatio((double)width/height);

}

const OIS::MouseState &ms = mouse_->getMouseState();

ms.width = width;

ms.height = height;

ogre_window_->resize(width, height);

ogre_window_->windowMovedOrResized();

ogre_window_->update();