/**
* @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;
}
virtual void registerHlms(void)
{
GraphicsSystem::registerHlms();
Ogre::ConfigFile cf;
cf.load(mResourcePath + "resources2.cfg");
Ogre::String dataFolder = cf.getSetting("DoNotUseAsResource", "Hlms", "");
if (dataFolder.empty())
dataFolder = "./";
else if (*(dataFolder.end() - 1) != '/')
dataFolder += "/";
Ogre::RenderSystem *renderSystem = mpRoot->getRenderSystem();
Ogre::String shaderSyntax = "GLSL";
if (renderSystem->getName() == "Direct3D11 Rendering Subsystem")
shaderSyntax = "HLSL";
Ogre::Archive *archiveLibrary = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Common/" + shaderSyntax,
"FileSystem", true);
Ogre::Archive *archiveLibraryAny = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Common/Any",
"FileSystem", true);
Ogre::Archive *archivePbsLibraryAny = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Pbs/Any",
"FileSystem", true);
Ogre::Archive *pbsLibrary = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Pbs/" + shaderSyntax,
"FileSystem", true);
Ogre::ArchiveVec library;
library.push_back(archiveLibrary);
library.push_back(archiveLibraryAny);
library.push_back(archivePbsLibraryAny);
library.push_back(pbsLibrary);
Ogre::Archive *archiveTerra = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Terra/" + shaderSyntax,
"FileSystem", true);
Ogre::HlmsTerra *hlmsTerra = OGRE_NEW Ogre::HlmsTerra(archiveTerra, &library);
Ogre::HlmsManager *hlmsManager = mpRoot->getHlmsManager();
hlmsManager->registerHlms(hlmsTerra);
//Add Terra's piece files that customize the PBS implementation.
//These pieces are coded so that they will be activated when
//we set the HlmsPbsTerraShadows listener and there's an active Terra
//(see Tutorial_TerrainGameState::createScene01)
Ogre::Hlms *hlmsPbs = hlmsManager->getHlms(Ogre::HLMS_PBS);
Ogre::Archive *archivePbs = hlmsPbs->getDataFolder();
Ogre::ArchiveVec libraryPbs = hlmsPbs->getPiecesLibraryAsArchiveVec();
libraryPbs.push_back(Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Terra/" + shaderSyntax + "/PbsTerraShadows",
"FileSystem", true));
hlmsPbs->reloadFrom(archivePbs, &libraryPbs);
}
void GameSettings::update()
{
Root* root = Ogre::Root::getSingletonPtr();
Ogre::RenderSystem* renderer = root->getRenderSystem();
#if OGRE_VERSION_MINOR == 7 || OGRE_VERSION_MINOR == 8
const RenderSystemList& renderers = root->getAvailableRenderers();
#else
const RenderSystemList renderers = *root->getAvailableRenderers();
#endif
createElements(mVideoRenderer, renderers.size());
for (unsigned int i = 0; i < renderers.size(); ++i)
{
Ogre::RenderSystem* cur = renderers[i];
ListboxItem* item = mVideoRenderer->getListboxItemFromIndex(i);
item->setText(cur->getName());
if (cur == renderer)
{
mVideoRenderer->setItemSelectState(item, true);
}
}
ConfigOptionMap config = renderer->getConfigOptions();
setOption(config, "Full Screen", mVideoFullscreen);
std::vector<RadioButton*> videoColorDepth;
videoColorDepth.push_back(mVideoColorDepth32);
videoColorDepth.push_back(mVideoColorDepth16);
setOption(config, "Colour Depth", videoColorDepth);
std::vector<RadioButton*> videoAntiAliasing;
videoAntiAliasing.push_back(mVideoFsaa0);
videoAntiAliasing.push_back(mVideoFsaa2);
videoAntiAliasing.push_back(mVideoFsaa4);
videoAntiAliasing.push_back(mVideoFsaa8);
setOption(config, "FSAA", videoAntiAliasing);
std::vector<RadioButton*> videoRttMode;
videoRttMode.push_back(mVideoRttModeFBO);
videoRttMode.push_back(mVideoRttModePBuffer);
videoRttMode.push_back(mVideoRttModeCopy);
setOption(config, "RTT Preferred Mode", videoRttMode);
setOption(config, "Video Mode", mVideoResolution);
}
//------------------------------------------------------------------------------
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 RenderSystem::setupRenderSystem()
{
Ogre::RenderSystem *renderSys;
const Ogre::RenderSystemList *rsList;
// Get the list of available renderers.
#if OGRE_VERSION_MAJOR == 1 && OGRE_VERSION_MINOR == 6
rsList = ogre_root_->getAvailableRenderers();
#else
rsList = &(ogre_root_->getAvailableRenderers());
#endif
// Look for the OpenGL one, which we require.
renderSys = NULL;
for( unsigned int i = 0; i < rsList->size(); i++ )
{
renderSys = rsList->at( i );
if( renderSys->getName().compare("OpenGL Rendering Subsystem")== 0 )
{
break;
}
}
if( renderSys == NULL )
{
throw std::runtime_error( "Could not find the opengl rendering subsystem!\n" );
}
// We operate in windowed mode
renderSys->setConfigOption("Full Screen","No");
/// We used to allow the user to set the RTT mode to PBuffer, FBO, or Copy.
/// Copy is slow, and there doesn't seem to be a good reason to use it
/// PBuffer limits the size of the renderable area of the RTT to the
/// size of the first window created.
/// FBO seem to be the only good option
// renderSys->setConfigOption("RTT Preferred Mode", "FBO");
// Set the Full Screen Anti-Aliasing factor.
renderSys->setConfigOption("FSAA", "2");
ogre_root_->setRenderSystem(renderSys);
}
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);
}
void MaterialEditorFrame::createOgrePane()
{
mRoot = new Ogre::Root();
// Find Render Systems
// Testing only, this will be deleted once Projects can tell us
// which rendering system they want used
mDirectXRenderSystem = NULL;
mOpenGLRenderSystem = NULL;
const RenderSystemList &rl = mRoot.getAvailableRenderers();
if (rl->empty())
{
wxMessageBox("No render systems found", "Error");
return;
}
for(RenderSystemList::const_iterator it = rl.begin(); it != rl.end(); ++it)
{
Ogre::RenderSystem *rs = (*it);
rs->setConfigOption("Full Screen", "No");
rs->setConfigOption("VSync", "No");
rs->setConfigOption("Video Mode", "512 x 512 @ 32-bit");
if(rs->getName() == "OpenGL Rendering Subsystem")
mOpenGLRenderSystem = *it;
else if(rs->getName() == "Direct3D9 Rendering Subsystem")
mDirectXRenderSystem = *it;
}
// We'll see if there is already and Ogre.cfg, if not we'll
// default to OpenGL since we know that will work on all
// platforms
if(!mRoot->restoreConfig())
{
mRoot->setRenderSystem(mOpenGLRenderSystem);
}
mOgreControl = new wxOgre(this);
ConfigFile cf;
cf.load("resources.cfg");
ConfigFile::SectionIterator seci = cf.getSectionIterator();
Ogre::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;
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(archName, typeName, secName);
}
}
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
wxString caption;
String rs = mRoot->getRenderSystem()->getName();
if(rs == "OpenGL Rendering Subsystem") caption = "OGRE - OpenGL";
else caption = "OGRE - DirectX";
wxAuiPaneInfo info;
info.Caption(caption);
info.MaximizeButton(true);
info.MinimizeButton(true);
info.Floatable(true);
info.BestSize(512, 512);
info.Left();
mAuiManager->AddPane(mOgreControl, info);
}
/****************************************************************************
**
** Copyright (C) 2016 - 2017
**
** This file is generated by the Magus toolkit
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE go (ODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
****************************************************************************/
#include "ogre3_renderman.h"
#include "OgreConfigFile.h"
#include "OgreArchiveManager.h"
#include "OgreHlms.h"
#include "OgreHlmsUnlit.h"
#include "OgreHlmsPbs.h"
#include "OgreHlmsManager.h"
#include "OgreHlmsCommon.h"
#include "OgreLogManager.h"
#include "OgreFrameStats.h"
namespace Magus
{
//****************************************************************************/
OgreManager::OgreManager(void)
{
mGlContext = 0;
mCompositorPassProvider = 0;
mPause = true;
#if _DEBUG || DEBUG
mResourcesCfg = "resources_d.cfg";
mPluginsCfg = "plugins_d.cfg";
#else
mResourcesCfg = "resources.cfg";
mPluginsCfg = "plugins.cfg";
#endif
// Create Ogre tt and initialize
mRoot = new Ogre::Root(mPluginsCfg);
// Setup renderer
mCurrentRenderSystem = 0;
const Ogre::RenderSystemList& rsList = mRoot->getAvailableRenderers();
Ogre::RenderSystem* renderSystem = rsList[0];
std::vector<Ogre::String> renderOrder;
#if defined(Q_OS_WIN)
renderOrder.push_back("Direct3D11");
#endif
renderOrder.push_back("OpenGL 3+");
for (std::vector<Ogre::String>::iterator iter = renderOrder.begin(); iter != renderOrder.end(); iter++)
{
for (Ogre::RenderSystemList::const_iterator it = rsList.begin(); it != rsList.end(); it++)
{
if ((*it)->getName().find(*iter) != Ogre::String::npos)
{
renderSystem = *it;
break;
}
}
if (renderSystem != 0) break;
}
if (renderSystem == 0)
{
if (!mRoot->restoreConfig())
{
if (!mRoot->showConfigDialog())
OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Abort render system configuration", "OgreManager::OgreManager");
}
}
renderSystem->setConfigOption("Full Screen", "No");
renderSystem->setConfigOption("VSync", "Yes");
mRoot->setRenderSystem(renderSystem);
mCurrentRenderSystem = renderSystem;
// Uncomment next line to show dialog
//if(mRoot->restoreConfig() || mRoot->showConfigDialog())
//{
mRoot->initialise(false);
//}
// Initialize resources
setupResources();
// Start timer
mTimer = new Ogre::Timer();
mTimer->reset();
}
//****************************************************************************/
OgreManager::~OgreManager(void)
{
// Added removeAllWorkspaces after Ogre 2.1 upgrade (commit 2783a361c0b8)
// In debug mode, the application crashed in deleting mRoot
Ogre::CompositorManager2* compositorManager = mRoot->getCompositorManager2();
compositorManager->removeAllWorkspaces();
// Delete the dummy CompositorPassProvider
compositorManager->setCompositorPassProvider(0);
OGRE_DELETE mCompositorPassProvider;
// Destroy render textures
// This is a piece of custom code specific for the HLMS Editor (assume that the OgreWidget is still available)
QMap<int, QOgreWidget*>::iterator i;
QOgreWidget* item = 0;
for (i = mQOgreWidgetMap.begin(); i != mQOgreWidgetMap.end(); ++i)
{
item = i.value();
item->cleanup();
}
// Delete Ogre root
delete mRoot;
}
//-------------------------------------------------------------------------------------
void OgreManager::initialize(void)
{
// Create dummy CompositorPassProvider (see http://www.ogre3d.org/forums/viewtopic.php?f=11&t=84816&p=525752&hilit=CompositorPassProvider#p525752)
// If one of the resource locations contains a compositor with a custom pass, the editor doesn't work anymore. This is to prevent it
Ogre::MyCompositorPassProvider* mCompositorPassProvider = OGRE_NEW Ogre::MyCompositorPassProvider;
Ogre::CompositorManager2* compositorManager = mRoot->getCompositorManager2();
compositorManager->setCompositorPassProvider(mCompositorPassProvider);
// After resources have been setup and renderwindows created (in ogre widget), the Hlms managers are registered
registerHlms();
// Initialise, parse scripts etc
try
{
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups(false);
}
catch (Ogre::Exception e){}
mPause = false;
try
{
mRoot->renderOneFrame(); // Render first
}
catch (Ogre::Exception e) {}
}
//-------------------------------------------------------------------------------------
void OgreManager::setupResources(void)
{
// Load resource paths from config file
Ogre::ConfigFile cf;
cf.load(mResourcesCfg);
// 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();
if( secName != "Hlms" )
{
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 );
}
}
}
}
//****************************************************************************/
bool OgreManager::isRenderSystemGL(void)
{
if (mCurrentRenderSystem)
return (mCurrentRenderSystem->getName() == OGRE_RENDERSYSTEM_OPENGL3PLUS);
return false;
}
//****************************************************************************/
GL_CONTEXT OgreManager::getGlContext(void) const
{
return mGlContext;
}
//****************************************************************************/
void OgreManager::setGlContext(GL_CONTEXT glContext)
{
mGlContext = glContext;
}
//****************************************************************************/
void OgreManager::registerHlms(void)
{
Ogre::ConfigFile cf;
cf.load(mResourcesCfg);
Ogre::String dataFolder = cf.getSetting( "DoNotUseAsResource", "Hlms", "" );
if( dataFolder.empty() )
dataFolder = "./";
else if( *(dataFolder.end() - 1) != '/' )
dataFolder += "/";
Ogre::RenderSystem* renderSystem = mRoot->getRenderSystem();
Ogre::String shaderSyntax = "GLSL";
if( renderSystem->getName() == OGRE_RENDERSYSTEM_DIRECTX11 )
shaderSyntax = "HLSL";
else if( renderSystem->getName() == OGRE_RENDERSYSTEM_METAL )
shaderSyntax = "Metal";
Ogre::Archive* archiveLibrary = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Common/" + shaderSyntax,
"FileSystem", true );
Ogre::Archive* archiveLibraryAny = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Common/Any",
"FileSystem", true );
Ogre::Archive* archivePbsLibraryAny = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Pbs/Any",
"FileSystem", true );
Ogre::Archive* archiveUnlitLibraryAny = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Unlit/Any",
"FileSystem", true );
Ogre::ArchiveVec library;
library.push_back( archiveLibrary );
library.push_back( archiveLibraryAny );
Ogre::Archive* archiveUnlit = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Unlit/" + shaderSyntax,
"FileSystem", true );
library.push_back( archiveUnlitLibraryAny );
Ogre::HlmsUnlit* hlmsUnlit = OGRE_NEW Ogre::HlmsUnlit( archiveUnlit, &library );
mRoot->getHlmsManager()->registerHlms( hlmsUnlit );
library.pop_back();
Ogre::Archive* archivePbs = Ogre::ArchiveManager::getSingletonPtr()->load(
dataFolder + "Hlms/Pbs/" + shaderSyntax,
"FileSystem", true );
library.push_back( archivePbsLibraryAny );
Ogre::HlmsPbs* hlmsPbs = OGRE_NEW Ogre::HlmsPbs( archivePbs, &library );
mRoot->getHlmsManager()->registerHlms( hlmsPbs );
library.pop_back();
if( renderSystem->getName() == "Direct3D11 Rendering Subsystem" )
{
//Set lower limits 512kb instead of the default 4MB per Hlms in D3D 11.0
//and below to avoid saturating AMD's discard limit (8MB) or
//saturate the PCIE bus in some low end machines.
bool supportsNoOverwriteOnTextureBuffers;
renderSystem->getCustomAttribute( "MapNoOverwriteOnDynamicBufferSRV",
&supportsNoOverwriteOnTextureBuffers );
if( !supportsNoOverwriteOnTextureBuffers )
{
hlmsPbs->setTextureBufferDefaultSize( 512 * 1024 );
hlmsUnlit->setTextureBufferDefaultSize( 512 * 1024 );
}
}
}
void QOgreWindow::initialize()
{
// Initialize Ogre like normal
#ifdef _MSC_VER
oRoot = new Ogre::Root(Ogre::String("plugins" OGRE_BUILD_SUFFIX ".cfg"));
#else
oRoot = new Ogre::Root(Ogre::String("plugins.cfg"));
#endif
Ogre::ConfigFile oConf;
oConf.load(resConfig);
Ogre::ConfigFile::SectionIterator seci = oConf.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::String name, locType;
Ogre::ConfigFile::SectionIterator secIt = oConf.getSectionIterator();
while(secIt.hasMoreElements())
{
Ogre::ConfigFile::SettingsMultiMap* _settings = secIt.getNext();
Ogre::ConfigFile::SettingsMultiMap::iterator it;
for (it = _settings->begin(); it != _settings->end(); ++it)
{
locType = it->first;
name = it->second;
}
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(name,locType);
}*/
//if (!oRoot->restoreConfig() || oRoot->showConfigDialog()) return;
const Ogre::RenderSystemList& rsList = oRoot->getAvailableRenderers();
Ogre::RenderSystem* rs = rsList[0];
// This list setup search order for used render system
Ogre::StringVector renderOrder;
renderOrder.push_back("OpenGL");
#if PONY_PLATFORM == PLAT_WIN32 || PONY_PLATFORM == PLAT_WIN64
renderOrder.push_back("Direct3D9");
renderOrder.push_back("Direct3D11");
#endif
//renderOrder.push_back("OpenGL 3+");
for (Ogre::StringVector::iterator iter = renderOrder.begin(); iter != renderOrder.end(); iter++)
{
for (Ogre::RenderSystemList::const_iterator it = rsList.begin(); it != rsList.end(); it++)
{
if ((*it)->getName().find(*iter) != Ogre::String::npos)
{
rs = *it;
break;
}
}
if (rs != NULL) break;
}
if (rs == NULL)
{
if (!oRoot->restoreConfig())
{
if (!oRoot->showConfigDialog())
{
OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "[PoneNgine][Ogre3D] Abort render system configuration.","QOgreWindow::initialize");
}
}
}
// Settings size on windows will solve a lot of problems
// VSync... why is this praised by developers again? Becuase I hate it in games.
// Soon, I'll make a settings class for the in-game settings.
QString dimensions = QString("%1 x %2").arg(this->width()).arg(this->height());
rs->setConfigOption("Video Mode", dimensions.toStdString());
rs->setConfigOption("Full Screen", "No");
rs->setConfigOption("VSync", "No");
oRoot->setRenderSystem(rs);
oRoot->initialise(false);
Ogre::NameValuePairList parameters;
if (rs->getName().find("GL") <= rs->getName().size())
parameters["currentGLContext"] = Ogre::String("false");
#if PONY_PLATFORM == PLAT_WIN32 || PONY_PLATFORM == PLAT_WIN64 || PONY_PLATFORM == PLAT_MACOSX
parameters["externalWindowHandle"] = Ogre::StringConverter::toString((size_t)(this->winId()));
parameters["parentWindowHandle"] = Ogre::StringConverter::toString((size_t)(this->winId()));
#else
parameters["externalWindowHandle"] = Ogre::StringConverter::toString((unsigned long)(this->winId()));
parameters["parentWindowHandle"] = Ogre::StringConverter::toString((unsigned long)(this->winId()));
#endif
#if PONY_PLATFORM == PLAT_MACOSX
parameters["macAPI"] = "cocoa";
parameters["macAPICocoaUseNSView"] = "true";
#endif
oWin = oRoot->createRenderWindow("QOgreWindow Test | PoneNgine Version "+Ogre::String(PONENGINE_VERSION)+" Build "+Ogre::String(PONENGINE_BUILD), this->width(), this->height(), false, ¶meters);
oWin->setVisible(true);
Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
#if OGRE_VERSION >= ((2 << 16) | (0 << 8) | 0)
const size_t numThreads = std::max<int>(1, Ogre::PlatformInformation::getNumLogicalCores());
Ogre::InstancingTheadedCullingMethod threadedCullingMethod = Ogre::INSTANCING_CULLING_SINGLETHREAD;
if (numThreads > 1)threadedCullingMethod = Ogre::INSTANCING_CULLING_THREADED;
oSceneMgr = oRoot->createSceneManager(Ogre::ST_GENERIC, numThreads, threadedCullingMethod);
#else
oSceneMgr = oRoot->createSceneManager(Ogre::ST_GENERIC);
#endif
oCam = oSceneMgr->createCamera("MainCamera");
oCam->setPosition(Ogre::Vector3(0.0f,0.0f,10.0f));
oCam->lookAt(Ogre::Vector3(0.0f,0.0f,-300.0f));
oCam->setNearClipDistance(0.1f);
oCam->setFarClipDistance(200.0f);
camMan = new OgreQtBites::QtOgreSdkCameraMan(oCam);
#if OGRE_VERSION >= ((2 << 16) | (0 << 8) | 0)
createCompositor();
#else
Ogre::Viewport* oViewPort = oWin->addViewport(oCam);
oViewPort->setBackgroundColour(oBgColor);
#endif
oCam->setAspectRatio(Ogre::Real(oWin->getWidth()) / Ogre::Real(oWin->getHeight()));
oCam->setAutoAspectRatio(true);
createScene();
oRoot->addFrameListener(this);
}
bool GameManager::configure(void)
{
//// load config settings from ogre.cfg
//if (!mRoot->restoreConfig())
//{
// // if there is no config file, show the configuration dialog
// if (!mRoot->showConfigDialog())
// {
// return false;
// }
//}
//// initialise and create a default rendering window
//mRenderWindow = mRoot->initialise(true);
//ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// -- NEW --
// A list of required plugins
Ogre::StringVector required_plugins;
required_plugins.push_back("GL RenderSystem");
// required_plugins.push_back("Octree & Terrain Scene Manager");
// List of plugins to load
Ogre::StringVector plugins_toLoad;
plugins_toLoad.push_back("RenderSystem_GL");
//plugins_toLoad.push_back("Plugin_OctreeSceneManager");
// Load the OpenGL RenderSystem and the Octree SceneManager plugins
for (Ogre::StringVector::iterator j = plugins_toLoad.begin(); j != plugins_toLoad.end(); j++)
{
#ifdef _DEBUG
mRoot->loadPlugin(*j + Ogre::String("_d"));
#else
mRoot->loadPlugin(*j);
#endif;
}
// Check if the required plugins are installed and ready for use
// If not: exit the application
Ogre::Root::PluginInstanceList ip = mRoot->getInstalledPlugins();
for (Ogre::StringVector::iterator j = required_plugins.begin(); j != required_plugins.end(); j++)
{
bool found = false;
// try to find the required plugin in the current installed plugins
for (Ogre::Root::PluginInstanceList::iterator k = ip.begin(); k != ip.end(); k++) {
if ((*k)->getName() == *j) {
found = true;
break;
}
}
if (!found) // return false because a required plugin is not available
{
return false;
}
}
////-------------------------------------------------------------------------------------
// // setup resources
// // Only add the minimally required resource locations to load up the Ogre head mesh
// Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../../media/materials/programs", "FileSystem", "General");
// Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../../media/materials/scripts", "FileSystem", "General");
// Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../../media/materials/textures", "FileSystem", "General");
// Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../../media/models", "FileSystem", "General");
//
//-------------------------------------------------------------------------------------
// configure
// Grab the OpenGL RenderSystem, or exit
Ogre::RenderSystem* rs = mRoot->getRenderSystemByName("OpenGL Rendering Subsystem");
if(!(rs->getName() == "OpenGL Rendering Subsystem"))
{
return false; //No RenderSystem found
}
// configure our RenderSystem
rs->setConfigOption("Full Screen", "No");
rs->setConfigOption("VSync", "No");
rs->setConfigOption("Video Mode", "800 x 600 @ 32-bit");
mRoot->setRenderSystem(rs);
mRenderWindow = mRoot->initialise(true, "LowLevelOgre Render Window");
return true;
}
/*!
Initialisation of Ogre.
Load the plugins that are specified in the plugins.cfg or
plugins_d.cfg files. These files are located in
VISP_HAVE_OGRE_PLUGINS_PATH folder that is defined in vpConfig.h.
Note that plugins.cfg file is always considered under Unix
platforms. The file plugins_d.cfg is only considered under Windows
when the build type is Debug.
Load also the resources that are defined in the resources.cfg
file. This file is located in VISP_HAVE_OGRE_RESOURCES_PATH folder
that is defined in vpConfig.h.
\param bufferedKeys : If true, use of buffered input for the keyboard (see
Ogre documentation). Note that this parameter is only useful if OIS is used.
\param hidden : If true, the created window will be hidden.
Note that this functionnality requires Ogre3D 1.8.1 at least.
\exception vpException::ioError : If the required plugins.cfg /
plugins_d.cfg or resources.cfg files are not accessible.
*/
void vpAROgre::init(bool
#ifdef VISP_HAVE_OIS
bufferedKeys
#endif
,bool hidden
)
{
// Create the root
// mPluginsPath may contain more than one folder location separated by ";"
bool pluginsFileExists = false;
std::string pluginFile;
std::vector<std::string> plugingsPaths = vpIoTools::splitChain(std::string(mPluginsPath), std::string(";"));
for (size_t i=0; i<plugingsPaths.size(); i++) {
#if defined(NDEBUG) || !defined(_WIN32)
pluginFile = plugingsPaths[i]+"/plugins.cfg";
#else
pluginFile = plugingsPaths[i]+"/plugins_d.cfg";
#endif
if(vpIoTools::checkFilename(pluginFile)) {
pluginsFileExists = true;
break;
}
}
if (! pluginsFileExists) {
std::string errorMsg = std::string("Error: the requested plugins file \"")
#if defined(NDEBUG) || !defined(_WIN32)
+ std::string("plugins.cfg")
#else
+ std::string("plugins_d.cfg")
#endif
+ std::string("\" doesn't exist in ")
+ std::string(mPluginsPath);
std::cout << errorMsg << std::endl;
throw (vpException(vpException::ioError, errorMsg));
}
std::cout << "######################### Load plugin file: " << pluginFile << std::endl;
if(Ogre::Root::getSingletonPtr() == NULL)
mRoot = new Ogre::Root(pluginFile, "ogre.cfg", "Ogre.log");
else
mRoot = Ogre::Root::getSingletonPtr();
// Load resource paths from config file
// File format is:
// [ResourceGroupName]
// ArchiveType=Path
// .. repeat
// For example:
// [General]
// FileSystem=media/
// Zip=packages/level1.zip
// mResourcePath may contain more than one folder location separated by ";"
bool resourcesFileExists = false;
std::string resourceFile;
std::vector<std::string> resourcesPaths = vpIoTools::splitChain(std::string(mResourcePath), std::string(";"));
for (size_t i=0; i<resourcesPaths.size(); i++) {
resourceFile = resourcesPaths[i]+"/resources.cfg";
if(vpIoTools::checkFilename(resourceFile)) {
resourcesFileExists = true;
break;
}
}
if (! resourcesFileExists) {
std::string errorMsg = std::string("Error: the requested resource file \"resources.cfg\"")
+ std::string("doesn't exist in ")
+ std::string(mResourcePath);
std::cout << errorMsg << std::endl;
throw (vpException(vpException::ioError, errorMsg));
}
std::cout << "######################### Load resource file: " << resourceFile << std::endl;
Ogre::ConfigFile cf;
cf.load(resourceFile);
// 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);
}
}
std::cout << "##################### add resources" << std::endl;
//Add optionnal resources (given by the user).
for(std::list<std::string>::const_iterator iter = mOptionnalResourceLocation.begin(); iter != mOptionnalResourceLocation.end(); ++iter){
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(*iter, "FileSystem", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
}
// Create the window
bool canInit = true;
if(mshowConfigDialog){
mRoot->restoreConfig();
if(!mRoot->showConfigDialog())
canInit = false;
}
else{
if(!mRoot->restoreConfig())
canInit = false;
}
if(!mRoot->isInitialised()){
if(!canInit){ //We set the default renderer system
const Ogre::RenderSystemList& lRenderSystemList = mRoot->getAvailableRenderers();
if( lRenderSystemList.size() == 0 )
throw "ConfigDialog aborted"; // Exit the application on cancel
Ogre::RenderSystem *lRenderSystem = lRenderSystemList.at(0);
std::cout << "Using " << lRenderSystem->getName() << " as renderer." << std::endl;
mRoot->setRenderSystem(lRenderSystem);
}
mRoot->initialise(false);
}
bool fullscreen = false;
Ogre::NameValuePairList misc;
Ogre::ConfigOptionMap config = mRoot->getRenderSystem()->getConfigOptions();
Ogre::ConfigOptionMap::const_iterator it = config.begin();
while( it != config.end() ){
Ogre::String leftconf = (*it).first;
Ogre::String rightconf = (*it).second.currentValue;
if(leftconf == "Video Mode"){
if(canInit) {
int ret = sscanf(rightconf.c_str(), "%d %*s %d", &mWindowWidth, &mWindowHeight);
if (ret == 0)
std::cout << "Cannot read Ogre video mode" << std::endl;
}
else{
if(mWindowWidth == 0 && mWindowHeight == 0){
mWindowWidth = mBackgroundWidth;
mWindowHeight = mBackgroundHeight;
}
}
}
else if( leftconf == "Full Screen" ){
if(canInit){
if(rightconf == "Yes") fullscreen = true;
}
}
else
misc[leftconf] = rightconf;
it++;
}
// With Ogre version >= 1.8.1 we hide the window
if( hidden ){
#if ( OGRE_VERSION >= (1 << 16 | 8 << 8 | 1) )
misc["hidden"] = "true";
windowHidden = true;
#endif
}
mWindow = mRoot->createRenderWindow(name, mWindowWidth, mWindowHeight, fullscreen, &misc);
// Initialise resources
Ogre::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
//-----------------------------------------------------
mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC);
// Create the camera
createCamera();
// Create a viewport
Ogre::Viewport* viewPort = mWindow->addViewport(mCamera);
// Ogre::Viewport* viewPort = mCamera->getViewport();
viewPort->setClearEveryFrame(true);
// Set the projection parameters to match the camera intrinsic parameters
updateCameraProjection();
// Create the 3D scene
createScene();
// Initialise and register event handlers
mRoot->addFrameListener(this);
// Register as a Window listener
Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);
#ifdef VISP_HAVE_OIS
// Initialise OIS
Ogre::LogManager::getSingletonPtr()->logMessage("*** Initializing OIS ***");
OIS::ParamList pl;
size_t windowHnd = 0;
std::ostringstream windowHndStr;
// Initialise window
mWindow->getCustomAttribute("WINDOW", &windowHnd);
windowHndStr << windowHnd;
pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
// Let the user use the keyboard elsewhere
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))) // UNIX
pl.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));
#endif
mInputManager = OIS::InputManager::createInputSystem( pl );
//Create all devices
// Here we only consider the keyboard input
mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, bufferedKeys ));
if ( !bufferedKeys ) mKeyboard->setEventCallback ( this);
#endif
// Initialise a render to texture to be able to retrieve a screenshot
Ogre::TexturePtr Texture = Ogre::TextureManager::getSingleton().createManual("rtf", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,Ogre::TEX_TYPE_2D,
mWindow->getWidth(),mWindow->getHeight(), 0, Ogre::PF_R8G8B8A8, Ogre::TU_RENDERTARGET);
// Ogre::TexturePtr Texture = Ogre::TextureManager::getSingleton().createManual("rtf", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,Ogre::TEX_TYPE_2D,
// 640,480, 0, Ogre::PF_R8G8B8A8, Ogre::TU_RENDERTARGET);
Ogre::RenderTexture* RTarget = Texture->getBuffer()->getRenderTarget();
/*Ogre::Viewport* Viewport =*/ RTarget->addViewport(mCamera);
RTarget->getViewport(0)->setClearEveryFrame(true);
RTarget->getViewport(0)->setOverlaysEnabled(false);
}