perlin 0.1.0pre1-x86-mingw32

data/ext/perlin/classic.c

@@ -0,0 +1,160 @@
+#include "classic.h"
+
+long seed = 0; // Speeds up lookup of this value when it is accessed a LOT. PROBABLY NOT THREAD SAFE!
+
+static inline float perlin_interpolate(const float a, const float b, const float x)
+{
+    const float ft = x * M_PI;
+    const float f = (1 - cos(ft)) * 0.5;
+    return    a * (1 - f) + b * f;
+}
+
+
+// 2D ------------------------------------------------------------------
+
+static inline float perlin_noise_2d(const int x, const int y)
+{
+    long n = x + y * 57;
+    n = (n << 13) ^ n;
+    return (1.0 - ((n * (n * n * 15731*seed + 789221*seed) + 1376312589*seed) & 0x7fffffff) / 1073741824.0);
+}
+
+static float perlin_smooth_noise_2d(const int x, const int y)
+{
+    const float corners = (
+        perlin_noise_2d(x - 1, y - 1) +
+        perlin_noise_2d(x + 1, y - 1) +
+        perlin_noise_2d(x - 1, y + 1) +
+        perlin_noise_2d(x + 1, y + 1)
+        ) / 4;
+    const float sides     = (
+        perlin_noise_2d(x - 1, y) +
+        perlin_noise_2d(x + 1, y) +
+        perlin_noise_2d(x, y - 1) +
+        perlin_noise_2d(x, y + 1)
+        ) /    4;
+    const float center    =  perlin_noise_2d(x, y) / 4;
+    return corners + sides + center;
+}
+
+float perlin_interpolated_noise_2d(const float x, const float y)
+{
+    const int integer_X         = (int)x;
+    const float fractional_X    = x - integer_X;
+
+    const int integer_Y         = (int)y;
+    const float fractional_Y    = y - integer_Y;
+
+    const float v1 = perlin_smooth_noise_2d(integer_X,         integer_Y);
+    const float v2 = perlin_smooth_noise_2d(integer_X + 1, integer_Y);
+    const float v3 = perlin_smooth_noise_2d(integer_X,         integer_Y + 1);
+    const float v4 = perlin_smooth_noise_2d(integer_X + 1, integer_Y + 1);
+
+    const float i1 = perlin_interpolate(v1, v2, fractional_X);
+    const float i2 = perlin_interpolate(v3, v4, fractional_X);
+
+    return perlin_interpolate(i1, i2, fractional_Y);
+}
+
+float perlin_octaves_2d(const float x, const float y, const float p, const float n)
+{
+    float total = 0.;
+    float frequency = 1., amplitude = 1.;
+    int i;
+
+    for (i = 0; i < n; ++i)
+    {
+        total += perlin_interpolated_noise_2d(x * frequency, y * frequency) * amplitude;
+        frequency *= 2;
+        amplitude *= p;
+    }
+
+    return total;
+}
+
+// 3D ------------------------------------------------------------------
+
+static inline float perlin_noise_3d(const int x, const int y, const int z)
+{
+    long n = x + y + z * 57;
+    n = (n << 13) ^ n;
+    return (1.0 - ((n * (n * n * 15731*seed + 789221*seed) + 1376312589*seed) & 0x7fffffff) / 1073741824.0);
+}
+
+static float perlin_smooth_noise_3d(const int x, const int y, const int z)
+{
+    const float corners = (
+        perlin_noise_3d(x - 1, y - 1, z + 1) +
+        perlin_noise_3d(x + 1, y - 1, z + 1) +
+        perlin_noise_3d(x - 1, y + 1, z + 1) +
+        perlin_noise_3d(x + 1, y + 1, z + 1) +
+        perlin_noise_3d(x - 1, y - 1, z - 1) +
+        perlin_noise_3d(x + 1, y - 1, z - 1) +
+        perlin_noise_3d(x - 1, y + 1, z - 1) +
+        perlin_noise_3d(x + 1, y + 1, z - 1)
+        ) / 16;
+    const float sides = (
+        perlin_noise_3d(x - 1, y, z + 1) +
+        perlin_noise_3d(x + 1, y, z + 1) +
+        perlin_noise_3d(x, y - 1, z + 1) +
+        perlin_noise_3d(x, y + 1, z + 1) +
+        perlin_noise_3d(x - 1, y, z - 1) +
+        perlin_noise_3d(x + 1, y, z - 1) +
+        perlin_noise_3d(x, y - 1, z - 1) +
+        perlin_noise_3d(x, y + 1, z - 1) +
+        perlin_noise_3d(x - 1, y - 1, z) +
+        perlin_noise_3d(x + 1, y - 1, z) +
+        perlin_noise_3d(x + 1, y + 1, z) +
+        perlin_noise_3d(x - 1, y + 1, z)
+        ) / 8;
+    const float center = perlin_noise_2d(x, y) / 12;
+    return corners + sides + center;
+}
+
+float perlin_interpolated_noise_3d(const float x, const float y, const float z)
+{
+    const int integer_X                = (int)x;
+    const float fractional_X    = x - integer_X;
+
+    const int integer_Y                = (int)y;
+    const float fractional_Y    = y - integer_Y;
+
+    const int integer_Z                = (int)z;
+    const float fractional_Z    = z - integer_Z;
+
+    const float a = perlin_smooth_noise_3d(integer_X,         integer_Y,             integer_Z);
+    const float b = perlin_smooth_noise_3d(integer_X + 1, integer_Y,             integer_Z);
+    const float c = perlin_smooth_noise_3d(integer_X,         integer_Y + 1,     integer_Z);
+    const float d = perlin_smooth_noise_3d(integer_X,         integer_Y,             integer_Z + 1);
+    const float e = perlin_smooth_noise_3d(integer_X + 1, integer_Y + 1,     integer_Z);
+    const float f = perlin_smooth_noise_3d(integer_X,         integer_Y + 1,     integer_Z + 1);
+    const float g = perlin_smooth_noise_3d(integer_X + 1, integer_Y,             integer_Z + 1);
+    const float h = perlin_smooth_noise_3d(integer_X + 1, integer_Y + 1,     integer_Z + 1);
+
+    const float i1 = perlin_interpolate(a, b, fractional_X);
+    const float i2 = perlin_interpolate(c, d, fractional_X);
+    const float i3 = perlin_interpolate(e, f, fractional_X);
+    const float i4 = perlin_interpolate(g, h, fractional_X);
+
+    const float y1 = perlin_interpolate(i1, i2, fractional_Y);
+    const float y2 = perlin_interpolate(i3, i4, fractional_Y);
+
+    return perlin_interpolate(y1, y2, fractional_Z);
+}
+
+float perlin_octaves_3d(const float x, const float y, const float z, const float p, const float n)
+{
+    float total = 0.;
+    float frequency = 1., amplitude = 1.;
+    int i;
+
+    for (i = 0; i < n; ++i)
+    {
+        total += perlin_interpolated_noise_3d(x * frequency, y * frequency, z * frequency) * amplitude;
+        frequency *= 2;
+        amplitude *= p;
+    }
+
+    return total;
+}
+

