propane 0.5.0-java → 0.6.0-java

data/examples/regular/slider_simple.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'propane'
+
+class SliderSimple < Propane::App
+  load_library :slider
+  attr_reader :color1, :color2, :color3, :r, :gs, :b, :back
+
+  def setup
+    size(600, 400)
+    smooth(4)
+    @back = true
+    @r, @gs, @b = 0, 0, 0
+    @color1 = Slider.slider(
+      app: self,
+      x: 77,
+      y: 200,
+      name: 'Slider 1',
+      initial_value: 50
+    )
+    @color2 = Slider.slider(
+      app: self,
+      x: 77,
+      y: 230,
+      name: 'Slider 2',
+      initial_value: 50
+    )
+    @color3 = Slider.slider(
+      app: self,
+      x: 77,
+      y: 260,
+      name: 'Slider 3'
+    )
+    color_mode(RGB, 100)
+  end
+
+  def draw
+    background(b, r, gs)
+    fill(r, gs, b)
+    ellipse(300, 200, 300, 300)
+    @r = color1.read_value
+    @gs = color2.read_value
+    @b = color3.read_value
+  end
+end
+
+SliderSimple.new(title: 'Simple Slider')

data/examples/regular/tree.rb

@@ -0,0 +1,76 @@
+require 'propane'
+
+class Tree < Propane::App
+  # http://processing.org/learning/topics/tree.html
+  # by Joe Holt
+  
+  def setup
+    size 200, 200
+    color_mode RGB, 1
+    frame_rate 30
+    smooth
+    @x = 0.0
+    @dx = width / 100
+    @start_time = Time.now
+    @frame_time = nil
+  end
+  
+  def draw
+    t = Time.now
+    if @frame_time
+      fps = 1.0 / (t - @frame_time)
+      # printf "%0.1f fps\n", fps
+    end
+    @frame_time = t
+    
+    background 0
+    stroke 1, 1, 1
+    # Let's pick an angle 0 to 90 degrees based on the mouse position
+    a = (@x / width) * 90
+    # Convert it to radians
+    @theta = a.radians
+    # Start the tree from the bottom of the screen
+    translate(width / 2, height)
+    # Draw a line 60 pixels
+    h = height / 3
+    line(0, 0, 0,  -h)
+    # Move to the end of that line
+    translate(0, -h)
+    # Start the recursive branching!
+    branch(h)
+    
+    @x += @dx
+    if @x < 0
+      puts "Time after this iteration: " + (Time.now - @start_time).to_s
+    end
+    if @x > width || @x < 0
+      @dx = - @dx
+      @x += @dx * 2
+    end
+  end
+  
+  def branch(h)
+    # Each branch will be 2/3rds the size of the previous one
+    h *= 0.66
+    # All recursive functions must have an exit condition!!!!
+    # Here, ours is when the length of the branch is 2 pixels or less
+    if h > 2
+      push_matrix       # Save the current state of transformation (i.e. where are we now)
+      rotate(@theta)   # Rotate by theta
+      line(0, 0, 0, -h)   # Draw the branch
+      translate(0, -h)  # Move to the end of the branch
+      branch(h)        # Ok, now call myself to draw two new branches!!
+      pop_matrix        # Whenever we get back here, we "pop" in order to restore the previous matrix state
+      
+      # Repeat the same thing, only branch off to the "left" this time!
+      push_matrix
+      rotate(-@theta)
+      line(0, 0, 0, -h)
+      translate(0, -h)
+      branch(h)
+      pop_matrix
+    end
+  end  
+end
+
+Tree.new title: 'Tree'

data/lib/propane/app.rb

@@ -111,12 +111,7 @@ module Propane
       int < 256 ? int.chr : int
     end
 
-    private
-    
-        # Provide a convenient handle for the Java-space version of self.
-    def java_self
-      @java_self ||= to_java(Java::ProcessingCore::PApplet)
-    end
+    private    
     
     def import_opengl
       # Include processing opengl classes that we'd like to use:

data/lib/propane/helper_methods.rb

@@ -15,6 +15,21 @@ module Propane
       buf
     end
 
