propane 3.6.0-java → 3.10.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8e0f1b907888514e27260110225621d9fa5f7792d319ddae436540bd98be75a
-  data.tar.gz: f26c694203a50b98df365b2b003d2c258c11c87e550618a146158a69dfa7954e
+  metadata.gz: 412793f807afe7defb88f5a8376cf15de48e65f79ff2758d8fa9c4c1a0eb0202
+  data.tar.gz: a6a387f0a7e4db3b6a7048f35f1f4d5006734fe6a37a021918bd81850c37eedc
 SHA512:
-  metadata.gz: 1263af382d8cec20f5d16d760d0afe542802955ee42bb398e4ca28e8e5583ca04a04fd619529567b5df78cadd3f824c17de8d860a8ba1c3f003b2453a87fa16a
-  data.tar.gz: 90b9e87ca02ee5dde1bfd71dc51efc91574ee2855fddfea113793d2e3d8434b07f090d2170c0a4df798fd6b200846cb9645415c09158d684f3a757ef8ee0682f
+  metadata.gz: e229c8b432547844db7d625fdfeff7551300fb8319bc485aa99a6bdcb723d364d0eb2bd20673a68dba5f8433e6f897d2e204f34f1028430b986b45967cdf48ec
+  data.tar.gz: 47864625dcf2cfd9cdfbce74cbd4ac2b470c97482e90f119dc235027557afe80b3302f150a097a2027a119a546ff29b0017bf6d4426178b2e966b4f21d360c6e

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/.travis.yml

@@ -2,7 +2,7 @@ language: java
 dist: bionic
 
 rvm:
-  - jruby-9.2.12.0
+  - jruby-9.2.17.0
 jdk:
   - openjdk11
 os:

data/CHANGELOG.md

@@ -1,4 +1,8 @@
-**v3.6.0** Recommend JRuby-9.2.14.0 use video-2.0 release
+**v3.10.0** Default to using FastNoise module, with alternative of SmoothNoise module.
+
+**v3.8.0** Refactor noise to delegate pattern, improve default implementation and add simplex noise option
+
+**v3.7.1** Recommend JRuby-9.2.16.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.3+`
-- `jruby-9.2.12.0`
-
-Currently you can ignore `illegal reflective access` warnings, see [here how to suppress them][warning].
+- `jdk-11.0.7+`
+- `jruby-9.2.17.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.10.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.10.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/Rakefile

@@ -8,7 +8,7 @@ task default: %i[init compile install test gem]
 desc 'Copy Jars'
 task :init do
   jogl24 = File.join(ENV['HOME'], 'jogl24')
-  opengl = Dir.entries(jogl24).grep(/amd64|universal/).select { |jar| jar =~ /linux|windows|macosx/ }
+  opengl = Dir.entries(jogl24).grep(/amd64|universal|arm64/).select { |jar| jar =~ /linux|windows|macosx|ios|/ }
   opengl.concat %w[jogl-all.jar gluegen-rt.jar]
   opengl.each do |gl|
     FileUtils.cp(File.join(jogl24, gl), File.join('.', 'lib'))
@@ -17,7 +17,8 @@ end
 
 desc 'Install'
 task :install do
-  sh "mv target/propane-#{Propane::VERSION}.jar lib"
+  sh 'mvn dependency:copy'
+  FileUtils.mv("target/propane-#{Propane::VERSION}.jar", 'lib')
 end
 
 desc 'Gem'
@@ -35,9 +36,9 @@ task :compile do
   sh './mvnw package'
 end
 
-desc 'JRuby-Complete'
-task :install_complete do
-  sh 'cd vendors && rake'
+desc 'pmd'
+task :pmd do
+  sh './mvnw pmd:pmd'
 end
 
 desc 'Test'
@@ -53,7 +54,7 @@ end
 desc 'clean'
 task :clean do
   Dir['./**/*.{jar,gem}'].each do |path|
-    puts "Deleting #{path} ..."
+    puts 'Deleting #{path} ...'
     File.delete(path)
   end
   FileUtils.rm_rf('./target')

data/lib/java/japplemenubar/JAppleMenuBar.java

