gee_geometry.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_GEOMETRY_H
#define GEE_GEOMETRY_H

#include <gee_config.h>
#include <gee_enums.h>
#include <gee_id.h>
#include <gee_interval.h>
#include <gee_material.h>

#include <vee_color.h>
#include <vee_garbage.h>
#include <vee_vector3.h>
#include <vee_matrix4.h>

class GEE_Bounded;
class GEE_Containment;
class GEE_Mover;
class GEE_ReColor;
class GEE_Renderer;
class GEE_World;

class VEE_BoundingBox;

class GEE_Geometry : public VEE_Garbage, public GEE_IdContainer
{
public:
  GEE_Geometry(VEE_GarbageBin *bin = 0);
  virtual ~GEE_Geometry();

  virtual GEE_Geometry * clone() const;
  virtual GEE_Geometry * copy(GEE_World *target, id_remap * remap) const;
  virtual void erase();
  virtual bool eraseData(GEE_Containment *);
  virtual bool intersects(GEE_Containment *);
  virtual void selectVertices(GEE_Containment *,  
            uint mask, 
            uint values);
  virtual void selectFaces(GEE_Containment *,  
         uint mask, 
         uint values);
  virtual bool colorData(GEE_ReColor *);
  virtual bool moveData(GEE_Mover *);
  virtual void render(GEE_Renderer *);
  virtual bool getBoundingBox(VEE_BoundingBox *);
  virtual bool move(const VEE_Vector3 & offset);
  virtual void setMaterial(const GEE_Material &m);
  virtual bool read(GEE_Io * );
  virtual bool write(GEE_Io *);
  virtual bool finalizeRead();

  bool readBasics(GEE_Io *);
  bool writeBasics(GEE_Io *);

  bool readFile(const char *);
  bool writeFile(const char *);

  void copyBasics(const GEE_Geometry &);

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

  GEE_id_t generation() const { return m_generation; }

  void incrementGeneration(GEE_id_t add = 1) 
  { if(m_generation >= 0) m_generation += add; }

  void setGeneration(GEE_id_t g) { m_generation = g; }

  void attachEditor() { m_editorCount++; }
  void detachEditor() 
  { if(m_editorCount) m_editorCount--; incrementGeneration(); }
  int  editorCount() const { return m_editorCount; }

  void setMaterialName(const std::string &mat);
  void setMaterialName(const char *mat);
  const std::string & materialName() const { return m_materialName; }

  GEE_Material & material() { return m_material; }

  bool visible() const { return m_visible; }
  void setVisible(bool v) { m_visible = v; }

  VEE_Matrix4d &       transformation() { return m_transformation; }
  const VEE_Matrix4d & transformation() const { return m_transformation; }
  void setTransformation(const VEE_Matrix4d &t) { m_transformation = t; }
  void getWorldTransformation(VEE_Matrix4d *) const;
  void getWorldTransformation(VEE_Matrix4 *) const;
  void getWorldTransformations(VEE_Matrix4d *, VEE_Matrix4d *, bool *) const;
  void getWorldTransformations(VEE_Matrix4 *, VEE_Matrix4 *, bool *) const;
  void centralize();

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

  uint selectionState() const { return m_selectionState; }
  virtual void setSelectionState(uint s);
  inline void setNearlySelected(bool s);
  inline void setSelected(bool s);
  bool isSelected() const { return m_selectionState & GEE_SELECT_BIT; }

  static GEE_Geometry * readGeometry(GEE_Io * );
  static GEE_Geometry * create(const char *);
  static void init();

protected:

  bool intersectsBounded(GEE_Bounded *, 
       VEE_BoundingBox * myBounds, 
       const VEE_Matrix4 & myWorldTransform);

  GEE_World   *m_world;

  int          m_editorCount;
  GEE_id_t     m_generation;
  GEE_id_t     m_group;
  GEE_Material m_material;
  std::string  m_materialName;
  bool         m_visible;
  uint         m_selectionState;
private:
  VEE_Matrix4d  m_transformation;
  // VEE_Matrix4d  m_inverseTransformation;
};


inline void GEE_Geometry::setNearlySelected(bool s)
{
  setSelectionState(s ?
        m_selectionState |= GEE_NEARLY_SELECT_BIT :
        m_selectionState &= ~GEE_NEARLY_SELECT_BIT);
}

inline void GEE_Geometry::setSelected(bool s)
{
  setSelectionState(s ?
        m_selectionState |= GEE_SELECT_BIT :
        m_selectionState &= ~GEE_SELECT_BIT);
}

#endif

---