jax 0.0.0.1

data/src/jax/webgl/texture.js

@@ -0,0 +1,312 @@
+Jax.NORMAL_MAP = 1;
+
+
+/**
+ * class Jax.Texture
+ * Creates a managed WebGL texture.
+ **/
+Jax.Texture = (function() {
+  function imageFailed(self, image) {
+    throw new Error("Texture image '"+self.image.src+"' failed to load!");
+  }
+  
+  function isPoT(s) {
+    return s && (s & -s == s);
+  }
+  
+  function imageLoaded(self, isImageArray, img) {
+    var onload = self.options.onload || self.onload;
+    
+    if (!isPoT(img.width) || !isPoT(img.height)) {
+      self.options.mag_filter = GL_LINEAR;
+      self.options.min_filter = GL_LINEAR;
+      self.options.wrap_s = GL_CLAMP_TO_EDGE;
+      self.options.wrap_t = GL_CLAMP_TO_EDGE;
+      self.options.generate_mipmap = false;
+    }
+
+    if (!isImageArray) {
+      if (onload) onload.call(self, self.image);
+      self.loaded = true;
+    } else {
+      self.images.load_count++;
+      if (self.images.load_count == self.images.length) {
+        /* all done */
+        if (onload) onload.call(self, self.image);
+        self.loaded = true;
+      }
+    }
+  }
+  
+  function build(self, context) {
+    self.handles[context.id] = context.glCreateTexture();
+  }
+  
+  function generateTexture(context, self) {
+    var data_type = self.options.data_type, format = self.options.format, target = self.options.target;
+    if (self.image) {
+      switch(target) {
+        case GL_TEXTURE_2D:
+          context.glTexImage2D(target, 0, format, format, data_type, self.image);
+          break;
+        case GL_TEXTURE_CUBE_MAP:
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, format, format, data_type, self.image);
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, format, format, data_type, self.image);
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, format, format, data_type, self.image);
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, format, format, data_type, self.image);
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, format, format, data_type, self.image);
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, format, format, data_type, self.image);
+          break;
+        default: throw new Error("Unexpected texture target "+target+"; use GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP");
+      }
+    } else if (self.images) {
+      switch(target) {
+        case GL_TEXTURE_2D:
+          context.glTexImage2D(target, 0, format, format, data_type, self.images[0]);
+          break;
+        case GL_TEXTURE_CUBE_MAP:
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, format, format, data_type, self.images[GL_TEXTURE_CUBE_MAP_POSITIVE_X] || self.images[0]);
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0, format, format, data_type, self.images[GL_TEXTURE_CUBE_MAP_POSITIVE_Y] || self.images[1]);
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0, format, format, data_type, self.images[GL_TEXTURE_CUBE_MAP_POSITIVE_Z] || self.images[2]);
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0, format, format, data_type, self.images[GL_TEXTURE_CUBE_MAP_NEGATIVE_X] || self.images[3]);
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, format, format, data_type, self.images[GL_TEXTURE_CUBE_MAP_NEGATIVE_Y] || self.images[4]);
+          context.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, format, format, data_type, self.images[GL_TEXTURE_CUBE_MAP_NEGATIVE_Z] || self.images[5]);
+          break;
+        default: throw new Error("Unexpected texture target "+target+"; use GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP");
+      }
+    } else {
+      // no images at all -- load the texture with empty data; it's probably for a framebuffer
+      var width = self.options.width, height = self.options.height;
+      if (!width || !height) throw new Error("Can't build an empty texture without at least a width and height");
+      
+      function ti2d(glEnum) {
+        try {
+          context.glTexImage2D(glEnum, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, null);
+        } catch (e) {
+          var tex = new Uint8Array(width*height*Jax.Util.sizeofFormat(format));
+          context.glTexImage2D(glEnum, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, tex);
+        }
+      }
+      
+      switch(target) {
+        case GL_TEXTURE_2D:
+          ti2d(GL_TEXTURE_2D);
+          break;
+        case GL_TEXTURE_CUBE_MAP:
+          ti2d(GL_TEXTURE_CUBE_MAP_POSITIVE_X);
+          ti2d(GL_TEXTURE_CUBE_MAP_POSITIVE_Y);
+          ti2d(GL_TEXTURE_CUBE_MAP_POSITIVE_Z);
+          ti2d(GL_TEXTURE_CUBE_MAP_NEGATIVE_X);
+          ti2d(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y);
+          ti2d(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);
+          break;
+        default: throw new Error("Unexpected texture target "+target+"; use GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP");
+      }
+    }
+  }
+  
+  /* pushLevel/popLevel are used for automatic management of glActiveTexture's.
+    The general concept is that you can do something like:
+    
+      tex1.bind(context, function() {
+        tex2.bind(context, function() {
+          // render stuff.
+          // tex1 => GL_TEXTURE0, tex1.textureLevel => 0
+          // tex2 => GL_TEXTURE1, tex2.textureLevel => 1
+          
+          tex3.bind(context, 5, function() {
+            // tex3 => GL_TEXTURE5, tex3.textureLevel => 5
+          });
+        });
+      });
+   */
+  function pushLevel(self, level, context) {
+    if (level == null) level = Jax.Texture._level++;
+    self.textureLevel = level;
+    context.glActiveTexture(GL_TEXTURES[level]);
+  }
+  
+  function popLevel(self, context) {
+    Jax.Texture._level = self.textureLevel - 1;
+    if (Jax.Texture._level < 0) Jax.Texture._level = 0;
+    delete self.textureLevel;
+  }
+  
+  return Jax.Class.create({
+    /**
+     * new Jax.Texture(url[, options])
+     * - url (String): the URL or relative path to the image to be loaded.
+     * - options (Object): a generic object optionally consisting of the following properties:
+     * new Jax.Texture(urls[, options])
+     * - urls (Array): an array of URLs or relative paths to the images to be loaded. This is intended
+     *                 for use with cube maps. If used with a cube map, 6 paths must be provided.
+     *                 If used with a standard 2D texture, only the first path in the array will be used.
+     * - options (Object): a generic object optionally consisting of the following properties:
+     * new Jax.Texture(options)
+     * - options (Object): a generic object optionally consisting of the following properties, plus a mandatory
+     *                     _width_ and _height_ in pixels:
+     * 
+     *   * min_filter: GL_NEAREST
+     *   * mag_filter: GL_NEARETS
+     *   * generate_mipmap: true
+     *   * mipmap_hint: GL_DONT_CARE
+     *   * format: GL_RGBA
+     *   * target: GL_TEXTURE_2D
+     *   * data_type: GL_UNSIGNED_BYTE
+     *   * wrap_s: GL_REPEAT
+     *   * wrap_t: GL_REPEAT
+     *   * flip_y: false
+     *   * premultiply_alpha: false
+     *   * colorspace_conversion: true
+     *   * onload: null - a function to be called after the image has been loaded. This function
+     *                    will not be called if the image fails to load.
+     *                     
+     **/
+    initialize: function(path_or_array, options) {
+      this.handles = {};
+      this.loaded = false;
+      this.valid = [];
+      
+      if (!options && typeof(path_or_array) == "object" && path_or_array.length == undefined) {
+        options = path_or_array;
+        path_or_array = options.path || null;
+        delete options.path;
+      }
+      
+      var self = this;
+      this.options = Jax.Util.normalizeOptions(options, {
+        min_filter: GL_NEAREST,
+        mag_filter: GL_NEAREST,
+        generate_mipmap: true,
+        mipmap_hint: GL_DONT_CARE,
+        format: GL_RGBA,
+        target: GL_TEXTURE_2D,
+        data_type: GL_UNSIGNED_BYTE,
+        wrap_s: GL_REPEAT,
+        wrap_t: GL_REPEAT,
+        flip_y: false,
+        premultiply_alpha: false,
+        colorspace_conversion: true,
+        onload: null
+      });
+      
+      var i;
+      var enums = ['min_filter', 'mag_filter', 'mipmap_hint', 'format', 'target', 'data_type', 'wrap_s', 'wrap_t'];
+      for (i = 0; i < enums.length; i++)
+        if (typeof(this.options[enums[i]]) == "string")
+          this.options[enums[i]] = window[this.options[enums[i]]];
+
+      if (path_or_array) {
+        if (typeof(path_or_array) == "string") {
+          this.image = new Image();
+          this.image.onload = function() { imageLoaded(self, false, this); };
+          this.image.onerror = this.image.onabort = function() { imageFailed(self, this); };
+          this.image.src = path_or_array;
+        } else {
+          var onload = function() { imageLoaded(self, true, this); };
+          this.images = [];
+          this.images.load_count = 0;
+          for (i = 0; i < path_or_array.length; i++) {
+            this.images[i] = new Image();
+            this.images[i].onload = onload;
+            this.images[i].onerror = this.images[i].onabort = function() { imageFailed(self, this); };
+            this.images[i].src = path_or_array[i];
+          }
+        }
+      }
+      else {
+        // nothing to load
+        this.options.generate_mipmap = !!(options && options.generate_mipmap);
+        this.loaded = true;
+      }
+    },
+    
+    getTarget: function() { return this.options.target; },
+    getMinFilter: function() { return this.options.min_filter; },
+    getMagFilter: function() { return this.options.mag_filter; },
+    getGeneratesMipmaps: function() { return this.options.generate_mipmap; },
+    getMipmapHint: function() { return this.options.mipmap_hint; },
+    getFormat: function() { return this.options.format; },
+    getDataType: function() { return this.options.data_type; },
+    getWrapS: function() { return this.options.wrap_s; },
+    getWrapT: function() { return this.options.wrap_t; },
+    getFlipY: function() { return this.options.flip_y; },
+    getPremultipliesAlpha: function() { return this.options.premultiply_alpha; },
+    getDoesColorspaceConversion: function() { return this.options.colorspace_conversion; },
+    getOnloadFunc: function() { return this.options.onload; },
+    
+    refresh: function(context) {
+      if (!this.ready()) return;
+      
+      context.glBindTexture(this.options.target, this.getHandle(context));
+      generateTexture(context, this);
+      context.glTexParameteri(this.options.target, GL_TEXTURE_MAG_FILTER, this.options.mag_filter);
+      context.glTexParameteri(this.options.target, GL_TEXTURE_MIN_FILTER, this.options.min_filter);
+      context.glTexParameteri(this.options.target, GL_TEXTURE_WRAP_S, this.options.wrap_s);
+      context.glTexParameteri(this.options.target, GL_TEXTURE_WRAP_T, this.options.wrap_t);
+      context.glPixelStorei(GL_UNPACK_FLIP_Y_WEBGL, this.options.flip_y);
+      context.glPixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL, this.options.premultiply_alpha);
+      context.glPixelStorei(GL_UNPACK_COLORSPACE_CONVERSION_WEBGL, this.options.colorspace_conversion ? GL_BROWSER_DEFAULT_WEBGL : GL_NONE);
+      
+      if (this.options.generate_mipmap) {
+        this.generateMipmap(context);
+      }
+      
+      context.glBindTexture(this.options.target, null);
+      this.valid[context.id] = true;
+    },
+    
+    generateMipmap: function(context) {
+      // FIXME why does this raise 1280 invalid enum?
+//      context.glHint(GL_GENERATE_MIPMAP_HINT, this.options.mipmap_hint);
+      context.glGenerateMipmap(this.options.target);
+    },
+    
+    invalidate: function() { this.valid.clear(); },
+    
+    dispose: function(context) {
+      context.glDeleteTexture(getHandle(context));
+      delete this.handles[context.id];
+    },
+    
+    getHandle: function(context) {
+      if (!this.handles[context.id]) {
+        build(this, context);
+        this.refresh(context);
+      }
+      return this.handles[context.id];
+    },
+    
+    isValid: function(context) {
+      return !!this.valid[context.id];
+    },
+    
+    bind: function(context, level, callback) {
+      if (!this.ready()) return; // no texture to display, yet... but not worth crashing over.
+      if (!this.isValid(context)) this.refresh(context);
+      
+      if (typeof(level) == "number")
+        pushLevel(this, level, context);
+      else if (typeof(level) == "function") { callback = level; pushLevel(this, null, context); }
+      
+      context.glBindTexture(this.options.target, this.getHandle(context));
+      if (callback)
+      {
+        callback.call(this, this.textureLevel);
+        this.unbind(context);
+      }
+    },
+    
+    unbind: function(context) {
+      if (this.textureLevel != undefined) context.glActiveTexture(GL_TEXTURES[this.textureLevel]);
+      context.glBindTexture(this.options.target, null);
+      popLevel(this, context);
+    },
+    
+    ready: function() {
+      return this.loaded;
+    }
+  });
+})();
+
+Jax.Texture._level = 0;

