terrainmorph.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2007
        www.grinninglizard.com/lilith

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

        The full text of the license can be found in license.txt
*/
#ifndef LILITH_TERRAINMORPH_INCLUDED
#define LILITH_TERRAINMORPH_INCLUDED

#ifdef _MSC_VER
#pragma warning( disable : 4786 )       // Debugger truncating names.
#pragma warning( disable : 4530 )       // Exception handler isn't used
#endif

#include "../grinliz/gltypes.h"
#include "../grinliz/glrandom.h"
#include "../grinliz/glpublisher.h"
#include "../grinliz/glvector.h"
#include "../grinliz/glrectangle.h"
#include "../grinliz/glgeometry.h"
#include "sequence.h"

namespace lilith3d
{

class TerrainMesh;
class TimeClock;
class VolcanoMorph;
//class PointLight;
class StaticResource;
class Texture;
class DecalMesh;

class TerrainMorph : public ISequence
{
  public:
        TerrainMorph();
    virtual ~TerrainMorph();

        virtual bool DoSequence( TimeClock* timeClock ) = 0;

protected:
        void GenerateHeightMap( grinliz::LineLoop* loop, 
                                                        float blendDistance,
                                                        float contribution,
                                                        float* maxDelta );
        void DoTick( TimeClock* timeClock, float speed );


        grinliz::Rectangle2I mapBounds; // Set if a height map was generated.
        float* targetMap;

        grinliz::Random rand;
};


class VolcanoMorphListener : public grinliz::Listener< VolcanoMorphListener >
{
  public:
        virtual void VolcanoGrow( VolcanoMorph* volcano, int x, int y, float newAltitude ) = 0;
        virtual void VolcanoDone( VolcanoMorph* volcano, int x, int y, float finalAltitude ) = 0;
};


class VolcanoMorph : public TerrainMorph
{
  public:
        VolcanoMorph( int x, int y, float altitude );
        ~VolcanoMorph();

        void AddTexture( const Texture* texture );

        grinliz::Publisher< VolcanoMorphListener > publish;

        virtual bool DoSequence( TimeClock* timeClock );

  private:
        enum {
                FUZZ_SIZE = 37
        };
        float fuzzHeight[ FUZZ_SIZE ];

        float                   altitude;
//      PointLight*             glowLight;
        U32                             lastParticleTime;
        int                             terrainX, terrainY;
        DecalMesh*              decal;
};

class PitMorph;

class PitMorphListener : public grinliz::Listener< PitMorphListener >
{
  public:
        virtual void PitSink( PitMorph* pit, int x, int y, float newAltitude ) = 0;
        virtual void PitDone( PitMorph* pit, int x, int y, float finalAltitude ) = 0;
};


class PitMorph : public TerrainMorph
{
  public:
        PitMorph( int x, int y, float altitude );
        ~PitMorph()     {}

        grinliz::Publisher< PitMorphListener > publish;

        virtual bool DoSequence( TimeClock* timeClock );

  private:
        float   altitude;
        int             terrainX, terrainY;
};


class BridgeMorph;

class BridgeMorphListener : public grinliz::Listener< BridgeMorphListener >
{
  public:
        virtual void BridgeDone( BridgeMorph* bridge ) = 0;
};


class BridgeMorph : public TerrainMorph
{
  public:
        BridgeMorph( float width, float originX, float originY, float destX, float destY );
        ~BridgeMorph()  {}

        grinliz::Publisher< BridgeMorphListener > publish;

        virtual bool DoSequence( TimeClock* timeClock );

  private:
        //void SetBridgeHeight( TerrainMesh* mesh, int x, int y, float h );
        float maxDelta; 
        U32 startTime;
};

class FlattenMorph;

class FlattenMorphListener : public grinliz::Listener< FlattenMorphListener >
{
  public:
        virtual void FlattenDone( FlattenMorph* flatten ) = 0;
};


class FlattenMorph : public TerrainMorph
{
public:
        FlattenMorph( const grinliz::Rectangle2I& bounds, float height, float blendDistace=1.0f, float blendAmount=1.0f );
        virtual ~FlattenMorph() {};

        grinliz::Publisher< FlattenMorphListener > publish;     

        virtual bool DoSequence( TimeClock* timeClock );

        const grinliz::Rectangle2I& Bounds() const      { return bounds; }
        float HeightTarget() const                                      { return heightTarget; }

  private:
        U32 startTime;
        U32 runTime;
        grinliz::Rectangle2I bounds;
        float heightTarget;
        float maxDelta;
};

class BuildingMorph;
class BuildingMesh;

class BuildingMorphListener : public grinliz::Listener< BuildingMorphListener >
{
  public:
        virtual void BuildingMorphDone( BuildingMorph* flatten, BuildingMesh* placed ) = 0;
};


class BuildingMorph : public TerrainMorph
{
public:
        BuildingMorph( int x, int y, float height, const StaticResource* buildingResource );
        virtual ~BuildingMorph()        {};

        void SetTime( U32 timeInMSec );

        grinliz::Publisher< BuildingMorphListener > publish;

        virtual bool DoSequence( TimeClock* timeClock );

        const grinliz::Rectangle2I& Bounds()    { return bounds; }

  private:
        U32 startTime;
        U32 runTime;
        float ratio;

        grinliz::Rectangle2I bounds;    // vertex bounds of the building
        grinliz::Vector2I        pos;                   // location
        float maxDelta;
        bool canPlace;
        const StaticResource* resource;
};

// Used for debugging. Changes the terrain on a regular interval to test pathing, buildings, etc.
class CycleMorph : public TerrainMorph
{
  public:
        CycleMorph( float intensity, int iterations );
        virtual ~CycleMorph()   {}

        virtual bool DoSequence( TimeClock* tc );

  private:
        int maxIteration;
        float intensity;
        int index;
        float bias;
        int iteration;
};

};      // namespace lilith3d

#endif

---