propane 0.3.0.pre-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d427bc8bff6a2ecdae40c103234be639ce4f78db
+  data.tar.gz: 84d89e9ff7e3d14aebd3daa2eccf80e62be05bbd
+SHA512:
+  metadata.gz: 647c0f4a7f69ecd471205ecdba116d99b012f201ca705a1cef5c9660f5f23e920688e5b61603da4012f0af3a0b1f5e6a07b4a4b8e914b3f93fc8f64e21f6735c
+  data.tar.gz: 3315621182cb97955f3d9cbd6c88bc7d3ae0f4f67679fe7f83b6e774facf09ef6959ad01653c0488d5d8732f9e1c16ebddb514a41aba731c2cd673ea1410d68a

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+target
+*.jar
+*~
+MANIFEST.MF
+

data/.mvn/extensions.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<extensions>
+  <extension>
+    <groupId>io.takari.polyglot</groupId>
+    <artifactId>polyglot-ruby</artifactId>
+    <version>0.1.15</version>
+  </extension>
+</extensions>

data/.mvn/wrapper/maven-wrapper.properties

@@ -0,0 +1 @@
+distributionUrl=https://repo1.maven.org/maven2/org/apache/maven/apache-maven/3.3.3/apache-maven-3.3.3-bin.zip

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+
+rvm:
+  - jruby-19mode
+script:
+  - bundle exec rake spec
+before_install:
+  - "export DISPLAY=:99.0"
+  - "sh -e /etc/init.d/xvfb start"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gemspec
+gem 'rspec'
+gem 'rake'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Philip Cunningham
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# Propane
+
+A really slim layer to communicate with Processing from JRuby, features a polyglot maven build, this started out as a non serious project by Phillip Cunningam called ribiprocessing.  It has now morphed into an experimental project for ruby-processing so we can now "Cook with Gas". We have created a configuration free version of ruby processing, albeit tied to processing-2.2.1, where we get processing core from maven central (and opengl currently testing on linux64/mac). These jars are small enough to include in a gem distribution, and hence we should not require configuration. This would is mainly scriptable version ie files get run direct from jruby.  For certain sketches we need to call jruby via jruby-complete for this we have created an executable `propane` that can used to install `jruby-complete` and run sketches (maybe export?, possibly watch).
+
+## Building and testing
+
+```bash
+rake
+rake gem
+rake javadoc
+```
+
+## Installation
+```bash
+jgem install propane-{version}-java.gem
+```
+
+## Usage
+
+``` ruby
+require 'propane'
+
+class FlashingLightsSketch < Propane::App
+
+  attr_reader :random_background
+
+  def initialize opts={}
+    @random_background = opts.fetch :random_background, RandomBackground.new(self)
+    super
+  end
+
+  def setup
+    size(800, 600)
+  end
+
+  def draw
+    random_background.generate
+  end
+
+end
+
+class RandomBackground
+  include Propane::Proxy
+
+  def generate
+    background(rand(255), rand(255), rand(255))
+  end
+
+end
+
+FlashingLightsSketch.new title: "Flashing Lights"
+```
+
+Many sketches will run just using an installed jruby, but shader sketches must be run using jruby-complete, but don't worry we make it easy, to install jruby-complete:
+```bash
+propane --install
+```
+To run sketches using the installed jruby-complete
+```bash
+propane --run my_sketch.rb          # or
+jruby -S propane --run my_sketch.rb # belt and braces version
+```
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,59 @@
+# encoding: utf-8
+# frozen_string_literal: false
+require_relative 'lib/propane/version'
+
+def create_manifest
+  title = 'Implementation-Title: rpextras (java extension for propane)'
+  version = format('Implementation-Version: %s', Propane::VERSION)
+  File.open('MANIFEST.MF', 'w') do |f|
+    f.puts(title)
+    f.puts(version)
+  end
+end
+
+task default: [:init, :compile, :install, :test]
+
+desc 'Create Manifest'
+task :init do
+  create_manifest
+end
+
+desc 'Install'
+task :install do
+  sh 'mvn dependency:copy'
+  sh 'mv target/rpextras.jar lib'
+end
+
+desc 'Gem'
+task :gem do
+  sh 'gem build propane.gemspec'
+end
+
+desc 'Document'
+task :javadoc do
+  sh 'mvn javadoc:javadoc'
+end
+
+desc 'Compile'
+task :compile do
+  sh 'mvn package'
+end
+
+desc 'JRuby-Complete'
+task :install_complete do
+  sh 'cd vendors && rake'
+end
+
+desc 'Test'
+task :test do
+  sh 'jruby test/respond_to_test.rb'
+end
+
+desc 'clean'
+task :clean do
+  Dir['./**/*.%w{jar gem}'].each do |path|
+    puts 'Deleting #{path} ...'
+    File.delete(path)
+  end
+  FileUtils.rm_rf('./target')
+end

