propane 3.7.1-java → 3.8.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d91c85e879a5cf795566043ce69accbc17b2d71f34ddbfbe7f3a7855975b5e3
-  data.tar.gz: 70ddc22146913b60b6cf5dc66e9cbb47efa20e394acc039aca71a16282f80e76
+  metadata.gz: 5df47b4eba645e3b5de5e4c6bbcd5af6c2955cc2e34c326fcb712b967d272c2e
+  data.tar.gz: fd791b044c4780f082aa2f6660a7818266603fd6fdcbb6463c8af6c42e34a41d
 SHA512:
-  metadata.gz: 6d17d5093f9e26213ec22d936ae15cf0c50b3cc9ae162423c7499294cc0d96df7bc964e20f9cd9bfb47b31afeed9d1407482a1137fc0f837e7235950fb25963b
-  data.tar.gz: e22db42e8e8b3a780da3faa62fbbcb7bd7f653ba6bda5f92cc3338853178d2a21e77662e1d08871cbb2b6223ccdffe4047d4e5ec7e78bea946424c6d660d7190
+  metadata.gz: 49bab01156deeea38dc4710486fa371dc93a0b0056f7e93d5110fc2343f4477093fcbd2cc50cc7d3153668916d80ed1dff74a0e3fdcce652784d0d6d8d99c90a
+  data.tar.gz: 752c53bb1719652fc1b11514add89b0dff33b2dba23b72ed44db0c58a3d86b99373d1f69f7d928c12e829fb4d1b942da89805d3d4dc3c427bcc36477d60abd75

data/.mvn/extensions.xml

@@ -3,6 +3,6 @@
   <extension>
     <groupId>io.takari.polyglot</groupId>
     <artifactId>polyglot-ruby</artifactId>
-    <version>0.4.5</version>
+    <version>0.4.6</version>
   </extension>
 </extensions>

data/CHANGELOG.md

@@ -1,3 +1,5 @@
+**v3.8.0** Refactor noise to delegate pattern, improve default implementation and add simplex noise option
+
 **v3.7.1** Recommend JRuby-9.2.15.0 use
 
 **v3.5.0** Rebase processing core code around Sam Pottingers latest fixes for JOGL an image save, does mean breaking some of Diwis and Joshua Davis examples, but one hopes codeanticode knows what he's doing.

data/README.md

@@ -8,12 +8,10 @@ adjust above for your OS/distro setup.
 
 ## Requirements
 
-There may be a linker issue with P2D or P3D sketches with stock openjdk with some linux distros, in which case you might find [Adopt open jdk binaries][adopt] will work for you.
+Previously there has been linker issue with P2D or P3D sketches with stock openjdk with some linux distros, but that seems to have gone away. [Adopt open jdk binaries][adopt] have always worked.
 
 - `jdk-11.0.7+`
-- `jruby-9.2.14.0`
-
-Currently you can ignore `illegal reflective access` warnings, see [here how to suppress them][warning].
+- `jruby-9.2.16.0`
 
 ## Building and testing
 
@@ -27,10 +25,10 @@ rake javadoc
 
 ```bash
 jgem install propane # from rubygems
-jgem install propane-3.6.0-java.gem # local install
+jgem install propane-3.8.0-java.gem # local install
 # Alternative
 jruby -S gem install propane # from rubygems
-jruby -S gem install propane-3.6.0-java.gem # local install
+jruby -S gem install propane-3.8.0-java.gem # local install
 ```
 
 ## Check Install
@@ -39,11 +37,6 @@ To check version and confirm gem bin files are on your path (also checks JDK ver
 ```bash
 propane --version
 ```
-
-## Suppressing Reflective Access warnings
-
-Since propane-3.5.0 it is possible to suppress reflective access warnings by setting JAVA_HOME environmental variable jruby does the rest.
-
 ## Usage
 
 A propane sketch:-
@@ -100,7 +93,7 @@ See [gh-pages][gh-pages] for more detailed instructions and much more.
 ```bash
 propane --install samples
 ```
- please move existing `propane_samples` if you wish to keep them. The current release features several PixelFlow glsl library examples, including a few shadertoy demos as sketches.
+ please move existing `propane_samples` if you wish to keep them. The current release features some noise sketches that exploit the new choice of noise implementation.
 
 [adopt]: https://adoptopenjdk.net/
 [building]:http://ruby-processing.github.io/building/building/

data/lib/propane/app.rb

@@ -16,6 +16,9 @@ module Propane
     java_import 'monkstone.vecmath.ShapeRender'
   end
 
+  VALUE = Java::MonkstoneNoise::NoiseMode::PERLIN
+  SIMPLEX = Java::MonkstoneNoise::NoiseMode::SIMPLEX
+
   # This class is the base class the user should inherit from when making
   # their own sketch.
   #

data/lib/propane/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Propane
-  VERSION = '3.7.1'
+  VERSION = '3.8.0'
 end

data/pom.rb

@@ -2,7 +2,7 @@
 
 project 'propane', 'https://github.com/monkstone/propane' do
   model_version '4.0.0'
-  id 'propane:propane:3.7.1'
+  id 'propane:propane:3.8.0'
   packaging 'jar'
 
   description 'An integrated processing-core (somewhat hacked), with additional java code for a jruby version of processing.'
@@ -46,7 +46,7 @@ project 'propane', 'https://github.com/monkstone/propane' do
       'jogl.version' => '2.3.2', # for compiling actual included 2.4.0-rc
       'jruby.api' => 'http://jruby.org/apidocs/')
 
