propane 0.3.0.pre-java

data/pom.rb

@@ -0,0 +1,113 @@
+require 'fileutils'
+project 'rp5extras', 'https://github.com/monkstone/propane' do
+  model_version '4.0.0'
+  id 'propane:rp5extras', '0.3.0'
+  packaging 'jar'
+  description 'rp5extras for propane'
+  organization 'ruby-processing', 'https://ruby-processing.github.io'
+  { 'monkstone' => 'Martin Prout', 'filib' => 'Phillip Cunningham' }.each do |key, value|
+    developer key do
+      name value
+      roles 'developer'
+    end
+  end
+  license 'MIT', 'http://www.opensource.org/licenses/mit-license.php'
+  license 'GPL 3', 'http://www.gnu.org/licenses/gpl-3.0-standalone.html'  
+  issue_management 'https://github.com/monkstone/propane/issues', 'Github'
+  
+  source_control(
+    url: 'https://github.com/monkstone/propane',
+    connection: 'scm:git:git://github.com/monkstone/propane.git',
+    developer_connection: 'scm:git:git@github.com/monkstone/propane.git'
+    )
+  
+  properties('source.directory' => 'src',
+    'propane.basedir' => '${project.basedir}',
+    'polyglot.dump.pom' => 'pom.xml',
+    'maven.compiler.source' => '1.7',
+    'project.build.sourceEncoding' => 'utf-8',
+    'maven.compiler.target' => '1.7',
+    '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')
+  jar('org.processing:core:2.2.1')
+  jar('org.jogamp.jogl:jogl-all:${jogl.version}')
+  jar('org.jogamp.gluegen:gluegen-rt-main:${jogl.version}')
+  
+  overrides do
+    plugin :resources, '2.6'
+    plugin :dependency, '2.10' do
+      execute_goals( id: 'default-cli',
+        artifactItems: [ { groupId:  'org.processing',
+          artifactId:  'core',
+          version:  '2.2.1',         
+          type:  'jar',
+          outputDirectory: '${propane.basedir}/lib'
+        },
+        { groupId:  'org.jogamp.jogl',
+          artifactId:  'jogl-all',
+          version:  '${jogl.version}',
+          type:  'jar',
+          outputDirectory: '${propane.basedir}/lib'
+        },
+        { groupId:  'org.jogamp.gluegen',
+          artifactId:  'gluegen-rt',
+          version:  '${jogl.version}',
+          type:  'jar',
+          outputDirectory: '${propane.basedir}/lib'
+        },
+        { groupId:  'org.jogamp.jogl',
+          artifactId:  'jogl-all',
+          version:  '${jogl.version}',
+          classifier: 'natives-linux-amd64',
+          type:  'jar',
+          outputDirectory: '${propane.basedir}/lib'
+        },
+        { groupId:  'org.jogamp.gluegen',
+          artifactId:  'gluegen-rt',
+          version:  '${jogl.version}',
+          type:  'jar',
+          classifier: 'natives-linux-amd64',
+          outputDirectory: '${propane.basedir}/lib'
+        },
+        { groupId:  'org.jogamp.jogl',
+          artifactId:  'jogl-all',
+          version:  '${jogl.version}',
+          classifier: 'natives-macosx-universal',
+          type:  'jar',
+          outputDirectory: '${propane.basedir}/lib'
+        },
+        { groupId:  'org.jogamp.gluegen',
+          artifactId:  'gluegen-rt',
+          version:  '${jogl.version}',
+          type:  'jar',
+          classifier: 'natives-macosx-universal',
+          outputDirectory: '${propane.basedir}/lib'
+        }
+        ]
+      )
+    end
+      
+    plugin( :compiler, '3.3',
+      source: '${maven.compiler.source}',
+      target: '${maven.compiler.target}'
+    )
+    plugin( :javadoc, '2.10.3',
+      detect_offline_links:  'false',
+      links: ['${jruby.api}', '${processing.api}']
+    )
+    plugin( :jar, '2.6',
+      archive: { manifestFile: 'MANIFEST.MF' }
+    )
+  end
+
+  build do
+    default_goal 'package'
+    source_directory 'src'
+    final_name 'rpextras'
+  end
+end

data/pom.xml