@@ -0,0 +1,88 @@
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2011-12 hansi raber, released under LGPL under agreement
+
+  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, version 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., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/ 
+package japplemenubar;
+
+import java.io.*;
+
+import processing.core.PApplet;
+
+
+/**
+ * Starting point for the application. General initialization should be done 
+ * inside the ApplicationController's init() method. If certain kinds of 
+ * non-Swing initialization takes too long, it should happen in a new Thread 
+ * and off the Swing event dispatch thread (EDT).
+ * 
+ * @author hansi
+ */
+public class JAppleMenuBar {
+  static JAppleMenuBar instance;
+  static final String FILENAME = "libjAppleMenuBar.jnilib";
+  
+	static {
+	  try {
+	    File temp = File.createTempFile("processing", "menubar");
+	    temp.delete();  // remove the file itself
+	    temp.mkdirs();  // create a directory out of it
+	    temp.deleteOnExit();
+
+	    File jnilibFile = new File(temp, FILENAME);
+	    InputStream input = JAppleMenuBar.class.getResourceAsStream(FILENAME);
+	    if (input != null) {
+	      if (PApplet.saveStream(jnilibFile, input)) {
+	        System.load(jnilibFile.getAbsolutePath());
+	        instance = new JAppleMenuBar();
+
+	      } else {
+	        sadness("Problem saving " + FILENAME + " for full screen use.");
+	      }
+	    } else {
+        sadness("Could not load " + FILENAME + " from core.jar");
+	    }
+	  } catch (IOException e) {
+	    sadness("Unknown error, here's the stack trace.");
+	    e.printStackTrace();
+	  }
+	}
+	
+	
+	static void sadness(String msg) {
+	  System.err.println("Full screen mode disabled. " + msg);
+	}
+
+	
+//	static public void show() {
+//	  instance.setVisible(true);
+//	}
+
+	
+	static public void hide() {
+	  instance.setVisible(false, false);
+	}
+
+	
+	public native void setVisible(boolean visibility, boolean kioskMode); 
+
+	
+//  public void setVisible(boolean visibility) {
+//    // Keep original API in-tact.  Default kiosk-mode to off.
+//    setVisible(visibility, false);
+//  }
+}

data/lib/java/monkstone/ColorUtil.java

@@ -0,0 +1,127 @@
+/**
+ * This utility allows JRubyArt users to use the processing.org color method
+ * in their sketches. Includes a method to efficiently convert an array of web
+ * strings to an array of color int, and another to convert an array of color
+ * int to a string that can be used in ruby code (to generate web color array).
+ * Copyright (c) 2015-20 Martin Prout.
+ * This utility 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.
+ *
+ * Obtain a copy of the license at http://www.gnu.org/licenses/lgpl-2.1.html
+ */
+package monkstone;
+
+import java.util.Random;
+/**
+ *
+ * @author Martin Prout
+ */
+public class ColorUtil {
+
+    /**
+     * Returns hex long as a positive int unless greater than Integer.MAX_VALUE
+     * else return the complement as a negative integer or something like that
+     *
+     * @param hexlong long
+     * @return rgb int
+     */
+    static final int hexLong(long hexlong) {
+        long SPLIT = Integer.MAX_VALUE + 1;
+        if (hexlong < SPLIT) {
+            return (int) hexlong;
+        } else {
+            return (int) (hexlong - SPLIT * 2L);
+        }
+    }
+
+    /**
+     * @param hexstring String
+     * @return rgb int
+     */
+    static public int colorString(String hexstring) {
+        return java.awt.Color.decode(hexstring).getRGB();
+    }
+
+    /**
+     *
+     * @param web Array of web (hex) String
+     * @return array of color int according to java
+     */
+    static public int[] webArray(String[] web) {
+        int[] result = new int[web.length];
+        for (int i = 0; i < web.length; i++) {
+            result[i] = java.awt.Color.decode(web[i]).getRGB();
+        }
+        return result;
+    }
+
+    /**
+     * Return a ruby string of the form "%w(a b c)" where a, b, c are raw web
+     * strings. This string can be used in ruby code.
+     *
+     * @param hex int array
+     * @return String for use in ruby
+     */
+    static public String rubyString(int[] hex) {
+        StringBuilder result = new StringBuilder("%w(");
+        for (int i = 0; i < hex.length; i++) {
+            result.append(String.format("#%06X", (0xFFFFFF & hex[i])));
+            if (i < hex.length - 1) {
+                result.append(' ');
+            }
+        }
+        result.append(")\n");
+        return result.toString();
+    }
+
+    /**
+     *
+     * @param hex double
+     * @return hex float
+     */
+    static public float colorLong(double hex) {
+        return (float) hex;
+    }
+
+    /**
+     *
+     * @param hexlong long
+     * @return hexlong int
+     */
+    static public int colorLong(long hexlong) {
+        return hexLong(hexlong);
+    }
+
+    /**
+     *
+     * @param hex double
+     * @return hex float
+     */
+    static public float colorDouble(double hex) {
+        return (float) hex;
+    }
+
+    static public int[] shuffle(int[] cols) {
+    Random rgen = new Random();  // Random number generator
+    for (int i = 0; i < cols.length; i++) {
+        int randomPosition = rgen.nextInt(cols.length);
+        int temp = cols[i];
+        cols[i] = cols[randomPosition];
+        cols[randomPosition] = temp;
+    }
+    return cols;
+}
+
+    /**
+     *
+     * @param hue
+     * @param sat
+     * @param brightness
+     * @return
+     */
+    static public int hsbToRgB(double hue, double sat, double brightness) {
+        return java.awt.Color.HSBtoRGB((float) hue, (float) sat, (float) brightness);
+    }
+}

