grass_drawable.h

Go to the documentation of this file.

#ifndef _GRASS_GEOMETRY_H
#define _GRASS_GEOMETRY_H

#include <osg/Geometry>
#include <osg/Drawable>
#include <osg/Geode>
#include <osg/Vec3>
#include <vector>
#include <osg/matrix>

#include <osgutil/CullVisitor>

#include "grass_parameters.h"
#include "grass_mesh.h"


using namespace osg;

namespace grass
{



  
  // Extends class Drawable. Adds some grass-ability-specific stuff like private
  // display list or a pointer to a more detailed version of this Drawable.
  class GrassDrawable : public Drawable
  {
  public:
    // This extended cosntructor collects all triangles of given Geode and creates
    // a grass-like mesh from them, so the original mesh of given Geode is covered with grass
    GrassDrawable(Geode & g, GrassAbilityParameters * parameters);

    // Default constructor creates emplty Drawable
    GrassDrawable(Mesh * newMesh, GrassAbilityParameters * parameters);

    // we will need to manage something prior to destroying this object
    virtual ~GrassDrawable();

    // some necessary stuff
    GrassDrawable(const GrassDrawable& gd, const CopyOp& copyop = CopyOp::SHALLOW_COPY);
    virtual Object* cloneType() const { return new GrassDrawable(*this); }
    virtual Object* clone(const CopyOp& copyop) const { return new GrassDrawable(*this, copyop); } 
    virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const GrassDrawable*>(obj) != NULL; }
    virtual const char* libraryName() const { return "grass"; }
    virtual const char* className() const { return "GrassDrawable"; }

    // custom method which manages drawing of this object
    virtual void drawImplementation(RenderInfo& renderInfo) const;

    // this method is called by our friend - our private CullCallback and determines
    // whether to draw this drawable or whether to draw its more detailed version etc.
    void ManageCulling(osgUtil::CullVisitor * cv, RenderInfo* renderInfo);

    // role of the object of this class
    enum ROLE
    {
      TOP_LEVEL,    // constins the original geometry - is drawn always (if visible, of course)
      INTERMEDIATE, // is only an intermediate node in something like a oct-tree - constains nothing to draw
      DETAILED      // contains individual grass leaves - is drawn only if is close enough to eye
    };

  protected:
    // holds level of detail (depends on distance from the center of the mesh to the eye point)
    float LOD;

    // distance form eye (to the center of the mesh)
    float distanceFromEye;

    // true if displaylist ready for drawing
    mutable bool displayListValid;

    // prepares displaylist according to the role of the object
    void PrepareDisplayList(osg::RenderInfo & renderInfo) const;

    // set of parameters of parent ability
    ref_ptr<GrassAbilityParameters> params;
    
    // specifies the meaning of this object
    ROLE role;

    // A kind of a private subtree - it is used during processing cullcallback of this Geometry.
    // If is this geometry too close to eye, this tree is traversed to collect visible geometry
    // in it and this parent low-detail geometry is not used.
    // Otherwise (if eye is far away) only this parent geometry is used or drawing.
    std::vector<ref_ptr<GrassDrawable>> moreDetailedVersion;

    // display list containing the geometry of this Drawable. SetUseDisplayList is set to false for this object,
    // so it manages its drawing itself every frame. And it uses this display list for it.
    mutable GLuint grassDisplayList;

    // mesh of this Drawable
    ref_ptr<Mesh> mesh;

    // ensures that more detailed version of this piece of grass is ready for drawing
    void EnsureDetailedVersionIsReady();
  };









}; // end of namespace grass



#endif _GRASS_GEOMETRY_H