jax 0.0.0.1

data/.gitignore

@@ -0,0 +1,12 @@
+*.gem
+.bundle
+Gemfile.lock
+**/*/pkg/*
+.idea
+dist
+doc
+.*.pdoc.yaml
+.hg
+tmp/
+guides/output
+/pkg/

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/pdoc"]
+	path = vendor/pdoc
+	url = git://github.com/tobie/pdoc.git

data/.rvmrc

@@ -0,0 +1,7 @@
+rvm use --create --install 1.9.2@webgl 2>&1
+
+# Bundle is available, non-custom config.
+if command -v bundle >/dev/null && ! [ -e .bundle ] ; then
+  bundle install
+  mkdir .bundle
+fi

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in jax.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,32 @@
+== Important
+
+JAX is a working title and is subject to change. Also, it is under heavy development and is largely incomplete.
+Keep in mind that this README represents how JAX is _meant_ to work upon completion, not necessarily how it would
+work if you were to clone the git repository right now.
+
+<b>I reserve the right to commit broken code until version 0.0.1 is officially released.</b>
+
+== JAX
+
+JAX is a framework for developing rich WebGL-enabled applications using JavaScript and Ruby.
+
+== Requirements
+
+It requires ruby, which you can download at: http://www.ruby-lang.org
+
+Other than that, JAX requires a few ruby gems which will be retrieved automatically when installing.
+
+== Getting Started
+
+If you're unfamiliar with Jax, a good place to start would be at the {Jax Wiki}[http://github.com/sinisterchipmunk/jax/wiki]
+where you can find tutorials, documentation, and tips.
+
+<b>Please be aware that, like Jax itself, the Wiki is a work in progress and will be updated periodically to reflect the
+latest code changes.</b>
+
+== The Demo App
+
+This project includes an {example application}[https://github.com/sinisterchipmunk/jax/tree/master/spec/example_app],
+which is meant to represent a very basic Jax application. It provides a visual testbed for various aspects of Jax
+while simultaneously demonstrating key concepts such as event processing and resource management.
+

data/Rakefile

@@ -0,0 +1,144 @@
+# used to flag auto-compile. Just makes my life easier.
+$JAX_DEVELOPMENT = true
+$JAX_RAKE = true
+
+begin
+  require 'bundler'
+  Bundler::GemHelper.install_tasks
+rescue LoadError
+  puts " *** You don't seem to have Bundler installed. ***"
+  puts "     Please run the following command:"
+  puts
+  puts "       gem install bundler --version=1.0.10"
+  exit
+end
+
+DEPENDENCIES = %w(jasmine sprockets treetop bluecloth)
+DEPENDENCIES.each do |dep|
+  begin
+    require dep
+  rescue LoadError
+    system("bundle", "install")
+    exec("bundle", "exec", "rake", *ARGV)
+  end
+end
+
+# pdoc is a different beast because the released gem seems to be quite dated,
+# and is incompatible with Ruby 1.9.2. We'll grab the latest from git, instead.
+begin
+  require File.join(File.dirname(__FILE__), 'vendor/pdoc/lib/pdoc')
+rescue LoadError
+  puts "You don't seem to have pdoc. Fetching..."
+  if !system("git", "submodule", "init") || !system("git", "submodule", "update")
+    puts "Couldn't fetch pdoc. Make sure you have git installed."
+    exit
+  end
+  require File.join(File.dirname(__FILE__), 'vendor/pdoc/lib/pdoc')
+end
+
+load 'jasmine/tasks/jasmine.rake'
+require File.expand_path("lib/jax/monkeypatch/jasmine", File.dirname(__FILE__))
+
+require File.join(File.dirname(__FILE__), "lib/jax")
+JAX_ROOT = File.dirname(__FILE__)
+# put a dummy Application in place
+class Development < Jax::Application
+end
+
+
+desc "compile Jax"
+task :compile do
+  secretary = Sprockets::Secretary.new(
+          :root => File.dirname(__FILE__),
+          :asset_root => "public",
+          :load_path => ["src"],
+          :source_files => ["src/jax.js", "builtin/**/*.js"]
+  )
+  rm_rf "dist"
+  mkdir_p "dist"
+  secretary.concatenation.save_to "dist/jax.js"
+
+  # generate the built-in shaders for testing against (these are not added to the real jax dist because they are
+  # regenerated in the user's app)
+  rm File.join(File.dirname(__FILE__), "tmp/shaders.js")
+  File.open(File.join(File.dirname(__FILE__), "tmp/shaders.js"), "w") do |f|
+    Jax.application.shaders.each { |shader| shader.save_to f }
+  end
+
+  puts "generated #{File.expand_path "dist/jax.js", '.'}"
+  cp File.join(File.dirname(__FILE__), "dist/jax.js"), 
+     File.join(File.dirname(__FILE__), "lib/jax/generators/app/templates/public/javascripts/jax.js")
+  
+  puts "(project built)"
+end
+
+desc "compile and minify Jax into dist/jax.js and dist/jax-min.js"
+task :minify => :compile do
+  puts "(minifying...)"
+  if system("java", "-jar", File.join(File.dirname(__FILE__), "vendor/yuicompressor-2.4.2.jar"), "dist/jax.js", "-o", "dist/jax-min.js")
+    puts "(done.)"
+  else
+    puts "(Error while minifying!)"
+  end
+end
+
+namespace :doc do
+  desc "build the Jax JavaScript documentation"
+  task :js do
+    FileUtils.rm_rf 'doc'
+    
+    PDoc.run({
+      :source_files => [File.join('src', 'jax.js')] + Dir[File.join('src', 'jax', '**', '*.js')],
+      :destination  => "doc",
+#      :index_page   => 'src/README.markdown',
+      :syntax_highlighter => 'coderay',
+      :markdown_parser    => :bluecloth,
+      :src_code_text => "View source on GitHub &rarr;",
+      :src_code_href => proc { |obj|
+        "https://github.com/sinisterchipmunk/jax/tree/master/#{obj.file}#L#{obj.line_number}"
+      },
+      :pretty_urls => false,
+      :bust_cache  => false,
+      :name => 'Jax WebGL Framework',
+      :short_name => 'Jax',
+      :home_url => 'http://jaxgl.com',
+      :version => Jax::VERSION,
+#      :index_header => "",
+#      :footer => '',
+#      :assets => 'doc_assets'
+    })
+
+    Dir['src/**/.*.pdoc.yaml'].each { |f| FileUtils.rm f }
+  end
+end
+
+namespace :guides do
+  desc 'Generate guides (for authors), use ONLY=foo to process just "foo.textile"'
+  task :generate do
+    rm_rf "guides/output"
+    ENV["WARN_BROKEN_LINKS"] = "1" # authors can't disable this
+    ruby "guides/jax_guides.rb"
+  end
+
+  desc 'Validate guides, use ONLY=foo to process just "foo.html"'
+  task :validate do
+    ruby "guides/w3c_validator.rb"
+  end
+  
+  desc "Publish the guides"
+  task :publish => 'guides:generate' do
+    require 'rake/contrib/sshpublisher'
+    mkdir_p 'pkg'
+    `tar -czf pkg/guides.gz guides/output`
+    Rake::SshFilePublisher.new("jaxgl.com", "~/guides/public", "pkg", "guides.gz").upload
+    `ssh jaxgl.com 'cd ~/guides/public/ && tar -xvzf guides.gz && mv guides/output/* . && rm -rf guides*'`
+  end
+end
+
+# 'Guides' tasks & code borrowed from Railties.
+desc 'Generate guides (for authors), use ONLY=foo to process just "foo.textile"'
+task :guides => 'guides:generate'
+
+task :jasmine => :compile
+task :build   => :compile
+task :default => :compile

