picrate 0.0.2-java

data/lib/picrate/creators/sketch_factory.rb

@@ -0,0 +1,12 @@
+require_relative 'sketch_writer'
+
+class SketchFactory
+  NAMES = %w[One Two Three]
+  def initialize(argc)
+    NAMES.each do |name|
+      SketchWriter.new(File.basename(name, '.rb'), width: 300, height: 300).write
+    end
+  end
+end
+
+SketchFactory.new(File.join(ENV['HOME'], 'test'))

data/lib/picrate/creators/sketch_writer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: false
+require_relative 'sketch_class'
+
+# The file writer can write a sketch when given instance of Sketch type
+class SketchWriter
+  attr_reader :file, :sketch
+
+  def initialize(path, args)
+    @sketch = SketchClass.new(
+      name: path,
+      width: args[0].to_i,
+      height: args[1].to_i,
+      mode: args[2]
+    )
+    @file = format('%s/%s.rb', File.dirname(path), path)
+  end
+
+  def write
+    File.open(file, 'w+') { |f| f.write sketch.lines.join("\n") }
+  end
+end

data/lib/picrate/helper_methods.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: false
+# processing module wrapper
+require_relative 'helpers/numeric'
+module Processing
+  # Provides some convenience methods
+  module HelperMethods
+    # processings epsilon may not be defined yet
+    EPSILON ||= 9.999999747378752e-05
+    # 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
+
+    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) { |x, y| block_stuff }
+    # NB: now implemented in java
+
+    # 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
+
+    # hue, sat, brightness in range 0..1.0 returns RGB color int
+    def hsb_color(hue, sat, brightness)
+      Java::Monkstone::ColorUtil.hsbToRgB(hue, sat, brightness)
+    end
+
+    def color(*args)
+      return super(*args) unless args.length == 1
+      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)
+      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
+    # you might choose to use ruby method directly and then
+    # provide a block to alter comparator eg
+    # args.min(&block) # { |a, b| a.value <=> b.value }
+
+    def min(*args)
+      args.min
+    end
+
+    # explicitly provide 'processing.org' max instance method
+    # to return a float:- a, b and c need to be floats see above
+
+    def max(*args)
+      args.max
+    end
+
+    # explicitly provide 'processing.org' dist instance method
+    def dist(*args)
+      case args.length
+      when 4
+        return dist2d(*args)
+      when 6
+        return dist3d(*args)
+      else
+        raise ArgumentError, 'takes 4 or 6 parameters'
+      end
+    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(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 key
+      int = @declared_fields['key'].value(java_self)
+      int < 256 ? int.chr : int
+    end
+
+    # Provide a convenient handle for the Java-space version of self.
+    def java_self
+      @java_self ||= to_java(Java::ProcessingCore::PApplet)
+    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
+
+    # 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
+
+    private
+
+    INTEGER_COL = -> (x) { x.is_a?(Integer) }
+    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)
+      case a
+      when INTEGER_COL
+        Java::Monkstone::ColorUtil.colorLong(a)
+      when STRING_COL
+        return Java::Monkstone::ColorUtil.colorString(a) if a =~ /#\h+/
+        raise StandardError, 'Dodgy Hexstring'
+      when FLOAT_COL
+        Java::Monkstone::ColorUtil.colorDouble(a)
+      else
+        raise StandardError, 'Dodgy Color Conversion'
+      end
+    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/picrate/helpers/numeric.rb

@@ -0,0 +1,9 @@
+class Numeric #:nodoc:
+  def degrees
+    self * 57.29577951308232
+  end
+
+  def radians
+    self * 0.017453292519943295
+  end
+end

data/lib/picrate/library.rb

