picrate 0.0.2-java

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

@@ -0,0 +1,115 @@
+/**
+ * This utility allows PiCrate 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) 2018 Martin Prout.
+ * This utility 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.
+ *
+ * Obtain a copy of the license at http://www.gnu.org/licenses/gpl-3.0-standalone.html
+ */
+package monkstone;
+
+/**
+ *
+ *
+ */
+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;
+    }
+
+    /**
+     *
+     * @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/src/main/java/monkstone/MathToolModule.java

@@ -0,0 +1,236 @@
+/**
+ * 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) 2018 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/gpl-3.0-standalone.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;
+
+/**
+ *
+ *
+ */
+@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) {
+        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);
+    }
+     // start2 + (stop2 - start2) * ((value - start1) / (stop1 - start1));
+    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);
+    }
+
+    /**
+     * 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));
+              }
+        }
+        return context.nil;
+
+    }
+}

data/src/main/java/monkstone/PicrateLibrary.java

@@ -0,0 +1,47 @@
+/**
+ * The purpose of this class is to load the MathTool into PiCrate runtime 
+ * Copyright (C) 18 Martin Prout. This code 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/gpl-3.0-standalone.html
+ */
+
+package monkstone;
+
+import java.io.IOException;
+import monkstone.fastmath.Deglut;
+import monkstone.vecmath.vec2.Vec2;
+import monkstone.vecmath.vec3.Vec3;
+import org.jruby.Ruby;
+import org.jruby.runtime.load.Library;
+
+/**
+ *
+ *
+ */
+public class PicrateLibrary implements Library{
+  
+    /**
+     *
+     * @param runtime
+     */
+    public static void load(final Ruby runtime) {
+        MathToolModule.createMathToolModule(runtime);
+        Deglut.createDeglut(runtime);
+        Vec2.createVec2(runtime);
+        Vec3.createVec3(runtime);
+    } 
+    
+    /**
+     *
+     * @param runtime
+     * @param wrap
+     * @throws java.io.IOException
+     */
+    @Override
+    public void load(final Ruby runtime, boolean wrap) throws IOException {
+        load(runtime);
+    }  
+}

data/src/main/java/monkstone/core/LibraryProxy.java

@@ -0,0 +1,127 @@
+package monkstone.core;
+
+import processing.core.PApplet;
+import static processing.core.PConstants.*;
+import processing.event.MouseEvent;
+import processing.event.KeyEvent;
+
+/**
+* The purpose of this class is to enable
+* access to processing pre, draw and post loops in
+* ruby-processing as a regular java library class.
+* Also included background, fill and stroke methods.
+* PConstants should also be available from static import
+*
+*/
+public abstract class LibraryProxy {
+
+  private final PApplet app;
+
+  /**
+  * Useful accessors
+  */
+  public int width, height;
+
+  /**
+  *
+  * @param app PApplet
+  */
+  public LibraryProxy(PApplet app) {
+    this.app = app;
+    this.width = app.width;
+    this.height = app.height;
+    setActive(true);
+  }
+
+  /**
+  * Extending classes can override this, gives access to, by reflection,
+  * processing PApplet pre loop (called before draw)
+  */
+  public void pre(){}
+
+  /**
+  * Extending classes must implement this gives access to processing PApplet
+  * draw loop
+  */
+  public abstract void draw();
+
+  /**
+  * Extending classes can override this, gives access to, by reflection,
+  * processing PApplet post loop (called after draw)
+  */
+  public void post(){}
+
+  /**
+  * Extending classes can override this, gives access to, by reflection,
+  * processing PApplet post loop (called after draw)
+     * @param e
+  */
+  public void keyEvent(KeyEvent e){}
+
+  /**
+  * Extending classes can override this, gives access to, by reflection,
+  * processing PApplet post loop (called after draw)
+     * @param e
+  */
+  public void mouseEvent(MouseEvent e){}
+
+  /**
+  * Register or unregister reflection methods
+  * @param active
+  */
+  final void setActive(boolean active) {
+    if (active) {
+      this.app.registerMethod("pre", this);
+      this.app.registerMethod("draw", this);
+      this.app.registerMethod("post", this);
+      this.app.registerMethod("mouseEvent", this);
+      this.app.registerMethod("keyEvent", this);
+      this.app.registerMethod("dispose", this);
+    } else {
+      this.app.unregisterMethod("pre", this);
+      this.app.unregisterMethod("draw", this);
+      this.app.unregisterMethod("post", this);
+      this.app.unregisterMethod("mouseEvent", this);
+      this.app.unregisterMethod("keyEvent", this);
+    }
+  }
+
+  /**
+  * Simple signature for background hides need to call app
+  * @param col int
+  */
+  public void background(int col) {
+    this.app.background(col);
+  }
+
+  /**
+  * Simple signature for fill hides need to call app
+  * @param col int
+  */
+  public void fill(int col) {
+    this.app.fill(col);
+  }
+
+  /**
+  * Simple signature for stroke hides need to call app
+  * @param col int
+  */
+  public void stroke(int col) {
+    this.app.stroke(col);
+  }
+
+  /**
+  * Access applet if we must
+  * @return applet PApplet
+  */
+  public PApplet app() {
+    return this.app;
+  }
+
+  /**
+  * required for processing
+  */
+  public void dispose() {
+    setActive(false);
+  }
+}