Define NoiseMode and noiseMode(mode)

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>

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

pom.xml

@@ -2,7 +2,7 @@
 <!--
 
 
-DO NOT MODIFIY - GENERATED CODE
+DO NOT MODIFY - GENERATED CODE
 
 
 -->

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

@@ -42,40 +42,6 @@ default float noise(float x, float y) {
 
     /**
      * <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
-     * @param w w-coordinate typically time
-     * @return
-     */
-    float noise(float x, float y, float z);
-
-        /**
-     * <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.
@@ -106,8 +72,12 @@ default float noise(float x, float y) {
      * @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

src/main/java/monkstone/noise/NoiseGenerator.java

@@ -9,26 +9,39 @@
  *
  * @author Martin Prout
  */
-public class NoiseGenerator implements Noise{
-    
-    private final Noise implementation;
-    
-    public NoiseGenerator(){
+public class NoiseGenerator implements Noise {
+
+    private Noise implementation;
+    private NoiseMode mode;
+
+    public NoiseGenerator() {
         this.implementation = new ValueNoise();
-           
+        this.mode = NoiseMode.PERLIN;
+    }
+
+    public void noiseMode(NoiseMode mode) {
+        if (this.mode != mode && this.mode != NoiseMode.PERLIN) {
+            this.implementation = new ValueNoise();
+            this.mode = NoiseMode.PERLIN;
+        }
+        if (this.mode != mode && this.mode != NoiseMode.SIMPLEX) {
+            this.implementation = new SimplexNoise();
+            this.mode = NoiseMode.SIMPLEX;
+        }
+    }
+
+    public NoiseMode noiseMode(){
+        return this.mode;
     }
-    
-    public NoiseGenerator(Noise implementation){
-        this.implementation = implementation;
-       }
-    
+
     @Override
     public float noise(float x, float y, float z) {
         return implementation.noise(x, y, z);
     }
-    
-        @Override
+
+    @Override
     public float noise(float x, float y, float z, float w) {
+      if (mode == NoiseMode.PERLIN) { return 0.5f;}
         return implementation.noise(x, y, z, w);
     }
 
@@ -46,5 +59,5 @@ public void noiseDetail(int lod, float falloff) {
     public void noiseSeed(long seed) {
         implementation.noiseSeed(seed);
     }
-    
+
 }

src/main/java/monkstone/noise/NoiseMode.java

@@ -0,0 +1,15 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package monkstone.noise;
+
+/**
+ *
+ * @author tux
+ */
+public enum NoiseMode {
+   SIMPLEX,
+   PERLIN;
+}

src/main/java/monkstone/noise/SimplexNoise.java

@@ -443,6 +443,11 @@ public void noiseSeed(long seed) {
 
     }
 
+    @Override
+    public void noiseMode(NoiseMode mode) {
+        
+    }
+
     // Inner class to speed upp gradient computations
     // (In Java, array access is a lot slower than member access)
     private static class Grad {

src/main/java/monkstone/noise/ValueNoise.java

@@ -132,7 +132,10 @@ public float noise(float x, float y, float z) {
         return r;
     }
 
-
+    @Override
+    public void noiseMode(NoiseMode mode) {
+        
+    }
 
     @Override
     public void noiseDetail(int lod) {
@@ -162,7 +165,6 @@ public void noiseSeed(long seed) {
 
     @Override
     public float noise(float x, float y, float z, float w) {
-        String message = "Use Simplex Noise for 4D noise";
-        throw new UnsupportedOperationException(message); 
+        throw new UnsupportedOperationException("Not supported yet.");
     }
 }

src/main/java/processing/core/PApplet.java

@@ -39,7 +39,7 @@
 
 // loadXML() error handling
 import javax.xml.parsers.ParserConfigurationException;
-import monkstone.fastmath.DegLutTables;
+import monkstone.noise.NoiseMode;
 import monkstone.noise.Noise;
 import org.xml.sax.SAXException;
 
@@ -4912,9 +4912,8 @@ public final void randomSeed(long seed) {
         internalRandom.setSeed(seed);
     }
 
-    public void simplexNoise(boolean simplex){
-        Noise implement = (simplex) ? new SimplexNoise() : new ValueNoise();
-        noiseGenerator = new NoiseGenerator(implement);
+    public void noiseMode(NoiseMode mode){
+        noiseGenerator.noiseMode(mode);
     }
 
     /**
@@ -4932,12 +4931,13 @@ public float noise(float x, float y) {
     /**
      * ( begin auto-generated from noise.xml )
      *
-     * 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
+     * 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
@@ -4958,7 +4958,6 @@ public float noise(float x, float y) {
      *
      * ( end auto-generated )
      *
-     * @return 
      * @webref math:random
      * @param x x-coordinate in noise space
      * @param y y-coordinate in noise space
@@ -4971,17 +4970,6 @@ public float noise(float x, float y, float z) {
         return noiseGenerator.noise(x, y, z);
     }
 
-    /**
-     *
-     * @param x
-     * @param y
-     * @param z
-     * @param w
-     * @return
-     */
-    public float noise(float x, float y, float z, float w) {
-        return noiseGenerator.noise(x, y, z, w);
-    }
 
 
     // [toxi 040903]