propane 2.0.3-java → 2.0.4-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f3c6dc86329bbde3a56d284d72b1c6a3fe5775e
-  data.tar.gz: 0ad232d5e8538db5e81c43cec89afc4e340ce14c
+  metadata.gz: b8a56b1bfc4c73b83741bc7e847298d4b3d0e35c
+  data.tar.gz: fa2f47690147a25f9f23b229924969011e618d3c
 SHA512:
-  metadata.gz: 34c22b6d7512b91f33161501723f65f3409ab204b1ab5c6148740d8b83e4bb99e069d0ba5977ab3a74c4c6e1e4e2164b6b049af749452cea8f1a69058bb5adc5
-  data.tar.gz: daf9fe02b0423fae841cf8e05abfdd8453e30f6a390b0d7feebcf1f3a830bacaa8c81d0e23f73a6919d287b415aa21bb3d1a1757a6d1d99f2e211ac27dd0f84c
+  metadata.gz: ff02e67b5b2eb154820b51f2271e12a3f8af13c18e2f82fd8ee4f09b5dfd379c3884e8f5ac4c561e5f2068334ec4fb3497471f0bf6e5682aeade7fc6dc874662
+  data.tar.gz: 43e964fe32d9870740fef91680cc9e785f364aa227ec1916ce699f453955cb465a7662476f198979f9a3689d454af17120424072deb643dfdb9410b036fdfa02

data/CHANGELOG.md

@@ -1,5 +1,5 @@
+**v2.0.4** Correct `norm_strict`, add `math_tool_test` add `simplex_noise` expand samples
 **v2.0.3** Suggest use of jruby-9.1.4.0, more about loading vanilla libraries
- 
 **v2.0.2** Refactor install to either install `samples\sound\video` or warn (update to use a local processing-3.2.1 core, this is why travis fails), fix some examples, hence `0.3`
 
 **v2.0.1** Support processing-3.2.0

data/README.md