data/bin/jax

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require "thor"
+require "thor/group"
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "../lib/jax/generators/script_jax_loader")
+
+Jax::Generators::ScriptJaxLoader.exec_script_jax! # this uses exec so, if found, the rest of this file won't load
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "../lib/jax/generators/app")
+JaxGenerator.start

data/builtin/shaders/basic/common.ejs

@@ -0,0 +1,11 @@
+shared uniform mat4 ivMatrix, mvMatrix, pMatrix, vMatrix;
+shared uniform mat3 vnMatrix, nMatrix;
+
+shared uniform vec4 materialDiffuse, materialAmbient, materialSpecular;
+shared uniform float materialShininess;
+
+shared uniform int PASS_TYPE;
+
+shared varying vec2 vTexCoords;
+shared varying vec3 vNormal, vSurfacePos;
+shared varying vec4 vBaseColor;

data/builtin/shaders/basic/fragment.ejs

@@ -0,0 +1,5 @@
+void main(inout vec4 ambient, inout vec4 diffuse, inout vec4 specular) {
+  ambient = materialAmbient * vBaseColor;
+  diffuse = materialDiffuse * vBaseColor;
+  specular = materialSpecular * vBaseColor;
+}

data/builtin/shaders/basic/vertex.ejs

@@ -0,0 +1,13 @@
+shared attribute vec2 VERTEX_TEXCOORDS;
+shared attribute vec3 VERTEX_NORMAL;
+shared attribute vec4 VERTEX_POSITION, VERTEX_COLOR, VERTEX_TANGENT;
+
+void main(void) {
+  vBaseColor = VERTEX_COLOR;
+  vNormal = nMatrix * VERTEX_NORMAL;
+  vTexCoords = VERTEX_TEXCOORDS;
+                          
+  vSurfacePos = (mvMatrix * VERTEX_POSITION).xyz;
+
+  gl_Position = pMatrix * mvMatrix * VERTEX_POSITION;
+}