+    def kamera(
+      eye: Vec3D.new(width / 2.0, height / 2.0, (height / 2.0) / tan(PI * 30.0 / 180.0)),
+      center: Vec3D.new(width / 2.0, height / 2.0, 0),
+      up: Vec3D.new(0, 1.0, 0))
+      camera(eye.x, eye.y, eye.z, center.x, center.y, center.z, up.x, up.y, up.z)
+    end
+
+    def perspektiv(
+      fov: Math::PI / 3.0,
+      aspect_ratio: width.to_f / height,
+      near_z: (height / 20.0) / tan(fov / 2.0),
+      far_z: (height * 5) / tan(fov / 2.0))
+      perspective(fov, aspect_ratio, near_z, far_z)
+    end
+
     # A nice method to run a given block for a grid.
     # Lifted from action_coding/Nodebox.
     def grid(cols, rows, col_size = 1, row_size = 1)
@@ -36,6 +51,15 @@ module Propane
       super(hex_color(args[0]))
     end
 
+    def web_to_color_array(web)
+      Java::Monkstone::ColorUtil.webArray(web)
+    end
+
+    def int_to_ruby_colors(hex)
+      Java::Monkstone::ColorUtil.rubyString(hex)
+    end
+
+
     # Overrides Processing convenience function thread, which takes a String
     # arg (for a function) to more rubylike version, takes a block...
     def thread(&block)
@@ -102,12 +126,10 @@ module Propane
       end
     end
 
-    
-
     # Provide a convenient handle for the Java-space version of self.
-    #def java_self
-    #  @java_self ||= to_java(Java::ProcessingCore::PApplet)
-    #end
+    def java_self
+      @java_self ||= to_java(Java::ProcessingCore::PApplet)
+    end
 
     # Get the sketch path
     def sketch_path
@@ -146,17 +168,24 @@ module Propane
       super(fps)
     end
 
-
     private
 
+    FIXNUM_COL = -> (x) { x.is_a?(Fixnum) }
+    STRING_COL = -> (x) { x.is_a?(String) }
+    FLOAT_COL = -> (x) { x.is_a?(Float) }
     # parse single argument color int/double/String
     def hex_color(a)
-      return Java::Monkstone::ColorUtil.colorLong(a) if a.is_a?(Fixnum)
-      if a.is_a?(String)
+      case a
+      when FIXNUM_COL
+        Java::Monkstone::ColorUtil.colorLong(a)
+      when STRING_COL
         return Java::Monkstone::ColorUtil.colorString(a) if a =~ /#\h+/
-        raise StandardError, 'Dodgy Hexstring'
+        fail StandardError, 'Dodgy Hexstring'
+      when FLOAT_COL
+        Java::Monkstone::ColorUtil.colorDouble(a)
+      else
+        fail StandardError, 'Dodgy Color Conversion'
       end
-      Java::Monkstone::ColorUtil.colorDouble(a)
     end
 
     def dist2d(*args)

data/lib/propane/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 # frozen_string_literal: true
 module Propane
-  VERSION = '0.5.0'.freeze
+  VERSION = '0.6.0'.freeze
 end

data/library/slider/slider.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+# frozen_string_literal: true
+# Here's a little library for quickly hooking up in sketch sliders.
+# Copyright (c) 2016 Martin Prout.
+
+java_import 'monkstone.slider.CustomHorizontalSlider'
+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
+    unless opts.empty?
+      slider.bar_width(opts.fetch(:bar_width, 10))
+      slider.set_value(opts.fetch(:initial_value, 0))
+    end
+    slider
+  end
+  
+  def self.default
+    { length: 100, range: (0..100) }
+  end
+end

data/pom.rb

@@ -1,7 +1,7 @@
 require 'fileutils'
 project 'rp5extras', 'https://github.com/monkstone/propane' do
   model_version '4.0.0'
-  id 'propane:rp5extras', '0.5.0'
+  id 'propane:rp5extras', '0.6.0'
   packaging 'jar'
   description 'rp5extras for propane'
   organization 'ruby-processing', 'https://ruby-processing.github.io'
