propane 3.4.0-java → 3.7.0.pre-java

data/library/slider/slider.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 # Here's a little library for quickly hooking up in sketch sliders.
-# Copyright (c) 2016-19 Martin Prout.
+# Copyright (c) 2015-20 Martin Prout.
 
 java_import 'monkstone.slider.CustomHorizontalSlider'
 java_import 'monkstone.slider.CustomVerticalSlider'
@@ -9,27 +10,27 @@ java_import 'monkstone.slider.CustomVerticalSlider'
 module Slider
   def self.slider(app:, x:, y:, name:, **opts)
     options = default.merge opts
-    if options[:vertical]
-      slider = CustomVerticalSlider.new(
-        app,
-        x,
-        y,
-        options[:length],
-        options[:range].first,
-        options[:range].last,
-        name
-    )
-    else
-      slider = CustomHorizontalSlider.new(
-        app,
-        x,
-        y,
-        options[:length],
-        options[:range].first,
-        options[:range].last,
-        name
-    )
-    end
+    slider = if options[:vertical]
+               CustomVerticalSlider.new(
+                 app,
+                 x,
+                 y,
+                 options[:length],
+                 options[:range].first,
+                 options[:range].last,
+                 name
+               )
+             else
+               CustomHorizontalSlider.new(
+                 app,
+                 x,
+                 y,
+                 options[:length],
+                 options[:range].first,
+                 options[:range].last,
+                 name
+               )
+             end
     unless opts.empty?
       slider.bar_width(opts.fetch(:bar_width, 10))
       slider.set_value(opts.fetch(:initial_value, 0))

data/library/vector_utils/vector_utils.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 PHI ||= (1 + Math.sqrt(5)) / 2 # golden ratio
 GA = PHI * 2 * Math::PI # golden angle
 
@@ -48,6 +50,7 @@ module VectorUtil
   def self.cartesian_to_polar(vec:)
     res = Vec3D.new(vec.mag, 0, 0)
     return Vec3D.new unless res.x > 0
+
     res.y = -Math.atan2(vec.z, vec.x)
     res.z = Math.asin(vec.y / res.x)
     res
@@ -64,6 +67,7 @@ module VectorUtil
 
   def self.polar_to_cartesian(vec:)
     return Vec3D.new if vec.mag <= 0
+
     Vec3D.new(Math.asin(vec.y / vec.mag), vec.mag, -Math.atan2(vec.z, vec.x))
   end
 end

data/library/video_event/video_event.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 class Propane::App
-  include Java::MonkstoneVideoevent::VideoInterface
+  include Java::MonkstoneVideoevent::CaptureEvent
+  include Java::MonkstoneVideoevent::MovieEvent
 end

data/pom.rb

@@ -1,7 +1,8 @@
-project 'propane', 'https://github.com/monkstone/propane' do
+# frozen_string_literal: true
 
+project 'propane', 'https://github.com/monkstone/propane' do
   model_version '4.0.0'
-  id 'propane:propane:3.4.0'
+  id 'propane:propane:3.7.0.pre'
   packaging 'jar'
 
   description 'An integrated processing-core (somewhat hacked), with additional java code for a jruby version of processing.'
@@ -33,49 +34,49 @@ project 'propane', 'https://github.com/monkstone/propane' do
 
   issue_management 'https://github.com/ruby-processing/propane/issues', 'Github'
 
-  source_control( :url => 'https://github.com/ruby-processing/propane',
-    :connection => 'scm:git:git://github.com/ruby-processing/propane.git',
-    :developer_connection => 'scm:git:git@github.com/ruby-processing/propane.git' )
+  source_control(url: 'https://github.com/ruby-processing/propane',
+    connection: 'scm:git:git://github.com/ruby-processing/propane.git',
+    developer_connection: 'scm:git:git@github.com/ruby-processing/propane.git')
 
