--- /dev/null
+
+/*] Copyright (c) 2009-2010, Charles McGarvey [**************************
+**] All rights reserved.
+*
+* vi:ts=4 sw=4 tw=75
+*
+* Distributable under the terms and conditions of the 2-clause BSD license;
+* see the file COPYING for a complete text of the license.
+*
+**************************************************************************/
+
+#include <algorithm>
+#include <cstdlib> // exit, srand
+#include <ctime> // time
+#include <string>
+
+#include <SDL/SDL.h>
+#include "fastevents.h"
+
+#include "event.hh"
+#include "log.hh"
+#include "math.hh"
+#include "modal_dialog.hh"
+#include "settings.hh"
+#include "timer.hh"
+#include "video.hh"
+#include "view.hh"
+
+
+namespace moof {
+
+
+class root_view : public view
+{
+ void update(scalar t, scalar dt)
+ {
+ if (children().size() == 0) stop();
+ }
+};
+
+static root_view gRootView;
+
+
+class view::impl
+{
+public:
+
+ impl(view* view, moof::settings& settings, moof::video& video) :
+ view_(*view),
+ settings_(&settings),
+ video_(&video),
+ parent_(&gRootView)
+ {
+ init();
+
+ unsigned randomSeed;
+ if (settings.get("rngseed", randomSeed)) srand(randomSeed);
+ else srand(time(0));
+
+ scalar timestep = 80.0;
+ settings.get("timestep", timestep);
+ timestep_ = 1.0 / timestep;
+
+ scalar framerate = 40.0;
+ settings.get("framerate", framerate);
+ framerate_ = 1.0 / framerate;
+
+ show_fps_ = false;
+ settings.get("showfps", show_fps_);
+ }
+
+ impl(view* view) :
+ view_(*view),
+ settings_(0),
+ video_(0),
+ parent_(&gRootView)
+ {
+ init();
+ }
+
+ void init()
+ {
+ timestep_ = SCALAR(0.01);
+ framerate_ = SCALAR(0.02);
+ show_fps_ = false;
+ }
+
+
+ /**
+ * The main loop. This just calls dispatch_events(), update(), and
+ * draw() over and over again. The timing of the update and draw are
+ * decoupled. The actual frame rate is also calculated here. This
+ * function will return the exit code used to stop the loop.
+ */
+
+ void run()
+ {
+ ASSERT(video_ && "running without video set");
+
+ scalar totalTime = 0.0;
+ scalar ticks = timer::ticks();
+
+ scalar nextUpdate = ticks;
+ scalar nextDraw = ticks;
+ scalar nextSecond = ticks + SCALAR(1.0);
+
+ fps_ = 0;
+ int frameCount = 0;
+
+ const scalar timestep = timestep_;
+ const scalar framerate = framerate_;
+
+ const int MAX_FRAMESKIP = 15;
+ const scalar inverseTimestep = SCALAR(1.0) / timestep;
+
+ is_running_ = true;
+ for (;;)
+ {
+ timer::fire_expired_timers(); // 1. fire timers
+ dispatch_events(); // 2. dispatch events
+
+ if (!is_running_) break;
+
+ int i = 0;
+ while (nextUpdate < timer::ticks() && i < MAX_FRAMESKIP)
+ {
+ totalTime += timestep; // 3. update state
+ view_.update(totalTime, timestep);
+
+ nextUpdate += timestep;
+ ++i;
+
+ if (!is_running_) break;
+ }
+
+ if (nextDraw < (ticks = timer::ticks()))
+ {
+ view_.draw(
+ (ticks + timestep - nextUpdate) * inverseTimestep);
+ video_->swap(); // 4. draw state
+
+ nextDraw += framerate;
+ ++frameCount;
+
+ if (nextSecond < timer::ticks())
+ {
+ fps_ = frameCount;
+ frameCount = 0;
+
+ if (show_fps_) log_info << fps_ << " fps" << std::endl;
+
+ nextSecond += SCALAR(1.0);
+ }
+ }
+
+ if (!is_running_) break;
+
+ ticks = timer::ticks(); // 5. yield timeslice
+ if (ticks < nextUpdate && ticks < nextDraw) timer::sleep(0.0);
+ }
+ }
+
+ void stop()
+ {
+ is_running_ = false;
+ }
+
+
+ void dispatch_events()
+ {
+ event event;
+
+ while (FE_PollEvent(&event) == 1)
+ {
+ switch (event.type)
+ {
+ case SDL_KEYDOWN:
+ if (event.key.keysym.sym == SDLK_ESCAPE &&
+ (SDL_GetModState() & KMOD_CTRL) )
+ {
+ // emergency escape
+ log_warning("escape forced");
+ exit(1);
+ }
+ break;
+
+ case SDL_VIDEORESIZE:
+ video_->resize(event.resize.w, event.resize.h);
+ break;
+ }
+
+ view_.handle_event(event);
+ }
+ }
+
+ bool handle_event(const event& event)
+ {
+ std::list<view_ptr>::iterator it;
+ for (it = children_.begin(); it != children_.end(); ++it)
+ {
+ if ((*it)->handle_event(event)) return true;
+ }
+
+ return false;
+ }
+
+ void update(scalar t, scalar dt)
+ {
+ std::list<view_ptr>::iterator it;
+ for (it = children_.begin(); it != children_.end(); ++it)
+ {
+ (*it)->update(t, dt);
+ }
+ }
+
+ void draw(scalar alpha)
+ {
+ std::list<view_ptr>::iterator it;
+ for (it = children_.begin(); it != children_.end(); ++it)
+ {
+ (*it)->draw(alpha);
+ }
+ }
+
+
+ void add_child(view_ptr child)
+ {
+ ASSERT(child && "adding null view");
+ ASSERT(child.get() != &view_ && "adding view to itself");
+
+ child->impl_->parent_->remove_child(child);
+ children_.push_back(child);
+
+ child->impl_->parent_ = &view_;
+ child->impl_->percolate_objects();
+
+ child->did_add_to_view();
+ }
+
+ void percolate_objects()
+ {
+ bool recurseAgain = false;
+
+ if (parent_->impl_->video_ && parent_->impl_->video_ != video_)
+ {
+ video_ = parent_->impl_->video_;
+ recurseAgain = true;
+ }
+
+ if (parent_->impl_->settings_ &&
+ parent_->impl_->settings_ != settings_)
+ {
+ settings_ = parent_->impl_->settings_;
+ recurseAgain = true;
+ }
+
+ if (recurseAgain)
+ {
+ std::list<view_ptr>::iterator it;
+ for (it = children_.begin(); it != children_.end(); ++it)
+ {
+ (*it)->impl_->percolate_objects();
+ }
+ }
+ }
+
+ view_ptr remove_child(view* child)
+ {
+ ASSERT(child && "cannot remove null child");
+
+ std::list<view_ptr>::iterator it;
+ for (it = children_.begin(); it != children_.end(); ++it)
+ {
+ if ((*it).get() == child)
+ {
+ view_ptr found = *it;
+ found->will_remove_from_view();
+ children_.erase(it);
+
+ found->impl_->parent_ = &gRootView;
+
+ return found;
+ }
+ }
+
+ return view_ptr();
+ }
+
+ void clear()
+ {
+ children_.clear();
+ }
+
+
+ bool is_running_;
+ view& view_;
+
+ moof::settings* settings_;
+ moof::video* video_;
+
+ view* parent_;
+ std::list<view_ptr> children_;
+
+ scalar timestep_;
+ scalar framerate_;
+
+ int fps_;
+ bool show_fps_;
+};
+
+
+view::view(moof::settings& settings, moof::video& video) :
+ // pass through
+ impl_(new view::impl(this, settings, video)) {}
+
+view::view() :
+ impl_(new view::impl(this)) {}
+
+
+void view::update(scalar t, scalar dt)
+{
+ // pass through
+ impl_->update(t, dt);
+}
+
+void view::draw(scalar alpha) const
+{
+ // pass through
+ impl_->draw(alpha);
+}
+
+bool view::handle_event(const event& event)
+{
+ // pass through
+ return impl_->handle_event(event);
+}
+
+
+void view::add_child(view_ptr view)
+{
+ // pass through
+ impl_->add_child(view);
+}
+
+view_ptr view::remove_child(view* view)
+{
+ // pass through
+ return impl_->remove_child(view);
+}
+
+view_ptr view::remove_child(view_ptr view)
+{
+ // pass through
+ return impl_->remove_child(view.get());
+}
+
+void view::clear()
+{
+ // pass through
+ impl_->clear();
+}
+
+
+view& view::parent() const
+{
+ return *(impl_->parent_);
+}
+
+const std::list<view_ptr>& view::children() const
+{
+ return impl_->children_;
+}
+
+
+moof::settings& view::settings() const
+{
+ ASSERT(impl_->settings_ && "accessing null reference");
+ // pass through
+ return *(impl_->settings_);
+}
+
+video& view::video() const
+{
+ ASSERT(impl_->video_ && "accessing null reference");
+ // pass through
+ return *(impl_->video_);
+}
+
+
+void view::run()
+{
+ // pass through
+ return impl_->run();
+}
+
+void view::stop()
+{
+ // pass through
+ return impl_->stop();
+}
+
+bool view::is_running() const
+{
+ // pass through
+ return impl_->is_running_;
+}
+
+
+} // namespace moof
+
projects / chaz / yoink / blobdiff