@@ -24,16 +24,16 @@ project 'rp5extras', 'https://github.com/monkstone/propane' do
   properties('source.directory' => 'src',
     'propane.basedir' => '${project.basedir}',
     'polyglot.dump.pom' => 'pom.xml',
-    'maven.compiler.source' => '1.7',
+    'maven.compiler.source' => '1.8',
     'project.build.sourceEncoding' => 'utf-8',
-    'maven.compiler.target' => '1.7',
+    'maven.compiler.target' => '1.8',
     'jruby.api' => 'http://jruby.org/apidocs/',
     'processing.api' => 'http://processing.github.io/processing-javadocs/core/',
     'jruby.api' => 'http://jruby.org/apidocs/',
     'jogl.version' => '2.1.5-01'
     )
   
-  pom('org.jruby:jruby:9.0.5.0')
+  pom('org.jruby:jruby:9.1.0.0')
   jar('org.processing:core:2.2.1')
   jar('org.jogamp.jogl:jogl-all:${jogl.version}')
   jar('org.jogamp.gluegen:gluegen-rt-main:${jogl.version}')

data/pom.xml

@@ -11,7 +11,7 @@ DO NOT MODIFIY - GENERATED CODE
   <modelVersion>4.0.0</modelVersion>
   <groupId>propane</groupId>
   <artifactId>rp5extras</artifactId>
-  <version>0.5.0</version>
+  <version>0.6.0</version>
   <name>rp5extras</name>
   <description>rp5extras for propane</description>
   <url>https://github.com/monkstone/propane</url>
@@ -58,18 +58,18 @@ DO NOT MODIFIY - GENERATED CODE
     <jogl.version>2.1.5-01</jogl.version>
     <jruby.api>http://jruby.org/apidocs/</jruby.api>
     <source.directory>src</source.directory>
-    <maven.compiler.target>1.7</maven.compiler.target>
+    <maven.compiler.target>1.8</maven.compiler.target>
     <processing.api>http://processing.github.io/processing-javadocs/core/</processing.api>
     <propane.basedir>${project.basedir}</propane.basedir>
     <project.build.sourceEncoding>utf-8</project.build.sourceEncoding>
     <polyglot.dump.pom>pom.xml</polyglot.dump.pom>
-    <maven.compiler.source>1.7</maven.compiler.source>
+    <maven.compiler.source>1.8</maven.compiler.source>
   </properties>
   <dependencies>
     <dependency>
       <groupId>org.jruby</groupId>
       <artifactId>jruby</artifactId>
-      <version>9.0.5.0</version>
+      <version>9.1.0.0</version>
       <type>pom</type>
     </dependency>
     <dependency>

data/propane.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |gem|
   gem.files << 'lib/jogl-all-2.1.5-01-natives-macosx-universal.jar'
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.add_runtime_dependency 'arcball', '~> 0.0.1'  
+  gem.add_runtime_dependency 'arcball', '~> 0.0.2'  
   gem.require_paths = ['lib']
   gem.platform      = 'java'
 end

data/src/monkstone/ColorUtil.java

