gee_operator.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef GEE_OPERATOR_H
#define GEE_OPERATOR_H

#include <gee_id.h>
#include <gee_interval.h>

#include <vee_reference_object.h>

#include <di_types.h>

#include <list>
#include <map>

class GEE_Io;
class GEE_World;
class GEE_OperatorManager;
class GEE_OperatorGroup;

class GEE_Operator : public GEE_IdContainer
{
public:
  GEE_Operator();
  virtual ~GEE_Operator();

  virtual bool start(GEE_World *, const GEE_TimeStamp &);
  virtual bool act(GEE_World *, const GEE_TimeStamp &);
  virtual bool stop(GEE_World *, const GEE_TimeStamp &);

  virtual bool read(GEE_Io *);
  virtual bool write(GEE_Io *);
  virtual const char * type();

  bool readBasics(GEE_Io *);
  bool writeBasics(GEE_Io *);
  void copyBasics(const GEE_Operator &);

  const GEE_Interval & interval() const { return m_interval; }
  GEE_Interval & interval()             { return m_interval; }

  GEE_id_t group() const { return m_group; }
  void setGroup(GEE_id_t g) { m_group = g; }

  void setManager(GEE_OperatorManager * manager) { m_manager = manager; }

  static GEE_Operator * create(const char * type);

  bool keepAlive() { return m_keepAlive; }
  void setKeepAlive(bool keep) { m_keepAlive = keep; }

protected:
  static void init();

  GEE_Interval m_interval;

  GEE_id_t m_group;
  bool     m_keepAlive;

  GEE_OperatorManager * m_manager;
};


class GEE_OperatorTimer
{
public:
  GEE_OperatorTimer() : m_id(-1) {}
  GEE_OperatorTimer(const GEE_Operator *a);
  GEE_OperatorTimer(const GEE_OperatorGroup *g);

  ~GEE_OperatorTimer() {}

  const GEE_TimeStamp & time() const { return m_time; }

  bool operator < (const GEE_OperatorTimer &that) const
  { 
    if(m_time != that.m_time) return m_time < that.m_time;
    else return m_id < that.m_id;
  }

  bool operator > (const GEE_OperatorTimer &that) const
  { 
    if(m_time != that.m_time) return m_time > that.m_time;
    else return m_id > that.m_id;
  }

  bool operator <= (const GEE_OperatorTimer &that) const
  { 
    if(m_time != that.m_time) return m_time <= that.m_time;
    else return m_id <= that.m_id;
  }

  bool operator >= (const GEE_OperatorTimer &that) const
  { 
    if(m_time != that.m_time) return m_time > that.m_time;
    else return m_id >= that.m_id;
  }

  bool operator == (const GEE_OperatorTimer &that) const
  { 
    return (m_time == that.m_time) && (m_id == that.m_id);
  }

protected:
  GEE_TimeStamp m_time;
  GEE_id_t      m_id;
};


class GEE_OperatorGroup : public GEE_IdContainer
{
public:
  /* typedef std::multimap<GEE_TimeStamp, VEE_RefPtr<GEE_Operator> > container;
     typedef container::iterator iterator; */

  typedef std::map<GEE_OperatorTimer, VEE_RefPtr<GEE_Operator> > container;
  typedef container::iterator iterator;

  typedef std::list<VEE_RefPtr<GEE_Operator> > operatorList;
  typedef operatorList::iterator listIter;

  GEE_OperatorGroup();
  ~GEE_OperatorGroup();

  bool start(GEE_OperatorManager *, GEE_World *, const GEE_TimeStamp &);
  bool act(GEE_OperatorManager *, GEE_World *, const GEE_TimeStamp &);
  bool stop(GEE_OperatorManager *, GEE_World *, const GEE_TimeStamp &);

  void addOperator(VEE_RefPtr<GEE_Operator> &);
  void clearOperators();

  bool read(GEE_Io *);
  bool write(GEE_Io *);

  const GEE_TimeStamp & offset() const { return m_offset; }
  void setOffset(const GEE_TimeStamp &offset) { m_offset = offset; }
  GEE_TimeStamp endTime() { return m_offset + m_endTime * m_scale; }
  GEE_TimeStamp firstTime();
  void calculateEndTime();

