webruby 0.2.2 → 0.2.4

data/modules/emscripten/src/library_gl.js

@@ -11,6 +11,7 @@ var LibraryGL = {
 #endif
 
     counter: 1, // 0 is reserved as 'null' in gl
+    lastError: 0,
     buffers: [],
     programs: [],
     framebuffers: [],
@@ -40,7 +41,13 @@ var LibraryGL = {
       8  // GL_DOUBLE
     ],
 
-    uniformTable: {}, // name => uniform ID. the uID must be identical until relinking, cannot create a new uID each call to glGetUniformLocation
+    programInfos: {}, // Stores additional information needed for each shader program. Each entry is of form:
+    /* { uniforms: {}, // Maps ints back to the opaque WebGLUniformLocation objects.
+         maxUniformLength: int, // Cached in order to implement glGetProgramiv(GL_ACTIVE_UNIFORM_MAX_LENGTH)
+         maxAttributeLength: int // Cached in order to implement glGetProgramiv(GL_ACTIVE_ATTRIBUTE_MAX_LENGTH)
+       } */
+
+    stringCache: {},
 
     packAlignment: 4,   // default alignment is 4 bytes
     unpackAlignment: 4, // default alignment is 4 bytes
@@ -49,6 +56,13 @@ var LibraryGL = {
       Browser.moduleContextCreatedCallbacks.push(GL.initExtensions);
     },
 
+    // Records a GL error condition that occurred, stored until user calls glGetError() to fetch it. As per GLES2 spec, only the first error 
+    // is remembered, and subsequent errors are discarded until the user has cleared the stored error by a call to glGetError().
+    recordError: function recordError(errorCode) {
+      if (!GL.lastError) {
+        GL.lastError = errorCode;
+      }
+    },
     // Get a new ID for a texture/buffer/etc., while keeping the table dense and fast. Creation is farely rare so it is worth optimizing lookups later.
     getNewId: function(table) {
       var ret = GL.counter++;
@@ -195,6 +209,114 @@ var LibraryGL = {
                ((height - 1) * alignedRowSize + plainRowSize);
     },
 
+    get: function(name_, p, type) {
+      // Guard against user passing a null pointer.
+      // Note that GLES2 spec does not say anything about how passing a null pointer should be treated.
+      // Testing on desktop core GL 3, the application crashes on glGetIntegerv to a null pointer, but
+      // better to report an error instead of doing anything random.
+      if (!p) {
+#if GL_ASSERTIONS
+        Module.printErr('GL_INVALID_VALUE in glGet' + type + 'v(name=' + name_ + ': Function called with null out pointer!');
+#endif
+        GL.recordError(0x0501 /* GL_INVALID_VALUE */);
+        return;
+      }
+      var ret = undefined;
+      switch(name_) { // Handle a few trivial GLES values
+        case 0x8DFA: // GL_SHADER_COMPILER
+          ret = 1;
+          break;
+        case 0x8DF8: // GL_SHADER_BINARY_FORMATS
+          if (type !== 'Integer') {
+            GL.recordError(0x0500); // GL_INVALID_ENUM
+#if GL_ASSERTIONS
+            Module.printErr('GL_INVALID_ENUM in glGet' + type + 'v(GL_SHADER_BINARY_FORMATS): Invalid parameter type!');
+#endif
+          }
+          return; // Do not write anything to the out pointer, since no binary formats are supported.
+        case 0x8DF9: // GL_NUM_SHADER_BINARY_FORMATS
+          ret = 0;
+          break;
+        case 0x86A2: // GL_NUM_COMPRESSED_TEXTURE_FORMATS
+          // WebGL doesn't have GL_NUM_COMPRESSED_TEXTURE_FORMATS (it's obsolete since GL_COMPRESSED_TEXTURE_FORMATS returns a JS array that can be queried for length),
+          // so implement it ourselves to allow C++ GLES2 code get the length.
+          var formats = Module.ctx.getParameter(0x86A3 /*GL_COMPRESSED_TEXTURE_FORMATS*/);
+          ret = formats.length;
+          break;
+        case 0x8B9A: // GL_IMPLEMENTATION_COLOR_READ_TYPE
+          ret = 0x1401; // GL_UNSIGNED_BYTE
+          break;
+        case 0x8B9B: // GL_IMPLEMENTATION_COLOR_READ_FORMAT
+          ret = 0x1908; // GL_RGBA
+          break;
+      }
+
+      if (ret === undefined) {
+        var result = Module.ctx.getParameter(name_);
+        switch (typeof(result)) {
+          case "number":
+            ret = result;
+            break;
+          case "boolean":
+            ret = result ? 1 : 0;
+            break;
+          case "string":
+            GL.recordError(0x0500); // GL_INVALID_ENUM
+#if GL_ASSERTIONS
+            Module.printErr('GL_INVALID_ENUM in glGet' + type + 'v(' + name_ + ') on a name which returns a string!');
+#endif
+            return;
+          case "object":
+            if (result === null) {
+              GL.recordError(0x0500); // GL_INVALID_ENUM
+#if GL_ASSERTIONS
+              Module.printErr('GL_INVALID_ENUM in glGet' + type + 'v(' + name_ + ') and it returns null!');
+#endif
+              return;
+            } else if (result instanceof Float32Array ||
+                       result instanceof Uint32Array ||
+                       result instanceof Int32Array ||
+                       result instanceof Array) {
+              for (var i = 0; i < result.length; ++i) {
+                switch (type) {
+                  case 'Integer': {{{ makeSetValue('p', 'i*4', 'result[i]',     'i32') }}};   break;
+                  case 'Float':   {{{ makeSetValue('p', 'i*4', 'result[i]',     'float') }}}; break;
+                  case 'Boolean': {{{ makeSetValue('p', 'i',   'result[i] ? 1 : 0', 'i8') }}};    break;
+                  default: throw 'internal glGet error, bad type: ' + type;
+                }
+              }
+              return;
+            } else if (result instanceof WebGLBuffer ||
+                       result instanceof WebGLProgram ||
+                       result instanceof WebGLFramebuffer ||
+                       result instanceof WebGLRenderbuffer ||
+                       result instanceof WebGLTexture) {
+              ret = result.name | 0;
+            } else {
+              GL.recordError(0x0500); // GL_INVALID_ENUM
+#if GL_ASSERTIONS
+              Module.printErr('GL_INVALID_ENUM in glGet' + type + 'v: Unknown object returned from WebGL getParameter(' + name_ + ')!');
+#endif
+              return;
+            }
+            break;
+          default:
+            GL.recordError(0x0500); // GL_INVALID_ENUM
+#if GL_ASSERTIONS
+            Module.printErr('GL_INVALID_ENUM in glGetIntegerv: Native code calling glGet' + type + 'v(' + name_ + ') and it returns ' + result + ' of type ' + typeof(result) + '!');
+#endif
+            return;
+        }
+      }
+
+      switch (type) {
+        case 'Integer': {{{ makeSetValue('p', '0', 'ret', 'i32') }}};    break;
+        case 'Float':   {{{ makeSetValue('p', '0', 'ret', 'float') }}};  break;
+        case 'Boolean': {{{ makeSetValue('p', '0', 'ret ? 1 : 0', 'i8') }}}; break;
+        default: throw 'internal glGet error, bad type: ' + type;
+      }
+    },  
+
     getTexPixelData: function(type, format, width, height, pixels, internalFormat) {
       var sizePerPixel;
       switch (type) {
@@ -240,7 +362,9 @@ var LibraryGL = {
           sizePerPixel = 2;
           break;
         case 0x1406 /* GL_FLOAT */:
+#if ASSERTIONS
           assert(GL.floatExt, 'Must have OES_texture_float to use float textures');
+#endif
           switch (format) {
             case 0x1907 /* GL_RGB */:
               sizePerPixel = 3*4;
@@ -272,8 +396,24 @@ var LibraryGL = {
       }
     },
 
+#if GL_FFP_ONLY
+    enabledClientAttribIndices: [],
+    enableVertexAttribArray: function enableVertexAttribArray(index) {
+      if (!GL.enabledClientAttribIndices[index]) {
+        GL.enabledClientAttribIndices[index] = true;
+        Module.ctx.enableVertexAttribArray(index);
+      }
+    },
+    disableVertexAttribArray: function disableVertexAttribArray(index) {
+      if (GL.enabledClientAttribIndices[index]) {
+        GL.enabledClientAttribIndices[index] = false;
+        Module.ctx.disableVertexAttribArray(index);
+      }
+    },
+#endif
+
 #if FULL_ES2
-    calcBufLength: function(size, type, stride, count) {
+    calcBufLength: function calcBufLength(size, type, stride, count) {
       if (stride > 0) {
         return count * stride;  // XXXvlad this is not exactly correct I don't think
       }
@@ -283,7 +423,7 @@ var LibraryGL = {
 
     usedTempBuffers: [],
 
-    preDrawHandleClientVertexAttribBindings: function(count) {
+    preDrawHandleClientVertexAttribBindings: function preDrawHandleClientVertexAttribBindings(count) {
       GL.resetBufferBinding = false;
 
       var used = GL.usedTempBuffers;
@@ -317,7 +457,7 @@ var LibraryGL = {
       }
     },
 
-    postDrawHandleClientVertexAttribBindings: function() {
+    postDrawHandleClientVertexAttribBindings: function postDrawHandleClientVertexAttribBindings() {
       if (GL.resetBufferBinding) {
         Module.ctx.bindBuffer(Module.ctx.ARRAY_BUFFER, GL.buffers[GL.currArrayBuffer]);
       }
@@ -451,15 +591,23 @@ var LibraryGL = {
       GL.validateGLObjectID(GL.programs, program, 'populateUniformTable', 'program');
 #endif
       var p = GL.programs[program];
-      GL.uniformTable[program] = {};
-      var ptable = GL.uniformTable[program];
-      // A program's uniformTable maps the string name of an uniform to an integer location of that uniform.
+      GL.programInfos[program] = {
+        uniforms: {},
+        maxUniformLength: 0, // This is eagerly computed below, since we already enumerate all uniforms anyway.
+        maxAttributeLength: -1 // This is lazily computed and cached, computed when/if first asked, "-1" meaning not computed yet.
+      };
+
+      var ptable = GL.programInfos[program];
+      var utable = ptable.uniforms;
+      // A program's uniform table maps the string name of an uniform to an integer location of that uniform.
       // The global GL.uniforms map maps integer locations to WebGLUniformLocations.
       var numUniforms = Module.ctx.getProgramParameter(p, Module.ctx.ACTIVE_UNIFORMS);
       for (var i = 0; i < numUniforms; ++i) {
         var u = Module.ctx.getActiveUniform(p, i);
 
         var name = u.name;
+        ptable.maxUniformLength = Math.max(ptable.maxUniformLength, name.length+1);
+
         // Strip off any trailing array specifier we might have got, e.g. "[0]".
         if (name.indexOf(']', name.length-1) !== -1) {
           var ls = name.lastIndexOf('[');
@@ -467,11 +615,11 @@ var LibraryGL = {
         }
 
         // Optimize memory usage slightly: If we have an array of uniforms, e.g. 'vec3 colors[3];', then 
-        // only store the string 'colors' in ptable, and 'colors[0]', 'colors[1]' and 'colors[2]' will be parsed as 'colors'+i.
+        // only store the string 'colors' in utable, and 'colors[0]', 'colors[1]' and 'colors[2]' will be parsed as 'colors'+i.
         // Note that for the GL.uniforms table, we still need to fetch the all WebGLUniformLocations for all the indices.
         var loc = Module.ctx.getUniformLocation(p, name);
         var id = GL.getNewId(GL.uniforms);
-        ptable[name] = [u.size, id];
+        utable[name] = [u.size, id];
         GL.uniforms[id] = loc;
 
         for (var j = 1; j < u.size; ++j) {
@@ -497,11 +645,14 @@ var LibraryGL = {
 
   glGetString__sig: 'ii',
   glGetString: function(name_) {
+    if (GL.stringCache[name_]) return GL.stringCache[name_];
+    var ret; 
     switch(name_) {
       case 0x1F00 /* GL_VENDOR */:
       case 0x1F01 /* GL_RENDERER */:
       case 0x1F02 /* GL_VERSION */:
-        return allocate(intArrayFromString(Module.ctx.getParameter(name_)), 'i8', ALLOC_NORMAL);
+        ret = allocate(intArrayFromString(Module.ctx.getParameter(name_)), 'i8', ALLOC_NORMAL);
+        break;
       case 0x1F03 /* GL_EXTENSIONS */:
         var exts = Module.ctx.getSupportedExtensions();
         var gl_exts = [];
@@ -509,151 +660,35 @@ var LibraryGL = {
           gl_exts.push(exts[i]);
           gl_exts.push("GL_" + exts[i]);
         }
-        return allocate(intArrayFromString(gl_exts.join(' ')), 'i8', ALLOC_NORMAL); // XXX this leaks! TODO: Cache all results like this in library_gl.js to be clean and nice and avoid leaking.
+        ret = allocate(intArrayFromString(gl_exts.join(' ')), 'i8', ALLOC_NORMAL);
+        break;
       case 0x8B8C /* GL_SHADING_LANGUAGE_VERSION */:
-        return allocate(intArrayFromString('OpenGL ES GLSL 1.00 (WebGL)'), 'i8', ALLOC_NORMAL);
+        ret = allocate(intArrayFromString('OpenGL ES GLSL 1.00 (WebGL)'), 'i8', ALLOC_NORMAL);
+        break;
       default:
-        throw 'Failure: Invalid glGetString value: ' + name_;
+        GL.recordError(0x0500/*GL_INVALID_ENUM*/);
+#if GL_ASSERTIONS
+        Module.printErr('GL_INVALID_ENUM in glGetString: Unknown parameter ' + name_ + '!');
+#endif
+        return 0;
     }
+    GL.stringCache[name_] = ret;
+    return ret;
   },
 
   glGetIntegerv__sig: 'vii',
   glGetIntegerv: function(name_, p) {
-    switch(name_) { // Handle a few trivial GLES values
-      case 0x8DFA: // GL_SHADER_COMPILER
-        {{{ makeSetValue('p', '0', '1', 'i32') }}};
-        return;
-      case 0x8DF9: // GL_NUM_SHADER_BINARY_FORMATS
-        {{{ makeSetValue('p', '0', '0', 'i32') }}};
-        return;
-      case 0x86A2: // GL_NUM_COMPRESSED_TEXTURE_FORMATS
-        // WebGL doesn't have GL_NUM_COMPRESSED_TEXTURE_FORMATS (it's obsolete since GL_COMPRESSED_TEXTURE_FORMATS returns a JS array that can be queried for length),
-        // so implement it ourselves to allow C++ GLES2 code get the length.
-        var formats = Module.ctx.getParameter(0x86A3 /*GL_COMPRESSED_TEXTURE_FORMATS*/);
-        {{{ makeSetValue('p', '0', 'formats.length', 'i32') }}};
-        return;
-    }
-    var result = Module.ctx.getParameter(name_);
-    switch (typeof(result)) {
-      case "number":
-        {{{ makeSetValue('p', '0', 'result', 'i32') }}};
-        break;
-      case "boolean":
-        {{{ makeSetValue('p', '0', 'result ? 1 : 0', 'i8') }}};
-        break;
-      case "string":
-        throw 'Native code calling glGetIntegerv(' + name_ + ') on a name which returns a string!';
-      case "object":
-        if (result === null) {
-          {{{ makeSetValue('p', '0', '0', 'i32') }}};
-        } else if (result instanceof Float32Array ||
-                   result instanceof Uint32Array ||
-                   result instanceof Int32Array ||
-                   result instanceof Array) {
-          for (var i = 0; i < result.length; ++i) {
-            {{{ makeSetValue('p', 'i*4', 'result[i]', 'i32') }}};
-          }
-        } else if (result instanceof WebGLBuffer) {
-          {{{ makeSetValue('p', '0', 'result.name | 0', 'i32') }}};
-        } else if (result instanceof WebGLProgram) {
-          {{{ makeSetValue('p', '0', 'result.name | 0', 'i32') }}};
-        } else if (result instanceof WebGLFramebuffer) {
-          {{{ makeSetValue('p', '0', 'result.name | 0', 'i32') }}};
-        } else if (result instanceof WebGLRenderbuffer) {
-          {{{ makeSetValue('p', '0', 'result.name | 0', 'i32') }}};
-        } else if (result instanceof WebGLTexture) {
-          {{{ makeSetValue('p', '0', 'result.name | 0', 'i32') }}};
-        } else {
-          throw 'Unknown object returned from WebGL getParameter';
-        }
-        break;
-      case "undefined":
-        throw 'Native code calling glGetIntegerv(' + name_ + ') and it returns undefined';
-      default:
-        throw 'Why did we hit the default case?';
-    }
+    return GL.get(name_, p, 'Integer');
   },
 
   glGetFloatv__sig: 'vii',
   glGetFloatv: function(name_, p) {
-    var result = Module.ctx.getParameter(name_);
-    switch (typeof(result)) {
-      case "number":
-        {{{ makeSetValue('p', '0', 'result', 'float') }}};
-        break;
-      case "boolean":
-        {{{ makeSetValue('p', '0', 'result ? 1.0 : 0.0', 'float') }}};
-        break;
-      case "string":
-          {{{ makeSetValue('p', '0', '0', 'float') }}};
-      case "object":
-        if (result === null) {
-          throw 'Native code calling glGetFloatv(' + name_ + ') and it returns null';
-        } else if (result instanceof Float32Array ||
-                   result instanceof Uint32Array ||
-                   result instanceof Int32Array ||
-                   result instanceof Array) {
-          for (var i = 0; i < result.length; ++i) {
-            {{{ makeSetValue('p', 'i*4', 'result[i]', 'float') }}};
-          }
-        } else if (result instanceof WebGLBuffer) {
-          {{{ makeSetValue('p', '0', 'result.name | 0', 'float') }}};
-        } else if (result instanceof WebGLProgram) {
-          {{{ makeSetValue('p', '0', 'result.name | 0', 'float') }}};
-        } else if (result instanceof WebGLFramebuffer) {
-          {{{ makeSetValue('p', '0', 'result.name | 0', 'float') }}};
-        } else if (result instanceof WebGLRenderbuffer) {
-          {{{ makeSetValue('p', '0', 'result.name | 0', 'float') }}};
-        } else if (result instanceof WebGLTexture) {
-          {{{ makeSetValue('p', '0', 'result.name | 0', 'float') }}};
-        } else {
-          throw 'Unknown object returned from WebGL getParameter';
-        }
-        break;
-      case "undefined":
-        throw 'Native code calling glGetFloatv(' + name_ + ') and it returns undefined';
-      default:
-        throw 'Why did we hit the default case?';
-    }
+    return GL.get(name_, p, 'Float');
   },
 
   glGetBooleanv__sig: 'vii',
   glGetBooleanv: function(name_, p) {
-    var result = Module.ctx.getParameter(name_);
-    switch (typeof(result)) {
-      case "number":
-        {{{ makeSetValue('p', '0', 'result != 0', 'i8') }}};
-        break;
-      case "boolean":
-        {{{ makeSetValue('p', '0', 'result != 0', 'i8') }}};
-        break;
-      case "string":
-        throw 'Native code calling glGetBooleanv(' + name_ + ') on a name which returns a string!';
-      case "object":
-        if (result === null) {
-          {{{ makeSetValue('p', '0', '0', 'i8') }}};
-        } else if (result instanceof Float32Array ||
-                   result instanceof Uint32Array ||
-                   result instanceof Int32Array ||
-                   result instanceof Array) {
-          for (var i = 0; i < result.length; ++i) {
-            {{{ makeSetValue('p', 'i', 'result[i] != 0', 'i8') }}};
-          }
-        } else if (result instanceof WebGLBuffer ||
-                   result instanceof WebGLProgram ||
-                   result instanceof WebGLFramebuffer ||
-                   result instanceof WebGLRenderbuffer ||
-                   result instanceof WebGLTexture) {
-          {{{ makeSetValue('p', '0', '1', 'i8') }}}; // non-zero ID is always 1!
-        } else {
-          throw 'Unknown object returned from WebGL getParameter';
-        }
-        break;
-      case "undefined":
-          throw 'Unknown object returned from WebGL getParameter';
-      default:
-        throw 'Why did we hit the default case?';
-    }
+    return GL.get(name_, p, 'Boolean');
   },
 
   glGenTextures__sig: 'vii',
@@ -680,7 +715,9 @@ var LibraryGL = {
 
   glCompressedTexImage2D__sig: 'viiiiiiii',
   glCompressedTexImage2D: function(target, level, internalFormat, width, height, border, imageSize, data) {
+#if ASSERTIONS
     assert(GL.compressionExt);
+#endif
     if (data) {
       data = {{{ makeHEAPView('U8', 'data', 'data+imageSize') }}};
     } else {
@@ -691,7 +728,9 @@ var LibraryGL = {
 
   glCompressedTexSubImage2D__sig: 'viiiiiiiii',
   glCompressedTexSubImage2D: function(target, level, xoffset, yoffset, width, height, format, imageSize, data) {
+#if ASSERTIONS
     assert(GL.compressionExt);
+#endif
     if (data) {
       data = {{{ makeHEAPView('U8', 'data', 'data+imageSize') }}};
     } else {
@@ -725,7 +764,9 @@ var LibraryGL = {
 
   glReadPixels__sig: 'viiiiiii',
   glReadPixels: function(x, y, width, height, format, type, pixels) {
+#if ASSERTIONS
     assert(type == 0x1401 /* GL_UNSIGNED_BYTE */);
+#endif
     var sizePerPixel;
     switch (format) {
       case 0x1907 /* GL_RGB */:
@@ -734,7 +775,12 @@ var LibraryGL = {
       case 0x1908 /* GL_RGBA */:
         sizePerPixel = 4;
         break;
-      default: throw 'unsupported glReadPixels format';
+      default: 
+        GL.recordError(0x0500/*GL_INVALID_ENUM*/);
+#if GL_ASSERTIONS
+        Module.printErr('GL_INVALID_ENUM in glReadPixels: Unsupported format ' + format + '!');
+#endif
+        return;
     }
     var totalSize = width*height*sizePerPixel;
     Module.ctx.readPixels(x, y, width, height, format, type, HEAPU8.subarray(pixels, pixels + totalSize));
@@ -938,11 +984,12 @@ var LibraryGL = {
       name = name.slice(0, ls);
     }
 
-    var ptable = GL.uniformTable[program];
+    var ptable = GL.programInfos[program];
     if (!ptable) {
       return -1;
     }
-    var uniformInfo = ptable[name]; // returns pair [ dimension_of_uniform_array, uniform_location ]
+    var utable = ptable.uniforms;
+    var uniformInfo = utable[name]; // returns pair [ dimension_of_uniform_array, uniform_location ]
     if (uniformInfo && arrayOffset < uniformInfo[0]) { // Check if user asked for an out-of-bounds element, i.e. for 'vec4 colors[3];' user could ask for 'colors[10]' which should return -1.
       return uniformInfo[1]+arrayOffset;
     } else {
@@ -1357,7 +1404,9 @@ var LibraryGL = {
     {{{ makeSetValue('count', '0', 'len', 'i32') }}};
     for (var i = 0; i < len; ++i) {
       var id = GL.shaders.indexOf(result[i]);
+#if ASSERTIONS
       assert(id !== -1, 'shader not bound to local id');
+#endif
       {{{ makeSetValue('shaders', 'i*4', 'id', 'i32') }}};
     }
   },
@@ -1428,6 +1477,47 @@ var LibraryGL = {
 #endif
     if (pname == 0x8B84) { // GL_INFO_LOG_LENGTH
       {{{ makeSetValue('p', '0', 'Module.ctx.getProgramInfoLog(GL.programs[program]).length + 1', 'i32') }}};
+    } else if (pname == 0x8B87 /* GL_ACTIVE_UNIFORM_MAX_LENGTH */) {
+      var ptable = GL.programInfos[program];
+      if (ptable) {
+        {{{ makeSetValue('p', '0', 'ptable.maxUniformLength', 'i32') }}};
+        return;
+      } else if (program < GL.counter) {
+#if GL_ASSERTIONS
+        Module.printErr("A GL object " + program + " that is not a program object was passed to glGetProgramiv!");
+#endif
+        GL.recordError(0x0502 /* GL_INVALID_OPERATION */);
+      } else {
+#if GL_ASSERTIONS
+        Module.printErr("A GL object " + program + " that did not come from GL was passed to glGetProgramiv!");
+#endif
+        GL.recordError(0x0501 /* GL_INVALID_VALUE */);
+      }
+    } else if (pname == 0x8B8A /* GL_ACTIVE_ATTRIBUTE_MAX_LENGTH */) {
+      var ptable = GL.programInfos[program];
+      if (ptable) {
+        if (ptable.maxAttributeLength == -1) {
+          var program = GL.programs[program];
+          var numAttribs = Module.ctx.getProgramParameter(program, Module.ctx.ACTIVE_ATTRIBUTES);
+          ptable.maxAttributeLength = 0; // Spec says if there are no active attribs, 0 must be returned.
+          for(var i = 0; i < numAttribs; ++i) {
+            var activeAttrib = Module.ctx.getActiveAttrib(program, i);
+            ptable.maxAttributeLength = Math.max(ptable.maxAttributeLength, activeAttrib.name.length+1);
+          }
+        }
+        {{{ makeSetValue('p', '0', 'ptable.maxAttributeLength', 'i32') }}};
+        return;
+      } else if (program < GL.counter) {
+#if GL_ASSERTIONS
+        Module.printErr("A GL object " + program + " that is not a program object was passed to glGetProgramiv!");
+#endif
+        GL.recordError(0x0502 /* GL_INVALID_OPERATION */);
+      } else {
+#if GL_ASSERTIONS
+        Module.printErr("A GL object " + program + " that did not come from GL was passed to glGetProgramiv!");
+#endif
+        GL.recordError(0x0501 /* GL_INVALID_VALUE */);
+      }
     } else {
       {{{ makeSetValue('p', '0', 'Module.ctx.getProgramParameter(GL.programs[program], pname)', 'i32') }}};
     }
@@ -1455,7 +1545,7 @@ var LibraryGL = {
     Module.ctx.deleteProgram(program);
     program.name = 0;
     GL.programs[program] = null;
-    GL.uniformTable[program] = null;
+    GL.programInfos[program] = null;
   },
 
   glAttachShader__sig: 'vii',
@@ -1491,7 +1581,7 @@ var LibraryGL = {
     GL.validateGLObjectID(GL.programs, program, 'glLinkProgram', 'program');
 #endif
     Module.ctx.linkProgram(GL.programs[program]);
-    GL.uniformTable[program] = {}; // uniforms no longer keep the same names after linking
+    GL.programInfos[program] = null; // uniforms no longer keep the same names after linking
     GL.populateUniformTable(program);
   },
 
@@ -1645,7 +1735,7 @@ var LibraryGL = {
 
       // Add some emulation workarounds
       Module.printErr('WARNING: using emscripten GL emulation. This is a collection of limited workarounds, do not expect it to work.');
-#if GL_UNSAFE_OPTS == 0
+#if GL_UNSAFE_OPTS == 1
       Module.printErr('WARNING: using emscripten GL emulation unsafe opts. If weirdness happens, try -s GL_UNSAFE_OPTS=0');
 #endif
 
@@ -1663,7 +1753,7 @@ var LibraryGL = {
       };
 
       var glEnable = _glEnable;
-      _glEnable = function(cap) {
+      _glEnable = function _glEnable(cap) {
         // Clean up the renderer on any change to the rendering state. The optimization of
         // skipping renderer setup is aimed at the case of multiple glDraw* right after each other
         if (GL.immediate.lastRenderer) GL.immediate.lastRenderer.cleanup();
@@ -1685,7 +1775,7 @@ var LibraryGL = {
       };
 
       var glDisable = _glDisable;
-      _glDisable = function(cap) {
+      _glDisable = function _glDisable(cap) {
         if (GL.immediate.lastRenderer) GL.immediate.lastRenderer.cleanup();
         if (cap == 0x0B60 /* GL_FOG */) {
           GLEmulation.fogEnabled = false;
@@ -1703,7 +1793,7 @@ var LibraryGL = {
         }
         glDisable(cap);
       };
-      _glIsEnabled = function(cap) {
+      _glIsEnabled = function _glIsEnabled(cap) {
         if (cap == 0x0B60 /* GL_FOG */) {
           return GLEmulation.fogEnabled ? 1 : 0;
         } else if (!(cap in validCapabilities)) {
@@ -1713,7 +1803,7 @@ var LibraryGL = {
       };
 
       var glGetBooleanv = _glGetBooleanv;
-      _glGetBooleanv = function(pname, p) {
+      _glGetBooleanv = function _glGetBooleanv(pname, p) {
         var attrib = GLEmulation.getAttributeFromCapability(pname);
         if (attrib !== null) {
           var result = GL.immediate.enabledClientAttributes[attrib];
@@ -1724,7 +1814,7 @@ var LibraryGL = {
       };
 
       var glGetIntegerv = _glGetIntegerv;
-      _glGetIntegerv = function(pname, params) {
+      _glGetIntegerv = function _glGetIntegerv(pname, params) {
         switch (pname) {
           case 0x84E2: pname = Module.ctx.MAX_TEXTURE_IMAGE_UNITS /* fake it */; break; // GL_MAX_TEXTURE_UNITS
           case 0x8B4A: { // GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB
@@ -1774,17 +1864,17 @@ var LibraryGL = {
             return;
           }
           case 0x8088: { // GL_TEXTURE_COORD_ARRAY_SIZE
-            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0];
+            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture];
             {{{ makeSetValue('params', '0', 'attribute ? attribute.size : 0', 'i32') }}};
             return;
           }
           case 0x8089: { // GL_TEXTURE_COORD_ARRAY_TYPE
-            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0];
+            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture];
             {{{ makeSetValue('params', '0', 'attribute ? attribute.type : 0', 'i32') }}};
             return;
           }
           case 0x808A: { // GL_TEXTURE_COORD_ARRAY_STRIDE
-            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0];
+            var attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture];
             {{{ makeSetValue('params', '0', 'attribute ? attribute.stride : 0', 'i32') }}};
             return;
           }
@@ -1793,14 +1883,17 @@ var LibraryGL = {
       };
 
       var glGetString = _glGetString;
-      _glGetString = function(name_) {
+      _glGetString = function _glGetString(name_) {
+        if (GL.stringCache[name_]) return GL.stringCache[name_];
         switch(name_) {
           case 0x1F03 /* GL_EXTENSIONS */: // Add various extensions that we can support
-            return allocate(intArrayFromString(Module.ctx.getSupportedExtensions().join(' ') +
+            var ret = allocate(intArrayFromString(Module.ctx.getSupportedExtensions().join(' ') +
                    ' GL_EXT_texture_env_combine GL_ARB_texture_env_crossbar GL_ATI_texture_env_combine3 GL_NV_texture_env_combine4 GL_EXT_texture_env_dot3 GL_ARB_multitexture GL_ARB_vertex_buffer_object GL_EXT_framebuffer_object GL_ARB_vertex_program GL_ARB_fragment_program GL_ARB_shading_language_100 GL_ARB_shader_objects GL_ARB_vertex_shader GL_ARB_fragment_shader GL_ARB_texture_cube_map GL_EXT_draw_range_elements' +
                    (GL.compressionExt ? ' GL_ARB_texture_compression GL_EXT_texture_compression_s3tc' : '') +
                    (GL.anisotropicExt ? ' GL_EXT_texture_filter_anisotropic' : '')
             ), 'i8', ALLOC_NORMAL);
+            GL.stringCache[name_] = ret;
+            return ret;
         }
         return glGetString(name_);
       };
@@ -1814,7 +1907,7 @@ var LibraryGL = {
       GL.shaderOriginalSources = {};
 #endif
       var glCreateShader = _glCreateShader;
-      _glCreateShader = function(shaderType) {
+      _glCreateShader = function _glCreateShader(shaderType) {
         var id = glCreateShader(shaderType);
         GL.shaderInfos[id] = {
           type: shaderType,
@@ -1824,7 +1917,7 @@ var LibraryGL = {
       };
 
       var glShaderSource = _glShaderSource;
-      _glShaderSource = function(shader, count, string, length) {
+      _glShaderSource = function _glShaderSource(shader, count, string, length) {
         var source = GL.getSource(shader, count, string, length);
 #if GL_DEBUG
         console.log("glShaderSource: Input: \n" + source);
@@ -1937,7 +2030,7 @@ var LibraryGL = {
       };
 
       var glCompileShader = _glCompileShader;
-      _glCompileShader = function(shader) {
+      _glCompileShader = function _glCompileShader(shader) {
         Module.ctx.compileShader(GL.shaders[shader]);
 #if GL_DEBUG
         if (!Module.ctx.getShaderParameter(GL.shaders[shader], Module.ctx.COMPILE_STATUS)) {
@@ -1952,14 +2045,14 @@ var LibraryGL = {
 
       GL.programShaders = {};
       var glAttachShader = _glAttachShader;
-      _glAttachShader = function(program, shader) {
+      _glAttachShader = function _glAttachShader(program, shader) {
         if (!GL.programShaders[program]) GL.programShaders[program] = [];
         GL.programShaders[program].push(shader);
         glAttachShader(program, shader);
       };
 
       var glDetachShader = _glDetachShader;
-      _glDetachShader = function(program, shader) {
+      _glDetachShader = function _glDetachShader(program, shader) {
         var programShader = GL.programShaders[program];
         if (!programShader) {
           Module.printErr('WARNING: _glDetachShader received invalid program: ' + program);
@@ -1971,7 +2064,7 @@ var LibraryGL = {
       };
 
       var glUseProgram = _glUseProgram;
-      _glUseProgram = function(program) {
+      _glUseProgram = function _glUseProgram(program) {
 #if GL_DEBUG
         if (GL.debug) {
           Module.printErr('[using program with shaders]');
@@ -1983,12 +2076,15 @@ var LibraryGL = {
           }
         }
 #endif
-        GL.currProgram = program;
+        if (GL.currProgram != program) {
+          GL.currentRenderer = null; // This changes the FFP emulation shader program, need to recompute that.
+          GL.currProgram = program;
+        }
         glUseProgram(program);
       }
 
       var glDeleteProgram = _glDeleteProgram;
-      _glDeleteProgram = function(program) {
+      _glDeleteProgram = function _glDeleteProgram(program) {
         glDeleteProgram(program);
         if (program == GL.currProgram) GL.currProgram = 0;
       };
@@ -1996,12 +2092,12 @@ var LibraryGL = {
       // If attribute 0 was not bound, bind it to 0 for WebGL performance reasons. Track if 0 is free for that.
       var zeroUsedPrograms = {};
       var glBindAttribLocation = _glBindAttribLocation;
-      _glBindAttribLocation = function(program, index, name) {
+      _glBindAttribLocation = function _glBindAttribLocation(program, index, name) {
         if (index == 0) zeroUsedPrograms[program] = true;
         glBindAttribLocation(program, index, name);
       };
       var glLinkProgram = _glLinkProgram;
-      _glLinkProgram = function(program) {
+      _glLinkProgram = function _glLinkProgram(program) {
         if (!(program in zeroUsedPrograms)) {
           Module.ctx.bindAttribLocation(GL.programs[program], 0, 'a_position');
         }
@@ -2009,11 +2105,13 @@ var LibraryGL = {
       };
 
       var glBindBuffer = _glBindBuffer;
-      _glBindBuffer = function(target, buffer) {
+      _glBindBuffer = function _glBindBuffer(target, buffer) {
         glBindBuffer(target, buffer);
         if (target == Module.ctx.ARRAY_BUFFER) {
           if (GLEmulation.currentVao) {
+#if ASSERTIONS
             assert(GLEmulation.currentVao.arrayBuffer == buffer || GLEmulation.currentVao.arrayBuffer == 0 || buffer == 0, 'TODO: support for multiple array buffers in vao');
+#endif
             GLEmulation.currentVao.arrayBuffer = buffer;
           }
         } else if (target == Module.ctx.ELEMENT_ARRAY_BUFFER) {
@@ -2022,7 +2120,7 @@ var LibraryGL = {
       };
 
       var glGetFloatv = _glGetFloatv;
-      _glGetFloatv = function(pname, params) {
+      _glGetFloatv = function _glGetFloatv(pname, params) {
         if (pname == 0x0BA6) { // GL_MODELVIEW_MATRIX
           HEAPF32.set(GL.immediate.matrix['m'], params >> 2);
         } else if (pname == 0x0BA7) { // GL_PROJECTION_MATRIX
@@ -2045,7 +2143,7 @@ var LibraryGL = {
       };
 
       var glHint = _glHint;
-      _glHint = function(target, mode) {
+      _glHint = function _glHint(target, mode) {
         if (target == 0x84EF) { // GL_TEXTURE_COMPRESSION_HINT
           return;
         }
@@ -2053,21 +2151,21 @@ var LibraryGL = {
       };
 
       var glEnableVertexAttribArray = _glEnableVertexAttribArray;
-      _glEnableVertexAttribArray = function(index) {
+      _glEnableVertexAttribArray = function _glEnableVertexAttribArray(index) {
         glEnableVertexAttribArray(index);
         GLEmulation.enabledVertexAttribArrays[index] = 1;
         if (GLEmulation.currentVao) GLEmulation.currentVao.enabledVertexAttribArrays[index] = 1;
       };
 
       var glDisableVertexAttribArray = _glDisableVertexAttribArray;
-      _glDisableVertexAttribArray = function(index) {
+      _glDisableVertexAttribArray = function _glDisableVertexAttribArray(index) {
         glDisableVertexAttribArray(index);
         delete GLEmulation.enabledVertexAttribArrays[index];
         if (GLEmulation.currentVao) delete GLEmulation.currentVao.enabledVertexAttribArrays[index];
       };
 
       var glVertexAttribPointer = _glVertexAttribPointer;
-      _glVertexAttribPointer = function(index, size, type, normalized, stride, pointer) {
+      _glVertexAttribPointer = function _glVertexAttribPointer(index, size, type, normalized, stride, pointer) {
         glVertexAttribPointer(index, size, type, normalized, stride, pointer);
         if (GLEmulation.currentVao) { // TODO: avoid object creation here? likely not hot though
           GLEmulation.currentVao.vertexAttribPointers[index] = [index, size, type, normalized, stride, pointer];
@@ -2099,9 +2197,6 @@ var LibraryGL = {
   glGetShaderPrecisionFormat__sig: 'v',
   glGetShaderPrecisionFormat: function() { throw 'glGetShaderPrecisionFormat: TODO' },
 
-  glShaderBinary__sig: 'v',
-  glShaderBinary: function() { throw 'glShaderBinary: TODO' },
-
   glDeleteObject__sig: 'vi',
   glDeleteObject: function(id) {
     if (GL.programs[id]) {
@@ -2113,11 +2208,6 @@ var LibraryGL = {
     }
   },
 
-  glReleaseShaderCompiler__sig: 'v',
-  glReleaseShaderCompiler: function() {
-    // NOP (as allowed by GLES 2.0 spec)
-  },
-
   glGetObjectParameteriv__sig: 'viii',
   glGetObjectParameteriv: function(id, type, result) {
     if (GL.programs[id]) {
@@ -2153,7 +2243,9 @@ var LibraryGL = {
 
   glBindProgram__sig: 'vii',
   glBindProgram: function(type, id) {
+#if ASSERTIONS
     assert(id == 0);
+#endif
   },
 
   glGetPointerv: function(name, p) {
@@ -2164,8 +2256,13 @@ var LibraryGL = {
       case 0x8090: // GL_COLOR_ARRAY_POINTER
         attribute = GLImmediate.clientAttributes[GLImmediate.COLOR]; break;
       case 0x8092: // GL_TEXTURE_COORD_ARRAY_POINTER
-        attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0]; break;
-      default: throw 'TODO: glGetPointerv for ' + name;
+        attribute = GLImmediate.clientAttributes[GLImmediate.TEXTURE0 + GLImmediate.clientActiveTexture]; break;
+      default:
+        GL.recordError(0x0500/*GL_INVALID_ENUM*/);
+#if GL_ASSERTIONS
+        Module.printErr('GL_INVALID_ENUM in glGetPointerv: Unsupported name ' + name + '!');
+#endif
+        return;
     }
     {{{ makeSetValue('p', '0', 'attribute ? attribute.pointer : 0', 'i32') }}};
   },
@@ -2186,14 +2283,14 @@ var LibraryGL = {
       function CNaiveListMap() {
         var list = [];
 
-        this.insert = function(key, val) {
+        this.insert = function CNaiveListMap_insert(key, val) {
           if (this.contains(key|0)) return false;
           list.push([key, val]);
           return true;
         };
 
         var __contains_i;
-        this.contains = function(key) {
+        this.contains = function CNaiveListMap_contains(key) {
           for (__contains_i = 0; __contains_i < list.length; ++__contains_i) {
             if (list[__contains_i][0] === key) return true;
           }
@@ -2201,7 +2298,7 @@ var LibraryGL = {
         };
 
         var __get_i;
-        this.get = function(key) {
+        this.get = function CNaiveListMap_get(key) {
           for (__get_i = 0; __get_i < list.length; ++__get_i) {
             if (list[__get_i][0] === key) return list[__get_i][1];
           }
@@ -2235,7 +2332,7 @@ var LibraryGL = {
         function CNLNode() {
           var map = new CNaiveListMap();
 
-          this.child = function(keyFrag) {
+          this.child = function CNLNode_child(keyFrag) {
             if (!map.contains(keyFrag|0)) {
               map.insert(keyFrag|0, new CNLNode());
             }
@@ -2243,11 +2340,11 @@ var LibraryGL = {
           };
 
           this.value = undefined;
-          this.get = function() {
+          this.get = function CNLNode_get() {
             return this.value;
           };
 
-          this.set = function(val) {
+          this.set = function CNLNode_set(val) {
             this.value = val;
           };
         }
@@ -2255,22 +2352,22 @@ var LibraryGL = {
         function CKeyView(root) {
           var cur;
 
-          this.reset = function() {
+          this.reset = function CKeyView_reset() {
             cur = root;
             return this;
           };
           this.reset();
 
-          this.next = function(keyFrag) {
+          this.next = function CKeyView_next(keyFrag) {
             cur = cur.child(keyFrag);
             return this;
           };
 
-          this.get = function() {
+          this.get = function CKeyView_get() {
             return cur.get();
           };
 
-          this.set = function(val) {
+          this.set = function CKeyView_set(val) {
             cur.set(val);
           };
         };
@@ -2278,17 +2375,17 @@ var LibraryGL = {
         var root;
         var staticKeyView;
 
-        this.createKeyView = function() {
+        this.createKeyView = function CNLNode_createKeyView() {
           return new CKeyView(root);
         }
 
-        this.clear = function() {
+        this.clear = function CNLNode_clear() {
           root = new CNLNode();
           staticKeyView = this.createKeyView();
         };
         this.clear();
 
-        this.getStaticKeyView = function() {
+        this.getStaticKeyView = function CNLNode_getStaticKeyView() {
           staticKeyView.reset();
           return staticKeyView;
         };
@@ -2522,32 +2619,85 @@ var LibraryGL = {
           GL_SRC_ALPHA
         ];
 
+        // Map GLenums to small values to efficiently pack the enums to bits for tighter access.
+        this.traverseKey = {
+          // mode
+          0x1E01 /* GL_REPLACE */: 0,
+          0x2100 /* GL_MODULATE */: 1,
+          0x0104 /* GL_ADD */: 2,
+          0x0BE2 /* GL_BLEND */: 3,
+          0x2101 /* GL_DECAL */: 4,
+          0x8570 /* GL_COMBINE */: 5,
+
+          // additional color and alpha combiners
+          0x84E7 /* GL_SUBTRACT */: 3,
+          0x8575 /* GL_INTERPOLATE */: 4,
+
+          // color and alpha src
+          0x1702 /* GL_TEXTURE */: 0,
+          0x8576 /* GL_CONSTANT */: 1,
+          0x8577 /* GL_PRIMARY_COLOR */: 2,
+          0x8578 /* GL_PREVIOUS */: 3,
+
+          // color and alpha op
+          0x0300 /* GL_SRC_COLOR */: 0,
+          0x0301 /* GL_ONE_MINUS_SRC_COLOR */: 1,
+          0x0302 /* GL_SRC_ALPHA */: 2,
+          0x0300 /* GL_ONE_MINUS_SRC_ALPHA */: 3
+        };
+
+        // The tuple (key0,key1,key2) uniquely identifies the state of the variables in CTexEnv.
+        // -1 on key0 denotes 'the whole cached key is dirty'
+        this.key0 = -1;
+        this.key1 = 0;
+        this.key2 = 0;
+
+        this.computeKey0 = function() {
+          var k = this.traverseKey;
+          var key = k[this.mode] * 1638400; // 6 distinct values.
+          key += k[this.colorCombiner] * 327680; // 5 distinct values.
+          key += k[this.alphaCombiner] * 65536; // 5 distinct values.
+          // The above three fields have 6*5*5=150 distinct values -> 8 bits.
+          key += (this.colorScale-1) * 16384; // 10 bits used.
+          key += (this.alphaScale-1) * 4096; // 12 bits used.
+          key += k[this.colorSrc[0]] * 1024; // 14
+          key += k[this.colorSrc[1]] * 256; // 16
+          key += k[this.colorSrc[2]] * 64; // 18
+          key += k[this.alphaSrc[0]] * 16; // 20
+          key += k[this.alphaSrc[1]] * 4; // 22
+          key += k[this.alphaSrc[2]]; // 24 bits used total.
+          return key;
+        }
+        this.computeKey1 = function() {
+          var k = this.traverseKey;
+          key = k[this.colorOp[0]] * 4096;
+          key += k[this.colorOp[1]] * 1024;             
+          key += k[this.colorOp[2]] * 256;
+          key += k[this.alphaOp[0]] * 16;
+          key += k[this.alphaOp[1]] * 4;
+          key += k[this.alphaOp[2]];
+          return key;            
+        }
+        // TODO: remove this. The color should not be part of the key!
+        this.computeKey2 = function() {
+          return this.envColor[0] * 16777216 + this.envColor[1] * 65536 + this.envColor[2] * 256 + 1 + this.envColor[3];
+        }
+        this.recomputeKey = function() {
+          this.key0 = this.computeKey0();
+          this.key1 = this.computeKey1();
+          this.key2 = this.computeKey2();
+        }
+        this.invalidateKey = function() {
+          this.key0 = -1; // The key of this texture unit must be recomputed when rendering the next time.
+          GL.immediate.currentRenderer = null; // The currently used renderer must be re-evaluated at next render.
+        }
         this.traverseState = function(keyView) {
-          keyView.next(this.mode);
-          keyView.next(this.colorCombiner);
-          keyView.next(this.alphaCombiner);
-          keyView.next(this.colorCombiner);
-          keyView.next(this.alphaScale);
-          keyView.next(this.envColor[0]);
-          keyView.next(this.envColor[1]);
-          keyView.next(this.envColor[2]);
-          keyView.next(this.envColor[3]);
-
-          keyView.next(this.colorSrc[0]);
-          keyView.next(this.colorSrc[1]);
-          keyView.next(this.colorSrc[2]);
-
-          keyView.next(this.alphaSrc[0]);
-          keyView.next(this.alphaSrc[1]);
-          keyView.next(this.alphaSrc[2]);
-
-          keyView.next(this.colorOp[0]);
-          keyView.next(this.colorOp[1]);
-          keyView.next(this.colorOp[2]);
-
-          keyView.next(this.alphaOp[0]);
-          keyView.next(this.alphaOp[1]);
-          keyView.next(this.alphaOp[2]);
+          if (this.key0 == -1) {
+            this.recomputeKey();
+          }
+          keyView.next(this.key0);
+          keyView.next(this.key1);
+          keyView.next(this.key2);
         };
       }
 
@@ -2558,7 +2708,7 @@ var LibraryGL = {
         this.enabled_tex3D   = false;
         this.enabled_texCube = false;
 
-        this.traverseState = function(keyView) {
+        this.traverseState = function CTexUnit_traverseState(keyView) {
           var texUnitType = this.getTexType();
           keyView.next(texUnitType);
           if (!texUnitType) return;
@@ -2567,11 +2717,11 @@ var LibraryGL = {
       };
 
       // Class impls:
-      CTexUnit.prototype.enabled = function() {
+      CTexUnit.prototype.enabled = function CTexUnit_enabled() {
         return this.getTexType() != 0;
       }
 
-      CTexUnit.prototype.genPassLines = function(passOutputVar, passInputVar, texUnitID) {
+      CTexUnit.prototype.genPassLines = function CTexUnit_genPassLines(passOutputVar, passInputVar, texUnitID) {
         if (!this.enabled()) {
           return ["vec4 " + passOutputVar + " = " + passInputVar + ";"];
         }
@@ -2579,7 +2729,7 @@ var LibraryGL = {
         return this.env.genPassLines(passOutputVar, passInputVar, texUnitID);
       }
 
-      CTexUnit.prototype.getTexType = function() {
+      CTexUnit.prototype.getTexType = function CTexUnit_getTexType() {
         if (this.enabled_texCube) {
           return GL_TEXTURE_CUBE_MAP;
         } else if (this.enabled_tex3D) {
@@ -2592,7 +2742,7 @@ var LibraryGL = {
         return 0;
       }
 
-      CTexEnv.prototype.genPassLines = function(passOutputVar, passInputVar, texUnitID) {
+      CTexEnv.prototype.genPassLines = function CTexEnv_genPassLines(passOutputVar, passInputVar, texUnitID) {
         switch (this.mode) {
           case GL_REPLACE: {
             /* RGB:
@@ -2714,9 +2864,9 @@ var LibraryGL = {
         return Abort_NoSupport("Unsupported TexEnv mode: 0x" + this.mode.toString(16));
       }
 
-      CTexEnv.prototype.genCombinerLines = function(isColor, outputVar,
-                                                    passInputVar, texUnitID,
-                                                    combiner, srcArr, opArr)
+      CTexEnv.prototype.genCombinerLines = function CTexEnv_getCombinerLines(isColor, outputVar,
+                                                                             passInputVar, texUnitID,
+                                                                             combiner, srcArr, opArr)
       {
         var argsNeeded = null;
         switch (combiner) {
@@ -2832,9 +2982,9 @@ var LibraryGL = {
           } else if (gl) {
             maxTexUnits = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
           }
-
+#if ASSERTIONS
           assert(maxTexUnits > 0);
-
+#endif
           s_texUnits = [];
           for (var i = 0; i < maxTexUnits; i++) {
             s_texUnits.push(new CTexUnit());
@@ -2893,9 +3043,10 @@ var LibraryGL = {
         },
 
         getTexUnitType: function(texUnitID) {
+#if ASSERTIONS
           assert(texUnitID >= 0 &&
                  texUnitID < s_texUnits.length);
-
+#endif
           return s_texUnits[texUnitID].getTexType();
         },
 
@@ -2908,16 +3059,28 @@ var LibraryGL = {
           var cur = getCurTexUnit();
           switch (cap) {
             case GL_TEXTURE_1D:
-              cur.enabled_tex1D = true;
+              if (!cur.enabled_tex1D) {
+                GL.immediate.currentRenderer = null; // Renderer state changed, and must be recreated or looked up again.
+                cur.enabled_tex1D = true;
+              }
               break;
             case GL_TEXTURE_2D:
-              cur.enabled_tex2D = true;
+              if (!cur.enabled_tex2D) {
+                GL.immediate.currentRenderer = null;
+                cur.enabled_tex2D = true;
+              }
               break;
             case GL_TEXTURE_3D:
-              cur.enabled_tex3D = true;
+              if (!cur.enabled_tex3D) {
+                GL.immediate.currentRenderer = null;
+                cur.enabled_tex3D = true;
+              }
               break;
             case GL_TEXTURE_CUBE_MAP:
-              cur.enabled_texCube = true;
+              if (!cur.enabled_texCube) {
+                GL.immediate.currentRenderer = null;
+                cur.enabled_texCube = true;
+              }
               break;
           }
         },
@@ -2926,16 +3089,28 @@ var LibraryGL = {
           var cur = getCurTexUnit();
           switch (cap) {
             case GL_TEXTURE_1D:
-              cur.enabled_tex1D = false;
+              if (cur.enabled_tex1D) {
+                GL.immediate.currentRenderer = null; // Renderer state changed, and must be recreated or looked up again.
+                cur.enabled_tex1D = false;
+              }
               break;
             case GL_TEXTURE_2D:
-              cur.enabled_tex2D = false;
+              if (cur.enabled_tex2D) {
+                GL.immediate.currentRenderer = null;
+                cur.enabled_tex2D = false;
+              }
               break;
             case GL_TEXTURE_3D:
-              cur.enabled_tex3D = false;
+              if (cur.enabled_tex3D) {
+                GL.immediate.currentRenderer = null;
+                cur.enabled_tex3D = false;
+              }
               break;
             case GL_TEXTURE_CUBE_MAP:
-              cur.enabled_texCube = false;
+              if (cur.enabled_texCube) {
+                GL.immediate.currentRenderer = null;
+                cur.enabled_texCube = false;
+              }
               break;
           }
         },
@@ -2947,10 +3122,16 @@ var LibraryGL = {
           var env = getCurTexUnit().env;
           switch (pname) {
             case GL_RGB_SCALE:
-              env.colorScale = param;
+              if (env.colorScale != param) {
+                env.invalidateKey(); // We changed FFP emulation renderer state.
+                env.colorScale = param;
+              }
               break;
             case GL_ALPHA_SCALE:
-              env.alphaScale = param;
+              if (env.alphaScale != param) {
+                env.invalidateKey();
+                env.alphaScale = param;
+              }
               break;
 
             default:
@@ -2965,61 +3146,112 @@ var LibraryGL = {
           var env = getCurTexUnit().env;
           switch (pname) {
             case GL_TEXTURE_ENV_MODE:
-              env.mode = param;
+              if (env.mode != param) {
+                env.invalidateKey(); // We changed FFP emulation renderer state.
+                env.mode = param;
+              }
               break;
 
             case GL_COMBINE_RGB:
-              env.colorCombiner = param;
+              if (env.colorCombiner != param) {
+                env.invalidateKey();
+                env.colorCombiner = param;
+              }
               break;
             case GL_COMBINE_ALPHA:
-              env.alphaCombiner = param;
+              if (env.alphaCombiner != param) {
+                env.invalidateKey();
+                env.alphaCombiner = param;
+              }
               break;
 
             case GL_SRC0_RGB:
-              env.colorSrc[0] = param;
+              if (env.colorSrc[0] != param) {
+                env.invalidateKey();
+                env.colorSrc[0] = param;
+              }
               break;
             case GL_SRC1_RGB:
-              env.colorSrc[1] = param;
+              if (env.colorSrc[1] != param) {
+                env.invalidateKey();
+                env.colorSrc[1] = param;
+              }
               break;
             case GL_SRC2_RGB:
-              env.colorSrc[2] = param;
+              if (env.colorSrc[2] != param) {
+                env.invalidateKey();
+                env.colorSrc[2] = param;
+              }
               break;
 
             case GL_SRC0_ALPHA:
-              env.alphaSrc[0] = param;
+              if (env.alphaSrc[0] != param) {
+                env.invalidateKey();
+                env.alphaSrc[0] = param;
+              }
               break;
             case GL_SRC1_ALPHA:
-              env.alphaSrc[1] = param;
+              if (env.alphaSrc[1] != param) {
+                env.invalidateKey();
+                env.alphaSrc[1] = param;
+              }
               break;
             case GL_SRC2_ALPHA:
-              env.alphaSrc[2] = param;
+              if (env.alphaSrc[2] != param) {
+                env.invalidateKey();
+                env.alphaSrc[2] = param;
+              }
               break;
 
             case GL_OPERAND0_RGB:
-              env.colorOp[0] = param;
+              if (env.colorOp[0] != param) {
+                env.invalidateKey();
+                env.colorOp[0] = param;
+              }
               break;
             case GL_OPERAND1_RGB:
-              env.colorOp[1] = param;
+              if (env.colorOp[1] != param) {
+                env.invalidateKey();
+                env.colorOp[1] = param;
+              }
               break;
             case GL_OPERAND2_RGB:
-              env.colorOp[2] = param;
+              if (env.colorOp[2] != param) {
+                env.invalidateKey();
+                env.colorOp[2] = param;
+              }
               break;
 
             case GL_OPERAND0_ALPHA:
-              env.alphaOp[0] = param;
+              if (env.alphaOp[0] != param) {
+                env.invalidateKey();
+                env.alphaOp[0] = param;
+              }
               break;
             case GL_OPERAND1_ALPHA:
-              env.alphaOp[1] = param;
+              if (env.alphaOp[1] != param) {
+                env.invalidateKey();
+                env.alphaOp[1] = param;
+              }
               break;
             case GL_OPERAND2_ALPHA:
-              env.alphaOp[2] = param;
+              if (env.alphaOp[2] != param) {
+                env.invalidateKey();
+                env.alphaOp[2] = param;
+              }
               break;
 
             case GL_RGB_SCALE:
-              env.colorScale = param;
+              if (env.colorScale != param) {
+                env.invalidateKey();
+                env.colorScale = param;
+              }
               break;
             case GL_ALPHA_SCALE:
-              env.alphaScale = param;
+              if (env.alphaScale != param) {
+                env.invalidateKey();
+                env.alphaScale = param;
+              }
               break;
 
             default:
@@ -3035,7 +3267,10 @@ var LibraryGL = {
             case GL_TEXTURE_ENV_COLOR: {
               for (var i = 0; i < 4; i++) {
                 var param = {{{ makeGetValue('params', 'i*4', 'float') }}};
-                env.envColor[i] = param;
+                if (env.envColor[i] != param) {
+                  env.invalidateKey(); // We changed FFP emulation renderer state.
+                  env.envColor[i] = param;
+                }
               }
               break
             }
@@ -3075,26 +3310,21 @@ var LibraryGL = {
     NORMAL: 1,
     COLOR: 2,
     TEXTURE0: 3,
-    TEXTURE1: 4,
-    TEXTURE2: 5,
-    TEXTURE3: 6,
-    TEXTURE4: 7,
-    TEXTURE5: 8,
-    TEXTURE6: 9,
-    NUM_ATTRIBUTES: 10, // Overwritten in init().
-    MAX_TEXTURES: 7,    // Overwritten in init().
+    NUM_ATTRIBUTES: -1, // Initialized in GL emulation init().
+    MAX_TEXTURES: -1,   // Initialized in GL emulation init().
 
     totalEnabledClientAttributes: 0,
     enabledClientAttributes: [0, 0],
     clientAttributes: [], // raw data, including possible unneeded ones
     liveClientAttributes: [], // the ones actually alive in the current computation, sorted
+    currentRenderer: null, // Caches the currently active FFP emulation renderer, so that it does not have to be re-looked up unless relevant state changes.
     modifiedClientAttributes: false,
     clientActiveTexture: 0,
     clientColor: null,
     usedTexUnitList: [],
     fixedFunctionProgram: null,
 
-    setClientAttribute: function(name, size, type, stride, pointer) {
+    setClientAttribute: function setClientAttribute(name, size, type, stride, pointer) {
       var attrib = this.clientAttributes[name];
       if (!attrib) {
         for (var i = 0; i <= name; i++) { // keep flat
@@ -3121,7 +3351,7 @@ var LibraryGL = {
     },
 
     // Renderers
-    addRendererComponent: function(name, size, type) {
+    addRendererComponent: function addRendererComponent(name, size, type) {
       if (!this.rendererComponents[name]) {
         this.rendererComponents[name] = 1;
 #if ASSERTIONS
@@ -3137,13 +3367,18 @@ var LibraryGL = {
       }
     },
 
-    disableBeginEndClientAttributes: function() {
+    disableBeginEndClientAttributes: function disableBeginEndClientAttributes() {
       for (var i = 0; i < this.NUM_ATTRIBUTES; i++) {
         if (this.rendererComponents[i]) this.enabledClientAttributes[i] = false;
       }
     },
 
-    getRenderer: function() {
+    getRenderer: function getRenderer() {
+      // If no FFP state has changed that would have forced to re-evaluate which FFP emulation shader to use,
+      // we have the currently used renderer in cache, and can immediately return that.
+      if (this.currentRenderer) {
+        return this.currentRenderer;
+      }
       // return a renderer object given the liveClientAttributes
       // we maintain a cache of renderers, optimized to not generate garbage
       var attributes = GL.immediate.liveClientAttributes;
@@ -3152,10 +3387,11 @@ var LibraryGL = {
       var keyView = cacheMap.getStaticKeyView().reset();
 
       // By attrib state:
+      var enabledAttributesKey = 0;
       for (var i = 0; i < attributes.length; i++) {
-        var attribute = attributes[i];
-        keyView.next(attribute.name).next(attribute.size).next(attribute.type);
+        enabledAttributesKey |= 1 << attributes[i].name;
       }
+      keyView.next(enabledAttributesKey);
 
       // By fog state:
       var fogParam = 0;
@@ -3181,45 +3417,41 @@ var LibraryGL = {
       }
 
       // If we don't already have it, create it.
-      if (!keyView.get()) {
+      var renderer = keyView.get();
+      if (!renderer) {
 #if GL_DEBUG
         Module.printErr('generating renderer for ' + JSON.stringify(attributes));
 #endif
-        keyView.set(this.createRenderer());
+        renderer = this.createRenderer();
+        this.currentRenderer = renderer;
+        keyView.set(renderer);
+        return renderer;
       }
-      return keyView.get();
+      this.currentRenderer = renderer; // Cache the currently used renderer, so later lookups without state changes can get this fast.
+      return renderer;
     },
 
-    createRenderer: function(renderer) {
+    createRenderer: function createRenderer(renderer) {
       var useCurrProgram = !!GL.currProgram;
-      var hasTextures = false, textureSizes = [], textureTypes = [];
+      var hasTextures = false;
       for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
         var texAttribName = GL.immediate.TEXTURE0 + i;
         if (!GL.immediate.enabledClientAttributes[texAttribName])
           continue;
 
+#if ASSERTIONS
         if (!useCurrProgram) {
-          assert(GL.immediate.TexEnvJIT.getTexUnitType(i) != 0, "GL_TEXTURE" + i + " coords are supplied, but that texture unit is disabled in the fixed-function pipeline.");
+          if (GL.immediate.TexEnvJIT.getTexUnitType(i) == 0) {
+             Runtime.warnOnce("GL_TEXTURE" + i + " coords are supplied, but that texture unit is disabled in the fixed-function pipeline.");
+          }
         }
+#endif
 
-        textureSizes[i] = GL.immediate.clientAttributes[texAttribName].size;
-        textureTypes[i] = GL.immediate.clientAttributes[texAttribName].type;
         hasTextures = true;
       }
-      var positionSize = GL.immediate.clientAttributes[GL.immediate.VERTEX].size;
-      var positionType = GL.immediate.clientAttributes[GL.immediate.VERTEX].type;
-      var colorSize = 0, colorType;
-      if (GL.immediate.enabledClientAttributes[GL.immediate.COLOR]) {
-        colorSize = GL.immediate.clientAttributes[GL.immediate.COLOR].size;
-        colorType = GL.immediate.clientAttributes[GL.immediate.COLOR].type;
-      }
-      var normalSize = 0, normalType;
-      if (GL.immediate.enabledClientAttributes[GL.immediate.NORMAL]) {
-        normalSize = GL.immediate.clientAttributes[GL.immediate.NORMAL].size;
-        normalType = GL.immediate.clientAttributes[GL.immediate.NORMAL].type;
-      }
+
       var ret = {
-        init: function() {
+        init: function init() {
           // For fixed-function shader generation.
           var uTexUnitPrefix = 'u_texUnit';
           var aTexCoordPrefix = 'a_texCoord';
@@ -3352,10 +3584,25 @@ var LibraryGL = {
             this.program = Module.ctx.createProgram();
             Module.ctx.attachShader(this.program, this.vertexShader);
             Module.ctx.attachShader(this.program, this.fragmentShader);
-            Module.ctx.bindAttribLocation(this.program, 0, 'a_position');
+
+            // As optimization, bind all attributes to prespecified locations, so that the FFP emulation
+            // code can submit attributes to any generated FFP shader without having to examine each shader in turn.
+            // These prespecified locations are only assumed if GL_FFP_ONLY is specified, since user could also create their
+            // own shaders that didn't have attributes in the same locations.
+            Module.ctx.bindAttribLocation(this.program, GL.immediate.VERTEX, 'a_position');
+            Module.ctx.bindAttribLocation(this.program, GL.immediate.COLOR, 'a_color');
+            Module.ctx.bindAttribLocation(this.program, GL.immediate.NORMAL, 'a_normal');
+            for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
+              Module.ctx.bindAttribLocation(this.program, GL.immediate.TEXTURE0 + i, 'a_texCoord'+i);
+              Module.ctx.bindAttribLocation(this.program, GL.immediate.TEXTURE0 + i, aTexCoordPrefix+i);
+            }
             Module.ctx.linkProgram(this.program);
           }
 
+          // Stores a map that remembers which matrix uniforms are up-to-date in this FFP renderer, so they don't need to be resubmitted
+          // each time we render with this program.
+          this.textureMatrixVersion = {};
+
           this.positionLocation = Module.ctx.getAttribLocation(this.program, 'a_position');
 
           this.texCoordLocations = [];
@@ -3398,7 +3645,9 @@ var LibraryGL = {
           this.projectionLocation = Module.ctx.getUniformLocation(this.program, 'u_projection');
 
           this.hasTextures = hasTextures;
-          this.hasNormal = normalSize > 0 && this.normalLocation >= 0;
+          this.hasNormal = GL.immediate.enabledClientAttributes[GL.immediate.NORMAL] &&
+                           GL.immediate.clientAttributes[GL.immediate.NORMAL].size > 0 &&
+                           this.normalLocation >= 0;
           this.hasColor = (this.colorLocation === 0) || this.colorLocation > 0;
 
           this.floatType = Module.ctx.FLOAT; // minor optimization
@@ -3411,23 +3660,25 @@ var LibraryGL = {
                            this.fogScaleLocation || this.fogDensityLocation);
         },
 
-        prepare: function() {
+        prepare: function prepare() {
           // Calculate the array buffer
           var arrayBuffer;
           if (!GL.currArrayBuffer) {
             var start = GL.immediate.firstVertex*GL.immediate.stride;
             var end = GL.immediate.lastVertex*GL.immediate.stride;
+#if ASSERTIONS
             assert(end <= GL.MAX_TEMP_BUFFER_SIZE, 'too much vertex data');
+#endif
             arrayBuffer = GL.tempVertexBuffers[GL.tempBufferIndexLookup[end]];
             // TODO: consider using the last buffer we bound, if it was larger. downside is larger buffer, but we might avoid rebinding and preparing
           } else {
             arrayBuffer = GL.currArrayBuffer;
           }
 
+#if GL_UNSAFE_OPTS
           // If the array buffer is unchanged and the renderer as well, then we can avoid all the work here
           // XXX We use some heuristics here, and this may not work in all cases. Try disabling GL_UNSAFE_OPTS if you
           // have odd glitches
-#if GL_UNSAFE_OPTS
           var lastRenderer = GL.immediate.lastRenderer;
           var canSkip = this == lastRenderer &&
                         arrayBuffer == GL.immediate.lastArrayBuffer &&
@@ -3462,62 +3713,105 @@ var LibraryGL = {
             GL.immediate.fixedFunctionProgram = this.program;
           }
 
-          if (this.modelViewLocation) Module.ctx.uniformMatrix4fv(this.modelViewLocation, false, GL.immediate.matrix['m']);
-          if (this.projectionLocation) Module.ctx.uniformMatrix4fv(this.projectionLocation, false, GL.immediate.matrix['p']);
+          if (this.modelViewLocation && this.modelViewMatrixVersion != GL.immediate.matrixVersion['m']) {
+            this.modelViewMatrixVersion = GL.immediate.matrixVersion['m'];
+            Module.ctx.uniformMatrix4fv(this.modelViewLocation, false, GL.immediate.matrix['m']);
+          }
+          if (this.projectionLocation && this.projectionMatrixVersion != GL.immediate.matrixVersion['p']) {
+            this.projectionMatrixVersion = GL.immediate.matrixVersion['p'];
+            Module.ctx.uniformMatrix4fv(this.projectionLocation, false, GL.immediate.matrix['p']);
+          }
 
           var clientAttributes = GL.immediate.clientAttributes;
+          var posAttr = clientAttributes[GL.immediate.VERTEX];
 
 #if GL_ASSERTIONS
-          GL.validateVertexAttribPointer(positionSize, positionType, GL.immediate.stride, clientAttributes[GL.immediate.VERTEX].offset);
+          GL.validateVertexAttribPointer(posAttr.size, posAttr.type, GL.immediate.stride, clientAttributes[GL.immediate.VERTEX].offset);
 #endif
-          Module.ctx.vertexAttribPointer(this.positionLocation, positionSize, positionType, false,
-                                         GL.immediate.stride, clientAttributes[GL.immediate.VERTEX].offset);
+
+#if GL_FFP_ONLY
+          if (!GL.currArrayBuffer) {
+            Module.ctx.vertexAttribPointer(GL.immediate.VERTEX, posAttr.size, posAttr.type, false, GL.immediate.stride, posAttr.offset);
+            GL.enableVertexAttribArray(GL.immediate.VERTEX);
+            if (this.hasNormal) {
+              var normalAttr = clientAttributes[GL.immediate.NORMAL];
+              Module.ctx.vertexAttribPointer(GL.immediate.NORMAL, normalAttr.size, normalAttr.type, true, GL.immediate.stride, normalAttr.offset);
+              GL.enableVertexAttribArray(GL.immediate.NORMAL);
+            }
+          }
+#else
+          Module.ctx.vertexAttribPointer(this.positionLocation, posAttr.size, posAttr.type, false, GL.immediate.stride, posAttr.offset);
           Module.ctx.enableVertexAttribArray(this.positionLocation);
+          if (this.hasNormal) {
+            var normalAttr = clientAttributes[GL.immediate.NORMAL];
+#if GL_ASSERTIONS
+            GL.validateVertexAttribPointer(normalAttr.size, normalAttr.type, GL.immediate.stride, normalAttr.offset);
+#endif
+            Module.ctx.vertexAttribPointer(this.normalLocation, normalAttr.size, normalAttr.type, true, GL.immediate.stride, normalAttr.offset);
+            Module.ctx.enableVertexAttribArray(this.normalLocation);
+          }
+#endif
           if (this.hasTextures) {
-            //for (var i = 0; i < this.usedTexUnitList.length; i++) {
-            //  var texUnitID = this.usedTexUnitList[i];
             for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
-              var texUnitID = i;
-              var attribLoc = this.texCoordLocations[texUnitID];
+#if GL_FFP_ONLY
+              if (!GL.currArrayBuffer) {
+                var attribLoc = GL.immediate.TEXTURE0+i;
+                var texAttr = clientAttributes[attribLoc];
+                if (texAttr.size) {
+                  Module.ctx.vertexAttribPointer(attribLoc, texAttr.size, texAttr.type, false, GL.immediate.stride, texAttr.offset);
+                  GL.enableVertexAttribArray(attribLoc);
+                } else {
+                  // These two might be dangerous, but let's try them.
+                  Module.ctx.vertexAttrib4f(attribLoc, 0, 0, 0, 1);
+                  GL.disableVertexAttribArray(attribLoc);
+                }
+              }
+#else
+              var attribLoc = this.texCoordLocations[i];
               if (attribLoc === undefined || attribLoc < 0) continue;
+              var texAttr = clientAttributes[GL.immediate.TEXTURE0+i];
 
-              if (texUnitID < textureSizes.length && textureSizes[texUnitID]) {
+              if (texAttr.size) {
 #if GL_ASSERTIONS
-                GL.validateVertexAttribPointer(textureSizes[texUnitID], textureTypes[texUnitID], GL.immediate.stride, GL.immediate.clientAttributes[GL.immediate.TEXTURE0 + texUnitID].offset);
+                GL.validateVertexAttribPointer(texAttr.size, texAttr.type, GL.immediate.stride, texAttr.offset);
 #endif
-                Module.ctx.vertexAttribPointer(attribLoc, textureSizes[texUnitID], textureTypes[texUnitID], false,
-                                               GL.immediate.stride, GL.immediate.clientAttributes[GL.immediate.TEXTURE0 + texUnitID].offset);
+                Module.ctx.vertexAttribPointer(attribLoc, texAttr.size, texAttr.type, false, GL.immediate.stride, texAttr.offset);
                 Module.ctx.enableVertexAttribArray(attribLoc);
               } else {
                 // These two might be dangerous, but let's try them.
                 Module.ctx.vertexAttrib4f(attribLoc, 0, 0, 0, 1);
                 Module.ctx.disableVertexAttribArray(attribLoc);
               }
-            }
-            for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
-              if (this.textureMatrixLocations[i]) { // XXX might we need this even without the condition we are currently in?
-                Module.ctx.uniformMatrix4fv(this.textureMatrixLocations[i], false, GL.immediate.matrix['t' + i]);
+#endif
+              var t = 't'+i;
+              if (this.textureMatrixLocations[i] && this.textureMatrixVersion[t] != GL.immediate.matrixVersion[t]) { // XXX might we need this even without the condition we are currently in?
+                this.textureMatrixVersion[t] = GL.immediate.matrixVersion[t];
+                Module.ctx.uniformMatrix4fv(this.textureMatrixLocations[i], false, GL.immediate.matrix[t]);
               }
             }
           }
-          if (colorSize) {
+          if (GL.immediate.enabledClientAttributes[GL.immediate.COLOR]) {
+            var colorAttr = clientAttributes[GL.immediate.COLOR];
 #if GL_ASSERTIONS
-            GL.validateVertexAttribPointer(colorSize, colorType, GL.immediate.stride, clientAttributes[GL.immediate.COLOR].offset);
+            GL.validateVertexAttribPointer(colorAttr.size, colorAttr.type, GL.immediate.stride, colorAttr.offset);
 #endif
-            Module.ctx.vertexAttribPointer(this.colorLocation, colorSize, colorType, true,
-                                           GL.immediate.stride, clientAttributes[GL.immediate.COLOR].offset);
+#if GL_FFP_ONLY
+            if (!GL.currArrayBuffer) {
+              Module.ctx.vertexAttribPointer(GL.immediate.COLOR, colorAttr.size, colorAttr.type, true, GL.immediate.stride, colorAttr.offset);
+              GL.enableVertexAttribArray(GL.immediate.COLOR);
+            }
+#else
+            Module.ctx.vertexAttribPointer(this.colorLocation, colorAttr.size, colorAttr.type, true, GL.immediate.stride, colorAttr.offset);
             Module.ctx.enableVertexAttribArray(this.colorLocation);
+#endif
           } else if (this.hasColor) {
+#if GL_FFP_ONLY
+            GL.disableVertexAttribArray(GL.immediate.COLOR);
+            Module.ctx.vertexAttrib4fv(GL.immediate.COLOR, GL.immediate.clientColor);
+#else
             Module.ctx.disableVertexAttribArray(this.colorLocation);
             Module.ctx.vertexAttrib4fv(this.colorLocation, GL.immediate.clientColor);
-          }
-          if (this.hasNormal) {
-#if GL_ASSERTIONS
-            GL.validateVertexAttribPointer(normalSize, normalType, GL.immediate.stride, clientAttributes[GL.immediate.NORMAL].offset);
 #endif
-            Module.ctx.vertexAttribPointer(this.normalLocation, normalSize, normalType, true,
-                                           GL.immediate.stride, clientAttributes[GL.immediate.NORMAL].offset);
-            Module.ctx.enableVertexAttribArray(this.normalLocation);
           }
           if (this.hasFog) {
             if (this.fogColorLocation) Module.ctx.uniform4fv(this.fogColorLocation, GLEmulation.fogColor);
@@ -3527,11 +3821,12 @@ var LibraryGL = {
           }
         },
 
-        cleanup: function() {
+        cleanup: function cleanup() {
+#if !GL_FFP_ONLY
           Module.ctx.disableVertexAttribArray(this.positionLocation);
           if (this.hasTextures) {
-            for (var i = 0; i < textureSizes.length; i++) {
-              if (textureSizes[i] && this.texCoordLocations[i] >= 0) {
+            for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
+              if (GL.immediate.enabledClientAttributes[GL.immediate.TEXTURE0+i] && this.texCoordLocations[i] >= 0) {
                 Module.ctx.disableVertexAttribArray(this.texCoordLocations[i]);
               }
             }
@@ -3555,6 +3850,7 @@ var LibraryGL = {
           GL.immediate.lastProgram = null;
 #endif
           GL.immediate.matricesModified = true;
+#endif
         }
       };
       ret.init();
@@ -3565,7 +3861,7 @@ var LibraryGL = {
       // Replace some functions with immediate-mode aware versions. If there are no client
       // attributes enabled, and we use webgl-friendly modes (no GL_QUADS), then no need
       // for emulation
-      _glDrawArrays = function(mode, first, count) {
+      _glDrawArrays = function _glDrawArrays(mode, first, count) {
         if (GL.immediate.totalEnabledClientAttributes == 0 && mode <= 6) {
           Module.ctx.drawArrays(mode, first, count);
           return;
@@ -3581,15 +3877,15 @@ var LibraryGL = {
         GL.immediate.mode = -1;
       };
 
-      _glDrawElements = function(mode, count, type, indices, start, end) { // start, end are given if we come from glDrawRangeElements
+      _glDrawElements = function _glDrawElements(mode, count, type, indices, start, end) { // start, end are given if we come from glDrawRangeElements
         if (GL.immediate.totalEnabledClientAttributes == 0 && mode <= 6 && GL.currElementArrayBuffer) {
           Module.ctx.drawElements(mode, count, type, indices);
           return;
         }
+#if ASSERTIONS
         if (!GL.currElementArrayBuffer) {
           assert(type == Module.ctx.UNSIGNED_SHORT); // We can only emulate buffers of this kind, for now
         }
-#if ASSERTIONS
         console.log("DrawElements doesn't actually prepareClientAttributes properly.");
 #endif
         GL.immediate.prepareClientAttributes(count, false);
@@ -3621,43 +3917,43 @@ var LibraryGL = {
       }
 
       var glActiveTexture = _glActiveTexture;
-      _glActiveTexture = function(texture) {
+      _glActiveTexture = function _glActiveTexture(texture) {
         GL.immediate.TexEnvJIT.hook_activeTexture(texture);
         glActiveTexture(texture);
       };
 
       var glEnable = _glEnable;
-      _glEnable = function(cap) {
+      _glEnable = function _glEnable(cap) {
         GL.immediate.TexEnvJIT.hook_enable(cap);
         glEnable(cap);
       };
       var glDisable = _glDisable;
-      _glDisable = function(cap) {
+      _glDisable = function _glDisable(cap) {
         GL.immediate.TexEnvJIT.hook_disable(cap);
         glDisable(cap);
       };
 
       var glTexEnvf = (typeof(_glTexEnvf) != 'undefined') ? _glTexEnvf : function(){};
-      _glTexEnvf = function(target, pname, param) {
+      _glTexEnvf = function _glTexEnvf(target, pname, param) {
         GL.immediate.TexEnvJIT.hook_texEnvf(target, pname, param);
         // Don't call old func, since we are the implementor.
         //glTexEnvf(target, pname, param);
       };
       var glTexEnvi = (typeof(_glTexEnvi) != 'undefined') ? _glTexEnvi : function(){};
-      _glTexEnvi = function(target, pname, param) {
+      _glTexEnvi = function _glTexEnvi(target, pname, param) {
         GL.immediate.TexEnvJIT.hook_texEnvi(target, pname, param);
         // Don't call old func, since we are the implementor.
         //glTexEnvi(target, pname, param);
       };
       var glTexEnvfv = (typeof(_glTexEnvfv) != 'undefined') ? _glTexEnvfv : function(){};
-      _glTexEnvfv = function(target, pname, param) {
+      _glTexEnvfv = function _glTexEnvfv(target, pname, param) {
         GL.immediate.TexEnvJIT.hook_texEnvfv(target, pname, param);
         // Don't call old func, since we are the implementor.
         //glTexEnvfv(target, pname, param);
       };
 
       var glGetIntegerv = _glGetIntegerv;
-      _glGetIntegerv = function(pname, params) {
+      _glGetIntegerv = function _glGetIntegerv(pname, params) {
         switch (pname) {
           case 0x8B8D: { // GL_CURRENT_PROGRAM
             // Just query directly so we're working with WebGL objects.
@@ -3684,11 +3980,15 @@ var LibraryGL = {
 
       this.TexEnvJIT.init(Module.ctx);
 
-      GL.immediate.MAX_TEXTURES = Module.ctx.getParameter(Module.ctx.MAX_TEXTURE_IMAGE_UNITS);
-      GL.immediate.NUM_ATTRIBUTES = GL.immediate.TEXTURE0 + GL.immediate.MAX_TEXTURES;
+      // User can override the maximum number of texture units that we emulate. Using fewer texture units increases runtime performance
+      // slightly, so it is advantageous to choose as small value as needed.
+      GL.immediate.MAX_TEXTURES = Module['GL_MAX_TEXTURE_IMAGE_UNITS'] || Module.ctx.getParameter(Module.ctx.MAX_TEXTURE_IMAGE_UNITS);
+      GL.immediate.NUM_ATTRIBUTES = 3 /*pos+normal+color attributes*/ + GL.immediate.MAX_TEXTURES;
       GL.immediate.clientAttributes = [];
+      GLEmulation.enabledClientAttribIndices = [];
       for (var i = 0; i < GL.immediate.NUM_ATTRIBUTES; i++) {
         GL.immediate.clientAttributes.push({});
+        GLEmulation.enabledClientAttribIndices.push(false);
       }
 
       this.matrixStack['m'] = [];
@@ -3698,13 +3998,18 @@ var LibraryGL = {
       }
 
       // Initialize matrix library
-
+      // When user sets a matrix, increment a 'version number' on the new data, and when rendering, submit
+      // the matrices to the shader program only if they have an old version of the data.
+      GL.immediate.matrixVersion = {};
       GL.immediate.matrix['m'] = GL.immediate.matrix.lib.mat4.create();
+      GL.immediate.matrixVersion['m'] = 0;
       GL.immediate.matrix.lib.mat4.identity(GL.immediate.matrix['m']);
       GL.immediate.matrix['p'] = GL.immediate.matrix.lib.mat4.create();
+      GL.immediate.matrixVersion['p'] = 0;
       GL.immediate.matrix.lib.mat4.identity(GL.immediate.matrix['p']);
       for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
         GL.immediate.matrix['t' + i] = GL.immediate.matrix.lib.mat4.create();
+        GL.immediate.matrixVersion['t' + i] = 0;
       }
 
       // Renderer cache
@@ -3725,7 +4030,7 @@ var LibraryGL = {
     // Modifies liveClientAttributes, stride, vertexPointer, vertexCounter
     //   count: number of elements we will draw
     //   beginEnd: whether we are drawing the results of a begin/end block
-    prepareClientAttributes: function(count, beginEnd) {
+    prepareClientAttributes: function prepareClientAttributes(count, beginEnd) {
       // If no client attributes were modified since we were last called, do nothing. Note that this
       // does not work for glBegin/End, where we generate renderer components dynamically and then
       // disable them ourselves, but it does help with glDrawElements/Arrays.
@@ -3797,13 +4102,17 @@ var LibraryGL = {
           if (!attribute) break;
           attribute.offset = attribute.pointer - start;
           if (attribute.offset > bytes) { // ensure we start where we should
+#if ASSERTIONS
             assert((attribute.offset - bytes)%4 == 0); // XXX assuming 4-alignment
+#endif
             bytes += attribute.offset - bytes;
           }
           bytes += attribute.size * GL.byteSizeByType[attribute.type - GL.byteSizeByTypeRoot];
           if (bytes % 4 != 0) bytes += 4 - (bytes % 4); // XXX assuming 4-alignment
         }
+#if ASSERTIONS
         assert(beginEnd || bytes <= stride); // if not begin-end, explicit stride should make sense with total byte size
+#endif
         if (bytes < stride) { // ensure the size is that of the stride
           bytes = stride;
         }
@@ -3819,7 +4128,7 @@ var LibraryGL = {
       }
     },
 
-    flush: function(numProvidedIndexes, startIndex, ptr) {
+    flush: function flush(numProvidedIndexes, startIndex, ptr) {
 #if ASSERTIONS
       assert(numProvidedIndexes >= 0 || !numProvidedIndexes);
 #endif
@@ -3830,18 +4139,21 @@ var LibraryGL = {
 
       // Generate index data in a format suitable for GLES 2.0/WebGL
       var numVertexes = 4 * this.vertexCounter / GL.immediate.stride;
+#if ASSERTIONS
       assert(numVertexes % 1 == 0, "`numVertexes` must be an integer.");
-
+#endif
       var emulatedElementArrayBuffer = false;
       var numIndexes = 0;
       if (numProvidedIndexes) {
         numIndexes = numProvidedIndexes;
         if (!GL.currArrayBuffer && GL.immediate.firstVertex > GL.immediate.lastVertex) {
           // Figure out the first and last vertex from the index data
+#if ASSERTIONS
           assert(!GL.currElementArrayBuffer); // If we are going to upload array buffer data, we need to find which range to
                                               // upload based on the indices. If they are in a buffer on the GPU, that is very
                                               // inconvenient! So if you do not have an array buffer, you should also not have
                                               // an element array buffer. But best is to use both buffers!
+#endif
           for (var i = 0; i < numProvidedIndexes; i++) {
             var currIndex = {{{ makeGetValue('ptr', 'i*2', 'i16', null, 1) }}};
             GL.immediate.firstVertex = Math.min(GL.immediate.firstVertex, currIndex);
@@ -3850,7 +4162,9 @@ var LibraryGL = {
         }
         if (!GL.currElementArrayBuffer) {
           // If no element array buffer is bound, then indices is a literal pointer to clientside data
+#if ASSERTIONS
           assert(numProvidedIndexes << 1 <= GL.MAX_TEMP_BUFFER_SIZE, 'too many immediate mode indexes (a)');
+#endif
           var indexBuffer = GL.tempIndexBuffers[GL.tempBufferIndexLookup[numProvidedIndexes << 1]];
           Module.ctx.bindBuffer(Module.ctx.ELEMENT_ARRAY_BUFFER, indexBuffer);
           Module.ctx.bufferSubData(Module.ctx.ELEMENT_ARRAY_BUFFER, 0, {{{ makeHEAPView('U16', 'ptr', 'ptr + (numProvidedIndexes << 1)') }}});
@@ -3862,11 +4176,15 @@ var LibraryGL = {
         // GL.immediate.firstVertex is the first vertex we want. Quad indexes are in the pattern
         // 0 1 2, 0 2 3, 4 5 6, 4 6 7, so we need to look at index firstVertex * 1.5 to see it.
         // Then since indexes are 2 bytes each, that means 3
+#if ASSERTIONS
         assert(GL.immediate.firstVertex % 4 == 0);
+#endif
         ptr = GL.immediate.firstVertex*3;
         var numQuads = numVertexes / 4;
         numIndexes = numQuads * 6; // 0 1 2, 0 2 3 pattern
+#if ASSERTIONS
         assert(ptr + (numIndexes << 1) <= GL.MAX_TEMP_BUFFER_SIZE, 'too many immediate mode indexes (b)');
+#endif
         Module.ctx.bindBuffer(Module.ctx.ELEMENT_ARRAY_BUFFER, GL.tempQuadIndexBuffer);
         emulatedElementArrayBuffer = true;
       }
@@ -3883,7 +4201,7 @@ var LibraryGL = {
         Module.ctx.bindBuffer(Module.ctx.ELEMENT_ARRAY_BUFFER, GL.buffers[GL.currElementArrayBuffer] || null);
       }
 
-#if GL_UNSAFE_OPTS == 0
+#if GL_UNSAFE_OPTS == 0 && !GL_FFP_ONLY
       renderer.cleanup();
 #endif
     }
@@ -4050,7 +4368,7 @@ var LibraryGL = {
   glColor4ubv__deps: ['glColor4ub'],
   glColor4ubv: function(p) {
     _glColor4ub({{{ makeGetValue('p', '0', 'i8') }}}, {{{ makeGetValue('p', '1', 'i8') }}}, {{{ makeGetValue('p', '2', 'i8') }}}, {{{ makeGetValue('p', '3', 'i8') }}});
-	},
+  },
 
   glFogf: function(pname, param) { // partial support, TODO
     switch(pname) {
@@ -4131,10 +4449,12 @@ var LibraryGL = {
     if (disable && GL.immediate.enabledClientAttributes[attrib]) {
       GL.immediate.enabledClientAttributes[attrib] = false;
       GL.immediate.totalEnabledClientAttributes--;
+      this.currentRenderer = null; // Will need to change current renderer, since the set of active vertex pointers changed.
       if (GLEmulation.currentVao) delete GLEmulation.currentVao.enabledClientStates[cap];
     } else if (!disable && !GL.immediate.enabledClientAttributes[attrib]) {
       GL.immediate.enabledClientAttributes[attrib] = true;
       GL.immediate.totalEnabledClientAttributes++;
+      this.currentRenderer = null; // Will need to change current renderer, since the set of active vertex pointers changed.
       if (GLEmulation.currentVao) GLEmulation.currentVao.enabledClientStates[cap] = 1;
     }
     GL.immediate.modifiedClientAttributes = true;
@@ -4146,15 +4466,40 @@ var LibraryGL = {
   glVertexPointer__deps: ['$GLEmulation'], // if any pointers are used, glVertexPointer must be, and if it is, then we need emulation
   glVertexPointer: function(size, type, stride, pointer) {
     GL.immediate.setClientAttribute(GL.immediate.VERTEX, size, type, stride, pointer);
+#if GL_FFP_ONLY
+    if (GL.currArrayBuffer) {
+      Module.ctx.vertexAttribPointer(GL.immediate.VERTEX, size, type, false, stride, pointer);
+      GL.enableVertexAttribArray(GL.immediate.VERTEX);
+    }
+#endif
   },
   glTexCoordPointer: function(size, type, stride, pointer) {
     GL.immediate.setClientAttribute(GL.immediate.TEXTURE0 + GL.immediate.clientActiveTexture, size, type, stride, pointer);
+#if GL_FFP_ONLY
+    if (GL.currArrayBuffer) {
+      var loc = GL.immediate.TEXTURE0 + GL.immediate.clientActiveTexture;
+      Module.ctx.vertexAttribPointer(loc, size, type, false, stride, pointer);
+      GL.enableVertexAttribArray(loc);
+    }
+#endif
   },
   glNormalPointer: function(type, stride, pointer) {
     GL.immediate.setClientAttribute(GL.immediate.NORMAL, 3, type, stride, pointer);
+#if GL_FFP_ONLY
+    if (GL.currArrayBuffer) {
+      Module.ctx.vertexAttribPointer(GL.immediate.NORMAL, size, type, true, stride, pointer);
+      GL.enableVertexAttribArray(GL.immediate.NORMAL);
+    }
+#endif
   },
   glColorPointer: function(size, type, stride, pointer) {
     GL.immediate.setClientAttribute(GL.immediate.COLOR, size, type, stride, pointer);
+#if GL_FFP_ONLY
+    if (GL.currArrayBuffer) {
+      Module.ctx.vertexAttribPointer(GL.immediate.COLOR, size, type, true, stride, pointer);
+      GL.enableVertexAttribArray(GL.immediate.COLOR);
+    }
+#endif
   },
 
   glClientActiveTexture__sig: 'vi',
@@ -4237,23 +4582,27 @@ var LibraryGL = {
 
   glPushMatrix: function() {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrixStack[GL.immediate.currentMatrix].push(
         Array.prototype.slice.call(GL.immediate.matrix[GL.immediate.currentMatrix]));
   },
 
   glPopMatrix: function() {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix[GL.immediate.currentMatrix] = GL.immediate.matrixStack[GL.immediate.currentMatrix].pop();
   },
 
   glLoadIdentity__deps: ['$GL', '$GLImmediateSetup'],
   glLoadIdentity: function() {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.identity(GL.immediate.matrix[GL.immediate.currentMatrix]);
   },
 
   glLoadMatrixd: function(matrix) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.set({{{ makeHEAPView('F64', 'matrix', 'matrix+' + (16*8)) }}}, GL.immediate.matrix[GL.immediate.currentMatrix]);
   },
 
@@ -4262,35 +4611,41 @@ var LibraryGL = {
     if (GL.debug) Module.printErr('glLoadMatrixf receiving: ' + Array.prototype.slice.call(HEAPF32.subarray(matrix >> 2, (matrix >> 2) + 16)));
 #endif
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.set({{{ makeHEAPView('F32', 'matrix', 'matrix+' + (16*4)) }}}, GL.immediate.matrix[GL.immediate.currentMatrix]);
   },
 
   glLoadTransposeMatrixd: function(matrix) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.set({{{ makeHEAPView('F64', 'matrix', 'matrix+' + (16*8)) }}}, GL.immediate.matrix[GL.immediate.currentMatrix]);
     GL.immediate.matrix.lib.mat4.transpose(GL.immediate.matrix[GL.immediate.currentMatrix]);
   },
 
   glLoadTransposeMatrixf: function(matrix) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.set({{{ makeHEAPView('F32', 'matrix', 'matrix+' + (16*4)) }}}, GL.immediate.matrix[GL.immediate.currentMatrix]);
     GL.immediate.matrix.lib.mat4.transpose(GL.immediate.matrix[GL.immediate.currentMatrix]);
   },
 
   glMultMatrixd: function(matrix) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.multiply(GL.immediate.matrix[GL.immediate.currentMatrix],
         {{{ makeHEAPView('F64', 'matrix', 'matrix+' + (16*8)) }}});
   },
 
   glMultMatrixf: function(matrix) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.multiply(GL.immediate.matrix[GL.immediate.currentMatrix],
         {{{ makeHEAPView('F32', 'matrix', 'matrix+' + (16*4)) }}});
   },
 
   glMultTransposeMatrixd: function(matrix) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     var colMajor = GL.immediate.matrix.lib.mat4.create();
     GL.immediate.matrix.lib.mat4.set({{{ makeHEAPView('F64', 'matrix', 'matrix+' + (16*8)) }}}, colMajor);
     GL.immediate.matrix.lib.mat4.transpose(colMajor);
@@ -4299,6 +4654,7 @@ var LibraryGL = {
 
   glMultTransposeMatrixf: function(matrix) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     var colMajor = GL.immediate.matrix.lib.mat4.create();
     GL.immediate.matrix.lib.mat4.set({{{ makeHEAPView('F32', 'matrix', 'matrix+' + (16*4)) }}}, colMajor);
     GL.immediate.matrix.lib.mat4.transpose(colMajor);
@@ -4307,6 +4663,7 @@ var LibraryGL = {
 
   glFrustum: function(left, right, bottom, top_, nearVal, farVal) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.multiply(GL.immediate.matrix[GL.immediate.currentMatrix],
         GL.immediate.matrix.lib.mat4.frustum(left, right, bottom, top_, nearVal, farVal));
   },
@@ -4314,6 +4671,7 @@ var LibraryGL = {
 
   glOrtho: function(left, right, bottom, top_, nearVal, farVal) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.multiply(GL.immediate.matrix[GL.immediate.currentMatrix],
         GL.immediate.matrix.lib.mat4.ortho(left, right, bottom, top_, nearVal, farVal));
   },
@@ -4321,18 +4679,21 @@ var LibraryGL = {
 
   glScaled: function(x, y, z) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.scale(GL.immediate.matrix[GL.immediate.currentMatrix], [x, y, z]);
   },
   glScalef: 'glScaled',
 
   glTranslated: function(x, y, z) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.translate(GL.immediate.matrix[GL.immediate.currentMatrix], [x, y, z]);
   },
   glTranslatef: 'glTranslated',
 
   glRotated: function(angle, x, y, z) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.rotate(GL.immediate.matrix[GL.immediate.currentMatrix], angle*Math.PI/180, [x, y, z]);
   },
   glRotatef: 'glRotated',
@@ -4415,6 +4776,7 @@ var LibraryGL = {
 
   gluPerspective: function(fov, aspect, near, far) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix[GL.immediate.currentMatrix] =
       GL.immediate.matrix.lib.mat4.perspective(fov, aspect, near, far,
                                                GL.immediate.matrix[GL.immediate.currentMatrix]);
@@ -4422,6 +4784,7 @@ var LibraryGL = {
 
   gluLookAt: function(ex, ey, ez, cx, cy, cz, ux, uy, uz) {
     GL.immediate.matricesModified = true;
+    GL.immediate.matrixVersion[GL.immediate.currentMatrix] = (GL.immediate.matrixVersion[GL.immediate.currentMatrix] + 1)|0;
     GL.immediate.matrix.lib.mat4.lookAt(GL.immediate.matrix[GL.immediate.currentMatrix], [ex, ey, ez],
         [cx, cy, cz], [ux, uy, uz]);
   },
@@ -4572,6 +4935,30 @@ var LibraryGL = {
 #endif
   },
 
+  glShaderBinary__sig: 'v',
+  glShaderBinary: function() {
+    GL.recordError(0x0500/*GL_INVALID_ENUM*/);
+#if GL_ASSERTIONS
+    Module.printErr("GL_INVALID_ENUM in glShaderBinary: WebGL does not support binary shader formats! Calls to glShaderBinary always fail.");
+#endif    
+  },
+
+  glReleaseShaderCompiler__sig: 'v',
+  glReleaseShaderCompiler: function() {
+    // NOP (as allowed by GLES 2.0 spec)
+  },
+
+  glGetError__sig: 'i',
+  glGetError: function() {
+    // First return any GL error generated by the emscripten library_gl.js interop layer.
+    if (GL.lastError) {
+      var error = GL.lastError;
+      GL.lastError = 0/*GL_NO_ERROR*/;
+      return error;
+    } else { // If there were none, return the GL error from the browser GL context.
+      return Module.ctx.getError();
+    }
+  },
   // signatures of simple pass-through functions, see later
 
   glActiveTexture__sig: 'vi',
@@ -4605,16 +4992,15 @@ var LibraryGL = {
   glFlush__sig: 'v',
   glClearColor__sig: 'viiii',
   glIsEnabled__sig: 'ii',
-  glGetError__sig: 'i',
   glFrontFace__sig: 'vi',
-  glSampleCoverage__sig: 'vi',
+  glSampleCoverage__sig: 'vii',
 };
 
 
 // Simple pass-through functions. Starred ones have return values. [X] ones have X in the C name but not in the JS name
-[[0, 'getError* finish flush'],
- [1, 'clearDepth clearDepth[f] depthFunc enable disable frontFace cullFace clear lineWidth clearStencil depthMask stencilMask checkFramebufferStatus* generateMipmap activeTexture blendEquation sampleCoverage isEnabled*'],
- [2, 'blendFunc blendEquationSeparate depthRange depthRange[f] stencilMaskSeparate hint polygonOffset vertexAttrib1f'],
+[[0, 'finish flush'],
+ [1, 'clearDepth clearDepth[f] depthFunc enable disable frontFace cullFace clear lineWidth clearStencil depthMask stencilMask checkFramebufferStatus* generateMipmap activeTexture blendEquation isEnabled*'],
+ [2, 'blendFunc blendEquationSeparate depthRange depthRange[f] stencilMaskSeparate hint polygonOffset vertexAttrib1f sampleCoverage'],
  [3, 'texParameteri texParameterf vertexAttrib2f stencilFunc stencilOp'],
  [4, 'viewport clearColor scissor vertexAttrib3f colorMask renderbufferStorage blendFuncSeparate blendColor stencilFuncSeparate stencilOpSeparate'],
  [5, 'vertexAttrib4f'],
@@ -4687,7 +5073,7 @@ LibraryGL.emscripten_GetProcAddress__deps = [function() {
   tableImpl += '}\nreturn 0;';
   LibraryManager.library.emscripten_procAddressTable = new Function('name', tableImpl);
 }, 'emscripten_procAddressTable'];
-LibraryGL.emscripten_GetProcAddress = function(name) {
+LibraryGL.emscripten_GetProcAddress = function _LibraryGL_emscripten_GetProcAddress(name) {
   name = name.replace('EXT', '').replace('ARB', '');
   switch(name) { // misc renamings
     case 'glCreateProgramObject': name = 'glCreateProgram'; break;