data/VERSION.txt

@@ -0,0 +1,4 @@
+0.2.0
+=====
+
+* Added some guard clauses and fleshed out specs.

data/bin/propane

@@ -0,0 +1,8 @@
+#!/usr/bin/env jruby
+unless defined? PROPANE_ROOT
+  $LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+  PROPANE_ROOT = File.expand_path(File.dirname(__FILE__) + '/../')
+end
+
+require "#{PROPANE_ROOT}/lib/propane/runner"
+Propane::Runner.execute

data/examples/complete/Rakefile

@@ -0,0 +1,32 @@
+# encoding: utf-8
+# frozen_string_literal: true
+# Simple demo Rakefile to autorun samples in current directory
+# adjust path to jruby-complete, and or opts as required
+
+SAMPLES_DIR = './'
+
+desc 'run demo'
+task default: [:demo]
+
+desc 'demo'
+task :demo do
+  samples_list.shuffle.each { |sample| run_sample sample }
+end
+
+def samples_list
+  files = []
+  Dir.chdir(SAMPLES_DIR)
+  Dir.glob('*.rb').each do |file|
+    files << File.join(SAMPLES_DIR, file)
+  end
+  return files
+end
+
+def run_sample(sample_name)
+  puts "Running #{sample_name}...quit to run next sample"
+  open("|jruby -S propane --run #{sample_name}", 'r') do |io|
+    while l = io.gets
+      puts(l.chop)
+    end
+  end
+end

data/examples/complete/data/displaceFrag.glsl

@@ -0,0 +1,8 @@
+
+uniform sampler2D colorMap;
+
+varying vec4 vertTexCoord;
+
+void main() {
+  gl_FragColor = texture2D(colorMap, vertTexCoord.st);
+}

data/examples/complete/data/displaceVert.glsl

