GraphicTriangleMesh.hpp

Go to the documentation of this file.

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

/* COPYRIGHT
 *
 * This file is part of the Simple Object Loader and Renderer - SOLAR
 *
 * Read the file "SOLAR-LICENSE" for the license.
 *
 * Authors & Copyright:
 *
 * Tommi Ilmonen, 2001-2003, except LWO-code by RJ, 2001-2003
 *
 * Tommi's email: firstname.lastname@hut.fi
 *
 */

#ifndef SOLAR_GRAPHIC_TRIANGLE_MESH_H
#define SOLAR_GRAPHIC_TRIANGLE_MESH_H

#include <Fluid/Vector2.hpp>

#include <Solar/BoundingBox.hpp>
#include <Solar/Graphic.hpp>

#include <vector>

namespace Solar {

class GraphicTriangleMesh : public Graphic
{
public:
  GraphicTriangleMesh();
  virtual ~GraphicTriangleMesh();

  class Triangle {
  public:

    uint & vertex(uint i) { return m_vertices[i]; }
    const uint & vertex(uint i) const { return m_vertices[i]; }

    uint m_vertices[3];
    void clear();
    void write(std::ostream *);
  };

  class VertexData {
  public:
    
    void scale(const Fluid::Vector3 &v)
    {
      m_location[0] *= v[0];
      m_location[1] *= v[1];
      m_location[2] *= v[2];      
    }

    void move(const Fluid::Vector3 &v)
    { m_location += v; }

    void transform(const Fluid::Matrix3 &m)
    {
      m_location = m * m_location;
      m_normal   = m * m_normal;
    }

    Fluid::Vector3 & location() { return m_location; }
    Fluid::Vector3 & normal() { return m_normal; }
    Fluid::Vector2 & uv() { return m_uv; }

    const Fluid::Vector3 & location() const { return m_location; }
    const Fluid::Vector3 & normal() const { return m_normal; }
    const Fluid::Vector2 & uv() const { return m_uv; }

    Fluid::Vector3 m_location;
    Fluid::Vector3 m_normal;
    Fluid::Vector2 m_uv;

    void write(std::ostream *);
  };

  virtual Type type() const;
  virtual void getBoundingBox(BoundingBox *bbox);
  virtual int nofPrimitives() const;
  virtual void render(Renderer *);
  virtual void scale(const Fluid::Vector3 &);
  virtual void move(const Fluid::Vector3 &);
  virtual void transform(const Fluid::Matrix3 &);
  virtual void write(std::ostream *);

  void clear();

  void addVertex(const VertexData &);
  void addTriangle(const Triangle &);
  void addTriangle(uint i, uint j, uint k);
  
  void recalculateBoundingBox();

  uint nofTriangles() const { return m_triangles.size(); }
  const Triangle &triangle(uint i) const { return m_triangles[i]; }
  void reserveTriangles(uint n) { m_triangles.reserve(n); }

  const VertexData * vertexPtr() const { return &* m_vertices.begin(); }
  VertexData & vertex(uint i) { return m_vertices[i]; }
  const VertexData & vertex(uint i) const { return m_vertices[i]; }
  void reserveVertices(uint n) { m_vertices.reserve(n); }

protected:

  BoundingBox m_boundingBox;

  std::vector<VertexData> m_vertices;
  std::vector<Triangle>   m_triangles;
};

} // namespace Solar

#endif

---