data/builtin/shaders/depthmap/common.ejs

@@ -0,0 +1 @@
+shared uniform mat4 pMatrix;

data/builtin/shaders/depthmap/fragment.ejs

@@ -0,0 +1,5 @@
+//= require "../functions/depth_map"
+
+void main(void) {
+  gl_FragColor = pack_depth(gl_FragCoord.z);
+}

data/builtin/shaders/depthmap/vertex.ejs

@@ -0,0 +1,7 @@
+shared attribute vec4 VERTEX_POSITION;
+    
+shared uniform mat4 mvMatrix;
+            
+void main(void) {
+  gl_Position = pMatrix * mvMatrix * VERTEX_POSITION;
+}

data/builtin/shaders/fog/common.ejs

@@ -0,0 +1,7 @@
+uniform vec4 FogColor;
+
+uniform int Algorithm;
+
+uniform float Scale;
+uniform float End;
+uniform float Density;

data/builtin/shaders/fog/fragment.ejs

@@ -0,0 +1,23 @@
+const float LOG2 = 1.442695;
+
+void main(inout vec4 ambient, inout vec4 diffuse, inout vec4 specular) {
+  float fog;
+  float distance = length(gl_FragCoord.z / gl_FragCoord.w);
+
+  if (Algorithm == <%=Jax.LINEAR%>) {
+    fog = (End - distance) * Scale;
+  } else if (Algorithm == <%=Jax.EXPONENTIAL%>) {
+    fog = exp(-Density * distance);
+  } else if (Algorithm == <%=Jax.EXP2%>) {
+    fog = exp2(-Density * Density * distance * distance * LOG2);
+  } else {
+    /* error condition, output red */
+    ambient = diffuse = specular = vec4(1,0,0,1);
+    return;
+  }
+
+  fog = clamp(fog, 0.0, 1.0);
+  
+  ambient  = mix(FogColor,  ambient,  fog);
+  diffuse  = mix(FogColor,  diffuse,  fog);
+}

data/builtin/shaders/fog/manifest.yml

@@ -0,0 +1,12 @@
+description: A fog effect.
+
+options:
+  color:
+    red: 1.0
+    green: 1.0
+    blue: 1.0
+    alpha: 1.0
+  algorithm: EXP2
+  start: 10.0
+  end: 100.0
+  density: 0.0015

data/builtin/shaders/fog/material.js

@@ -0,0 +1,34 @@
+Jax.LINEAR = 1;
+Jax.EXPONENTIAL = 2;
+Jax.EXP2 = 3;
+
+Jax.Material.Fog = Jax.Class.create(Jax.Material, {
+  initialize: function($super, options) {
+    options = Jax.Util.normalizeOptions(options, {
+      shader: "fog",
+      algorithm: Jax.EXP2,
+      start: 10.0,
+      end: 100.0,
+      density: 0.0015,
+      color:[1,1,1,1]
+    });
+    options.color = Jax.Util.colorize(options.color);
+    options.color = [options.color[0],options.color[1],options.color[2],options.color[3]];
+    if (typeof(options.algorithm) == "string") {
+      var name = options.algorithm;
+      options.algorithm = Jax[name];
+      if (!options.algorithm) throw new Error("Jax: Fog algorithm must be one of LINEAR, EXPONENTIAL, or EXP2");
+    }
+    $super(options);
+  },
+  
+  setUniforms: function($super, context, mesh, options, uniforms) {
+    $super(context, mesh, options, uniforms);
+    
+    uniforms.set('End', this.end);
+    uniforms.set('Scale', 1.0 / (this.end - this.start));
+    uniforms.set('Algorithm', this.algorithm);
+    uniforms.set('Density', this.density);
+    uniforms.set('FogColor', this.color);
+  }
+});

