Perlin.h

Go to the documentation of this file.

/*
--------------------------------------------------------------------------------
This source file is part of Hydrax.
Visit ---
 
Copyright (C) 2008 Xavier Verguín González <xavierverguin@hotmail.com>
                                           <xavyiy@gmail.com>
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser 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, or go to
http://www.gnu.org/copyleft/lesser.txt.
--------------------------------------------------------------------------------
 
Based on the perlin noise code from Claes Johanson thesis:
http://graphics.cs.lth.se/theses/projects/projgrid/
--------------------------------------------------------------------------------
*/
 
#ifndef _Hydrax_Noise_Perlin_H_
#define _Hydrax_Noise_Perlin_H_
 
#include "Noise.h"
 
 
 
#define n_bits              5
#define n_size              (1<<(n_bits-1))
#define n_size_m1           (n_size - 1)
#define n_size_sq           (n_size*n_size)
#define n_size_sq_m1        (n_size_sq - 1)
 
#define n_packsize          4
 
#define np_bits             (n_bits+n_packsize-1)
#define np_size             (1<<(np_bits-1))
#define np_size_m1          (np_size-1)
#define np_size_sq          (np_size*np_size)
#define np_size_sq_m1       (np_size_sq-1)
 
#define n_dec_bits          12
#define n_dec_magn          4096
#define n_dec_magn_m1       4095
 
#define max_octaves         32
 
#define noise_frames        256
#define noise_frames_m1     (noise_frames-1)
 
#define noise_decimalbits   15
#define noise_magnitude     (1<<(noise_decimalbits-1))
 
#define scale_decimalbits   15
#define scale_magnitude     (1<<(scale_decimalbits-1))
 
namespace Hydrax{ namespace Noise
{
    class Perlin : public Noise
    {
    public:
        struct Options
        {
            int Octaves;
            float Scale;
            float Falloff;
            float Animspeed;
            float Timemulti;
 
            float GPU_Strength;
            Ogre::Vector3 GPU_LODParameters;
 
            Options()
                : Octaves(8)
                , Scale(0.085f)
                , Falloff(0.49f)
                , Animspeed(1.4f)
                , Timemulti(1.27f)
                , GPU_Strength(2.0f)
                , GPU_LODParameters(Ogre::Vector3(0.5f, 50, 150000))
            {
            }
 
            Options(const int   &_Octaves,
                    const float &_Scale,
                    const float &_Falloff,
                    const float &_Animspeed,
                    const float &_Timemulti)
                : Octaves(_Octaves)
                , Scale(_Scale)
                , Falloff(_Falloff)
                , Animspeed(_Animspeed)
                , Timemulti(_Timemulti)
                , GPU_Strength(2.0f)
                , GPU_LODParameters(Ogre::Vector3(0.5f, 50, 150000))
            {
            }
 
            Options(const int   &_Octaves,
                    const float &_Scale,
                    const float &_Falloff,
                    const float &_Animspeed,
                    const float &_Timemulti,
                    const float &_GPU_Strength,
                    const Ogre::Vector3 &_GPU_LODParameters)
                : Octaves(_Octaves)
                , Scale(_Scale)
                , Falloff(_Falloff)
                , Animspeed(_Animspeed)
                , Timemulti(_Timemulti)
                , GPU_Strength(_GPU_Strength)
                , GPU_LODParameters(_GPU_LODParameters)
            {
            }
        };
 
        Perlin();
 
        Perlin(const Options &Options);
 
        ~Perlin();
 
        void create();
 
        void remove();
 
        bool createGPUNormalMapResources(GPUNormalMapManager *g);
 
        void update(const Ogre::Real &timeSinceLastFrame);
 
        void saveCfg(Ogre::String &Data);
 
        bool loadCfg(Ogre::ConfigFile &CfgFile);
 
        float getValue(const float &x, const float &y);
 
        void setOptions(const Options &Options);
 
        inline const Options& getOptions() const
        {
            return mOptions;
        }
 
    private:
        void _initNoise();
 
        void _calculeNoise();
 
        void _updateGPUNormalMapResources();
 
        int _readTexelLinearDual(const int &u, const int &v, const int &o);
 
        float _getHeigthDual(float u, float v);
 
        int _mapSample(const int &u, const int &v, const int &upsamplepower, const int &octave);
 
        int noise[n_size_sq*noise_frames];
        int o_noise[n_size_sq*max_octaves];
        int p_noise[np_size_sq*(max_octaves>>(n_packsize-1))];
        int *r_noise;
        float magnitude;
 
        double time;
 
        GPUNormalMapManager *mGPUNormalMapManager;
 
        Options mOptions;
    };
}}
 
 
#endif