gee_world.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_WORLD_H
#define GEE_WORLD_H

#include <gee_camera_parameters.h>
#include <gee_geometry.h>
#include <gee_operator.h>

#include <vee_reference_object.h>

#include <di_types.h>

#include <map>

class GEE_Engine;
class GEE_Renderer;

class VEE_RenderClass;

class GEE_World : public GEE_IdContainer
{
public:

  friend class GEE_LayerGeometryIterator;

  typedef std::map<GEE_id_t, VEE_RefPtr<GEE_Geometry> > container;
  typedef container::iterator iterator;

  typedef std::map<GEE_id_t, GEE_CameraParameters> cameraContainer;
  typedef cameraContainer::iterator cameraIterator;


  GEE_World(GEE_Engine * host = 0);
  ~GEE_World();

  GEE_id_t addGeometry(GEE_Geometry *);
  GEE_id_t addGeometry2(VEE_RefPtr<GEE_Geometry> &);

  inline GEE_Geometry * geometry(GEE_id_t id);
  inline VEE_RefPtr<GEE_Geometry> * geometry2(GEE_id_t id);
  bool eraseGeometry(GEE_id_t id);

  void render(GEE_Renderer *);
  // void clearAfter(GEE_TimeStamp ts);

  void clear();

  iterator begin() { return m_geometry.begin(); }
  iterator end()   { return m_geometry.end(); }

  void setGarbageBin(VEE_GarbageBin * bin) { m_deleted = bin; }
  
  static VEE_RefPtr<GEE_Geometry> & getGeometry(iterator & i) 
  { return (*i).second; }

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

  void collectIds(GEE_IdContainer::id_remap &);
  void remapIds(GEE_IdContainer::id_remap &);
  void setAllGenerations(int g);
  
  const VEE_Rgba &backgroundColor() const { return m_bgColor; }
  void setBackgroundColor(const VEE_Rgba &color) { m_bgColor = color; }

  void deNearlySelectAll();
  void selectAll(uint selectionState);

  void dump();

  static void addTextureId(const std::string & name, int id);
  static int textureId(const std::string & name);
  static std::string textureName(int id);
  static void loadTextureDefinitions(const char * filename);

  static void addRenderClass(const std::string & id, const VEE_RenderClass * );
  static VEE_RenderClass * renderClass(const std::string & id);
  static void getRenderClassNames(std::list<std::string> * classes);

  void merge(GEE_World &);
  void allGeometriesToLayer(GEE_id_t layer);

  void getBoundingBox(VEE_BoundingBox *);
  GEE_Engine     * host() { return m_host; }

  uint geometryCount() const { return m_geometry.size(); }

  GEE_CameraParameters * camera(GEE_id_t);
  void setCamera(GEE_id_t, const GEE_CameraParameters &);

  cameraIterator beginCamera() { return m_cameras.begin(); }
  cameraIterator endCamera()   { return m_cameras.end(); }

protected:

  // static void cleanContainer(container &, GEE_TimeStamp);

  container        m_geometry;

  VEE_GarbageBin * m_deleted;

  VEE_Rgba         m_bgColor;

  GEE_Engine     * m_host;

  cameraContainer  m_cameras;
};


inline GEE_Geometry * GEE_World::geometry(GEE_id_t id)
{
  iterator it = m_geometry.find(id);
  if(it == m_geometry.end())
    return 0;

  return (*it).second.ptr();
}

inline VEE_RefPtr<GEE_Geometry> * GEE_World::geometry2(GEE_id_t id)
{
  iterator it = m_geometry.find(id);
  if(it == m_geometry.end())
    return 0;

  return & (*it).second;
}


class GEE_LayerGeometryIterator
{
public:
  GEE_LayerGeometryIterator(GEE_World *w, GEE_id_t layer, bool visibles=true) 
    : m_layer(layer), m_it(w->begin()), m_end(w->end()), m_world(w)
  {
    if((layer != -1) && (m_it != m_end)) {
      while((m_it != m_end) && ((*m_it).second.ptr()->layer() != layer))
  m_it++;
    }
    if(visibles && (m_it != m_end) && !(*m_it).second.ptr()->visible())
      nextVisible();
  }
  
  GEE_Geometry * operator * () 
  { return (m_it == m_end) ? 0 : GEE_World::getGeometry(m_it).ptr(); }
  
  void operator ++ ()
  {
    m_it++;

    if(m_layer != -1) {
      while((m_it != m_end) && 
      ((*m_it).second.ptr()->layer() != m_layer))
  m_it++;
    }
  }
  
  void nextVisible()
  {
    m_it++;
    if(m_layer == -1) {
      while((m_it != m_end) && !(*m_it).second.ptr()->visible())
  m_it++;
    }
    else {
      while((m_it != m_end) &&
      (((*m_it).second.ptr()->layer() != m_layer) ||
       !(*m_it).second.ptr()->visible()))
  m_it++;
    }
  }

  void eraseAndNextVisible();

protected:

  GEE_id_t   m_layer;
  GEE_World::iterator   m_it;
  GEE_World::iterator   m_end;
  GEE_World * m_world;
};


#endif

---