  double scale() const { return m_scale; }
  void setScale(double scale) { m_scale = scale; }
  
  GEE_id_t group() const { return m_group; }
  void setGroup(GEE_id_t g) { m_group = g; }

  bool keepAlive() { return m_keepAlive; }
  void setKeepAlive(bool keep) { m_keepAlive = keep; }

  uint operatorCount() const { return m_operators.size(); }

protected:

  void nextFrame(GEE_World *, const GEE_TimeStamp &);

  GEE_TimeStamp m_time;
  GEE_TimeStamp m_offset;
  GEE_TimeStamp m_endTime;
  double        m_scale;

  uint          m_frame;

  GEE_id_t      m_group;
  container     m_operators;
  iterator      m_nextOperator;
  operatorList  m_currentOperators;

  bool     m_keepAlive;
  bool     m_running;

  static bool m_debug;
};



class GEE_OperatorManager
{
public:
  typedef std::map<GEE_OperatorTimer, 
       VEE_RefPtr<GEE_OperatorGroup> > container;
  typedef container::iterator iterator;

  typedef std::map<GEE_id_t, VEE_RefPtr<GEE_OperatorGroup> > groupContainer;
  typedef groupContainer::iterator groupIterator;
  
  typedef std::list<VEE_RefPtr<GEE_OperatorGroup> > groupList;
  typedef groupList::iterator groupListIter;
  
  typedef std::list<VEE_RefPtr<GEE_Operator> > operatorList;
  typedef operatorList::iterator operatorListIter;

  typedef std::map<GEE_id_t, VEE_RefPtr<GEE_Operator> > operatorMap;
  typedef operatorMap::iterator mapIterator;

  GEE_OperatorManager();
  ~GEE_OperatorManager();

  bool addOperator(GEE_Operator*);
  bool addOperatorGroup(const GEE_OperatorGroup &);
  bool addOperatorGroup2(VEE_RefPtr<GEE_OperatorGroup> &);
  inline GEE_OperatorGroup *getOperatorGroup(GEE_id_t g);

  GEE_TimeStamp operatorTimeToRealTime(GEE_TimeStamp , GEE_id_t groupId);
  GEE_TimeStamp realTimeToOperatorTime(GEE_TimeStamp , GEE_id_t groupId);

  void undo(uint n = 1);
  void redo(uint n = 1);
  operatorListIter undoIterator() { return m_undoIter; }
  operatorListIter undoEnd() { return m_undoList.end(); }

  bool read(GEE_Io *, const char * dirname);
  bool write(GEE_Io *, const char * dirname);

  void collectIds(GEE_IdContainer::id_remap &);
  void remapIds(GEE_IdContainer::id_remap &);

  void collectOperators(operatorList *);
  
  void update(GEE_TimeStamp);
  void rewind(GEE_TimeStamp);
  void toBegin() { rewind(-1); }
  void stop();

  GEE_World  *world() { return m_world; }
  void setWorld(GEE_World *w) { m_world = w; }
  
  void clear();

  void merge(GEE_OperatorManager &);

  void rebuildPlan();

  uint actionCount() { return m_undoList.size(); }

  uint fps() const { return m_fps; }

protected:
  // void addOperatorInternal(VEE_RefPtr<GEE_Operator> &, bool inundo);
  void addOperatorInternal(VEE_RefPtr<GEE_Operator> &);
  void nextFrame(GEE_TimeStamp);


  container   m_plan;
  iterator    m_nextGroup;
  bool        m_dirtyPlan;
  bool        m_running;

  // container   m_pending;
  groupList    m_currentGroups;

  groupContainer m_groups;

  // operatorMap  m_operatorStore;
  operatorList m_undoList;
  operatorListIter m_undoIter;

  GEE_TimeStamp m_time;
  uint          m_fps;
  uint          m_frame;

  GEE_World  *m_world;

  static bool m_debug;
};

inline GEE_OperatorGroup *GEE_OperatorManager::getOperatorGroup(GEE_id_t g)
{
  groupIterator git = m_groups.find(g);
  return (git == m_groups.end()) ? 0 : (*git).second.ptr();
}


#endif

---