GrassLoader.h

Go to the documentation of this file.

/*-------------------------------------------------------------------------------------
Copyright (c) 2006 John Judnich
 
This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
    1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
    2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
    3. This notice may not be removed or altered from any source distribution.
-------------------------------------------------------------------------------------*/
 
#ifndef __GrassLoader_H__
#define __GrassLoader_H__
 
#include "PagedGeometry.h"
#include "PropertyMaps.h"
#include "RandomTable.h"
 
#include "OgrePrerequisites.h"
#include "OgreMaterial.h"
#include "OgrePixelFormat.h"
#include "OgreStringConverter.h"
 
 
namespace Forests {
 
class GrassLayer;
 
class GrassLoader: public PageLoader
{
public:
    GrassLoader(PagedGeometry *geom);
    ~GrassLoader();
 
    GrassLayer *addLayer(const Ogre::String &material);
 
    void deleteLayer(GrassLayer *layer);
 
    inline std::list<GrassLayer*> &getLayerList() { return layerList; }
 
    inline void setWindDirection(Ogre::Vector3 &dir) { windDir = dir; }
 
    inline Ogre::Vector3 &getWindDirection() { return windDir; }
 
    inline void setDensityFactor(float density) { densityFactor = density; }
 
    inline float getDensityFactor() { return densityFactor; }
 
    inline void setRenderQueueGroup(Ogre::uint8 queueID) { renderQueue = queueID; }
 
    void setHeightFunction(Ogre::Real (*heightFunction)(Ogre::Real x, Ogre::Real z, void *userData), void *userData = NULL) {
        this->heightFunction = heightFunction;
        heightFunctionUserData = userData;
    }
 
    void loadPage(PageInfo &page);
    void unloadPage(PageInfo &page);
    void frameUpdate();
 
    static float getRangeRandom(float start, float end);
 
 
private:
    friend class GrassLayer;
 
    //Helper functions
    Ogre::Mesh *generateGrass_QUAD(PageInfo &page, GrassLayer *layer, const float *grassPositions, unsigned int grassCount);
    Ogre::Mesh *generateGrass_CROSSQUADS(PageInfo &page, GrassLayer *layer, const float *grassPositions, unsigned int grassCount);
    Ogre::Mesh *generateGrass_SPRITE(PageInfo &page, GrassLayer *layer, const float *grassPositions, unsigned int grassCount);
 
    //List of grass types
    std::list<GrassLayer*> layerList;
 
    //Height data
    Ogre::Real (*heightFunction)(Ogre::Real x, Ogre::Real z, void *userData);   //Pointer to height function
    void *heightFunctionUserData;
 
    //Misc.
    PagedGeometry *geom;
    Ogre::uint8 renderQueue;
    float densityFactor;
 
    // random table
    RandomTable *rTable;
 
    //Animation
    Ogre::Timer windTimer;
    Ogre::Vector3 windDir;
    unsigned long lastTime;
 
    static unsigned long GUID;
    static inline Ogre::String getUniqueID()
    {
        return "GrassLDR" + Ogre::StringConverter::toString(++GUID);
    }
};
 
class GrassLayer
{
public:
    void setMaterialName(const Ogre::String &matName);
 
    void setMinimumSize(float width, float height);
 
    void setMaximumSize(float width, float height);
 
    void setDensity(float density) { this->density = density; }
 
    void setHeightRange(float minHeight, float maxHeight = 0) { minY = minHeight; maxY = maxHeight; }
 
    void setMaxSlope(const float maxSlopeRatio) { maxSlope = maxSlopeRatio; }
 
    void setMaxSlope(Ogre::Radian maxSlopeAngle) {
        if (maxSlopeAngle > Ogre::Degree(89.99f))
            maxSlopeAngle = Ogre::Degree(89.99f);
        if (maxSlopeAngle < Ogre::Degree(0))
            maxSlopeAngle = Ogre::Degree(0);
 
        maxSlope = Ogre::Math::Tan(maxSlopeAngle);
    }
 
    Ogre::Real getMaxSlope() const { return maxSlope; }
 
    void setDensityMap(const Ogre::String &mapFile, MapChannel channel = CHANNEL_COLOR);
 