-    pom 'org.jruby:jruby:9.2.15.0'
+    pom 'org.jruby:jruby:9.2.16.0'
       jar 'org.processing:video:3.3.7' # only for compiling
       jar 'org.jogamp.jogl:jogl-all:${jogl.version}'
       jar 'org.jogamp.gluegen:gluegen-rt-main:${jogl.version}'

data/pom.xml

@@ -2,7 +2,7 @@
 <!--
 
 
-DO NOT MODIFIY - GENERATED CODE
+DO NOT MODIFY - GENERATED CODE
 
 
 -->
@@ -11,7 +11,7 @@ DO NOT MODIFIY - GENERATED CODE
   <modelVersion>4.0.0</modelVersion>
   <groupId>propane</groupId>
   <artifactId>propane</artifactId>
-  <version>3.7.1</version>
+  <version>3.8.0</version>
   <name>propane</name>
   <description>An integrated processing-core (somewhat hacked), with additional java code for a jruby version of processing.</description>
   <url>https://github.com/monkstone/propane</url>
@@ -74,7 +74,7 @@ DO NOT MODIFIY - GENERATED CODE
     <dependency>
       <groupId>org.jruby</groupId>
       <artifactId>jruby</artifactId>
-      <version>9.2.15.0</version>
+      <version>9.2.16.0</version>
       <type>pom</type>
     </dependency>
     <dependency>

data/propane.gemspec

@@ -21,9 +21,11 @@ Gem::Specification.new do |gem|
   gem.files << 'lib/jogl-all.jar'
   gem.files << 'lib/gluegen-rt-natives-linux-amd64.jar'
   gem.files << 'lib/gluegen-rt-natives-macosx-universal.jar'
+#  gem.files << 'lib/gluegen-rt-natives-ios-arm64.jar'
   gem.files << 'lib/gluegen-rt-natives-windows-amd64.jar'
   gem.files << 'lib/jogl-all-natives-linux-amd64.jar'
   gem.files << 'lib/jogl-all-natives-macosx-universal.jar'
+#  gem.files << 'lib/jogl-all-natives-ios-arm64.jar'
   gem.files << 'lib/jogl-all-natives-windows-amd64.jar'
   gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})

data/src/main/java/monkstone/fastmath/DegLutTables.java

