#ifndef _MOOF_ENGINE_HH_
#define _MOOF_ENGINE_HH_
-#include <stdexcept>
-
#include <boost/shared_ptr.hpp>
-#include <Moof/Event.hh>
-#include <Moof/Exception.hh>
-#include <Moof/Math.hh>
+#include <Moof/Dispatch.hh>
+#include <Moof/Error.hh>
+#include <Moof/Video.hh>
+#include <Moof/Layer.hh>
namespace Mf {
-// forward declaration
-class Video;
+/**
+ * The engine is essentially a stack of layers. While running, it updates each
+ * layer from the bottom up every timestep. It also draws each layer from the
+ * bottom up, adhering to the maximum frame-rate. Events are sent to each layer
+ * from the top down until a layer signals the event was handled. The engine is
+ * also responsible for firing timers on time. The engine will continue running
+ * as long as there are layers on the stack.
+ */
class Engine
{
-protected:
+public:
- Engine(int argc, char* argv[], const std::string& configFile,
- const std::string& name, const std::string& iconFile);
+ Engine();
+ ~Engine() {}
-public:
+ const Error& getError() const;
+
+ // setting the video is required before you can run the engine and should
+ // probably be done before adding any layers
+ void setVideo(VideoP video);
+ VideoP getVideo() const;
- virtual ~Engine();
+ void setTimestep(int ts);
+ int getTimestep() const;
- int run();
- void stop(int exitCode = 0);
+ void setMaxFps(int maxFps); // draw rate is always capped at the timestep
+ int getMaxFps() const;
- void setTimestep(Scalar ts);
- Scalar getTimestep();
- void setMaxFrameRate(long maxFps);
- long getMaxFrameRate();
+ int getFps() const;
- Video& getVideo();
- long getFrameRate();
+ void push(LayerP layer); // push a layer onto the top
+ LayerP pop(); // pop the top layer
+ LayerP pop(Layer* layer); // pops a specific layer and all layers above it
+ void clear(); // remove all layers (the engine will stop)
- // override these if you want
- virtual void update(Scalar t, Scalar dt);
- virtual void draw(Scalar alpha);
- virtual void handleEvent(const Event& event);
+ int getSize() const; // get the size of the stack
- struct Exception : public Mf::Exception
- {
- explicit Exception(unsigned error) :
- Mf::Exception(error) {}
+ // set this machine in motion
+ void run();
- void raise()
- {
- throw *this;
- }
- };
+ Dispatch::Handler addHandler(const std::string& event,
+ const Dispatch::Function& callback);
+ Dispatch::Handler addHandler(const std::string& event,
+ const Dispatch::Function& callback, Dispatch::Handler handler);
+
+ void dispatch(const std::string& event,
+ const Dispatch::Message* message = 0);
private:
- Engine() {} // this class must be subclassed to be useful
class Impl;
- boost::shared_ptr<Impl> impl_;
+ boost::shared_ptr<Impl> mImpl;
};
+extern Engine engine;
+
+
} // namespace Mf
#endif // _MOOF_ENGINE_HH_