jax 0.0.0.7 → 0.0.0.8

data/guides/partials/_top_nav.html.erb

@@ -0,0 +1,17 @@
+<div id="topNav">
+  <div class="wrapper">
+    <strong>More at <a href="http://jaxgl.com">jaxgl.com:</a> </strong>
+    <a href="http://blog.jaxgl.com/what-is-jax">Overview</a> |
+    <%if @link_to_guides%>
+      <a href="http://guides.jaxgl.com">Guides</a> |
+    <%end%>
+    <!-- <a href="http://jaxgl.com/download">Download</a> | -->
+    <!-- <a href="http://jaxgl.com/deploy">Deploy</a> | -->
+    <a href="http://github.com/sinisterchipmunk/jax">Code</a> |
+    <%if !@hide_links_to_api_docs%>
+      <a href="http://guides.jaxgl.com/api/js/index.html">Documentation</a> |
+    <%end%>
+    <a href="http://blog.jaxgl.com/forum">Forums</a> |
+    <a href="http://blog.jaxgl.com/">Blog</a>
+  </div>
+</div>

data/guides/source/index.html.erb

@@ -52,3 +52,10 @@
 <% end %>
 
 </dl>
+
+<h3>API Documentation</h3>
+
+<dl>
+  <%=guide("Jax JavaScript API Docs", "api/js/index.html") do%>
+  <%end%>
+</dl>

data/guides/source/layout.html.erb

@@ -21,18 +21,7 @@
     <img src="images/edge_badge.png" alt="edge-badge" id="edge-badge" />
   </div>
   <% end %>
-  <div id="topNav">
-    <div class="wrapper">
-      <strong>More at <a href="http://jaxgl.com">jaxgl.com:</a> </strong>
-      <a href="http://blog.jaxgl.com/what-is-jax">Overview</a> |
-      <!-- <a href="http://jaxgl.com/download">Download</a> | -->
-      <!-- <a href="http://jaxgl.com/deploy">Deploy</a> | -->
-      <a href="http://github.com/sinisterchipmunk/jax">Code</a> |
-      <!-- <a href="http://jaxgl.com/documentation">Documentation</a> | -->
-      <a href="http://blog.jaxgl.com/forum">Forums</a> |
-      <a href="http://blog.jaxgl.com/">Blog</a>
-    </div>
-  </div>
+  <%= render :partial => '../partials/top_nav' %>
   <!--
   I want to use a similar index to below, once the Jax guides start to take shape:
 

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

@@ -1,5 +1,5 @@
 
