propane 0.3.0.pre-java

data/lib/export.txt

@@ -0,0 +1,10 @@
+# If you want to support more platforms, visit jogamp.org to get the 
+# natives libraries for the platform in question (i.e. Solaris). 
+
+name = OpenGL
+
+application.macosx=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-macosx-universal.jar,gluegen-rt-natives-macosx-universal.jar
+application.windows32=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-windows-i586.jar,gluegen-rt-natives-windows-i586.jar
+application.windows64=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-windows-amd64.jar,gluegen-rt-natives-windows-amd64.jar
+application.linux32=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-linux-i586.jar,gluegen-rt-natives-linux-i586.jar
+application.linux64=core.jar,jogl-all.jar,gluegen-rt.jar,jogl-all-natives-linux-amd64.jar,gluegen-rt-natives-linux-amd64.jar

data/lib/propane.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+# frozen_string_literal: false
+unless defined? PROPANE_ROOT
+  $LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+  PROPANE_ROOT = File.expand_path(File.dirname(__FILE__) + '/../')
+end
+Dir["#{PROPANE_ROOT}/lib/*.jar"].each do |jar|
+  require jar
+end
+require 'propane/version'
+require 'propane/app'
+require 'propane/helpers/numeric'

data/lib/propane/app.rb

@@ -0,0 +1,197 @@
+# encoding: utf-8
+# frozen_string_literal: false
+require_relative 'underscorer'
+require_relative 'helper_methods'
+require_relative 'library_loader'
+
+module Propane
+  include_package 'processing.core' # imports the processing jar.
+  # Load vecmath, fastmath and mathtool modules
+  Java::Monkstone::PropaneLibrary.load(JRuby.runtime)
+  # We may change this
+  module Render
+    java_import 'monkstone.vecmath.AppRender'
+    java_import 'monkstone.vecmath.ShapeRender'
+  end
+
+  
+
+  # This class is the base class the user should inherit from when making
+  # their own sketch.
+  #
+  # i.e.
+  #
+  # class MySketch < Propane::App
+  #
+  #   def draw
+  #     background rand(255)
+  #   end
+  #
+  # end
+  class App < PApplet
+    include Math
+    include HelperMethods
+    attr_reader :title, :arguments, :options
+    # App should be instantiated with an optional list of options
+    # and array of arguments.
+    #
+    # App.new(width: 500, height: 500, fullscreen: true)
+    #
+    class << self
+      # Handy getters and setters on the class go here:
+      attr_accessor :sketch_class, :library_loader
+
+      def load_libraries(*args)
+        library_loader ||= LibraryLoader.new
+        library_loader.load_library(*args)
+      end
+      alias_method :load_library, :load_libraries
+
+      def library_loaded?(library_name)
+        library_loader.library_loaded?(library_name)
+      end
+
+      def load_ruby_library(*args)
+        library_loader.load_ruby_library(*args)
+      end
+
+      def load_java_library(*args)
+        library_loader.load_java_library(*args)
+      end
+    end
+
+    def library_loaded?(library_name)
+      self.class.library_loaded?(library_name)
+    end
+    
+    
+    def initialize(options = {}, arguments = [])
+      # Guard against invalid input.
+      proxy_java_fields
+      raise TypeError unless options.is_a?   Hash
+      raise TypeError unless arguments.is_a? Array
+      # Set up the sketch.
+      super()
+      $app = self
+      @arguments = arguments
+      @options   = options
+      configure_sketch
+      run_sketch
+    end
+
+    def size(*args)
+      w, h, mode       = *args
+      @width           ||= w
+      @height          ||= h
+      @render_mode     ||= mode
+      import_opengl if /opengl/ =~ mode
+      super(*args)
+    end
+
+    # This method runs the processing sketch.
+    #
+    def run_sketch
+      PApplet.run_sketch(arguments, self)
+    end
+    
+    # Is the mouse pressed for this frame?
+    def mouse_pressed?
+      @declared_fields['mousePressed'].value(java_self)
+    end
+
+    # Is a key pressed for this frame?
+    def key_pressed?
+      @declared_fields['keyPressed'].value(java_self)
+    end
+    
+    # Fix java conversion problems getting the last key
+    # If it's ASCII, return the character, otherwise the integer
+    def key
+      int = @declared_fields['key'].value(java_self)
+      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
+    
+    def import_opengl
+      # Include processing opengl classes that we'd like to use:
+      %w(FontTexture FrameBuffer LinePath LineStroker PGL
+         PGraphics2D PGraphics3D PGraphicsOpenGL PShader
+         PShapeOpenGL Texture).each do |klass|
+        java_import "processing.opengl.#{klass}"
+      end
+    end
+
+    # This method configures the sketch title and and presentation mode.
+    #
+    def configure_sketch
+      set_sketch_title
+      set_presentation_mode
+    end
+
+    # This method sets the sketch presentation mode.
+    #
+    def set_presentation_mode
+      arguments.concat ['--present'] if options[:fullscreen]
+    end
+
+    # This method sets the sketch title.
+    #
+    def set_sketch_title
+      title_string = options.fetch(:title, 'processing sketch')
+      arguments.concat [title_string]
+    end
+
+    %w(displayHeight displayWidth frameCount keyCode
+       mouseButton mouseX mouseY pmouseX pmouseY).each do |name|
+      sc_name = name.split(/(?![a-z])(?=[A-Z])/).map(&:downcase).join('_')
+      alias_method sc_name, name
+    end
+
+    def self.method_added(name)
+      name = name.to_s
+      if name.include?('_')
+        lcc_name = name.split('_').map(&:capitalize).join('')
+        lcc_name[0] = lcc_name[0].downcase
+        alias_method lcc_name, name if lcc_name != name
+      end
+    end
+
+    def method_missing(name, *args)
+      self.class.__send__(name, *args) if PApplet.public_methods.include?(name)
+    end
+    
+    def proxy_java_fields
+      fields = %w(sketchPath key frameRate mousePressed keyPressed)
+      methods  = fields.map { |field| java_class.declared_field(field) }
+      @declared_fields = Hash[fields.zip(methods)]
+    end
+    
+    # Fix java conversion problems getting the last key
+    # If it's ASCII, return the character, otherwise the integer
+   # def self.key
+   #   int = @declared_fields['key'].value(java_self)
+   #   int < 256 ? int.chr : int
+   # end
+  end
+
+  # Importing PConstants to access to processing constants,
+  # to keep namespace clean use PConstants::TRIANGLE (for example)
+  # or to use bare TRIANGLE also 'include PConstants'
+  # Using :method_missing to mimic inner class methods
+  # @HACK you should consider using 'forwardable' to avoid this
+  # egregious hack...
+  module Proxy
+    java_import 'processing.core.PConstants'
+
+    def method_missing(name, *args)
+      return $app.send(name, *args) if $app && $app.respond_to?(name)
+      super
+    end
+  end
+end

