jruby_art 0.2.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3828fdddac86cd22f16778671b86ca7177b73aa
+  data.tar.gz: 0cc177cf9d0e4d9027694777439ffd4330ed4ad2
+SHA512:
+  metadata.gz: 9493554519ee7744117ebfb307c0f9c48e78f0e447f3bc0dd98bd5ad1921605bd43debd6173d0ed46582bfae4c39670d1fd2e3674c9d5306c6857cc457ab7dc1
+  data.tar.gz: 2813e9daadee89de3bd19ca20f6a8d4252bb7a9f2e1c3171efde53ca5cfb0df720100c5ef65ca7cc0e55a5e1ba4cd2648e81ba4132e11b61f0122fa44fd4154e

data/LICENSE.md

@@ -0,0 +1,39 @@
+JRubyArt is released under the MIT License. 
+You can do pretty much whatever you'd like with it.
+
+___
+
+Copyright (c) 2013 Martin Prout
+
+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.
+
+___
+
+JRubyArt depends on core components 
+of both [JRuby][] and [Processing][] both of which are 
+licensed under the GNU lesser public license
+
+[jruby]: http://www.jruby.org/
+[processing]: http://www.processing.org/

data/README.md

@@ -0,0 +1,88 @@
+## JRubyArt
+
+
+Is a development fork of [ruby-processing][] that may soon have a somewhat independent existence, see [processing-core][] at least in the short term. Plan was that JRubyArt releases (pre-releases) would use jruby-9.0.0.0 from the start, but now I think it might be more sane to start with jruby-1.7.19.  However until that time:-
+
+
+You should (like ruby-processing) install [processing-2.2.1][]
+
+Then create a `~/.jruby_art/config.yml` config file, here is
+what mine looks like on arch-linux
+
+```ruby
+---
+PROCESSING_ROOT: /usr/share/processing
+
+```
+However unlike ruby-processing, the core jars become part of the gem and PROCESSING_ROOT is not used at runtime.
+
+The following config should work on macosx
+
+```ruby
+---
+PROCESSING_ROOT: /Applications/Processing.app/Contents/Java
+```
+
+To copy processing jars `rake processing_jars`
+
+To compile extensions `jruby -S rake compile` _requires rake-compiler gem_
+
+To build gem `jruby -S rake package`
+
+To install `gem install pkg/jruby_art-0.2.pre.gem`
+
+To create a new blank sketch
+
+```bash
+k9 create my_app 200 200
+```
+
+or for 3D opengl sketch
+
+```bash
+k9 create my_app 200 200 p3d
+```
+
+To run most sketches, all you need is an installed jruby:-
+
+```bash
+jruby my_app.rb
+```
+
+To run certain sketches, eg those with load_image (or shaders), either use [netbeans][] as your development ide or use the vendored jruby-complete (beyond our control something to do with jruby permissions?).  To install jruby-complete:-
+
+```bash
+k9 setup install # requires wget (Now also downloads examples to users home)
+```
+To run sketches with jruby-complete (rather than installed jruby)
+
+```bash
+k9 run my_app.rb # NB: k9 setup install, is a one-time install to gem procedure
+```
+
+[Contributing][]
+
+[License][]
+
+[Acknowledgements][]
+
+[Examples][]
+
+[CHANGELOG][]
+
+###Ruby Versions
+
+jruby-9.0.0.0.pre1+ (when sketches run with jruby command)
+
+ruby-2.1.2+ (when sketches are run using k9 command, ie using jruby-complete)
+
+[Acknowledgements]:ACKNOWLEDGEMENTS.md
+[CHANGELOG]:CHANGELOG.md
+[Contributing]:CONTRIBUTING.md
+[Examples]:https://github.com/ruby-processing/JRubyArt-examples
+[License]:LICENSE.md
+[processing]:https://github.com/processing/processing
+[ruby-processing]:https://github.com/jashkenas/ruby-processing
+[netbeans]:http://learning-ruby-processing.blogspot.co.uk/2014/10/alternative-ruby-processing-implentation.html
+[processing-2.2.1]:https://processing.org/download/
+[processing-core]:https://github.com/ruby-processing/processing-core/blob/master/README.md

data/Rakefile

