jax 0.0.0.1

data/lib/jax/generators/commands.rb

@@ -0,0 +1,81 @@
+# This script is required by script/jax if script/jax is found.
+
+require 'thor'
+require 'thor/group'
+require File.expand_path('../../jax', File.dirname(__FILE__))
+
+module Jax
+  module Generators
+    class Command < Thor::Group
+      class << self
+        def inherited(base)
+          base.base_path = File.dirname(caller.first.gsub(/:.*$/, ''))
+        end
+        
+        def base_path
+          @base_path || raise("Jax Command base path was not found")
+        end
+        
+        def base_path=(path)
+          @base_path = path
+        end
+        
+        def start(given_args=ARGV, config={})
+          if (given_args.length == 0)
+            usage = ERB.new(File.read(File.expand_path("USAGE", base_path)), nil, '-')
+            puts usage.result(binding)
+          else
+            super
+          end
+        end
+      end
+    end
+    
+    autoload :Controller, File.join(File.dirname(__FILE__), "controller/controller_generator")
+    autoload :Model,      File.join(File.dirname(__FILE__), "model/model_generator")
+    autoload :LightSource,File.join(File.dirname(__FILE__), "light_source/light_source_generator")
+    autoload :Material,   File.join(File.dirname(__FILE__), "material/material_generator")
+  end
+end
+
+class JaxGeneratorInvoker < Thor
+  def self.basename
+    "jax generate"
+  end
+
+  desc "controller", "generates a new controller"
+  def controller(*args)
+    Jax::Generators::Controller::ControllerGenerator.start(args)
+  end
+  
+  desc "model", "generates a new model"
+  def model(*args)
+    Jax::Generators::Model::ModelGenerator.start(args)
+  end
+  
+  desc "light", "generates a new light source"
+  def light(*args)
+    Jax::Generators::LightSource::LightSourceGenerator.start(args)
+  end
+  
+  desc "material", "generates a new material"
+  def material(*args)
+    args = ARGV.dup
+    2.times { args.shift }
+    Jax::Generators::Material::MaterialGenerator.start(args)
+  end
+
+  desc "scaffold", "generates a controller, model and material, all with the same name"
+  def scaffold(name)
+    Jax::Generators::Controller::ControllerGenerator.start([name, 'index'])
+    Jax::Generators::Model::ModelGenerator.start([name])
+    Jax::Generators::Material::MaterialGenerator.start([name])
+  end
+end
+
+class JaxGenerator < Thor
+  desc "generate", "generates a controller, model, light source, or material"
+  def generate(*args)
+    JaxGeneratorInvoker.start(args)
+  end
+end

data/lib/jax/generators/controller/USAGE

@@ -0,0 +1,9 @@
+Usage:
+  jax generate controller NAME [action1 action2 ... actionN]
+
+Generates a new controller, including its test file, helper file, and any
+views it may have.
+
+Optional arguments are action names. Usually, you'll want to at least specify
+'index', though this is not absolutely required.
+

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

@@ -0,0 +1,59 @@
+require 'active_support/core_ext'
+
+module Jax
+  module Generators
+    module Controller
+      class ControllerGenerator < Jax::Generators::Command
+        include Thor::Actions
+        argument :controller_name
+        attr_reader :actions, :action_name
+
+        def self.source_root
+          File.expand_path("templates", File.dirname(__FILE__))
+        end
+        
+        def initialize(args=[], options={}, config={})
+          super
+          @actions = args[1..-1].collect { |c| c.underscore }
+          @controller_name = controller_name.underscore
+        end
+        
+        def source
+          template 'controller_source.js.tt', File.join("app/controllers", "#{file_name}_controller.js")
+        end
+        
+        def helper
+          template 'helper.js.tt', File.join("app/helpers", "#{file_name}_helper.js")
+        end
+        
+        def tests
+          template 'controller_test.js.tt', File.join('spec/javascripts/controllers', "#{file_name}_controller_spec.js")
+          template 'helper_test.js.tt', File.join('spec/javascripts/helpers', "#{file_name}_helper_spec.js")
+        end
+
+        def views
+          actions.each do |action|
+            @action_name = action
+            template 'view.js.tt', File.join("app/views", file_name, "#{action}.js")
+          end
+        end
+        
+        def routes
+          actions.each do |action|
+            insert_into_file "config/routes.rb", "\n  map '#{controller_name}/#{action}'",
+                             :after => /\.routes\.map do$/
+          end
+        end
+
+        protected
+        def file_name
+          controller_name.underscore
+        end
+        
+        def class_name
+          controller_name.camelize
+        end
+      end
+    end
+  end
+end