data/builtin/shaders/fog/vertex.ejs

@@ -0,0 +1,10 @@
+shared attribute vec4 VERTEX_POSITION;
+
+shared uniform mat4 mvMatrix, pMatrix;
+
+const float LOG2 = 1.442695;
+
+void main(void) {
+  vec4 pos = mvMatrix * VERTEX_POSITION;
+  gl_Position = pMatrix * pos;
+}

data/builtin/shaders/functions/depth_map.ejs

@@ -0,0 +1,24 @@
+vec4 pack_depth(const in float depth)
+{
+  const vec4 bit_shift = vec4(256.0*256.0*256.0, 256.0*256.0, 256.0, 1.0);
+  const vec4 bit_mask  = vec4(0.0, 1.0/256.0, 1.0/256.0, 1.0/256.0);
+  vec4 res = fract(depth * bit_shift);
+  res -= res.xxyz * bit_mask;
+  return res;
+}
+
+/*
+float linearize(in float z) {
+  float A = pMatrix[2].z, B = pMatrix[3].z;
+  float n = - B / (1.0 - A); // camera z near
+  float f =   B / (1.0 + A); // camera z far
+  return (2.0 * n) / (f + n - z * (f - n));
+}
+*/
+
+float unpack_depth(const in vec4 rgba_depth)
+{
+  const vec4 bit_shift = vec4(1.0/(256.0*256.0*256.0), 1.0/(256.0*256.0), 1.0/256.0, 1.0);
+  float depth = dot(rgba_depth, bit_shift);
+  return depth;
+}

data/builtin/shaders/functions/lights.ejs

