#include <boost/shared_ptr.hpp>
-#include <Moof/Dispatcher.hh>
-#include <Moof/Event.hh>
-#include <Moof/Math.hh>
-#include <Moof/Singleton.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 : public Singleton<Engine>
+class Engine
{
public:
- Engine(const std::string& name, int argc, char* argv[],
- const std::string& configFile);
- virtual ~Engine();
- int run();
- void stop();
+ Engine();
+ ~Engine() {}
- void setTimestep(Scalar ts);
- Scalar getTimestep();
- void setMaxFrameRate(long maxFps);
- long getMaxFrameRate();
+ const Error& getError() const;
- Video& getVideo();
- long getFrameRate();
+ // 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;
- // Override these if you want.
- virtual void update(Scalar t, Scalar dt);
- virtual void draw(Scalar alpha);
- virtual void handleEvent(const Event& event);
+ void setTimestep(int ts);
+ int getTimestep() const;
+
+ void setMaxFps(int maxFps); // draw rate is always capped at the timestep
+ int getMaxFps() const;
+
+ int getFps() const;
+
+ 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)
+
+ int getSize() const; // get the size of the stack
+
+ // set this machine in motion
+ void run();
+
+ 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:
- class EngineImpl;
- boost::shared_ptr<EngineImpl> impl_;
+
+ class Impl;
+ boost::shared_ptr<Impl> mImpl;
};
+extern Engine engine;
+
+
} // namespace Mf
#endif // _MOOF_ENGINE_HH_