-    properties( 'propane.basedir' => '${project.basedir}',
+    properties('propane.basedir' => '${project.basedir}',
       'processing.api' => 'http://processing.github.io/processing-javadocs/core/',
       'source.directory' => 'src',
       'polyglot.dump.pom' => 'pom.xml',
       'project.build.sourceEncoding' => 'utf-8',
-      'jogl.version' => '2.3.2',
-      'jruby.api' => 'http://jruby.org/apidocs/' )
+      '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.8.0'
-      jar 'org.processing:video:3.2.3'
+      pom 'org.jruby:jruby:9.2.14.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}'
 
       overrides do
-        plugin( 'org.codehaus.mojo:versions-maven-plugin:2.7',
-          'generateBackupPoms' =>  'false' )
-          plugin( :compiler, '3.8.1',
-            'release' =>  '11' )
-            plugin( :javadoc, '3.1.1',
-              'detectOfflineLinks' =>  'false',
-              'links' => [ '${jruby.api}',
-                '${processing.api}' ] )
-                plugin(
-                  :jar, '3.1.2',
+        plugin('org.codehaus.mojo:versions-maven-plugin:2.7',
+          'generateBackupPoms' => 'false')
+          plugin(:compiler, '3.8.1',
+            'release' => '11')
+            plugin(:javadoc, '3.2.0',
+              'detectOfflineLinks' => 'false',
+              'links' => ['${jruby.api}',
+                '${processing.api}'])
+                plugin(:jar, '3.2.0',
                   'archive' => {
-                    'manifestEntries' => { 'Class-Path' => 'gluegen-rt.jar jog-all.jar' }
-                  }
-                )
-              end
-              build do
-                resource do
-                  directory '${source.directory}/main/java'
-                  includes '**/**/*.glsl', '**/*.jnilib'
-                  excludes '**/**/*.java'
-                end
-                resource do
-                  directory '${source.directory}/main/resources'
-                  includes '**/*.png', '*.txt'
-                  excludes
+                    'manifestEntries' => {
+                      'Automatic-Module-Name' => 'processing.core'
+                    }
+                    })
+                  end
+                  build do
+                    resource do
+                      directory '${source.directory}/main/java'
+                      includes '**/**/*.glsl', '**/*.jnilib'
+                      excludes '**/**/*.java'
+                    end
+                    resource do
+                      directory '${source.directory}/main/resources'
+                      includes '**/*.png', '*.txt'
+                      excludes
+                    end
+                  end
                 end
-              end
-            end

data/pom.xml

@@ -6,12 +6,12 @@ DO NOT MODIFIY - GENERATED CODE
 
 
 -->
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <modelVersion>4.0.0</modelVersion>
   <groupId>propane</groupId>
   <artifactId>propane</artifactId>
-  <version>3.4.0</version>
+  <version>3.7.0.pre</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,13 +74,13 @@ DO NOT MODIFIY - GENERATED CODE
     <dependency>
       <groupId>org.jruby</groupId>
       <artifactId>jruby</artifactId>
-      <version>9.2.8.0</version>
+      <version>9.2.14.0</version>
       <type>pom</type>
     </dependency>
     <dependency>
       <groupId>org.processing</groupId>
       <artifactId>video</artifactId>
-      <version>3.2.3</version>
+      <version>3.3.7</version>
     </dependency>
     <dependency>
       <groupId>org.jogamp.jogl</groupId>
@@ -132,7 +132,7 @@ DO NOT MODIFIY - GENERATED CODE
         </plugin>
         <plugin>
           <artifactId>maven-javadoc-plugin</artifactId>
-          <version>3.1.1</version>
+          <version>3.2.0</version>
           <configuration>
             <detectOfflineLinks>false</detectOfflineLinks>
             <links>
@@ -143,11 +143,11 @@ DO NOT MODIFIY - GENERATED CODE
         </plugin>
         <plugin>
           <artifactId>maven-jar-plugin</artifactId>