data/src/jax/webgl/world.js

@@ -0,0 +1,119 @@
+//= require "scene"
+
+Jax.World = (function() {
+  return Jax.Class.create({
+    initialize: function(context) {
+      this.context  = context;
+      this.lighting = new Jax.Scene.LightManager(context);
+      this.objects  = [];
+      this.shadow_casters = [];
+    },
+    
+    addLightSource: function(light)   { this.lighting.add(light); },
+    
+    addObject: function(object) { this.objects.push(object); this.invalidate(); return object; },
+    
+    getObject: function(index) { return this.objects[index]; },
+    
+    removeObject: function(object_or_index) {
+      if (this.objects[object_or_index]) {
+        var obj = this.objects[object_or_index];
+        this.objects.splice(object_or_index, 1);
+        this.invalidate();
+        return obj;
+      }
+      else
+        for (var i = 0; i < this.objects.length; i++)
+          if (this.objects[i] == object_or_index)
+          {
+            this.objects.splice(i, 1);
+            this.invalidate();
+            return this.objects[i];
+          }
+    },
+    
+    countObjects: function() {
+      return this.objects.length;
+    },
+    
+    invalidate: function() {
+      while (this.shadow_casters.length > 0) {
+        /* TODO we still need to unregister the camera event listener */
+        this.shadow_casters.pop();
+      }
+      
+      var updated = function() { self.shadowmaps_valid = false; };
+
+      var i;
+      for (i = 0; i < this.objects.length; i++) {
+        var self = this;
+        if (this.objects[i].isShadowCaster()) {
+          this.objects[i].camera.addEventListener('matrixUpdated', updated);
+          this.shadow_casters.push(this.objects[i]);
+        }
+      }
+      
+      for (i = 0; i < this.lighting.count(); i++) {
+        var light = this.lighting.getLight(i);
+        if (light.isShadowcaster())
+          light.camera.addEventListener('matrixUpdated', updated);
+      }
+      this.shadowmaps_valid = false;
+    },
+    
+    getShadowCasters: function() { return this.shadow_casters; },
+    
+    render: function() {
+      var i;
+      
+      /* this.current_pass is used by the material */
+
+      this.context.current_pass = Jax.Scene.AMBIENT_PASS;
+      this.context.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+      var unlit = {unlit:true};
+      
+      if (this.lighting.isEnabled()) {
+        /* ambient pass */
+        for (i = 0; i < this.objects.length; i++) {
+          if (!this.objects[i].lit)
+            this.objects[i].render(this.context, unlit);
+        }
+        this.lighting.ambient(this.context, this.objects);
+      
+        /* shadowgen pass */
+        this.context.current_pass = Jax.Scene.SHADOWMAP_PASS;
+        if (!this.shadowmaps_valid) {
+          this.lighting.updateShadowMaps(this.context, this.shadow_casters);
+          this.shadowmaps_valid = true;
+        }
+        
+        /* illumination pass */
+        this.context.glBlendFunc(GL_ONE, GL_ONE);
+        this.context.current_pass = Jax.Scene.ILLUMINATION_PASS;
+        this.lighting.illuminate(this.context, this.objects);
+      } else {
+        for (i = 0; i < this.objects.length; i++)
+          this.objects[i].render(this.context, unlit);
+      }
+    },
+    
+    update: function(timechange) {
+      for (var i = this.objects.length-1; i >= 0; i--)
+        if (this.objects[i].update)
+          this.objects[i].update(timechange);
+    },
+      
+    dispose: function() {
+      var i, o;
+      
+      for (i = this.objects.length-1; i >= 0; i--)
+      /*
+        actually, we may not want to dispose the objects just yet. What if the user has a handle to them?
+        Maybe better to let JS GC take care of this one.
+      */
+        (o = this.objects.pop());// && o.dispose();
+      
+      this.lighting = new Jax.Scene.LightManager(this.context);
+    }
+  });
+})();