data/ext/perlin/classic.h

@@ -0,0 +1,24 @@
+/*
+ * "Classic" Perlin noise generation.
+ */
+
+#ifndef CLASSIC_H
+#define CLASSIC_H
+
+#include <math.h>
+
+extern long seed;
+
+static inline float perlin_interpolate(const float a, const float b, const float x);
+
+static inline float perlin_noise_2d(const int x, const int y);
+static float perlin_smooth_noise_2d(const int x, const int y);
+float perlin_interpolated_noise_2d(const float x, const float y);
+float perlin_octaves_2d(const float x, const float y, const float p, const float n);
+
+static inline float perlin_noise_3d(const int x, const int y, const int z);
+static float perlin_smooth_noise_3d(const int x, const int y, const int z);
+float perlin_interpolated_noise_3d(const float x, const float y, const float z);
+float perlin_octaves_3d(const float x, const float y, const float z, const float p, const float n);
+
+#endif // CLASSIC_H

data/ext/perlin/extconf.rb

@@ -0,0 +1,15 @@
+require 'mkmf'
+
+RUBY_VERSION =~ /(\d+.\d+)/
+extension_name = "perlin/#{$1}/perlin"
+
+dir_config(extension_name)
+
+# 1.9 compatibility
+$CFLAGS += ' -DRUBY_19' if RUBY_VERSION =~ /^1.9/
+
+# let's use c99
+#$CFLAGS += " -std=c99"
+$CFLAGS += " -std=gnu99"
+
+create_makefile(extension_name)

