Dogcows Code - chaz/yoink/blob - src/Moof/Engine.cc

   1
   2 /*******************************************************************************
   3
   4  Copyright (c) 2009, Charles McGarvey
   5  All rights reserved.
   6
   7  Redistribution   and   use  in  source  and  binary  forms,  with  or  without
   8  modification, are permitted provided that the following conditions are met:
   9
  10    * Redistributions  of  source  code  must retain the above copyright notice,
  11      this list of conditions and the following disclaimer.
  12    * Redistributions  in binary form must reproduce the above copyright notice,
  13      this  list of conditions and the following disclaimer in the documentation
  14      and/or other materials provided with the distribution.
  15
  16  THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  AND  ANY  EXPRESS  OR  IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  DISCLAIMED.  IN  NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  20  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  DAMAGES  (INCLUDING,  BUT  NOT  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22  SERVICES;  LOSS  OF  USE,  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23  CAUSED  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24  OR  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26
  27 *******************************************************************************/
  28
  29 #include <cstdlib>                      // exit
  30 #include <iostream>
  31 #include <string>
  32
  33 #include <SDL/SDL.h>
  34 #include "fastevents.h"
  35 #include <SDL/SDL_sound.h>
  36 #include <AL/alut.h>
  37
  38 #include "Dispatcher.hh"
  39 #include "Engine.hh"
  40 #include "Random.hh"
  41 #include "Settings.hh"
  42 #include "Timer.hh"
  43 #include "Video.hh"
  44
  45
  46 namespace Mf {
  47
  48
  49 class Engine::Impl
  50 {
  51 public:
  52         Impl(int argc, char* argv[], const std::string& configFile,
  53                         const std::string& name, const std::string& iconFile,
  54                         Engine* outer) :
  55                 interface(outer),
  56                 settings(argc, argv)
  57         {
  58                 if (SDL_Init(SDL_INIT_EVERYTHING | SDL_INIT_EVENTTHREAD) != 0)
  59                 {
  60                         throw Exception(SDL_GetError());
  61                 }
  62                 if (FE_Init() != 0)
  63                 {
  64                         throw Exception(FE_GetError());
  65                 }
  66                 if (Sound_Init() != 0)
  67                 {
  68                         //throw Exception(Sound_GetError());
  69                         std::cerr << Sound_GetError() << std::endl;
  70                 }
  71                 alutInit(&argc, argv);
  72
  73                 settings.loadFromFile(configFile);
  74
  75                 long randomSeed;
  76                 if (settings.get("engine.rngseed", randomSeed)) setSeed(randomSeed);
  77                 else setSeed();
  78
  79                 double ts = 0.01;
  80                 settings.get("engine.timestep", ts);
  81                 timestep = Scalar(ts);
  82
  83                 long maxFps = 40;
  84                 settings.getNumber("video.maxfps", maxFps);
  85                 drawRate = 1.0 / Scalar(maxFps);
  86
  87                 printFps = false;
  88                 settings.get("video.printfps", printFps);
  89
  90                 video = VideoPtr(new Video(name, iconFile));
  91                 video->makeActive();
  92         }
  93
  94         ~Impl()
  95         {
  96                 // the video object must be destroyed before we can shutdown SDL
  97                 video.reset();
  98
  99                 alutExit();
 100                 Sound_Quit();
 101                 FE_Quit();
 102                 SDL_Quit();
 103         }
 104
 105
 106         /**
 107          * The main loop.  This just calls dispatchEvents(), update(), and draw()
 108          * over and over again.  The timing of the update and draw are decoupled.
 109          * The actual frame rate is also calculated here.  This function will return
 110          * the exit code used to stop the loop.
 111          */
 112
 113         int run()
 114         {
 115                 Scalar ticksNow = getTicks();
 116
 117                 Scalar nextStep = ticksNow;
 118                 Scalar nextDraw = ticksNow;
 119                 Scalar nextFpsUpdate = ticksNow + 1.0;
 120
 121                 Scalar totalTime = 0.0;
 122                 Scalar deltaTime = 0.0;
 123                 Scalar accumulator = timestep;
 124
 125                 fps = 0;
 126                 int frameAccum = 0;
 127
 128                 running = true;
 129                 do
 130                 {
 131                         Scalar newTicks = getTicks();
 132                         deltaTime = newTicks - ticksNow;
 133                         ticksNow = newTicks;
 134
 135                         if (deltaTime >= 0.25) deltaTime = 0.25;
 136                         accumulator += deltaTime;
 137
 138                         while (accumulator >= timestep)
 139                         {
 140                                 dispatchEvents();
 141                                 interface->update(totalTime, timestep);
 142
 143                                 totalTime += timestep;
 144                                 accumulator -= timestep;
 145
 146                                 nextStep += timestep;
 147                         }
 148                         if (ticksNow >= nextStep)
 149                         {
 150                                 nextStep = ticksNow + timestep;
 151                         }
 152
 153                         if (ticksNow >= nextDraw)
 154                         {
 155                                 frameAccum++;
 156
 157                                 if (ticksNow >= nextFpsUpdate) // determine the actual fps
 158                                 {
 159                                         fps = frameAccum;
 160                                         frameAccum = 0;
 161
 162                                         nextFpsUpdate += 1.0;
 163                                         if (ticksNow >= nextFpsUpdate)
 164                                         {
 165                                                 nextFpsUpdate = ticksNow + 1.0;
 166                                         }
 167
 168                                         if (printFps)
 169                                         {
 170                                                 std::cout << "FPS: " << fps << std::endl;
 171                                         }
 172                                 }
 173
 174                                 interface->draw(accumulator / timestep);
 175                                 video->swap();
 176
 177                                 nextDraw += drawRate;
 178                                 if (ticksNow >= nextDraw)
 179                                 {
 180                                         // we missed some scheduled draws, so reset the schedule
 181                                         nextDraw = ticksNow + drawRate;
 182                                 }
 183                         }
 184
 185                         // be a good citizen and give back what you don't need
 186                         sleep(std::min(nextStep, nextDraw), true);
 187                 }
 188                 while (running);
 189
 190                 return exitCode;
 191         }
 192
 193
 194         void dispatchEvents()
 195         {
 196                 SDL_Event event;
 197
 198                 while (FE_PollEvent(&event) == 1)
 199                 {
 200                         switch (event.type)
 201                         {
 202                                 case SDL_KEYDOWN:
 203                                         if (event.key.keysym.sym == SDLK_ESCAPE &&
 204                                                         (SDL_GetModState() & KMOD_CTRL) )
 205                                         {
 206                                            exit(0);
 207                                         }
 208                                         break;
 209
 210                                 case SDL_VIDEORESIZE:
 211                                         video->resize(event.resize.w, event.resize.h);
 212                                         break;
 213                         }
 214
 215                         interface->handleEvent(event);
 216                 }
 217         }
 218
 219
 220         Engine*         interface;
 221
 222         Settings        settings;
 223         Dispatcher      dispatcher;
 224         VideoPtr        video;
 225
 226         bool            running;
 227         int                     exitCode;
 228
 229         Scalar          timestep;
 230         Scalar          drawRate;
 231
 232         long            fps;
 233         bool            printFps;
 234 };
 235
 236
 237 Engine::Engine(int argc, char* argv[], const std::string& configFile,
 238                 const std::string& name, const std::string& iconFile) :
 239         impl_(new Engine::Impl(argc, argv, configFile, name, iconFile, this)) {}
 240
 241 Engine::~Engine() {}
 242
 243
 244 int Engine::run()
 245 {
 246         return impl_->run();
 247 }
 248
 249 void Engine::stop(int exitCode)
 250 {
 251         impl_->running = false;
 252         impl_->exitCode = exitCode;
 253 }
 254
 255
 256 void Engine::setTimestep(Scalar ts)
 257 {
 258         impl_->timestep = ts;
 259 }
 260
 261 Scalar Engine::getTimestep()
 262 {
 263         return impl_->timestep;
 264 }
 265
 266 void Engine::setMaxFrameRate(long maxFps)
 267 {
 268         impl_->drawRate = 1.0 / Scalar(maxFps);
 269 }
 270
 271 long Engine::getMaxFrameRate()
 272 {
 273         return long(1.0 / impl_->drawRate);
 274 }
 275
 276
 277 Video& Engine::getVideo()
 278 {
 279         return *impl_->video;
 280 }
 281
 282 long Engine::getFrameRate()
 283 {
 284         return impl_->fps;
 285 }
 286
 287
 288 void Engine::update(Scalar t, Scalar dt) {}
 289 void Engine::draw(Scalar alpha) {}
 290 void Engine::handleEvent(const Event& event) {}
 291
 292
 293 } // namespace Mf
 294
 295 /** vim: set ts=4 sw=4 tw=80: *************************************************/
 296