support for gl_TextureMatrixes

3 files changed, 344 insertions, 7 deletions

diff --git a/src/library_gl.js b/src/library_gl.js
index 639b3d89..1969f2c1 100644
--- a/src/library_gl.js
+++ b/src/library_gl.js
@@ -980,7 +980,7 @@ var LibraryGL = {
           if (need_mm && !has_mm) source = 'uniform mat4 u_modelView; \n' + source;
           if (need_pm && !has_pm) source = 'uniform mat4 u_projection; \n' + source;
           GL.shaderInfos[shader].ftransform = need_pm || need_mm || need_pv; // we will need to provide the fixed function stuff as attributes and uniforms
-          for (var i = 0; i <= 6; i++) {
+          for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
             // XXX To handle both regular texture mapping and cube mapping, we use vec4 for tex coordinates.
             var old = source;
             var need_vtc = source.search('v_texCoord' + i) == -1;
@@ -992,6 +992,12 @@ var LibraryGL = {
                 source = 'varying vec4 v_texCoord' + i + ';   \n' + source;
               }
             }
+
+            old = source;
+            source = source.replace(new RegExp('gl_TextureMatrix\\[' + i + '\\]', 'g'), 'u_textureMatrix' + i);
+            if (source != old) {
+              source = 'uniform mat4 u_textureMatrix' + i + '; \n' + source;
+            }
           }
           if (source.indexOf('gl_FrontColor') >= 0) {
             source = 'varying vec4 v_color; \n' +
@@ -1012,7 +1018,7 @@ var LibraryGL = {
                      source.replace(/gl_FogFragCoord/g, 'v_fogCoord');
           }
         } else { // Fragment shader
-          for (var i = 0; i <= 6; i++) {
+          for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
             var old = source;
             source = source.replace(new RegExp('gl_TexCoord\\[' + i + '\\]', 'g'), 'v_texCoord' + i);
             if (source != old) {
@@ -1103,7 +1109,7 @@ var LibraryGL = {
         } else if (pname == 0x0BA7) { // GL_PROJECTION_MATRIX
           HEAPF32.set(GL.immediate.matrix['p'], params >> 2);
         } else if (pname == 0x0BA8) { // GL_TEXTURE_MATRIX
-          HEAPF32.set(GL.immediate.matrix['t'], params >> 2);
+          HEAPF32.set(GL.immediate.matrix['t' + GL.immediate.clientActiveTexture], params >> 2);
         } else if (pname == 0x0B66) { // GL_FOG_COLOR
           {{{ makeSetValue('params', '0', '0', 'float') }}};
         } else {
@@ -1223,6 +1229,7 @@ var LibraryGL = {
   $GLImmediate: {
     // Vertex and index data
     maxElements: 10240,
+    MAX_TEXTURES: 7,
     vertexData: null, // current vertex data. either tempData (glBegin etc.) or a view into the heap (gl*Pointer). Default view is F32
     vertexDataU8: null, // U8 view
     tempData: null,
@@ -1410,6 +1417,10 @@ var LibraryGL = {
               this.texCoordLocations[i] = Module.ctx.getAttribLocation(this.program, 'a_texCoord' + i);
             }
           }
+          this.textureMatrixLocations = [];
+          for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
+            this.textureMatrixLocations[i] = Module.ctx.getUniformLocation(this.program, 'u_textureMatrix' + i);
+          }
           this.colorLocation = Module.ctx.getAttribLocation(this.program, 'a_color');
           this.normalLocation = Module.ctx.getAttribLocation(this.program, 'a_normal');
 
@@ -1442,6 +1453,11 @@ var LibraryGL = {
                 Module.ctx.enableVertexAttribArray(this.texCoordLocations[i]);
               }
             }
+            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]);
+              }
+            }
           }
           if (this.hasColorAttrib) {
             Module.ctx.vertexAttribPointer(this.colorLocation, colorSize, colorType, true,
@@ -1495,11 +1511,15 @@ var LibraryGL = {
       // No JSON notation for these objects, for closure w/js optimizer
       this.matrix['m'] = null; // modelview
       this.matrix['p'] = null; // projection
-      this.matrix['t'] = null; // texture
+      for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
+        this.matrix['t' + i] = null; // texture
+      }
 
       this.matrixStack['m'] = [];
       this.matrixStack['p'] = [];
-      this.matrixStack['t'] = [];
+      for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
+        this.matrixStack['t' + i] = [];
+      }
 
       this.ATTRIBUTE_BY_NAME['V'] = 0;
       this.ATTRIBUTE_BY_NAME['N'] = 1;
@@ -1516,7 +1536,9 @@ var LibraryGL = {
 
       GL.immediate.matrix['m'] = GL.immediate.matrix.lib.mat4.create();
       GL.immediate.matrix['p'] = GL.immediate.matrix.lib.mat4.create();
-      GL.immediate.matrix['t'] = GL.immediate.matrix.lib.mat4.create();
+      for (var i = 0; i < GL.immediate.MAX_TEXTURES; i++) {
+        GL.immediate.matrix['t' + i] = GL.immediate.matrix.lib.mat4.create();
+      }
       GL.immediate.currentMatrix = GL.immediate.matrix.lib.mat4.create();
 
       // Buffers for data
@@ -1843,7 +1865,7 @@ var LibraryGL = {
     } else if (mode == 0x1701 /* GL_PROJECTION */) {
       GL.immediate.currentMatrix = 'p';
     } else if (mode == 0x1702) { // GL_TEXTURE
-      GL.immediate.currentMatrix = 't';
+      GL.immediate.currentMatrix = 't' + GL.immediate.clientActiveTexture;
     } else {
       throw "Wrong mode " + mode + " passed to glMatrixMode";
     }
diff --git a/tests/cubegeom_texturematrix.c b/tests/cubegeom_texturematrix.c
new file mode 100644
index 00000000..229bf2a8
--- /dev/null
+++ b/tests/cubegeom_texturematrix.c
@@ -0,0 +1,312 @@
+/*
+THIS WORK, INCLUDING THE SOURCE CODE, DOCUMENTATION
+AND RELATED MEDIA AND DATA, IS PLACED INTO THE PUBLIC DOMAIN.
+
+THE ORIGINAL AUTHOR IS KYLE FOLEY.
+
+THIS SOFTWARE IS PROVIDED AS-IS WITHOUT WARRANTY
+OF ANY KIND, NOT EVEN THE IMPLIED WARRANTY OF
+MERCHANTABILITY. THE AUTHOR OF THIS SOFTWARE,
+ASSUMES _NO_ RESPONSIBILITY FOR ANY CONSEQUENCE
+RESULTING FROM THE USE, MODIFICATION, OR
+REDISTRIBUTION OF THIS SOFTWARE.
+*/
+
+#if !EMSCRIPTEN
+#define USE_GLEW 1
+#endif
+
+#if USE_GLEW
+#include "GL/glew.h"
+#endif
+
+#include "SDL/SDL.h"
+#if !USE_GLEW
+#include "SDL/SDL_opengl.h"
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+void verify() {
+  int width = 640, height = 480;
+  unsigned char *data = (unsigned char*)malloc(width*height*4);
+  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, data);
+  int sum = 0;
+  for (int x = 0; x < width*height*4; x++) {
+    if (x % 4 != 3) sum += x * data[x];
+  }
+#if EMSCRIPTEN
+  int result = sum;
+  REPORT_RESULT();
+#endif
+}
+
+int main(int argc, char *argv[])
+{
+    SDL_Surface *screen;
+    if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) {
+        printf("Unable to initialize SDL: %s\n", SDL_GetError());
+        return 1;
+    }
+
+    SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+    screen = SDL_SetVideoMode( 640, 480, 24, SDL_OPENGL );
+    if ( !screen ) {
+        printf("Unable to set video mode: %s\n", SDL_GetError());
+        return 1;
+    }
+    
+    glClearColor( 0, 0, 0, 0 );
+    glClear( GL_COLOR_BUFFER_BIT );
+
+    // Create a texture
+
+    GLuint texture;
+    glGenTextures( 1, &texture );
+    glBindTexture( GL_TEXTURE_2D, texture );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    GLubyte textureData[16*16*4];
+    for (int x = 0; x < 16; x++) {
+      for (int y = 0; y < 16; y++) {
+        *((int*)&textureData[(x*16 + y) * 4]) = x*16 + ((y*16) << 8);
+      }
+    }
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, 
+                  GL_RGBA, GL_UNSIGNED_BYTE, textureData );
+
+    // Create a second texture
+
+    GLuint texture2;
+    glGenTextures( 1, &texture2 );
+    glBindTexture( GL_TEXTURE_2D, texture2 );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    GLubyte texture2Data[] = { 0xff,    0,    0, 0xff,
+                                  0, 0xff,    0, 0xaa,
+                                  0,    0, 0xff, 0x55,
+                               0x80, 0x90, 0x70,    0 };
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0,
+                  GL_RGBA, GL_UNSIGNED_BYTE, texture2Data );
+    
+    // BEGIN
+
+#if USE_GLEW
+    glewInit();
+#endif
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    // original: glFrustum(-0.6435469817188064, 0.6435469817188064 ,-0.48266022190470925, 0.48266022190470925 ,0.5400000214576721, 2048);
+    glFrustum(-0.6435469817188064, 0.1435469817188064 ,-0.48266022190470925, 0.88266022190470925 ,0.5400000214576721, 2048);
+    glRotatef(-30, 1, 1, 1);
+    //GLfloat pm[] = { 1.372136116027832, 0, 0, 0, 0, 0.7910231351852417, 0, 0, -0.6352481842041016, 0.29297152161598206, -1.0005275011062622, -1, 0, 0, -1.080284833908081, 0 };
+    //glLoadMatrixf(pm);
+
+    glMatrixMode(GL_MODELVIEW);
+    GLfloat matrixData[] = { -1, 0, 0, 0,
+                              0, 0,-1, 0,
+                              0, 1, 0, 0,
+                              0, 0, 0, 1 };
+    glLoadMatrixf(matrixData);
+
+    glActiveTexture(GL_TEXTURE0); // TODO: try 1
+    glMatrixMode(GL_TEXTURE);
+    GLfloat tm[] = { 1, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5 };
+    glLoadMatrixf(tm);
+
+    glEnable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+
+    glClear(GL_DEPTH_BUFFER_BIT);
+
+    glEnableClientState(GL_NORMAL_ARRAY);
+    glEnableClientState(GL_COLOR_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glActiveTexture(GL_TEXTURE0);
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+
+    GLuint arrayBuffer, elementBuffer;
+    glGenBuffers(1, &arrayBuffer);
+    glGenBuffers(1, &elementBuffer);
+
+    GLubyte arrayData[] = {
+/*
+[0, 0,   0, 67] ==>  128 float
+[0, 0, 128, 67] ==>  256 float
+[0, 0,   0, 68] ==>  512 float
+[0, 0, 128, 68] ==> 1024 float
+
+[vertex x        ] [vertex y         ] [vertex z         ] [nr]                [texture u        ] [texture v        ] [lm u   ] [lm v   ] [color r,g,b,a    ] */
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 255, 128, 255, 128, //  0
+  0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,   0,   0,   0,   0,   0, 128, 0, 255, 128, //  1
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 64, 255, 128, //  2
+  0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,   0, 128, 128, 255, 255, //  3
+  0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,   0,   0,   0,   0,   0, 196, 128, 255, 128, //  4
+  0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  67,   0,   0,   0,   0,   0,   0,   0,   0, 128, 0, 255, 128, //  5
+  0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 128, 255, 128, //  6
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 64, 255, 0, //  7
+  0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,   0, 64, 128, 255, 128, //  8
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 0, 255, 128, //  9
+  0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0, 128,  67,   0,   0,   0,   0, 128, 128, 255, 128, // 10
+  0,   0,   0,   0,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128,  67,   0,   0,   0,   0, 128, 128, 255, 0, // 11
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,  67,   0,   0,   0,   0, 100, 128, 255, 128, // 12
+  0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 0, 255, 128, // 13
+  0,   0, 128,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  67,   0,   0, 128,  67,   0,   0,   0,   0, 128, 128, 255, 128, // 14
+  0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0, 128,  67,   0,   0,   0,   0, 128, 128, 255, 0, // 15
+
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,   0,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0, 128,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0, 128,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,   0,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,   0,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0, 128,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0,   0,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0, 128,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
+  0,   0, 128,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128
+    };
+    assert(sizeof(arrayData) == 1408);
+    glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(arrayData), arrayData, GL_STATIC_DRAW);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+    GLushort elementData[] = { 1, 2, 0, 2, 3, 0, 5, 6, 4, 6, 7, 4, 9, 10, 8, 10, 11, 8, 13, 14, 12, 14, 15, 12 };
+    assert(sizeof(elementData) == 48);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elementData), elementData, GL_STATIC_DRAW);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+    glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
+
+    // sauer vertex data is apparently 0-12: V3F, 12: N1B, 16-24: T2F, 24-28: T2S, 28-32: C4B
+    glVertexPointer(3, GL_FLOAT, 32, (void*)0); // all these apply to the ARRAY_BUFFER that is bound
+    glTexCoordPointer(2, GL_FLOAT, 32, (void*)16);
+    glClientActiveTexture(GL_TEXTURE1); // XXX seems to be ignored in native build
+    glTexCoordPointer(2, GL_SHORT, 32, (void*)24);
+    glClientActiveTexture(GL_TEXTURE0); // likely not needed, it is a cleanup
+    glNormalPointer(GL_BYTE, 32, (void*)12);
+    glColorPointer(4, GL_UNSIGNED_BYTE, 32, (void*)28);
+
+    glBindTexture(GL_TEXTURE_2D, texture); // diffuse?
+    glActiveTexture(GL_TEXTURE0);
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, texture2); // lightmap?
+    glActiveTexture(GL_TEXTURE0);
+
+    GLint ok;
+
+    const char *vertexShader = "uniform vec4 texgenscroll;\n"
+                               "void main(void)\n"
+                               "{\n"
+                               "    gl_Position = gl_TextureMatrix[0] * ftransform();\n"
+                               "    gl_TexCoord[0].xy = gl_MultiTexCoord0.xy/100.0 + texgenscroll.xy;\n" // added /100 here
+                               "    gl_TexCoord[1] = gl_Color;\n"
+                               "}\n";
+    const char *fragmentShader = "uniform vec4 colorparams;\n"
+                                 "uniform sampler2D diffusemap, lightmap;\n"
+                                 "void main(void)\n"
+                                 "{\n"
+                                 "    vec4 diffuse = texture2D(diffusemap, gl_TexCoord[0].xy);\n"
+                                 "    vec4 lm = texture2D(lightmap, gl_TexCoord[1].xy);\n"
+                                 "    diffuse *= colorparams;\n"
+                                 "    gl_FragColor = (diffuse * lm * 0.2) +  gl_TexCoord[1];\n"
+                                 "}\n";
+
+    GLuint vs = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vs, 1, &vertexShader, NULL);
+    glCompileShader(vs);
+    glGetShaderiv ( vs, GL_COMPILE_STATUS, &ok );
+    if ( !ok ) 
+    {
+       GLint infoLen = 0;
+       glGetShaderiv ( vs, GL_INFO_LOG_LENGTH, &infoLen );
+       if ( infoLen > 1 )
+       {
+          char* infoLog = (char*)malloc (sizeof(char) * infoLen );
+          glGetShaderInfoLog ( vs, infoLen, NULL, infoLog );
+          printf ( "Error compiling shader:\n%s\n", infoLog );            
+          free ( infoLog );
+       }
+       glDeleteShader ( vs );
+       return 0;
+    }
+
+    GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fs, 1, &fragmentShader, NULL);
+    glCompileShader(fs);
+    glGetShaderiv(fs, GL_COMPILE_STATUS, &ok);
+    assert(ok);
+
+    GLuint program = glCreateProgram();
+
+    glAttachShader(program, vs);
+    glAttachShader(program, fs);
+    glLinkProgram(program);
+    glGetProgramiv(program, GL_LINK_STATUS, &ok);
+    assert(ok);
+
+    glUseProgram(program);
+
+    GLint lightmapLocation = glGetUniformLocation(program, "lightmap");
+    assert(lightmapLocation >= 0);
+    glUniform1i(lightmapLocation, 1); // sampler2D? Is it the texture unit?
+
+    GLint diffusemapLocation = glGetUniformLocation(program, "diffusemap");
+    assert(diffusemapLocation >= 0);
+    glUniform1i(diffusemapLocation, 0);
+
+    GLint texgenscrollLocation = glGetUniformLocation(program, "texgenscroll");
+    assert(texgenscrollLocation >= 0);
+
+    GLint colorparamsLocation = glGetUniformLocation(program, "colorparams");
+    assert(colorparamsLocation >= 0);
+
+    GLfloat texgenscrollData[] = { 0, 0, 0, 0 };
+    glUniform4fv(texgenscrollLocation, 1, texgenscrollData);
+
+    GLfloat colorparamsData[] = { 2, 2, 2, 1 };
+    glUniform4fv(colorparamsLocation, 1, colorparamsData);
+
+    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)12);
+    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*) 0);
+    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)24);
+    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)36);
+
+    // END
+
+    SDL_GL_SwapBuffers();
+
+    verify();
+   
+#if !EMSCRIPTEN
+    SDL_Delay(1500);
+#endif
+
+    SDL_Quit();
+    
+    return 0;
+}
diff --git a/tests/runner.py b/tests/runner.py
index a1a3425a..8e4b42f0 100755
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -7299,6 +7299,9 @@ elif 'browser' in str(sys.argv):
     def test_cubegeom_color2(self):
       self.btest('cubegeom_color2.c', expected='1121999515')
 
+    def test_cubegeom_texturematrix(self):
+      self.btest('cubegeom_texturematrix.c', expected='1297500583')
+
     def test_pre_run_deps(self):
       # Adding a dependency in preRun will delay run
       open(os.path.join(self.get_dir(), 'pre.js'), 'w').write('''