perlin 0.1.0pre1-x86-mingw32

data/ext/perlin/simplex.h

@@ -0,0 +1,196 @@
+/* Copyright (c) 2007-2012 Eliot Eshelman
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+
+#ifndef SIMPLEX_H_
+#define SIMPLEX_H_
+
+#include <math.h>
+
+
+/* 2D, 3D and 4D Simplex Noise functions return 'random' values in (-1, 1).
+
+This algorithm was originally designed by Ken Perlin, but my code has been
+adapted from the implementation written by Stefan Gustavson (stegu@itn.liu.se)
+
+Raw Simplex noise functions return the value generated by Ken's algorithm.
+
+Scaled Raw Simplex noise functions adjust the range of values returned from the
+traditional (-1, 1) to whichever bounds are passed to the function.
+
+Multi-Octave Simplex noise functions compine multiple noise values to create a
+more complex result. Each successive layer of noise is adjusted and scaled.
+
+Scaled Multi-Octave Simplex noise functions scale the values returned from the
+traditional (-1,1) range to whichever range is passed to the function.
+
+In many cases, you may think you only need a 1D noise function, but in practice
+2D  is almost always better.  For instance, if you're using the current frame
+number  as the parameter for the noise, all objects will end up with the same
+noise value  at each frame. By adding a second parameter on the second
+dimension, you can ensure that each gets a unique noise value and they don't
+all look identical.
+*/
+
+
+// Multi-octave Simplex noise
+// For each octave, a higher frequency/lower amplitude function will be added to the original.
+// The higher the persistence [0-1], the more of each succeeding octave will be added.
+float octave_noise_2d(const float octaves,
+                    const float persistence,
+                    const float scale,
+                    const float x,
+                    const float y);
+float octave_noise_3d(const float octaves,
+                    const float persistence,
+                    const float scale,
+                    const float x,
+                    const float y,
+                    const float z);
+float octave_noise_4d(const float octaves,
+                    const float persistence,
+                    const float scale,
+                    const float x,
+                    const float y,
+                    const float z,
+                    const float w);
+
+
+// Scaled Multi-octave Simplex noise
+// The result will be between the two parameters passed.
+float scaled_octave_noise_2d(  const float octaves,
+                            const float persistence,
+                            const float scale,
+                            const float loBound,
+                            const float hiBound,
+                            const float x,
+                            const float y);
+float scaled_octave_noise_3d(  const float octaves,
+                            const float persistence,
+                            const float scale,
+                            const float loBound,
+                            const float hiBound,
+                            const float x,
+                            const float y,
+                            const float z);
+float scaled_octave_noise_4d(  const float octaves,
+                            const float persistence,
+                            const float scale,
+                            const float loBound,
+                            const float hiBound,
+                            const float x,
+                            const float y,
+                            const float z,
+                            const float w);
+
+// Scaled Raw Simplex noise
+// The result will be between the two parameters passed.
+float scaled_raw_noise_2d( const float loBound,
+                        const float hiBound,
+                        const float x,
+                        const float y);
+float scaled_raw_noise_3d( const float loBound,
+                        const float hiBound,
+                        const float x,
+                        const float y,
+                        const float z);
+float scaled_raw_noise_4d( const float loBound,
+                        const float hiBound,
+                        const float x,
+                        const float y,
+                        const float z,
+                        const float w);
+
+
+// Raw Simplex noise - a single noise value.
+float raw_noise_2d(const float x, const float y);
+float raw_noise_3d(const float x, const float y, const float z);
+float raw_noise_4d(const float x, const float y, const float, const float w);
+
+
+int fastfloor(const float x);
+
+float dot2(const int* g, const float x, const float y);
+float dot3(const int* g, const float x, const float y, const float z);
+float dot4(const int* g, const float x, const float y, const float z, const float w);
+
+
+// The gradients are the midpoints of the vertices of a cube.
+static const int grad3[12][3] = {
+    {1,1,0}, {-1,1,0}, {1,-1,0}, {-1,-1,0},
+    {1,0,1}, {-1,0,1}, {1,0,-1}, {-1,0,-1},
+    {0,1,1}, {0,-1,1}, {0,1,-1}, {0,-1,-1}
+};
+
+
+// The gradients are the midpoints of the vertices of a hypercube.
+static const int grad4[32][4]= {
+    {0,1,1,1},  {0,1,1,-1},  {0,1,-1,1},  {0,1,-1,-1},
+    {0,-1,1,1}, {0,-1,1,-1}, {0,-1,-1,1}, {0,-1,-1,-1},
+    {1,0,1,1},  {1,0,1,-1},  {1,0,-1,1},  {1,0,-1,-1},
+    {-1,0,1,1}, {-1,0,1,-1}, {-1,0,-1,1}, {-1,0,-1,-1},
+    {1,1,0,1},  {1,1,0,-1},  {1,-1,0,1},  {1,-1,0,-1},
+    {-1,1,0,1}, {-1,1,0,-1}, {-1,-1,0,1}, {-1,-1,0,-1},
+    {1,1,1,0},  {1,1,-1,0},  {1,-1,1,0},  {1,-1,-1,0},
+    {-1,1,1,0}, {-1,1,-1,0}, {-1,-1,1,0}, {-1,-1,-1,0}
+};
+
+
+// Permutation table.  The same list is repeated twice.
+static const int perm[512] = {
+    151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,
+    8,99,37,240,21,10,23,190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,
+    35,11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,168,68,175,74,165,71,
+    134,139,48,27,166,77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,
+    55,46,245,40,244,102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208, 89,
+    18,169,200,196,135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,
+    250,124,123,5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,
+    189,28,42,223,183,170,213,119,248,152,2,44,154,163,70,221,153,101,155,167,43,
+    172,9,129,22,39,253,19,98,108,110,79,113,224,232,178,185,112,104,218,246,97,
+    228,251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,
+    107,49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,
+    138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180,
+
+    151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,
+    8,99,37,240,21,10,23,190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,
+    35,11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,168,68,175,74,165,71,
+    134,139,48,27,166,77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,
+    55,46,245,40,244,102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208, 89,
+    18,169,200,196,135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,
+    250,124,123,5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,
+    189,28,42,223,183,170,213,119,248,152,2,44,154,163,70,221,153,101,155,167,43,
+    172,9,129,22,39,253,19,98,108,110,79,113,224,232,178,185,112,104,218,246,97,
+    228,251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,
+    107,49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,
+    138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
+};
+
+
+// A lookup table to traverse the simplex around a given point in 4D.
+static const int simplex[64][4] = {
+    {0,1,2,3},{0,1,3,2},{0,0,0,0},{0,2,3,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,2,3,0},
+    {0,2,1,3},{0,0,0,0},{0,3,1,2},{0,3,2,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,3,2,0},
+    {0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
+    {1,2,0,3},{0,0,0,0},{1,3,0,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,3,0,1},{2,3,1,0},
+    {1,0,2,3},{1,0,3,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,0,3,1},{0,0,0,0},{2,1,3,0},
+    {0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
+    {2,0,1,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,0,1,2},{3,0,2,1},{0,0,0,0},{3,1,2,0},
+    {2,1,0,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,1,0,2},{0,0,0,0},{3,2,0,1},{3,2,1,0}
+};
+
+
+#endif /*SIMPLEX_H_*/

data/lib/perlin.rb

@@ -0,0 +1,13 @@
+require 'perlin/version'
+
+begin
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "perlin/#{$1}/perlin.so"
+rescue LoadError
+  require "perlin/perlin.so"
+end
+
+require 'perlin/generator'
+
+module Perlin
+end

data/lib/perlin/generator.rb

@@ -0,0 +1,161 @@
+module Perlin
+  # Perlin noise generator.
+  #
+  # @!attribute [rw] seed
+  #   @return [Integer]
+  #
+  # @!attribute [r] persistence
+  #   @return [Float]
+  #
+  # @!attribute [r] octave
+  #   @return [Integer]
+  class Generator
+    attr_reader :seed, :octave, :persistence
+    def classic?; @classic; end
+
+    # @!method initialize(seed, persistence, octave)
+    #   Create a noise generator.
+    #
+    #   Using the same seed will always produce the same pattern. Animate a perlin 'texture' by altering the seed based on time.
+    #
+    #   @param seed [Integer] Seed value to create a different pattern.
+    #   @param persistence [Float] Used to generate different frequencies/amplitudes of output.
+    #   @param octave [Integer] Number of iterations to run (higher number of octaves takes more time)
+    #   @option options :classic [Boolean] (false) Whether to use the slower Classic algorithm, rather than default (and much faster) Simplex.
+    def initialize(seed, persistence, octave, options = {})
+      options = {
+          :classic => false,
+      }.merge! options
+
+      initialize_(seed, persistence, octave, options[:classic])
+    end
+    protected :initialize_ # Underlying C implementation.
+
+    # @overload chunk(x, y, steps_x, steps_y, interval)
+    #   Calculates a rectangular section of height (n) values and returns them as a 2D array.
+    #
+    #   This is much faster than accessing each point separately using {#[]}
+    #
+    #   @example
+    #     noise = Perlin::Generator.new 123, 1.0, 1
+    #     arr = noise.chunk 1, 1, 2, 3, 1.5
+    #
+    #     # access position 1, 2 (remember that arr is offset by the x, y value of the chunk)
+    #     puts arr[0, 1] #=> -0.2208995521068573
+    #
+    #     p arr  #= > [[0.05753844603896141, -0.2208995521068573, 0.3973901569843292], [0.1383310854434967, -0.22248442471027374, 0.15600799024105072]]
+    #
+    #   @param x [Float]
+    #   @param y [Float]
+    #   @param steps_x [Integer]
+    #   @param steps_y [Integer]
+    #   @param interval [Float]
+    #
+    #   @return [Array<Array<Float>>] height (n) values within the rectangle.
+    #
+    # @overload chunk(x, y, steps_x, steps_y, interval) {|h, x, y| }
+    #   Calculates a rectangular section of height (n) values and returns them as a 2D array.
+    #
+    #   This is much faster than accessing each point separately using {#[]}
+    #
+    #   @example
+    #     noise = Perlin::Generator.new 123, 0.5, 3
+    #     noise.chunk 1.0, 2.3, 3, 2, 1.5 do |h, x, y|
+    #       # Use the height value, which is at x, y.
+    #     end
+    #
+    #   @param x [Float]
+    #   @param y [Float]
+    #   @param steps_x [Integer]
+    #   @param steps_y [Integer]
+    #   @param interval [Float]
+    #
+    #   @yieldparam h [Float] Height at x, y
+    #   @yieldparam x [Float]
+    #   @yieldparam y [Float]
+    #
+    #   @return [nil]
+    #
+    # @overload chunk(x, y, z, size_x, size_y, size_z, interval)
+    #   Calculates a rectangular section of height (n) values and returns them as a 3D array.
+    #
+    #   This is much faster than accessing each point separately using {#[]}
+    #
+    #   @example
+    #     noise = Perlin::Generator.new 123, 0.5, 5
+    #     arr = noise.chunk 6.0, 5.0, 4.0, 3, 2, 1, 1.5
+    #
+    #     # access position 2, 1, 0 (remember that arr is offset by the x, y and z value of the chunk)
+    #     puts arr[2, 1, 0] #=>
+    #
+    #     p arr  #= >
+    #
+    #   @param x [Float]
+    #   @param y [Float]
+    #   @param z [Float]
+    #   @param steps_x [Integer]
+    #   @param steps_y [Integer]
+    #   @param steps_z [Integer]
+    #   @param interval [Float]
+    #
+    #   @return [Array<Array<Float>>] height (n) values within the rectangle.
+    #
+    # @overload chunk(x, y, z, size_x, size_y, size_z, interval) {|h, x, y| }
+    #   Calculates a rectangular section of height (n) values and returns them as a 3D array.
+    #
+    #   This is much faster than accessing each point separately using {#[]}
+    #
+    #   @example
+    #     noise = Perlin::Generator.new 123, 0.8, 3
+    #     noise.chunk 6.0, 5.0, 4.0, 3, 2, 1, 1.5 do |h, x, y, z|
+    #       # Use the height value, which is at x, y, z.
+    #     end
+    #
+    #   @param x [Float]
+    #   @param y [Float]
+    #   @param z [Float]
+    #   @param steps_x [Integer]
+    #   @param steps_y [Integer]
+    #   @param steps_z [Integer]
+    #   @param interval [Float]
+    #
+    #   @yieldparam h [Float] Height at x, y, z
+    #   @yieldparam x [Float]
+    #   @yieldparam y [Float]
+    #   @yieldparam z [Float]
+    #
+    #   @return [nil]
+
+    # Gets height (n) at a point in 2D or 3D space.
+    #
+    # This is much slower, if accessing many points, than using {#chunk}
+    #
+    # @overload [](x, y)
+    #   Gets height (n) value at a specific 2D position.
+    #
+    #   @example
+    #     noise = Perlin::Generator.new 123, 1.0, 1
+    #
+    #     # Returns a 'height' value for (x, y)
+    #     puts noise[10, 20]  #=> 0.9004574418067932
+    #
+    #   @param x [Float]
+    #   @param y [Float]
+    #   @return [Float] height (n) value at the position
+    #
+    # @overload [](x, y, z)
+    #   Gets height (n) value at a specific 3D position.
+    #
+    #   @example
+    #     noise = Perlin::Generator.new 123, 1.0, 1
+    #
+    #     # Returns a 'height' value for (x, y, z)
+    #     puts noise[10, 20, 30]  #=> 0.017745036631822586
+    #
+    #   @param x [Float]
+    #   @param y [Float]
+    #   @param z [Float]
+    #   @return [Float]  height (n) value at the position
+    alias_method :run, :[]
+  end
+end

data/lib/perlin/version.rb

@@ -0,0 +1,5 @@
+# Perlin noise generation.
+module Perlin
+  # Current version of the gem.
+  VERSION = "0.1.0pre1"
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: perlin
+version: !ruby/object:Gem::Version
+  version: 0.1.0pre1
+  prerelease: 5
+platform: x86-mingw32
+authors:
+- Brian 'bojo' Jones
+- Camille Goudeseune
+- Bil Bas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compile
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+- !ruby/object:Gem::Dependency
+  name: launchy
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+description: ! 'Perlin Noise C extension
+
+
+  A Perlin/Simplex noise implementation based of
+
+  <http://freespace.virgin.net/hugo.elias/models/m_perlin.htm>. Implemented as a Ruby
+  C extension.
+
+'
+email:
+- mojobojo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG
+- LICENSE
+- Rakefile
+- README.md
+- lib/perlin/1.9/perlin.so
+- lib/perlin/generator.rb
+- lib/perlin/version.rb
+- lib/perlin.rb
+- ext/perlin/classic.c
+- ext/perlin/classic.h
+- ext/perlin/extconf.rb
+- ext/perlin/generator.c
+- ext/perlin/generator.h
+- ext/perlin/perlin.c
+- ext/perlin/perlin.h
+- ext/perlin/simplex.c
+- ext/perlin/simplex.h
+- examples/chunk_in_2d.rb
+- examples/chunk_in_3d.rb
+- examples/index_in_2d.rb
+- examples/index_in_3d.rb
+- examples/ogl/README.md
+- examples/ogl/run.rb
+homepage: https://github.com/boj/ruby-perlin
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: ruby-perlin
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Perlin Noise C extension
+test_files: []