jax 0.0.0.1

data/builtin/shaders/lighting/common.ejs

@@ -0,0 +1,5 @@
+//= require "../functions/lights"
+
+shared uniform bool LIGHTING_ENABLED;
+
+shared varying vec3 vLightDir;

data/builtin/shaders/lighting/fragment.ejs

@@ -0,0 +1,34 @@
+void main(inout vec4 ambient, inout vec4 diffuse, inout vec4 specular) {
+  vec4 _ambient = vec4(0), _diffuse = vec4(0), _specular = vec4(0);
+  
+  vec3 nNormal = normalize(vNormal);
+
+  if (LIGHTING_ENABLED) {
+    if (LIGHT_TYPE == <%=Jax.DIRECTIONAL_LIGHT%>)
+      DirectionalLight(nNormal, _ambient, _diffuse, _specular);
+    else
+      if (LIGHT_TYPE == <%=Jax.POINT_LIGHT%>)
+        if (LIGHT_ATTENUATION_CONSTANT == 1.0 && LIGHT_ATTENUATION_LINEAR == 0.0 && LIGHT_ATTENUATION_QUADRATIC == 0.0)
+          PointLightWithoutAttenuation(vSurfacePos, nNormal, _ambient, _diffuse, _specular);
+        else
+          PointLightWithAttenuation(vSurfacePos, nNormal, _ambient, _diffuse, _specular);
+    else
+      if (LIGHT_TYPE == <%=Jax.SPOT_LIGHT%>)
+        SpotLight(vSurfacePos, nNormal, _ambient, _diffuse, _specular);
+    else
+    { // error condition, output 100% red
+      gl_FragColor = vec4(1,0,0,1);
+      return;
+    }
+  } else {
+    _ambient = vec4(1,1,1,1);
+    _diffuse = _specular = vec4(0,0,0,0);
+  }
+
+  // is this correct??
+  if (_ambient.a != 0.0) _ambient.a = 1.0;
+  
+  ambient *= _ambient;
+  diffuse *= _diffuse;
+  specular *= _specular;
+}

data/builtin/shaders/lighting/manifest.yml

@@ -0,0 +1,4 @@
+description: Lighting support.
+
+options:
+  

data/builtin/shaders/lighting/material.js

@@ -0,0 +1,26 @@
+Jax.Material.Lighting = Jax.Class.create(Jax.Material, {
+  initialize: function($super) {
+    $super({shader: "lighting"});
+  },
+  
+  setUniforms: function($super, context, mesh, options, uniforms) {
+    $super(context, mesh, options, uniforms);
+    
+    var light = context.world.lighting.getLight();
+    uniforms.set({
+      LIGHTING_ENABLED: context.world.lighting.isEnabled() && !(options.unlit),
+      LIGHT_POSITION: light.getPosition(),
+      LIGHT_DIRECTION: light.getDirection(),
+      LIGHT_AMBIENT: light.getAmbientColor(),
+      LIGHT_DIFFUSE: light.getDiffuseColor(),
+      LIGHT_SPECULAR: light.getSpecularColor(),
+      LIGHT_ATTENUATION_CONSTANT: light.getConstantAttenuation(),
+      LIGHT_ATTENUATION_LINEAR: light.getLinearAttenuation(),
+      LIGHT_ATTENUATION_QUADRATIC: light.getQuadraticAttenuation(),
+      LIGHT_SPOT_EXPONENT: light.getSpotExponent(),
+      LIGHT_SPOT_COS_CUTOFF: light.getSpotCosCutoff(),
+      LIGHT_ENABLED: light.isEnabled(),
+      LIGHT_TYPE: light.getType()
+    });
+  }
+});

data/builtin/shaders/lighting/vertex.ejs

@@ -0,0 +1,7 @@
+shared attribute vec2 VERTEX_TEXCOORDS;
+shared attribute vec3 VERTEX_NORMAL;
+shared attribute vec4 VERTEX_POSITION, VERTEX_COLOR, VERTEX_TANGENT;
+
+void main(void) {
+  vLightDir = normalize(vnMatrix * -normalize(LIGHT_DIRECTION));
+}

data/builtin/shaders/normal_map/common.ejs

@@ -0,0 +1,12 @@
+//= require "../functions/lights"
+
+uniform sampler2D NormalMap;
+
+shared uniform mat4 mvMatrix, pMatrix, vMatrix;
+shared uniform mat3 nMatrix;
+
+shared varying vec2 vTexCoords;
+
+varying vec3 vEyeDir;
+varying vec3 vLightDir;
+varying float vAttenuation;

data/builtin/shaders/normal_map/fragment.ejs