data/lib/jax/generators/controller/templates/controller_source.js.tt

@@ -0,0 +1,16 @@
+//= require "application_controller"
+
+var <%=class_name%>Controller = (function() {
+  return Jax.Controller.create("<%=controller_name%>", ApplicationController, {
+    <%actions.each do |action|%><%=action%>: function() {
+      
+    },
+
+    <%end%>
+    // Some special actions are fired whenever the corresponding input is
+    // received from the user.
+    mouse_clicked: function(event) {
+      
+    }
+  });
+})();

data/lib/jax/generators/controller/templates/controller_test.js.tt

@@ -0,0 +1,11 @@
+describe("<%=class_name%>Controller", function() {
+  var controller;
+
+  beforeEach(function() {
+    controller = new <%=class_name%>Controller();
+  });
+
+  it("does something", function() {
+    expect(1).toEqual(1);
+  });
+});

data/lib/jax/generators/controller/templates/helper.js.tt

@@ -0,0 +1,3 @@
+var <%=class_name%>Helper = Jax.Helper.create({
+
+});

data/lib/jax/generators/controller/templates/helper_test.js.tt

@@ -0,0 +1,12 @@
+describe("<%=class_name%>Helper", function() {
+  var helper;
+
+  beforeEach(function() {
+    var klass = Jax.Class.create({helpers: function() { return [<%=class_name%>Helper]; } });
+    helper = new klass();
+  });
+
+  it("does something", function() {
+    expect(1).toEqual(1);
+  });
+});

data/lib/jax/generators/controller/templates/view.js.tt

@@ -0,0 +1,4 @@
+Jax.views.push('<%=file_name%>/<%=action_name%>', function() {
+  this.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  this.world.render();
+});

data/lib/jax/generators/light_source/USAGE

@@ -0,0 +1,14 @@
+Usage:
+  jax generate light NAME [directional|point|spot]
+
+Generates a new light source with the specified type, which defaults to 'point'.
+
+  - Directional: light shines the same direction for all objects
+    Ex: sunlight
+    
+  - Point: light shines in all directions from a specific position
+    Ex: candle
+    
+  - Spot: light projects in a cone shape from position in a specific direction
+    Ex: flashlight
+

data/lib/jax/generators/light_source/light_source_generator.rb

@@ -0,0 +1,47 @@
+require 'active_support/core_ext'
+
+module Jax
+  module Generators
+    module LightSource
+      class LightSourceGenerator < Jax::Generators::Command
+        include Thor::Actions
+        argument :name, :desc => "The name of this light source", :banner => "[name]"
+        argument :type, :default => "point", :desc => "The light type: one of 'point', 'spot', 'directional'",
+                :banner => "[point|spot|directional]"
+        
+        def self.source_root
+          File.expand_path("templates", File.dirname(__FILE__))
+        end
+                
+        def light
+          template 'light.yml.tt', File.join("app/resources/light_sources", "#{file_name}.yml")
+        end
+        
+        protected
+        def jax_light_type
+          type = self.type.strip.upcase
+          case type
+            when 'POINT', 'SPOT', 'DIRECTIONAL' then return type+"_LIGHT"
+            else raise ArgumentError, "Unexpected light type: "+type
+          end
+        end
+        
+        def banner
+          "jax generate light #{self.arguments.map { |a| a.usage }.join(' ')}"
+        end
+
+        def file_name
+          name.underscore
+        end
+        
+        def class_name
+          name.camelize
+        end
+        
+        def plural_name
+          name.pluralize
+        end
+      end
+    end
+  end
+end

data/lib/jax/generators/light_source/templates/light.yml.tt

@@ -0,0 +1,39 @@
+shadowcaster: true
+
+enabled: true
+<%if jax_light_type != 'DIRECTIONAL_LIGHT'%>
+position:
+  x: -20
+  y: 0
+  z: 0
+<%end%><%if jax_light_type != 'POINT_LIGHT'%>
+direction:
+  x: 1
+  y: 0
+  z: 0
+<%end%>
+type: <%=jax_light_type%>
+
+attenuation:
+  constant: 0
+  linear: 1.0
+  quadratic: 0
+
+color:
+  ambient:
+    red: 0.2
+    green: 0.2
+    blue: 0.2
+    alpha: 1
+
+  diffuse:
+    red: 0.5
+    green: 0.5
+    blue: 0.5
+    alpha: 1.0
+
+  specular:
+    red: 0.2
+    green: 0.2
+    blue: 0.2
+    alpha: 1.0

data/lib/jax/generators/material/USAGE

