PerlinNoise.cpp

#include "PerlinNoise.h"

PerlinNoise::PerlinNoise (int size_x_, int size_y_)
{
        size_x = size_x_;
        size_y = size_y_;

        // push a first element onto the stack
        top = NULL;
        Push ();

}

PerlinNoise::~PerlinNoise ()
{
        while (!IsEmpty ())
        {Pop ();}
}

void PerlinNoise::Push ()
{
        StackElem * top_noise;

        if (top == NULL)
        {
                top = new StackElem;
                top->next = NULL;
        }
        else
        {
                top_noise = new StackElem;
                top_noise->next = top;
                top = top_noise;
        }

        // set default values and allocate memory
        SetParameters (1.0, 0.25, 8, true);
        SetBackgroundColor (0.0f, 0.0f, 0.0f, 1.0f);
        SetForegroundColor (1.0f, 1.0f, 1.0f, 1.0f);

        top->interpolation = CUBIC_INTERPOLATION;
        top->perlin_buffer = new float[size_x * size_y];
        top->color_buffer = new float[size_x * size_y * 4];
}

void PerlinNoise::Pop ()
{
        StackElem * old_top;

        if (IsEmpty ())
        {printf ("PerlinNoise: Cannot pop from empty stack\n"); return;}

        old_top = top;
        top = top->next;

        // free top element 
        delete old_top->perlin_buffer;
        delete old_top->color_buffer;
        delete old_top;
}

bool PerlinNoise::IsEmpty ()
{
        return top == NULL;
}

void PerlinNoise::FlushToColorBuffer ()
{
        for (int index = 0; index < size_x * size_y; index++)
        {
                for (int c = 0; c < 4; c++)
                {top->color_buffer[4*index + c] = top->background[c] * (1 - top->perlin_buffer[index]) + top->foreground[c] * top->perlin_buffer[index];}
        }
}

void PerlinNoise::SetBackgroundColor (float red, float green, float blue, float alpha)
{
        top->background[0] = red;
        top->background[1] = green;
        top->background[2] = blue;
        top->background[3] = alpha;
}

void PerlinNoise::SetForegroundColor (float red, float green, float blue, float alpha)
{
        top->foreground[0] = red;
        top->foreground[1] = green;
        top->foreground[2] = blue;
        top->foreground[3] = alpha;
}

void PerlinNoise::SetParameters (float frequency_, float persistence_, int octaves_, bool smooth_)
{
        top->frequency = frequency_;
        top->persistence = persistence_;
        top->octaves = octaves_;
        top->smooth = smooth_;
}

void PerlinNoise::SetInterpolationMode (int mode)
{
        top->interpolation = mode;
}

void PerlinNoise::GetDimensions (int & dim_x, int & dim_y)
{
        dim_x = size_x;
        dim_y = size_y;
}

void PerlinNoise::GenerateNoise ()
{
        float total;
        float amplitude;
        float base_frequency;
        float current_frequency;

        base_frequency = top->frequency / sqrt ((float)(size_x*size_x + size_y*size_y)) / 1.414;

        // calculate a random offset in order to get a different noise
        float x_rand = (((float)(rand())) / ((float)(RAND_MAX))) * 100.0f;
        float y_rand = (((float)(rand())) / ((float)(RAND_MAX))) * 100.0f;

        for (int y = 0; y < size_y; y++)
        {
                for (int x = 0; x < size_x; x++)
                {
                        total = 0.0f;
                        amplitude = 1.0f;
                        current_frequency = base_frequency;

                        // sum up all 
                        for (int k = 0; k < top->octaves; k++)
                        {
                                if (!top->smooth)
                                {total += GetNoiseValue ((x_rand + x) * current_frequency, (y_rand + y) * current_frequency) * amplitude;}
                                else
                                {total += GetSmoothedValue ((x_rand + x) * current_frequency, (y_rand + y) * current_frequency) * amplitude;}

                                amplitude *= top->persistence;
                                current_frequency *= 2;
                        }

                        top->perlin_buffer[x + size_x * y] = total;
                }
        }
}