data/vendor/ejs/.svn/all-wcprops

@@ -0,0 +1,17 @@
+K 25
+svn:wc:ra_dav:version-url
+V 22
+/svn/!svn/ver/72/trunk
+END
+license.txt
+K 25
+svn:wc:ra_dav:version-url
+V 33
+/svn/!svn/ver/4/trunk/license.txt
+END
+Eratta.txt
+K 25
+svn:wc:ra_dav:version-url
+V 32
+/svn/!svn/ver/4/trunk/Eratta.txt
+END

data/vendor/ejs/.svn/entries

@@ -0,0 +1,114 @@
+10
+
+dir
+72
+http://embeddedjavascript.googlecode.com/svn/trunk
+http://embeddedjavascript.googlecode.com/svn
+
+
+
+2009-11-14T02:03:53.328213Z
+72
+justinbmeyer
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+efe5f0e3-6940-0410-82d6-07539bb1838e
+
+test
+dir
+
+license.txt
+file
+
+
+
+
+2011-04-26T10:28:12.000000Z
+2bc2730ac1113f50dccf794fa3384840
+2007-12-07T17:03:30.157741Z
+4
+edward.benson
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1104
+
+script
+dir
+
+doc
+dir
+
+lib
+dir
+
+src
+dir
+
+example
+dir
+
+Eratta.txt
+file
+
+
+
+
+2011-04-26T10:28:12.000000Z
+e6cae8351503560908499843729bf1dd
+2007-12-07T17:03:30.157741Z
+4
+edward.benson
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+107
+