gee_triangle_mesh.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_TRIANGLE_MESH_H
#define GEE_TRIANGLE_MESH_H

#include <gee_geometry.h>

#include <vee_bounding_box.h>
#include <vee_vector2.h>
#include <vee_vector3.h>
#include <vee_vector4.h>

#include <map>
#include <vector>

class GEE_Io;

class GEE_PolygonVertex
{
public:
  GEE_PolygonVertex(const VEE_Vector3 & location = VEE_Vector3ZERO,
        const VEE_Vector3 & normal   = VEE_Vector3ZERO,
        const VEE_Vector2 & uv       = VEE_Vector2ZERO,
        const VEE_Vector4 & rgba     = VEE_Vector4ONE)
    : m_location(location), m_normal(normal), m_uv(uv), m_rgba(rgba),
      m_selectionState(0)
  {}

  void addPolygon(int p);
  bool removePolygon(int);

  bool read(GEE_Io *);
  bool write(GEE_Io *);
  
  VEE_Vector3 m_location;
  VEE_Vector3 m_normal;
  VEE_Vector2 m_uv;

  VEE_Vector4 m_rgba;

  std::vector<int> m_polygons;
  uchar m_selectionState;
};

class GEE_TriangleIndices
{
public:

  GEE_TriangleIndices(int v1 = -1, int v2 = -1, int v3 = -1, 
          bool continues = false, uint stripIndex = 0)
    : m_continues(continues), 
      m_selectionState(0),
      m_stripIndex(stripIndex)
  {
    m_indices[0] = v1; m_indices[1] = v2; m_indices[2] = v3; 
  }

  bool read(GEE_Io *);
  bool write(GEE_Io *);
  
  void make(int v1, int v2, int v3)
  { m_indices[0] = v1; m_indices[1] = v2; m_indices[2] = v3; }

  int   m_indices[3];

  bool  m_continues;
  uchar m_selectionState;
  uint  m_stripIndex;
};

enum GEE_TriMeshItem {
  GEE_TRIMESH_UNKNOWN,
  GEE_TRIMESH_TRILIST,
  GEE_TRIMESH_TRIS,
  GEE_TRIMESH_END,
  GEE_TRIMESH_COLOR,
  GEE_TRIMESH_NORMAL,
  GEE_TRIMESH_LOCATION,
  GEE_TRIMESH_UV
};

class GEE_TriMeshListItem
{
public:
  GEE_TriMeshListItem(GEE_TriMeshItem type = GEE_TRIMESH_UNKNOWN) 
    : m_type(type ) {}

  GEE_TriMeshItem m_type;
  VEE_Vector4     m_data;
};

class GEE_TriMeshList
{
public:
  typedef std::vector<GEE_TriMeshListItem> container;
  typedef container::iterator iterator;

  GEE_TriMeshList() : m_size(0), m_generation(-1) {}
  ~GEE_TriMeshList() {}

  void reserve(uint n) { if(m_list.size() < n) m_list.resize(n); }
  void prepareNew() { m_size = 0; }
  void addItem(const GEE_TriMeshListItem & item)
  {
    if(m_size + 1 > m_list.size())
      m_list.resize(m_size + 100);
    m_list[m_size] = item;
    m_size++;
  }

  void addItem2(GEE_TriMeshItem type) { addItem(GEE_TriMeshListItem(type)); }

  iterator begin() { return m_list.begin(); }
  iterator end()   { return m_list.begin() + m_size; }

  container m_list;
  
  uint m_size;

  int m_generation;
};

class GEE_TriangleMesh : public GEE_Geometry
{
public: 
  typedef std::map<int, GEE_PolygonVertex>::iterator vertexIterator;
  typedef std::map<int, GEE_TriangleIndices>::iterator triangleIterator;

  GEE_TriangleMesh();
  virtual ~GEE_TriangleMesh();

  static GEE_Geometry * create();
  virtual GEE_Geometry * clone() const;
  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 bool smooth(GEE_Containment *);

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

  GEE_Geometry * removeData(const VEE_Vector3 &loc, float radius);
  void clear();

  int addVertex(const GEE_PolygonVertex &);
  void setVertex(int, const GEE_PolygonVertex &);
  inline GEE_PolygonVertex * getVertex(int);
  bool removeVertex(int index);
  uint vertexCounter() const { return m_vertexCounter; }

  int addTriangle(const GEE_TriangleIndices &, int id = -1);
  GEE_TriangleIndices * getTriangle(int);

  triangleIterator beginTriangle() { return m_triangles.begin(); }
  triangleIterator endTriangle()   { return m_triangles.end(); }
  uint triangleCount() const { return m_triangles.size(); }

  vertexIterator beginVertex() { return m_vertices.begin(); }
  vertexIterator endVertex()   { return m_vertices.end(); }
  uint vertexCount() const { return m_vertices.size(); }

  static GEE_TriangleIndices & getTriangle(triangleIterator &it)
  { return (*it).second; }

  void autoNormalize();
  void normalizeVertex(vertexIterator &it, bool adjustGeneration = true);
  bool normalizeVertex(int index, bool adjustGeneration = true)
  {
    vertexIterator it = m_vertices.find(index);
    if(it != m_vertices.end()) {
      normalizeVertex(it, adjustGeneration);
      return true;
    }
    return false;
  }

  void createRectangularGrid(uint xdivision, uint ydivision,
           float width = 1.0f, float height = 1.0f);

  static GEE_TriangleMesh * cast(GEE_Geometry *d) 
  { return dynamic_cast<GEE_TriangleMesh *> (d); }

  void setUseStrips(bool useStrips) { m_useStrips =  useStrips; }
  bool useStrips() const { return m_useStrips; }

  void vertexWasMoved(const VEE_Vector3 & newLocation)
  { m_bbox.expand(newLocation); }

  VEE_Vector3 triangleNormal(int, int);

  float vertexWrinkliness(int vertex);
  float vertexWrinklinessLinked(int vertex);
  VEE_Vector3 smoothVertex(int vertex, float effect);
  VEE_Vector3 smoothVertex2(int vertex, int iterations, float effect);

  GEE_TriMeshList & list() { return m_list; }
  bool genList();

protected:

  void listifyVertex(const GEE_PolygonVertex &);

  void eraseTriangleInternal(int tri)
  {
    triangleIterator it = m_triangles.find(tri);
    if(it != m_triangles.end())
      m_triangles.erase(it);
  }

  std::map<int, GEE_PolygonVertex>   m_vertices;
  std::map<int, GEE_TriangleIndices> m_triangles;

  int m_vertexCounter;
  int m_triangleCounter;

  bool m_useStrips;

  VEE_BoundingBox m_bbox;

  GEE_TriMeshList m_list;
};

inline GEE_PolygonVertex * GEE_TriangleMesh::getVertex(int id)
{
  vertexIterator it = m_vertices.find(id);
  
  if(it != m_vertices.end()) {
    return & (*it).second;
  }

  return 0;
}

#endif

---