mod_sim_terrain_heightmap.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2007 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#if COMPILING_MODULE
#ifndef MOD_SIM_TERRAIN_HEIGHTMAP_HH
#define MOD_SIM_TERRAIN_HEIGHTMAP_HH 1

#include "eng_task.hh"

namespace mod_sim {

class Heightmap : public Shared
{
  // way too big to copy
friend class Terrain;
friend class TileFactory;
public:
    typedef uint8 Height;
    CLASS_CONST uint HEIGHT_INVALID = 0xff;
    CLASS_CONST uint HEIGHT_LIMIT   = 0xfe;

public:
    class Elem
    {
    public:
        // Uninitialized for speed, Heightmap() ctor can clear optionally.
        Elem( void )
        {
            
        }

        ~Elem( void ) { }

        fp GetHeight( void ) const
        {
            ASSERT( mHeight != Heightmap::HEIGHT_INVALID );  // was element computed?

            return fp(mHeight) / fp(Heightmap::HEIGHT_LIMIT);
        }

        Heightmap::Height GetHeightDirect( void ) const
        {
            ASSERT( mHeight != Heightmap::HEIGHT_INVALID );  // was element computed?

            return mHeight;
        }

        void SetHeight( Heightmap::Height height )
        {
            // Change height in case value has the reserved invalid value.
            

            mHeight = height;
        }

    private:
        Heightmap::Height   mHeight;  
    };

//------------------------------------------------------------------------------
// Parameters for initializing a Heightmap.
public:
    struct InitArgs
    {
        InitArgs( const BoxVolume& boxVolume,
                  const int        heightmapWidth,
                  const fp         heightScale );
        #if DEBUG
        void Check( void ) const;
        #endif

        // See Heightmap data members for desc.
        BoxVolume   mBoxVolume;         // passed
        int         mHeightmapWidth;    // passed
        fp          mHeightScale;       // passed
        fp          mWidthInWorld;      // computed
    };

//------------------------------------------------------------------------------
// Noise args:
public:
    struct NoiseArgs
    {
        NoiseArgs( fp inc, fp z ) : mInc(inc), mZ(z) { }
        fp      mInc;   // increment across coordinates in Noise Space
        fp      mZ;     // Z in 3D Noise Space
    };

//------------------------------------------------------------------------------
// Graphic task:
private:
    class TextureTask : public Task::TaskFunctor
    {
    public:
        TextureTask( Heightmap& heightmap, Array2D<Texture::Texel32>& colormap )
        : mHeightmap(heightmap), mColormap(colormap)
        {
        }
        void operator()( void );

        Heightmap&                  mHeightmap;
        Array2D<Texture::Texel32>&  mColormap;
    };
    friend class TextureTask;

//------------------------------------------------------------------------------
// Heightmap methods:
//
// Note: There are two (lat,lon) coordinate spaces:
// (hmLat,hmLon) and (worldLat,worldLon).

public:
            Heightmap( void );
            Heightmap( const InitArgs& initArgs );
            Heightmap( const InitArgs& initArgs, const NoiseArgs& noiseArgs );
            ~Heightmap();

private:
    void    Init( const InitArgs& initArgs );
    void    InitRandomNumbers( const InitArgs& initArgs );
    void    ComputePalette( void );

public:
    void SetHeight( const int hmLat, const int hmLon, const Height height )
    {
    ASSERT2( mValid );

        return mHeightmap.Get(hmLat,hmLon).SetHeight( height );  // Elem::GetHeight()
    }

    fp GetHeight( const int hmLat, const int hmLon ) const
    {
    ASSERT2( mValid );
  //ASSERT2( (hmLat < mHeightmapWidth) && (hmLon < mHeightmapWidth) );  // let Array2D clamp

        return mHeightmap.Get(hmLat,hmLon).GetHeight();  // Elem::GetHeight()
    }

    Heightmap::Height GetHeightDirect( const int hmLat, const int hmLon ) const
    {
    ASSERT2( mValid );
  //ASSERT2( (hmLat < mHeightmapWidth) && (hmLon < mHeightmapWidth) );  // let Array2D clamp

        return mHeightmap.Get(hmLat,hmLon).GetHeightDirect();
    }

    fp GetHeightScaled( const int hmLat, const int hmLon ) const
    {
    ASSERT2( mValid );
    ASSERT2( mHeightScale > 0.0 );

        return GetHeight(hmLat,hmLon) * mHeightScale;
    }

    fp GetHeightScaledInterpolated( const fp worldLat, const fp worldLon ) const
    {
    ASSERT2( mValid );
    ASSERT2( mHeightmapWorldRatio != 0.0 );
    ASSERT2( IfInsideApprox(worldLat,worldLon) );

        // (worldCoord-worldCoord) * (mapCoord/worldCoord) = worldCoord * (mapCoord/worldCood) = mapCoord
        int hmLat = int((worldLat - mBoxVolume.mMin.LAT_) * mHeightmapWorldRatio);
        int hmLon = int((worldLon - mBoxVolume.mMin.LON_) * mHeightmapWorldRatio);
        // TODO: Interpolation formula.
        return GetHeightScaled( hmLat, hmLon );
    }

    // Get an average height value.
    CLASS_METHOD Heightmap::Height
    GetHeightMedian( void );