@@ -0,0 +1,29 @@
+Usage:
+  jax generate material NAME [list of shaders]
+
+Generates a new material. If no arguments other than NAME are given, then the
+material will support only lighting and color. More advanced capabilities like
+texturing, normal mapping, shadow map support, and so forth must be specified
+directly. There is no hard limit to the number of shaders you can use for a
+material, but keep in mind that the actual supported complexity of the
+material depends heavily on the end user's graphics card. In addition to the
+obvious performance implications of using complicated materials, some shaders
+may flat-out not compile if, for instance, the length of the source code
+exceeds the capabilities of the graphics processor.
+
+Processors supported by your application:
+
+<%supported_shaders.each do |shader| -%>
+  - <%=shader.name.ljust(20)%> : <%=shader.description.gsub(/\n/, "\n"+" "*25)%>
+<%end -%>
+
+You can specify a shader more than once. For instance, you can create a
+material that uses three textures and two normal maps:
+
+  jax generate material NAME texture texture texture normal_map normal_map
+
+You can also pass the --append option to update an existing material rather
+than generate an all-new one:
+
+  jax generate material NAME --append texture
+

data/lib/jax/generators/material/material_generator.rb

@@ -0,0 +1,81 @@
+require 'active_support/core_ext'
+
+module Jax
+  module Generators
+    module Material
+      class MaterialGenerator < Jax::Generators::Command
+        include Thor::Actions
+        argument :name, :desc => "The name of this material", :banner => "[name]"
+        class_option :append, :default => false, :type => :boolean
+        
+        def initialize(args = [], *other)
+          chain.unshift args.pop while args.length > 1 # name is arg0
+          super(args, *other)
+        end
+        
+        def self.source_root
+          File.expand_path("templates", File.dirname(__FILE__))
+        end
+             
+        def material
+          filename = File.join("app/resources/materials", "#{file_name}.yml")
+          
+          if options[:append]
+            tmp = "tmp/amendment.#{file_name}.yml"
+            template 'append.yml.tt', tmp, :verbose => false
+            
+            if File.file?(filename)
+              say_status :append, filename, :green
+            else
+              say_status :missing, filename, :red
+              return
+            end
+            
+            File.open(filename, "a+") { |f| f.puts File.read(tmp) }
+            
+            # doesn't append if the end of the file matches string identically - usually useful, but in this case troublesome.
+            # append_to_file File.join("app/resources/materials", "#{file_name}.yml"), File.read("tmp/amendment.#{file_name}.yml")
+            
+            remove_file tmp, :verbose => false
+          else
+            template 'material.yml.tt', filename
+          end
+        end
+        
+        protected
+        def chain
+          @chain ||= []
+        end
+        
+        class << self
+          def supported_shaders
+            Jax.application.shaders.select do |shader|
+              shader.manifest && !shader.manifest.empty?
+            end
+          end
+        end
+        
+        def shader(name)
+          name = name.strip
+          Jax.application.shaders.find(name) || raise(ArgumentError, "Shader not found: '"+name+"'")
+        end
+        
+        def banner
+          "jax generate light #{self.arguments.map { |a| a.usage }.join(' ')}"
+        end
+
+        def file_name
+          name.underscore
+        end
+        
+        def class_name
+          name.camelize
+        end
+        
+        def plural_name
+          name.pluralize
+        end
+      end
+    end
+  end
+end

data/lib/jax/generators/material/templates/append.yml.tt

@@ -0,0 +1,7 @@
+
+<%if !chain.empty? -%>
+  <%- chain.each do |n| -%>
+  - type: <%=shader(n).name.camelize%>
+    <%=shader(n).default_options.to_yaml.lines.to_a[1..-1].join("    ")%>
+  <%- end -%>
+<%end-%>

data/lib/jax/generators/material/templates/material.yml.tt

@@ -0,0 +1,33 @@
+# ambient component multiplied with the light source's ambient component
+ambient:
+  red:   1.0
+  green: 1.0
+  blue:  1.0
+  alpha: 1.0
+
+# diffuse component multiplied with the light source's diffuse component
+diffuse:
+  red:   1.0
+  green: 1.0
+  blue:  1.0
+  alpha: 1.0
+
+# specular component multiplied with the light source's specular component
+specular:
+  red:   1.0
+  green: 1.0
+  blue:  1.0
+  alpha: 1.0
+
+shininess: 30
+
+layers:
+  # remove Lighting to conserve video memory if you don't need/want support for light sources
+  - type: Lighting
+
+<%if !chain.empty? -%>
+  <%- chain.each do |n| -%>
+  - type: <%=shader(n).name.camelize%>
+    <%=shader(n).default_options.to_yaml.lines.to_a[1..-1].join("    ")%>
+  <%- end -%>
+<%end-%>