void PerlinNoise::TransformXY (float (* processor)(float x, float y, float value))
{
        float base_frequency;

        base_frequency = top->frequency / sqrt ((float)(size_x*size_x + size_y*size_y)) / 1.414;
        
        for (int y = 0; y < size_y; y++)
        {
                for (int x = 0; x < size_x; x++)
                {
                        top->perlin_buffer[x + size_x * y] = processor (x * base_frequency, y * base_frequency, top->perlin_buffer[x + size_x * y]);
                }
        }
}

void PerlinNoise::TransformAB (float a, float b, float (* processor)(float a, float b, float value))
{
        for (int index = 0; index < size_x * size_y; index++)
        {
                top->perlin_buffer[index] = processor (a, b, top->perlin_buffer[index]);
        }
}

void PerlinNoise::ExportRGB256 (GLubyte * data_pointer)
{
        int byte;

        for (int index = 0; index < size_x * size_y * 4; index++)
        {
                byte = 255.0f * top->color_buffer[index];
                if (byte > 255) byte = 255;
                if (byte < 0) byte = 0;

                if (index%4 != 3)
                {data_pointer [(index/4)*3 + index%4] = byte;}
        }
}

void PerlinNoise::Export (float * data_pointer)
{
        for (int index = 0; index < size_x * size_y; index++)
        {
                data_pointer[index] = top->perlin_buffer[index];
        }
}

void PerlinNoise::CombineColorBuffers (float (* combiner)(float val_1, float val_2))
{
        if (top == NULL || top->next == NULL)
        {printf ("Perlin Noise: Cannot combine color buffers because there are less than two\n");}

        float * buffer_1;
        float * buffer_2;

        buffer_1 = top->color_buffer;
        buffer_2 = top->next->color_buffer;

        for (int index = 0; index < size_x * size_y * 4; index++)
        {
                buffer_2[index] = combiner (buffer_1[index], buffer_2[index]);
        }

        Pop ();
}

void PerlinNoise::CombineColorBuffersAB (float a, float b, float (* combiner)(float a, float b, float val_1, float val_2))
{
        if (top == NULL || top->next == NULL)
        {printf ("Perlin Noise: Cannot combine color buffers because there are less than two\n");}

        float * buffer_1;
        float * buffer_2;

        buffer_1 = top->color_buffer;
        buffer_2 = top->next->color_buffer;

        for (int index = 0; index < size_x * size_y * 4; index++)
        {
                buffer_2[index] = combiner (a, b, buffer_1[index], buffer_2[index]);
        }

        Pop ();
}

void PerlinNoise::SmoothBorder (int border)
{
        if (border == 0) return;

        for (int y = 0; y < size_y; y++)
        {
                for (int x = 0; x < size_x; x++)
                {
                        if (x < border)
                        {
                                top->perlin_buffer[x + y * size_x] *= 1 - ((float)(border - x)) / border;
                                top->perlin_buffer[x + y * size_x] *= 1 - ((float)(border - x)) / border;
                        }
                        if (y < border)
                        {
                                top->perlin_buffer[x + y * size_x] *= 1 - ((float)(border - y)) / border;
                                top->perlin_buffer[x + y * size_x] *= 1 - ((float)(border - y)) / border;
                        }
                        if (x > size_x - border - 1)
                        {
                                top->perlin_buffer[x + y * size_x] *= 1 - ((float)(border - (size_x - x - 1))) / border;
                                top->perlin_buffer[x + y * size_x] *= 1 - ((float)(border - (size_x - x - 1))) / border;
                        }
                        if (y > size_y - border - 1)
                        {
                                top->perlin_buffer[x + y * size_x] *= 1 - ((float)(border - (size_y - y - 1))) / border;
                                top->perlin_buffer[x + y * size_x] *= 1 - ((float)(border - (size_y - y - 1))) / border;
                        }       
                }
        }
}