data/lib/propane/helper_methods.rb

@@ -0,0 +1,177 @@
+# encoding: utf-8
+# frozen_string_literal: false
+module Propane
+  module HelperMethods
+    # processings epsilon may not be defined yet
+    EPSILON ||= 1.0e-04
+    # Nice block method to draw to a buffer.
+    # You can optionally pass it a width, a height, and a renderer.
+    # Takes care of starting and ending the draw for you.
+    def buffer(buf_width = width, buf_height = height, renderer = @render_mode)
+      buf = create_graphics(buf_width, buf_height, renderer)
+      buf.begin_draw
+      yield buf
+      buf.end_draw
+      buf
+    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)
+      (0...cols * rows).map do |i|
+        x = col_size * (i % cols)
+        y = row_size * i.div(cols)
+        yield x, y
+      end
+    end
+
+    # lerp_color takes three or four arguments, in Java that's two
+    # different methods, one regular and one static, so:
+    def lerp_color(*args)
+      args.length > 3 ? self.class.lerp_color(*args) : super(*args)
+    end
+
+    def color(*args)
+      return super(*args) unless args.length == 1
+      super(hex_color(args[0]))
+    end
+
+    # Overrides Processing convenience function thread, which takes a String
+    # arg (for a function) to more rubylike version, takes a block...
+    def thread(&block)
+      if block_given?
+        Thread.new(&block)
+      else
+        raise ArgumentError, 'thread must be called with a block', caller
+      end
+    end
+
+    # explicitly provide 'processing.org' min instance method
+    # to return a float:- a, b and c need to be floats
+
+    def min(*args)
+      args.min # { |a,b| a <=> b } optional block not reqd
+    end
+
+    # explicitly provide 'processing.org' max instance method
+    # to return a float:- a, b and c need to be floats
+
+    def max(*args)
+      args.max # { |a, b| a <=> b } optional block not reqd
+    end
+
+    # explicitly provide 'processing.org' dist instance method
+    def dist(*args)
+      len = args.length
+      return dist2d(*args) if len == 4
+      return dist3d(*args) if len == 6
+      raise ArgumentError, 'takes 4 or 6 parameters'
+    end
+
+    # Uses PImage class method under hood
+    def blend_color(c1, c2, mode)
+      Java::ProcessingCore::PImage.blendColor(c1, c2, mode)
+    end
+
+    # There's just so many functions in Processing,
+    # Here's a convenient way to look for them.
+    def find_method(method_name)
+      reg = Regexp.new(method_name.to_s, true)
+      methods.sort.select { |meth| reg.match(meth) }
+    end
+
+    # Proxy over a list of Java declared fields that have the same name as
+    # some methods. Add to this list as needed.
+    def proxy_java_fields
+      fields = %w(sketchPath key frameRate frame mousePressed keyPressed)
+      methods = fields.map { |field| java_class.declared_field(field) }
+      @declared_fields = Hash[fields.zip(methods)]
+    end
+
+    class VersionError < StandardError
+    end
+
+    # By default, your sketch path is the folder that your sketch is in.
+    # If you'd like to do something fancy, feel free.
+    def set_sketch_path(spath = nil)
+      field = @declared_fields['sketchPath']
+      begin
+        field.set_value(java_self, spath || SKETCH_ROOT)
+      rescue TypeError
+        raise VersionError, 'Use JRubyArt for processing-3.0'
+      end
+    end
+
+    
+
+    # Provide a convenient handle for the Java-space version of self.
+    #def java_self
+    #  @java_self ||= to_java(Java::ProcessingCore::PApplet)
+    #end
+
+    # Get the sketch path
+    def sketch_path
+      @declared_fields['sketchPath'].value(java_self)
+    end
+
+    # Fields that should be made accessible as under_scored.
+    define_method(:mouse_x) { mouseX }
+
+    define_method(:mouse_y) { mouseY }
+
+    define_method(:pmouse_x) { pmouseX }
+
+    define_method(:pmouse_y) { pmouseY }
+
+    define_method(:frame_count) { frameCount }
+
+    define_method(:mouse_button) { mouseButton }
+
+    define_method(:key_code) { keyCode }
+
+    # Ensure that load_strings returns a real Ruby array
+    def load_strings(file_or_url)
+      loadStrings(file_or_url).to_a
+    end
+
+    # Writes an array of strings to a file, one line per string.
+    # This file is saved to the sketch's data folder
+    def save_strings(filename, strings)
+      saveStrings(filename, [strings].flatten.to_java(:String))
+    end
+
+    # frame_rate needs to support reading and writing
+    def frame_rate(fps = nil)
+      return @declared_fields['frameRate'].value(java_self) unless fps
+      super(fps)
+    end
+
+
+    private
+
+    # 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)
+        return Java::Monkstone::ColorUtil.colorString(a) if a =~ /#\h+/
+        raise StandardError, 'Dodgy Hexstring'
+      end
+      Java::Monkstone::ColorUtil.colorDouble(a)
+    end
+
+    def dist2d(*args)
+      dx = args[0] - args[2]
+      dy = args[1] - args[3]
+      return 0 if dx.abs < EPSILON && dy.abs < EPSILON
+      Math.hypot(dx, dy)
+    end
+
+    def dist3d(*args)
+      dx = args[0] - args[3]
+      dy = args[1] - args[4]
+      dz = args[2] - args[5]
+      return 0 if dx.abs < EPSILON && dy.abs < EPSILON && dz.abs < EPSILON
+      Math.sqrt(dx * dx + dy * dy + dz * dz)
+    end
+  end
+end