@@ -0,0 +1,26 @@
+void main(inout vec4 ambient, inout vec4 diffuse, inout vec4 specular) {
+  // ambient was applied by the basic shader; applying it again will simply brighten some fragments
+  // beyond their proper ambient value. So, we really need to apply the bump shader ONLY to diffuse+specular.
+
+  if (PASS_TYPE == <%=Jax.Scene.AMBIENT_PASS%>) return;
+  
+  vec3 nLightDir = normalize(vLightDir);
+  vec3 nEyeDir = normalize(vEyeDir);
+  vec4 color = texture2D(NormalMap, vTexCoords);
+  vec3 map = //nMatrix * 
+             normalize(color.xyz * 2.0 - 1.0);
+             
+  float litColor = max(dot(map, nLightDir), 0.0) * vAttenuation;
+
+  // specular
+  vec3 reflectDir = reflect(nLightDir, map);
+  float spec = max(dot(nEyeDir, reflectDir), 0.0);
+  spec = pow(spec, materialShininess);
+
+  // Treat alpha in the normal map as a specular map; if it's unused it will be 1 and this
+  // won't matter.
+  spec *= color.a;
+  
+  diffuse *= litColor;
+  specular *= spec;
+}

data/builtin/shaders/normal_map/manifest.yml

@@ -0,0 +1,17 @@
+description: Maps a normal map (DOT3 bumpmap) to this material
+
+options:
+  path: "/path/to/normal_map.png"
+  flip_y: false
+  scale_x: 1.0
+  scale_y: 1.0
+  generate_mipmap: true
+  min_filter: GL_NEAREST
+  mag_filter: GL_NEAREST
+  mipmap_hint: GL_DONT_CARE
+  format: GL_RGBA
+  data_type: GL_UNSIGNED_BYTE
+  wrap_s: GL_REPEAT
+  wrap_t: GL_REPEAT
+  premultiply_alpha: false
+  colorspace_conversion: true

data/builtin/shaders/normal_map/material.js

@@ -0,0 +1,16 @@
+Jax.Material.NormalMap = Jax.Class.create(Jax.Material, {
+  initialize: function($super, map) {
+    this.map = Jax.Material.Texture.normalizeTexture(map);
+    $super({shader:"normal_map"});
+  },
+  
+  setUniforms: function($super, context, mesh, options, uniforms) {
+    $super(context, mesh, options, uniforms);
+    uniforms.texture('NormalMap', this.map, context);
+  },
+  
+  setAttributes: function($super, context, mesh, options, attributes) {
+    $super(context, mesh, options, attributes);
+    attributes.set('VERTEX_TANGENT', mesh.getTangentBuffer());
+  }
+});

data/builtin/shaders/normal_map/vertex.ejs

@@ -0,0 +1,57 @@
+shared attribute vec4 VERTEX_POSITION;
+shared attribute vec2 VERTEX_TEXCOORDS;
+shared attribute vec4 VERTEX_TANGENT;
+shared attribute vec3 VERTEX_NORMAL;
+
+void main(void) {
+  // ambient was applied by the basic shader; applying it again will simply brighten some fragments
+  // beyond their proper ambient value. So, we really need to apply the bump shader ONLY to diffuse+specular.
+
+  if (PASS_TYPE == <%=Jax.Scene.AMBIENT_PASS%>) return;
+
+  vec3 ecPosition = vec3(mvMatrix * VERTEX_POSITION);
+
+  gl_Position = pMatrix * mvMatrix * VERTEX_POSITION;
+  vTexCoords = VERTEX_TEXCOORDS;
+
+  vEyeDir = vec3(mvMatrix * VERTEX_POSITION);
+  
+  vec3 n = normalize(nMatrix * VERTEX_NORMAL);
+  vec3 t = normalize(nMatrix * VERTEX_TANGENT.xyz);
+  vec3 b = cross(n, t) * VERTEX_TANGENT.w;
+  
+  vec3 v, p;
+  
+  vAttenuation = 1.0;
+  
+  if (LIGHT_TYPE == <%=Jax.POINT_LIGHT%>)
+    if (LIGHT_ATTENUATION_CONSTANT == 1.0 && LIGHT_ATTENUATION_LINEAR == 0.0 && LIGHT_ATTENUATION_QUADRATIC == 0.0) {
+      // no change to attenuation, but we still need P
+      p = vec3(ivMatrix * vec4(LIGHT_POSITION, 1.0)) - ecPosition;
+    }
+    else {
+      // attenuation calculation figures out P for us, so we may as well use it
+      vAttenuation = calcAttenuation(ecPosition, p);
+    }
+  else
+    if (LIGHT_TYPE == <%=Jax.SPOT_LIGHT%>) {
+      // attenuation calculation figures out P for us, so we may as well use it
+      vAttenuation = calcAttenuation(ecPosition, p);
+    }
+    else
+    { // directional light -- all we need is P
+      p = vec3(vnMatrix * -normalize(LIGHT_DIRECTION));
+    }
+    
+    
+    
+  v.x = dot(p, t);
+  v.y = dot(p, b);
+  v.z = dot(p, n);
+  vLightDir = normalize(p);
+  
+  v.x = dot(vEyeDir, t);
+  v.y = dot(vEyeDir, b);
+  v.z = dot(vEyeDir, n);
+  vEyeDir = normalize(v);
+}

