jax 0.0.0.4 → 0.0.0.5

data/builtin/shaders/lighting/common.ejs

@@ -1,4 +1,4 @@
-//= require "../functions/lights"
+//= require "functions/lights"
 
 shared uniform bool LIGHTING_ENABLED;
 

data/builtin/shaders/normal_map/common.ejs

@@ -1,4 +1,4 @@
-//= require "../functions/lights"
+//= require "functions/lights"
 
 uniform sampler2D NormalMap;
 

data/builtin/shaders/{paraboloid-depthmap → paraboloid}/common.ejs

@@ -2,5 +2,5 @@ shared uniform mat4 mvMatrix;
 shared uniform float DP_SHADOW_NEAR, DP_SHADOW_FAR;
 shared uniform float DP_DIRECTION;
 
-shared varying float vClip;
-shared varying vec4 vPos;
+varying float vClip;
+varying vec4 vPos;

data/builtin/shaders/{paraboloid-depthmap → paraboloid}/fragment.ejs

@@ -1,8 +1,8 @@
-//= require "../functions/depth_map"
-
 void main(void) {
   /* because we do our own projection, we also have to do our own clipping */
   /* if vClip is less than 0, it's behind the near plane and can be dropped. */
   if (vClip < 0.0) discard;
-  gl_FragColor = pack_depth(vPos.z);
+  
+  export(vec4, exPos, vPos);
+//  gl_FragColor = pack_depth(vPos.z);
 }

data/builtin/shaders/paraboloid/manifest.yml

@@ -0,0 +1,5 @@
+description: |
+  Renders the scene distorted into a paraboloid. Useful for fast
+    omnidirectional environment mapping.
+
+# no options

data/builtin/shaders/{paraboloid-depthmap → paraboloid}/material.js

