PerlinNoise.h

#ifndef PERLIN_NOISE_
#define PERLIN_NOISE_

#include <math.h>
#include <stdio.h>
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

#include "Geometry.h"

#define LINEAR_INTERPOLATION            0
#define COSINE_INTERPOLATION            1
#define CUBIC_INTERPOLATION                     2


class PerlinNoise
{
public:
        PerlinNoise (int size_x, int size_y);

        ~PerlinNoise ();

        void SetForegroundColor (float red, float green, float blue, float alpha);

        void SetBackgroundColor (float red, float green, float blue, float alpha);

        void SetParameters (float frequency, float persistence, int octaves, bool smooth);

        void SetInterpolationMode (int mode);

        void TransformXY (float (* processor)(float x, float y, float value));

        void TransformAB (float a, float b, float (* processor)(float a, float b, float value));

        void GenerateNoise ();

        void ExportRGB256 (GLubyte * data_pointer);

        void Export (float * data_pointer);

        void GetDimensions (int &dim_x, int &dim_y);

        void Push ();

        void FlushToColorBuffer ();

        void CombineColorBuffers (float (* combiner)(float val_1, float val_2));

        void CombineColorBuffersAB (float a, float b, float (* combiner)(float a, float b, float val_1, float val_2));

        void SmoothBorder (int border);


private:
        PerlinNoise ();

        void Pop ();

        bool IsEmpty ();

        float GetSmoothedValue (float x, float y);

        float GetNoiseValue (float x, float y);

        float GetNoise2D (int x, int y);

        float Interpolate (float value_1, float value_2, float fraction);

        float LinearInterpolation (float value_1, float value_2, float fraction);

        float CosineInterpolation (float value_1, float value_2, float fraction);

        float CubicInterpolation (float value_1, float value_2, float fraction);

        int size_x;

        int size_y;

        typedef struct StackElem
        {
                float background[4];                            
                float foreground[4];                            
                float frequency;                                        
                float persistence;                                      
                int octaves;                                            
                bool smooth;                                            
                int interpolation;                                      
                float * perlin_buffer;                          
                float * color_buffer;                           
                StackElem * next;                                       
        }PerlinStack;

        PerlinStack * top;                                              
//-------------------------------------------------------------------------------------------
//                                                              PREDEFINED ROUTINES
//-------------------------------------------------------------------------------------------
public:

        static float RangeTransform (float a, float b, float perlin_xy);

        static float LinearTransform (float a, float b, float perlin_xy);

        static float MarblyTransform (float x, float y, float perlin_xy);

        static float GrainyTransform (float x, float y, float perlin_xy);

        static float SumCombiner (float val_1, float val_2);

        static float ProductCombiner (float val_1, float val_2);

        static float MaximumCombiner (float val_1, float val_2);

        static float WeightedSumCombiner (float weight_1, float weight_2, float val_1, float val_2);
};


#endif

---