data/builtin/shaders/paraboloid-depthmap/common.ejs

@@ -0,0 +1,6 @@
+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;

data/builtin/shaders/paraboloid-depthmap/fragment.ejs

@@ -0,0 +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);
+}

data/builtin/shaders/paraboloid-depthmap/material.js

@@ -0,0 +1,15 @@
+Jax.Material.DualParaboloid = Jax.Class.create(Jax.Material, {
+  initialize: function($super) {
+    $super({shader:"paraboloid-depthmap"});
+  },
+  
+  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;}},
+      DP_DIRECTION: options && options.direction || 1
+    });
+  }
+});

data/builtin/shaders/paraboloid-depthmap/vertex.ejs

@@ -0,0 +1,26 @@
+shared attribute vec4 VERTEX_POSITION;
+                
+void main(void) {
+  /*
+    we do our own projection to form the paraboloid, so we
+    can ignore the projection matrix entirely.
+   */
+  vec4 pos = mvMatrix * VERTEX_POSITION;
+
+  pos = vec4(pos.xyz / pos.w, pos.w);
+
+  pos.z *= DP_DIRECTION;
+
+  float L = length(pos.xyz);
+  pos /= L;
+  vClip = pos.z;
+
+  pos.z += 1.0;
+  pos.x /= pos.z;
+  pos.y /= pos.z;
+  pos.z = (L - DP_SHADOW_NEAR) / (DP_SHADOW_FAR - DP_SHADOW_NEAR);
+  pos.w = 1.0;
+
+  vPos = pos;
+  gl_Position = pos;
+}

data/builtin/shaders/shadow_map/common.ejs

@@ -0,0 +1,14 @@
+shared uniform mat4 mMatrix;
+
+uniform bool SHADOWMAP_ENABLED;
+uniform sampler2D SHADOWMAP0, SHADOWMAP1;
+uniform mat4 SHADOWMAP_MATRIX;
+uniform bool SHADOWMAP_PCF_ENABLED;
+uniform float DP_SHADOW_NEAR, DP_SHADOW_FAR;
+
+varying vec4 vShadowCoord;
+
+varying vec4 vDP0, vDP1;
+//varying float vDPz, vDPDepth;
+
+//= require "../functions/lights"

data/builtin/shaders/shadow_map/fragment.ejs

@@ -0,0 +1,66 @@
+//= require "../functions/depth_map"
+
+float dp_lookup() {
+  float map_depth, depth;
+  vec4 rgba_depth;
+      
+  if (vDP0.w > 0.0) {
+    rgba_depth = texture2D(SHADOWMAP0, vDP0.xy);
+    depth = vDP1.w;//P0.z;
+  } else {
+    rgba_depth = texture2D(SHADOWMAP1, vDP1.xy);
+    depth = vDP1.w;//P1.z;
+  }
+      
+      
+  map_depth = unpack_depth(rgba_depth);
+      
+  if (map_depth + 0.00005 < depth) return 0.0;
+  else return 1.0;
+}
+      
+float pcf_lookup(float s, vec2 offset) {
+  /*
+    s is the projected depth of the current vShadowCoord relative to the shadow's camera. This represents
+    a *potentially* shadowed surface about to be drawn.
+    
+    d is the actual depth stored within the SHADOWMAP texture (representing the visible surface).
+  
+    if the surface to be drawn is further back than the light-visible surface, then the surface is
+    shadowed because it has a greater depth. Less-or-equal depth means it's either in front of, or it *is*
+    the light-visible surface.
+  */
+  vec2 texcoord = (vShadowCoord.xy/vShadowCoord.w)+offset;
+  vec4 rgba_depth = texture2D(SHADOWMAP0, texcoord);
+  float d = unpack_depth(rgba_depth);
+  return (s - d > 0.00002) ? 0.0 : 1.0;
+}
+
+void main(inout vec4 ambient, inout vec4 diffuse, inout vec4 specular) {
+//ambient = vec4(0);
+  if (PASS_TYPE == <%=Jax.Scene.AMBIENT_PASS%> || !SHADOWMAP_ENABLED) return;
+  float visibility = 1.0;
+  float s = vShadowCoord.z / vShadowCoord.w;
+  if (LIGHT_TYPE == <%=Jax.POINT_LIGHT%>) {
+    visibility = dp_lookup();
+  } else {
+    vec2 offset = vec2(0.0, 0.0);
+    if (!SHADOWMAP_PCF_ENABLED)
+      visibility = pcf_lookup(s, offset);
+    else {
+      // do PCF filtering
+      float dx, dy;
+      visibility = 0.0;
+      for (float dx = -1.5; dx <= 1.5; dx += 1.0)
+        for (float dy = -1.5; dy <= 1.5; dy += 1.0) {
+          offset.x = dx/2048.0;
+          offset.y = dy/2048.0;
+          visibility += pcf_lookup(s, offset);
+        }
+      visibility /= 16.0;
+    }
+  }
+
+  diffuse *= visibility;
+  specular *= visibility;
+}

