grass_mesh.h

Go to the documentation of this file.

#ifndef GRASS_MESH_H
#define GRASS_MESH_H

#include <osg/Geode>
#include <osg/Vec3>

using namespace osg;

namespace grass
{




  // vertex with its normal
  struct Vertex
  {
    Vec3 position, normal;
    Vertex() {}
    Vertex(Vec3 nPosition) : position(nPosition), normal(0,0,0) {}
    Vertex(Vec3 nPosition, Vec3 nNormal) : position(nPosition), normal(nNormal) {}
    
    // moves this vertex between two specified vertices
    // and sets its normal to average of normals of two specified vertices
    void IsAverageOf(const Vertex & a, const Vertex & b)
    {
      this->position = (a.position + b.position) * 0.5f;
      this->normal = (a.normal + b.normal) * 0.5f;
    }
  };



  // three triangle's vertices and its area and center
  struct Triangle
  {
  public:
    Vertex *A, *B, *C;
    float area;
    Vec3 center;

  private:
    Vertex GetPointAt(const float a, const float b, const float c) const
    {
      return Vertex(  A->position*a + B->position*b + C->position*c,
                      A->normal*a + B->normal*b + C->normal*c  );
    }
  public:
    // default constructor
    Triangle() {}

    // constructor that gets pointers to its three vertices
    // and computer the area and center itself
    Triangle(Vertex * nA, Vertex * nB, Vertex * nC) : A(nA), B(nB), C(nC)
    {
      center = (A->position+B->position+C->position) * 0.33333f;
      area = ( (A->position-B->position) ^ (A->position-C->position) ).length() * 0.5f;
    }

    // returns random point (with its normal) lying on this triangle.
    Vertex GetRandomPoint() const
    {
      // select an order of vertices while getting their coefficients
      const int point = rand() % 6;
      const float a = rand() / float(RAND_MAX*1.2f);
      const float b = (1.0f - a) * rand() / float(RAND_MAX);
      const float c = 1.0f - a - b;
      switch(point)
      {
        case 0:  return GetPointAt(a,b,c);
        case 1:  return GetPointAt(a,c,b);
        case 2:  return GetPointAt(b,c,a);
        case 3:  return GetPointAt(b,a,c);
        case 4:  return GetPointAt(c,a,b);
        default: return GetPointAt(c,b,a);
      }
    }
  }; 




  // mesh containing info about vertices, normals and triangles
  class Mesh : public osg::Referenced
  {
  private:
    // maximal height of the grass
    float maxGrassHeight;

    // triangles of this subtree (used in all meshes of this subtree)
    Triangle * triangleBuffer;
    unsigned int numOfTriangles;
    
    // vertices of triangles stored in vector 'triangleBuffer' 
    Vertex * vertices;
    unsigned int numOfVertices;

    // boundingbox of this mesh
    BoundingBox boundingBox;

    // computes boundingbox
    void ComputeBoundingBox();

  public:    
    // pointers to triangles used in this single mesh
    std::vector<Triangle*> triangles;

    // creates empty mesh
    Mesh(const float nMaxGrassHeight)
      : maxGrassHeight(nMaxGrassHeight), Referenced()
    {
      triangleBuffer = 0;
      numOfTriangles = 0;
      vertices = 0;
      numOfVertices = 0;
    }

    virtual ~Mesh()
    {
    if(vertices)
      delete [] vertices;
    if(triangleBuffer)
      delete [] triangleBuffer;
    }

    // returns the bounding box of this mesh
    BoundingBox GetBound() const {return boundingBox;}

    // Divides this mesh into at least two and at most eight smaller meshes. 
    // Returns a vector with pointers to those new meshes. The original mesh is preserved.
    std::vector<Mesh *> Divide() const;

    friend class TriangleCollector;
  };





}; // end of namespace grass

#endif // GRASS_MESH_H