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 <string>
  31
  32 #include <SDL/SDL.h>
  33 #include "fastevents.h"
  34 #include <AL/alut.h>
  35
  36 #include "Dispatcher.hh"
  37 #include "Engine.hh"
  38 #include "Log.hh"
  39 #include "Random.hh"
  40 #include "Settings.hh"
  41 #include "Timer.hh"
  42 #include "Video.hh"
  43
  44
  45 namespace Mf {
  46
  47
  48 class Engine::Impl
  49 {
  50 public:
  51         Impl(int argc, char* argv[], const std::string& configFile,
  52                         const std::string& name, const std::string& iconFile,
  53                         Engine* outer) :
  54                 interface(outer)
  55         {
  56 #if defined(_WIN32) || defined (_WIN64) || defined(__WIN32__)
  57                 if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) != 0)
  58 #else
  59                 if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD) != 0)
  60 #endif
  61                 {
  62                         logError("sdl is complaining: %s", SDL_GetError());
  63                         throw Exception(Exception::SDL_ERROR);
  64                 }
  65                 if (FE_Init() != 0)
  66                 {
  67                         logError("fast events error: %s", FE_GetError());
  68                         throw Exception(Exception::SDL_ERROR);
  69                 }
  70                 alutInit(&argc, argv);
  71
  72                 Settings& settings = Settings::getInstance();
  73                 settings.parseArgs(argc, argv);
  74                 settings.loadFromFile(configFile);
  75
  76                 long randomSeed;
  77                 if (settings.get("engine.rngseed", randomSeed)) setSeed(randomSeed);
  78                 else setSeed();
  79
  80                 double ts = 0.01;
  81                 settings.get("engine.timestep", ts);
  82                 timestep = Scalar(ts);
  83
  84                 long maxFps = 40;
  85                 settings.getNumber("video.maxfps", maxFps);
  86                 drawRate = 1.0 / Scalar(maxFps);
  87
  88                 printFps = false;
  89                 settings.get("video.printfps", printFps);
  90
  91                 video = Video::alloc(name, iconFile);
  92                 video->makeActive();
  93         }
  94
  95         ~Impl()
  96         {
  97                 // the video object must be destroyed before we can shutdown SDL
  98                 video.reset();
  99
 100                 alutExit();
 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 = Timer::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 = Timer::getTicks();
 132                         deltaTime = newTicks - ticksNow;
 133                         ticksNow = newTicks;
 134
 135                         if (deltaTime >= 0.25) deltaTime = 0.25;
 136                         accumulator += deltaTime;
 137
 138                         Timer::fireIfExpired(ticksNow);
 139
 140                         while (accumulator >= timestep)
 141                         {
 142                                 dispatchEvents();
 143                                 interface->update(totalTime, timestep);
 144
 145                                 totalTime += timestep;
 146                                 accumulator -= timestep;
 147
 148                                 nextStep += timestep;
 149                         }
 150                         if (ticksNow >= nextStep)
 151                         {
 152                                 nextStep = ticksNow + timestep;
 153                         }
 154
 155                         if (ticksNow >= nextDraw)
 156                         {
 157                                 frameAccum++;
 158
 159                                 if (ticksNow >= nextFpsUpdate) // determine the actual fps
 160                                 {
 161                                         fps = frameAccum;
 162                                         frameAccum = 0;
 163
 164                                         nextFpsUpdate += 1.0;
 165                                         if (ticksNow >= nextFpsUpdate)
 166                                         {
 167                                                 nextFpsUpdate = ticksNow + 1.0;
 168                                         }
 169
 170                                         if (printFps)
 171                                         {
 172                                                 logInfo("framerate: %d fps", fps);
 173                                         }
 174                                 }
 175
 176                                 interface->draw(accumulator / timestep);
 177                                 video->swap();
 178
 179                                 nextDraw += drawRate;
 180                                 if (ticksNow >= nextDraw)
 181                                 {
 182                                         // we missed some scheduled draws, so reset the schedule
 183                                         nextDraw = ticksNow + drawRate;
 184                                 }
 185                         }
 186
 187                         // be a good citizen and give back what you don't need
 188                         Timer::sleep(std::min(std::min(nextStep, nextDraw),
 189                                                 Timer::getNextFire()), true);
 190                 }
 191                 while (running);
 192
 193                 return exitCode;
 194         }
 195
 196
 197         void dispatchEvents()
 198         {
 199                 SDL_Event event;
 200
 201                 while (FE_PollEvent(&event) == 1)
 202                 {
 203                         switch (event.type)
 204                         {
 205                                 case SDL_KEYDOWN:
 206                                         if (event.key.keysym.sym == SDLK_ESCAPE &&
 207                                                         (SDL_GetModState() & KMOD_CTRL) )
 208                                         {
 209                                            exit(0);
 210                                         }
 211                                         break;
 212
 213                                 case SDL_VIDEORESIZE:
 214                                         video->resize(event.resize.w, event.resize.h);
 215                                         break;
 216                         }
 217
 218                         interface->handleEvent(event);
 219                 }
 220         }
 221
 222
 223         Engine*         interface;
 224
 225         VideoP          video;
 226
 227         bool            running;
 228         int                     exitCode;
 229
 230         Scalar          timestep;
 231         Scalar          drawRate;
 232
 233         long            fps;
 234         bool            printFps;
 235 };
 236
 237
 238 Engine::Engine(int argc, char* argv[], const std::string& configFile,
 239                 const std::string& name, const std::string& iconFile) :
 240         impl_(new Engine::Impl(argc, argv, configFile, name, iconFile, this)) {}
 241
 242 Engine::~Engine() {}
 243
 244
 245 int Engine::run()
 246 {
 247         return impl_->run();
 248 }
 249
 250 void Engine::stop(int exitCode)
 251 {
 252         impl_->running = false;
 253         impl_->exitCode = exitCode;
 254 }
 255
 256
 257 void Engine::setTimestep(Scalar ts)
 258 {
 259         impl_->timestep = ts;
 260 }
 261
 262 Scalar Engine::getTimestep()
 263 {
 264         return impl_->timestep;
 265 }
 266
 267 void Engine::setMaxFrameRate(long maxFps)
 268 {
 269         impl_->drawRate = 1.0 / Scalar(maxFps);
 270 }
 271
 272 long Engine::getMaxFrameRate()
 273 {
 274         return long(1.0 / impl_->drawRate);
 275 }
 276
 277
 278 Video& Engine::getVideo()
 279 {
 280         return *impl_->video;
 281 }
 282
 283 long Engine::getFrameRate()
 284 {
 285         return impl_->fps;
 286 }
 287
 288
 289 void Engine::update(Scalar t, Scalar dt) {}
 290 void Engine::draw(Scalar alpha) {}
 291 void Engine::handleEvent(const Event& event) {}
 292
 293
 294 } // namespace Mf
 295
 296 /** vim: set ts=4 sw=4 tw=80: *************************************************/
 297