data/builtin/shaders/shadow_map/manifest.yml

@@ -0,0 +1 @@
+description: Adds support for shadows cast by light sources via shadow mapping

data/builtin/shaders/shadow_map/material.js

@@ -0,0 +1,26 @@
+Jax.Material.ShadowMap = Jax.Class.create(Jax.Material, {
+  initialize: function($super) {
+    $super({shader:"shadow_map"});
+  },
+  
+  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;}},
+          
+      SHADOWMAP_PCF_ENABLED: false,
+      SHADOWMAP_MATRIX: context.world.lighting.getLight().getShadowMatrix(),
+      SHADOWMAP_ENABLED: context.world.lighting.getLight().isShadowMapEnabled()
+    });
+    
+    var light = context.world.lighting.getLight(), front, back;
+
+    front = light.getShadowMapTextures(context)[0];
+    back  = light.getShadowMapTextures(context)[1];
+    
+    if (front) uniforms.texture('SHADOWMAP0', front, context);
+    if (back)  uniforms.texture('SHADOWMAP1', back,  context);
+  }
+});

data/builtin/shaders/shadow_map/vertex.ejs

@@ -0,0 +1,46 @@
+void main(void) {
+  if (PASS_TYPE == <%=Jax.Scene.AMBIENT_PASS%> || !SHADOWMAP_ENABLED) return;
+
+  vShadowCoord = SHADOWMAP_MATRIX * mMatrix * VERTEX_POSITION;
+  
+//  if (LIGHT.type == <%=Jax.POINT_LIGHT%>) {
+    /* Perform dual-paraboloid shadow map calculations - for point lights only */
+    vec4 p = vShadowCoord;
+    vec3 pos = p.xyz / p.w;
+          
+    float L = length(pos.xyz);
+    vDP0.xyz = pos / L;
+    vDP1.xyz = pos / L;
+      
+    vDP0.w = pos.z;    
+    //vDPz = pos.z;
+          
+    vDP0.z = 1.0 + vDP0.z;
+    vDP0.x /= vDP0.z;
+    vDP0.y /= vDP0.z;
+    vDP0.z = (L - DP_SHADOW_NEAR) / (DP_SHADOW_FAR - DP_SHADOW_NEAR);
+          
+    vDP0.x =  0.5 * vDP0.x + 0.5;
+    vDP0.y =  0.5 * vDP0.y + 0.5;
+          
+    vDP1.z = 1.0 - vDP1.z;
+    vDP1.x /= vDP1.z;
+    vDP1.y /= vDP1.z;
+    vDP1.z = (L - DP_SHADOW_NEAR) / (DP_SHADOW_FAR - DP_SHADOW_NEAR);
+      
+    vDP1.x =  0.5 * vDP1.x + 0.5;
+    vDP1.y =  0.5 * vDP1.y + 0.5;
+          
+    float map_depth, depth;
+    vec4 rgba_depth;
+      
+    if (vDP0.w > 0.0) {    
+    //if (vDPz > 0.0) {
+      vDP1.w = vDP0.z;
+      //vDPDepth = vDP0.z;
+    } else {
+      vDP1.w = vDP1.z;
+      //vDPDepth = vDP1.z;
+    }
+//  }
+}

data/builtin/shaders/texture/common.ejs

@@ -0,0 +1,4 @@
+uniform sampler2D Texture;
+uniform float TextureScaleX, TextureScaleY;
+
+shared varying vec2 vTexCoords;