@@ -0,0 +1,69 @@
+require_relative 'native_folder'
+require_relative 'native_loader'
+require 'pathname'
+
+# This class knows where to find picrate libraries
+class Library
+  attr_reader :name, :path, :dir, :ppath
+
+  def initialize(name)
+    @name = name
+    @ruby = true
+  end
+
+  def locate
+    return if (@path = Pathname.new(
+      File.join(Processing::SKETCH_ROOT, 'library', name, "#{name}.rb")
+    )).exist?
+    return if (@path = Pathname.new(
+      File.join(PICRATE_ROOT, 'library', name, "#{name}.rb")
+    )).exist?
+    locate_java
+  end
+
+  def locate_java
+    @dir = Pathname.new(
+      File.join(Processing::SKETCH_ROOT, 'library', name)
+    )
+    locate_installed_java
+  end
+
+  def locate_installed_java
+    unless dir.directory?
+      @dir = Pathname.new(
+        File.join(ENV['HOME'], '.picrate', 'libraries', name, 'library')
+      )
+    end
+    @path = dir.join(Pathname.new("#{name}.jar"))
+  end
+
+  def ruby?
+    path.extname == '.rb'
+  end
+
+  def exist?
+    path.exist?
+  end
+
+  def load_jars
+    Dir.glob("#{dir}/*.jar").each do |jar|
+      require jar
+    end
+    return true unless native_binaries?
+    add_binaries_to_classpath
+  end
+
+  def native_binaries?
+    native_folder = NativeFolder.new
+    native = native_folder.name
+    @ppath = File.join(dir, native)
+    File.directory?(ppath) &&
+      !Dir.glob(File.join(ppath, native_folder.extension)).empty?
+  end
+
+  def add_binaries_to_classpath
+    native_loader = NativeLoader.new
+    native_loader.add_native_path(ppath)
+    true
+  end
+end

data/lib/picrate/library_loader.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: false
+
+# The processing wrapper module
+module Processing
+  require_relative 'library'
+
+  # Encapsulate library loader functionality as a class
+  class LibraryLoader
+    attr_reader :library
+
+    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 :video, :video_event
+    #
+    # If a library is put into a 'library' folder next to the sketch it will
+    # be used instead of an installed picrate library.
+    def load_libraries(*args)
+      message = 'no such file to load -- %s'
+      args.each do |lib|
+        loaded = loader(lib)
+        raise(LoadError.new, format(message, lib)) unless loaded
+      end
+    end
+    alias load_library load_libraries
+
+    def loader(name)
+      return true if @loaded_libraries.include?(name)
+      fname = name.to_s
+      library = Library.new(fname)
+      library.locate
+      return require_library(library, name) if library.ruby?
+      warn("Not found library: #{fname}") unless library.exist?
+      load_jars(library, name)
+    end
+
+    def load_jars(lib, name)
+      lib.load_jars
+      @loaded_libraries[name] = true
+    end
+
+    def require_library(lib, name)
+      @loaded_libraries[name] = require lib.path
+    end
+  end
+end

data/lib/picrate/native_folder.rb

@@ -0,0 +1,35 @@
+require 'rbconfig'
+
+# Utility to load native binaries on Java CLASSPATH
+class NativeFolder
+  attr_reader :os, :bit
+
+  WIN_FORMAT = 'windows%d'.freeze
+  LINUX_FORMAT = 'linux%d'.freeze
+  ARM32 = '-armv6hf'.freeze
+  ARM64 = '-aarch64'.freeze
+  # WIN_PATTERNS = [
+  #   /bccwin/i,
+  #   /cygwin/i,
+  #   /djgpp/i,
+  #   /ming/i,
+  #   /mswin/i,
+  #   /wince/i
+  # ].freeze
+
+  def initialize
+    @os = RbConfig::CONFIG['host_os'].downcase
+    @bit = java.lang.System.get_property('os.arch') =~ /64/ ? 64 : 32
+  end
+
+  def name
+    return 'macosx' if os =~ /darwin/ || os =~ /mac/
+    return format(LINUX_FORMAT, ARM32) if os =~ /^arm/
+    return format(LINUX_FORMAT, bit) if os =~ /linux/
+  end
+
+  def extension
+    return '*.so' if os =~ /linux/
+    '*.dylib' # MacOS
+  end
+end

data/lib/picrate/native_loader.rb

@@ -0,0 +1,27 @@
+# This class knows how to dynamically set the 'java' native library path
+# It might not work with java 9?
+class NativeLoader
+  attr_reader :separator, :current_path
+
+  # This module wraps java_import with namespace JC
+  module JC
+    java_import 'java.lang.Class'
+    java_import 'java.lang.System'
+    java_import 'java.io.File'
+  end
+
+  def initialize
+    @separator = JC::File.pathSeparatorChar
+    @current_path = JC::System.getProperty('java.library.path')
+  end
+
+  def add_native_path(pth)
+    current_path << separator << pth
+    JC::System.setProperty('java.library.path', current_path)
+    field = JC::Class.for_name('java.lang.ClassLoader')
+                     .get_declared_field('sys_paths')
+    return unless field
+    field.accessible = true # some jruby magic
+    field.set(JC::Class.for_name('java.lang.System').get_class_loader, nil)
+  end
+end