data/lib/java/monkstone/MathToolModule.java

@@ -0,0 +1,287 @@
+/**
+* The purpose of this tool is to allow JRubyArt users to use an alternative
+* to processing.org map, lerp and norm methods in their sketches and to implement
+* JRubyArt convenenience method grid(width, height, stepW, stepH) { |x, y| do stuff }
+* Copyright (c) 2015-20 Martin Prout. This tool 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.
+*
+* Obtain a copy of the license at http://www.gnu.org/licenses/lgpl-2.1.html
+*/
+package monkstone;
+
+import org.jruby.Ruby;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyFloat;
+import org.jruby.RubyModule;
+import org.jruby.RubyRange;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.anno.JRubyModule;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+*
+* @author Martin Prout
+*/
+@JRubyModule(name = "MathTool")
+public class MathToolModule {
+
+  /**
+  *
+  * @param runtime Ruby
+  */
+  public static void createMathToolModule(Ruby runtime) {
+    RubyModule mtModule = runtime.defineModule("MathTool");
+    mtModule.defineAnnotatedMethods(MathToolModule.class);
+  }
+
+  /**
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of RubyRange (must be be numeric)
+  * @return mapped value RubyFloat
+  */
+  @JRubyMethod(name = "map1d", rest = true, module = true)
+  public static IRubyObject mapOneD(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    double value = (args[0] instanceof RubyFloat)
+    ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+    RubyRange r1 = (RubyRange) args[1];
+    RubyRange r2 = (RubyRange) args[2];
+    double first1 = (r1.first(context) instanceof RubyFloat)
+    ? ((RubyFloat) r1.first(context)).getValue() : ((RubyFixnum) r1.first(context)).getDoubleValue();
+    double first2 = (r2.first(context) instanceof RubyFloat)
+    ? ((RubyFloat) r2.first(context)).getValue() : ((RubyFixnum) r2.first(context)).getDoubleValue();
+    double last1 = (r1.last(context) instanceof RubyFloat)
+    ? ((RubyFloat) r1.last(context)).getValue() : ((RubyFixnum) r1.last(context)).getDoubleValue();
+    double last2 = (r2.last(context) instanceof RubyFloat)
+    ? ((RubyFloat) r2.last(context)).getValue() : ((RubyFixnum) r2.last(context)).getDoubleValue();
+    return mapMt(context, value, first1, last1, first2, last2);
+  }
+
+  /**
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of RubyRange (must be be numeric)
+  * @return mapped value RubyFloat
+  */
+  @JRubyMethod(name = "constrained_map", rest = true, module = true)
+  public static IRubyObject constrainedMap(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+    RubyRange r1 = (RubyRange) args[1];
+    RubyRange r2 = (RubyRange) args[2];
+    double first1 = (r1.first(context) instanceof RubyFloat)
+    ? ((RubyFloat) r1.first(context)).getValue() : ((RubyFixnum) r1.first(context)).getDoubleValue();
+    double first2 = (r2.first(context) instanceof RubyFloat)
+    ? ((RubyFloat) r2.first(context)).getValue() : ((RubyFixnum) r2.first(context)).getDoubleValue();
+    double last1 = (r1.last(context) instanceof RubyFloat)
+    ? ((RubyFloat) r1.last(context)).getValue() : ((RubyFixnum) r1.last(context)).getDoubleValue();
+    double last2 = (r2.last(context) instanceof RubyFloat)
+    ? ((RubyFloat) r2.last(context)).getValue() : ((RubyFixnum) r2.last(context)).getDoubleValue();
+    double max = Math.max(first1, last1);
+    double min = Math.min(first1, last1);
+    if (value < min) {
+      return mapMt(context, min, first1, last1, first2, last2);
+    }
+    if (value > max) {
+      return mapMt(context, max, first1, last1, first2, last2);
+    }
+    return mapMt(context, value, first1, last1, first2, last2);
+  }
+
+  /**
+  *
+  * @param context ThreadContext
+  * @param recv self IRubyObject
+  * @param args floats as in processing map function
+  * @return mapped value RubyFloat
+  */
+  @JRubyMethod(name = "p5map", rest = true, module = true)
+  public static IRubyObject mapProcessing(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    double value = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+    double first1 = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+    double first2 = (args[3] instanceof RubyFloat) ? ((RubyFloat) args[3]).getValue() : ((RubyFixnum) args[3]).getDoubleValue();
+    double last1 = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
+    double last2 = (args[4] instanceof RubyFloat) ? ((RubyFloat) args[4]).getValue() : ((RubyFixnum) args[4]).getDoubleValue();
+    return mapMt(context, value, first1, last1, first2, last2);
+  }
+
+  /**
+  * A more correct version than processing.org version
+  *
+  * @param context ThreadContext
+  * @param recv self IRubyObject
+  * @param args args[2] should be between 0 and 1.0 if not returns start or
+  * stop
+  * @return lerped value RubyFloat
+  */
+  @JRubyMethod(name = "lerp", rest = true, module = true)
+  public static IRubyObject lerpP(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    double start = (args[0] instanceof RubyFloat) ? ((RubyFloat) args[0]).getValue() : ((RubyFixnum) args[0]).getDoubleValue();
+    double stop = (args[1] instanceof RubyFloat) ? ((RubyFloat) args[1]).getValue() : ((RubyFixnum) args[1]).getDoubleValue();
+    double amount = (args[2] instanceof RubyFloat) ? ((RubyFloat) args[2]).getValue() : ((RubyFixnum) args[2]).getDoubleValue();
+    if (amount <= 0) {
+      return args[0];
+    }
+    if (amount >= 1.0) {
+      return args[1];
+    }
+    return context.runtime.newFloat((1 - amount) * start + (stop * amount));
+  }
+
+  /**
+  * Identical to p5map(value, low, high, 0, 1). Numbers outside of the range
+  * are not clamped to 0 and 1, because out-of-range values are often
+  * intentional and useful.
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of args must be be numeric
+  * @return mapped value RubyFloat
+  */
+  @JRubyMethod(name = "norm", rest = true, module = true)
+  public static IRubyObject normP(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    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();
+    return mapMt(context, value, start, stop, 0, 1.0);
+  }
+
+  /**
+  * Identical to p5map(value, low, high, 0, 1) but 'clamped'. Numbers outside
+  * of the range are clamped to 0 and 1,
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of args must be be numeric
+  * @return mapped value RubyFloat
+  */
+  @JRubyMethod(name = "norm_strict", rest = true, module = true)
+  public static IRubyObject norm_strict(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+
+    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();
+    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) {
+    Ruby ruby = context.runtime;
+    double result = first2 + (last2 - first2) * ((value - first1) / (last1 - first1));
+    return ruby.newFloat(result);
+  }
+
+  /**
+  * Provides processing constrain method as a ruby module method
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of args must be be numeric
+  * @return original or limit values
+  */
+  @JRubyMethod(name = "constrain", rest = true, module = true)
+  public static IRubyObject constrainValue(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+    RubyFloat value = args[0].convertToFloat();
+    RubyFloat start = args[1].convertToFloat();
+    RubyFloat stop = args[2].convertToFloat();
+    if (value.op_ge(context, start).isTrue() && value.op_le(context, stop).isTrue()) {
+      return args[0];
+    } else if (value.op_ge(context, start).isTrue()) {
+      return args[2];
+    } else {
+      return args[1];
+    }
+  }
+
+  /**
+  * Provides JRubyArt grid method as a ruby module method behaves like:-
+  * def grid(dx, dy, sx = 1, sy = 1)
+  *   (0...dx).step(sx) do |x|
+  *     (0...dy).step(sy) do |y|
+  *       yield(x, y)
+  *     end
+  *   end
+  * end
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of args should be Fixnum
+  * @param block { |x, y| `do something` }
+  * @return nil
+  */
+  @JRubyMethod(name = "grid", rest = true, module = true)
+  public static IRubyObject createGrid(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
+    Ruby ruby = context.runtime;
+    int row = (int) args[0].toJava(Integer.class);
+    int column =  (int) args[1].toJava(Integer.class);
+    int rowStep = 1;
+    int colStep = 1;
+    if (args.length == 4){
+      rowStep = (int) args[2].toJava(Integer.class);
+      colStep = (int) args[3].toJava(Integer.class);
+    }
+    if (block.isGiven()) {
+      int tempRow = row / rowStep;
+      int tempColumn = column /colStep;
+      for (int z = 0; z < (tempRow * tempColumn); z++){
+        int y = z % tempColumn;
+        int x = z / tempColumn;
+        block.yieldSpecific(context, ruby.newFixnum(x * rowStep), ruby.newFixnum(y * colStep));
+      }
+    }
+    return context.nil;
+  }
+  /**
+  * Provides JRubyArt mesh_grid method as a ruby module method
+  * def grid(dx, dy, dz, sx = 1, sy = 1, sz = 1)
+  *   (0...dx).step(sx) do |x|
+  *     (0...dy).step(sy) do |y|
+  *       (0...dz).step(sy) do |z|
+  *         yield(x, y, z)
+  *       end
+  *     end
+  *   end
+  * end
+  *
+  * @param context ThreadContext
+  * @param recv IRubyObject
+  * @param args array of args should be Fixnum
+  * @param block { |x, y, z| `do something` }
+  * @return nil
+  */
+  @JRubyMethod(name = "mesh_grid", rest = true, module = true)
+  public static IRubyObject createGrid3D(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) {
+    Ruby ruby = context.runtime;
+    int xDim = (int) args[0].toJava(Integer.class);
+    int yDim =  (int) args[1].toJava(Integer.class);
+    int zDim =  (int) args[2].toJava(Integer.class);
+    int xStep = (args.length > 3) ? (int) args[3].toJava(Integer.class) : 1;
+    int yStep = (args.length > 4) ? (int) args[4].toJava(Integer.class) : 1;
+    int zStep = (args.length == 6) ? (int) args[5].toJava(Integer.class) : 1;
+    int dimX = xDim / xStep;
+    int dimY = yDim / yStep;
+    int dimZ = zDim / zStep;
+    if (block.isGiven()) {
+      int count = dimX * dimY * dimZ;
+      for (int x = 0; x < xDim; x += xStep){
+        for (int j = 0; j < (dimZ * dimY); j++){
+          int z = j % dimZ;
+          int y = j / dimZ;
+          block.yieldSpecific(context, ruby.newFixnum(x), ruby.newFixnum(y * yStep), ruby.newFixnum(z * zStep));
+        }
+      }
+    }
+    return context.nil;
+  }
+}