@@ -0,0 +1,198 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+
+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"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>propane</groupId>
+  <artifactId>rp5extras</artifactId>
+  <version>0.3.0</version>
+  <name>rp5extras</name>
+  <description>rp5extras for propane</description>
+  <url>https://github.com/monkstone/propane</url>
+  <organization>
+    <name>ruby-processing</name>
+    <url>https://ruby-processing.github.io</url>
+  </organization>
+  <licenses>
+    <license>
+      <name>MIT</name>
+      <url>http://www.opensource.org/licenses/mit-license.php</url>
+    </license>
+    <license>
+      <name>GPL 3</name>
+      <url>http://www.gnu.org/licenses/gpl-3.0-standalone.html</url>
+    </license>
+  </licenses>
+  <developers>
+    <developer>
+      <id>monkstone</id>
+      <name>Martin Prout</name>
+      <roles>
+        <role>developer</role>
+      </roles>
+    </developer>
+    <developer>
+      <id>filib</id>
+      <name>Phillip Cunningham</name>
+      <roles>
+        <role>developer</role>
+      </roles>
+    </developer>
+  </developers>
+  <scm>
+    <connection>scm:git:git://github.com/monkstone/propane.git</connection>
+    <developerConnection>scm:git:git@github.com/monkstone/propane.git</developerConnection>
+    <url>https://github.com/monkstone/propane</url>
+  </scm>
+  <issueManagement>
+    <system>Github</system>
+    <url>https://github.com/monkstone/propane/issues</url>
+  </issueManagement>
+  <properties>
+    <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>
+    <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>
+  </properties>
+  <dependencies>
+    <dependency>
+      <groupId>org.jruby</groupId>
+      <artifactId>jruby</artifactId>
+      <version>9.0.5.0</version>
+      <type>pom</type>
+    </dependency>
+    <dependency>
+      <groupId>org.processing</groupId>
+      <artifactId>core</artifactId>
+      <version>2.2.1</version>
+    </dependency>
+    <dependency>
+      <groupId>org.jogamp.jogl</groupId>
+      <artifactId>jogl-all</artifactId>
+      <version>${jogl.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.jogamp.gluegen</groupId>
+      <artifactId>gluegen-rt-main</artifactId>
+      <version>${jogl.version}</version>
+    </dependency>
+  </dependencies>
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+    <defaultGoal>package</defaultGoal>
+    <finalName>rpextras</finalName>
+    <pluginManagement>
+      <plugins>
+        <plugin>
+          <artifactId>maven-resources-plugin</artifactId>
+          <version>2.6</version>
+        </plugin>
+        <plugin>
+          <artifactId>maven-dependency-plugin</artifactId>
+          <version>2.10</version>
+          <executions>
+            <execution>
+              <id>default-cli</id>
+              <configuration>
+                <artifactItems>
+                  <artifactItem>
+                    <groupId>org.processing</groupId>
+                    <artifactId>core</artifactId>
+                    <version>2.2.1</version>
+                    <type>jar</type>
+                    <outputDirectory>${propane.basedir}/lib</outputDirectory>
+                  </artifactItem>
+                  <artifactItem>
+                    <groupId>org.jogamp.jogl</groupId>
+                    <artifactId>jogl-all</artifactId>
+                    <version>${jogl.version}</version>
+                    <type>jar</type>
+                    <outputDirectory>${propane.basedir}/lib</outputDirectory>
+                  </artifactItem>
+                  <artifactItem>
+                    <groupId>org.jogamp.gluegen</groupId>
+                    <artifactId>gluegen-rt</artifactId>
+                    <version>${jogl.version}</version>
+                    <type>jar</type>
+                    <outputDirectory>${propane.basedir}/lib</outputDirectory>
+                  </artifactItem>
+                  <artifactItem>
+                    <groupId>org.jogamp.jogl</groupId>
+                    <artifactId>jogl-all</artifactId>
+                    <version>${jogl.version}</version>
+                    <classifier>natives-linux-amd64</classifier>
+                    <type>jar</type>
+                    <outputDirectory>${propane.basedir}/lib</outputDirectory>
+                  </artifactItem>
+                  <artifactItem>
+                    <groupId>org.jogamp.gluegen</groupId>
+                    <artifactId>gluegen-rt</artifactId>
+                    <version>${jogl.version}</version>
+                    <type>jar</type>
+                    <classifier>natives-linux-amd64</classifier>
+                    <outputDirectory>${propane.basedir}/lib</outputDirectory>
+                  </artifactItem>
+                  <artifactItem>
+                    <groupId>org.jogamp.jogl</groupId>
+                    <artifactId>jogl-all</artifactId>
+                    <version>${jogl.version}</version>
+                    <classifier>natives-macosx-universal</classifier>
+                    <type>jar</type>
+                    <outputDirectory>${propane.basedir}/lib</outputDirectory>
+                  </artifactItem>
+                  <artifactItem>
+                    <groupId>org.jogamp.gluegen</groupId>
+                    <artifactId>gluegen-rt</artifactId>
+                    <version>${jogl.version}</version>
+                    <type>jar</type>
+                    <classifier>natives-macosx-universal</classifier>
+                    <outputDirectory>${propane.basedir}/lib</outputDirectory>
+                  </artifactItem>
+                </artifactItems>
+              </configuration>
+            </execution>
+          </executions>
+        </plugin>
+        <plugin>
+          <artifactId>maven-compiler-plugin</artifactId>
+          <version>3.3</version>
+          <configuration>
+            <source>${maven.compiler.source}</source>
+            <target>${maven.compiler.target}</target>
+          </configuration>
+        </plugin>
+        <plugin>
+          <artifactId>maven-javadoc-plugin</artifactId>
+          <version>2.10.3</version>
+          <configuration>
+            <detect_offline_links>false</detect_offline_links>
+            <links>
+              <link>${jruby.api}</link>
+              <link>${processing.api}</link>
+            </links>
+          </configuration>
+        </plugin>
+        <plugin>
+          <artifactId>maven-jar-plugin</artifactId>
+          <version>2.6</version>
+          <configuration>
+            <archive>
+              <manifestFile>MANIFEST.MF</manifestFile>
+            </archive>
+          </configuration>
+        </plugin>
+      </plugins>
+    </pluginManagement>
+  </build>
+</project>

data/propane.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'propane/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'propane'
+  gem.version       = Propane::VERSION
+  gem.authors       = ['filib', 'monkstone']
+  gem.email         = ['martin_p@lineone.net']
+  gem.license       = 'MIT'
+  gem.description   = %q{A Standalone Ruby Processing implementation} 
+  gem.summary       = %q{A really slim layer between Ruby and Processing-2.2.1.}
+  gem.homepage      = 'https://github.com/monkstone/propane'
+  gem.files         = `git ls-files`.split($/)
+  gem.files << 'lib/rpextras.jar'
+  gem.files << 'lib/core-2.2.1.jar'
+  gem.files << 'lib/gluegen-rt-2.1.5-01.jar'
+  gem.files << 'lib/gluegen-rt-2.1.5-01-natives-linux-amd64.jar'
+  gem.files << 'lib/gluegen-rt-2.1.5-01-natives-macosx-universal.jar'
+  gem.files << 'lib/jogl-all-2.1.5-01-natives-linux-amd64.jar'
+  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.require_paths = ['lib']
+  gem.platform      = 'java'
+end

data/src/monkstone/ColorUtil.java

@@ -0,0 +1,67 @@
+/**
+ * The purpose of this utility is to allow ruby-processing users to use an alternative 
+ * to processing.org color their sketches (to cope with ruby FixNumber vs java int)
+ * Copyright (C) 2015-16 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;
+
+/**
+ *
+ * @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
+     */
+    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
+     * @return
+     */
+    static public int colorString(String hexstring) {
+        return java.awt.Color.decode(hexstring).getRGB();
+    }
+
+    /**
+     *
+     * @param hex
+     * @return
+     */
+    static public float colorLong(double hex) {
+        return (float) hex;
+    }
+    
+    /**
+     *
+     * @param hexlong
+     * @return
+     */
+    static public int colorLong(long hexlong){
+       return hexLong(hexlong);
+    }
+
+    /**
+     *
+     * @param hex
+     * @return
+     */
+    static public float colorDouble(double hex){
+       return (float)hex;
+    }
+}