    // Convert height into a world coordinate.
    fp ScaleHeight( const Height height )
    {
    ASSERT2( mHeightScale > 0.0 );
        return fp(height) / fp(HEIGHT_LIMIT) * mHeightScale;
    }

    WorldVertex GetPosition( const int hmLat, const int hmLon ) const
    {
    ASSERT2( mValid );
    ASSERT2( mWorldHeightmapRatio > 0.0 );
    ASSERT2( IfInsideApprox( hmLat * mWorldHeightmapRatio,
                             hmLon * mWorldHeightmapRatio ) );

        // mapCoord * (worldCoord/mapCoord) = worldCoord
        return WorldVertex( LAT_LON_ALT( mBoxVolume.mMin.LAT_ + hmLat * mWorldHeightmapRatio,
                                         mBoxVolume.mMin.LON_ + hmLon * mWorldHeightmapRatio,
                                         GetHeightScaled(hmLat,hmLon) ) );
    }

    uint GetIdx( const int hmLat, const int hmLon ) const
    {
    ASSERT2( mValid );
  //ASSERT2( (hmLat < mHeightmapWidth) && (hmLon < mHeightmapWidth) );  // let Array2D clamp

        return mHeightmap.GetIdx( hmLat, hmLon );
    }

    SharedPtr<Texture> GetColormapTexture( void ) const
    {
        return mColormapTexture;
    }

    TexCoord GetColormapTexCoord( const fp worldLat, const fp worldLon ) const
    {
        // Clamp tex coords.
        const fp tx = Clamp1( (worldLat - mBoxVolume.mMin.LAT_) / mWidthInWorld );
        const fp ty = Clamp1( (worldLon - mBoxVolume.mMin.LON_) / mWidthInWorld );
      //return TexCoord( tx, ty );
        return TexCoord( ty, tx );  // transpose
    }

#if DEBUG
    bool IfInsideApprox( const fp worldLat, const fp worldLon ) const;
#endif

    // Directly access element by flat index.
    Elem&       operator[]( uint i )       { return mHeightmap[i]; }  // Array2D[i]
    const Elem& operator[]( uint i ) const { return mHeightmap[i]; }

//------------------------------------------------------------------------------
// Water texture:
    class WaterTexture
    {
    public:
                WaterTexture( const uint heightmapWidth );
                ~WaterTexture();

        inline uint
        CLAMP_WATER_COLOR( uint in )
        {
            if ( in < 0 )
                return 0;
            else if ( in > 150 )
                return 150;
            else
                return in;
        }

        inline Texture::Texel32
        GetTexel( const uint lat, const uint lon )
        {
            uint bufIdx = uint((lat * mIdxRatio) + (lon * mIdxRatio * mBufWidth)) << 2;
            ASSERT( bufIdx+3 < mBufLen );
            const uint8* c = reinterpret_cast<const uint8*>( &mBuf[bufIdx] );
            return ( CLAMP_WATER_COLOR(c[BB]- 70) << TexelDefs::TEXEL32_BB_BIT_SHIFT )
                 | ( CLAMP_WATER_COLOR(c[GG]-180) << TexelDefs::TEXEL32_GG_BIT_SHIFT )
                 | ( CLAMP_WATER_COLOR(c[RR]-180) << TexelDefs::TEXEL32_RR_BIT_SHIFT )
                 | (                   c[AA]      << TexelDefs::TEXEL32_AA_BIT_SHIFT );

        }

    private:
        Targa*          mTarga;
        const uint8*    mBuf;           // see Targa
        uint            mBufLen;
        uint            mBufWidth;
        fp              mIdxRatio;      // maps heightmap (lat,lon) to waterTexture (tx,ty)
    };

//------------------------------------------------------------------------------
// Heightmap data:
//
// BoxVolume:
// Part of the World this Heightmap occupies.
//
// HeightmapWidth:
// Determines the size of the Heightmap 2D array.
// Width is in terms of height values.
// This width is allowed to differ from the width of the texture image.
// If heightmapWidth is smaller than the texture width, resolution will be lost.
//
// HeightScale:
// Multiplies a Height value.
// Equivalent to the altitude limit in World Space.

private:
    CLASS_VAR int           msHeightmapWidthMinus1;  // tweak
    CLASS_VAR Array2D<fp>   msRandomHeight;  
    CLASS_VAR Array2D<uint> msRandomColor;   
    CLASS_VAR vector<RGBA>  msPalette;       
    CLASS_VAR WaterTexture* msWaterTexture;

    bool            mValid;

    // Spatial:
    BoxVolume       mBoxVolume;             
    fp              mWidthInWorld;          
    fp              mHeightScale;           
    fp              mHeightScaleHalf;
    fp              mWorldHeightmapRatio;   
    fp              mHeightmapWorldRatio;   

    // Heightmap:
    typedef Array2D<Elem,Shared> HeightmapArray2D;
    HeightmapArray2D mHeightmap;            
    int             mHeightmapWidth;        

    // Colormap:
    shptr<Texture>  mColormapTexture;       

#if DEBUG
public:
    CLASS_VAR bool msDisableIfInsideApprox;  // some cases do produce (lat,lon) outside a volume
#endif
};

} // namespace mod_sim

#endif // MOD_SIM_TERRAIN_HEIGHTMAP_HH
#endif // COMPILING_MODULE

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:13 2007