@@ -0,0 +1,93 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rubygems/package_task'
+require 'rdoc/task'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require_relative 'lib/jruby_art/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'jruby_art'
+  s.version = JRubyArt::VERSION
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.md', 'LICENSE.md']
+  s.summary = 'Ruby processing development branch'
+  s.description = 'A jruby wrapper for processing'
+  s.license = 'MIT'
+  s.author = 'Martin Prout'
+  s.email = 'martin_p@lineone.net'
+  s.homepage = 'https://github.com/ruby-processing/JRubyArt'
+  s.executables << 'k9'
+  s.files = %w(LICENSE.md README.md Rakefile) + Dir.glob("{bin,lib,spec,vendors}/**/*")
+  s.require_path = 'lib'
+  s.add_development_dependency "rake", "~> 10.3"
+  s.add_development_dependency "rake-compiler", "~> 0.9"
+  s.requirements << 'A decent graphics card'
+  s.requirements << 'java runtime >= 1.7+'
+  s.requirements << 'processing = 2.2.1+'
+end
+
+# -*- ruby -*-
+
+require 'java'
+require 'rake/javaextensiontask'
+
+# -*- encoding: utf-8 -*-
+require 'psych'
+
+def copy_jars(name, dest)
+  conf = '~/.jruby_art/config.yml'
+  begin
+    path = File.expand_path(conf)
+    rp_config = (Psych.load_file(path))
+    source= "#{rp_config["PROCESSING_ROOT"]}/core/library/"    
+  rescue
+    raise "WARNING: you must set PROCESSING_ROOT in #{conf} compile"
+  end
+	body = proc {
+	  Dir["#{source}/*.jar"].each do |f|
+	    puts "Copying #{f} To #{dest}"
+	    FileUtils.cp f, dest
+	  end
+	}
+	Rake::Task.define_task(name, &body)	
+end
+
+copy_jars(:processing_jars, 'lib')
+
+Rake::JavaExtensionTask.new('processing') do |ext|
+  jars = FileList['lib/*.jar']
+  ext.classpath = jars.map { |x| File.expand_path x}.join ':'
+  ext.name = 'rpextras'
+  ext.debug = true
+  ext.lib_dir = 'lib'
+  ext.source_version='1.7'
+  ext.target_version='1.7'
+end
+
+Gem::PackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.md', 'LICENSE.md', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.md" # page to start on
+  rdoc.title = "JRubyArt Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end
+
+RSpec::Core::RakeTask.new do |spec|
+  spec.pattern = 'spec/*_spec.rb'
+  spec.rspec_opts = [Dir["lib"].to_a.join(':')]
+end
+
+

data/bin/k9

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+file = __FILE__
+if test(?l, file)
+  require 'pathname'
+  file = Pathname.new(file).realpath
+end
+
+require File.expand_path(File.dirname(file) + '/../lib/jruby_art')
+Processing::Runner.execute

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/jruby_art.rb

@@ -0,0 +1,27 @@
+VERBOSE = true
+
+unless defined? K9_ROOT
+  $LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+  K9_ROOT = File.expand_path(File.dirname(__FILE__) + '/../')
+end
+
+# guard prevents issues with mri ruby when using creator
+if RUBY_PLATFORM == 'java'
+  working_directory = File.join(File.dirname(__FILE__))
+  $LOAD_PATH << working_directory unless $LOAD_PATH.include?(working_directory)
+  Dir[File.join(working_directory, '*.jar')].each do |jar|
+    require jar
+  end
+  Java::ProcessingFastmath::DeglutLibrary.new.load(JRuby.runtime, false)
+  Java::ProcessingVecmathVec2::Vec2Library.new.load(JRuby.runtime, false)
+  Java::ProcessingVecmathVec3::Vec3Library.new.load(JRuby.runtime, false)
+  AppRender = Java::ProcessingVecmath::AppRender
+  ShapeRender = Java::ProcessingVecmath::ShapeRender
+  require 'jruby_art/app'
+  require 'jruby_art/helper_methods'
+end
+
+require 'jruby_art/version'
+require 'jruby_art/helpers/numeric'
+require 'jruby_art/helpers/range'
+require 'jruby_art/runner'

data/lib/jruby_art/app.rb