@@ -0,0 +1,111 @@
+/* 
+ * Copyright (c) 2021 Martin Prout
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library 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
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package monkstone.fastmath;
+
+public final class DegLutTables {
+
+    /**
+     *
+     */
+    static public final float PI = 3.1415927f;
+
+    /**
+     *
+     */
+    static public final float PI2 = PI * 2;
+    static private final int SIN_BITS = 15; // 16KB. Adjust for accuracy.
+    static private final int SIN_MASK = ~(-1 << SIN_BITS);
+    static private final int SIN_COUNT = SIN_MASK + 1;
+
+    static private final float RAD_FULL = PI * 2;
+    static private final float DEG_FULL = 360;
+    static private final float RAD_TO_INDEX = SIN_COUNT / RAD_FULL;
+    static private final float DEG_TO_INDEX = SIN_COUNT / DEG_FULL;
+
+    /**
+     * multiply by this to convert from radians to degrees
+     */
+    static public final float RADIANS_TO_DEGREES = 180f / PI;
+
+    /**
+     *
+     */
+    static public final float RAD_DEG = RADIANS_TO_DEGREES;
+    /**
+     * multiply by this to convert from degrees to radians
+     */
+    static public final float DEGREES_TO_RADIANS = PI / 180;
+
+    /**
+     *
+     */
+    static public final float DEG_RAD = DEGREES_TO_RADIANS;
+
+    static private class Sin {
+
+        static final float[] table = new float[SIN_COUNT];
+
+        static {
+            for (int i = 0; i < SIN_COUNT; i++) {
+                table[i] = (float) Math.sin((i + 0.5f) / SIN_COUNT * RAD_FULL);
+            }
+            for (int i = 0; i < 360; i += 90) {
+                table[(int) (i * DEG_TO_INDEX) & SIN_MASK] = (float) Math.sin(i * DEGREES_TO_RADIANS);
+            }
+        }
+    }
+
+    /**
+     * Returns the sine in radians from a lookup table.
+     * @param radians
+     * @return 
+     */
+    static public final float sin(float radians) {
+        return Sin.table[(int) (radians * RAD_TO_INDEX) & SIN_MASK];
+    }
+
+    /**
+     * Returns the cosine in radians from a lookup table.
+     * @param radians
+     * @return 
+     */
+    static public final float cos(float radians) {
+        return Sin.table[(int) ((radians + PI / 2) * RAD_TO_INDEX) & SIN_MASK];
+    }
+
+    /**
+     * Returns the sine in radians from a lookup table.
+     * @param degrees
+     * @return 
+     */
+    static public final float sinDeg(float degrees) {
+        return Sin.table[(int) (degrees * DEG_TO_INDEX) & SIN_MASK];
+    }
+
+    /**
+     * Returns the cosine in radians from a lookup table.
+     * @param degrees
+     * @return 
+     */
+    static public final float cosDeg(float degrees) {
+        return Sin.table[(int) ((degrees + 90) * DEG_TO_INDEX) & SIN_MASK];
+    }
+}
+

data/src/main/java/monkstone/fastmath/Deglut.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2015-20 Martin Prout
+ * Copyright (c) 2015-21 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -20,7 +20,7 @@
 package monkstone.fastmath;
 
 import org.jruby.Ruby;
-import org.jruby.RubyInteger;
+import org.jruby.RubyNumeric;
 import org.jruby.RubyModule;
 import org.jruby.anno.JRubyModule;
 import org.jruby.anno.JRubyMethod;
@@ -34,38 +34,6 @@ import org.jruby.runtime.builtin.IRubyObject;
 @JRubyModule(name = "DegLut")
 public class Deglut {
 
-    /**
-     * Lookup table for degree cosine/sine, has a fixed precision 1.0 degrees
-     * Quite accurate but imprecise
-     *
-     * @author Martin Prout <martin_p@lineone.net>
-     */
-    static final double[] SIN_DEG_LUT = new double[91];
-    /**
-     *
-     */
-    public static final double TO_RADIANS = Math.PI / 180;
-    /**
-     *
-     */
-    private static boolean initialized = false;
-
-    private final static int NINETY = 90;
-    private final static int FULL = 360;
-    private static final long serialVersionUID = -1466528933765940101L;
-
-    /**
-     * Initialize sin table with values (first quadrant only)
-     */
-    public static final void initTable() {
-        if (initialized == false) {
-            for (int i = 0; i <= NINETY; i++) {
-                SIN_DEG_LUT[i] = Math.sin(TO_RADIANS * i);
-            }
-            initialized = true;
-        }
-    }
-
     /**
      *
      * @param runtime Ruby
@@ -73,7 +41,6 @@ public class Deglut {
     public static void createDeglut(final Ruby runtime) {
         RubyModule deglutModule = runtime.defineModule("DegLut");
         deglutModule.defineAnnotatedMethods(Deglut.class);
-        Deglut.initTable();
     }
 
     /**
@@ -84,18 +51,9 @@ public class Deglut {
      * @return sin IRubyObject
      */
     @JRubyMethod(name = "sin", module = true)
-
     public static IRubyObject sin(ThreadContext context, IRubyObject recv, IRubyObject other) {
-        int thet = (int) ((RubyInteger) other).getLongValue();
-        while (thet < 0) {
-            thet += FULL; // Needed because negative modulus plays badly in java
-        }
-        int theta = thet % FULL;
-        int y = theta % NINETY;
-        double result = (theta < NINETY) ? SIN_DEG_LUT[y] : (theta < 180)
-                ? SIN_DEG_LUT[NINETY - y] : (theta < 270)
-                        ? -SIN_DEG_LUT[y] : -SIN_DEG_LUT[NINETY - y];
-        return context.runtime.newFloat(result);
+        float thet = (float) ((RubyNumeric) other).getLongValue();
+        return context.runtime.newFloat(DegLutTables.sinDeg(thet));
     }
 
     /**
@@ -107,15 +65,7 @@ public class Deglut {
      */
     @JRubyMethod(name = "cos", module = true)
     public static IRubyObject cos(ThreadContext context, IRubyObject recv, IRubyObject other) {
-        int thet = (int) ((RubyInteger) other).getLongValue();
-        while (thet < 0) {
-            thet += FULL; // Needed because negative modulus plays badly in java
-        }
-        int theta = thet % FULL;
-        int y = theta % NINETY;
-        double result = (theta < NINETY) ? SIN_DEG_LUT[NINETY - y] : (theta < 180)
-                ? -SIN_DEG_LUT[y] : (theta < 270)
-                        ? -SIN_DEG_LUT[NINETY - y] : SIN_DEG_LUT[y];
-        return context.runtime.newFloat(result);
+        float thet = (float) ((RubyNumeric) other).getLongValue();
+        return context.runtime.newFloat(DegLutTables.cosDeg(thet));
     }
 }

