jax 1.1.1 → 2.0.0

data/{builtin/app → lib/assets/javascripts}/shaders/picking/material.js

@@ -3,12 +3,10 @@ Jax.Material.Picking = Jax.Class.create(Jax.Material, {
     $super({shader:"picking"});
   },
   
-  setUniforms: function($super, context, mesh, options, uniforms) {
-    $super(context, mesh, options, uniforms);
-
+  setVariables: function(context, mesh, options, vars) {
     model_index = options.model_index;
     if (model_index == undefined) model_index = -1;
 
-    uniforms.set('INDEX', model_index);
+    vars.set('INDEX', model_index);
   }
 });

data/{builtin/app/shaders/shadow_map/common.ejs → lib/assets/javascripts/shaders/shadow_map/common.glsl}

@@ -1,3 +1,5 @@
+//= require "shaders/functions/lights"
+
 shared uniform mat4 mMatrix;
 
 uniform bool SHADOWMAP_ENABLED;
@@ -11,4 +13,3 @@ varying vec4 vShadowCoord;
 varying vec4 vDP0, vDP1;
 //varying float vDPz, vDPDepth;
 
-//= require "functions/lights"

data/{builtin/app/shaders/shadow_map/fragment.ejs → lib/assets/javascripts/shaders/shadow_map/fragment.glsl}