    void setDensityMap(Ogre::TexturePtr map, MapChannel channel = CHANNEL_COLOR);
 
    void setDensityMapFilter(MapFilter filter);
 
    void setColorMap(const Ogre::String &mapFile, MapChannel channel = CHANNEL_COLOR);
 
    void setColorMap(Ogre::TexturePtr map, MapChannel channel = CHANNEL_COLOR);
 
    void setColorMapFilter(MapFilter filter);
 
    void setMapBounds(const TBounds &bounds)
    {
        mapBounds = bounds;
    }
 
    DensityMap* getDensityMap() const { return densityMap; }
 
    ColorMap* getColorMap() const { return colorMap; }
 
    bool getBlendValue() const { return blend;};
 
    GrassLoader* getParentGrassLoader() const { return parent; }
 
    bool getLightingEnabled() const { return lighting; }
 
    const TBounds& getMapBounds() const { return mapBounds; }
 
    void setRenderTechnique(GrassTechnique style, bool blendBase = false);
 
    void setFadeTechnique(FadeTechnique style);
 
    void setAnimationEnabled(bool enabled);
 
 
    void setLightingEnabled(bool enabled);
 
    void setSwayLength(Ogre::Real mag) { animMag = mag; }
 
    void setSwaySpeed(Ogre::Real speed) { animSpeed = speed; }
 
    void setSwayDistribution(Ogre::Real freq) { animFreq = freq; }
 
private:
    friend class GrassLoader;
 
    GrassLayer(PagedGeometry *geom, GrassLoader *ldr);
 
    ~GrassLayer();
 
    //Updates the vertex shader used by this layer based on the animate enable status
    void _updateShaders();
 
    //Used by GrassLoader::loadPage() - populates an array with a uniform distribution of grass
    //Returns the final number of grasses, which will always be <= grassCount
    unsigned int _populateGrassList_Uniform(PageInfo page, float *posBuff, unsigned int grassCount);
 
    //Used by GrassLoader::loadPage() - populates an array of grass positions based on the density map
    //Returns the final number of grasses, which will always be <= grassCount
    unsigned int _populateGrassList_UnfilteredDM(PageInfo page, float *posBuff, unsigned int grassCount);
 
    //Variation of _populateGrassList(), using bilinear filtering on the density map lookups
    //Returns the final number of grasses, which will always be <= grassCount
    unsigned int _populateGrassList_BilinearDM(PageInfo page, float *posBuff, unsigned int grassCount);
 
 
    GrassLoader *parent;
 
    //Grass material/shape properties
    Ogre::MaterialPtr material;
   Ogre::Real density;
    Ogre::Real minWidth, maxWidth;
    Ogre::Real minHeight, maxHeight;
 
    Ogre::Real minY, maxY;
   Ogre::Real maxSlope;
 
    FadeTechnique fadeTechnique;
    GrassTechnique renderTechnique;
 
    //Property maps
    TBounds mapBounds;
 
    DensityMap *densityMap;
    MapFilter densityMapFilter;
 
    ColorMap *colorMap;
    MapFilter colorMapFilter;
 
    //Grass shader properties
    bool animate, blend, lighting, shaderNeedsUpdate;
    Ogre::Real animMag, animSpeed, animFreq;
 
    //Current frame of animation for this layer
    Ogre::Real waveCount;
 
    PagedGeometry *geom;
};
 
 
class GrassPage: public GeometryPage
{
public:
    void init(PagedGeometry *geom, const Ogre::Any &data);
    ~GrassPage();
 
    void addEntity(Ogre::Entity *ent, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, const Ogre::Vector3 &scale, const Ogre::ColourValue &color);
    void removeEntities();
    void setFade(bool enabled, Ogre::Real visibleDist, Ogre::Real invisibleDist) {}
    void setVisible(bool visible);
 
private:
    Ogre::SceneManager *sceneMgr;
    Ogre::SceneNode *rootNode;
 
    std::list<Ogre::SceneNode*> nodeList;
 
    static unsigned long GUID;
    static inline Ogre::String getUniqueID()
    {
        return "GrassPage" + Ogre::StringConverter::toString(++GUID);
    }
};
 
 
}
 
#endif