int startup()
{
_root = new Root("plugins_d.cfg");
if (!_root->showConfigDialog()) {
return -1;
}
RenderWindow* window = _root->initialise(true, "Lab 4");
_sceneManager = _root->createSceneManager(ST_GENERIC);
Camera* camera = _sceneManager->createCamera("Camera");
camera->setPosition(Ogre::Vector3(0,0,50));
camera->lookAt(Ogre::Vector3(0,0,0));
camera->setNearClipDistance(5);
Viewport *viewPort = window->addViewport(camera);
viewPort->setBackgroundColour(ColourValue(0.0,0.0,0.0));
camera->setAspectRatio(Real(viewPort->getActualWidth())/Real(viewPort->getActualHeight()));
loadResources();
createScene();
_listener = new MyFrameListener(window, camera, new CylindricalEffect(_myCube, Ogre::Vector3(2.0, 10.0, 0.0), Ogre::Vector3(0.0, 0.0, 0.1)));
_root->addFrameListener(_listener);
return 0;
}
void go(void)
{
// OGRE의 메인 루트 오브젝트 생성
#if !defined(_DEBUG)
mRoot = new Root("plugins.cfg", "ogre.cfg", "ogre.log");
#else
mRoot = new Root("plugins_d.cfg", "ogre.cfg", "ogre.log");
#endif
// 초기 시작의 컨피규레이션 설정 - ogre.cfg 이용
if (!mRoot->restoreConfig()) {
if (!mRoot->showConfigDialog()) return;
}
mWindow = mRoot->initialise(true, "Hello Professor : Copyleft Dae-Hyun Lee");
// ESC key를 눌렀을 경우, 오우거 메인 렌더링 루프의 탈출을 처리
size_t windowHnd = 0;
std::ostringstream windowHndStr;
OIS::ParamList pl;
mWindow->getCustomAttribute("WINDOW", &windowHnd);
windowHndStr << windowHnd;
pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
mInputManager = OIS::InputManager::createInputSystem(pl);
mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject(OIS::OISKeyboard, false));
mESCListener = new ESCListener(mKeyboard);
mRoot->addFrameListener(mESCListener);
mSceneMgr = mRoot->createSceneManager(ST_GENERIC);
mCamera = mSceneMgr->createCamera("camera");
mCamera->setPosition(0.0f, 200.0f, 300.0f);
mCamera->lookAt(0.0f, 100.0f, 0.00f);
mCamera->setNearClipDistance(5.0f);
mViewport = mWindow->addViewport(mCamera);
mViewport->setBackgroundColour(ColourValue(0.0f,0.0f,0.5f));
mCamera->setAspectRatio(Real(mViewport->getActualWidth()) / Real(mViewport->getActualHeight()));
ResourceGroupManager::getSingleton().addResourceLocation("resource.zip", "Zip");
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
mSceneMgr->setAmbientLight(ColourValue(1.0f, 1.0f, 1.0f));
Entity* daehyunEntity = mSceneMgr->createEntity("Daehyun", "DustinBody.mesh");
SceneNode* daehyunNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
daehyunNode->attachObject(daehyunEntity);
mRoot->startRendering();
mInputManager->destroyInputObject(mKeyboard);
OIS::InputManager::destroyInputSystem(mInputManager);
delete mRoot;
}
void createViewports(void){
// Create one viewport, entire window, and tie it to our camera
vp = mWindow->addViewport(mCamera);
vp->setBackgroundColour(ColourValue(0,0,0));
// Alter the camera aspect ratio to match the viewport
mCamera->setAspectRatio(Real(vp->getActualWidth()) / Real(vp->getActualHeight()));
}
virtual void createViewports()
{
// Create one viewport, entire window.
Viewport *vp = mWindow->addViewport(mCamera);
vp->setBackgroundColour(ColourValue(0, 0.25, 0.5));
// Alter the camera aspect ratio to match the viewport.
mCamera->setAspectRatio(
Real(vp->getActualWidth()) / Real(vp->getActualHeight()));
}
int main()
{
Root *root = new Root(StringUtil::BLANK, StringUtil::BLANK);
GLPlugin *glPlugin = new GLPlugin();
root->installPlugin(glPlugin);
RenderSystem *renderSystem = root->getAvailableRenderers().at(0);
renderSystem->setConfigOption("Fixed Pipeline Enabled", "No");
root->setRenderSystem(renderSystem);
root->initialise(false);
RenderWindow *window = root->createRenderWindow("Hello, OGRE", 800, 600, false);
SceneManager *sceneManager = root->createSceneManager(ST_GENERIC);
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
RTShader::ShaderGenerator::initialize();
RTShader::ShaderGenerator::getSingleton().addSceneManager(sceneManager);
createSphereMesh("SphereMesh", 10.f, 16, 16);
ResourceGroupManager::getSingleton().addResourceLocation("shader", "FileSystem");
createSphereMaterial("SphereMaterial", 1.f, 0.f, 0.f);
Camera *camera = sceneManager->createCamera("Camera");
camera->setPosition(0.f, 0.f, 80.f);
camera->lookAt(0.f, 0.f, 0.f);
camera->setNearClipDistance(5.f);
Viewport *viewport = window->addViewport(camera);
viewport->setBackgroundColour(ColourValue(0.f, 0.f, 0.f));
viewport->setMaterialScheme(RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME);
camera->setAspectRatio((Real)(viewport->getActualWidth()) / (Real)(viewport->getActualHeight()));
sceneManager->setAmbientLight(ColourValue(0.5f, 0.5f, 0.5f));
Light *light = sceneManager->createLight("Light");
light->setPosition(50.f, 50.f, 50.f);
Entity *sphereEntity = sceneManager->createEntity("SphereEntity", "SphereMesh");
sphereEntity->setMaterialName("SphereMaterial");
SceneNode *sphereNode = sceneManager->getRootSceneNode()->createChildSceneNode();
sphereNode->attachObject(sphereEntity);
HelloOgreFrameListener *frameListener = new HelloOgreFrameListener(window);
root->addFrameListener(frameListener);
root->startRendering();
delete frameListener;
delete root;
delete glPlugin;
return 0;
}
void OgreCPP::setup(std::string mResourcePath)
{
// Create a new root object with the correct paths
#ifdef __linux
mRoot = new Root(mResourcePath + "/plugins_linux.cfg", mResourcePath + "/ogre.cfg",
mResourcePath + "/ogre.log");
#else
mRoot = new Root(mResourcePath + "/Contents/MacOS/plugins.cfg", mResourcePath + "/Contents/MacOS/ogre.cfg",
mResourcePath + "/Contents/MacOS/ogre.log");
mRoot->setRenderSystem(mRoot->getAvailableRenderers().front());
#endif
// Show a configure box and exit if user clicked cancel
if(!mRoot->showConfigDialog())
return;
// Initialise
RenderWindow *mWindow = mRoot->initialise(true);
mSceneMgr = mRoot->createSceneManager(ST_GENERIC, "My scene manager");
// Add resource locations
//ResourceGroupManager::getSingleton().addResourceLocation(mResourcePath,
// std::string("FileSystem"), ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
setupResources(mResourcePath);
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// Create the camera, node & attach camera
Camera *mCamera = mSceneMgr->createCamera("PlayerCam");
SceneNode *camNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
camNode->attachObject(mCamera);
mWindow->addViewport(mCamera);
mCamera->setPosition(Ogre::Vector3(0,0,0));
mCamera->lookAt(Ogre::Vector3(0,0,300));
mCamera->roll( Ogre::Radian( M_PI ) );
mCamera->setNearClipDistance( 0.2 );
createScene();
}
// ------------------------- Application main function ------------------------- //
void run() {
// Create root object and window
mRoot = new Root();
mRoot->restoreConfig(); // read config from ogre.cfg
//if(!mRoot->showConfigDialog()) return; // alternatively, you can show a dialog window here
mWindow = mRoot->initialise(true, "Ogre running");
mRoot->addFrameListener(this);
mEventListener = new SimpleMouseAndKeyboardListener(mWindow, mRoot, this);
// Load resources
ResourceGroupManager::getSingleton().addResourceLocation("../data/Character", "FileSystem");
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// Create scene
mScene = createOgreScene();
// Set current scene
Viewport* vp = mWindow->addViewport(mScene->getCamera("MainCamera"));
vp->setBackgroundColour(ColourValue(0, 0, 0));
// Start rendering loop
mRoot->startRendering();
}
int mainSetupAndRunOgre()
{
Ogre::LogManager* log_manager = 0;
Ogre::Root* root = 0;
#ifdef FREEORION_MACOSX
OISInput* ois_input_plugin = 0;
#elif defined(OGRE_STATIC_LIB)
OISInput* ois_input_plugin = 0;
Ogre::OctreePlugin* octree_plugin = 0;
Ogre::ParticleFXPlugin* particle_fx_plugin = 0;
Ogre::GLPlugin* gl_plugin = 0;
#endif
try {
using namespace Ogre;
log_manager = new LogManager();
log_manager->createLog((GetUserDir() / "ogre.log").string(), true, false);
root = new Root((GetRootDataDir() / "ogre_plugins.cfg").string());
// this line is needed on some Linux systems which otherwise will crash with
// errors about GLX_icon.png being missing.
Ogre::ResourceGroupManager::getSingleton().addResourceLocation((ClientUI::ArtDir() / ".").string(),
"FileSystem", "General");
#if defined(OGRE_STATIC_LIB)
octree_plugin = new Ogre::OctreePlugin;
particle_fx_plugin = new Ogre::ParticleFXPlugin;
gl_plugin = new Ogre::GLPlugin;
root->installPlugin(octree_plugin);
root->installPlugin(particle_fx_plugin);
root->installPlugin(gl_plugin);
#endif
RenderSystem* selected_render_system = root->getRenderSystemByName("OpenGL Rendering Subsystem");
if (selected_render_system == 0)
throw std::runtime_error("Failed to find an Ogre GL render system.");
root->setRenderSystem(selected_render_system);
int colour_depth = GetOptionsDB().Get<int>("color-depth");
bool fullscreen = GetOptionsDB().Get<bool>("fullscreen");
std::pair<int, int> width_height = HumanClientApp::GetWindowWidthHeight(selected_render_system);
int width(width_height.first), height(width_height.second);
selected_render_system->setConfigOption("Full Screen", fullscreen ? "Yes" : "No");
std::string video_mode_str =
boost::io::str(boost::format("%1% x %2% @ %3%-bit colour") %
width %
height %
colour_depth);
selected_render_system->setConfigOption("Video Mode", video_mode_str);
RenderWindow* window = root->initialise(true, "FreeOrion " + FreeOrionVersionString());
#ifdef FREEORION_WIN32
# ifdef IDI_ICON1
// set window icon to embedded application icon
HWND hwnd;
window->getCustomAttribute("WINDOW", &hwnd);
HINSTANCE hInst = (HINSTANCE)GetModuleHandle(NULL);
SetClassLong (hwnd, GCL_HICON,
(LONG)LoadIcon (hInst, MAKEINTRESOURCE (IDI_ICON1)));
# endif
#endif
SceneManager* scene_manager = root->createSceneManager("OctreeSceneManager", "SceneMgr");
Camera* camera = scene_manager->createCamera("Camera");
camera->setPosition(Vector3(0, 0, 500)); // Position it at 500 in Z direction
camera->lookAt(Vector3(0, 0, -300)); // Look back along -Z
camera->setNearClipDistance(5);
Viewport* viewport = window->addViewport(camera);
viewport->setBackgroundColour(ColourValue(0, 0, 0));
//EntityRenderer entity_renderer(scene_manager);
parse::init();
HumanClientApp app(root, window, scene_manager, camera, viewport, (GetRootDataDir() / "OISInput.cfg").string());
#ifdef FREEORION_MACOSX
ois_input_plugin = new OISInput;
root->installPlugin(ois_input_plugin);
#elif defined(OGRE_STATIC_LIB)
ois_input_plugin = new OISInput;
root->installPlugin(ois_input_plugin);
#else
root->loadPlugin(OGRE_INPUT_PLUGIN_NAME);
#endif
if (GetOptionsDB().Get<bool>("quickstart")) {
// immediately start the server, establish network connections, and
// go into a single player game, using default universe options (a
// standard quickstart, without requiring the user to click the
// quickstart button).
app.NewSinglePlayerGame(true); // acceptable to call before app()
}
std::string load_filename = GetOptionsDB().Get<std::string>("load");
if (load_filename != "") {
// immediately start the server, establish network connections, and
// go into a single player game, loading the indicated file
// (without requiring the user to click the load button).
app.LoadSinglePlayerGame(load_filename); // acceptable to call before app()
}
// run rendering loop
app(); // calls GUI::operator() which calls OgreGUI::Run() which starts rendering loop
} catch (const HumanClientApp::CleanQuit&) {
// do nothing
std::cout << "mainSetupAndRunOgre caught CleanQuit" << std::endl;
} catch (const std::invalid_argument& e) {
Logger().errorStream() << "main() caught exception(std::invalid_argument): " << e.what();
std::cerr << "main() caught exception(std::invalid_arg): " << e.what() << std::endl;
} catch (const std::runtime_error& e) {
Logger().errorStream() << "main() caught exception(std::runtime_error): " << e.what();
std::cerr << "main() caught exception(std::runtime_error): " << e.what() << std::endl;
} catch (const boost::io::format_error& e) {
Logger().errorStream() << "main() caught exception(boost::io::format_error): " << e.what();
std::cerr << "main() caught exception(boost::io::format_error): " << e.what() << std::endl;
} catch (const GG::ExceptionBase& e) {
Logger().errorStream() << "main() caught exception(" << e.type() << "): " << e.what();
std::cerr << "main() caught exception(" << e.type() << "): " << e.what() << std::endl;
} catch (const std::exception& e) {
Logger().errorStream() << "main() caught exception(std::exception): " << e.what();
std::cerr << "main() caught exception(std::exception): " << e.what() << std::endl;
} catch (...) {
Logger().errorStream() << "main() caught unknown exception.";
std::cerr << "main() caught unknown exception." << std::endl;
}
if (root) {
#ifdef FREEORION_MACOSX
root->uninstallPlugin(ois_input_plugin);
delete ois_input_plugin;
#elif defined(OGRE_STATIC_LIB)
root->uninstallPlugin(ois_input_plugin);
root->uninstallPlugin(octree_plugin);
root->uninstallPlugin(particle_fx_plugin);
root->uninstallPlugin(gl_plugin);
delete ois_input_plugin;
delete octree_plugin;
delete particle_fx_plugin;
delete gl_plugin;
#else
root->unloadPlugin(OGRE_INPUT_PLUGIN_NAME);
#endif
delete root;
}
if (log_manager)
delete log_manager;
return 0;
}
void go(void)
{
// OGRE의 메인 루트 오브젝트 생성
#if !defined(_DEBUG)
mRoot = new Root("plugins.cfg", "ogre.cfg", "ogre.log");
#else
mRoot = new Root("plugins_d.cfg", "ogre.cfg", "ogre.log");
#endif
// 초기 시작의 컨피규레이션 설정 - ogre.cfg 이용
if (!mRoot->restoreConfig()) {
if (!mRoot->showConfigDialog()) return;
}
mWindow = mRoot->initialise(true, CLIENT_DESCRIPTION " : Copyleft by Dae-Hyun Lee");
mSceneMgr = mRoot->createSceneManager(ST_GENERIC, "main");
mCamera = mSceneMgr->createCamera("main");
mCamera->setPosition(0.0f, 150.0f, 1000.0f);
mCamera->lookAt(0.0f, 100.0f, 0.0f);
mViewport = mWindow->addViewport(mCamera);
mViewport->setBackgroundColour(ColourValue(0.0f, 0.0f, 0.5f));
mCamera->setAspectRatio(Real(mViewport->getActualWidth()) / Real(mViewport->getActualHeight()));
ResourceGroupManager::getSingleton().addResourceLocation("resource.zip", "Zip");
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
mSceneMgr->setAmbientLight(ColourValue(1.0f, 1.0f, 1.0f));
// 좌표축 표시
Ogre::Entity* mAxesEntity = mSceneMgr->createEntity("Axes", "axes.mesh");
mSceneMgr->getRootSceneNode()->createChildSceneNode("AxesNode", Ogre::Vector3(0, 0, 0))->attachObject(mAxesEntity);
mSceneMgr->getSceneNode("AxesNode")->setScale(5, 5, 5);
_drawGridPlane();
Entity* entity1 = mSceneMgr->createEntity("Ninja", "ninja.mesh");
SceneNode* node1 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Ninja", Vector3(-100.0f, 0.0f, 0.0f));
node1->attachObject(entity1);
Entity* entity2 = mSceneMgr->createEntity("Professor", "DustinBody.mesh");
SceneNode* node2 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Professor", Vector3(200.0f, 0.0f, 200.0f));
node2->attachObject(entity2);
#if 0
Entity* entity2 = mSceneMgr->createEntity("Ninja", "ninja.mesh");
SceneNode* node2 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Ninja", Vector3(0.0f, 0.0f, 0.0f));
node2->attachObject(entity2);
node2->setOrientation(Ogre::Quaternion(Ogre::Degree(180), Ogre::Vector3::UNIT_Y));
#endif
size_t windowHnd = 0;
std::ostringstream windowHndStr;
OIS::ParamList pl;
mWindow->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")));
pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
mInputManager = OIS::InputManager::createInputSystem(pl);
mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject(OIS::OISKeyboard, true));
mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject(OIS::OISMouse, true));
InputController* inputController = new InputController(mRoot, mKeyboard, mMouse);
mRoot->addFrameListener(inputController);
ProfessorController* professorController = new ProfessorController(mRoot);
mRoot->addFrameListener(professorController);
mRoot->startRendering();
mInputManager->destroyInputObject(mKeyboard);
mInputManager->destroyInputObject(mMouse);
OIS::InputManager::destroyInputSystem(mInputManager);
delete professorController;
delete inputController;
delete mRoot;
}
int main(int argc, char **argv)
#endif
{
//-----------------------------------------------------
// 1 enter ogre
//-----------------------------------------------------
Root* root = new Root;
//-----------------------------------------------------
// 2 configure resource paths
//-----------------------------------------------------
// Load resource paths from config file
// File format is:
// [ResourceGroupName]
// ArchiveType=Path
// .. repeat
// For example:
// [General]
// FileSystem=media/
// Zip=packages/level1.zip
ConfigFile cf;
cf.load("./resources.cfg");
// Go through all sections & settings in the file
ConfigFile::SectionIterator seci = cf.getSectionIterator();
String secName, typeName, archName;
while (seci.hasMoreElements())
{
secName = seci.peekNextKey();
ConfigFile::SettingsMultiMap *settings = seci.getNext();
ConfigFile::SettingsMultiMap::iterator i;
for (i = settings->begin(); i != settings->end(); ++i)
{
typeName = i->first;
archName = i->second;
ResourceGroupManager::getSingleton().addResourceLocation(
archName, typeName, secName);
}
}
//-----------------------------------------------------
// 3 Configures the application and creates the window
//-----------------------------------------------------
if(!root->showConfigDialog())
{
//Ogre
delete root;
return false; // Exit the application on cancel
}
RenderWindow* window = root->initialise(true, "Simple Ogre App");
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
//-----------------------------------------------------
// 4 Create the SceneManager
//
// ST_GENERIC = octree
// ST_EXTERIOR_CLOSE = simple terrain
// ST_EXTERIOR_FAR = nature terrain (depreciated)
// ST_EXTERIOR_REAL_FAR = paging landscape
// ST_INTERIOR = Quake3 BSP
//-----------------------------------------------------
SceneManager* sceneMgr = root->createSceneManager(ST_GENERIC);
//-----------------------------------------------------
// 5 Create the camera
//-----------------------------------------------------
Camera* camera = sceneMgr->createCamera("SimpleCamera");
//-----------------------------------------------------
// 6 Create one viewport, entire window
//-----------------------------------------------------
Viewport* viewPort = window->addViewport(camera);
//----------------------------------------------------
// 7 add OIS input handling
//----------------------------------------------------
OIS::ParamList pl;
size_t windowHnd = 0;
std::ostringstream windowHndStr;
//tell OIS about the Ogre window
window->getCustomAttribute("WINDOW", &windowHnd);
windowHndStr << windowHnd;
pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
//setup the manager, keyboard and mouse to handle input
OIS::InputManager* inputManager = OIS::InputManager::createInputSystem(pl);
OIS::Keyboard* keyboard = static_cast<OIS::Keyboard*>(inputManager->createInputObject(OIS::OISKeyboard, true));
OIS::Mouse* mouse = static_cast<OIS::Mouse*>(inputManager->createInputObject(OIS::OISMouse, true));
//tell OIS about the window's dimensions
unsigned int width, height, depth;
int top, left;
window->getMetrics(width, height, depth, left, top);
const OIS::MouseState &ms = mouse->getMouseState();
ms.width = width;
ms.height = height;
// everything is set up, now we listen for input and frames (replaces while loops)
//key events
SimpleKeyListener* keyListener = new SimpleKeyListener();
keyboard->setEventCallback(keyListener);
//mouse events
SimpleMouseListener* mouseListener = new SimpleMouseListener();
mouse->setEventCallback(mouseListener);
//render events
SimpleFrameListener* frameListener = new SimpleFrameListener(keyboard, mouse);
root->addFrameListener(frameListener);
//----------------------------------------------------
// 8 start rendering
//----------------------------------------------------
root->startRendering(); // blocks until a frame listener returns false. eg from pressing escape in this example
//----------------------------------------------------
// 9 clean
//----------------------------------------------------
//OIS
inputManager->destroyInputObject(mouse); mouse = 0;
inputManager->destroyInputObject(keyboard); keyboard = 0;
OIS::InputManager::destroyInputSystem(inputManager); inputManager = 0;
//listeners
delete frameListener;
delete mouseListener;
delete keyListener;
//Ogre
delete root;
return 0;
}
void go(void)
{
// OGRE의 메인 루트 오브젝트 생성
#if !defined(_DEBUG)
mRoot = new Root("plugins.cfg", "ogre.cfg", "ogre.log");
#else
mRoot = new Root("plugins_d.cfg", "ogre.cfg", "ogre.log");
#endif
// 초기 시작의 컨피규레이션 설정 - ogre.cfg 이용
if (!mRoot->restoreConfig()) {
if (!mRoot->showConfigDialog()) return;
}
mWindow = mRoot->initialise(true, "Moving Professor & Ninja : Copyleft by Dae-Hyun Lee");
// ESC key를 눌렀을 경우, 오우거 메인 렌더링 루프의 탈출을 처리
size_t windowHnd = 0;
std::ostringstream windowHndStr;
OIS::ParamList pl;
mWindow->getCustomAttribute("WINDOW", &windowHnd);
windowHndStr << windowHnd;
pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
mInputManager = OIS::InputManager::createInputSystem(pl);
mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject(OIS::OISKeyboard, false));
// Fill Here --------------------------------------------------------------
// ------------------------------------------------------------------------
mCamera->setPosition(0.0f, 100.0f, 500.0f);
mCamera->lookAt(0.0f, 100.0f, 0.0f);
mCamera->setNearClipDistance(5.0f);
mViewport = mWindow->addViewport(mCamera);
mViewport->setBackgroundColour(ColourValue(0.0f,0.0f,0.5f));
mCamera->setAspectRatio(Real(mViewport->getActualWidth()) / Real(mViewport->getActualHeight()));
ResourceGroupManager::getSingleton().addResourceLocation("resource.zip", "Zip");
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
mSceneMgr->setAmbientLight(ColourValue(1.0f, 1.0f, 1.0f));
// 좌표축 표시
Ogre::Entity* mAxesEntity = mSceneMgr->createEntity("Axes", "axes.mesh");
mSceneMgr->getRootSceneNode()->createChildSceneNode("AxesNode",Ogre::Vector3(0,0,0))->attachObject(mAxesEntity);
mSceneMgr->getSceneNode("AxesNode")->setScale(5, 5, 5);
_drawGridPlane();
Entity* entity1 = mSceneMgr->createEntity("Professor", "DustinBody.mesh");
Entity* entity2 = mSceneMgr->createEntity("Ninja", "ninja.mesh");
SceneNode* node1 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Professor", Vector3(0.0f, 0.0f, 0.0f));
node1->attachObject(entity1);
SceneNode* node2 = mSceneMgr->getRootSceneNode()->createChildSceneNode("Ninja", Vector3(200.0f, 0.0f, -200.0f));
node2->attachObject(entity2);
// Fill Here ----------------------------------------------
// --------------------------------------------------------
mRoot->startRendering();
mInputManager->destroyInputObject(mKeyboard);
OIS::InputManager::destroyInputSystem(mInputManager);
delete mRoot;
}
int WINAPI WinMain ( HINSTANCE hInst, HINSTANCE, LPSTR szCmdLine, int)
{
Root * pRoot = new Root(StringUtil::BLANK);
pRoot->loadPlugin(PLUGIN("RenderSystem_GL"));
pRoot->loadPlugin(PLUGIN("RenderSystem_Direct3D9"));
pRoot->addResourceLocation("paging", "FileSystem", "Paging");
if (pRoot->showConfigDialog())
{
OverhangTerrainSceneManager * pScMgr = OGRE_NEW OverhangTerrainSceneManager("Default");
PageManager * pPgMan = OGRE_NEW PageManager();
OverhangTerrainPaging * pOhPging = new OverhangTerrainPaging(pPgMan);
RenderWindow * pRendWindow = pRoot->initialise(true);
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
Light * pSun = pScMgr->createLight("Sun");
pSun->setPosition(0,5000, 0);
pSun->setType(Light::LT_POINT);
MaterialPtr pMat = MaterialManager::getSingleton().create("BaseMaterial", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Pass * pPass = pMat->getTechnique(0) ->getPass(0);
pPass->setLightingEnabled(true);
pPass->setDiffuse(0.1f, 0.5f, 1.0f, 1.0f);
pPass->setAmbient(0.05f, 0.1f, 0.2f);
pPass->setSpecular(1.0f, 1.0f, 1.0f, 1.0f);
pPass->setShininess(80);
Camera * pCam = pScMgr->createCamera("Photographer");
pCam->setNearClipDistance(0.1f);
pCam->setFarClipDistance(7000);
pCam->setPosition(Vector3(-2725.24f, 277.747f, 2748.56f));
pCam->setDirection(Vector3(0.998938f, 0.0495558f, 0.00161433f));
Viewport * vp = pRendWindow->addViewport(pCam);
pCam->setAspectRatio(Real(vp->getActualWidth()) / Real(vp->getActualHeight()));
SceneNode
* pnCam = pScMgr->getRootSceneNode()->createChildSceneNode("Helicopter"),
* pnLight = pScMgr->getRootSceneNode() ->createChildSceneNode("Aura");
pnCam->attachObject(pCam);
pnLight->attachObject(pSun);
OverhangTerrainOptions options;
options.primaryCamera = pCam;
options.pageSize = 129;
options.tileSize = 33;
options.cellScale = 50.0;
options.heightScale = 8.0;
options.channels[TERRAIN_ENTITY_CHANNEL].material = pMat;
options.channels[TERRAIN_ENTITY_CHANNEL].maxGeoMipMapLevel = 6;
options.channels[TERRAIN_ENTITY_CHANNEL].maxPixelError = 10;
options.channels[TERRAIN_ENTITY_CHANNEL].qid = RENDER_QUEUE_1;
pScMgr->setOptions(options);
OverhangTerrainGroup * pGrp = OGRE_NEW OverhangTerrainGroup(pScMgr, NULL, "Paging");
pPgMan->addCamera(pCam);
DummyPageProvider dpp;
pPgMan->setPageProvider(&dpp);
PagedWorld * pWorld = pPgMan->createWorld("OhTSM");
OverhangTerrainPagedWorldSection * pOhPgSect = pOhPging->createWorldSection(pWorld, pGrp);
pScMgr->initialise();
ExamplePageProvider pp(pOhPgSect, pGrp->getResourceGroupName());
pGrp->setPageProvider(&pp);
ExampleController * pController = new ExampleController (pRendWindow, pCam, pScMgr);
pRoot->addFrameListener(pController);
pRoot->startRendering();
delete pController;
OGRE_DELETE pOhPgSect;
OGRE_DELETE pOhPging;
OGRE_DELETE pPgMan;
OGRE_DELETE pScMgr;
}
delete pRoot;
return 0;
}
int mainSetupAndRunOgre() {
Ogre::LogManager* log_manager = 0;
Ogre::Root* root = 0;
OISInput* ois_input_plugin = 0;
#ifdef OGRE_STATIC_LIB
Ogre::OctreePlugin* octree_plugin = 0;
Ogre::ParticleFXPlugin* particle_fx_plugin = 0;
Ogre::GLPlugin* gl_plugin = 0;
#endif
try {
using namespace Ogre;
log_manager = new LogManager();
#ifndef FREEORION_WIN32
log_manager->createLog((GetUserDir() / "ogre.log").string(), true, false);
root = new Root((GetRootDataDir() / "ogre_plugins.cfg").string());
// this line is needed on some Linux systems which otherwise will crash with
// errors about GLX_icon.png being missing.
Ogre::ResourceGroupManager::getSingleton().addResourceLocation((ClientUI::ArtDir() / ".").string(),
"FileSystem", "General");
#else
boost::filesystem::path::string_type file_native = (GetUserDir() / "ogre.log").native();
std::string ogre_log_file;
utf8::utf16to8(file_native.begin(), file_native.end(), std::back_inserter(ogre_log_file));
log_manager->createLog(ogre_log_file, true, false);
// for some reason, for this file, the built-in path conversion seems to work properly
std::string plugins_cfg_file = (GetRootDataDir() / "ogre_plugins.cfg").string();
root = new Root(plugins_cfg_file);
#endif
#if defined(OGRE_STATIC_LIB)
octree_plugin = new Ogre::OctreePlugin;
particle_fx_plugin = new Ogre::ParticleFXPlugin;
gl_plugin = new Ogre::GLPlugin;
root->installPlugin(octree_plugin);
root->installPlugin(particle_fx_plugin);
root->installPlugin(gl_plugin);
#endif
RenderSystem* selected_render_system = root->getRenderSystemByName("OpenGL Rendering Subsystem");
if (!selected_render_system)
throw std::runtime_error("Failed to find an Ogre GL render system.");
root->setRenderSystem(selected_render_system);
int colour_depth = GetOptionsDB().Get<int>("color-depth");
bool fullscreen = GetOptionsDB().Get<bool>("fullscreen");
std::pair<int, int> width_height = HumanClientApp::GetWindowWidthHeight(selected_render_system);
int width(width_height.first), height(width_height.second);
std::pair<int, int> left_top = HumanClientApp::GetWindowLeftTop();
int left(left_top.first), top(left_top.second);
root->initialise(false);
Ogre::NameValuePairList misc_window_params;
misc_window_params["title"] = "FreeOrion " + FreeOrionVersionString();
misc_window_params["colourDepth"] = boost::lexical_cast<std::string>(colour_depth);
misc_window_params["left"] = boost::lexical_cast<std::string>(left);
misc_window_params["top"] = boost::lexical_cast<std::string>(top);
misc_window_params["macAPI"] = "carbon";
misc_window_params["border"] = "resize";
if (fullscreen)
misc_window_params["monitorIndex"] = boost::lexical_cast<std::string>(
GetOptionsDB().Get<int>("fullscreen-monitor-id"));
RenderWindow* window = root->createRenderWindow("FreeOrion " + FreeOrionVersionString(),
width, height, fullscreen, &misc_window_params);
#ifdef FREEORION_WIN32
# ifdef IDI_ICON1
// set window icon to embedded application icon
HWND hwnd;
window->getCustomAttribute("WINDOW", &hwnd);
HINSTANCE hInst = (HINSTANCE)GetModuleHandle(NULL);
SetClassLong (hwnd, GCL_HICON,
(LONG)LoadIcon (hInst, MAKEINTRESOURCE (IDI_ICON1)));
# endif
#endif
SceneManager* scene_manager = root->createSceneManager("OctreeSceneManager", "SceneMgr");
Camera* camera = scene_manager->createCamera("Camera");
camera->setPosition(Vector3(0, 0, 500)); // Position it at 500 in Z direction
camera->lookAt(Vector3(0, 0, -300)); // Look back along -Z
camera->setNearClipDistance(5);
Viewport* viewport = window->addViewport(camera);
viewport->setBackgroundColour(ColourValue(0, 0, 0));
//EntityRenderer entity_renderer(scene_manager);
parse::init();
HumanClientApp app(root, window, scene_manager, camera, viewport, GetRootDataDir() / "OISInput.cfg");
ois_input_plugin = new OISInput;
ois_input_plugin->SetRenderWindow(window);
root->installPlugin(ois_input_plugin);
if (GetOptionsDB().Get<bool>("quickstart")) {
// immediately start the server, establish network connections, and
// go into a single player game, using default universe options (a
// standard quickstart, without requiring the user to click the
// quickstart button).
app.NewSinglePlayerGame(true); // acceptable to call before app()
}
std::string load_filename = GetOptionsDB().Get<std::string>("load");
if (!load_filename.empty()) {
// immediately start the server, establish network connections, and
// go into a single player game, loading the indicated file
// (without requiring the user to click the load button).
app.LoadSinglePlayerGame(load_filename); // acceptable to call before app()
}
// run rendering loop
app(); // calls GUI::operator() which calls OgreGUI::Run() which starts rendering loop
} catch (const HumanClientApp::CleanQuit&) {
// do nothing
std::cout << "mainSetupAndRunOgre caught CleanQuit" << std::endl;
} catch (const std::invalid_argument& e) {
Logger().errorStream() << "main() caught exception(std::invalid_argument): " << e.what();
std::cerr << "main() caught exception(std::invalid_arg): " << e.what() << std::endl;
} catch (const std::runtime_error& e) {
Logger().errorStream() << "main() caught exception(std::runtime_error): " << e.what();
std::cerr << "main() caught exception(std::runtime_error): " << e.what() << std::endl;
} catch (const boost::io::format_error& e) {
Logger().errorStream() << "main() caught exception(boost::io::format_error): " << e.what();
std::cerr << "main() caught exception(boost::io::format_error): " << e.what() << std::endl;
} catch (const GG::ExceptionBase& e) {
Logger().errorStream() << "main() caught exception(" << e.type() << "): " << e.what();
std::cerr << "main() caught exception(" << e.type() << "): " << e.what() << std::endl;
} catch (const std::exception& e) {
Logger().errorStream() << "main() caught exception(std::exception): " << e.what();
std::cerr << "main() caught exception(std::exception): " << e.what() << std::endl;
} catch (...) {
Logger().errorStream() << "main() caught unknown exception.";
std::cerr << "main() caught unknown exception." << std::endl;
}
if (root) {
root->uninstallPlugin(ois_input_plugin);
delete ois_input_plugin;
#ifdef OGRE_STATIC_LIB
root->uninstallPlugin(octree_plugin);
root->uninstallPlugin(particle_fx_plugin);
root->uninstallPlugin(gl_plugin);
delete octree_plugin;
delete particle_fx_plugin;
delete gl_plugin;
#endif
delete root;
}
if (log_manager)
delete log_manager;
return 0;
}