@@ -0,0 +1,155 @@
+/* see http://jax.thoughtsincomputation.com/2011/05/webgl-apps-crashing-on-windows-7/ */
+//const struct LightSource {
+//  int enabled;
+//  int type;
+//  vec3 position; // in world space
+//  vec3 direction; // in world space
+//  vec4 ambient, diffuse, specular;
+//  float constant_attenuation, linear_attenuation, quadratic_attenuation;
+//  float spotExponent, spotCosCutoff;
+//};
+
+shared uniform bool LIGHT_ENABLED;
+shared uniform int LIGHT_TYPE;
+shared uniform vec3 LIGHT_POSITION, LIGHT_DIRECTION;
+shared uniform vec4 LIGHT_AMBIENT, LIGHT_DIFFUSE, LIGHT_SPECULAR;
+shared uniform float LIGHT_ATTENUATION_CONSTANT, LIGHT_ATTENUATION_LINEAR, LIGHT_ATTENUATION_QUADRATIC,
+                     LIGHT_SPOT_EXPONENT, LIGHT_SPOT_COS_CUTOFF;
+
+float calcAttenuation(in vec3 ecPosition3,
+                      out vec3 lightDirection)
+{
+//  lightDirection = vec3(vnMatrix * -light.position) - ecPosition3;
+  lightDirection = vec3(ivMatrix * vec4(LIGHT_POSITION, 1.0)) - ecPosition3;
+  float d = length(lightDirection);
+  
+  return 1.0 / (LIGHT_ATTENUATION_CONSTANT + LIGHT_ATTENUATION_LINEAR * d + LIGHT_ATTENUATION_QUADRATIC * d * d);
+}
+
+void DirectionalLight(in vec3 normal,
+                      inout vec4 ambient,
+                      inout vec4 diffuse,
+                      inout vec4 specular)
+{
+  if (PASS_TYPE == <%=Jax.Scene.AMBIENT_PASS%>)
+    ambient += LIGHT_AMBIENT;
+  else {
+    vec3 nLDir = normalize(vnMatrix * -normalize(LIGHT_DIRECTION));
+    vec3 halfVector = normalize(nLDir + vec3(0,0,1));
+    float pf;
+    
+    float NdotD  = max(0.0, dot(normal, nLDir));
+    float NdotHV = max(0.0, dot(normal, halfVector));
+    
+    if (NdotD == 0.0) pf = 0.0;
+    else pf = pow(NdotHV, materialShininess);
+    
+    diffuse += LIGHT_DIFFUSE * NdotD;
+    specular += LIGHT_SPECULAR * pf;
+  }
+}
+
+/* Use when attenuation != (1,0,0) */
+void PointLightWithAttenuation(in vec3 ecPosition3,
+                               in vec3 normal,
+                               inout vec4 ambient,
+                               inout vec4 diffuse,
+                               inout vec4 specular)
+{
+  float NdotD; // normal . light direction
+  float NdotHV;// normal . half vector
+  float pf;    // specular factor
+  float attenuation;
+  vec3 VP;     // direction from surface to light position
+  vec3 halfVector; // direction of maximum highlights
+  
+  attenuation = calcAttenuation(ecPosition3, VP);
+  VP = normalize(VP);
+  
+  halfVector = normalize(VP+vec3(0,0,1));
+  NdotD = max(0.0, dot(normal, VP));
+  NdotHV= max(0.0, dot(normal, halfVector));
+  
+  if (NdotD == 0.0) pf = 0.0;
+  else pf = pow(NdotHV, materialShininess);
+
+  if (PASS_TYPE == <%=Jax.Scene.AMBIENT_PASS%>)
+    ambient += LIGHT_AMBIENT * attenuation;
+  else {
+    diffuse += LIGHT_DIFFUSE * NdotD * attenuation;
+    specular += LIGHT_SPECULAR * pf * attenuation;
+  }
+}
+
+/* Use for better performance when attenuation == (1,0,0) */
+void PointLightWithoutAttenuation(in vec3 ecPosition3,
+                                  in vec3 normal,
+                                  inout vec4 ambient,
+                                  inout vec4 diffuse,
+                                  inout vec4 specular)
+{
+  float NdotD; // normal . light direction
+  float NdotHV;// normal . half vector
+  float pf;    // specular factor
+  float d;     // distance from surface to light source
+  vec3 VP;     // direction from surface to light position
+  vec3 halfVector; // direction of maximum highlights
+  
+  VP = vec3(ivMatrix * vec4(LIGHT_POSITION, 1.0)) - ecPosition3;
+  d = length(VP);
+  VP = normalize(VP);
+  halfVector = normalize(VP+vec3(0,0,1));
+  NdotD = max(0.0, dot(normal, VP));
+  NdotHV= max(0.0, dot(normal, halfVector));
+  
+  if (NdotD == 0.0) pf = 0.0;
+  else pf = pow(NdotHV, materialShininess);
+  
+  if (PASS_TYPE == <%=Jax.Scene.AMBIENT_PASS%>)
+    ambient += LIGHT_AMBIENT;
+  else {
+    diffuse += LIGHT_DIFFUSE * NdotD;
+    specular += LIGHT_SPECULAR * pf;
+  }
+}
+
+void SpotLight(in vec3 ecPosition3,
+               in vec3 normal,
+               inout vec4 ambient,
+               inout vec4 diffuse,
+               inout vec4 specular)
+{
+  float NdotD; // normal . light direction
+  float NdotHV;// normal . half vector
+  float pf;    // specular factor
+  float attenuation;
+  vec3 VP;     // direction from surface to light position
+  vec3 halfVector; // direction of maximum highlights
+  float spotDot; // cosine of angle between spotlight
+  float spotAttenuation; // spotlight attenuation factor
+  
+  attenuation = calcAttenuation(ecPosition3, VP);
+  VP = normalize(VP);
+  
+  // See if point on surface is inside cone of illumination
+  spotDot = dot(-VP, normalize(vnMatrix*LIGHT_DIRECTION));
+  if (spotDot < LIGHT_SPOT_COS_CUTOFF)
+    spotAttenuation = 0.0;
+  else spotAttenuation = pow(spotDot, LIGHT_SPOT_EXPONENT);
+  
+  attenuation *= spotAttenuation;
+  
+  halfVector = normalize(VP+vec3(0,0,1));
+  NdotD = max(0.0, dot(normal, VP));
+  NdotHV= max(0.0, dot(normal, halfVector));
+  
+  if (NdotD == 0.0) pf = 0.0;
+  else pf = pow(NdotHV, materialShininess);
+  
+  if (PASS_TYPE == <%=Jax.Scene.AMBIENT_PASS%>)
+    ambient += LIGHT_AMBIENT * attenuation;
+  else {
+    diffuse += LIGHT_DIFFUSE * NdotD * attenuation;
+    specular += LIGHT_SPECULAR * pf * attenuation;
+  }
+}