data/ext/perlin/generator.c

@@ -0,0 +1,292 @@
+#include "generator.h"
+
+VALUE Perlin_Generator_set_seed(const VALUE self, const VALUE seed)
+{
+    rb_iv_set(self, "@seed", rb_funcall(seed, rb_intern("to_i"), 0));
+}
+
+VALUE Perlin_Generator_set_persistence(const VALUE self, const VALUE persistence)
+{
+   rb_iv_set(self, "@persistence", rb_funcall(persistence, rb_intern("to_f"), 0));
+}
+
+VALUE Perlin_Generator_set_octave(const VALUE self, const VALUE octave)
+{
+    rb_iv_set(self, "@octave", rb_funcall(octave, rb_intern("to_i"), 0));
+}
+
+VALUE Perlin_Generator_set_classic(const VALUE self, const VALUE classic)
+{
+    rb_iv_set(self, "@classic", classic);
+}
+
+// x, y
+// x, y, z
+VALUE Perlin_Generator_run(const int argc, const VALUE *argv, const VALUE self)
+{
+    VALUE x, y, z;
+
+    rb_scan_args(argc, argv, "21", &x, &y, &z);
+
+    switch(argc)
+    {
+        case 2:
+            Perlin_Generator_run2d(self, x, y);
+            break;
+
+        case 3:
+            Perlin_Generator_run3d(self, x, y, z);
+            break;
+
+        default:
+            rb_raise(rb_eArgError, "%d parameters not supported (2D and 3D are)", argc);
+    }
+}
+
+/*
+Takes points (x, y) and returns a height (n)
+*/
+VALUE Perlin_Generator_run2d(const VALUE self, const VALUE x, const VALUE y)
+{
+    const float p = RFLOAT_VALUE(rb_iv_get(self, "@persistence"));
+    const int n = NUM2INT(rb_iv_get(self, "@octave"));
+    const VALUE classic = rb_iv_get(self, "@classic");
+
+    seed = NUM2LONG(rb_iv_get(self, "@seed")); // Store in global, for speed.
+
+    if(RTEST(classic))
+    {
+        return rb_float_new(perlin_octaves_2d(NUM2DBL(x), NUM2DBL(y), p, n));
+    }
+    else
+    {
+        return rb_float_new(octave_noise_3d(n, p, 1.0, NUM2DBL(x), NUM2DBL(y), seed * SEED_OFFSET));
+    }
+}
+
+/*
+Takes points (x, y, z) and returns a height (n)
+*/
+VALUE Perlin_Generator_run3d(const VALUE self, const VALUE x, const VALUE y, const VALUE z)
+{
+    const float p = RFLOAT_VALUE(rb_iv_get(self, "@persistence"));
+    const int n = NUM2INT(rb_iv_get(self, "@octave"));
+    const VALUE classic = rb_iv_get(self, "@classic");
+
+    seed = NUM2LONG(rb_iv_get(self, "@seed")); // Store in global, for speed.
+
+    if(RTEST(classic))
+    {
+        return rb_float_new(perlin_octaves_3d(NUM2DBL(x), NUM2DBL(y), NUM2DBL(z), p, n));
+    }
+    else
+    {
+        return rb_float_new(octave_noise_4d(n, p, 1.0, NUM2DBL(x), NUM2DBL(y), NUM2DBL(z), seed * SEED_OFFSET));
+    }
+
+}
+
+// x, y steps_x, steps_y, interval
+// x, y, z, steps_x, steps_y, steps_z, interval
+VALUE Perlin_Generator_chunk(const int argc, const VALUE *argv, const VALUE self)
+{
+    VALUE a, b, c, d, e, f, g;
+
+    rb_scan_args(argc, argv, "52", &a, &b, &c, &d, &e, &f, &g);
+
+    switch(argc)
+    {
+        case 5:
+            Perlin_Generator_chunk2d(self, a, b, c, d, e);
+            break;
+
+        case 7:
+            Perlin_Generator_chunk3d(self, a, b, c, d, e, f, g);
+            break;
+
+        default:
+            rb_raise(rb_eArgError, "%d parameters not supported (5 for 2D and 7 for 3D are)", argc);
+    }
+}
+
+/*
+Returns a chunk of coordinates starting from x, y and of size steps_x, steps_y with interval.
+*/
+VALUE Perlin_Generator_chunk2d(const VALUE self, const VALUE x, const VALUE y, const VALUE steps_x, const VALUE steps_y, const VALUE interval)
+{
+    const float p = RFLOAT_VALUE(rb_iv_get(self, "@persistence"));
+    const int n = NUM2INT(rb_iv_get(self, "@octave"));
+    const int is_classic = RTEST(rb_iv_get(self, "@classic"));
+
+    VALUE arr, row;
+    int i, j;
+
+    const float x_min = NUM2DBL(x), y_min = NUM2DBL(y);
+    float _x, _y;
+    const int _steps_x = NUM2INT(steps_x), _steps_y = NUM2INT(steps_y);
+    const float _interval = NUM2DBL(interval);
+
+    if(_steps_x < 1 || _steps_y < 1)
+    {
+        rb_raise(rb_eArgError, "steps must be >= 1");
+    }
+
+    seed = NUM2LONG(rb_iv_get(self, "@seed")); // Store in global, for speed.
+
+    if(rb_block_given_p())
+    {
+        // Iterate through x, then y [0, 0], [1, 0], [2, 0]...
+        _x = x_min;
+        for (i = 0; i < _steps_x; i++)
+        {
+           _y = y_min;
+           for (j = 0; j < _steps_y; j++)
+           {
+                if(is_classic)
+                {
+                    rb_yield_values(3, rb_float_new(perlin_octaves_2d(_x, _y, p, n)),
+                                    rb_float_new(_x), rb_float_new(_y));
+                }
+                else
+                {
+                    rb_yield_values(3, rb_float_new(octave_noise_3d(n, p, 1.0, _x, _y, seed * SEED_OFFSET)),
+                                    rb_float_new(_x), rb_float_new(_y));
+                }
+
+                _y += _interval;
+           }
+           _x += _interval;
+       }
+
+       return Qnil;
+    }
+    else
+    {
+        // 2D array can be indexed with arr[x][y]
+        arr = rb_ary_new();
+        _x = x_min;
+        for (i = 0; i < _steps_x; i++)
+        {
+            row = rb_ary_new();
+            _y = y_min;
+            for (j = 0; j < _steps_y; j++)
+            {
+                if(is_classic)
+                {
+                    rb_ary_push(row, rb_float_new(perlin_octaves_2d(_x, _y, p, n)));
+                }
+                else
+                {
+                    rb_ary_push(row, rb_float_new(octave_noise_3d(n, p, 1.0, _x, _y, seed * SEED_OFFSET)));
+                }
+
+                _y += _interval;
+            }
+            rb_ary_push(arr, row);
+            _x += _interval;
+        }
+        return arr;
+    }
+}
+
+/*
+Returns a chunk of coordinates starting from x, y, z and of size steps_x, steps_y, size_z with interval.
+*/
+VALUE Perlin_Generator_chunk3d(const VALUE self, const VALUE x, const VALUE y, const VALUE z, const VALUE steps_x, const VALUE steps_y, const VALUE steps_z, const VALUE interval)
+{
+    const float p = RFLOAT_VALUE(rb_iv_get(self, "@persistence"));
+    const int n = NUM2INT(rb_iv_get(self, "@octave"));
+    const int is_classic = RTEST(rb_iv_get(self, "@classic"));
+
+    VALUE arr, row, column;
+    int i, j, k;
+
+    const float x_min = NUM2DBL(x), y_min = NUM2DBL(y), z_min = NUM2DBL(z);
+    float _x, _y, _z;
+    const int _steps_x = NUM2INT(steps_x), _steps_y = NUM2INT(steps_y), _steps_z = NUM2INT(steps_z);
+    const float _interval = NUM2DBL(interval);
+
+    if(_steps_x < 1 || _steps_y < 1 || _steps_z < 1)
+    {
+        rb_raise(rb_eArgError, "steps must be >= 1");
+    }
+
+    seed = NUM2LONG(rb_iv_get(self, "@seed")); // Store in global, for speed.
+
+    if(rb_block_given_p())
+    {
+        _x = x_min;
+        for (i = 0; i < _steps_x; i++)
+        {
+            _y = y_min;
+            for (j = 0; j < _steps_y; j++)
+            {
+                _z = z_min;
+                for (k = 0; k < _steps_z; k++)
+                {
+                    if(is_classic)
+                    {
+                        rb_yield_values(4, rb_float_new(perlin_octaves_3d(_x, _y, _z, p, n)),
+                                        rb_float_new(_x), rb_float_new(_y), rb_float_new(_z));
+                    }
+                    else
+                    {
+                        rb_yield_values(4, rb_float_new(octave_noise_4d(n, p, 1.0, _x, _y, _z, seed * SEED_OFFSET)),
+                                        rb_float_new(_x), rb_float_new(_y), rb_float_new(_z));
+                    }
+
+                    _z += _interval;
+                }
+                _y += _interval;
+            }
+            _x += _interval;
+        }
+        return Qnil;
+    }
+    else
+    {
+        arr = rb_ary_new();
+        _x = x_min;
+        for (i = 0; i < _steps_x; i++)
+        {
+            row = rb_ary_new();
+            _y = y_min;
+            for (j = 0; j < _steps_y; j++)
+            {
+                column = rb_ary_new();
+                _z = z_min;
+                for (k = 0; k < _steps_z; k++)
+                {
+                    if(is_classic)
+                    {
+                        rb_ary_push(column, rb_float_new(perlin_octaves_3d(_x, _y, _z, p, n)));
+                    }
+                    else
+                    {
+                        rb_ary_push(column, rb_float_new(octave_noise_4d(n, p, 1.0, _x, _y, _z, seed * SEED_OFFSET)));
+                    }
+
+                    _z += _interval;
+                }
+                rb_ary_push(row, column);
+                _y += _interval;
+            }
+            rb_ary_push(arr, row);
+            _x += _interval;
+        }
+        return arr;
+    }
+}
+
+/*
+The main initialize function which receives the inputs persistence and octave.
+*/
+VALUE Perlin_Generator_init(VALUE self, VALUE seed, VALUE persistence, VALUE octave, VALUE classic)
+{
+    Perlin_Generator_set_seed(self, seed);
+    Perlin_Generator_set_persistence(self, persistence);
+    Perlin_Generator_set_octave(self, octave);
+    Perlin_Generator_set_classic(self, classic);
+
+    return self;
+}