void Application::go()
{
Ogre::Timer loopTimer;
bool continueRunning = true;
while ( continueRunning )
{
Ogre::WindowEventUtilities::messagePump();
SimpleInputManager::capture();
// Update logic stuff
// Update graphics stuff
bool windowClosed = m_window->isClosed();
continueRunning &= ! windowClosed;
loopTimer.reset();
bool renderFrameSuccess = m_root->renderOneFrame();
continueRunning &= renderFrameSuccess;
continueRunning &= ! m_exitRequested;
}
}
void Application::update()
{
Ogre::Timer loopTimer;
bool continueRunning = true;
while (continueRunning)
{
Ogre::WindowEventUtilities::messagePump();
SimpleInputManager::capture();
float elapsedSeconds = loopTimer.getMicroseconds() * 1.0 / 1000000;
m_NXOgreTimeController->advance(elapsedSeconds);
loopTimer.reset();
updateOverlayInfo();
bool renderFrameSuccess = m_root->renderOneFrame();
if (!renderFrameSuccess || m_exitRequested)
{
continueRunning = false;
}
}
}
/**
* Releases the object's resources
*/
void MediaPlayerOCV::end()
{
// Check if already released
if ( !isValid() )
return;
// Release thread
if ( m_multithreaded && m_captureThread )
{
// Signal the thread and wait for it to be done
m_captureThread->signal();
Ogre::Timer timerLimit;
timerLimit.reset();
while( (m_captureThread->get_finished() == false) && (timerLimit.getMilliseconds() < 250) )
;
if ( m_captureThread->get_finished() )
{
delete m_captureThread;
}
else
LOG_CRITICAL( "MediaPlayerOCV: capture thread timer expired, and the thread did not finish. Something is wrong, there will be a memory leak" );
m_captureThread = NULL;
}
// Clear resources
m_capture.release();
m_frameImg.end();
// Clear flags
m_bIsValid = false;
m_newBufferReady = false;
m_loopPending = false;
}
void App::UpdThr()
{
Ogre::Timer gtim;
//#ifdef _WIN32
//DWORD af = 2;
//gtim.setOption("QueryAffinityMask", &af);
//#endif
gtim.reset();
while (!mShutDown)
{
/// step Game **
double dt = double(gtim.getMicroseconds()) * 0.000001;
gtim.reset();
if (pSet->multi_thr == 1 && !bLoading)
{
bSimulating = true;
bool ret = pGame->OneLoop(dt);
if (!ret)
mShutDown = true;
DoNetworking();
bSimulating = false;
}
boost::this_thread::sleep(boost::posix_time::milliseconds(pSet->thread_sleep));
}
}
void Application::go()
{
Ogre::Timer loopTimer;
bool continueRunning = true;
while ( continueRunning )
{
Ogre::WindowEventUtilities::messagePump();
SimpleInputManager::capture();
// Update logic stuff
float elapsedSeconds = loopTimer.getMicroseconds() * 1.0 / 1000000;
updateLogic( elapsedSeconds );
// Update graphics stuff
updateAnimations( elapsedSeconds );
bool windowClosed = m_window->isClosed();
continueRunning &= ! windowClosed;
updateStats();
loopTimer.reset();
bool renderFrameSuccess = m_root->renderOneFrame();
continueRunning &= renderFrameSuccess;
continueRunning &= ! m_exitRequested;
}
}
// Run
//-------------------------------------------------------------------------------------
void BaseApp::Run( bool showDialog )
{
mShowDialog = showDialog;
if (!setup())
return;
if (!pSet->limit_fps)
mRoot->startRendering(); // default
else
{ Ogre::Timer tim;
while (1)
{
Ogre::WindowEventUtilities::messagePump();
if (tim.getMicroseconds() > 1000000.0 / pSet->limit_fps_val)
{
tim.reset();
if (!mRoot->renderOneFrame())
break;
}else
if (pSet->limit_sleep >= 0)
boost::this_thread::sleep(boost::posix_time::milliseconds(pSet->limit_sleep));
} }
destroyScene();
}
//Run the app
void Application::go()
{
Ogre::Timer loopTimer;
long lastTick,currentTick;
lastTick=loopTimer.getMillisecondsCPU();
float fpsStep = 1.0f/(float)FPS;
float frameDelta;
bool continueRunning=true;
while(continueRunning)
{
Ogre::WindowEventUtilities::messagePump();
capture();
currentTick=loopTimer.getMillisecondsCPU();
frameDelta = (currentTick-lastTick)*0.001;
static float logicUpdateCounter=0;
logicUpdateCounter+=frameDelta;
while (logicUpdateCounter>fpsStep)
{
logicUpdateCounter-=fpsStep;
updateLogic(fpsStep);
updateGraphics(fpsStep);
}
bool windowClosed = m_window->isClosed();
continueRunning &= ! windowClosed;
bool renderFrameSuccess = m_root->renderOneFrame();
continueRunning &= renderFrameSuccess;
continueRunning &= ! m_exitRequested;
lastTick=currentTick;
}
}
void Application::initializeCEGUI()
{
Ogre::Timer timer;
timer.reset();
CEGUI::OgreRenderer::bootstrapSystem(*mOgreWindow);
mUIRoot = static_cast<CEGUI::GUISheet*>(CEGUI::WindowManager::getSingleton().createWindow("DefaultWindow", "Root"));
mUIRoot->setPosition(CEGUI::UVector2(CEGUI::UDim(0, 0), CEGUI::UDim(0, 0)));
mUIRoot->setSize(CEGUI::UVector2(CEGUI::UDim(1, 0), CEGUI::UDim(1, 0)));
mUIRoot->setVisible(true);
CEGUI::System::getSingleton().setGUISheet(mUIRoot);
CEGUI::SchemeManager::getSingleton().create("OISBDemo.scheme");
CEGUI::System::getSingleton().setDefaultMouseCursor("OgreTrayImages", "MouseArrow");
CEGUI::MouseCursor::getSingleton().hide();
//mUIRoot->addChildWindow(CEGUI::WindowManager::getSingleton().loadWindowLayout("Introduction.layout"));
mUIRoot->addChildWindow(CEGUI::WindowManager::getSingleton().loadWindowLayout("HUD.layout"));
mUIHUDThrottle = static_cast<CEGUI::ProgressBar*>(CEGUI::WindowManager::getSingleton().getWindow("HUD/Throttle"));
mUIHUDVelocity = CEGUI::WindowManager::getSingleton().getWindow("HUD/Velocity");
mUIHUDAltitude = CEGUI::WindowManager::getSingleton().getWindow("HUD/Altitude");
std::stringstream sstr;
sstr << timer.getMicroseconds();
CEGUI::Logger::getSingleton().logEvent("Time to start CEGUI: " + sstr.str());
}
//---------------------------------------------------------------------------
void HeatVisionListener::notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat)
{
if(pass_id == 0xDEADBABE)
{
// "random_fractions" parameter
fpParams->setNamedConstant("random_fractions", Ogre::Vector4(Ogre::Math::RangeRandom(0.0, 1.0), Ogre::Math::RangeRandom(0, 1.0), 0, 0));
// "depth_modulator" parameter
float inc = ((float)timer->getMilliseconds())/1000.0f;
if ( (fabs(curr-end) <= 0.001) )
{
// take a new value to reach
end = Ogre::Math::RangeRandom(0.95, 1.0);
start = curr;
}
else
{
if (curr > end) curr -= inc;
else curr += inc;
}
timer->reset();
fpParams->setNamedConstant("depth_modulator", Ogre::Vector4(curr, 0, 0, 0));
}
}
//-------------------------------------------------------------------------------------
void App::go(void)
{
#ifdef _DEBUG
mResourcesCfg = "resources_d.cfg";
mPluginsCfg = "plugins_d.cfg";
#else
mResourcesCfg = "resources.cfg";
mPluginsCfg = "plugins.cfg";
#endif
if (!setup())
return;
Ogre::Timer timer;
//mRoot->startRendering();
float lastTime = timer.getMicroseconds()/1000000.0f;
float curTime = timer.getMicroseconds()/1000000.0f;
while(update(curTime - lastTime))
{
lastTime = curTime;
curTime = timer.getMicroseconds()/1000000.0f;
//timer.reset();
}
// clean up
destroyScene();
}
void OMW::Engine::go()
{
assert (!mContentFiles.empty());
assert (!mOgre);
Settings::Manager settings;
std::string settingspath;
settingspath = loadSettings (settings);
// Create encoder
ToUTF8::Utf8Encoder encoder (mEncoding);
mEncoder = &encoder;
prepareEngine (settings);
// Play some good 'ol tunes
MWBase::Environment::get().getSoundManager()->playPlaylist(std::string("Explore"));
if (!mSaveGameFile.empty())
{
MWBase::Environment::get().getStateManager()->loadGame(mSaveGameFile);
}
else if (!mSkipMenu)
{
// start in main menu
MWBase::Environment::get().getWindowManager()->pushGuiMode (MWGui::GM_MainMenu);
try
{
// Is there an ini setting for this filename or something?
MWBase::Environment::get().getSoundManager()->streamMusic("Special/morrowind title.mp3");
std::string logo = mFallbackMap["Movies_Morrowind_Logo"];
if (!logo.empty())
MWBase::Environment::get().getWindowManager()->playVideo(logo, true);
}
catch (...) {}
}
else
{
MWBase::Environment::get().getStateManager()->newGame (!mNewGame);
}
// Start the main rendering loop
Ogre::Timer timer;
while (!MWBase::Environment::get().getStateManager()->hasQuitRequest())
{
float dt = timer.getMilliseconds()/1000.f;
dt = std::min(dt, 0.2f);
timer.reset();
Ogre::Root::getSingleton().renderOneFrame(dt);
}
// Save user settings
settings.saveUser(settingspath);
std::cout << "Quitting peacefully." << std::endl;
}
::FreeConsole();
}
void Game::Run()
{
InitializeGame();
ConnectToPVD();
InitializeKinect();
kinectController = BodyController();
InputManager* inputManager = InputManager::GetInstance();
inputManager->RegisterSensorListener(&kinectController);
inputManager->BeginAllCapture();
sceneManager = new SceneManager();
sceneManager->Initialize(mWindow, mRoot);
AllocConsole();
freopen("conin$","r",stdin);
freopen("conout$","w",stdout);
freopen("conout$","w",stderr);
printf("Debugging Window:\n");
/*std::shared_ptr<GameScene> gameScene(new GameScene(sceneManager, mRoot, "Probending Arena", contestantData));
sceneManager->FlagSceneSwitch(gameScene, true);
gameScene.reset();*/
std::shared_ptr<MenusScene> menuScene = std::make_shared<MenusScene>(sceneManager, mRoot, MenusScene::Screens::MainMenu);
sceneManager->FlagSceneSwitch(menuScene, true);
menuScene.reset();
bool rendering = true;
Ogre::Timer gameTimer = Ogre::Timer();
float currentTime = 0;
float previousTime = 0;
while (rendering)
{
gameTimer.reset();
if(!Update(currentTime / 1000.0f))
rendering = false;
//Ogre::WindowEventUtilities::messagePump();
#if(!MEMORY_LEAK_DETECT)
mRoot->renderOneFrame();
#endif
currentTime = (float)gameTimer.getMilliseconds();
//---------------------------------------------------------------------
unsigned long renderThreadApp(Ogre::ThreadHandle* threadHandle) {
LeDernierMorkid::LeDernierMorkidThreadData* threadData = reinterpret_cast<LeDernierMorkid::LeDernierMorkidThreadData*>(threadHandle->getUserParam());
GraphicsSystem* graphicsSystem = threadData->graphicsSystem;
Ogre::Barrier* barrier = threadData->barrier;
graphicsSystem->initialize("Le Dernier Morkid");
graphicsSystem->getInputHandler()->setGrabMousePointer(true);
graphicsSystem->getInputHandler()->setMouseVisible(false);
barrier->sync();
if (graphicsSystem->getQuit()) {
graphicsSystem->deinitialize();
return 0; // User cancelled config
}
graphicsSystem->createScene();
barrier->sync();
Ogre::RenderWindow* renderWindow = graphicsSystem->getRenderWindow();
Ogre::Timer timer;
unsigned long startTime = timer.getMicroseconds();
double timeSinceLast = 1.0 / 60.0;
while (!graphicsSystem->getQuit()) {
graphicsSystem->beginFrameParallel();
graphicsSystem->update(timeSinceLast);
graphicsSystem->finishFrameParallel();
if (!renderWindow->isVisible()) {
// Don't burn CPU cycles unnecessary when we're minimized.
Ogre::Threads::Sleep(500);
}
unsigned long endTime = timer.getMicroseconds();
timeSinceLast = (endTime - startTime) / 1000000.0;
timeSinceLast = std::min(1.0, timeSinceLast); // Prevent from going haywire.
startTime = endTime;
}
barrier->sync();
graphicsSystem->destroyScene();
barrier->sync();
graphicsSystem->deinitialize();
barrier->sync();
return 0;
}
unsigned long yield( double frameTime, unsigned long startTime )
{
unsigned long endTime = mExternalTimer->getMicroseconds();
while( frameTime * 1000000.0 > (endTime - startTime) )
{
endTime = mExternalTimer->getMicroseconds();
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
SwitchToThread();
#elif OGRE_PLATFORM == OGRE_PLATFORM_LINUX || OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
sched_yield();
#endif
}
return endTime;
}
//---------------------------------------------------------------------------
void HeatVisionListener::notifyMaterialSetup(Ogre::uint32 pass_id, Ogre::MaterialPtr &mat)
{
if(pass_id == 0xDEADBABE)
{
timer->reset();
fpParams =
mat->getTechnique(0)->getPass(0)->getFragmentProgramParameters();
}
}
void Application::run()
{
initialize();
setupScene();
Ogre::Timer timer;
timer.reset();
mRunning = true;
while (mRunning)
{
const Ogre::Real delta=
timer.getMicroseconds() * static_cast<Ogre::Real>(0.000001f);
timer.reset();
runOneFrame(delta);
}
finalize();
}
/// _Tool_ Warnings ......................................................
/// check all tracks for warnings
/// Warning: takes about 16 sec
void CGui::ToolTracksWarnings()
{
Ogre::Timer ti;
LogO("ALL tracks warnings ---------\n");
logWarn = true;
for (int i=0; i < data->tracks->trks.size(); ++i)
{ // foreach track
string trk = data->tracks->trks[i].name, path = gcom->pathTrk[0] +"/"+ trk +"/";
/**/if (!(trk[0] >= 'A' && trk[0] <= 'Z')) continue;
/**/if (StringUtil::startsWith(trk,"test")) continue;
Scene sc; sc.LoadXml(path +"scene.xml");
SplineRoad rd(app); rd.LoadFile(path +"road.xml");
LogO("Track: "+trk);
WarningsCheck(&sc,&rd);
}
LogO(String("::: Time ALL tracks: ") + fToStr(ti.getMilliseconds(),0,3) + " ms");
LogO("ALL tracks warnings ---------");
}
// FrameListener callback (~ idleFunc). Perform animation here
bool frameRenderingQueued(const Ogre::FrameEvent& evt) {
float t = mTimer.getMilliseconds()*0.001;
// Do some simple animations by changing scene node transform parameters
Ogre::SceneNode* triangle = mScene->getSceneNode("Triangle");
triangle->resetToInitialState();
triangle->rotate(Ogre::Vector3(0, 0, 1), Ogre::Radian(t));
// Exercise 1: Use SceneNode to manipulate the object and create animation
// ...
return true; // Return false to quit
}
bool initOgreRoot(){
try{
// Create logs that funnel to android logs
Ogre::LogManager *lm = OGRE_NEW Ogre::LogManager();
Ogre::Log *l = lm->createLog("AndroidLog", true, true, true);
g_ll = OGRE_NEW AndroidLogListener();
l->addListener(g_ll);
// Create a root object
g_root = OGRE_NEW Ogre::Root("", "", "");
// Register the ES2 plugin
g_gles2Plugin = OGRE_NEW Ogre::GLES2Plugin();
Ogre::Root::getSingleton().installPlugin(g_gles2Plugin);
// Register particle plugin
g_pfxPlugin = OGRE_NEW Ogre::ParticleFXPlugin();
Ogre::Root::getSingleton().installPlugin(g_pfxPlugin);
// Grab the available render systems
const Ogre::RenderSystemList &renderSystemList = g_root->getAvailableRenderers();
if(renderSystemList.empty())
{
return false;
}
// Set the render system and init
Ogre::RenderSystem *system = renderSystemList.front();
g_root->setRenderSystem(system);
g_root->initialise(false);
g_lastTime = g_timer.getMilliseconds();
return true;
}catch(Ogre::Exception &e){
}
return false;
}
///--------------------------------------------------------------------------------------------------------------
// Create Terrain
///--------------------------------------------------------------------------------------------------------------
void CScene::CreateTerrain(bool bNewHmap, bool bTer, bool terLoad)
{
Ogre::Timer tm;
terrain = 0;
/// sky
Vector3 scl = app->pSet->view_distance*Vector3::UNIT_SCALE;
CreateSkyDome(sc->skyMtr, scl, sc->skyYaw);
UpdFog();
// light
app->mSceneMgr->destroyAllLights();
sun = app->mSceneMgr->createLight("Sun");
sun->setType(Light::LT_DIRECTIONAL); UpdSun();
if (bTer)
{
///.
UpdShaderParams();
UpdLayerPars();
/// -------- fill HeightField data --------
//Ogre::Timer ti;
if (terLoad || bNewHmap)
{
int wx = sc->td.iVertsX, wy = sc->td.iVertsY, wxy = wx * wy; //wy=wx
delete[] sc->td.hfHeight; sc->td.hfHeight = new float[wxy];
const int size = wxy * sizeof(float);
String name = app->gcom->TrkDir() + (bNewHmap ? "heightmap-new.f32" : "heightmap.f32");
// load from f32 HMap +
{
std::ifstream fi;
fi.open(name.c_str(), std::ios_base::binary);
fi.read((char*)&sc->td.hfHeight[0], size);
fi.close();
}
}
CreateBlendTex(); //+
//LogO(String("::: Time Hmap: ") + fToStr(ti.getMilliseconds(),0,3) + " ms"); ti.reset(); // 4MB ~13ms
///.
UpdBlendmap();
// Terrain
{
if (!mTerrainGlobals)
mTerrainGlobals = OGRE_NEW TerrainGlobalOptions();
OGRE_DELETE mTerrainGroup;
mTerrainGroup = OGRE_NEW TerrainGroup(app->mSceneMgr, Terrain::ALIGN_X_Z,
sc->td.iTerSize, sc->td.fTerWorldSize);
mTerrainGroup->setOrigin(Vector3::ZERO);
SetupTerrain();
if (sc->td.hfHeight)
mTerrainGroup->defineTerrain(0,0, sc->td.hfHeight);
else
mTerrainGroup->defineTerrain(0,0, 0.f);
// sync load since we want everything in place when we start
mTerrainGroup->loadAllTerrains(true);
TerrainGroup::TerrainIterator ti = mTerrainGroup->getTerrainIterator();
while (ti.hasMoreElements())
{
Terrain* t = ti.getNext()->instance;
terrain = t; //<set
terrain->setVisibilityFlags(RV_Terrain);
}
mTerrainGroup->freeTemporaryResources();
}
// Horizon ----------
if (app->pSet->horizon)
{
if (!mHorizonGlobals)
mHorizonGlobals = OGRE_NEW TerrainGlobalOptions();
OGRE_DELETE mHorizonGroup;
mHorizonGroup = OGRE_NEW TerrainGroup(app->mSceneMgr, Terrain::ALIGN_X_Z,
sc->td.iTerSize, sc->td.fTerWorldSize * 16.f);
mHorizonGroup->setOrigin(Vector3::ZERO);
SetupHorizon();
//if (sc->td.hfHeight)
// mHorizonGroup->defineTerrain(0,0, sc->td.hfHeight);
//else
mHorizonGroup->defineTerrain(0,0, 0.f);
mHorizonGroup->loadAllTerrains(true);
TerrainGroup::TerrainIterator ti = mHorizonGroup->getTerrainIterator();
while (ti.hasMoreElements())
{
Terrain* t = ti.getNext()->instance;
//initBlendMaps(t);
horizon = t; //<set
horizon->setVisibilityFlags(RV_Terrain);
}
mHorizonGroup->freeTemporaryResources();
}
}//bTer
///.
changeShadows();
//UpdBlendmap(); //-
LogO(String("::: Time Terrain: ") + fToStr(tm.getMilliseconds(),0,3) + " ms");
}
void Client::Play() {
OgreEasy::SimpleOgreInit lOgreInit;
if(!lOgreInit.initOgre()) {
std::cout<<"Could not init ogre"<<std::endl;
return;
}
Ogre::Root* lRoot = lOgreInit.mRoot.get();
Ogre::RenderWindow* lWindow = lOgreInit.mWindow;
World* w = new World();
w->SetDebugMode(false);
GameObject camObject = w->AddObject("camera");
camObject.AddCameraComponent("camera");
camObject.SetPosition(Ogre::Vector3(0,0,0));
camObject.LookAt(Ogre::Vector3(0,0,0));
GameObject& light2 = w->AddObject("point_light");
light2.AddLightComponent(Ogre::Light::LT_DIRECTIONAL);
light2.SetPosition(Ogre::Vector3(0,0,40));
light2.LookAt(Ogre::Vector3(0,100,0));
GameObject& c = w->AddPhysicsObject("esine", "cube/Cube.mesh");
c.SetPosition(Ogre::Vector3(0,0,0));
c.AddBoxCollider(1,1,1);
PhysicsComponent phys = c.GetPhysicsComponent();
phys.SetMass(1.0);
c.SetMaterial("tex");
GameObject& c2 = w->AddPhysicsObject("esine2", "cube/Cube.mesh");
c2.SetPosition(Ogre::Vector3(1,2,1));
c2.AddBoxCollider(1,1,1);
PhysicsComponent phys2 = c2.GetPhysicsComponent();
phys2.SetMass(1.0);
c2.SetMaterial("tex");
GameObject& taso = w->AddPhysicsObject("taso", "cube/other/Cube.mesh");
taso.SetPosition(Ogre::Vector3(0, -10, 0));
taso.AddBoxCollider(10,0.1,10);
taso.SetMaterial("plane");
PhysicsComponent phys3 = taso.GetPhysicsComponent();
phys3.SetMass(0.0);
GameObject& anim = w->AddObject("anim" , "second_anim/Cube.mesh");
anim.SetPosition(Ogre::Vector3(0, -5, 0));
anim.SetMaterial("tex");
lRoot->clearEventTimes();
float f=0.0;
unsigned long t=0;
double d;
Ogre::Timer* a = new Ogre::Timer();
while(!lWindow->isClosed()) {
t=a->getMicroseconds();
camObject.SetPosition(Ogre::Vector3(cos(f)*15.0, -5, sin(f)*15.0));
camObject.LookAt(Ogre::Vector3(-0,-10,-0), Ogre::Vector3::UNIT_Y);
w->Update(d);
f+=d*.5;
d = (double)(a->getMicroseconds()-t)/1000000;
}
delete w;
}
void App::LoadTrackEv()
{
Ogre::Timer ti;
NewCommon(false); // full destroy
iObjCur = -1;
scn->DestroyRoad();
scn->DestroyPace();
// load scene
scn->sc->LoadXml(gcom->TrkDir()+"scene.xml");
scn->sc->vdr = IsVdrTrack();
if (scn->sc->vdr) scn->sc->ter = false;
// water RTT recreate
scn->UpdateWaterRTT(mCamera);
BltWorldInit();
UpdWndTitle();
scn->CreateFluids();
scn->CreateWeather();
// set sky tex name for water
sh::MaterialInstance* m = mFactory->getMaterialInstance(scn->sc->skyMtr);
std::string skyTex = sh::retrieveValue<sh::StringValue>(m->getProperty("texture"), 0).get();
sh::Factory::getInstance().setTextureAlias("SkyReflection", skyTex);
sh::Factory::getInstance().setTextureAlias("CubeReflection", "ReflectionCube");
bNewHmap = false;/**/
scn->CreateTerrain(bNewHmap, scn->sc->ter);
if (track)
if (scn->sc->vdr) // vdrift track
{
if (!LoadTrackVdr(pSet->gui.track))
LogO("Error during track loading: " + pSet->gui.track);
CreateVdrTrack(pSet->gui.track, track);
CreateVdrTrackBlt();
}
// road ~
scn->road = new SplineRoad(this);
scn->road->Setup("sphere.mesh", pSet->road_sphr, scn->terrain, mSceneMgr, mCamera);
scn->road->LoadFile(gcom->TrkDir()+"road.xml");
scn->UpdPSSMMaterials();
// pace ~ ~
scn->pace = new PaceNotes(pSet);
scn->pace->Setup(mSceneMgr, mCamera, scn->terrain, gui->mGui, mWindow);
/// HW_Inst Test * * *
//inst = new Instanced();
//inst->Create(mSceneMgr,"sphere_inst.mesh");
CreateObjects();
if (pSet->bTrees && scn->sc->ter)
scn->CreateTrees(); // trees after objects so they aren't inside them
// updates after load
//--------------------------
gcom->ReadTrkStats();
gui->SetGuiFromXmls(); ///
Rnd2TexSetup();
//UpdVisGui();
//UpdStartPos();
UpdEditWnds(); //
try {
TexturePtr tex = TextureManager::getSingleton().getByName("waterDepth.png");
if (!tex.isNull())
tex->reload();
} catch(...) { }
gui->Status("#{Loaded}", 0.5,0.7,1.0);
if (pSet->check_load)
gui->WarningsCheck(scn->sc, scn->road);
LogO(String("::: Time Load Track: ") + fToStr(ti.getMilliseconds(),0,3) + " ms");
}
// Create Scene
//-------------------------------------------------------------------------------------
void App::createScene() // once, init
{
// prv tex
int k=1024;
prvView.Create(k,k,"PrvView");
prvRoad.Create(k,k,"PrvRoad");
prvTer.Create(k,k,"PrvTer");
scn->roadDens.Create(k+1,k+1,"RoadDens");
/// ter lay tex
for (int i=0; i < 6; ++i)
{ String si = toStr(i);
scn->texLayD[i].SetName("layD"+si);
scn->texLayN[i].SetName("layN"+si);
}
// camera
asp = float(mWindow->getWidth())/float(mWindow->getHeight());
mCamera->setFarClipDistance(pSet->view_distance*1.1f);
mCamera->setNearClipDistance(0.1f);
// cam pos from last set
mCamera->setPosition(Vector3(pSet->cam_x,pSet->cam_y,pSet->cam_z));
mCamera->setDirection(Vector3(pSet->cam_dx,pSet->cam_dy,pSet->cam_dz).normalisedCopy());
mViewport->setVisibilityMask(RV_MaskAll); // hide prv cam rect
// tex fil
MaterialManager::getSingleton().setDefaultTextureFiltering(TFO_ANISOTROPIC);
MaterialManager::getSingleton().setDefaultAnisotropy(pSet->anisotropy);
Ogre::Timer ti;
// data load xml
scn->data->Load();
scn->sc->pFluidsXml = scn->data->fluids;
scn->sc->pReverbsXml = scn->data->reverbs;
// surfaces.cfg
LoadAllSurfaces();
LogO(String("::: Time load xmls: ") + fToStr(ti.getMilliseconds(),0,3) + " ms");
postInit(); // material factory
// gui * * *
if (pSet->startInMain)
pSet->isMain = true;
bGuiFocus = false/*true*/; bMoveCam = true; //*--
gui->InitGui();
///__ All #if 0 in Release !!!
/// _Tool_ scene ...................
#if 0
gui->ToolSceneXml();
exit(0);
#endif
/// _Tool_ warnings ................
/// takes some time
#if 0
gui->ToolTracksWarnings();
exit(0);
#endif
TerCircleInit();
createBrushPrv();
/// _Tool_ brushes prv .............
#if 0
gui->ToolBrushesPrv();
#endif
// load
if (pSet->autostart)
LoadTrack();
if (!pSet->autostart)
{ bGuiFocus = true; UpdVisGui(); }
iObjTNew = 0;
//SetObjNewType(0); //?white
gui->chkInputBar(0); // upd vis
gui->chkCamPos(0);
gui->chkFps(0);
}
// Setup
//-------------------------------------------------------------------------------------
bool BaseApp::setup()
{
Ogre::Timer ti;
LogO("*** start setup ***");
if (pSet->rendersystem == "Default")
{
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
pSet->rendersystem = "Direct3D9 Rendering Subsystem";
#else
pSet->rendersystem = "OpenGL Rendering Subsystem";
#endif
}
//LogManager::getSingleton().setLogDetail(LL_BOREME); //-
#ifdef _DEBUG
#define D_SUFFIX "_d"
#else
#define D_SUFFIX ""
#endif
// when show ogre dialog is on, load both rendersystems so user can select
if (pSet->ogre_dialog)
{
mRoot->loadPlugin(PATHMANAGER::OgrePluginDir() + "/RenderSystem_GL" + D_SUFFIX);
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
mRoot->loadPlugin(PATHMANAGER::OgrePluginDir() + "/RenderSystem_Direct3D9" + D_SUFFIX);
#endif
}else{
if (pSet->rendersystem == "OpenGL Rendering Subsystem")
mRoot->loadPlugin(PATHMANAGER::OgrePluginDir() + "/RenderSystem_GL" + D_SUFFIX);
else if (pSet->rendersystem == "Direct3D9 Rendering Subsystem")
mRoot->loadPlugin(PATHMANAGER::OgrePluginDir() + "/RenderSystem_Direct3D9" + D_SUFFIX);
}
mRoot->loadPlugin(PATHMANAGER::OgrePluginDir() + "/Plugin_ParticleFX" + D_SUFFIX);
setupResources();
if (!configure())
return false;
mSceneMgr = mRoot->createSceneManager(/*ST_GENERIC/**/Ogre::ST_EXTERIOR_FAR/**/);
#if OGRE_VERSION >= MYGUI_DEFINE_VERSION(1, 9, 0)
Ogre::OverlaySystem* pOverlaySystem = new Ogre::OverlaySystem();
mSceneMgr->addRenderQueueListener(pOverlaySystem);
#endif
createCamera();
Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
mSceneMgr->setFog(Ogre::FOG_NONE);
loadResources();
baseInitGui();
createFrameListener();
LogO(Ogre::String("::: Time Ogre Start: ") + fToStr(ti.getMilliseconds(),0,3) + " ms");
createScene();
return true;
}
MainMachineEvent SponsorsState::update(MainMachineInfo &info)
{
Ogre::Timer timer;
float timeStamp = 0;
MainMachineEvent result = MME_DONE;
Ogre::Real frameTime = 0;
float press = false;
// check we have loaded both overlays
ASSERT(mFader);
ASSERT(mOverlay);
// here is the main loop
bool running = true;
mAccumTime = mFaderTime;
mFader->show();
mOverlay->show();
while(running) {
timeStamp = timer.getMilliseconds();
GLOBAL_KEYBOARD->capture();
if(GLOBAL_KEYBOARD->isKeyDown(OIS::KC_ESCAPE)){
break;
}
// depending on the state we call the function
switch(mState){
case STATE_FADE_IN:
if(enterFade(frameTime)){
mState = STATE_SPONSORS;
mAccumTime = 0;
mFader->hide();
}
break;
case STATE_SPONSORS:
if(showSponsors(frameTime)){
mState = STATE_FADE_OUT;
mAccumTime = 0;
mFader->show();
}
break;
case STATE_FADE_OUT:
if(exitFade(frameTime)){
mState = STATE_END;
}
break;
case STATE_END:
running = false;
break;
default:
ASSERT(false);
}
// render the frame
if(!GLOBAL_ROOT->renderOneFrame()){
result = MME_DONE; //TODO: poner un erro real aca
break;
}
// This must be called when we use the renderOneFrame approach
Ogre::WindowEventUtilities::messagePump();
frameTime = (timer.getMilliseconds() - timeStamp) * 0.001;
}
return result;
}
bool mouseReleased(const OIS::MouseEvent& evt, OIS::MouseButtonID id)
{
if (evt.state.buttonDown(OIS::MB_Left) == false)
SdkSample::mouseReleased(evt, id);
Ogre::Ray ray = mTrayMgr->getCursorRay(mCamera);
beastie::ray_query result;
Ogre::Timer timer;
unsigned long rayTime = 0;
timer.reset();
bool ret = mTree->intersect(ray, 10000, result);
rayTime = timer.getMicroseconds();
mResultObject->beginUpdate(0);
if (ret)
{
// Hit something.
mResultObject->position(result.hitTriangle.a + (result.hitTriangle.n * 3.f));
mResultObject->position(result.hitTriangle.b + (result.hitTriangle.n * 3.f));
mResultObject->position(result.hitTriangle.c + (result.hitTriangle.n * 3.f));
mHitPosLabelX->setCaption(Ogre::StringConverter::toString(result.globalPosition.x));
mHitPosLabelY->setCaption(Ogre::StringConverter::toString(result.globalPosition.y));
mHitPosLabelZ->setCaption(Ogre::StringConverter::toString(result.globalPosition.z));
}
else
{
// Didn't hit anything.
// Try raycasting the ground plane.
Ogre::Vector3 globalPosition;
if (beastie::intersections::line( beastie::line(ray, 100000) , mPlane, globalPosition ))
{
mHitPosLabelX->setCaption(Ogre::StringConverter::toString(globalPosition.x));
mHitPosLabelY->setCaption(Ogre::StringConverter::toString(globalPosition.y));
mHitPosLabelZ->setCaption(Ogre::StringConverter::toString(globalPosition.z));
float const radius = 50;
// accuracy is the count of points (and lines).
// Higher values make the circle smoother, but may slowdown the performance.
// The performance also is related to the count of circles.
float const accuracy = 15;
for(float theta = 0; theta <= 2 * Math::PI; theta += Ogre::Math::PI / accuracy) {
mResultObject->position(globalPosition.x + (radius * cos(theta)), 0, globalPosition.z + (radius * sin(theta)));
mResultObject->position(globalPosition);
}
}
else
{
// Really didn't click on anything at all.
mHitPosLabelX->setCaption("-");
mHitPosLabelY->setCaption("-");
mHitPosLabelZ->setCaption("-");
mResultObject->position(0,0,0);
mResultObject->position(0,0,0);
mResultObject->position(0,0,0);
}
}
mResultObject->end();
return true;
}
//--------------------------------------------------------------------------------------------------
bool DiscoApplication::frameStarted( const Ogre::FrameEvent& evt )
{
static Ogre::Timer a;
static uint32_t lastTimeMS;
static uint32_t curTimeMS;
curTimeMS = a.getMilliseconds();
uint32_t timeDiffMS = curTimeMS - lastTimeMS;
if ( timeDiffMS > 0 )
{
//printf( "FPS = %f\n", 1000.0/(float)timeDiffMS );//1.0/((float)timeDiffMS/1000.0) );
}
lastTimeMS = curTimeMS;
const int32_t MAX_DEPTH_MM = 10000;
const float FOCAL_LENGTH = 0.525f; // Focal length in metres
const float FADE_START_XZ_DISTANCE = 0.5f;
const float FADE_MAX_XZ_DISTANCE = 6.0f;
xn::SceneMetaData sceneMD;
xn::DepthMetaData depthMD;
mpKinectController->getContext().WaitAndUpdateAll();
mpKinectController->getDepthGenerator().GetMetaData( depthMD );
mpKinectController->getUserGenerator().GetUserPixels( 0, sceneMD );
XnUserID userIdx[15];
XnUInt16 numUsers = 15;
mpKinectController->getUserGenerator().GetUsers( userIdx, numUsers );
if ( 0 == numUsers )
{
// Restart the time if there are no users to record
mRecordingGapTimer.reset();
}
else
{
for ( uint32_t i = 0; i < numUsers; i++ )
{
if ( tryToAttachParticleToUser( userIdx[ i ] ) )
{
break;
}
}
}
// Start recording if we see a person
if ( numUsers > 0 && !mbRecording
&& mRecordingGapTimer.getMilliseconds() > TIME_BETWEEN_RECORDINGS_MS )
{
mbRecording = true;
memset( mpImageData, 0, RECORDED_DATA_SIZE );
mRecordingFrameIdx = 0;
}
// Build an accumulative histogram to work out the colour for each point
uint32_t depthHist[ MAX_DEPTH_MM ];
memset( depthHist, 0, sizeof( depthHist ) );
uint32_t numPoints = 0;
const XnDepthPixel* pDepth = depthMD.Data();
int32_t recordingPixelStepX = depthMD.XRes() / SMALL_FRAME_WIDTH;
int32_t recordingPixelStepY = depthMD.YRes() / SMALL_FRAME_HEIGHT;
if ( recordingPixelStepX <= 0 ) recordingPixelStepX = 1;
if ( recordingPixelStepY <= 0 ) recordingPixelStepY = 1;
for ( uint32_t y = 0; y < depthMD.YRes(); y++ )
{
for ( uint32_t x = 0; x < depthMD.XRes(); x++ )
{
XnUInt16 value = *pDepth;
if ( 0 != value )
{
depthHist[ value ]++;
numPoints++;
}
pDepth++;
}
}
for ( uint32_t i = 1; i < MAX_DEPTH_MM; i++ )
{
depthHist[ i ] += depthHist[ i - 1 ];
}
if ( numPoints > 0 )
{
for ( uint32_t i = 1; i < MAX_DEPTH_MM; i++ )
{
depthHist[ i ] = (unsigned int)(256 * (1.0f - ((float)depthHist[ i ] / numPoints)));
}
}
// Update the point cloud to reflect the depth data
const float COLOURS[][3] =
{
{0,1,1},
{0,0,1},
{0,1,0},
{1,1,0},
{1,0,0},
{1,.5,0},
{.5,1,0},
{0,.5,1},
{.5,0,1},
{1,1,.5},
{1,1,1}
};
const uint32_t NUM_COLOURS = 10;
pDepth = depthMD.Data();
const XnLabel* pLabels = sceneMD.Data();
mpRosPointCloud->clear();
ogre_tools::PointCloud::Point* pPoints = new ogre_tools::PointCloud::Point[ numPoints ];
int32_t pointIdx = 0;
int32_t width = depthMD.XRes();
int32_t height = depthMD.YRes();
int32_t halfWidth = width / 2;
int32_t halfHeight = height / 2;
for ( int32_t y = 0; y < height; y++ )
{
for ( int32_t x = 0; x < width; x++ )
{
XnUInt16 value = *pDepth;
XnLabel label = *pLabels;
XnUInt32 colorId = label % NUM_COLOURS;
float fade = 1.0;
if (label == 0)
{
// Ignore background
colorId = NUM_COLOURS;
}
{
float worldZ = (float)(*pDepth)/1000.0; // Convert from mm to m
float worldX = (((float)(x-halfWidth)/1000.0)*worldZ) / FOCAL_LENGTH;
float distanceXZ = sqrtf( worldX*worldX + worldZ*worldZ );
if ( distanceXZ > FADE_MAX_XZ_DISTANCE )
{
fade = 0.0f;
}
else if ( distanceXZ > FADE_START_XZ_DISTANCE )
{
fade = 1.0 - (distanceXZ - FADE_START_XZ_DISTANCE)/(FADE_MAX_XZ_DISTANCE - FADE_START_XZ_DISTANCE);
}
}
if ( //mbRecording
0 != value && fade > 0.0
&& ( SHOW_BACKGROUND || label != 0 ) )
{
float worldZ = (float)(*pDepth)/1000.0; // Convert from mm to m
float worldX = (((float)(x-halfWidth)/1000.0)*worldZ) / FOCAL_LENGTH;
float worldY = (((float)(y-halfHeight)/1000.0)*worldZ) / FOCAL_LENGTH;
//float worldY = (((float)(((height-1)-y)-halfHeight)/1000.0)*worldZ) / FOCAL_LENGTH;
float histValue = (float)depthHist[ value ]/255.0;
pPoints[ pointIdx ].setColor(
fade * histValue * COLOURS[ colorId ][ 0 ],
fade * histValue * COLOURS[ colorId ][ 1 ],
fade * histValue * COLOURS[ colorId ][ 2 ] );
pPoints[ pointIdx ].x = worldX;
pPoints[ pointIdx ].y = worldY;
pPoints[ pointIdx ].z = worldZ;
pointIdx++;
if ( mbRecording && label != 0
&& x%recordingPixelStepX == 0 && y%recordingPixelStepY == 0 )
{
int32_t smallFrameX = x / recordingPixelStepX;
int32_t smallFrameY = y / recordingPixelStepY;
int32_t smallPixelIdx = mRecordingFrameIdx*SMALL_FRAME_WIDTH*SMALL_FRAME_HEIGHT
+ smallFrameY*SMALL_FRAME_WIDTH + smallFrameX;
//((uint16_t*)mpImageData)[ smallPixelIdx ] = 0xFFFF;
//((uint32_t*)mpImageData)[ smallPixelIdx ] = 0xFFFFFFFF;
mpImageData[ smallPixelIdx ] = 0xFF; // 255; //(uint8_t)(fade * histValue * 255.0);
//printf( "recorded %i to pixel %i\n", mpImageData[ smallPixelIdx ], smallPixelIdx );
}
}
pDepth++;
pLabels++;
}
}
mpRosPointCloud->addPoints( pPoints, pointIdx );
//printf( "Added %i points\n", pointIdx );
delete [] pPoints;
// Draw the crowd
uint32_t numCrowdMembers = mCrowdMembers.size();
mpCrowdObject->clear();
mpCrowdObject->estimateVertexCount( numCrowdMembers*4 );
mpCrowdObject->estimateIndexCount( numCrowdMembers*12 );
for ( uint32_t personIdx = 0; personIdx < numCrowdMembers; personIdx++ )
{
CrowdMember& crowdMember = mCrowdMembers[ personIdx ];
float startV = (float)crowdMember.mFrameIdx/(float)NUM_FRAMES_TO_RECORD;
float endV = (float)(crowdMember.mFrameIdx+1)/(float)NUM_FRAMES_TO_RECORD;
mpCrowdObject->begin( crowdMember.mMaterialName, Ogre::RenderOperation::OT_TRIANGLE_LIST );
//float startV = 0.0; //(float)crowdMember.mFrameIdx/(float)NUM_FRAMES_TO_RECORD;
//float endV = 1.0;// (float)(crowdMember.mFrameIdx+1)/(float)NUM_FRAMES_TO_RECORD;
//mpCrowdObject->begin( "Template/CutOut", Ogre::RenderOperation::OT_TRIANGLE_LIST );
mpCrowdObject->position( crowdMember.mPos + Ogre::Vector3( -0.5f, -0.375f, 0.0f ) );
mpCrowdObject->textureCoord( 0.0, startV );
mpCrowdObject->colour( COLOURS[ crowdMember.mColourIdx ][ 0 ],
COLOURS[ crowdMember.mColourIdx ][ 1 ], COLOURS[ crowdMember.mColourIdx ][ 2 ], 1.0 );
mpCrowdObject->position( crowdMember.mPos + Ogre::Vector3( 0.5f, -0.375f, 0.0f ) );
mpCrowdObject->textureCoord( 1.0, startV );
mpCrowdObject->position( crowdMember.mPos + Ogre::Vector3( 0.5f, 0.375f, 0.0f ) );
mpCrowdObject->textureCoord( 1.0, endV );
mpCrowdObject->position( crowdMember.mPos + Ogre::Vector3( -0.5f, 0.375f, 0.0f ) );
mpCrowdObject->textureCoord( 0.0, endV );
//mpCrowdObject->quad( 0, 1, 2, 3 );
mpCrowdObject->quad( 3, 2, 1, 0 );
mpCrowdObject->end();
// Move to the next frame
if ( crowdMember.mbReversing )
{
crowdMember.mFrameIdx--;
if ( crowdMember.mFrameIdx < 0 )
{
crowdMember.mFrameIdx = 1;
crowdMember.mbReversing = false;
}
}
else
{
crowdMember.mFrameIdx++;
if ( crowdMember.mFrameIdx >= NUM_FRAMES_TO_RECORD )
{
crowdMember.mFrameIdx = NUM_FRAMES_TO_RECORD-1;
crowdMember.mbReversing = true;
}
}
}
// Check to see if we can stop recording
if ( mbRecording )
{
mRecordingFrameIdx++;
if ( mRecordingFrameIdx >= NUM_FRAMES_TO_RECORD )
{
// Create a new crowd member
Ogre::Image image;
image.loadDynamicImage(
mpImageData, SMALL_FRAME_WIDTH, NUM_FRAMES_TO_RECORD*SMALL_FRAME_HEIGHT, 1, Ogre::PF_A4L4 );
std::stringstream ss;
ss << "RecordedSequenceTex_" << numCrowdMembers;
Ogre::String texName = ss.str();
Ogre::TextureManager* pTextureMgr = Ogre::TextureManager::getSingletonPtr();
Ogre::TexturePtr pTexture = pTextureMgr->loadImage( texName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, image );
ss.clear();
ss << "RecordedSequenceMat_" << numCrowdMembers;
Ogre::String matName = ss.str();
Ogre::MaterialManager* pMatMgr = Ogre::MaterialManager::getSingletonPtr();
Ogre::MaterialPtr pSrcMat = (Ogre::MaterialPtr)pMatMgr->getByName( "Template/CutOut", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
Ogre::MaterialPtr pMat = pSrcMat->clone( matName ); // (Ogre::MaterialPtr)pMatMgr->create( matName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
pMat->getTechnique( 0 )->getPass( 0 )->removeAllTextureUnitStates();
Ogre::TextureUnitState* pTex = pMat->getTechnique( 0 )->getPass( 0 )->createTextureUnitState( texName, 0 );
pMat->getTechnique( 0 )->getPass( 0 )->addTextureUnitState( pTex );
/*Ogre::Technique* pTech = pMat->getTechnique( 0 );
pTech->setSceneBlending( Ogre::SBT_TRANSPARENT_ALPHA );
Ogre::Pass *pPass = pTech->createPass();
pPass->setLightingEnabled( false );
pPass->setAmbient( 1.0, 1.0, 1.0 );
pPass->setDiffuse( 1.0, 1.0, 1.0, 1.0 );
pPass->setSpecular( 0.0, 0.0, 0.0, 0.0 );
Ogre::ColourValue val(0.0f, 0.0f, 0.0f, 1.0f);
pPass->setSelfIllumination(val);
//pPass->setE ( 0.0, 0.0, 0.0, 0.0 );
pPass->setSceneBlending( Ogre::SBT_TRANSPARENT_ALPHA );
pPass->setDepthWriteEnabled( false );
Ogre::TextureUnitState* pTex = pPass->createTextureUnitState( texName, 0 );
pPass->addTextureUnitState( pTex );
pTex->setColourOperation( Ogre::LBO_MODULATE );*/
pMat->setCullingMode( Ogre::CULL_NONE );
pMat->compile();
CrowdMember crowdMember;
crowdMember.mMaterialName = matName;
crowdMember.mFrameIdx = 0;
crowdMember.mColourIdx = rand()%NUM_COLOURS;
crowdMember.mbReversing = false;
int32_t rowIdx = rand()%NUM_ROWS;
float angle = MIN_CROWD_ANGLE + ((float)rand()/(float)RAND_MAX)*(MAX_CROWD_ANGLE-MIN_CROWD_ANGLE);
float x = ROW_DEPTHS[ rowIdx ]*sin( angle );
float z = ROW_DEPTHS[ rowIdx ]*cos( angle );
crowdMember.mPos = Ogre::Vector3( x, ROW_HEIGHTS[ rowIdx ], z );
mCrowdMembers.push_back( crowdMember );
mbRecording = false;
mRecordingGapTimer.reset(); // Reset time so that there's a gap between recording
printf( "Got frame\n" );
}
}
return true;
}
/*!
* Starts the main event loop. This function does not return, unless the
* application is supposed to quit - either by closing the rendering window or
* by telling the \ref InputHandler to quit (see \ref InputHandler::queueQuit).
*/
void TestApp::startEventLoop()
{
// try {
Ogre::Timer timer;
unsigned long lastFrameStarted = timer.getMilliseconds();
mFrameCount = 0;
#ifdef USE_CALLGRIND
CALLGRIND_START_INSTRUMENTATION;
CALLGRIND_TOGGLE_COLLECT; // switch collect off
#endif
while (!mInputHandler->getWantQuit() && (!mRenderWindow->isClosed() || !mUseGUI))
{
mFrameHistory->startFrame();
// emulate Ogre's timeSinceLastFrame feature
unsigned long now = timer.getMilliseconds();
float timeSinceLastFrame = ((float)(now - lastFrameStarted)) / 1000.0f;
lastFrameStarted = now;
mInputHandler->captureInput(timeSinceLastFrame);
Ogre::WindowEventUtilities::messagePump();
// AB: note: a "scene frame" is not necessarily a "graphic frame".
// -> the collision detection library may be called more often or less
// often than ogre.
// usually we should NOT couple the scene speed to the rendering
// speed, otherwise the scene will be VERY fast with a newer graphic
// card
//
// we do this here atm for the sake of simplicity only. we really
// should use a timer instead.
if (!mInputHandler->getPause() )
{
if (!mInputHandler->isChecked("PauseMovements"))
{
mSceneUpdateHistory->startFrame();
mScene->beginNextSceneFrame();
}
mSceneUpdateHistory->stopFrame();
}
if (mUseGUI)
{
if (!mGui->updateGui(mInputHandler->getPause()))
{
mInputHandler->queueQuit();
}
mGraphicFrameHistory->startFrame();
mOgreRoot->renderOneFrame();
mGraphicFrameHistory->stopFrame();
}
mFrameHistory->stopFrame();
mFrameCount++;
if (mMaxFrameCount > 0 && mFrameCount >= mMaxFrameCount)
{
mInputHandler->queueQuit();
}
}
//} catch (Exception e) {
// std::cerr << "Unhandled exception reached main-program: \n"
// << e.getErrorMessage() <<std::endl;
// e.printBacktrace();
// exit(1);
//}
}
void World::processInput()
{
using namespace OIS;
static Ogre::Timer timer;
static unsigned long lastTime = 0;
unsigned long currentTime = timer.getMilliseconds();
//Calculate the amount of time passed since the last frame
Real timeScale = (currentTime - lastTime) * 0.001f;
if (timeScale < 0.001f)
timeScale = 0.001f;
lastTime = currentTime;
//Get the current state of the keyboard and mouse
keyboard->capture();
mouse->capture();
//Always exit if ESC is pressed
if (keyboard->isKeyDown(OIS::KC_ESCAPE))
running = false;
//Reload the scene if R is pressed
static bool reloadedLast = false;
if (keyboard->isKeyDown(OIS::KC_R) && !reloadedLast){
unload();
load();
reloadedLast = true;
}
else {
reloadedLast = false;
}
//Get mouse movement
const OIS::MouseState &ms = mouse->getMouseState();
//Update camera rotation based on the mouse
camYaw += Radian(-ms.X.rel / 200.0f);
camPitch += Radian(-ms.Y.rel / 200.0f);
camera->setOrientation(Quaternion::IDENTITY);
camera->pitch(camPitch);
camera->yaw(camYaw);
//Allow the camera to move around with the arrow/WASD keys
Ogre::Vector3 trans(0, 0, 0);
if (keyboard->isKeyDown(KC_UP) || keyboard->isKeyDown(KC_W))
trans.z = -1;
if (keyboard->isKeyDown(KC_DOWN) || keyboard->isKeyDown(KC_S))
trans.z = 1;
if (keyboard->isKeyDown(KC_RIGHT) || keyboard->isKeyDown(KC_D))
trans.x = 1;
if (keyboard->isKeyDown(KC_LEFT) || keyboard->isKeyDown(KC_A))
trans.x = -1;
if (keyboard->isKeyDown(KC_PGUP) || keyboard->isKeyDown(KC_E))
trans.y = 1;
if (keyboard->isKeyDown(KC_PGDOWN) || keyboard->isKeyDown(KC_Q))
trans.y = -1;
//Shift = speed boost
if (keyboard->isKeyDown(KC_LSHIFT) || keyboard->isKeyDown(KC_RSHIFT))
trans *= 4;
else
trans *= 0.5f;
trans *= 30;
camera->moveRelative(trans * timeScale);
//Make sure the camera doesn't go under the terrain
Ogre::Vector3 camPos = camera->getPosition();
float terrY = HeightFunction::getTerrainHeight(camPos.x, camPos.z);
if (camPos.y < terrY + 1.5 || !keyboard->isKeyDown(KC_SPACE)){ //Space = walk
camPos.y = terrY + 1.5;
camera->setPosition(camPos);
}
}
//----------------------------------------------------------------------------------------------------------------------------------
/// Load (.car file)
//----------------------------------------------------------------------------------------------------------------------------------
bool CARDYNAMICS::Load(GAME* game, CONFIGFILE & c, ostream & error_output)
{
pGame = game;
Ogre::Timer ti;
//bTerrain = false;
string drive = "RWD";
int version(1);
c.GetParam("version", version);
if (version > 2)
{
error_output << "Unsupported car version: " << version << endl;
return false;
}
float temp_vec3[3];
//load the engine
{
float mass, rpm_limit, inertia, friction,
start_rpm, stall_rpm, fuel_consumption;
MATHVECTOR<double,3> position;
if (!c.GetParam("engine.rpm-limit", rpm_limit, error_output)) return false;
engine.SetRpmMax(rpm_limit);
if (!c.GetParam("engine.inertia", inertia, error_output)) return false;
engine.SetInertia(inertia);
if (!c.GetParam("engine.friction", friction, error_output)) return false;
engine.SetFrictionB(friction);
if (!c.GetParam("engine.start-rpm", start_rpm, error_output)) return false;
engine.SetStartRPM(start_rpm);
if (!c.GetParam("engine.stall-rpm", stall_rpm, error_output)) return false;
engine.SetStallRPM(stall_rpm);
if (!c.GetParam("engine.fuel-consumption", fuel_consumption, error_output)) return false;
engine.SetFuelConsumption(fuel_consumption);
if (!c.GetParam("engine.mass", mass, error_output)) return false;
if (!c.GetParam("engine.position", temp_vec3, error_output)) return false;
if (version == 2) ConvertV2to1(temp_vec3[0],temp_vec3[1],temp_vec3[2]);
position.Set(temp_vec3[0],temp_vec3[1],temp_vec3[2]);
engine.SetMass(mass);
engine.SetPosition(position);
AddMassParticle(mass, position);
float mul = 1.f, max_torque = 0;
c.GetParam("engine.torque-val-mul", mul);
float torque_point[3];
string torque_str("engine.torque-curve-00");
vector <pair <double, double> > torques;
int curve_num = 0;
while (c.GetParam(torque_str, torque_point))
{
max_torque = max(max_torque, torque_point[1] * mul);
torques.push_back(pair <float, float> (torque_point[0], torque_point[1] * mul));
curve_num++;
stringstream str;
str << "engine.torque-curve-"; str.width(2); str.fill('0');
str << curve_num;
torque_str = str.str();
}
if (torques.size() <= 1)
{
error_output << "You must define at least 2 torque curve points." << endl;
return false;
}
engine.SetTorqueCurve(rpm_limit, torques);
//load the clutch
{
float mul; //max_torque = sliding * radius * area * max_pressure;
//if (!c.GetParam("clutch.max-torque", max_torque, error_output)) return false;
if (!c.GetParam("clutch.max-torque-mul", mul, error_output)) return false;
clutch.SetMaxTorque(max_torque * mul);
}
// factor for stats -
mul = 1.f;
if (c.GetParam("engine.real-pow-tq-mul", mul))
engine.real_pow_tq_mul = mul;
mul = 1.f;
if (c.GetParam("engine.sound-vol-mul", mul))
engine_vol_mul = mul;
}
//load the transmission
{
float time = 0;
float ratio;
int gears;
c.GetParam("transmission.shift-delay", time);
shift_time = time;
if (!c.GetParam("transmission.gear-ratio-r", ratio, error_output)) return false;
transmission.SetGearRatio(-1, ratio);
if (!c.GetParam("transmission.gears", gears, error_output)) return false;
for (int i = 0; i < gears; i++)
{
stringstream s;
s << "transmission.gear-ratio-" << i+1;
if (!c.GetParam(s.str(), ratio, error_output)) return false;
transmission.SetGearRatio(i+1, ratio);
}
}
//load the differential(s)
string drivetype;
if (!c.GetParam("drive", drivetype, error_output)) return false;
if (drivetype == "hover") //>
{ hover = true; drivetype = "AWD"; }
else if (drivetype == "sphere")
{ sphere = true; drivetype = "AWD"; }
//if (!hover)
SetDrive(drivetype);
float final_drive, a, a_tq(0), a_tq_dec(0);
/// new 3 sets
if (drivetype == "AWD" &&
c.GetParam("diff-center.final-drive", a))
{
c.GetParam("diff-rear.anti-slip", a, error_output);
c.GetParam("diff-rear.torque", a_tq);
c.GetParam("diff-rear.torque-dec", a_tq_dec);
diff_rear.SetFinalDrive(1.0);
diff_rear.SetAntiSlip(a, a_tq, a_tq_dec);
c.GetParam("diff-front.anti-slip", a, error_output);
c.GetParam("diff-front.torque", a_tq);
c.GetParam("diff-front.torque-dec", a_tq_dec);
diff_front.SetFinalDrive(1.0);
diff_front.SetAntiSlip(a, a_tq, a_tq_dec);
c.GetParam("diff-center.final-drive", final_drive, error_output);
c.GetParam("diff-center.anti-slip", a, error_output);
c.GetParam("diff-center.torque", a_tq);
c.GetParam("diff-center.torque-dec", a_tq_dec);
diff_center.SetFinalDrive(final_drive);
diff_center.SetAntiSlip(a, a_tq, a_tq_dec);
}
else // old 1 for all
{
if (!c.GetParam("differential.final-drive", final_drive, error_output)) return false;
if (!c.GetParam("differential.anti-slip", a, error_output)) return false;
c.GetParam("differential.torque", a_tq);
c.GetParam("differential.torque-dec", a_tq_dec);
if (drivetype == "RWD")
{
diff_rear.SetFinalDrive(final_drive);
diff_rear.SetAntiSlip(a, a_tq, a_tq_dec);
}
else if (drivetype == "FWD")
{
diff_front.SetFinalDrive(final_drive);
diff_front.SetAntiSlip(a, a_tq, a_tq_dec);
}
else if (drivetype == "AWD")
{
diff_rear.SetFinalDrive(1.0);
diff_rear.SetAntiSlip(a, a_tq, a_tq_dec);
diff_front.SetFinalDrive(1.0);
diff_front.SetAntiSlip(a, a_tq, a_tq_dec);
diff_center.SetFinalDrive(final_drive);
diff_center.SetAntiSlip(a, a_tq, a_tq_dec);
}else
{ error_output << "Unknown drive type: " << drive << endl;
return false;
}
}
//load the brake
{
for (int i = 0; i < 2; i++)
{
string pos = "front";
WHEEL_POSITION left = FRONT_LEFT;
WHEEL_POSITION right = FRONT_RIGHT;
if (i == 1)
{
left = REAR_LEFT;
right = REAR_RIGHT;
pos = "rear";
}
float friction, max_pressure, area, bias, radius, handbrake(0);
if (!c.GetParam("brakes-"+pos+".friction", friction, error_output)) return false;
brake[left].SetFriction(friction);
brake[right].SetFriction(friction);
if (!c.GetParam("brakes-"+pos+".area", area, error_output)) return false;
brake[left].SetArea(area);
brake[right].SetArea(area);
if (!c.GetParam("brakes-"+pos+".radius", radius, error_output)) return false;
brake[left].SetRadius(radius);
brake[right].SetRadius(radius);
c.GetParam("brakes-"+pos+".handbrake", handbrake);
brake[left].SetHandbrake(handbrake);
brake[right].SetHandbrake(handbrake);
if (!c.GetParam("brakes-"+pos+".bias", bias, error_output)) return false;
brake[left].SetBias(bias);
brake[right].SetBias(bias);
if (!c.GetParam("brakes-"+pos+".max-pressure", max_pressure, error_output)) return false;
brake[left].SetMaxPressure(max_pressure*bias);
brake[right].SetMaxPressure(max_pressure*bias);
}
}
//load the fuel tank
{
float pos[3];
MATHVECTOR<double,3> position;
float capacity, volume, fuel_density;
if (!c.GetParam("fuel-tank.capacity", capacity, error_output)) return false;
fuel_tank.SetCapacity(capacity);
if (!c.GetParam("fuel-tank.volume", volume, error_output)) return false;
fuel_tank.SetVolume(volume);
if (!c.GetParam("fuel-tank.fuel-density", fuel_density, error_output)) return false;
fuel_tank.SetDensity(fuel_density);
if (!c.GetParam("fuel-tank.position", pos, error_output)) return false;
if (version == 2) ConvertV2to1(pos[0],pos[1],pos[2]);
position.Set(pos[0],pos[1],pos[2]);
fuel_tank.SetPosition(position);
//AddMassParticle(fuel_density*volume, position);
}
//load the suspension
{
for (int i = 0; i < 2; i++)
{
string posstr = "front";
string posshortstr = "F";
WHEEL_POSITION posl = FRONT_LEFT;
WHEEL_POSITION posr = FRONT_RIGHT;
if (i == 1)
{
posstr = "rear";
posshortstr = "R";
posl = REAR_LEFT;
posr = REAR_RIGHT;
}
float spring_constant, bounce, rebound, travel, camber, caster, toe, anti_roll;//, maxcompvel;
float hinge[3];
MATHVECTOR<double,3> tempvec;
if (!c.GetParam("suspension-"+posstr+".spring-constant", spring_constant, error_output)) return false;
suspension[posl].SetSpringConstant(spring_constant);
suspension[posr].SetSpringConstant(spring_constant);
if (!c.GetParam("suspension-"+posstr+".bounce", bounce, error_output)) return false;
suspension[posl].SetBounce(bounce);
suspension[posr].SetBounce(bounce);
if (!c.GetParam("suspension-"+posstr+".rebound", rebound, error_output)) return false;
suspension[posl].SetRebound(rebound);
suspension[posr].SetRebound(rebound);
string file;
if (c.GetParam("suspension-"+posstr+".factors-file", file))
{
int id = game->suspS_map[file]-1;
if (id == -1) { id = 0;
error_output << "Can't find suspension spring factors file: " << file << endl; }
suspension[posl].SetSpringFactorPoints(game->suspS[id]);
suspension[posr].SetSpringFactorPoints(game->suspS[id]);
id = game->suspD_map[file]-1;
if (id == -1) { id = 0;
error_output << "Can't find suspension damper factors file: " << file << endl; }
suspension[posl].SetDamperFactorPoints(game->suspD[id]);
suspension[posr].SetDamperFactorPoints(game->suspD[id]);
}else
{ // factor points
vector <pair <double, double> > damper, spring;
c.GetPoints("suspension-"+posstr, "damper-factor", damper);
suspension[posl].SetDamperFactorPoints(damper);
suspension[posr].SetDamperFactorPoints(damper);
c.GetPoints("suspension-"+posstr, "spring-factor", spring);
suspension[posl].SetSpringFactorPoints(spring);
suspension[posr].SetSpringFactorPoints(spring);
}
if (!c.GetParam("suspension-"+posstr+".travel", travel, error_output)) return false;
suspension[posl].SetTravel(travel);
suspension[posr].SetTravel(travel);
if (!c.GetParam("suspension-"+posstr+".camber", camber, error_output)) return false;
suspension[posl].SetCamber(camber);
suspension[posr].SetCamber(camber);
if (!c.GetParam("suspension-"+posstr+".caster", caster, error_output)) return false;
suspension[posl].SetCaster(caster);
suspension[posr].SetCaster(caster);
if (!c.GetParam("suspension-"+posstr+".toe", toe, error_output)) return false;
suspension[posl].SetToe(toe);
suspension[posr].SetToe(toe);
if (!c.GetParam("suspension-"+posstr+".anti-roll", anti_roll, error_output)) return false;
suspension[posl].SetAntiRollK(anti_roll);
suspension[posr].SetAntiRollK(anti_roll);
if (!c.GetParam("suspension-"+posshortstr+"L.hinge", hinge, error_output)) return false;
//cap hinge to reasonable values
for (int i = 0; i < 3; i++)
{
if (hinge[i] < -100) hinge[i] = -100;
if (hinge[i] > 100) hinge[i] = 100;
}
if (version == 2) ConvertV2to1(hinge[0],hinge[1],hinge[2]);
tempvec.Set(hinge[0],hinge[1], hinge[2]);
suspension[posl].SetHinge(tempvec);
if (!c.GetParam("suspension-"+posshortstr+"R.hinge", hinge, error_output)) return false;
for (int i = 0; i < 3; i++)
{
if (hinge[i] < -100) hinge[i] = -100;
if (hinge[i] > 100) hinge[i] = 100;
}
if (version == 2) ConvertV2to1(hinge[0],hinge[1],hinge[2]);
tempvec.Set(hinge[0],hinge[1], hinge[2]);
suspension[posr].SetHinge(tempvec);
}
}
//load the wheels
{
for (int i = 0; i < 4; i++)
{
string sPos;
WHEEL_POSITION wp;
if (i == 0) { sPos = "FL"; wp = FRONT_LEFT; }
else if (i == 1){ sPos = "FR"; wp = FRONT_RIGHT; }
else if (i == 2){ sPos = "RL"; wp = REAR_LEFT; }
else { sPos = "RR"; wp = REAR_RIGHT; }
float roll_h, mass;
float pos[3];
MATHVECTOR<double,3> vec;
if (!c.GetParam("wheel-"+sPos+".mass", mass, error_output)) return false;
wheel[wp].SetMass(mass);
if (!c.GetParam("wheel-"+sPos+".roll-height", roll_h, error_output)) return false;
wheel[wp].SetRollHeight(roll_h);
if (!c.GetParam("wheel-"+sPos+".position", pos, error_output)) return false;
if (version == 2) ConvertV2to1(pos[0],pos[1],pos[2]);
vec.Set(pos[0],pos[1], pos[2]);
wheel[wp].SetExtendedPosition(vec);
AddMassParticle(mass, vec);
}
//load the rotational inertia parameter from the tire section
float front_inertia;
float rear_inertia;
if (c.GetParam("tire-both.rotational-inertia", front_inertia, error_output))
rear_inertia = front_inertia;
else
{ if (!c.GetParam("tire-front.rotational-inertia", front_inertia, error_output)) return false;
if (!c.GetParam("tire-rear.rotational-inertia", rear_inertia, error_output)) return false;
}
wheel[FRONT_LEFT].SetInertia(front_inertia);
wheel[FRONT_RIGHT].SetInertia(front_inertia);
wheel[REAR_LEFT].SetInertia(rear_inertia);
wheel[REAR_RIGHT].SetInertia(rear_inertia);
}
//load the tire parameters
{
WHEEL_POSITION leftside = FRONT_LEFT;
WHEEL_POSITION rightside = FRONT_RIGHT;
float value;
bool both = c.GetParam("tire-both.radius", value);
string posstr = both ? "both" : "front";
for (int p = 0; p < 2; ++p)
{
if (p == 1)
{
leftside = REAR_LEFT;
rightside = REAR_RIGHT;
if (!both) posstr = "rear";
}
float rolling_resistance[3];
if (!c.GetParam("tire-"+posstr+".rolling-resistance", rolling_resistance, error_output)) return false;
wheel[leftside].SetRollingResistance(rolling_resistance[0], rolling_resistance[1]);
wheel[rightside].SetRollingResistance(rolling_resistance[0], rolling_resistance[1]);
float radius;
if (!c.GetParam("tire-"+posstr+".radius", radius, error_output)) return false;
wheel[leftside].SetRadius(radius);
wheel[rightside].SetRadius(radius);
}
}
//load the mass-only particles
{
MATHVECTOR<double,3> position;
float pos[3], mass;
if (c.GetParam("contact-points.mass", mass))
{
int paramnum(0);
string paramname("contact-points.position-00");
stringstream output_supression;
while (c.GetParam(paramname, pos))
{
if (version == 2) ConvertV2to1(pos[0],pos[1],pos[2]);
position.Set(pos[0],pos[1],pos[2]);
AddMassParticle(mass, position);
paramnum++;
stringstream str;
str << "contact-points.position-"; str.width(2); str.fill('0');
str << paramnum;
paramname = str.str();
}
}
string paramname = "particle-00";
int paramnum = 0;
while (c.GetParam(paramname+".mass", mass))
{
if (!c.GetParam(paramname+".position", pos, error_output)) return false;
if (version == 2) ConvertV2to1(pos[0],pos[1],pos[2]);
position.Set(pos[0],pos[1],pos[2]);
AddMassParticle(mass, position);
paramnum++;
stringstream str;
str << "particle-"; str.width(2); str.fill('0');
str << paramnum;
paramname = str.str();
}
}
//load the max steering angle
{
float maxangle = 26.f;
if (!c.GetParam("steering.max-angle", maxangle, error_output)) return false;
SetMaxSteeringAngle( maxangle );
float a = 1.f;
c.GetParam("steering.flip-pow-mul", a); flip_mul = a;
}
///car angular damping -new
{
float a = 0.4f;
c.GetParam("steering.angular-damping", a, error_output);
SetAngDamp(a);
a=0.f; c.GetParam("rot_drag.roll", a); rot_coef[0] = a;
a=0.f; c.GetParam("rot_drag.pitch", a); rot_coef[1] = a;
a=0.f; c.GetParam("rot_drag.yaw", a); rot_coef[2] = a;
a=0.f; c.GetParam("rot_drag.yaw2", a); rot_coef[3] = a;
}
//load the driver
{
float mass;
float pos[3];
MATHVECTOR<double,3> position;
if (!c.GetParam("driver.mass", mass, error_output)) return false;
if (!c.GetParam("driver.position", pos, error_output)) return false;
if (version == 2) ConvertV2to1(pos[0],pos[1],pos[2]);
position.Set(pos[0], pos[1], pos[2]);
AddMassParticle(mass, position);
}
//load the aerodynamics
{
float drag_area, drag_c, lift_area, lift_c, lift_eff;
float pos[3];
MATHVECTOR<double,3> position;
if (!c.GetParam("drag.frontal-area", drag_area, error_output)) return false;
if (!c.GetParam("drag.drag-coefficient", drag_c, error_output)) return false;
if (!c.GetParam("drag.position", pos, error_output)) return false;
if (version == 2) ConvertV2to1(pos[0],pos[1],pos[2]);
position.Set(pos[0], pos[1], pos[2]);
AddAerodynamicDevice(position, drag_area, drag_c, 0,0,0);
for (int i = 0; i < 2; i++)
{
string wingpos = "front";
if (i == 1)
wingpos = "rear";
if (!c.GetParam("wing-"+wingpos+".frontal-area", drag_area, error_output)) return false;
if (!c.GetParam("wing-"+wingpos+".drag-coefficient", drag_c, error_output)) return false;
if (!c.GetParam("wing-"+wingpos+".surface-area", lift_area, error_output)) return false;
if (!c.GetParam("wing-"+wingpos+".lift-coefficient", lift_c, error_output)) return false;
if (!c.GetParam("wing-"+wingpos+".efficiency", lift_eff, error_output)) return false;
if (!c.GetParam("wing-"+wingpos+".position", pos, error_output)) return false;
if (version == 2) ConvertV2to1(pos[0],pos[1],pos[2]);
position.Set(pos[0], pos[1], pos[2]);
AddAerodynamicDevice(position, drag_area, drag_c, lift_area, lift_c, lift_eff);
}
}
// hover params
if (hover || sphere)
{
c.GetParam("hover.hAbove", hov.hAbove); c.GetParam("hover.hRayLen", hov.hRayLen);
c.GetParam("hover.steerForce", hov.steerForce);
c.GetParam("hover.steerDamp", hov.steerDamp); c.GetParam("hover.steerDampP", hov.steerDampP);
c.GetParam("hover.engineForce", hov.engineForce); c.GetParam("hover.engineVelDec", hov.engineVelDec);
c.GetParam("hover.brakeForce", hov.brakeForce);
c.GetParam("hover.dampAirRes", hov.dampAirRes); c.GetParam("hover.dampSide", hov.dampSide);
c.GetParam("hover.dampUp", hov.dampUp); c.GetParam("hover.dampDn", hov.dampDn);
c.GetParam("hover.dampPmul", hov.dampPmul);
float al[3];
c.GetParam("hover.alignTqP", al); hov.alp.Set(al[0],al[1],al[2]);
c.GetParam("hover.alignTq", al); hov.alt.Set(al[0],al[1],al[2]);
c.GetParam("hover.pitchTq", hov.pitchTq);
c.GetParam("hover.rollTq", hov.rollTq); c.GetParam("hover.roll", hov.roll);
c.GetParam("hover_h.hov_vz", hov.hov_vz); c.GetParam("hover_h.hov_vsat", hov.hov_vsat);
c.GetParam("hover_h.hov_dsat", hov.hov_dsat);
c.GetParam("hover_h.hov_dampP",hov.hov_dampP); c.GetParam("hover_h.hov_damp", hov.hov_damp);
c.GetParam("hover_h.hov_fall", hov.hov_fall);
c.GetParam("hover_h.hov_riseP",hov.hov_riseP); c.GetParam("hover_h.hov_rise", hov.hov_rise);
}
UpdateMass();
LogO(Ogre::String(":::: Time car dynamics load: ") + fToStr(ti.getMilliseconds(),0,3) + " ms");
return true;
}