@@ -0,0 +1,153 @@
+require_relative 'helper_methods'
+
+# The Processing module is a wrapper for JRubyArt
+# Author:: Martin Prout (extends / re-implements ruby-processing)
+module Processing
+  include_package 'processing.core' # imports the processing.core package.
+  include_package 'processing.event'
+  # This class is the base class the user should inherit from when making
+  # their own sketch.
+  #
+  # i.e.
+  #
+  # class MySketch < Processing::App
+  #
+  #   def draw
+  #     background rand(255)
+  #   end
+  #
+  # end
+  #
+  module Common
+    # This method provides the possibility of adding and using
+    # new runtime options in sketches no need to re-define initialize
+    #
+    def post_initialize(_opts = {})
+      nil
+    end
+
+    # This method configures the sketch title and and presentation mode.
+    #
+    def configure_sketch
+      presentation_mode
+      sketch_title
+    end
+
+    # This method sets the sketch presentation mode.
+    #
+    def presentation_mode
+      return unless opts[:fullscreen]
+      args << '--full-screen'
+      args << "--bgcolor=#{opts[:bgcolor]}" if opts[:bgcolor]
+    end
+
+    # This method is the main draw loop of the sketch. This is usually
+    # overridden by the user.
+    #
+    def draw
+      nil
+    end
+
+    # This method runs the processing sketch.
+    #
+    def run_sketch
+      PApplet.run_sketch(args.to_java(:string), self)
+    end
+
+    # This method sets the sketch title.
+    #
+    def sketch_title
+      args << opts.fetch(:title, 'Sketch')
+    end
+  end
+  # Watch the definition of these methods, to make sure
+  # that Processing is able to call them during events.
+  METHODS_TO_ALIAS = {
+    mouse_pressed: :mousePressed,
+    mouse_dragged: :mouseDragged,
+    mouse_clicked: :mouseClicked,
+    mouse_moved: :mouseMoved,
+    mouse_released: :mouseReleased,
+    key_pressed: :keyPressed,
+    key_released: :keyReleased,
+    key_typed: :keyTyped
+  }
+
+  # This class is for default (Java2D) sketches only
+  class App < PApplet
+    include Common, HelperMethods
+    Java::ProcessingVecmathArcball::ArcballLibrary.new.load(JRuby.runtime, false)
+    attr_reader :title, :args, :opts
+
+    # App should be instantiated with an optional list of opts
+    # and array of args.
+    #
+    # App.new(title: 'My Simple App', fullscreen: true)
+    #
+    def initialize(opts = {}, args = [])
+      super()
+      proxy_java_fields
+      post_initialize(opts)
+      @args = args
+      @opts = opts
+      configure_sketch
+      run_sketch
+    end
+
+    # This method provides the default setup for the sketch. It can
+    # be overridden by the user for finer grained control.
+    #
+    def setup
+      size(width, height)
+    end
+
+    # When certain special methods get added to the sketch, we need to let
+    # Processing call them by their expected Java names.
+    def self.method_added(method_name) # :nodoc:
+      # Watch the definition of these methods, to make sure
+      # that Processing is able to call them during events.
+      if METHODS_TO_ALIAS.key?(method_name)
+        alias_method METHODS_TO_ALIAS[method_name], method_name
+      end
+    end
+  end
+
+  # This class is for opengl sketches (P2D and P3D)
+  class AppGL < PApplet
+    include Processing, Common
+    include_package 'processing.opengl' # imports the processing.opengl package.
+    include HelperMethods
+    attr_reader :title, :args, :opts
+
+    # App should be instantiated with an optional list of opts
+    # and array of args.
+    #
+    # App.new(title: 'My Simple App', fullscreen: true)
+    #
+    def initialize(opts = {}, args = [])
+      super()
+      proxy_java_fields
+      post_initialize(opts)
+      @args = args
+      @opts = opts
+      configure_sketch
+      run_sketch
+    end
+
+    # This method provides the default setup for the sketch. It can
+    # be overridden by the user for finer grained control.
+    #
+    def setup
+      size(width, height, mode = P3D)
+      fail unless /opengl/ =~ mode
+    end
+
+    # When certain special methods get added to the sketch, we need to let
+    # Processing call them by their expected Java names.
+    def self.method_added(method_name) #:nodoc:
+      if METHODS_TO_ALIAS.key?(method_name)
+        alias_method METHODS_TO_ALIAS[method_name], method_name
+      end
+    end
+  end
+end