-          <version>3.1.2</version>
+          <version>3.2.0</version>
           <configuration>
             <archive>
               <manifestEntries>
-                <Class-Path>gluegen-rt.jar jog-all.jar</Class-Path>
+                <Automatic-Module-Name>processing.core</Automatic-Module-Name>
               </manifestEntries>
             </archive>
           </configuration>

data/propane.gemspec

@@ -1,5 +1,6 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'propane/version'
 
@@ -8,28 +9,31 @@ Gem::Specification.new do |gem|
   gem.version       = Propane::VERSION
   gem.authors       = ['monkstone']
   gem.email         = ['mamba2928@yahoo.co.uk']
-  gem.licenses     = %w(GPL-3.0 LGPL-2.0)
+  gem.licenses     = %w[GPL-3.0 LGPL-2.0]
   gem.description  = <<-EOS
   A batteries included version of processing in ruby targetting jdk11.
   EOS
-  gem.summary       = %q{ruby implementation of processing-4.0 on MacOS, linux and windows (64bit only)}
+  gem.summary       = 'ruby implementation of processing-4.0 on MacOS, linux and windows (64bit only)'
   gem.homepage      = 'https://ruby-processing.github.io/propane/'
-  gem.files         = `git ls-files`.split($/)
-  gem.files << 'lib/propane-3.4.0.jar'
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.files << "lib/propane-#{Propane::VERSION}.jar"
   gem.files << 'lib/gluegen-rt.jar'
   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/gluegen-rt-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.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.add_development_dependency 'rake', '~> 12.3'
-  gem.add_development_dependency 'minitest', '~> 5.11'
-  gem.add_runtime_dependency 'arcball', '~> 1.0', '>= 1.0.0'
+  gem.add_development_dependency 'jruby-openssl', '~> 0.1.0', '>=0.1.3'
+  gem.add_development_dependency 'minitest', '~> 5.14'
+  gem.add_runtime_dependency 'rake', '~> 12.3'
+  gem.add_runtime_dependency 'arcball', '~> 1.0', '>= 1.0.2'
   gem.require_paths = ['lib']
   gem.platform      = 'java'
-  gem.requirements << 'java runtime >= 11.0.2+'
+  gem.requirements << 'java runtime >= 11.0.7+'
 end

data/src/main/java/monkstone/ColorUtil.java

@@ -3,7 +3,7 @@
  * 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-19 Martin Prout.
+ * 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
@@ -13,6 +13,7 @@
  */
 package monkstone;
 
+import java.util.Random;
 /**
  *
  * @author Martin Prout
@@ -102,6 +103,17 @@ public class ColorUtil {
         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

data/src/main/java/monkstone/MathToolModule.java

@@ -1,13 +1,14 @@
 /**
- * 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-19 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
- */
+* 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;
@@ -22,216 +23,265 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
 /**
- *
- * @author Martin Prout
- */
+*
+* @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 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 = "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 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);
     }
-
-    /**
-     *
-     * @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);
+    if (value > max) {
+      return mapMt(context, max, first1, last1, first2, last2);
     }
+    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));
-    }
+  /**
+  *
+  * @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);
+  }
 
-    /**
-     * 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);
+  /**
+  * 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];
     }
-
-    /**
-     * 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) {
-        Ruby ruby = context.runtime;
-        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);
+    if (amount >= 1.0) {
+      return args[1];
     }
-    // start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
+    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) {
 
-    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);
+    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 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 propane grid method as a ruby module method
-     *
-     * @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) {
-        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;
-            for (int z = 0; z < (tempRow * (column / colStep)); z++) {
-                int x = z % tempRow;
-                int y = z / tempRow;
-                block.yieldSpecific(context, context.runtime.newFixnum(x * rowStep), context.runtime.newFixnum(y * colStep));
-            }
+  /**
+  * 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;
-
+      }
     }
+    return context.nil;
+  }
 }