data/src/main/java/monkstone/noise/Noise.java

@@ -0,0 +1,116 @@
+package monkstone.noise;
+
+/*
+ * Copyright (c) 2021 Martin Prout
+ *
+ * This library 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.0 of the License, or (at your option) any later version.
+ *
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+public interface Noise {
+
+    /**
+     *
+     * @param x
+     * @return
+     */
+    default float noise(float x) {
+        return noise(x, 0);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    default float noise(float x, float y) {
+        return noise(x, y, 0);
+    }
+
+    /**
+     * <p>
+     * Returns the Perlin noise value at specified coordinates. Perlin noise is
+     * a random sequence generator producing a more natural ordered, harmonic
+     * succession of numbers compared to the standard <b>random()</b> function.
+     * It was invented by Ken Perlin in the 1980s and been used since in
+     * graphical applications to produce procedural textures, natural motion,
+     * shapes, terrains etc. The main difference to the
+     * <b>random()</b> function is that Perlin noise is defined in an infinite
+     * n-dimensional space where each pair of coordinates corresponds to a fixed
+     * semi-random value (fixed only for the lifespan of the program). The
+     * resulting value will always be between 0.0 and 1.0. Processing can
+     * compute 1D, 2D and 3D noise, depending on the number of coordinates
+     * given. The noise value can be animated by moving through the noise space
+     * as demonstrated in the example above. The 2nd and 3rd dimension can also
+     * be interpreted as time.The actual noise is structured similar to an audio
+     * signal, in respect to the function's use of frequencies. Similar to the
+     * concept of harmonics in physics, perlin noise is computed over several
+     * octaves which are added together for the final result. Another way to
+     * adjust the character of the resulting sequence is the scale of the input
+     * coordinates. As the function works within an infinite space the value of
+     * the coordinates doesn't matter as such, only the distance between
+     * successive coordinates does (eg. when using <b>noise()</b> within a
+     * loop). As a general rule the smaller the difference between coordinates,
+     * the smoother the resulting noise sequence will be. Steps of 0.005-0.03
+     * work best for most applications, but this will differ depending on use.
+     * <p>
+     * @param x x-coordinate in noise space
+     * @param y y-coordinate in noise space
+     * @param z z-coordinate in noise space
+     * @return
+     */
+    float noise(float x, float y, float z);
+
+    float noise(float x, float y, float z, float w);
+
+    void noiseMode(NoiseMode mode);
+
+    /**
+     * Adjusts the character and level of detail produced by the Perlin noise
+     * function.Similar to harmonics in physics, noise is computed over several
+     * octaves. Lower octaves contribute more to the output signal and as such
+     * define the overal intensity of the noise, whereas higher octaves create
+     * finer grained details in the noise sequence. By default, noise is
+     * computed over 4 octaves with each octave contributing exactly half than
+     * its predecessor, starting at 50% strength for the 1st octave. This
+     * falloff amount can be changed by adding an additional function parameter.
+     * Eg. a falloff factor of 0.75 means each octave will now have 75% impact
+     * (25% less) of the previous lower octave. Any value between 0.0 and 1.0 is
+     * valid, however note that values greater than 0.5 might result in greater
+     * than 1.0 values returned by <b>noise()</b>.By changing these parameters,
+     * the signal created by the <b>noise()</b>
+     * function can be adapted to fit very specific needs and characteristics.
+     *
+     * @param lod
+     */
+    void noiseDetail(int lod);
+
+    /**
+     * @param lod
+     * @param falloff falloff factor for each octave
+     */
+    void noiseDetail(int lod, float falloff);
+
+    /**
+     * Sets the seed value for <b>noise()</b>.By default, <b>noise()</b>
+     * produces different results each time the program is run. Set the
+     * <b>value</b> parameter to a constant to return the same pseudo-random
+     * numbers each time the software is run.
+     *
+     * @param seed
+     */
+    void noiseSeed(long seed);
+}