float PerlinNoise::GetSmoothedValue (float x, float y)
{
        float weighted_edges;
        float weighted_corners;
        float weighted_center;

        weighted_center = GetNoiseValue (x, y) / 4.0f;
        weighted_edges = (GetNoiseValue (x-1, y) + GetNoiseValue (x+1, y)+ GetNoiseValue (x, y-1) + GetNoiseValue (x, y+1)) / 8.0f;
        weighted_corners = (GetNoiseValue (x-1, y-1) + GetNoiseValue (x+1, y-1) + GetNoiseValue (x+1, y+1) + GetNoiseValue (x-1, y+1)) / 16.0f;

        return weighted_center + weighted_edges + weighted_corners;
}

float PerlinNoise::GetNoiseValue (float x, float y)
{
        int x_int, y_int;
        float x_resi, y_resi;
        float x0y0, x1y0, x0y1, x1y1;
        float interpol_y0, interpol_y1;
        float result;

        x_int = (int)x;
        y_int = (int)y;
        x_resi = x - x_int;
        y_resi = y - y_int;

        x0y0 = GetNoise2D (x_int, y_int);
        x1y0 = GetNoise2D (x_int + 1, y_int);
        x0y1 = GetNoise2D (x_int, y_int + 1);
        x1y1 = GetNoise2D (x_int + 1, y_int + 1);

        interpol_y0 = Interpolate (x0y0, x1y0, x_resi);
        interpol_y1 = Interpolate (x0y1, x1y1, x_resi);
        result = Interpolate (interpol_y0, interpol_y1, y_resi);

        return result;
}

float PerlinNoise::GetNoise2D (int x, int y)
{
        int n;
        float res;
   
        n = x + y * 57;
        n = (n<<13) ^ n;
    res = (float)( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff ) / 1073741824.0);
   
        return res;
}

float PerlinNoise::Interpolate (float value_1, float value_2, float fraction)
{
        switch (top->interpolation)
        {
                case LINEAR_INTERPOLATION:      return LinearInterpolation (value_1, value_2, fraction);
                                                                        break;
                case COSINE_INTERPOLATION:      return CosineInterpolation (value_1, value_2, fraction);
                                                                        break;
                case CUBIC_INTERPOLATION:       return CubicInterpolation (value_1, value_2, fraction);
                                                                        break;
                default:                                        printf ("Unknown interpolation mode\n");
        }

        return 0.0f;
}

float PerlinNoise::LinearInterpolation (float value_1, float value_2, float fraction)
{
        return value_1 * (1 - fraction) + value_2 * fraction;
}

float PerlinNoise::CosineInterpolation (float value_1, float value_2, float fraction)
{
        fraction = (1 - cos (fraction * MY_PI)) * 0.5f;
        return  value_1 * (1 - fraction) + value_2 * fraction;
}

float PerlinNoise::CubicInterpolation (float value_1, float value_2, float fraction)
{
        return  value_1 * (3*(1-fraction)*(1-fraction) - 2*(1-fraction)*(1-fraction)*(1-fraction)) + 
                        value_2 * (3*fraction*fraction - 2*fraction*fraction*fraction);
}


float PerlinNoise::RangeTransform (float a, float b, float perlin_xy)
{
        if (perlin_xy < a) perlin_xy = a;
        if (perlin_xy > b) perlin_xy = b;

        return perlin_xy;
}

float PerlinNoise::LinearTransform (float a, float b, float perlin_xy)
{
        return a * perlin_xy + b;
}

float PerlinNoise::MarblyTransform (float x, float y, float perlin_xy)
{
        return cos (x + perlin_xy);
}

float PerlinNoise::GrainyTransform (float x, float y, float perlin_xy)
{
        float grain;

        grain = perlin_xy * 20;
        return (grain - (int)(grain)) + perlin_xy;
}

float PerlinNoise::SumCombiner (float val_1, float val_2)
{
        return val_1 + val_2;
}

float PerlinNoise::ProductCombiner (float val_1, float val_2)
{
        return val_1 * val_2;
}

float PerlinNoise::MaximumCombiner (float val_1, float val_2)
{
        if (val_1 > val_2 ) return val_1; else return val_2;
}

float PerlinNoise::WeightedSumCombiner (float weight_1, float weight_2, float val_1, float val_2)
{
        return weight_1 * val_1 + weight_2 * val_2;
}

---