-var Jax = { PRODUCTION: 1, VERSION: "0.0.0.7" };
+var Jax = { PRODUCTION: 1, VERSION: "0.0.0.8" };
 
 /* Called by Jax applications as of version 0.0.0.5 to alert the user to incomplete upgrades */
 Jax.doVersionCheck = function(targetVersion) {
@@ -2243,6 +2243,7 @@ Math.equalish = Math.equalish || function(a, b) {
     if (Math.abs(a[i] - b[i]) > Math.EPSILON) return false;
   return true;
 };
+
 Jax.Util = {
   decodePickingColor: function(red, green, blue, alpha) {
     /* blue is a key. It is always max. So if it's 1, we're dealing with floats; else, bytes. */
@@ -3289,6 +3290,7 @@ Jax.Shader = (function() {
 
     getRawSource: function(options, which) {
       var source = this.options[which];
+      options = Jax.Util.normalizeOptions(options, {shader_type:which});
       if (source && (source = source.render(options))) {
         var result = this.getPreamble(options);
         if (!options || !options.skip_export_definitions)
@@ -3379,6 +3381,7 @@ Jax.Shader.max_varyings = gl.getParameter(GL_MAX_VARYING_VECTORS);
 Jax.Shader.max_vertex_uniforms = gl.getParameter(GL_MAX_VERTEX_UNIFORM_VECTORS);
 Jax.Shader.max_fragment_uniforms = gl.getParameter(GL_MAX_FRAGMENT_UNIFORM_VECTORS);
 Jax.Shader.max_attributes = gl.getParameter(GL_MAX_VERTEX_ATTRIBS);
+Jax.Shader.max_vertex_textures = gl.getParameter(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS);
 
 Jax.Shader.max_uniforms = Math.min(Jax.Shader.max_fragment_uniforms, Jax.Shader.max_vertex_uniforms);
 

data/lib/jax/version.rb

@@ -3,7 +3,7 @@ module Jax
     MAJOR = 0
     MINOR = 0
     TINY  = 0
-    PATCH = 7
+    PATCH = 8
 
     STRING = PATCH == 0 ? "#{MAJOR}.#{MINOR}.#{TINY}" : "#{MAJOR}.#{MINOR}.#{TINY}.#{PATCH}"
   end

data/spec/example_app/app/controllers/lighting_controller.js

@@ -12,8 +12,6 @@ var LightingController = (function() {
       // build a new material, since the default one isn't quite to our liking for this demo
       // all unspecified options will simply inherit the default ones.
       var custom_material = Jax.Material.find("lighting_with_shadows");
-//      var custom_material = new Jax.Material({shininess:128,ambient:[0.05,0.05,0.05,1]});
-//      custom_material.addLayer(new Jax.Material.ShadowMap());
       
       // add a Teapot
       this.world.addObject(new Jax.Model({ mesh: new Jax.Mesh.Teapot({size:10, material:custom_material}),position:[0,0,-25] }));

data/spec/javascripts/shaders/preprocessor_spec.js

@@ -2,6 +2,25 @@ describe("Preprocessor", function() {
   var context;
   var matr;
   
+  beforeEach(function() {
+    context = new Jax.Context(document.getElementById('canvas-element'));
+    matr = new Jax.Material();
+  });
+  
+  afterEach(function() { context.dispose(); });
+
+  it("should be able to determine shader type from within common code", function() {
+    Jax.shaders['test'] = new Jax.Shader({
+      common: "void <%=shader_type%>(void) { return; }",
+      vertex: "void main(void) { gl_Position = vec4(0,0,0,1); }",
+      fragment: "void main(void) { discard; }",
+      name: "test"
+    });
+    
+    expect(Jax.shaders['test'].getVertexSource(matr)).toMatch(/void vertex\(void\)/);
+    expect(Jax.shaders['test'].getFragmentSource(matr)).toMatch(/void fragment\(void\)/);
+  });
+  
   describe("with multiple similar vardecs", function() {
     Jax.shaders['test'] = new Jax.Shader({
       vertex: "shared uniform mat4 ivMatrix, mvMatrix, pMatrix, vMatrix;\n" +
@@ -21,13 +40,9 @@ describe("Preprocessor", function() {
     });
 
     beforeEach(function() {
-      context = new Jax.Context(document.getElementById('canvas-element'));
-      matr = new Jax.Material();
       matr.addLayer(new TestMaterial());
     });
 
-    afterEach(function() { context.dispose(); });
-
     it("should should not fail", function() {
       new Jax.Mesh({material:matr}).render(context);
     });

data/src/constants.yml

@@ -1 +1 @@
-JAX_VERSION: 0.0.0.7
+JAX_VERSION: 0.0.0.8

data/src/jax/anim_frame.js

@@ -31,7 +31,7 @@
 
 
 /**
- * Global.requestAnimFrame(callback, element) -> undefined
+ * Global#requestAnimFrame(callback, element) -> undefined
  * - callback (Function): callback to be fired to initiate a render sequence
  * - element (DOMElement): a DOM element to attach the animation state to
  *

data/src/jax/core/util.js

@@ -1,3 +1,8 @@
+/**
+ * class Array
+ * A standard JavaScript array.
+ **/
+
 /**
  * Jax.Util
  * Contains general-purpose utility and helper functions

data/src/jax/webgl/shader.js

@@ -196,6 +196,7 @@ Jax.Shader = (function() {
     
     getRawSource: function(options, which) {
       var source = this.options[which];
+      options = Jax.Util.normalizeOptions(options, {shader_type:which});
       if (source && (source = source.render(options))) {
         var result = this.getPreamble(options);
         if (!options || !options.skip_export_definitions)
@@ -287,6 +288,7 @@ Jax.Shader.max_varyings = gl.getParameter(GL_MAX_VARYING_VECTORS);
 Jax.Shader.max_vertex_uniforms = gl.getParameter(GL_MAX_VERTEX_UNIFORM_VECTORS);
 Jax.Shader.max_fragment_uniforms = gl.getParameter(GL_MAX_FRAGMENT_UNIFORM_VECTORS);
 Jax.Shader.max_attributes = gl.getParameter(GL_MAX_VERTEX_ATTRIBS);
+Jax.Shader.max_vertex_textures = gl.getParameter(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS);
 
 // FIXME differentiate between vertex & fragment uniforms
 Jax.Shader.max_uniforms = Math.min(Jax.Shader.max_fragment_uniforms, Jax.Shader.max_vertex_uniforms);

data/vendor/pdoc_template/html/assets/javascripts/pdoc/application.js

@@ -0,0 +1,478 @@
+//= require <prototype>
+
+if (!Prototype || Prototype.Version.indexOf('1.6') !== 0) {
+  throw "This script requires Prototype >= 1.6.";
+}
+
+Object.isDate = function(object) {
+  return object instanceof Date;
+};
+
+/** 
+ *  class Cookie
+ *  Creates a cookie.
+**/
+var Cookie = Class.create({
+  /**
+   *  new Cookie(name, value[, expires])
+   *  
+   *  - name (String): The name of the cookie.
+   *  - value (String): The value of the cookie.
+   *  - expires (Number | Date): Exact date (or number of days from now) that
+   *     the cookie will expire.
+  **/
+  initialize: function(name, value, expires) {
+    expires = expires || "";
+    if (Object.isNumber(expires)) {
+      var days = expires;
+      expires = new Date();
+      expires.setTime(expires.getTime() + (days * 24 * 60 * 60 * 1000));
+    }
+    
+    if (Object.isDate(expires))
+      expires = expires.toGMTString();
+
+    if (!Object.isUndefined(expires) && expires !== "")
+      expires = "; expires=" + expires;
+    
+    this.name    = name;
+    this.value   = value;
+    this.expires = expires;
+    
+    document.cookie = name + "=" + value + expires + "; path=/";      
+  },
+  
+  toString: function() {
+    return this.value;
+  },
+  
+  inspect: function() {
+    return "#<Cookie #{name}:#{value}>".interpolate(this);
+  }
+});
+
+/**
+ * Cookie
+**/
+Object.extend(Cookie, {
+  /**
+   *  Cookie.set(name, value, expires)
+   *  
+   *  Alias of [[Cookie#initialize]].
+  **/
+  set: function(name, value, expires) {
+    return new Cookie(name, value, expires);
+  },
+  
+  /**
+   *  Cookie.get(name)
+   *  
+   *  Returns the value of the cookie with the given name.
+   *  - name (String): The name of the cookie to retrieve.
+  **/
+  get: function(name) {
+    var c = document.cookie.split(';');
+    
+    for (var i = 0, cookie; i < c.length; i++) {
+      cookie = c[i].split('=');
+      if (cookie[0].strip() === name)
+        return cookie[1].strip();
+    }
+    
+    return null;
+  },
+  
+  /**
+   *  Cookie.unset(name)
+   *  
+   *  Deletes a cookie.
+   *  - name (String): The name of the cookie to delete.
+   *  
+  **/
+  unset: function(name) {
+    return Cookie.set(name, "", -1);
+  }
+});
+
+Cookie.erase = Cookie.unset;
+
+
+
+if (typeof PDoc === 'undefined') {
+  window.PDoc = {
+    Sidebar: {}
+  };
+}
+
+// HISTORY MANAGER (sort of)
+// Polls for changes to the hash.
+
+(function() {
+  var PREVIOUS_HASH = null;
+  
+  function poll() {
+    var hash = window.location.hash;
+    if (hash && hash !== PREVIOUS_HASH) {
+      document.fire('hash:changed', {
+        previous: PREVIOUS_HASH, current: hash
+      });
+    }
+    PREVIOUS_HASH = hash;
+    window.setTimeout(arguments.callee, 100);
+  }
+  
+  Event.observe(window, 'load', poll);  
+})();
+
+Object.extend(PDoc.Sidebar, {
+  getActiveTab: function() {
+    var activeTab = $('sidebar_tabs').down('.active');
+    if (!activeTab) return null;
+    
+    var href = activeTab.readAttribute('href');    
+    return href.endsWith('menu_pane') ? 'menu_pane' : 'search_pane';    
+  },
+  
+  // Remember the state of the sidebar so it can be restored on the next page.
+  serialize: function() {
+    var state = $H({
+      activeTab: PDoc.Sidebar.getActiveTab(),
+      menuScrollOffset: $('menu_pane').scrollTop,
+      searchScrollOffset: $('search_results').scrollTop,
+      searchValue: $('search').getValue()
+    });
+    
+    return escape(state.toJSON());
+  },
+  
+  // Restore the tree to a certain point based on a cookie.
+  restore: function(state) {
+    try {
+      state = unescape(state).evalJSON();
+      var filterer = $('search').retrieve('filterer');    
+      filterer.setSearchValue(state.searchValue);
+
+      (function() {
+        $('menu_pane').scrollTop = state.menuScrollOffset;
+        $('search_results').scrollTop = state.searchScrollOffset;
+      }).defer();
+    } catch(error) {
+      console.log(error);
+      if (!(error instanceof SyntaxError)) throw error;
+    }
+  }
+});
+
+
+
+// Live API search.
+PDoc.Sidebar.Filterer = Class.create({
+  initialize: function(element, options) {
+    this.element = $(element);
+    this.options = Object.extend(
+      Object.clone(PDoc.Sidebar.Filterer.DEFAULT_OPTIONS),
+      options || {}
+    );
+    
+    // The browser's "helpful" auto-complete gets in the way.
+    this.element.writeAttribute("autocomplete", "off");
+    this.element.setValue('');
+    
+    // Hitting "enter" should do nothing.
+    this.element.up('form').observe("submit", Event.stop);
+    
+    this.menu  = this.options.menu;
+    this.links = this.menu.select('a');
+    
+    this.resultsElement = this.options.resultsElement;
+    
+    this.observers = {
+      filter:  this.filter.bind(this),
+      keydown: this.keydown.bind(this),
+      keyup:   this.keyup.bind(this)
+    };
+    
+    this.menu.setStyle({ opacity: 0.9 });
+    this.addObservers();    
+  },
+  
+  addObservers: function() {
+    this.element.observe('keyup', this.observers.filter);
+  },
+
+  // Called whenever the list of results needs to update as a result of a 
+  // changed search key.
+  filter: function(event) {
+    // Clear the text box on ESC.
+    if (event.keyCode && event.keyCode === Event.KEY_ESC) {
+      this.element.setValue('');
+    }
+    
+    if (PDoc.Sidebar.Filterer.INTERCEPT_KEYS.include(event.keyCode))
+      return;
+        
+    // If there's nothing in the text box, clear the results list.
+    var value = $F(this.element).strip().toLowerCase();    
+    if (value === '') {
+      this.emptyResults();
+      this.hideResults();
+      return;
+    }
+    
+    var urls  = this.findURLs(value);
+    this.buildResults(urls);
+  },
+  
+  setSearchValue: function(value) {
+    this.element.setValue(value);
+    if (value.strip() === "") {
+      PDoc.Sidebar.Tabs.setActiveTab(0);
+      return;
+    }
+    this.buildResults(this.findURLs(value));
+  },
+  
+  // Given a key, finds all the PDoc objects that match.
+  findURLs: function(str) {
+    var results = [];
+    for (var name in PDoc.elements) {
+      if (name.toLowerCase().include(str.toLowerCase()))
+        results.push(PDoc.elements[name]);
+    }
+    return results;
+  },
+  
+  buildResults: function(results) {
+    this.emptyResults();
+    
+    results.each( function(result) {
+      var li = this._buildResult(result);
+      this.resultsElement.appendChild(li);
+    }, this);
+    this.showResults();
+  },
+  
+  _buildResult: function(obj) {
+    var li = new Element('li', { 'class': 'menu-item' });
+    var a = new Element('a', {
+      'class': obj.type.gsub(/\s/, '-'),
+      'href':  PDoc.pathPrefix + obj.path
+    }).update(obj.name);
+    
+    li.appendChild(a);
+    return li;
+  },
+  
+  emptyResults: function() {
+    this.resultsElement.update();
+  },
+  
+  hideResults: function() {
+    PDoc.Sidebar.Tabs.setActiveTab(0);    
+    //this.resultsElement.hide();
+    document.stopObserving('keydown', this.observers.keydown);
+    document.stopObserving('keyup', this.observers.keyup);
+  },
+  
+  showResults: function() {
+    PDoc.Sidebar.Tabs.setActiveTab(1);
+    //this.resultsElement.show();
+    document.stopObserving('keydown', this.observers.keydown);
+    this.element.stopObserving('keyup', this.observers.keyup);
+    this.element.observe('keydown', this.observers.keydown);
+    document.observe('keyup', this.observers.keyup);
+  },
+  
+  keydown: function(event) {
+    if (!PDoc.Sidebar.Filterer.INTERCEPT_KEYS.include(event.keyCode))
+      return;
+      
+    // Also ignore if any modifier keys are present.
+    if (event.shiftKey || event.ctrlKey || event.altKey || event.metaKey)
+      return;
+      
+    event.stop();
+
+    if (event.keyCode === Event.KEY_RETURN) {
+      // Follow the highlighted item, unless there is none.
+      if (!this.highlighted) return;
+      var a = this.highlighted.down('a');
+      if (a) {
+        window.location.href = a.href;
+      }
+    } else if ([Event.KEY_UP, Event.KEY_DOWN].include(event.keyCode)) {
+      // Is an arrow key.
+      var direction = (Event.KEY_DOWN === event.keyCode) ? 1 : -1;
+      this.highlighted = this.moveHighlight(direction);
+      
+      if (!Prototype.Browser.WebKit) {
+        // If up/down key is held down, list should keep scrolling.
+        // WebKit does this automatically because it fires the keydown
+        // event over and over.
+        this._scrollTimer = window.setTimeout(
+          this.scrollList.bind(this, direction), 1000);
+      }
+    }
+  },
+  
+  keyup: function(event) {
+    if (this._scrollTimer) {
+      window.clearTimeout(this._scrollTimer);
+    }
+  },
+  
+  moveHighlight: function(direction) {
+    if (!this.highlighted) {
+      // If there is none, highlight the first result.
+      this.highlighted =
+       this.resultsElement.down('li').addClassName('highlighted');
+    } else {
+      var method = (direction === 1) ? 'next' : 'previous';
+      this.highlighted.removeClassName('highlighted');
+      var adjacent = this.highlighted[method]('li');
+      // If there isn't an adjacent one, we're at the top or bottom
+      // of the list. Flip it.
+      if (!adjacent) {
+        adjacent = method == 'next' ? this.resultsElement.down('li') :
+         this.resultsElement.down('li:last-of-type');
+      }
+      adjacent.addClassName('highlighted');
+      this.highlighted = adjacent;
+    }
+    
+    var h = this.highlighted, r = this.resultsElement;
+    
+    var distanceToBottom = h.offsetTop + h.offsetHeight;
+    if (distanceToBottom > (r.offsetHeight + r.scrollTop)) {
+      // Item is below the visible frame.
+      r.scrollTop = distanceToBottom - r.offsetHeight;
+    } else if (h.offsetTop < r.scrollTop) {
+      // Item is above the visible frame.
+      r.scrollTop = h.offsetTop;
+    }
+
+    return this.highlighted;
+  },
+  
+  scrollList: function(direction) {
+    this.moveHighlight(direction);
+    this._scrollTimer = window.setTimeout(
+      this.scrollList.bind(this, direction), 100);
+  }
+});
+
+Object.extend(PDoc.Sidebar.Filterer, {
+  INTERCEPT_KEYS: [Event.KEY_UP, Event.KEY_DOWN, Event.KEY_RETURN],
+  DEFAULT_OPTIONS: {
+    interval: 0.1,
+    resultsElement: '.search-results'
+  }
+});
+
+
+Form.GhostedField = Class.create({
+  initialize: function(element, title, options) {
+    options = options || {};
+    
+    this.element = $(element);
+    this.title = title;
+    
+    this.isGhosted = true;
+    
+    if (options.cloak) {
+      
+      // Wrap the native getValue function so that it never returns the
+      // ghosted value. This is optional because it presumes the ghosted
+      // value isn't valid input for the field.
+      this.element.getValue = this.element.getValue.wrap(this.wrappedGetValue.bind(this));      
+    }
+    
+    this.addObservers();
+    
+    this.onBlur();
+  },
+  
+  wrappedGetValue: function($proceed) {
+    var value = $proceed();
+    return value === this.title ? "" : value;
+  },
+  
+  addObservers: function() {
+    this.element.observe('focus', this.onFocus.bind(this));
+    this.element.observe('blur',  this.onBlur.bind(this));
+    
+    var form = this.element.up('form');
+    if (form) {
+      form.observe('submit', this.onSubmit.bind(this));
+    }
+    
+    // Firefox's bfcache means that form fields need to be re-initialized
+    // when you hit the "back" button to return to the page.
+    if (Prototype.Browser.Gecko) {
+      window.addEventListener('pageshow', this.onBlur.bind(this), false);
+    }
+  },
+  
+  onFocus: function() {
+    if (this.isGhosted) {
+      this.element.setValue('');
+      this.setGhosted(false);
+    }
+  },
+  
+  onBlur: function() {
+    var value = this.element.getValue();
+    if (value.blank() || value == this.title) {
+      this.setGhosted(true);
+    } else {
+      this.setGhosted(false);
+    }
+  },
+  
+  setGhosted: function(isGhosted) {
+    this.isGhosted = isGhosted;
+    this.element[isGhosted ? 'addClassName' : 'removeClassName']('ghosted');
+    if (isGhosted) {
+      this.element.setValue(this.title);
+    }    
+  },
+
+  // Hook into the enclosing form's `onsubmit` event so that we clear any
+  // ghosted text before the form is sent.
+  onSubmit: function() {
+    if (this.isGhosted) {
+      this.element.setValue('');
+    }
+  }
+});
+
+document.observe('dom:loaded', function() {
+  PDoc.Sidebar.Tabs = new Control.Tabs($('sidebar_tabs'));
+  
+  var searchField = $('search');
+  
+  if (searchField) {
+    var filterer = new PDoc.Sidebar.Filterer(searchField, {
+      menu: $('api_menu'),
+      resultsElement: $('search_results')
+    });
+    searchField.store('filterer', filterer);
+  }  
+  
+  // Prevent horizontal scrolling in scrollable sidebar areas.
+  $$('.scrollable').invoke('observe', 'scroll', function() {
+    this.scrollLeft = 0;
+  });
+  
+  var sidebarState = Cookie.get('sidebar_state');
+  if (sidebarState) {
+    PDoc.Sidebar.restore(sidebarState);
+  }
+  
+  new Form.GhostedField(searchField, searchField.getAttribute('title'), 
+    { cloak: true });
+});
+
+Event.observe(window, 'unload', function() {
+  Cookie.set('sidebar_state', PDoc.Sidebar.serialize());
+});