src/ugdk/action/scene.h

Go to the documentation of this file.

#ifndef UGDK_ACTION_SCENE_H_
#define UGDK_ACTION_SCENE_H_

#include <ugdk/portable/tr1.h>
#include FROM_TR1(functional)
#include <list>
#include <queue>
#include <map>
#include <ugdk/action.h>
#include <ugdk/audio.h>
#include <ugdk/graphic.h>
#include <ugdk/base/types.h>

namespace ugdk {

namespace action {

class Scene {
  public:
    Scene();
      
    virtual ~Scene();

    virtual void Focus();

    virtual void DeFocus();

    void AddEntity(Entity *entity);

    void RemoveEntity(Entity *entity) { entities_.remove(entity); }

    void QueuedAddEntity(Entity *entity) { queued_entities_.push(entity); }

    void RemoveAllEntities();

    void AddTask(Task *task);

    void Finish() { End(); finished_ = true; }


    void Update(double delta_t);

    void StopsPreviousMusic(bool set) { stops_previous_music_ = set; }

    bool finished() const { return finished_; }

          graphic::Node*   content_node()       { return   content_node_; }
    const graphic::Node*   content_node() const { return   content_node_; }
          graphic::Node* interface_node()       { return interface_node_; }
    const graphic::Node* interface_node() const { return interface_node_; }

    Music* background_music() const { return background_music_; }
    void set_background_music(Music* music) { background_music_ = music; }
    void set_defocus_callback(std::tr1::function<void (Scene*)> defocus_callback) { 
        defocus_callback_ = defocus_callback;
    }
    void set_focus_callback(std::tr1::function<void (Scene*)> focus_callback) { 
        focus_callback_ = focus_callback;
    }

  protected:
    

    virtual void End();

    bool finished_;

    Music* background_music_;

  private:
    void UpdateEntities(double delta_t);
    void UpdateTasks(double delta_t);
    void DeleteToBeRemovedEntities();
    void DeleteFinishedTasks();
    void FlushEntityQueue();

    bool stops_previous_music_;

    graphic::Node*   content_node_;
    graphic::Node* interface_node_;

    std::list<Entity*> entities_;
    std::queue<Entity*> queued_entities_;
    std::tr1::function<void (Scene*)> defocus_callback_;
    std::tr1::function<void (Scene*)> focus_callback_;

    typedef std::map<int, std::list<Task*> > TasksContainer;
    TasksContainer tasks_;
   
  friend class Engine;
}; // class Scene.

} /* namespace action */

} /* namespace ugdk */

#endif /* UGDK_ACTION_SCENE_H_ */