@@ -0,0 +1,201 @@
+
+#define PROCESSING_TEXLIGHT_SHADER
+
+uniform mat4 modelview;
+uniform mat4 transform;
+uniform mat3 normalMatrix;
+uniform mat4 texMatrix;
+
+uniform int lightCount;
+uniform vec4 lightPosition[8];
+uniform vec3 lightNormal[8];
+uniform vec3 lightAmbient[8];
+uniform vec3 lightDiffuse[8];
+uniform vec3 lightSpecular[8];
+uniform vec3 lightFalloff[8];
+uniform vec2 lightSpot[8];
+
+attribute vec4 vertex;
+attribute vec4 color;
+attribute vec3 normal;
+attribute vec2 texCoord;
+
+attribute vec4 ambient;
+attribute vec4 specular;
+attribute vec4 emissive;
+attribute float shininess;
+
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+const float zero_float = 0.0;
+const float one_float = 1.0;
+const vec3 zero_vec3 = vec3(0);
+
+uniform float displaceStrength;
+uniform float time;
+
+float falloffFactor(vec3 lightPos, vec3 vertPos, vec3 coeff) {
+  vec3 lpv = lightPos - vertPos;
+  vec3 dist = vec3(one_float);
+  dist.z = dot(lpv, lpv);
+  dist.y = sqrt(dist.z);
+  return one_float / dot(dist, coeff);
+}
+
+float spotFactor(vec3 lightPos, vec3 vertPos, vec3 lightNorm, float minCos, float spotExp) {
+  vec3 lpv = normalize(lightPos - vertPos);
+  vec3 nln = -one_float * lightNorm;
+  float spotCos = dot(nln, lpv);
+  return spotCos <= minCos ? zero_float : pow(spotCos, spotExp);
+}
+
+float lambertFactor(vec3 lightDir, vec3 vecNormal) {
+  return max(zero_float, dot(lightDir, vecNormal));
+}
+
+float blinnPhongFactor(vec3 lightDir, vec3 vertPos, vec3 vecNormal, float shine) {
+  vec3 np = normalize(vertPos);
+  vec3 ldp = normalize(lightDir - np);
+  return pow(max(zero_float, dot(ldp, vecNormal)), shine);
+}
+
+// Source code for GLSL Perlin noise courtesy of:
+// https://github.com/ashima/webgl-noise/wiki
+
+vec3 mod289(vec3 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec2 mod289(vec2 x) {
+  return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+
+vec3 permute(vec3 x) {
+  return mod289(((x*34.0)+1.0)*x);
+}
+
+float snoise(vec2 v)
+  {
+  const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
+                      0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
+                     -0.577350269189626, // -1.0 + 2.0 * C.x
+                      0.024390243902439); // 1.0 / 41.0
+// First corner
+  vec2 i = floor(v + dot(v, C.yy) );
+  vec2 x0 = v - i + dot(i, C.xx);
+
+// Other corners
+  vec2 i1;
+  //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+  //i1.y = 1.0 - i1.x;
+  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  // x0 = x0 - 0.0 + 0.0 * C.xx ;
+  // x1 = x0 - i1 + 1.0 * C.xx ;
+  // x2 = x0 - 1.0 + 2.0 * C.xx ;
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+
+// Permutations
+  i = mod289(i); // Avoid truncation effects in permutation
+  vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
++ i.x + vec3(0.0, i1.x, 1.0 ));
+
+  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
+  m = m*m ;
+  m = m*m ;
+
+// Gradients: 41 points uniformly over a line, mapped onto a diamond.
+// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+
+// Normalise gradients implicitly by scaling m
+// Approximation of: m *= inversesqrt( a0*a0 + h*h );
+  m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
+
+// Compute final noise value at P
+  vec3 g;
+  g.x = a0.x * x0.x + h.x * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}
+
+void main() {
+  // Calculating texture coordinates, with r and q set both to one
+  vertTexCoord = texMatrix * vec4(texCoord, 1.0, 1.0);
+
+  vec2 p = texCoord; // put coordinates into vec2 p for convenience
+  p.x += time; // add time to make the noise and the subsequent displacement move
+  float df = snoise( p ); // create displacement float value from shader-based 2D Perlin noise
+  vec4 newVertexPos = vertex + vec4(normal * df * displaceStrength, 0.0); // regular vertex position + direction * displacementMap * displaceStrength
+
+  // Vertex in clip coordinates
+  gl_Position = transform * newVertexPos;
+    
+  // Vertex in eye coordinates
+  vec3 ecVertex = vec3(modelview * vertex);
+  
+  // Normal vector in eye coordinates
+  vec3 ecNormal = normalize(normalMatrix * normal);
+  
+  if (dot(-one_float * ecVertex, ecNormal) < zero_float) {
+    // If normal is away from camera, choose its opposite.
+    // If we add backface culling, this will be backfacing
+    ecNormal *= -one_float;
+  }
+
+  // Light calculations
+  vec3 totalAmbient = vec3(0, 0, 0);
+  vec3 totalDiffuse = vec3(0, 0, 0);
+  vec3 totalSpecular = vec3(0, 0, 0);
+  for (int i = 0; i < 8; i++) {
+    if (lightCount == i) break;
+    
+    vec3 lightPos = lightPosition[i].xyz;
+    bool isDir = zero_float < lightPosition[i].w;
+    float spotCos = lightSpot[i].x;
+    float spotExp = lightSpot[i].y;
+    
+    vec3 lightDir;
+    float falloff;
+    float spotf;
+      
+    if (isDir) {
+      falloff = one_float;
+      lightDir = -one_float * lightNormal[i];
+    } else {
+      falloff = falloffFactor(lightPos, ecVertex, lightFalloff[i]);
+      lightDir = normalize(lightPos - ecVertex);
+    }
+  
+    spotf = spotExp > zero_float ? spotFactor(lightPos, ecVertex, lightNormal[i],
+                                              spotCos, spotExp)
+                                 : one_float;
+    
+    if (any(greaterThan(lightAmbient[i], zero_vec3))) {
+      totalAmbient += lightAmbient[i] * falloff;
+    }
+    
+    if (any(greaterThan(lightDiffuse[i], zero_vec3))) {
+      totalDiffuse += lightDiffuse[i] * falloff * spotf *
+                       lambertFactor(lightDir, ecNormal);
+    }
+    
+    if (any(greaterThan(lightSpecular[i], zero_vec3))) {
+      totalSpecular += lightSpecular[i] * falloff * spotf *
+                       blinnPhongFactor(lightDir, ecVertex, ecNormal, shininess);
+    }
+  }
+  
+  // Calculating final color as result of all lights (plus emissive term).
+  // Transparency is determined exclusively by the diffuse component.
+  vertColor = vec4(totalAmbient, 0) * ambient +
+              vec4(totalDiffuse, 1) * color +
+              vec4(totalSpecular, 0) * specular +
+              vec4(emissive.rgb, 0);
+              
+}