vee_polygon.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 VEE_POLYGON_H
#define VEE_POLYGON_H

#include <vee_particle.h>

#include <vee_vector2.h>

#include <vector>

class VEE_Polygon : public VEE_Particle
{
public:

  VEE_Polygon();

  VEE_Polygon(uint num, const VEE_Vector3 *positions,
        uint numTri, const uint *indices,
        const VEE_Vector3 &velocity,
        float ageLimit, int material = -1,
        VEE_Looks *looks = 0);
  virtual ~VEE_Polygon();

  virtual bool setValue(const char *, VEE_Value *);

  virtual VEE_Polygon *clone() const;

  static VEE_Polygon * createNewMesh(const uint horizontalDivisions,
             const uint verticalDivisions,
             float width = 1.0,
             float height = 1.0,
             float ageLimit = 10000.0);
  static VEE_Polygon * createNewQuadMesh(const uint horizontalDivisions,
           const uint verticalDivisions,
           float width = 1.0,
           float height = 1.0,
           float ageLimit = 10000.0);

  virtual void resetLinks();
  virtual void resetDistances();

  virtual void updateVelocity(float dt);
  virtual void update(float dt);

  void printTextureUV();

  void transform(const VEE_Matrix3 &);
  void move(const VEE_Vector3 &);

  virtual void render(VEE_Renderer *);

  virtual void setStiffness(float s) { m_stiffness = s; }
  // virtual void setVertices(VEE_Vector3 *va, uint *vi);
  virtual void setTextureCoordinates(const std::vector<VEE_Vector2> &coords) 
  { m_vertexTextureCoordinates = coords; }
  virtual void setLinks(std::vector<uint> links)
  { m_links = links; resetDistances(); }
  virtual void setVelocity(const VEE_Vector3 &v);

  uint vertexCount() const { return m_n; }
  VEE_Vector3 &getVertex(uint i) { return m_vertexPositions[i]; }

  uint triangleCount() const { return m_nTri; }

  const uint *getTriangle(uint i) const { return & m_indices[i * 3]; }
  
  VEE_Vector2 &getTextureCoordinate(uint i) 
  { return m_vertexTextureCoordinates[i]; }

  void setMaterial(int m) { m_material = m; }
  int getMaterial() const { return m_material; }

  uint getMeshColumns() { return m_meshColumns; }
  uint getMeshRows() { return m_meshRows; }

protected:

  // nullify tensions
  void initTensions();
  // re-evaluate tensions
  void evaluateTensions();

  std::vector<VEE_Vector3> m_gravForces;
  std::vector<VEE_Vector3> m_dragForces;
  // all the vertices (n)
  std::vector<VEE_Vector3> m_vertexPositions;
  std::vector<VEE_Vector3> m_vertexVelocities;
  std::vector<VEE_Vector2> m_vertexTextureCoordinates;
  // Table of indices defining the triangles, clockwise ((n-2)*3).
  // First index is 0.
  std::vector<uint> m_indices;
  // Index pairs defining the links. As a default
  // this is based on the triangles defined in *m_indices.
  std::vector<uint> m_links;
  // Optimal distances between vertices for all the links
  // present.
  std::vector<float> m_distances;
  // Tensions between the two vertices. Based on
  // *m_distances
  std::vector<float> m_tensions;
  // maximum tension, same for all the links in the polygon
  float m_maxTension;
  // Defines how strongly the polygon tries to maintain
  // its shape.
  float m_stiffness;
  // number of vertices n, n >= 3
  uint m_n;
  // number of triangles
  uint m_nTri;
  // number of links
  uint m_nLinks;
  uint m_meshColumns;
  uint m_meshRows;

  int  m_material;
};

#endif

---