Merge pull request #38 from ruby-processing/delegate-noise

Delegate noise

Author: monkstone

.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>

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.

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/

lib/propane/app.rb

@@ -16,6 +16,9 @@ module Render
     java_import 'monkstone.vecmath.ShapeRender'
   end
 
+  PROCESSING = 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.
   #

lib/propane/version.rb

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

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 @@
       '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}'

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>

propane.gemspec

@@ -21,11 +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-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-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)/})

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];
+    }
+}
+

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,46 +34,13 @@
 @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 <[email protected]>
-     */
-    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
      */
     public static void createDeglut(final Ruby runtime) {
         RubyModule deglutModule = runtime.defineModule("DegLut");
         deglutModule.defineAnnotatedMethods(Deglut.class);
-        Deglut.initTable();
     }
 
     /**
@@ -84,18 +51,9 @@ public static void createDeglut(final Ruby runtime) {
      * @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 static IRubyObject sin(ThreadContext context, IRubyObject recv, IRubyObje
      */
     @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));
     }
 }