data/lib/propane/helpers/numeric.rb

@@ -0,0 +1,9 @@
+class Numeric #:nodoc:
+  def degrees
+    self * 180 / Math::PI
+  end
+
+  def radians
+    self * Math::PI / 180
+  end
+end

data/lib/propane/library_loader.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+require "#{PROPANE_ROOT}/lib/propane"
+
+# The processing wrapper module
+module Propane
+  # Encapsulate library loader functionality as a class
+  class LibraryLoader
+    def initialize
+      @loaded_libraries = Hash.new(false)
+    end
+
+    # Detect if a library has been loaded (for conditional loading)
+    def library_loaded?(library_name)
+      @loaded_libraries[library_name.to_sym]
+    end
+
+    # Load a list of Ruby or Java libraries (in that order)
+    # Usage: load_libraries :opengl, :boids
+    #
+    # If a library is put into a 'library' folder next to the sketch it will
+    # be used instead of the library that ships with Propane.
+    def load_libraries(*args)
+      message = 'no such file to load -- %s'
+      args.each do |lib|
+        loaded = load_ruby_library(lib) || load_java_library(lib)
+        fail(LoadError.new, format(message, lib)) unless loaded
+      end
+    end
+    alias_method :load_library, :load_libraries
+
+    # For pure ruby libraries.
+    # The library should have an initialization ruby file
+    # of the same name as the library folder.
+    def load_ruby_library(library_name)
+      library_name = library_name.to_sym
+      return true if @loaded_libraries.include?(library_name)
+      path = get_library_paths(library_name, 'rb').first
+      return false unless path
+      @loaded_libraries[library_name] = (require path)
+    end
+
+    # HACK: For pure java libraries, such as the ones that are available
+    # on this page: http://processing.org/reference/libraries/index.html
+    # that include native code, we mess with the 'Java ClassLoader', so that
+    # you don't have to futz with your PATH. But it's probably bad juju.
+    def load_java_library(library_name)
+      library_name = library_name.to_sym
+      return true if @loaded_libraries.include?(library_name)
+      jpath = get_library_directory_path(library_name, 'jar')
+      jars = get_library_paths(library_name, 'jar')
+      return false if jars.empty?
+      jars.each { |jar| require jar }
+      platform_specific_library_paths = get_platform_specific_library_paths(jpath)
+      platform_specific_library_paths = platform_specific_library_paths.select do |ppath|
+        FileTest.directory?(ppath) && !Dir.glob(File.join(ppath, '*.{so,dll,jnilib}')).empty?
+      end
+      unless platform_specific_library_paths.empty?
+        platform_specific_library_paths << java.lang.System.getProperty('java.library.path')
+        new_library_path = platform_specific_library_paths.join(java.io.File.pathSeparator)
+        java.lang.System.setProperty('java.library.path', new_library_path)
+        field = java.lang.Class.for_name('java.lang.ClassLoader').get_declared_field('sys_paths')
+        if field
+          field.accessible = true
+          field.set(java.lang.Class.for_name('java.lang.System').get_class_loader, nil)
+        end
+      end
+      @loaded_libraries[library_name] = true
+    end
+
+    def platform
+      match = %w(mac linux windows).find do |os|
+        java.lang.System.getProperty('os.name').downcase.index(os)
+      end
+      return 'other' unless match
+      return match unless match =~ /mac/
+      'macosx'
+    end
+
+    def get_platform_specific_library_paths(basename)
+      # for MacOSX, but does this even work, or does Mac return '64'?
+      bits = 'universal'
+      if java.lang.System.getProperty('sun.arch.data.model') == '32' ||
+         java.lang.System.getProperty('java.vm.name').index('32')
+        bits = '32'
+      elsif java.lang.System.getProperty('sun.arch.data.model') == '64' ||
+            java.lang.System.getProperty('java.vm.name').index('64')
+        bits = '64' unless platform =~ /macosx/
+      end
+      [platform, platform + bits].map { |p| File.join(basename, p) }
+    end
+
+    def get_library_paths(library_name, extension = nil)
+      dir = get_library_directory_path(library_name, extension)
+      Dir.glob("#{dir}/*.{rb,jar}")
+    end
+
+    protected
+
+    def get_library_directory_path(library_name, extension = nil)
+      extensions = extension ? [extension] : %w(jar rb)
+      extensions.each do |ext|
+        [
+          "#{PROPANE_ROOT}/library/#{library_name}",
+          "#{PROPANE_ROOT}/library/#{library_name}/library",
+          "#{PROPANE_ROOT}/library/#{library_name}"
+        ].each do |jpath|
+          if File.exist?(jpath) && !Dir.glob(format('%s/*.%s', jpath, ext)).empty?
+            return jpath
+          end
+        end
+      end
+      nil
+    end    
+  end
+end