@@ -1,12 +1,14 @@
 # Propane
 [![Gem Version](https://badge.fury.io/rb/propane.svg)](https://badge.fury.io/rb/propane)
 
-A slim layer to communicate with Processing from JRuby, features a polyglot maven build, this started out as a non serious project by Phillip Cunningam called ribiprocessing.  It has now morphed into an experimental project for ruby-processing so we can now "Cook with Gas". We have created a configuration free version of ruby processing, for processing-3.2.1+, where we get processing core from maven central (and opengl currently testing on linux64/mac). These jars are small enough to include in the gem distribution, and hence we should not require configuration. This has created a scriptable version, ie files get run direct from jruby, but you could use jruby-complete if you used the propane script (avoids need to give the absolute data path for the data folder, but would also be needed for a watch mode).
+A slim layer to communicate with Processing from JRuby, features a polyglot maven build. We have created a configuration free version of ruby processing, for processing-3.2.1+, where we include processing core (from a local maven repository and opengl etc from maven central). These jars are small enough to include in a gem distribution, and hence we do not require configuration. This has created a scriptable version, ie files get run direct from jruby, but you could use jruby-complete if you used the propane script (avoids need to give the absolute data path for the data folder, but would also be needed for a watch mode). NB: currently we only include linux64 and macOS opengl binaries, please fork this repository to include binaries for your OS if not included. See guide to [building ruby-processing projects][building].
+
 ## Requirements
 
 - jdk8+ since version 0.6.0
-- jruby-9.1.4.0+
+- jruby-9.1.5.0+
 - mvn-3.3.1+ (development only)
+- core.jar processing-3.2.1 (development only until processing.org is available at maven central)
 
 ## Building and testing
 
@@ -67,3 +69,5 @@ propane --install sound
 propane --install video
 ```
 Other java libraries can be manually installed to the same folder (no need for processing ide)
+
+[building]:http://ruby-processing.github.io/building/building/

data/Rakefile

@@ -48,6 +48,8 @@ desc 'Test'
 task :test do
   sh 'jruby test/respond_to_test.rb'
   sh 'jruby test/create_test.rb'
+  sh 'jruby test/math_tool_test.rb'
+  sh 'jruby test/deglut_spec_test.rb'
 end
 
 desc 'clean'

data/lib/propane/app.rb

@@ -7,12 +7,6 @@ module Propane
   include_package 'processing.core' # imports the processing jar.
   # Load vecmath, fastmath and mathtool modules
   Java::Monkstone::PropaneLibrary.load(JRuby.runtime)
-  # We may change this
-  module Render
-    java_import 'monkstone.vecmath.AppRender'
-    java_import 'monkstone.vecmath.ShapeRender'
-  end
-
   SKETCH_ROOT = File.absolute_path('.')
 
   # This class is the base class the user should inherit from when making

data/lib/propane/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 # frozen_string_literal: true
 module Propane
-  VERSION = '2.0.3'.freeze
+  VERSION = '2.0.4'.freeze
 end

data/library/simplex_noise/simplex_noise.rb

@@ -0,0 +1,3 @@
+class Propane::App
+  SimplexNoise = Java::MonkstoneNoise::SimplexNoise
+end

data/pom.rb

@@ -1,7 +1,7 @@
 require 'fileutils'
 project 'rp5extras', 'https://github.com/monkstone/propane' do
   model_version '4.0.0'
-  id 'propane:rp5extras', '2.0.3'
+  id 'propane:propane', '2.0.4'
   packaging 'jar'
   description 'rp5extras for propane'
   organization 'ruby-processing', 'https://ruby-processing.github.io'
@@ -32,7 +32,7 @@ project 'rp5extras', 'https://github.com/monkstone/propane' do
     'jogl.version' => '2.3.2'
     )
   
-  pom 'org.jruby:jruby:9.1.4.0'
+  pom 'org.jruby:jruby:9.1.5.0'
   jar 'org.processing:core:3.2.1'
   jar 'org.processing:video:3.0.2'
   jar('org.jogamp.jogl:jogl-all:${jogl.version}')

data/pom.xml

@@ -10,8 +10,8 @@ DO NOT MODIFIY - GENERATED CODE
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <modelVersion>4.0.0</modelVersion>
   <groupId>propane</groupId>
-  <artifactId>rp5extras</artifactId>
-  <version>2.0.3</version>
+  <artifactId>propane</artifactId>
+  <version>2.0.4</version>
   <name>rp5extras</name>
   <description>rp5extras for propane</description>
   <url>https://github.com/monkstone/propane</url>
@@ -58,7 +58,7 @@ DO NOT MODIFIY - GENERATED CODE
     <dependency>
       <groupId>org.jruby</groupId>
       <artifactId>jruby</artifactId>
-      <version>9.1.4.0</version>
+      <version>9.1.5.0</version>
       <type>pom</type>
     </dependency>
     <dependency>

data/propane.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |gem|
   gem.authors       = ['monkstone']
   gem.email         = ['mamba2928@yahoo.co.uk']
   gem.licenses     = %w(GPL-3.0 LGPL-2.0)
-  gem.description   = %q{A Standalone Ruby Processing implementation} 
-  gem.summary       = %q{A really slim layer between Ruby and Processing-3.2.1.}
+  gem.description   = %q{A batteries included version of processing in ruby} 
+  gem.summary       = %q{A jruby wrapper for processing-3.2.1}
   gem.homepage      = 'https://ruby-processing.github.io/propane/'
   gem.files         = `git ls-files`.split($/)
   gem.files << 'lib/propane.jar'

data/src/monkstone/MathToolModule.java

@@ -1,5 +1,5 @@
 /**
- * The purpose of this tool is to allow JRubyArt users to use an alternative
+ * The purpose of this tool is to allow propane users to use an alternative
  * to processing.org map, lerp and norm methods in their sketches
  * Copyright (c) 2015-16 Martin Prout. This tool is free software; you can
  * redistribute it and/or modify it under the terms of the GNU Lesser General
@@ -45,7 +45,7 @@ public class MathToolModule {
      */
     @JRubyMethod(name = "map1d", rest = true, module = true)
     public static IRubyObject mapOneD(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
-        double value = (args[0] instanceof RubyFloat) 
+        double value = (args[0] instanceof RubyFloat)
                 ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
         RubyRange r1 = (RubyRange) args[1];
         RubyRange r2 = (RubyRange) args[2];
@@ -83,10 +83,10 @@ public class MathToolModule {
         double max = Math.max(first1, last1);
         double min = Math.min(first1, last1);
         if (value < min) {
-            value = min;
+            return mapMt(context, min, first1, last1, first2, last2);
         }
         if (value > max) {
-            value = max;
+            return mapMt(context, max, first1, last1, first2, last2);
         }
         return mapMt(context, value, first1, last1, first2, last2);
     }
@@ -164,15 +164,17 @@ public class MathToolModule {
         double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
         double start = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
         double stop = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
-        if (value <= start) {
-            return new RubyFloat(ruby, 0);
-        } else if (value >= stop) {
-            return new RubyFloat(ruby, 1.0);
-        } else {
-            return mapMt(context, value, start, stop, 0, 1.0);
+        double max = Math.max(start, stop);
+        double min = Math.min(start, stop);
+        if (value < min) {
+            return mapMt(context, min, start, stop, 0, 1.0);
+        }
+        if (value > max) {
+            return mapMt(context, max, start, stop, 0, 1.0);
         }
+        return mapMt(context, value, start, stop, 0, 1.0);
     }
-
+     // start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
     static final RubyFloat mapMt(ThreadContext context, double value, double first1, double last1, double first2, double last2) {
         double result = first2 + (last2 - first2) * ((value - first1) / (last1 - first1));
         return context.runtime.newFloat(result);

data/src/monkstone/noise/SimplexNoise.java

@@ -0,0 +1,437 @@
+/*
+ * A speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
+ *
+ * Based on example code by Stefan Gustavson (stegu@itn.liu.se).
+ * Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
+ * Better rank ordering method for 4D by Stefan Gustavson in 2012.
+ *
+ * This could be speeded up even further, but it's useful as it is.
+ *
+ * Version 2012-03-09
+ *
+ * This code was placed in the public domain by its original author,
+ * Stefan Gustavson. You may use it as you see fit, but
+ * attribution is appreciated.
+ *
+ */
+
+package monkstone.noise;
+
+public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
+
+    private static Grad grad3[] = {new Grad(1, 1, 0), new Grad(-1, 1, 0), new Grad(1, -1, 0), new Grad(-1, -1, 0),
+        new Grad(1, 0, 1), new Grad(-1, 0, 1), new Grad(1, 0, -1), new Grad(-1, 0, -1),
+        new Grad(0, 1, 1), new Grad(0, -1, 1), new Grad(0, 1, -1), new Grad(0, -1, -1)};
+
+    private static Grad grad4[] = {new Grad(0, 1, 1, 1), new Grad(0, 1, 1, -1), new Grad(0, 1, -1, 1), new Grad(0, 1, -1, -1),
+        new Grad(0, -1, 1, 1), new Grad(0, -1, 1, -1), new Grad(0, -1, -1, 1), new Grad(0, -1, -1, -1),
+        new Grad(1, 0, 1, 1), new Grad(1, 0, 1, -1), new Grad(1, 0, -1, 1), new Grad(1, 0, -1, -1),
+        new Grad(-1, 0, 1, 1), new Grad(-1, 0, 1, -1), new Grad(-1, 0, -1, 1), new Grad(-1, 0, -1, -1),
+        new Grad(1, 1, 0, 1), new Grad(1, 1, 0, -1), new Grad(1, -1, 0, 1), new Grad(1, -1, 0, -1),
+        new Grad(-1, 1, 0, 1), new Grad(-1, 1, 0, -1), new Grad(-1, -1, 0, 1), new Grad(-1, -1, 0, -1),
+        new Grad(1, 1, 1, 0), new Grad(1, 1, -1, 0), new Grad(1, -1, 1, 0), new Grad(1, -1, -1, 0),
+        new Grad(-1, 1, 1, 0), new Grad(-1, 1, -1, 0), new Grad(-1, -1, 1, 0), new Grad(-1, -1, -1, 0)};
+
+    private static short p[] = {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};
+    // To remove the need for index wrapping, double the permutation table length
+    static short[] PERM = new short[512];
+    static short[] PERM_MOD_12 = new short[512];
+
+    static {
+        for (int i = 0; i < 512; i++) {
+            PERM[i] = p[i & 255];
+            PERM_MOD_12[i] = (short) (PERM[i] % 12);
+        }
+    }
+
+    // Skewing and unskewing factors for 2, 3, and 4 dimensions
+    private static final double F2 = 0.5 * (Math.sqrt(3.0) - 1.0);
+    private static final double G2 = (3.0 - Math.sqrt(3.0)) / 6.0;
+    private static final double F3 = 1.0 / 3.0;
+    private static final double G3 = 1.0 / 6.0;
+    private static final double F4 = (Math.sqrt(5.0) - 1.0) / 4.0;
+    private static final double G4 = (5.0 - Math.sqrt(5.0)) / 20.0;
+
+    // This method is a *lot* faster than using (int)Math.floor(x)
+    private static int fastfloor(double x) {
+        int xi = (int) x;
+        return x < xi ? xi - 1 : xi;
+    }
+
+    private static double dot(Grad g, double x, double y) {
+        return g.x * x + g.y * y;
+    }
+
+    private static double dot(Grad g, double x, double y, double z) {
+        return g.x * x + g.y * y + g.z * z;
+    }
+
+    private static double dot(Grad g, double x, double y, double z, double w) {
+        return g.x * x + g.y * y + g.z * z + g.w * w;
+    }
+
+    // 2D simplex noise
+    public static double noise(double xin, double yin) {
+        double n0, n1, n2; // Noise contributions from the three corners
+        // Skew the input space to determine which simplex cell we're in
+        double s = (xin + yin) * F2; // Hairy factor for 2D
+        int i = fastfloor(xin + s);
+        int j = fastfloor(yin + s);
+        double t = (i + j) * G2;
+        double X0 = i - t; // Unskew the cell origin back to (x,y) space
+        double Y0 = j - t;
+        double x0 = xin - X0; // The x,y distances from the cell origin
+        double y0 = yin - Y0;
+        // For the 2D case, the simplex shape is an equilateral triangle.
+        // Determine which simplex we are in.
+        int i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
+        if (x0 > y0) {
+            i1 = 1;
+            j1 = 0;
+        } // lower triangle, XY order: (0,0)->(1,0)->(1,1)
+        else {
+            i1 = 0;
+            j1 = 1;
+        }      // upper triangle, YX order: (0,0)->(0,1)->(1,1)
+        // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
+        // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
+        // c = (3-sqrt(3))/6
+        double x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
+        double y1 = y0 - j1 + G2;
+        double x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
+        double y2 = y0 - 1.0 + 2.0 * G2;
+        // Work out the hashed gradient indices of the three simplex corners
+        int ii = i & 255;
+        int jj = j & 255;
+        int gi0 = PERM_MOD_12[ii + PERM[jj]];
+        int gi1 = PERM_MOD_12[ii + i1 + PERM[jj + j1]];
+        int gi2 = PERM_MOD_12[ii + 1 + PERM[jj + 1]];
+        // Calculate the contribution from the three corners
+        double t0 = 0.5 - x0 * x0 - y0 * y0;
+        if (t0 < 0) {
+            n0 = 0.0;
+        } else {
+            t0 *= t0;
+            n0 = t0 * t0 * dot(grad3[gi0], x0, y0);  // (x,y) of grad3 used for 2D gradient
+        }
+        double t1 = 0.5 - x1 * x1 - y1 * y1;
+        if (t1 < 0) {
+            n1 = 0.0;
+        } else {
+            t1 *= t1;
+            n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
+        }
+        double t2 = 0.5 - x2 * x2 - y2 * y2;
+        if (t2 < 0) {
+            n2 = 0.0;
+        } else {
+            t2 *= t2;
+            n2 = t2 * t2 * dot(grad3[gi2], x2, y2);
+        }
+        // Add contributions from each corner to get the final noise value.
+        // The result is scaled to return values in the interval [-1,1].
+        return 70.0 * (n0 + n1 + n2);
+    }
+
+    // 3D simplex noise
+    public static double noise(double xin, double yin, double zin) {
+        double n0, n1, n2, n3; // Noise contributions from the four corners
+        // Skew the input space to determine which simplex cell we're in
+        double s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D
+        int i = fastfloor(xin + s);
+        int j = fastfloor(yin + s);
+        int k = fastfloor(zin + s);
+        double t = (i + j + k) * G3;
+        double X0 = i - t; // Unskew the cell origin back to (x,y,z) space
+        double Y0 = j - t;
+        double Z0 = k - t;
+        double x0 = xin - X0; // The x,y,z distances from the cell origin
+        double y0 = yin - Y0;
+        double z0 = zin - Z0;
+        // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
+        // Determine which simplex we are in.
+        int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
+        int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
+        if (x0 >= y0) {
+            if (y0 >= z0) {
+                i1 = 1;
+                j1 = 0;
+                k1 = 0;
+                i2 = 1;
+                j2 = 1;
+                k2 = 0;
+            } // X Y Z order
+            else if (x0 >= z0) {
+                i1 = 1;
+                j1 = 0;
+                k1 = 0;
+                i2 = 1;
+                j2 = 0;
+                k2 = 1;
+            } // X Z Y order
+            else {
+                i1 = 0;
+                j1 = 0;
+                k1 = 1;
+                i2 = 1;
+                j2 = 0;
+                k2 = 1;
+            } // Z X Y order
+        } else { // x0<y0
+            if (y0 < z0) {
+                i1 = 0;
+                j1 = 0;
+                k1 = 1;
+                i2 = 0;
+                j2 = 1;
+                k2 = 1;
+            } // Z Y X order
+            else if (x0 < z0) {
+                i1 = 0;
+                j1 = 1;
+                k1 = 0;
+                i2 = 0;
+                j2 = 1;
+                k2 = 1;
+            } // Y Z X order
+            else {
+                i1 = 0;
+                j1 = 1;
+                k1 = 0;
+                i2 = 1;
+                j2 = 1;
+                k2 = 0;
+            } // Y X Z order
+        }
+        // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
+        // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
+        // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
+        // c = 1/6.
+        double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
+        double y1 = y0 - j1 + G3;
+        double z1 = z0 - k1 + G3;
+        double x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords
+        double y2 = y0 - j2 + 2.0 * G3;
+        double z2 = z0 - k2 + 2.0 * G3;
+        double x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords
+        double y3 = y0 - 1.0 + 3.0 * G3;
+        double z3 = z0 - 1.0 + 3.0 * G3;
+        // Work out the hashed gradient indices of the four simplex corners
+        int ii = i & 255;
+        int jj = j & 255;
+        int kk = k & 255;
+        int gi0 = PERM_MOD_12[ii + PERM[jj + PERM[kk]]];
+        int gi1 = PERM_MOD_12[ii + i1 + PERM[jj + j1 + PERM[kk + k1]]];
+        int gi2 = PERM_MOD_12[ii + i2 + PERM[jj + j2 + PERM[kk + k2]]];
+        int gi3 = PERM_MOD_12[ii + 1 + PERM[jj + 1 + PERM[kk + 1]]];
+        // Calculate the contribution from the four corners
+        double t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0;
+        if (t0 < 0) {
+            n0 = 0.0;
+        } else {
+            t0 *= t0;
+            n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
+        }
+        double t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1;
+        if (t1 < 0) {
+            n1 = 0.0;
+        } else {
+            t1 *= t1;
+            n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
+        }
+        double t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2;
+        if (t2 < 0) {
+            n2 = 0.0;
+        } else {
+            t2 *= t2;
+            n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
+        }
+        double t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3;
+        if (t3 < 0) {
+            n3 = 0.0;
+        } else {
+            t3 *= t3;
+            n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3);
+        }
+        // Add contributions from each corner to get the final noise value.
+        // The result is scaled to stay just inside [-1,1]
+        return 32.0 * (n0 + n1 + n2 + n3);
+    }
+
+    // 4D simplex noise, better simplex rank ordering method 2012-03-09
+    public static double noise(double x, double y, double z, double w) {
+
+        double n0, n1, n2, n3, n4; // Noise contributions from the five corners
+        // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
+        double s = (x + y + z + w) * F4; // Factor for 4D skewing
+        int i = fastfloor(x + s);
+        int j = fastfloor(y + s);
+        int k = fastfloor(z + s);
+        int l = fastfloor(w + s);
+        double t = (i + j + k + l) * G4; // Factor for 4D unskewing
+        double X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
+        double Y0 = j - t;
+        double Z0 = k - t;
+        double W0 = l - t;
+        double x0 = x - X0;  // The x,y,z,w distances from the cell origin
+        double y0 = y - Y0;
+        double z0 = z - Z0;
+        double w0 = w - W0;
+        // For the 4D case, the simplex is a 4D shape I won't even try to describe.
+        // To find out which of the 24 possible simplices we're in, we need to
+        // determine the magnitude ordering of x0, y0, z0 and w0.
+        // Six pair-wise comparisons are performed between each possible pair
+        // of the four coordinates, and the results are used to rank the numbers.
+        int rankx = 0;
+        int ranky = 0;
+        int rankz = 0;
+        int rankw = 0;
+        if (x0 > y0) {
+            rankx++;
+        } else {
+            ranky++;
+        }
+        if (x0 > z0) {
+            rankx++;
+        } else {
+            rankz++;
+        }
+        if (x0 > w0) {
+            rankx++;
+        } else {
+            rankw++;
+        }
+        if (y0 > z0) {
+            ranky++;
+        } else {
+            rankz++;
+        }
+        if (y0 > w0) {
+            ranky++;
+        } else {
+            rankw++;
+        }
+        if (z0 > w0) {
+            rankz++;
+        } else {
+            rankw++;
+        }
+        int i1, j1, k1, l1; // The integer offsets for the second simplex corner
+        int i2, j2, k2, l2; // The integer offsets for the third simplex corner
+        int i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
+        // [rankx, ranky, rankz, rankw] is a 4-vector with the numbers 0, 1, 2 and 3
+        // in some order. We use a thresholding to set the coordinates in turn.
+        // Rank 3 denotes the largest coordinate.
+        i1 = rankx >= 3 ? 1 : 0;
+        j1 = ranky >= 3 ? 1 : 0;
+        k1 = rankz >= 3 ? 1 : 0;
+        l1 = rankw >= 3 ? 1 : 0;
+        // Rank 2 denotes the second largest coordinate.
+        i2 = rankx >= 2 ? 1 : 0;
+        j2 = ranky >= 2 ? 1 : 0;
+        k2 = rankz >= 2 ? 1 : 0;
+        l2 = rankw >= 2 ? 1 : 0;
+        // Rank 1 denotes the second smallest coordinate.
+        i3 = rankx >= 1 ? 1 : 0;
+        j3 = ranky >= 1 ? 1 : 0;
+        k3 = rankz >= 1 ? 1 : 0;
+        l3 = rankw >= 1 ? 1 : 0;
+        // The fifth corner has all coordinate offsets = 1, so no need to compute that.
+        double x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
+        double y1 = y0 - j1 + G4;
+        double z1 = z0 - k1 + G4;
+        double w1 = w0 - l1 + G4;
+        double x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
+        double y2 = y0 - j2 + 2.0 * G4;
+        double z2 = z0 - k2 + 2.0 * G4;
+        double w2 = w0 - l2 + 2.0 * G4;
+        double x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
+        double y3 = y0 - j3 + 3.0 * G4;
+        double z3 = z0 - k3 + 3.0 * G4;
+        double w3 = w0 - l3 + 3.0 * G4;
+        double x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
+        double y4 = y0 - 1.0 + 4.0 * G4;
+        double z4 = z0 - 1.0 + 4.0 * G4;
+        double w4 = w0 - 1.0 + 4.0 * G4;
+        // Work out the hashed gradient indices of the five simplex corners
+        int ii = i & 255;
+        int jj = j & 255;
+        int kk = k & 255;
+        int ll = l & 255;
+        int gi0 = PERM[ii + PERM[jj + PERM[kk + PERM[ll]]]] % 32;
+        int gi1 = PERM[ii + i1 + PERM[jj + j1 + PERM[kk + k1 + PERM[ll + l1]]]] % 32;
+        int gi2 = PERM[ii + i2 + PERM[jj + j2 + PERM[kk + k2 + PERM[ll + l2]]]] % 32;
+        int gi3 = PERM[ii + i3 + PERM[jj + j3 + PERM[kk + k3 + PERM[ll + l3]]]] % 32;
+        int gi4 = PERM[ii + 1 + PERM[jj + 1 + PERM[kk + 1 + PERM[ll + 1]]]] % 32;
+        // Calculate the contribution from the five corners
+        double t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
+        if (t0 < 0) {
+            n0 = 0.0;
+        } else {
+            t0 *= t0;
+            n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0);
+        }
+        double t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
+        if (t1 < 0) {
+            n1 = 0.0;
+        } else {
+            t1 *= t1;
+            n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1);
+        }
+        double t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
+        if (t2 < 0) {
+            n2 = 0.0;
+        } else {
+            t2 *= t2;
+            n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2);
+        }
+        double t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
+        if (t3 < 0) {
+            n3 = 0.0;
+        } else {
+            t3 *= t3;
+            n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3);
+        }
+        double t4 = 0.5 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
+        if (t4 < 0) {
+            n4 = 0.0;
+        } else {
+            t4 *= t4;
+            n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4);
+        }
+        // Sum up and scale the result to cover the range [-1,1]
+        return 27.0 * (n0 + n1 + n2 + n3 + n4);
+    }
+
+    // Inner class to speed upp gradient computations
+    // (In Java, array access is a lot slower than member access)
+    private static class Grad {
+
+        double x, y, z, w;
+
+        Grad(double x, double y, double z) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+        }
+
+        Grad(double x, double y, double z, double w) {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            this.w = w;
+        }
+    }
+}

data/test/deglut_spec_test.rb

@@ -0,0 +1,29 @@
+gem 'minitest' # don't use bundled minitest
+require 'java'
+require 'minitest/autorun'
+require 'minitest/pride'
+
+require_relative '../lib/propane'
+
+Java::Monkstone::PropaneLibrary.load(JRuby.runtime)
+
+Dir.chdir(File.dirname(__FILE__))
+
+class DeglutTest < Minitest::Test
+  attr_reader :to_radian
+
+  def setup
+    @to_radian = Math::PI / 180
+  end
+
+  def test_cos_sin
+    (-720..720).step(1) do |deg|
+      sine = DegLut.sin(deg)
+      deg_sin = Math.sin(deg * to_radian)
+      assert_in_delta(sine, deg_sin, delta = 0.000001)
+      cosine = DegLut.cos(deg)
+      deg_cos = Math.cos(deg * to_radian)
+      assert_in_delta(cosine, deg_cos, delta = 0.000001)
+    end
+  end
+end

data/test/math_tool_test.rb

@@ -0,0 +1,79 @@
+gem 'minitest'      # don't use bundled minitest
+require 'java'
+require 'minitest/autorun'
+require 'minitest/pride'
+
+require_relative '../lib/propane'
+# require_relative '../lib/jruby_art/helper_methods'
+
+Java::Monkstone::PropaneLibrary.new.load(JRuby.runtime, false)
+
+# include Processing::HelperMethods
+
+
+Dir.chdir(File.dirname(__FILE__))
+
+class MathToolTest < Minitest::Test
+ include MathTool
+ def test_map1d
+    x = [0, 5, 7.5, 10]
+    range1 = (0..10)
+    range2 = (100..1)
+    range3 = (0..10)
+    range4 = (5..105)
+    assert_in_delta(map1d(x[0], range1, range2), 100, delta = 0.00001, msg = 'map to first')
+    assert_in_delta(map1d(x[1], range1, range2), 50.5, delta = 0.00001, msg = 'map to reversed intermediate')
+    assert_in_delta(map1d(x[2], range3, range4), 80.0, delta = 0.00001, msg = 'map to intermediate')
+    assert_in_delta(map1d(x[3], range1, range2), 1, delta = 0.00001, msg = 'map to last')
+  end
+
+  def test_p5map # as map1d except not using range input
+    x = [0, 5, 7.5, 10]
+    range1 = (0..10)
+    range2 = (100..1)
+    range3 = (0..10)
+    range4 = (5..105)
+    assert_in_delta(p5map(x[0], range1.first, range1.last, range2.first, range2.last), 100, delta = 0.00001)
+    assert_in_delta(p5map(x[1], range1.first, range1.last, range2.first, range2.last), 50.5, delta = 0.00001)
+    assert_in_delta(p5map(x[2], range3.first, range3.last, range4.first, range4.last), 80.0, delta = 0.00001)
+    assert_in_delta(p5map(x[3], range1.first, range1.last, range2.first, range2.last), 1, delta = 0.00001)
+  end
+
+  def test_norm
+    x = [10, 140, 210]
+    start0, last0 = 30, 200
+    start_int, last_int = 0, 200
+    assert_in_delta(norm(x[0], start0, last0), -0.11764705882352941, delta = 0.00001, msg = 'unclamped map')
+    assert_in_delta(norm(x[1], start_int, last_int), 0.7, delta = 0.00001, msg = 'map to intermediate')
+    assert_in_delta(norm(x[2], start_int, last_int), 1.05, delta = 0.00001, msg = 'unclamped map')
+  end
+
+  def test_norm_strict
+    x = [10, 140, 210]
+    assert_in_delta(norm_strict(x[2], x[0], x[1]), 1.0, delta = 0.00001, msg = 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[2], x[1], x[0]), 0.0, delta = 0.00001, msg = 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[1], x[0], x[2]), 0.65, delta = 0.00001, msg = 'clamped map to 0..1.0')
+  end
+
+  def test_lerp # behaviour is deliberately different to processing which is unclamped
+    x = [0.5, 0.8, 2.0]
+    start0, last0 = 300, 200
+    start_int, last_int = 0, 200
+    assert_in_delta(lerp(start0, last0, x[0]), 250, delta = 0.00001, msg = 'produces a intermediate value of a reversed range')
+    assert_in_delta(lerp(start_int, last_int, x[1]), 160, delta = 0.00001, msg = 'lerps to an intermediate value')
+    assert_in_delta(lerp(start_int, last_int, x[2]), 200, delta = 0.00001, msg = 'lerps to the last value of a range')
+  end
+
+  def test_constrain
+    x_int = [15, 2_500, -2_500]
+    start_int, last_int = 0, 200
+    assert_in_delta(constrain(x_int[0], start_int, last_int), 15, delta = 0.00001)
+    assert_in_delta(constrain(x_int[1], start_int, last_int), 200, delta = 0.00001)
+    assert_in_delta(constrain(x_int[2], start_int, last_int), 0, delta = 0.00001)
+    xf = [15.0, 2_500.0, -2_500.0]
+    startf, lastf = 0, 200.0
+    assert_in_delta(constrain(xf[0], startf, lastf), 15.0, delta = 0.00001, msg = 'constrain to 0..200')
+    assert_in_delta(constrain(xf[1], startf, lastf), 200.0, delta = 0.00001, msg = 'constrain to 0..200')
+    assert_in_delta(constrain(xf[2], startf, lastf), 0.0, delta = 0.00001, msg = 'constrain to 0..200')
+  end
+end

data/vendors/Rakefile

@@ -9,7 +9,7 @@ SOUND = 'sound.zip'.freeze
 SOUND_VERSION = 'v1.3.2' # version 1.3.2
 VIDEO = 'video-2.zip'
 VIDEO_VERSION = '2' # version 1.0.1
-EXAMPLES = '0.3'.freeze
+EXAMPLES = '0.4'.freeze
 HOME_DIR = ENV['HOME']
 MAC_OR_LINUX = /linux|mac|darwin/ =~ RbConfig::CONFIG['host_os']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: propane
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: java
 authors:
 - monkstone
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-05 00:00:00.000000000 Z
+date: 2016-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arcball
@@ -24,7 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.3
-description: A Standalone Ruby Processing implementation
+description: A batteries included version of processing in ruby
 email:
 - mamba2928@yahoo.co.uk
 executables:
@@ -67,6 +67,7 @@ files:
 - library/control_panel/control_panel.rb
 - library/file_chooser/chooser.rb
 - library/file_chooser/file_chooser.rb
+- library/simplex_noise/simplex_noise.rb
 - library/slider/slider.rb
 - library/video_event/video_event.rb
 - pom.rb
@@ -79,6 +80,7 @@ files:
 - src/monkstone/fastmath/Deglut.java
 - src/monkstone/fastmath/package-info.java
 - src/monkstone/filechooser/Chooser.java
+- src/monkstone/noise/SimplexNoise.java
 - src/monkstone/slider/CustomHorizontalSlider.java
 - src/monkstone/slider/CustomVerticalSlider.java
 - src/monkstone/slider/SimpleHorizontalSlider.java
@@ -99,6 +101,8 @@ files:
 - src/monkstone/videoevent/VideoInterface.java
 - src/monkstone/videoevent/package-info.java
 - test/create_test.rb
+- test/deglut_spec_test.rb
+- test/math_tool_test.rb
 - test/respond_to_test.rb
 - vendors/Rakefile
 homepage: https://ruby-processing.github.io/propane/
@@ -125,7 +129,9 @@ rubyforge_project:
 rubygems_version: 2.6.3
 signing_key: 
 specification_version: 4
-summary: A really slim layer between Ruby and Processing-3.2.1.
+summary: A jruby wrapper for processing-3.2.1
 test_files:
 - test/create_test.rb
+- test/deglut_spec_test.rb
+- test/math_tool_test.rb
 - test/respond_to_test.rb