propane 0.3.0.pre-java

data/src/monkstone/PropaneLibrary.java

@@ -0,0 +1,47 @@
+/**
+ * The purpose of this class is to load the MathTool into ruby-processing runtime 
+ * Copyright (C) 2015-16 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/lgpl-2.1.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;
+
+/**
+ *
+ * @author Martin Prout
+ */
+public class PropaneLibrary implements Library{
+  
+    /**
+     *
+     * @param runtime
+     */
+    public static void load(final Ruby runtime) {
+        MathTool.createMathTool(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/monkstone/core/AbstractLibrary.java

@@ -0,0 +1,102 @@
+package monkstone.core;
+
+import static processing.core.PConstants.*;
+
+/**
+ * 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
+ * @author Martin Prout
+ */
+public abstract class AbstractLibrary {
+
+    private final processing.core.PApplet app;
+
+    /**
+     * Useful accessors
+     */
+    public int width, height;
+
+    /**
+     *
+     * @param app PApplet
+     */
+    public AbstractLibrary(processing.core.PApplet app) {
+        this.app = app;
+        this.width = app.width;
+        this.height = app.height;
+        setActive(true);
+    }
+
+    /**
+     * Extending classes must implement this gives access to, by reflection,
+     * processing PApplet pre loop (called before draw)
+     */
+    public abstract void pre();
+
+    /**
+     * Extending classes must implement this gives access to processing PApplet
+     * draw loop
+     */
+    public abstract void draw();
+
+    /**
+     * Extending classes must implement  this gives access to, by reflection,
+     * processing PApplet post loop (called after draw)
+     */
+    public abstract void post();
+
+    private void setActive(boolean active) {
+        if (active) {
+            this.app.registerMethod("pre", this);
+            this.app.registerMethod("draw", this);
+            this.app.registerMethod("post", this);
+            this.app.registerMethod("dispose", this);
+        } else {
+            this.app.unregisterMethod("pre", this);
+            this.app.unregisterMethod("draw", this);
+            this.app.unregisterMethod("post", this);
+        }
+    }
+
+    /**
+     * Simple signature for background hides need to call app
+     * @param col
+     */
+    public void background(int col) {
+        this.app.background(col);
+    }
+
+    /**
+     * Simple signature for fill hides need to call app
+     * @param col
+     */
+    public void fill(int col) {
+        this.app.fill(col);
+    }
+
+    /**
+     * Simple signature for stroke hides need to call app
+     * @param col
+     */
+    public void stroke(int col) {
+        this.app.stroke(col);
+    }
+
+    /**
+     * Access applet if we must
+     * @return app PApplet
+     */
+    public processing.core.PApplet app() {
+        return this.app;
+    }
+
+    /**
+     * required for processing
+     */
+    public void dispose() {
+        setActive(false);
+    }
+}

data/src/monkstone/fastmath/Deglut.java

@@ -0,0 +1,115 @@
+package monkstone.fastmath;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+*
+* @author Martin Prout
+*/
+@JRubyClass(name = "DegLut")
+public class Deglut extends RubyObject {
+  
+  /**
+  * Lookup table for degree cosine/sine, has a fixed precision 1.0
+  * degrees Quite accurate but imprecise
+  *
+  * @author Martin Prout <martin_p@lineone.net>
+  */
+  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;
+  
+  /**
+  * Initialise 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
+  */
+  
+  public static void createDeglut(final Ruby runtime){
+    RubyModule deglutModule = runtime.defineModule("DegLut");
+    deglutModule.defineAnnotatedMethods(Deglut.class);
+    Deglut.initTable();
+  }  
+  
+  
+  /**
+  *
+  * @param runtime
+  * @param klass
+  */
+  private Deglut(Ruby runtime, RubyClass klass) {
+    super(runtime, klass);
+  }
+  
+  /**
+  *
+  * @param context
+  * @param klazz
+  * @param other
+  * @return sin float
+  */
+  @JRubyMethod(name = "sin", meta = true)
+  
+  public static IRubyObject sin(ThreadContext context, IRubyObject klazz, IRubyObject other) {
+    int thet = (Integer) other.toJava(Integer.class);
+    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.getRuntime().newFloat(result);
+  }
+  
+  /**
+  *
+  * @param context
+  * @param klazz
+  * @param other
+  * @return cos float
+  */
+  @JRubyMethod(name = "cos", meta = true)
+  public static IRubyObject cos(ThreadContext context, IRubyObject klazz, IRubyObject other) {
+    int thet = (Integer) other.toJava(Integer.class);
+    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.getRuntime().newFloat(result);
+  }  
+}

data/src/monkstone/vecmath/AppRender.java

@@ -0,0 +1,87 @@
+package monkstone.vecmath;
+
+import processing.core.PApplet;
+
+/**
+ *
+ * @author Martin Prout
+ */
+public class AppRender implements JRender {
+
+    final PApplet app;
+
+    /**
+     *
+     * @param app
+     */
+    public AppRender(final PApplet app) {
+        this.app = app;
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     */
+    @Override
+    public void vertex(double x, double y) {
+        app.vertex((float) x, (float) y);
+    }
+    
+    /**
+     *
+     * @param x
+     * @param y
+     */
+    @Override
+    public void curveVertex(double x, double y) {
+        app.curveVertex((float) x, (float) y);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    @Override
+    public void vertex(double x, double y, double z) {
+        app.vertex((float) x, (float) y, (float) z);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    @Override
+    public void normal(double x, double y, double z) {
+        app.normal((float) x, (float) y, (float) z);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @param u
+     * @param v
+     */
+    @Override
+    public void vertex(double x, double y, double z, double u, double v) {
+        app.vertex((float) x, (float) y, (float) z, (float) u, (float) v);
+    }
+    
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    @Override
+    public void curveVertex(double x, double y, double z) {
+        app.curveVertex((float) x, (float) y, (float) z);
+    }
+
+}

data/src/monkstone/vecmath/JRender.java

@@ -0,0 +1,56 @@
+package monkstone.vecmath;
+
+/**
+ *
+ * @author Martin Prout
+ */
+public interface JRender {  
+
+    /**
+     *
+     * @param x
+     * @param y
+     */
+    public void vertex(double x, double y);
+
+    /**
+     *
+     * @param x
+     * @param y
+     */
+    public void curveVertex(double x, double y);
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    public void vertex(double x, double y, double z);
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @param u
+     * @param v
+     */
+    public void vertex(double x, double y, double z, double u, double v);
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    public void curveVertex(double x, double y, double z);
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    public void normal(double x, double y, double z);
+}

data/src/monkstone/vecmath/ShapeRender.java

@@ -0,0 +1,87 @@
+package monkstone.vecmath;
+
+import processing.core.PShape;
+
+/**
+ *
+ * @author Martin Prout
+ */
+public class ShapeRender implements JRender {
+
+    final PShape shape;
+
+    /**
+     *
+     * @param shape
+     */
+    public ShapeRender(final PShape shape) {
+        this.shape = shape;
+
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     */
+    @Override
+    public void vertex(double x, double y) {
+        shape.vertex((float) x, (float) y);
+    }
+    
+    /**
+     *
+     * @param x
+     * @param y
+     */
+    @Override
+    public void curveVertex(double x, double y) {
+        throw new UnsupportedOperationException("Not implemented for this renderer");
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    @Override
+    public void vertex(double x, double y, double z) {
+        shape.vertex((float) x, (float) y, (float) z);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    @Override
+    public void normal(double x, double y, double z) {
+        shape.normal((float) x, (float) y, (float) z);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @param u
+     * @param v
+     */
+    @Override
+    public void vertex(double x, double y, double z, double u, double v) {
+        shape.vertex((float) x, (float) y, (float) z, (float) u, (float) v);
+    }
+    
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    @Override
+    public void curveVertex(double x, double y, double z) {
+        throw new UnsupportedOperationException("Not implemented for this renderer");
+    }
+}