@@ -19,6 +19,8 @@ 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;
@@ -30,18 +32,49 @@ public class ColorUtil {
     }
 
     /**
-     *
-     * @param hexstring
-     * @return
+     * @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
-     * @return
+     * @param hex double
+     * @return hex float
      */
     static public float colorLong(double hex) {
         return (float) hex;
@@ -49,8 +82,8 @@ public class ColorUtil {
     
     /**
      *
-     * @param hexlong
-     * @return
+     * @param hexlong long
+     * @return hexlong int
      */
     static public int colorLong(long hexlong){
        return hexLong(hexlong);
@@ -58,8 +91,8 @@ public class ColorUtil {
 
     /**
      *
-     * @param hex
-     * @return
+     * @param hex double
+     * @return hex float
      */
     static public float colorDouble(double hex){
        return (float)hex;

data/src/monkstone/slider/CustomHorizontalSlider.java

@@ -0,0 +1,164 @@
+/* 
+ * Copyright (c) 2016 Martin Prout
+ * 
+ * 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; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package monkstone.slider;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+
+public class CustomHorizontalSlider extends SliderBar {
+
+    /**
+     *
+     * @param outer
+     * @param x top left position x
+     * @param y left top position y
+     * @param length width or height
+     * @param beginRange start range
+     * @param endRange end range
+     * @param label widget label/ID
+     */
+    public CustomHorizontalSlider(final PApplet outer, int x, int y, int length, float beginRange, float endRange, String label) {
+        this.applet = outer;
+        this.scrollWheelHandler = (short delta) -> {
+            changeWithWheel(delta);
+        };
+        setActive(true);
+        pX = x;
+        pY = y;
+        pW = length;
+        pH = 10;
+        ID = label;
+        limits(beginRange, endRange);
+    }
+
+    @Override
+    boolean mouseOver() {
+        return (applet.mouseX >= pX && applet.mouseX <= pX + pW && applet.mouseY >= pY && applet.mouseY <= pY + pH);
+    }
+
+    private void setActive(boolean active) {
+        if (active) {
+            applet.registerMethod("dispose", this);
+            applet.registerMethod("draw", this);
+            applet.registerMethod("mouseEvent", this);
+        } else {
+            applet.unregisterMethod("draw", this);
+            applet.unregisterMethod("mouseEvent", this);
+        }
+    }
+
+    @Override
+    void displayText() {
+        String lFormat = "%d";
+        if (displayLabel) {
+            applet.fill(labelColor);
+            applet.textSize(labelSize);
+            applet.textAlign(PConstants.CENTER);
+            applet.text(Integer.toString((int) pValue), pX + pW / 2, pY + pH / 2 + labelSize / 2 - 2);
+        }
+        if (displayValue) {
+            applet.textSize(numberSize);
+            applet.fill(numbersColor);
+            applet.textAlign(PConstants.LEFT);
+            applet.text(String.format(lFormat, (int) vMin), pX, pY - numberSize / 2);
+            applet.textAlign(PConstants.RIGHT);
+            applet.text(String.format(lFormat, (int) vMax), pX + pW, pY - numberSize / 2);
+        }
+    }
+    
+    @Override
+    void drawGui() {
+        if (backgroundVisible) {
+            applet.fill(sliderBack);
+            applet.rect(pX, pY, pW, pH);
+        }
+        applet.fill(sliderFill);
+        applet.rect(pX, pY, pScaled, pH);
+    }    
+
+    /**
+     *
+     * @param value
+     */
+    @Override
+    public void setValue(float value) {
+        if (value > vMax) {
+            value = vMax;
+        }
+        if (value < vMin) {
+            value = vMin;
+        }
+        pValue = value;
+        pScaled = map(pValue, vMin, vMax, 0, pW);
+    }
+
+    @Override
+    void checkKeyboard() {
+        if (mouseOver()) {
+            if (applet.mousePressed && applet.mouseButton == PConstants.LEFT) {
+                pValue = constrainMap(applet.mouseX - pX, 0, pW, vMin, vMax);
+            }
+            if (applet.keyPressed && pressOnlyOnce) {
+                if (applet.keyCode == PConstants.LEFT || applet.keyCode == PConstants.DOWN) {
+                    pValue--;
+                }
+                if (applet.keyCode == PConstants.RIGHT || applet.keyCode == PConstants.UP) {
+                    pValue++;
+                }
+                if (pValue > vMax) {
+                    pValue = vMax;
+                } else {
+                    pValue = (pValue < vMin) ? vMin : pValue;
+                }
+                pressOnlyOnce = false;
+            }
+            deBounce(5);
+            pScaled = map(pValue, vMin, vMax, 0, pW);
+        }
+    }
+
+    /**
+     *
+     * @param delta
+     */
+    @Override
+    public void changeWithWheel(int delta) {
+        if (!mouseOver()) {
+            return;
+        }
+        if (applet.keyPressed && applet.keyCode == PConstants.SHIFT) {
+            delta = delta * (int) (vMax / 10);
+        }
+        if (applet.keyPressed && applet.keyCode == PConstants.CONTROL) {
+            delta = delta * (int) (vMax / 4);
+        }
+        setValue(pValue + delta);
+    }
+    
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        String geomF = "HorizontalSliderBar.new(%d, %d, %d, %.2f, %.2f, \"%s\")";
+        return String.format(geomF, pX, pY, pW, vMin, vMax, ID);
+    }
+}