bool CServer::configureOgre(bool force)
{
//////////////////
// OGRE //
//////////////////
// Carga los ajustes de configudación desde ogre.cfg
if(force || !_root->restoreConfig()) {
//// Si no hay archivo de configuración se lanza la ventana de configuración
//if(!_root->showConfigDialog()) {
// // Si el juego no se puede configurar se finaliza
// return false;
//}
///seteamos la resolucion y el rendersystem a mano
Ogre::RenderSystemList rs = _root->getAvailableRenderers();
Ogre::RenderSystemList::iterator it = rs.begin();
for(; it != rs.end(); ++it)
{
if((*it)->getName() == "Direct3D9 Rendering Subsystem")
{
_root->setRenderSystem((*it));
(*it)->setConfigOption("Full Screen","No");
(*it)->setConfigOption("Video Mode","1280 x 720 @ 32-bit colour");
}
}
}
return true;
} // configure
GraphicsOgre::GraphicsOgre(const Options *config):
ogre_{new Ogre::Root("", "")},
window_{nullptr}
{
LOG(INFO) << "Initializing Ogre";
//use OpenGL
const std::string pluginsFolder = config->getValue<std::string>("ogrePluginsFolder");
ogre_->loadPlugin(pluginsFolder + "RenderSystem_GL");
const Ogre::RenderSystemList renderList = ogre_->getAvailableRenderers();
Ogre::RenderSystemList::const_iterator r_it;
r_it = renderList.begin();
ogre_->setRenderSystem(*r_it);
ogre_->initialise(false);
//create manualy the window
Ogre::NameValuePairList opts;
opts.insert(Ogre::NameValuePairList::value_type("vsync", "false"));
opts.insert(Ogre::NameValuePairList::value_type("top", "10"));
opts.insert(Ogre::NameValuePairList::value_type("left", "10"));
window_ = ogre_->createRenderWindow(
config->getValue<std::string>("appname"),
config->getValue<int>("width"),
config->getValue<int>("height"),
config->getValue<bool>("fullscreen"),
&opts);
//initialize ressources
defineRessources();
Ogre::ResourceGroupManager::getSingleton().loadResourceGroup("General");
}
/**
* @brief init the object
* @author kito berg-taylor
*/
void OgreWidget::init()
{
// create the main ogre object
mOgreRoot = new Ogre::Root;
mOgreRoot->loadPlugin("RenderSystem_GL");
Ogre::String rName("OpenGL Rendering Subsystem");
Ogre::RenderSystemList rList = mOgreRoot->getAvailableRenderers();
Ogre::RenderSystemList::iterator it = rList.begin();
Ogre::RenderSystem *rSys = 0;
while(it != rList.end())
{
rSys = * (it++);
Ogre::String strx=rSys->getName();
if(strx == rName)
{
mOgreRoot->setRenderSystem(rSys);
break;
}
}
QString dimensions = QString( "%1x%2" )
.arg(this->width())
.arg(this->height());
rSys->setConfigOption( "Video Mode", dimensions.toStdString() );
// initialize without creating window
mOgreRoot->getRenderSystem()->setConfigOption( "Full Screen", "No" );
mOgreRoot->saveConfig();
mOgreRoot->initialise(false); // don't create a window
}
void OgreMinimalSetup::debugRenderList(const Ogre::RenderSystemList& rsl)
{
assert(rsl.size() && "RenderSystemList size is 0");
cout << "RenderSystemList size is " << rsl.size() << endl;
Ogre::RenderSystem* rs = rsl[0];
assert(rs && "First RenderSystem is NULL");
cout << "First RenderSystem name is '" << rs->getName() << "'" << endl;
}
void OgreWidget::init( std::string plugins_file, std::string ogre_cfg_file, std::string ogre_log )
{
mOgreRoot = new Ogre::Root( plugins_file, ogre_cfg_file, ogre_log );
Ogre::RenderSystemList renderers = mOgreRoot->getAvailableRenderers();
assert( !renderers.empty() );
Ogre::RenderSystem *renderSystem = chooseRenderer(& renderers );
assert( renderSystem );
mOgreRoot->setRenderSystem( renderSystem );
QString dimensions = QString( "%1x%2" ).arg(this->width()).arg(this->height());
renderSystem->setConfigOption( "Video Mode", dimensions.toStdString() );
mOgreRoot->getRenderSystem()->setConfigOption( "Full Screen", "No" );
mOgreRoot->saveConfig();
mOgreRoot->initialise(false);
initResourses();
}
//------------------------------------------------------------------------------
void wxOgreRenderSystem::SelectOgreRenderSystem(const Ogre::String& render)
{
Ogre::RenderSystemList renderList;
Ogre::RenderSystemList::iterator it;
renderList = m_root->getAvailableRenderers();
// check through all available renderers, if there is one the
// string is "render"
for (it = renderList.begin(); it != renderList.end(); ++it) {
Ogre::RenderSystem* renderSys = *it;
if (std::string (renderSys->getName()) == render) {
m_root->setRenderSystem(renderSys);
break;
}
}
}
void
dmz::RenderModuleCoreOgreBasic::_init_render_system (Config &local) {
if (_root) {
String renderSystemName (
config_to_string ("renderSystem.name", local, "OpenGL"));
Ogre::RenderSystem *renderSystem (0);
Ogre::RenderSystemList *renderSystemList = _root->getAvailableRenderers ();
if (renderSystemList) {
Ogre::RenderSystemList::iterator it = renderSystemList->begin ();
while (it != renderSystemList->end () && !renderSystem) {
if (renderSystemList->size () == 1) {
renderSystem = *it;
}
else {
Ogre::String curName ((*it)->getName ());
if (curName.find (renderSystemName.get_buffer ()) >= 0) {
renderSystem = *it;
}
}
it++;
}
}
if (renderSystem) {
_root->setRenderSystem (renderSystem);
_root->initialise (false); // don't autocreate a window
}
else {
_log.error
<< "Specified render system (" << renderSystemName << ") not found" << endl;
}
}
}
virtual void SetUp()
{
Ogre::LogManager* log_manager = new Ogre::LogManager();
log_manager->createLog( "Ogre.log", false, false, true );
g_root = new Ogre::Root();
g_root->loadPlugin( "RenderSystem_GL" );
g_root->loadPlugin( "Plugin_OctreeSceneManager" );
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// Taken from gazebo
Ogre::RenderSystemList *rsList = g_root->getAvailableRenderers();
Ogre::RenderSystem* render_system = NULL;
Ogre::RenderSystemList::iterator renderIt = rsList->begin();
Ogre::RenderSystemList::iterator renderEnd = rsList->end();
for ( ; renderIt != renderEnd; ++renderIt )
{
render_system = *renderIt;
if ( render_system->getName() == "OpenGL Rendering Subsystem" )
{
break;
}
}
if ( render_system == NULL )
{
printf( "Could not find the opengl rendering subsystem!\n" );
exit(1);
}
render_system->setConfigOption("Full Screen","No");
render_system->setConfigOption("FSAA","2");
render_system->setConfigOption("RTT Preferred Mode", "PBuffer");
g_root->setRenderSystem( render_system );
g_render_window = g_root->initialise( true );
g_scene_manager = g_root->createSceneManager( Ogre::ST_GENERIC, "TestSceneManager" );
g_viewport = g_render_window->addViewport( NULL );
g_root->renderOneFrame();
}
void OgreWidget::initialiseOgre(void)
{
Ogre::RenderSystem* Direct3D9RenderSystem = 0;
try
{
mRoot->loadPlugin("RenderSystem_Direct3D9");
}
catch (...)
{
qWarning("Failed to load Direct3D9 plugin");
}
Ogre::RenderSystemList list = Ogre::Root::getSingletonPtr()->getAvailableRenderers();
Ogre::RenderSystemList::iterator i = list.begin();
while (i != list.end())
{
if ((*i)->getName() == "Direct3D9 Rendering Subsystem")
{
Direct3D9RenderSystem = *i;
}
i++;
}
if (!Direct3D9RenderSystem)
{
qCritical("No rendering subsystems found");
exit(0);
}
if (Direct3D9RenderSystem != 0)
{
mActiveRenderSystem = Direct3D9RenderSystem;
}
Ogre::Root::getSingletonPtr()->setRenderSystem(mActiveRenderSystem);
Ogre::Root::getSingletonPtr()->initialise(false);
mRoot->addFrameListener(this);
}
bool GraphicsImpl::configure()
{
Dout <<"Setting Rendering Subsystem" ;
Ogre::RenderSystemList renderers = root->getAvailableRenderers();
if (renderers.empty()) {
Dout <<"No rendering system available" ;
return false;
}
root->setRenderSystem(renderers.front());
Dout <<"Init Root" ;
root->initialise(false);
Dout <<"Create window" ;
window = root->createRenderWindow("Manual Ogre Window", boost::any_cast<int>(SettingsManager::Instance().getSetting("x_res").data), boost::any_cast<int>(SettingsManager::Instance().getSetting("y_res").data), false, 0); // use defaults for all other values
return true;
}
void CLASS::UpdateControls()
{
int valuecounter = 0; // Going to be usefull for selections
//Lang (Still not done)
if (!IsLoaded)
{
m_lang->addItem("English (U.S.)");
}
m_lang->setIndexSelected(0); //TODO
if (!IsLoaded)
{
m_gearbox_mode->addItem("Automatic shift");
m_gearbox_mode->addItem("Manual shift - Auto clutch");
m_gearbox_mode->addItem("Fully Manual: sequential shift");
m_gearbox_mode->addItem("Fully Manual: stick shift");
m_gearbox_mode->addItem("Fully Manual: stick shift with ranges");
}
//Gearbox
Ogre::String gearbox_mode = GameSettingsMap["GearboxMode"];
if (gearbox_mode == "Manual shift - Auto clutch")
m_gearbox_mode->setIndexSelected(1);
else if (gearbox_mode == "Fully Manual: sequential shift")
m_gearbox_mode->setIndexSelected(2);
else if (gearbox_mode == "Fully Manual: stick shift")
m_gearbox_mode->setIndexSelected(3);
else if (gearbox_mode == "Fully Manual: stick shift with ranges")
m_gearbox_mode->setIndexSelected(4);
else
m_gearbox_mode->setIndexSelected(0);
Ogre::RenderSystem* rs = Ogre::Root::getSingleton().getRenderSystem();
// add all rendersystems to the list
if (m_render_sys->getItemCount() == 0)
{
const Ogre::RenderSystemList list = Application::GetOgreSubsystem()->GetOgreRoot()->getAvailableRenderers();
int selection = 0;
for (Ogre::RenderSystemList::const_iterator it = list.begin(); it != list.end(); it++, valuecounter++)
{
if (rs && rs->getName() == (*it)->getName())
{
ExOgreSettingsMap["Render System"] = rs->getName();
selection = valuecounter;
}
else if (!rs) {
LOG("Error: No Ogre Render System found");
}
if (!IsLoaded)
{
m_render_sys->addItem(Ogre::String((*it)->getName()));
}
}
m_render_sys->setIndexSelected(selection);
}
Ogre::ConfigFile cfg;
cfg.load(SSETTING("ogre.cfg", "ogre.cfg"));
//Few GameSettingsMap
Ogre::String bFullScreen = cfg.getSetting("Full Screen", rs->getName());
if (bFullScreen == "Yes")
{
ExOgreSettingsMap["Full Screen"] = "Yes";
m_fullscreen->setStateCheck(true);
}
else
{
ExOgreSettingsMap["Full Screen"] = "No";
m_fullscreen->setStateCheck(false);
}
Ogre::String bVsync = cfg.getSetting("VSync", rs->getName());
if (bVsync == "Yes")
{
ExOgreSettingsMap["VSync"] = "Yes";
m_vsync->setStateCheck(true);
}
else
{
ExOgreSettingsMap["VSync"] = "No";
m_vsync->setStateCheck(false);
}
// store available rendering devices and available resolutions
Ogre::ConfigOptionMap& CurrentRendererOptions = rs->getConfigOptions();
Ogre::ConfigOptionMap::iterator configItr = CurrentRendererOptions.begin();
Ogre::StringVector mFoundResolutions;
Ogre::StringVector mFoundFSAA;
while (configItr != CurrentRendererOptions.end())
{
if ((configItr)->first == "Video Mode")
{
// Store Available Resolutions
mFoundResolutions = ((configItr)->second.possibleValues);
}
if ((configItr)->first == "FSAA")
{
// Store Available Resolutions
mFoundFSAA = ((configItr)->second.possibleValues);
}
configItr++;
}
//Loop thru the vector for the resolutions
valuecounter = 0; //Back to default
Ogre::StringVector::iterator iterRes = mFoundResolutions.begin();
for (; iterRes != mFoundResolutions.end(); iterRes++)
{
if (!IsLoaded)
{
m_resolution->addItem(Ogre::String((iterRes)->c_str()));
}
if ((iterRes)->c_str() == cfg.getSetting("Video Mode", rs->getName()))
{
ExOgreSettingsMap["Video Mode"] = (iterRes)->c_str();
m_resolution->setIndexSelected(valuecounter);
}
valuecounter++;
}
//Loop thru the vector for the FSAAs
valuecounter = 0; //Back to default
Ogre::StringVector::iterator iterFSAA = mFoundFSAA.begin();
for (; iterFSAA != mFoundFSAA.end(); iterFSAA++)
{
if (!IsLoaded)
{
m_fsaa->addItem(Ogre::String((iterFSAA)->c_str()));
}
if ((iterFSAA)->c_str() == cfg.getSetting("FSAA", rs->getName()))
{
ExOgreSettingsMap["FSAA"] = (iterFSAA)->c_str();
m_fsaa->setIndexSelected(valuecounter);
}
valuecounter++;
}
//Few GameSettingsMap
if (GameSettingsMap["ArcadeControls"] == "Yes")
m_arc_mode->setStateCheck(true);
else
m_arc_mode->setStateCheck(false);
if (GameSettingsMap["External Camera Mode"] == "Static")
m_d_cam_pitch->setStateCheck(true);
else
m_d_cam_pitch->setStateCheck(false);
if (GameSettingsMap["Creak Sound"] == "No")
m_d_creak_sound->setStateCheck(true);
else
m_d_creak_sound->setStateCheck(false);
//Fov
m_fovexternal->setCaption(GameSettingsMap["FOV External"]);
m_fovinternal->setCaption(GameSettingsMap["FOV Internal"]);
//Texture Filtering
Ogre::String texfilter = GameSettingsMap["Texture Filtering"];
if (texfilter == "Bilinear")
m_tex_filter->setIndexSelected(1);
else if (texfilter == "Trilinear")
m_tex_filter->setIndexSelected(2);
else if (texfilter == "Anisotropic (best looking)")
m_tex_filter->setIndexSelected(3);
else
m_tex_filter->setIndexSelected(0);
if (!IsLoaded)
{
m_water_type->addItem("Hydrax"); //It's working good enough to be here now.
}
if (BSETTING("DevMode", false) && !IsLoaded)
{
//Things that aren't ready to be used yet.
m_sky_type->addItem("SkyX (best looking, slower)");
m_shadow_type->addItem("Parallel-split Shadow Maps");
}
//Sky effects
Ogre::String skytype = GameSettingsMap["Sky effects"];
if (skytype == "Caelum (best looking, slower)")
m_sky_type->setIndexSelected(1);
else if (skytype == "SkyX (best looking, slower)" && BSETTING("DevMode", false))
m_sky_type->setIndexSelected(2);
else
m_sky_type->setIndexSelected(0);
//Shadow technique
Ogre::String shadowtype = GameSettingsMap["Shadow technique"];
if (shadowtype == "Texture shadows")
m_shadow_type->setIndexSelected(1);
else if (shadowtype == "Stencil shadows (best looking)")
m_shadow_type->setIndexSelected(2);
else if (shadowtype == "Parallel-split Shadow Maps" && BSETTING("DevMode", false))
m_shadow_type->setIndexSelected(3);
else
m_shadow_type->setIndexSelected(0);
//Water effects
Ogre::String watertype = GameSettingsMap["Water effects"];
if (watertype == "Reflection")
m_water_type->setIndexSelected(1);
else if (watertype == "Reflection + refraction (speed optimized)")
m_water_type->setIndexSelected(2);
else if (watertype == "Reflection + refraction (quality optimized)")
m_water_type->setIndexSelected(3);
else if (watertype == "Hydrax")
m_water_type->setIndexSelected(4);
else
m_water_type->setIndexSelected(0);
//Vegetation
Ogre::String vegetationtype = GameSettingsMap["Vegetation"];
if (vegetationtype == "20%")
m_vegetation->setIndexSelected(1);
else if (vegetationtype == "50%")
m_vegetation->setIndexSelected(2);
else if (vegetationtype == "Full (best looking, slower)")
m_vegetation->setIndexSelected(3);
else
m_vegetation->setIndexSelected(0);
//Light source effects
Ogre::String lightstype = GameSettingsMap["Lights"];
if (lightstype == "Only current vehicle, main lights")
m_light_source_effects->setIndexSelected(1);
else if (lightstype == "All vehicles, main lights")
m_light_source_effects->setIndexSelected(2);
else if (lightstype == "All vehicles, all lights")
m_light_source_effects->setIndexSelected(3);
else
m_light_source_effects->setIndexSelected(0);
//Speed until selection
Ogre::String speedunit = GameSettingsMap["SpeedUnit"];
if (speedunit == "Metric")
m_speed_unit->setIndexSelected(1);
else
m_speed_unit->setIndexSelected(0);
//Other configs
if (GameSettingsMap["DigitalSpeedo"] == "Yes")
m_digital_speedo->setStateCheck(true);
else
m_digital_speedo->setStateCheck(false);
if (GameSettingsMap["Particles"] == "Yes")
m_psystem->setStateCheck(true);
else
m_psystem->setStateCheck(false);
if (GameSettingsMap["HeatHaze"] == "Yes")
m_heathaze->setStateCheck(true);
else
m_heathaze->setStateCheck(false);
if (GameSettingsMap["Mirrors"] == "Yes")
m_mirrors->setStateCheck(true);
else
m_mirrors->setStateCheck(false);
if (GameSettingsMap["Sunburn"] == "Yes")
m_sunburn->setStateCheck(true);
else
m_sunburn->setStateCheck(false);
if (GameSettingsMap["HDR"] == "Yes")
m_hdr->setStateCheck(true);
else
m_hdr->setStateCheck(false);
if (GameSettingsMap["Motion blur"] == "Yes")
m_mblur->setStateCheck(true);
else
m_mblur->setStateCheck(false);
if (GameSettingsMap["Skidmarks"] == "Yes")
m_skidmarks->setStateCheck(true);
else
m_skidmarks->setStateCheck(false);
if (GameSettingsMap["Envmap"] == "Yes")
m_hq_ref->setStateCheck(true);
else
m_hq_ref->setStateCheck(false);
if (GameSettingsMap["Glow"] == "Yes")
m_glow->setStateCheck(true);
else
m_glow->setStateCheck(false);
if (GameSettingsMap["DOF"] == "Yes")
m_dof->setStateCheck(true);
else
m_dof->setStateCheck(false);
if (GameSettingsMap["Waves"] == "Yes")
m_e_waves->setStateCheck(true);
else
m_e_waves->setStateCheck(false);
if (GameSettingsMap["Shadow optimizations"] == "Yes")
m_sh_pf_opti->setStateCheck(true);
else
m_sh_pf_opti->setStateCheck(false);
if (GameSettingsMap["AsynchronousPhysics"] == "Yes")
m_enable_async_physics->setStateCheck(true);
else
m_enable_async_physics->setStateCheck(false);
if (GameSettingsMap["DisableCollisions"] == "Yes")
m_disable_inter_collsion->setStateCheck(true);
else
m_disable_inter_collsion->setStateCheck(false);
if (GameSettingsMap["DisableSelfCollisions"] == "Yes")
m_disable_intra_collision->setStateCheck(true);
else
m_disable_intra_collision->setStateCheck(false);
if (GameSettingsMap["Multi-threading"] == "No")
m_disable_multithreading->setStateCheck(true);
else
m_disable_multithreading->setStateCheck(false);
//Volume slider
long sound_volume = Ogre::StringConverter::parseLong(GameSettingsMap["Sound Volume"], 100);
m_volume_slider->setScrollRange(101);
m_volume_slider->setScrollPosition(sound_volume -1);
if (m_volume_slider->getScrollPosition() >= 100)
m_volume_indicator->setCaption("100%");
else
m_volume_indicator->setCaption(Ogre::StringConverter::toString(sound_volume) + "%");
//Audio Devices
valuecounter = 0; //Back to default
char *devices = (char *)alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
while (devices && *devices != 0)
{
if (!IsLoaded)
{
m_audio_dev->addItem(Ogre::String(devices));
}
if (Ogre::String(devices) == GameSettingsMap["AudioDevice"])
m_audio_dev->setIndexSelected(valuecounter);
devices += strlen(devices) + 1; //next device
valuecounter++;
}
//FPS Limiter slider
long fps_limit = Ogre::StringConverter::parseLong(GameSettingsMap["FPS-Limiter"], 60);
m_fps_limiter_slider->setScrollRange(200);
m_fps_limiter_slider->setScrollPosition(fps_limit -1);
if (fps_limit >= 199)
m_fps_limiter_indicator->setCaption("Unlimited");
else
m_fps_limiter_indicator->setCaption(Ogre::StringConverter::toString(fps_limit) + " FPS");
//SightRange slider
long sight_range = Ogre::StringConverter::parseLong(GameSettingsMap["SightRange"], 5000);
m_sightrange->setScrollRange(5000);
m_sightrange->setScrollPosition(sight_range -1);
if (sight_range >= 4999)
m_sightrange_indicator->setCaption("Unlimited");
else
m_sightrange_indicator->setCaption(Ogre::StringConverter::toString(sight_range) + " m");
if (GameSettingsMap["Replay mode"] == "Yes")
m_enable_replay->setStateCheck(true);
else
m_enable_replay->setStateCheck(false);
if (GameSettingsMap["Screenshot Format"] == "png (bigger, no quality loss)")
m_hq_screenshots->setStateCheck(true);
else
m_hq_screenshots->setStateCheck(false);
if (GameSettingsMap["ChatAutoHide"] == "Yes")
m_autohide_chatbox->setStateCheck(true);
else
m_autohide_chatbox->setStateCheck(false);
}
/*!
* Initialize the application, in particular initialize OGRE and OIS
* (the input system, see \ref InputHandler).
*
* \return TRUE on success, otherwise FALSE. The application should be
* quit, if initializing failed.
*/
bool TestApp::initialize() {
if (mOgreRoot) {
// already initialized
return true;
}
Ogre::String pluginFileName = "plugins.cfg"; // don't use any plugin config file
// (we specify everything by code)
Ogre::String configFileName = "ogre.cfg"; // don't use any config file
// (we specify everything by code)
// AB: we create our own logmanager - ogre will use that one.
Ogre::String logFileName = "Ogre.log"; // AB: name to identify the log - won't necessarily write to a file!
mOgreLogManager = new Ogre::LogManager();
// create a default log that ogre itself is going to use.
bool suppressFileOutput = false;
bool outputToConsole = true;
Ogre::Log* log = mOgreLogManager->createLog(logFileName, true, outputToConsole, suppressFileOutput);
log->addListener(mMyOgreLogListener);
// AB: atm we don't specify the 3rd parameter and thus use the default Ogre
// log filename (Ogre.log in the current dir)
// we could just use "" to disable the logfile.
mOgreRoot = new Ogre::Root(pluginFileName, configFileName);
// we use OpenGL
//#if defined __APPLE__ || defined WIN32
// mOgreRoot->loadPlugin("RenderSystem_GL");
//#else
// mOgreRoot->loadPlugin(DCOLLIDE_OGRE_PLUGIN_DIR "/RenderSystem_GL");
//#endif
Ogre::RenderSystemList* renderSystemList = mOgreRoot->getAvailableRenderers();
if (renderSystemList->empty()) {
std::cerr << "Could not load any renderers?!" << std::endl;
return false;
}
Ogre::RenderSystem* renderSystem = renderSystemList->at(0);
mOgreRoot->setRenderSystem(renderSystem);
mOgreRoot->initialise(false);
// Create a window
int width = 1024;
int height = 768;
bool fullscreen = false;
mRenderWindow = mOgreRoot->createRenderWindow("d-collide test application", width, height, fullscreen);
if (!mUseGUI) {
mRenderWindow->setVisible(false);
}
mWindowEventListener = new MyWindowEventListener(mRenderWindow);
mOgreRoot->addResourceLocation("../resources/textures", "FileSystem", "DCollideMaterials");
mOgreRoot->addResourceLocation("../resources/models", "FileSystem", "DCollideModels");
// input
int windowHandle = 0;
mRenderWindow->getCustomAttribute("WINDOW", &windowHandle);
mInputHandler = new InputHandler(windowHandle);
mInputHandler->setTestApp(this);
mInputHandler->setWindowSize(width, height);
mWindowEventListener->setInputHandler(mInputHandler);
// GUI
mGui = new Gui(mOgreRoot, mRenderWindow);
mGui->setInputHandler(mInputHandler);
mGui->addFrameHistory(mFrameHistory, false);
mGui->addFrameHistory(mGraphicFrameHistory, true);
mGui->addFrameHistory(mSceneUpdateHistory, true);
mGui->addFrameHistory(mPhysicsStepHistory, true);
mGui->addFrameHistory(mCollisionFrameHistory, true);
if (!mGui->initialize()) {
std::cerr << "Could not initialize the GUI" << std::endl;
return false;
}
// our actual scene
changeCurrentScene("default");
if (!mScene) {
//error() << "NULL current scene: could not initialize default scene";
return false;
}
mInputHandler->initActions();
return true;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
#else
int main (int argc, char *argv[]) {
#endif
Ogre::Root *ogre;
Ogre::RenderWindow *window;
Ogre::SceneManager *sceneMgr;
Ogre::SceneManager *guiSceneMgr;
Ogre::Camera *camera;
Ogre::Camera *guiCamera;
// fire up an Ogre rendering window. Clearing the first two (of three) params will let us
// specify plugins and resources in code instead of via text file
ogre = new Ogre::Root("", "");
#if defined(_DEBUG)
ogre->loadPlugin("RenderSystem_GL_d");
#else
ogre->loadPlugin("RenderSystem_GL");
#endif
Ogre::RenderSystemList *renderSystems = NULL;
Ogre::RenderSystemList::iterator r_it;
renderSystems = ogre->getAvailableRenderers();
r_it = renderSystems->begin();
ogre->setRenderSystem(*r_it);
ogre->initialise(false);
// load common plugins
#if defined(_DEBUG)
//ogre->loadPlugin("Plugin_CgProgramManager_d");
ogre->loadPlugin("Plugin_OctreeSceneManager_d");
#else
//ogre->loadPlugin("Plugin_CgProgramManager");
ogre->loadPlugin("Plugin_OctreeSceneManager");
#endif
// load the basic resource location(s)
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("resource", "FileSystem", "General");
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("resource/gui.zip", "Zip", "GUI");
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("meshes", "FileSystem", "Meshes");
#if defined(WIN32)
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("c:\\windows\\fonts", "FileSystem", "GUI");
#endif
Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("General");
Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("GUI");
Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("Meshes");
// setup main window; hardcode some defaults for the sake of presentation
Ogre::NameValuePairList opts;
opts["resolution"] = "1024x768";
opts["fullscreen"] = "false";
opts["vsync"] = "false";
// create a rendering window with the title "CDK"
window = ogre->createRenderWindow("Bouwgame Client v0.1", 1024, 768, false, &opts);
// since this is basically a CEGUI app, we can use the ST_GENERIC scene manager for now; in a later article
// we'll see how to change this
sceneMgr = ogre->createSceneManager(Ogre::ST_GENERIC);
guiSceneMgr = ogre->createSceneManager(Ogre::ST_GENERIC);
guiCamera = guiSceneMgr->createCamera("GUICamera");
guiCamera->setNearClipDistance(5);
camera = sceneMgr->createCamera("camera");
camera->setNearClipDistance(5);
Ogre::Viewport* vp = window->addViewport(guiCamera);
vp->setBackgroundColour(Ogre::ColourValue(0.2f,0.2f,0.8f));
/* ambient light */
sceneMgr->setAmbientLight(Ogre::ColourValue(0.8, 0.8, 0.8));
sceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
/* meshes */
Ogre::Entity* ent = sceneMgr->createEntity( "BouwPlaatsEntity", "world.mesh" );
Ogre::SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode("BouwNode", Ogre::Vector3(0, 0, 0));
node->attachObject(ent);
//node->setScale(Ogre::Vector3(0.7,0.7,0.7));
ent = sceneMgr->createEntity("plaats", "bouwplaats_step_00.mesh");
Ogre::Vector3 size = ent->getBoundingBox().getSize();
Ogre::LogManager::getSingletonPtr()->getDefaultLog()->logMessage(Ogre::String("Bouwplaats size: ") + Ogre::StringConverter::toString(size));
size = ent->getBoundingBox().getMaximum();
Ogre::LogManager::getSingletonPtr()->getDefaultLog()->logMessage(Ogre::String("Bouwplaats max: ") + Ogre::StringConverter::toString(size));
size = ent->getBoundingBox().getMinimum();
Ogre::LogManager::getSingletonPtr()->getDefaultLog()->logMessage(Ogre::String("Bouwplaats min: ") + Ogre::StringConverter::toString(size));
Ogre::Entity* ent1 = sceneMgr->createEntity( "KeetEntity", "keet.mesh" );
Ogre::SceneNode* scenenode = sceneMgr->getRootSceneNode()->createChildSceneNode("KeetNode", Ogre::Vector3(0, 0, 0));
scenenode->attachObject(ent1);
Ogre::Entity* ent2 = sceneMgr->createEntity( "HekjeEntity", "hekje.mesh" );
Ogre::SceneNode* scenenode2 = sceneMgr->getRootSceneNode()->createChildSceneNode("HekjeNode", Ogre::Vector3(0, -100, 0));
scenenode2->attachObject(ent2);
scenenode2->setScale(Ogre::Vector3(400,0,100));
// most examples get the viewport size to calculate this; for now, we'll just
// set it to 4:3 the easy way
camera->setAspectRatio((Ogre::Real)1.333333);
camera->setPosition(Ogre::Vector3(40,100,10));
guiCamera->setPosition(0, 0, 300);
guiCamera->lookAt(node->getPosition());
// this next bit is for the sake of the input handler
unsigned long hWnd;
window->getCustomAttribute("WINDOW", &hWnd);
// set up the input handlers
Simulation *sim = new Simulation();
InputHandler *handler = new InputHandler(sim, hWnd, camera);
DataManager *dataManager = new DataManager();
GameAI* gameAI = new GameAI(dataManager);
//Create Network
Network * net = new Network(dataManager);
//net->start();
sim->requestStateChange(GUI);
gui = new GuiManager();
// networkshit
while(!net->isConnected())
{
Sleep(1000);
}
net->Send(GETGROUPS, "", "", NULL);
net->Send(LOGIN, "gast", "gast", 1);
gui->setSimulation(sim);
gui->init("", ogre, guiSceneMgr, window);
gui->activate("main");
handler->setWindowExtents(1024,768);
SimulationState cState;
Ogre::WindowEventUtilities::addWindowEventListener(window, handler);
DWORD tFrameStart = 0x0; //in miliseconds
signed long tFrameX = 0x0;
float tDelta2 = 0.0f; //in seconds
float m_fps = 60.0f;
tFrameStart = GetTickCount();
float tDelta;
//testAI->calculateNextPath(40,10);
while ((cState = sim->getCurrentState()) != SHUTDOWN) {
tFrameX = GetTickCount() - tFrameStart;
tDelta2 = (float)tFrameX / 1000.0f;
if (tDelta2 > 3600) // tDelta > 1 hour
tDelta2 = 1.0f / m_fps; //< System tick count has highly likely overflowed, so get approximation
tFrameStart = GetTickCount();
m_fps = (int)(1.0f / tDelta2);
tDelta = tDelta2;
handler->capture();
handler->update(tDelta);
gui->update(tDelta);
//if (sim->getCurrentState() == SIMULATION || sim->getCurrentState() == SIMULATION_MOUSELOOK)
// testAI->update(tDelta);
// run the message pump (Eihort)
Ogre::WindowEventUtilities::messagePump();
ogre->renderOneFrame();
if (sim->getCurrentState() != cState) {
handler->StateSwitched(cState, sim->getCurrentState());
switch (sim->getCurrentState()) {
case GUI:
window->getViewport(0)->setCamera(guiCamera);
break;
case SIMULATION:
window->getViewport(0)->setCamera(camera);
break;
}
}
}
// clean up after ourselves
//delete testAI;
delete sim;
delete ogre;
delete handler;
delete gameAI;
delete dataManager;
return 0;
}
bool GfxService::initialize(ParameterSet* var)
{
Ogre::String plug;
#ifdef _DEBUG
plug = "plugins_d.cfg";
#else
plug = "plugins.cfg";
#endif
mRoot = new Ogre::Root(plug,"","ogre.log");
Ogre::LogManager::getSingleton().getDefaultLog()->setLogDetail(Ogre::LL_LOW);
// Load resource paths from config file
Ogre::ConfigFile cf;
cf.load("resources.cfg");
// Go through all sections & settings in the file
Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
Ogre::String secName, typeName, archName;
while (seci.hasMoreElements())
{
secName = seci.peekNextKey();
Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
Ogre::ConfigFile::SettingsMultiMap::iterator i;
for (i = settings->begin(); i != settings->end(); ++i)
{
typeName = i->first;
archName = i->second;
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
archName, typeName, secName);
}
}
Ogre::RenderSystemList* renderSystems = mRoot->getAvailableRenderers();
mRenderSystem = *(renderSystems->begin());
mRoot->setRenderSystem(mRenderSystem);
mRenderSystem->setConfigOption("Full Screen", "No");
mRenderSystem->setConfigOption("VSync", "No");
std::stringstream strVideoMode;
strVideoMode << 1024 << " x " << 768 << " @ " << 32 << "-bit colour";
mRenderSystem->setConfigOption("Video Mode", strVideoMode.str());
mWindow = mRoot->initialise(true, "TankStory");
mSceneManager = mRoot->createSceneManager( Ogre::ST_INTERIOR, "scMa" );
mSceneManager->setAmbientLight( Ogre::ColourValue( 0.5, 0.5, 0.5) );
mCamera = mSceneManager->createCamera("Camera");
mCamera->setNearClipDistance( 1.0f );
mCamera->setFOVy(Ogre::Radian(Ogre::Degree(45)));
mCamera->setFarClipDistance( 10000.0f );
mCamera->setPosition(0,100,100);
mCamera->lookAt(0,0,0);
Ogre::Viewport* viewport = mWindow->addViewport(mCamera);
viewport->setBackgroundColour(Ogre::ColourValue(0.3f, 0.3f, 0.3f));
mCamera->setAspectRatio( Ogre::Real(viewport->getActualWidth()) / Ogre::Real(viewport->getActualHeight()) );
Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(1);
Ogre::MaterialManager::getSingleton().setDefaultTextureFiltering(Ogre::TFO_ANISOTROPIC);
Ogre::MaterialManager::getSingleton().setDefaultAnisotropy(8);
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);
unsigned long wnd;
mWindow->getCustomAttribute("WINDOW",&wnd);
var->AddInt("HWND",wnd);
var->AddInt("RenderWindow",(unsigned long)mWindow);
return true;
}