@@ -1,11 +1,11 @@
-Jax.Material.DualParaboloid = Jax.Class.create(Jax.Material, {
-  initialize: function($super) {
-    $super({shader:"paraboloid-depthmap"});
+Jax.Material.Paraboloid = Jax.Class.create(Jax.Material, {
+  initialize: function($super, options) {
+    $super(Jax.Util.normalizeOptions(options, {shader:"paraboloid"}));
   },
   
   setUniforms: function($super, context, mesh, options, uniforms) {
     $super(context, mesh, options, uniforms);
-    
+
     uniforms.set({
       DP_SHADOW_NEAR: 0.1, //c.world.lighting.getLight().getDPShadowNear() || 0.1;}},
       DP_SHADOW_FAR:  500,//c.world.lighting.getLight().getDPShadowFar() || 500;}},

data/builtin/shaders/{paraboloid-depthmap → paraboloid}/vertex.ejs

@@ -22,5 +22,6 @@ void main(void) {
   pos.w = 1.0;
 
   vPos = pos;
+  export(vec4, Position, pos);
   gl_Position = pos;
 }

data/builtin/shaders/shadow_map/common.ejs

@@ -11,4 +11,4 @@ varying vec4 vShadowCoord;
 varying vec4 vDP0, vDP1;
 //varying float vDPz, vDPDepth;
 
-//= require "../functions/lights"
+//= require "functions/lights"

data/builtin/shaders/shadow_map/fragment.ejs

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

data/lib/jax.rb

@@ -1,3 +1,5 @@
+require "active_support/core_ext"
+
 module Jax
   autoload :Generators,       File.join(File.dirname(__FILE__), "jax/generators/commands")
   autoload :VERSION,          File.join(File.dirname(__FILE__), "jax/version")
@@ -20,6 +22,8 @@ module Jax
     def root
       application && application.root
     end
+    
+    delegate :shader_load_paths, :to => :application
   end
 end
 

data/lib/jax/application.rb

@@ -1,9 +1,7 @@
-require "active_support/core_ext"
-
 module Jax
   class Application
     autoload :Configuration, "jax/application/configuration"
-    
+
     class << self
       def inherited(base)
         raise "You cannot have more than one Jax::Application" if Jax.application
@@ -43,6 +41,7 @@ module Jax
     delegate :config, :to => "self.class"
     delegate :root, :to => :config
     delegate :routes, :to => :config
+    delegate :shader_load_paths, :to => :config
     
     def shaders
 #      @shaders ||= begin
@@ -62,7 +61,7 @@ module Jax
     
     def shader_paths
       shader_paths = {}
-      config.shader_load_paths.each do |path|
+      shader_load_paths.each do |path|
         full_path = File.directory?(path) ? path : File.expand_path(path, config.root)
         glob = File.join(full_path, "*/{fragment,vertex}.ejs")
         Dir[glob].each do |dir|
@@ -73,7 +72,7 @@ module Jax
       end
       shader_paths
     end
-
+    
     def find_root_with_flag(flag, default=nil)
       root_path = self.class.called_from
   

data/lib/jax/generators/app/templates/public/javascripts/jax.js

@@ -1,4 +1,15 @@
-var Jax = { PRODUCTION: 1 };
+var Jax = { PRODUCTION: 1, VERSION: "0.0.0.5" };
+
+/* Called by Jax applications as of version 0.0.0.5 to alert the user to incomplete upgrades */
+Jax.doVersionCheck = function(targetVersion) {
+  if (Jax.environment && Jax.environment == Jax.PRODUCTION) return;
+
+  if (Jax.VERSION != targetVersion) {
+    alert("Jax version mismatch!\n\n" +
+          "Your Jax gem is version "+targetVersion+", but the Jax JS library is version "+Jax.VERSION+"!\n\n" +
+          "Please run `rake jax:update` at the command line to fix this issue.");
+  }
+};
 
 Jax.default_shader = "basic";
 
@@ -4906,9 +4917,14 @@ Jax.Material.ShadowMap = Jax.Class.create(Jax.Material, {
     if (back)  uniforms.texture('SHADOWMAP1', back,  context);
   }
 });
-Jax.Material.DualParaboloid = Jax.Class.create(Jax.Material, {
+Jax.Material.Depthmap = Jax.Class.create(Jax.Material, {
   initialize: function($super) {
-    $super({shader:"paraboloid-depthmap"});
+    $super({shader:"depthmap"});
+  }
+});
+Jax.Material.Paraboloid = Jax.Class.create(Jax.Material, {
+  initialize: function($super, options) {
+    $super(Jax.Util.normalizeOptions(options, {shader:"paraboloid"}));
   },
 
   setUniforms: function($super, context, mesh, options, uniforms) {
@@ -4959,7 +4975,7 @@ Jax.Material.Fog = Jax.Class.create(Jax.Material, {
 Jax.Material.create("basic");
 Jax.Material.create("default", {default_shader:'basic'});
 Jax.Material.create("depthmap", {default_shader:"depthmap"});
-Jax.Material.create("paraboloid-depthmap", {type:"DualParaboloid",default_shader:"paraboloid-depthmap"});
+Jax.Material.create("paraboloid-depthmap", {type:"Paraboloid",default_shader:"paraboloid",layers:[{type:"Depthmap"}]});
 Jax.Core = {};
 
 Jax.Core.Face = Jax.Class.create({
@@ -5984,6 +6000,7 @@ Jax.Scene.LightSource = (function() {
         fieldOfView = 60;
         this.camera.perspective({near:nearPlane,far:nearPlane+(2.0*sceneBoundingRadius),fov:fieldOfView,width:2048,height:2048});
       } else if (this.type == Jax.POINT_LIGHT) {
+        var paraboloid_depthmap = Jax.Material.find("paraboloid-depthmap");
 
         context.glDisable(GL_BLEND);
         context.glEnable(GL_CULL_FACE);
@@ -5999,7 +6016,7 @@ Jax.Scene.LightSource = (function() {
             mat4.set(context.getInverseViewMatrix(), sm);
 
             for (var i = 0; i < objects.length; i++) {
-              objects[i].render(context, {material:'paraboloid-depthmap', direction:1});
+              objects[i].render(context, {material:paraboloid_depthmap, direction:1});
             }
           });
 
@@ -6008,7 +6025,7 @@ Jax.Scene.LightSource = (function() {
             context.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
             context.loadViewMatrix(self.camera.getModelViewMatrix());
             for (var i = 0; i < objects.length; i++) {
-              objects[i].render(context, {material:'paraboloid-depthmap',direction:-1});
+              objects[i].render(context, {material:paraboloid_depthmap,direction:-1});
             }
           });
 
@@ -7250,6 +7267,173 @@ Jax.Context = (function() {
 Jax.Context.identifier = 0;
 Jax.Context.addMethods(GL_METHODS);
 Jax.Context.addMethods(Jax.EVENT_METHODS);
+Jax.Noise = (function() {
+  var perm/*[256]*/ = [151,160,137,91,90,15,
+    131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
+    190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
+    88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
+    77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
+    102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
+    135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
+    5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
+    223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
+    129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
+    251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
+    49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
+    138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180];
+
+  /* These are Ken Perlin's proposed gradients for 3D noise. I kept them for
+     better consistency with the reference implementation, but there is really
+     no need to pad this to 16 gradients for this particular implementation.
+     If only the "proper" first 12 gradients are used, they can be extracted
+     from the grad4[][] array: grad3[i][j] == grad4[i*2][j], 0<=i<=11, j=0,1,2
+  */
+  var grad3/*[16][3]*/ = [0,1,1,    0,1,-1,   0,-1,1,   0,-1,-1,
+                          1,0,1,    1,0,-1,  -1,0,1,   -1,0,-1,
+                          1,1,0,    1,-1,0,  -1,1,0,   -1,-1,0, // 12 cube edges
+                          1,0,-1,  -1,0,-1,   0,-1,1,   0,1,1]; // 4 more to make 16
+
+  /* These are my own proposed gradients for 4D noise. They are the coordinates
+     of the midpoints of each of the 32 edges of a tesseract, just like the 3D
+     noise gradients are the midpoints of the 12 edges of a cube.
+  */
+  var grad4/*[32][4]*/ = [0,1,1,1,   0,1,1,-1,   0,1,-1,1,   0,1,-1,-1, // 32 tesseract edges
+                          0,-1,1,1,  0,-1,1,-1,  0,-1,-1,1,  0,-1,-1,-1,
+                          1,0,1,1,   1,0,1,-1,   1,0,-1,1,   1,0,-1,-1,
+                         -1,0,1,1,  -1,0,1,-1,  -1,0,-1,1,  -1,0,-1,-1,
+                          1,1,0,1,   1,1,0,-1,   1,-1,0,1,   1,-1,0,-1,
+                         -1,1,0,1,  -1,1,0,-1,  -1,-1,0,1,  -1,-1,0,-1,
+                          1,1,1,0,   1,1,-1,0,   1,-1,1,0,   1,-1,-1,0,
+                         -1,1,1,0,  -1,1,-1,0,  -1,-1,1,0,  -1,-1,-1,0];
+
+  /* This is a look-up table to speed up the decision on which simplex we
+     are in inside a cube or hypercube "cell" for 3D and 4D simplex noise.
+     It is used to avoid complicated nested conditionals in the GLSL code.
+     The table is indexed in GLSL with the results of six pair-wise
+     comparisons beween the components of the P=(x,y,z,w) coordinates
+     within a hypercube cell.
+     c1 = x>=y ? 32 : 0;
+     c2 = x>=z ? 16 : 0;
+     c3 = y>=z ? 8 : 0;
+     c4 = x>=w ? 4 : 0;
+     c5 = y>=w ? 2 : 0;
+     c6 = z>=w ? 1 : 0;
+     offsets = simplex[c1+c2+c3+c4+c5+c6];
+     o1 = step(160,offsets);
+     o2 = step(96,offsets);
+     o3 = step(32,offsets);
+     (For the 3D case, c4, c5, c6 and o3 are not needed.)
+  */
+    var simplex4/*[][4]*/ = [0,64,128,192,   0,64,192,128,   0,0,0,0,        0,128,192,64,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        64,128,192,0,
+                             0,128,64,192,   0,0,0,0,        0,192,64,128,   0,192,128,64,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        64,192,128,0,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             64,128,0,192,   0,0,0,0,        64,192,0,128,   0,0,0,0,
+                             0,0,0,0,        0,0,0,0,        128,192,0,64,   128,192,64,0,
+                             64,0,128,192,   64,0,192,128,   0,0,0,0,        0,0,0,0,
+                             0,0,0,0,        128,0,192,64,   0,0,0,0,        128,64,192,0,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             128,0,64,192,   0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             192,0,64,128,   192,0,128,64,   0,0,0,0,        192,64,128,0,
+                             128,64,0,192,   0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             192,64,0,128,   0,0,0,0,        192,128,0,64,   192,128,64,0];
+
+  var simplex_buf = null, perm_buf = null, grad_buf = null;
+
+  /*
+   * initPermTexture() - create and load a 2D texture for
+   * a combined index permutation and gradient lookup table.
+   * This texture is used for 2D and 3D noise, both classic and simplex.
+   */
+  function initPermTexture(context)
+  {
+    var tex = new Jax.Texture({min_filter: GL_NEAREST, mag_filter: GL_NEAREST, width:256, height:256});
+
+    if (!perm_buf) {
+      var pixels = new Array(256*256*4);
+      var i,j;
+      for(i = 0; i<256; i++)
+        for(j = 0; j<256; j++) {
+          var offset = (i*256+j)*4;
+          var value = perm[(j+perm[i]) & 0xFF];
+          var g = (value & 0x0F) * 3;
+          pixels[offset]   = grad3[g+0] * 64 + 64; // Gradient x
+          pixels[offset+1] = grad3[g+1] * 64 + 64; // Gradient y
+          pixels[offset+2] = grad3[g+2] * 64 + 64; // Gradient z
+          pixels[offset+3] = value;                // Permuted index
+        }
+      perm_buf = new Uint8Array(pixels);
+    }
+
+    tex.bind(context, function() {
+      context.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, perm_buf);
+    });
+
+    return tex;
+  }
+
+  /*
+   * initSimplexTexture() - create and load a 1D texture for a
+   * simplex traversal order lookup table. This is used for simplex noise only,
+   * and only for 3D and 4D noise where there are more than 2 simplices.
+   * (3D simplex noise has 6 cases to sort out, 4D simplex noise has 24 cases.)
+   */
+  function initSimplexTexture(context)
+  {
+
+    if (!simplex_buf) simplex_buf = new Uint8Array(simplex4);
+    var tex = new Jax.Texture({min_filter:GL_NEAREST,mag_filter:GL_NEAREST, width:64, height:1});
+    tex.bind(context, function() {
+      context.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, simplex_buf);
+    });
+    return tex;
+  }
+
+  /*
+   * initGradTexture(context) - create and load a 2D texture
+   * for a 4D gradient lookup table. This is used for 4D noise only.
+   */
+  function initGradTexture(context)
+  {
+    var tex = new Jax.Texture({min_filter: GL_NEAREST, mag_filter: GL_NEAREST, width:256, height:256});
+
+    if (!grad_buf) {
+      var pixels = new Array(256*256*4);
+      var i,j;
+
+      for(i = 0; i<256; i++)
+        for(j = 0; j<256; j++) {
+          var offset = (i*256+j)*4;
+          var value = perm[(j+perm[i]) & 0xFF];
+          var g = (value & 0x1F) * 4;
+          pixels[offset]   = grad4[g+0] * 64 + 64; // Gradient x
+          pixels[offset+1] = grad4[g+1] * 64 + 64; // Gradient y
+          pixels[offset+2] = grad4[g+2] * 64 + 64; // Gradient z
+          pixels[offset+3] = grad4[g+3] * 64 + 64; // Gradient z
+        }
+
+      grad_buf = new Uint8Array(pixels);
+    }
+
+    tex.bind(context, function() {
+      context.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, grad_buf);
+    });
+    return tex;
+  }
+
+  return Jax.Class.create({
+    initialize: function(context) {
+      this.perm = initPermTexture(context);
+
+      this.simplex = initSimplexTexture(context);
+
+      this.grad = initGradTexture(context);
+    }
+  });
+})();
 
 Jax.shaders = {};
 

data/lib/jax/generators/material/USAGE

@@ -14,7 +14,7 @@ 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)%>
+  - <%=shader.name.ljust(20)%> : <%=shader.description.strip.gsub(/\n/, "\n"+" "*25)%>
 <%end -%>
 
 You can specify a shader more than once. For instance, you can create a

data/lib/jax/generators/shader/templates/common.ejs.tt

@@ -6,7 +6,7 @@ shared uniform mat4 mvMatrix, pMatrix;
 
 shared varying vec2 vTexCoords;
 shared varying vec3 vNormals;
-shared varying vec4 vColors;
+shared varying vec4 vColor;
 
 // If a variable isn't shared, it will be defined specifically for this shader.
 // If this shader is used twice in one materials, unshared variables will be

data/lib/jax/generators/shader/templates/spec.js.tt

@@ -5,6 +5,10 @@ describe("Shader '<%=file_name%>'", function() {
     context = new Jax.Context('webgl-canvas');
     mesh = new Jax.Mesh.Quad();
   });
+  
+  /* dispose the context so it doesn't continue using
+     resources after the tests have completed */
+  afterEach(function() { context.dispose(); });
 
   describe("stand-alone", function() {
     beforeEach(function() { mesh.material = new Jax.Material.<%=class_name%>(); });

data/lib/jax/packager/sprockets_template.rb

@@ -18,6 +18,10 @@ class Jax::Packager::SprocketsTemplate < Sprockets::SourceFile
           template << "//= require \"#{relative_path}\""
         end
       end
+      template.concat [
+        "if (Jax.doVersionCheck) Jax.doVersionCheck('#{Jax::Version::STRING}');",
+        "else alert('Your Jax gem version is newer than your Jax JavaScript library!\n\nRun `rake jax:update` to fix this.');"
+      ]
       template
     end
   end

data/lib/jax/resource_compiler.rb

@@ -5,7 +5,7 @@ class Jax::ResourceCompiler
     if destination_file.kind_of?(IO)
       save_resources destination_file, resources
     else
-      mkdir_p File.dirname(destination_file)
+      mkdir_p File.dirname(destination_file) unless File.exist?(File.dirname(destination_file))
       File.open destination_file, "w" do |f|
         save_resources f, resources
       end

data/lib/jax/shader.rb

@@ -118,14 +118,26 @@ class Jax::Shader
     # look for Sprockets-style require directives
     str.gsub! /\/\/=\s*require\s*['"]([^'"]*)['"]/m do |sub|
       filename = $~[1]
-      macro_name = "dependency_#{filename}".underscore.gsub(/[^a-zA-Z0-9_]/, '_')
-      <<-end_code
-      #ifndef #{macro_name}
-      #define #{macro_name}
+      found = false
+      paths = Jax.shader_load_paths
+      result = nil
+      for path in paths
+        if File.file?(real = File.join(path, "#{filename}.ejs"))
+          found = true
+          macro_name = "dependency_#{filename}".underscore.gsub(/[^a-zA-Z0-9_]/, '_')
+          result = <<-end_code
+          #ifndef #{macro_name}
+          #define #{macro_name}
       
-      #{File.read(File.join(path, "#{filename}.ejs"))}
-      #endif
-      end_code
+          #{File.read(real)}
+          #endif
+          end_code
+          break
+        end
+      end
+      
+      raise "Required file '#{filename}.ejs' not found in load paths #{paths.inspect} for shader '#{name}'!" if !found
+      result
     end
   end