data/src/monkstone/MathTool.java

@@ -0,0 +1,195 @@
+/**
+ * The purpose of this tool is to allow ruby-processing users to use an alternative 
+ * to processing.org map, lerp and norm methods in their sketches
+ * Copyright (C) 2015-16 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.RubyClass;
+import org.jruby.RubyFloat;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.RubyRange;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+/**
+ *
+ * @author MartinProut
+ */
+
+public class MathTool extends RubyObject {
+
+    private static final long serialVersionUID = 4427564758225746633L;
+    /**
+     *
+     * @param runtime
+     */
+    public static void createMathTool(Ruby runtime) {
+        RubyModule processing = runtime.defineModule("Processing");
+        RubyModule module = processing.defineModuleUnder("MathTool");
+        module.defineAnnotatedMethods(MathTool.class);
+    }
+
+    /**
+     *
+     * @param context JRuby runtime
+     * @param recv self
+     * @param args array of RubyRange (must be be numeric)
+     * @return RubyFloat
+     */
+    @JRubyMethod(name = "map1d", rest = true, module = true)
+    public static IRubyObject mapOneD(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        double value = (Double) args[0].toJava(Double.class);
+        RubyRange r1 = (RubyRange) args[1];
+        RubyRange r2 = (RubyRange) args[2];
+        double first1 = (Double) r1.first(context).toJava(Double.class);
+        double first2 = (Double) r2.first(context).toJava(Double.class);
+        double last1 = (Double) r1.last(context).toJava(Double.class);
+        double last2 = (Double) r2.last(context).toJava(Double.class);
+        return mapMt(context, value, first1, last1, first2, last2);
+    }
+
+    /**
+     *
+     * @param context JRuby runtime
+     * @param recv self
+     * @param args array of RubyRange (must be be numeric)
+     * @return RubyFloat
+     */
+    @JRubyMethod(name = "constrained_map", rest = true, module = true)
+    public static IRubyObject constrainedMap(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        double value = (Double) args[0].toJava(Double.class);
+        RubyRange r1 = (RubyRange) args[1];
+        RubyRange r2 = (RubyRange) args[2];
+        double first1 = (Double) r1.first(context).toJava(Double.class);
+        double first2 = (Double) r2.first(context).toJava(Double.class);
+        double last1 = (Double) r1.last(context).toJava(Double.class);
+        double last2 = (Double) r2.last(context).toJava(Double.class);
+        double max = Math.max(first1, last1);
+        double min = Math.min(first1, last1);
+        if (value < min) {
+            value = min;
+        }
+        if (value > max) {
+            value = max;
+        }
+       return mapMt(context, value, first1, last1, first2, last2);
+    }    
+    
+    /**
+     *
+     * @param context JRuby runtime
+     * @param recv self
+     * @param args floats as in processing map function
+     * @return RubyFloat
+     */
+    @JRubyMethod(name = {"p5map", "map"}, rest = true, module = true)
+    public static IRubyObject mapProcessing(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        double value = (Double) args[0].toJava(Double.class);
+        double first1 = (Double) args[1].toJava(Double.class);
+        double first2 = (Double) args[3].toJava(Double.class);
+        double last1 = (Double) args[2].toJava(Double.class);
+        double last2 = (Double) args[4].toJava(Double.class);
+        return mapMt(context, value, first1, last1, first2, last2);
+    }   
+  
+    /**
+     * A more correct version than processing.org version
+     * @param context
+     * @param recv
+     * @param args args[2] should be between 0 and 1.0 if not returns start or stop
+     * @return lerp value
+     */
+    @JRubyMethod(name = "lerp", rest = true, module = true)
+    public static IRubyObject lerpP(ThreadContext context, IRubyObject recv, IRubyObject[] args) {
+        double start = (Double) args[0].toJava(Double.class);
+        double stop = (Double) args[1].toJava(Double.class);
+        double amount = (Double) args[2].toJava(Double.class);
+        if (amount <= 0) return args[0];
+        if (amount >= 1.0) return args[1];
+        return context.getRuntime().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
+     * @param recv
+     * @param args
+     * @return norm value
+     */
+    @JRubyMethod(name = "norm", rest = true, module = true)
+    public static IRubyObject normP(ThreadContext context, IRubyObject recv, IRubyObject[] args) { 
+        double value = (Double) args[0].toJava(Double.class);
+        double start = (Double) args[1].toJava(Double.class);
+        double stop = (Double) args[2].toJava(Double.class);         
+        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
+     * @param recv
+     * @param args
+     * @return strict normalized value ie 0..1.0
+     */
+    @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 = (Double) args[0].toJava(Double.class);
+        double start = (Double) args[1].toJava(Double.class);
+        double stop = (Double) args[2].toJava(Double.class);
+        if (value <= start) {
+            return new RubyFloat(ruby, 0);
+        } else if (value >= stop) {
+            return new RubyFloat(ruby, 1.0);
+        } else {
+            return mapMt(context, value, start, stop, 0, 1.0);
+        }
+    }    
+    
+    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.getRuntime().newFloat(result);
+    }
+    
+    /**
+     * Provides processing constrain method as a ruby module method
+     * @param context
+     * @param recv
+     * @param args
+     * @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];
+        }
+    }
+
+    /**
+     *
+     * @param runtime
+     * @param metaClass
+     */
+    public MathTool(Ruby runtime, RubyClass metaClass) {
+        super(runtime, metaClass);
+    }
+}