@@ -1,4 +1,4 @@
-//= require "functions/depth_map"
+//= require "shaders/functions/depth_map"
 
 float dp_lookup() {
   float map_depth, depth;

data/{builtin/app → lib/assets/javascripts}/shaders/shadow_map/material.js

@@ -3,10 +3,8 @@ Jax.Material.ShadowMap = Jax.Class.create(Jax.Material, {
     $super({shader:"shadow_map"});
   },
   
-  setUniforms: function($super, context, mesh, options, uniforms) {
-    $super(context, mesh, options, uniforms);
-    
-    uniforms.set({
+  setVariables: function(context, mesh, options, vars) {
+    vars.set({
       DP_SHADOW_NEAR: 0.1, //c.world.lighting.getLight().getDPShadowNear() || 0.1;}},
       DP_SHADOW_FAR: 500,//c.world.lighting.getLight().getDPShadowFar() || 500;}},
           
@@ -20,7 +18,7 @@ Jax.Material.ShadowMap = Jax.Class.create(Jax.Material, {
     front = light.getShadowMapTextures(context)[0];
     back  = light.getShadowMapTextures(context)[1];
     
-    if (front) uniforms.texture('SHADOWMAP0', front, context);
-    if (back)  uniforms.texture('SHADOWMAP1', back,  context);
+    if (front) vars.texture('SHADOWMAP0', front, context);
+    if (back)  vars.texture('SHADOWMAP1', back,  context);
   }
 });

data/lib/assets/javascripts/shaders/texture/material.js

@@ -0,0 +1,17 @@
+Jax.Material.Texture = Jax.Class.create(Jax.Material, {
+  initialize: function($super, texture) {
+    this.texture = Jax.Material.Texture.normalizeTexture(texture);
+    $super({shader:"texture"});
+  },
+  
+  setVariables: function(context, mesh, options, vars) {
+    vars.texture('Texture', this.texture, context);
+    vars.set('TextureScaleX', this.texture.options.scale_x || this.texture.options.scale || 1);
+    vars.set('TextureScaleY', this.texture.options.scale_y || this.texture.options.scale || 1);
+  }
+});
+
+Jax.Material.Texture.normalizeTexture = function(tex) {
+  if (tex.isKindOf && tex.isKindOf(Jax.Texture)) return tex;
+  return new Jax.Texture(tex); 
+};

data/lib/generators/jax/all.rb

@@ -0,0 +1,16 @@
+# this is required to make the specs pass on Ruby 1.8. No idea why!!!
+module Jax
+  module Generators
+  end
+end
+
+require 'active_support/core_ext'
+require 'rails/generators'
+require File.expand_path("base/source_root",      File.dirname(__FILE__))
+require File.expand_path("base/coffee_generator", File.dirname(__FILE__))
+require File.expand_path("base/named_base",       File.dirname(__FILE__))
+require File.expand_path("base/rails_base",       File.dirname(__FILE__))
+require File.expand_path("base/plugin_base",      File.dirname(__FILE__))
+require File.expand_path("base/actions",          File.dirname(__FILE__))
+
+Dir[File.expand_path("*/*.rb", File.dirname(__FILE__))].each { |generator| require generator }

data/lib/generators/jax/application/application_generator.rb

@@ -0,0 +1,48 @@
+require 'jax/version'
+require File.expand_path("../all", File.dirname(__FILE__))
+
+module Jax
+  module Generators
+    class ApplicationGenerator < Jax::Generators::NamedBase
+      class_option :skip_bundle, :type => :boolean, :default => false, :desc => "Don't run bundle install"
+      
+      def generate_application
+        directory "app", file_name
+      end
+      
+      def create_jax_application_controller
+        coffee_template_with_fallback "application_controller.js",
+          File.join(file_name, 'app/assets/jax/controllers/application_controller.js')
+      end
+
+      def create_jax_application_helper
+        coffee_template_with_fallback "application_helper.js",
+          File.join(file_name, 'app/assets/jax/helpers/application_helper.js')
+      end
+      
+      def run_bundle
+        inside file_name do
+          bundle_command('install') unless options[:skip_bundle]
+        end
+      end
+
+      protected
+      # this comes from Rails.
+      def bundle_command(command)
+        say_status :run, "bundle #{command}"
+
+        # We are going to shell out rather than invoking Bundler::CLI.new(command)
+        # because `rails new` loads the Thor gem and on the other hand bundler uses
+        # its own vendored Thor, which could be a different version. Running both
+        # things in the same process is a recipe for a night with paracetamol.
+        #
+        # We use backticks and #print here instead of vanilla #system because it
+        # is easier to silence stdout in the existing test suite this way. The
+        # end-user gets the bundler commands called anyway, so no big deal.
+        #
+        # Thanks to James Tucker for the Gem tricks involved in this call.
+        print `"#{Gem.ruby}" -rubygems "#{Gem.bin_path('bundler', 'bundle')}" #{command}`
+      end
+    end
+  end
+end

data/lib/generators/jax/base/actions.rb

@@ -0,0 +1,52 @@
+module Jax::Generators::Actions
+  def prompt_yn(message, options = {})
+    yn = ask(message).downcase[0]
+    throw :aborted, "Aborted by user." if yn != ?y
+  end
+  
+  def menu(items, options = {})
+    min = 1
+    if options[:allow_all]
+      say_option 0, "All candidates"
+      min = 0
+    end
+    
+    items.each_with_index do |item, index|
+      say_option index+1, item
+    end
+    which = menu_choice(:min => min, :max => items.length)
+                    
+    if which == -1
+      items.each_with_index { |item, index| yield item, index }
+    else
+      yield items[which], which
+    end
+  end
+  
+  def menu_choice(*args)
+    options = args.extract_options!
+    caption, addl_caption = *args
+    caption = "Please select an option, or press ctrl+c to cancel >" unless caption
+    
+    which = ask("#{addl_caption}#{caption}")
+    sel = which.to_i
+    # if sel.to_s != which then which is non-numeric
+    if sel.to_s != which || options[:min] && sel < options[:min] || options[:max] && sel > options[:max]
+      menu_choice(caption, "Invalid choice. ")
+    else
+      sel - 1
+    end
+  end
+  
+  def say_option(which, caption)
+    say "\t#{which}\t: #{caption}"
+  end
+  
+  def overwrite(path)
+    path = path.to_s
+    if File.exist? path
+      prompt_yn "Path '#{path}' already exists! Delete it?"
+      FileUtils.rm_rf path
+    end
+  end
+end

data/lib/generators/jax/base/coffee_generator.rb

@@ -0,0 +1,30 @@
+module Jax
+  module Generators
+    module CoffeeGenerator
+      unless defined?(COFFEESCRIPT_AVAILABLE)
+        begin
+          require 'coffee-script'
+          COFFEESCRIPT_AVAILABLE = true
+        rescue LoadError
+          COFFEESCRIPT_AVAILABLE = false
+        end
+      end
+
+      def self.included(base)
+        base.class_eval do
+          class_option :without_coffeescript, :type => :boolean, :aliases => "-j", :default => false,
+                       :desc => "Indicates whether to generate pure JavaScript instead of CoffeeScript"
+        end
+      end
+
+      protected
+      def coffee_template_with_fallback(src, dest)
+        if COFFEESCRIPT_AVAILABLE && !options['without_coffeescript']
+          template "#{src}.coffee.erb", "#{dest}.coffee"
+        else
+          template "#{src}.erb", dest
+        end
+      end
+    end
+  end
+end

data/lib/generators/jax/base/named_base.rb

@@ -0,0 +1,17 @@
+module Jax
+  module Generators
+    class NamedBase < ::Rails::Generators::NamedBase
+      class Error < Thor::Error
+      end
+
+      no_tasks do
+        def exit(message = "")
+          raise Jax::Generators::NamedBase::Error, message
+        end
+      end
+
+      extend  Jax::Generators::SourceRoot
+      include Jax::Generators::CoffeeGenerator
+    end
+  end
+end

data/lib/generators/jax/base/plugin_base.rb

@@ -0,0 +1,108 @@
+require File.expand_path("plugin_manifest", File.dirname(__FILE__))
+require File.expand_path("plugin_credentials", File.dirname(__FILE__))
+
+module Jax::Generators::PluginBase
+  class ResponseError < StandardError
+    def initialize(message)
+      super("#{message} Make sure your firewall isn't injecting invalid responses.")
+    end
+  end
+  
+  def rest_resource(name, accept = :xml)
+    url = Jax.config.plugin_repository_url
+    url.concat "/" unless url =~ /\/$/
+    url.concat name
+    RestClient::Resource.new(url, :accept => accept)
+  end
+  
+  def search_query_rx(query)
+    /^#{Regexp::escape query}/i
+  end
+  
+  def search(plugin_list, query)
+    plugin_list.select { |plugin, path_to_plugin|
+      !query || plugin =~ search_query_rx(query)
+    }.inject({}) do |hash, (plugin, path_to_plugin)|
+      hash[plugin] = path_to_plugin
+      hash
+    end
+  end
+  
+  def installed_plugins
+    plugins = []
+    Dir.glob(::Rails.application.root.join("vendor/plugins/*").to_s).each do |path|
+      if File.directory? path
+        plugins.push [File.basename(path), Pathname.new(path)]
+      end
+    end
+    plugins.sort { |a, b| a[0] <=> b[0] }
+  end
+  
+  def load_or_infer_manifest(name, plugin_dir)
+    if File.file?(manifest_path = File.join(plugin_dir, "manifest.yml"))
+      YAML::load(File.read(manifest_path)) || { 'name' => name, 'description' => '(Description unavailable)' }
+    else
+      { 'name' => name, 'description' => '(Manifest file not found!)' }
+    end
+  end
+  
+  def installed_plugin_manifests(filter_name = nil)
+    { 'jax_plugins' => search(installed_plugins, filter_name).collect do |name, path|
+        load_or_infer_manifest(name, path)
+      end
+    }
+  end
+  
+  def matching_plugins(name = nil)
+    if options[:local]
+      hash = installed_plugin_manifests(name)
+    else
+      hash = get_remote_plugins_matching name
+    end
+    
+    find_plugin_list(hash)
+  end
+  
+  def find_plugin_list(hash_containing_plugin_list)
+    hash_containing_plugin_list['jax_plugins'] ||
+    hash_containing_plugin_list['nil_classes'] ||
+    raise(ResponseError.new("Fatal: couldn't find plugin list."))
+  end
+  
+  def get_remote_plugins_matching(name = nil)
+    plugins = rest_resource("plugins")
+    if name
+      extract_hash_from_response plugins['search'][name].get
+    else
+      extract_hash_from_response plugins.get
+    end
+  end
+  
+  def each_plugin(name = nil, &block)
+    matching_plugins(name).each &block
+  end
+  
+  def plugin_version(details)
+    if options['version']
+      for release in details['releases']
+        if release['version'] && release['version'] == options['version']
+          return options['version']
+        end
+      end
+      raise "Release information for version #{options['version']} not found for plugin '#{details['name']}'!"
+    else
+      if release = details['releases'].last and release['version']
+        return release['version']
+      end
+      raise "Release information not found for plugin '#{details['name']}'!"
+    end
+  end
+  
+  def extract_hash_from_response(response)
+    begin
+      hash = Hash.from_xml(response)
+    rescue
+      raise ResponseError.new("Fatal: response couldn't be parsed. (Maybe it wasn't valid XML?)")
+    end
+  end
+end

data/lib/generators/jax/base/plugin_credentials.rb

@@ -0,0 +1,99 @@
+require 'rest_client'
+
+module Jax::Plugin
+  class Credentials
+    attr_reader :home, :shell
+  
+    def api_key
+      @api_key ||= find_api_key
+    end
+  
+    def initialize(options = {})
+      @shell = options[:shell] || Thor::Shell::Basic.new
+      @home = home_path(options)
+    end
+  
+    def config_file
+      File.join(home, ".jax")
+    end
+  
+    def home_path(options = {})
+      File.expand_path(options[:home] || Thor::Util.user_home)
+    end
+  
+    def plugins
+      @plugins ||= RestClient::Resource.new(File.join(Jax.config.plugin_repository_url, "plugins"), :accept => :xml)
+    end
+
+    def authors
+      @authors ||= RestClient::Resource.new(File.join(Jax.config.plugin_repository_url, "authors"), :accept => :xml)
+    end
+  
+    def profile
+      @profile ||= RestClient::Resource.new(File.join(Jax.config.plugin_repository_url, "profile"), :accept => :xml)
+    end
+  
+    private
+    def login
+      profile.options[:user] = email
+      profile.options[:password] = password
+    
+      begin
+        Hash.from_xml(profile.get).with_indifferent_access
+      rescue RestClient::RequestFailed => err # login doesn't exist
+        message = Hash.from_xml($!.http_body)
+        if message && (message = message['hash']) && (message = message['error']) && (message =~ /Login not found/i)
+          create_account
+        else
+          raise err
+        end
+      rescue RestClient::Unauthorized # bad password
+        raise "Invalid password."
+      end
+    end
+  
+    def email
+      @email ||= begin
+        shell.ask "Please enter your email address: "
+      end
+    end
+  
+    def password
+      @password ||= begin
+        shell.ask "Please enter your password: "
+      end
+    end
+  
+    def create_account
+      confirmation = shell.ask "Please confirm your password: "
+      raise "Password and confirmation don't match" if confirmation != password
+    
+      login = email && email[/\@/] ? email[0...$~.offset(0)[0]] : email
+      Hash.from_xml(profile.post(:author => {
+        :login => login, :password => password, :password_confirmation => confirmation, :email => email
+      })).with_indifferent_access
+    rescue RestClient::RequestFailed
+      raise Hash.from_xml($!.http_body)['hash']['error']
+    end
+    
+    def save_api_key
+      key = login[:author][:single_access_token]
+      yml = { :api_key => key }
+      File.open(config_file, "w") { |f| f.print yml.to_yaml }
+      key
+    end
+  
+    def find_api_key
+      if File.file?(config_file)
+        yml = (YAML::load(File.read(config_file)) || {}).with_indifferent_access
+        if yml[:api_key]
+          yml[:api_key]
+        else
+          save_api_key
+        end
+      else
+        save_api_key
+      end
+    end
+  end
+end

data/lib/generators/jax/base/plugin_manifest.rb

@@ -0,0 +1,75 @@
+require 'active_support/hash_with_indifferent_access'
+
+module Jax::Plugin
+  class Manifest < ActiveSupport::HashWithIndifferentAccess
+    class << self
+      def find(name)
+        man = new name
+        man.load
+      end
+    end
+
+    def initialize(plugin_name = "")
+      super()
+      self[:name] = plugin_name
+      defaults
+    end
+
+    def name
+      self[:name]
+    end
+
+    def name=(n)
+      self[:name] = n
+    end
+
+    def version
+      self[:version]
+    end
+
+    def version=(n)
+      self[:version] = n
+    end
+
+    def description
+      self[:description]
+    end
+
+    def description=(n)
+      self[:description] = n
+    end
+
+    def load
+      load_from path
+    end
+
+    def load_from(path)
+      yml = YAML::load(File.read(path))
+      yml.each do |key, value|
+        self[key] = value
+      end
+      self
+    end
+
+    def save
+      save_to path
+    end
+
+    def save_to(path)
+      base = File.dirname(path)
+      FileUtils.mkdir_p(base) unless File.directory?(base)
+      File.open(path, "w") { |f| f.print to_yaml }
+      self
+    end
+
+    def path
+      File.join(::Rails.application.root, "vendor/plugins", name, "manifest.yml")
+    end
+
+    def defaults
+      self[:description] ||= ""
+      self[:version] ||= "0.0.1"
+      self
+    end
+  end
+end

data/lib/generators/jax/base/rails_base.rb

@@ -0,0 +1,30 @@
+module Jax
+  module Generators
+    class RailsBase < Jax::Generators::NamedBase
+      no_tasks do
+        class_attribute :rails_equivalent_block
+      end
+      
+      def self.rails_equivalent(&block)
+        self.rails_equivalent_block = block
+      end
+      
+      class_option :rails, :type => :boolean, :aliases => '-r', :default => false,
+                   :desc => "If true, the equivalent Rails generator will be invoked also."
+    
+      def initialize(args = [], options = {}, config = {})
+        super
+        if self.options[:rails] && equiv = rails_equivalent
+          args << "--skip-namespace" # otherwise everything ends up in jax/, the opposite of what we want
+          ::Rails::Generators.invoke(equiv, args, config)
+        end
+      end
+
+      protected
+      def rails_equivalent
+        self.class.rails_equivalent_block && instance_eval(&self.class.rails_equivalent_block)
+      end
+    end
+  end
+end
+

data/lib/generators/jax/base/source_root.rb

@@ -0,0 +1,5 @@
+module Jax::Generators::SourceRoot
+  def source_root
+    @source_root ||= File.expand_path("../../../../templates", File.dirname(__FILE__))
+  end
+end

data/lib/generators/jax/controller/controller_generator.rb

@@ -0,0 +1,37 @@
+require File.expand_path("../all", File.dirname(__FILE__))
+
+module Jax
+  module Generators
+    class ControllerGenerator < Jax::Generators::RailsBase
+      argument :actions, :type => :array, :default => [], :banner => "action action"
+      class_option :without_index, :type => :boolean, :default => false,
+                   :desc => "skip the default 'index' action unless explicitly specified"
+      rails_equivalent { "controller" }
+      
+      def add_index_action
+        actions.unshift 'index' unless actions.include?('index') or options[:without_index]
+      end
+      
+      def create_controller_file
+        coffee_template_with_fallback "controller.js",
+          File.join('app/assets/jax/controllers', "#{file_name}_controller.js")
+      end
+      
+      def create_spec_file
+        coffee_template_with_fallback "controller_spec.js",
+          File.join('spec/javascripts/jax/controllers', "#{file_name}_controller_spec.js")
+      end
+      
+      def create_view_file
+        for action in actions
+          @action_name = action
+          coffee_template_with_fallback "view.js",
+            File.join('app/assets/jax/views', file_name, "#{action}.js")
+        end
+      end
+      
+      private
+      attr_reader :action_name
+    end
+  end
+end

data/lib/generators/jax/helper/helper_generator.rb

@@ -0,0 +1,30 @@
+require File.expand_path("../all", File.dirname(__FILE__))
+
+module Jax
+  module Generators
+    class HelperGenerator < Jax::Generators::NamedBase
+      def create_helper
+        coffee_template_with_fallback "helper.js",
+          File.join('app/assets/jax/helpers', "#{underscored_helper_name}.js")
+      end
+
+      def create_spec
+        coffee_template_with_fallback "helper_spec.js",
+          File.join('spec/javascripts/jax/helpers', "#{underscored_helper_name}_spec.js")
+      end
+      
+      protected
+      def underscored_helper_name
+        if file_name =~ /_helper$/
+          file_name
+        else
+          "#{file_name}_helper"
+        end
+      end
+
+      def camelized_helper_name
+        underscored_helper_name.camelize
+      end
+    end
+  end
+end