FixedFuncPipeline: Optimize shader resource, if preset != ShaderSelectionMode.AUTO (good for mobile); Lazy shader instantiation.

8 files changed, 214 insertions, 84 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/ShaderSelectionMode.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/ShaderSelectionMode.java
index fba4b755e..e6bdf702c 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/ShaderSelectionMode.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/ShaderSelectionMode.java
@@ -14,10 +14,14 @@ public enum ShaderSelectionMode {
     AUTO, 
     /** Fixed shader selection: Simple color. */
     COLOR, 
-    /** Fixed shader selection: Multi-Textured color. */
-    COLOR_TEXTURE, 
+    /** Fixed shader selection: Multi-Textured color. 2 texture units. */
+    COLOR_TEXTURE2, 
+    /** Fixed shader selection: Multi-Textured color. 4 texture units. */
+    COLOR_TEXTURE4, 
+    /** Fixed shader selection: Multi-Textured color. 8 texture units. */
+    COLOR_TEXTURE8, 
     /** Fixed shader selection: Color with vertex-lighting. */
     COLOR_LIGHT_PER_VERTEX, 
-    /** Fixed shader selection: Multi-Textured color with vertex-lighting. */
-    COLOR_TEXTURE_LIGHT_PER_VERTEX 
+    /** Fixed shader selection: Multi-Textured color with vertex-lighting. 8 texture units.*/
+    COLOR_TEXTURE8_LIGHT_PER_VERTEX 
 }
\ No newline at end of file
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java
index be9fe8c34..b7097b0fd 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/FixedFuncPipeline.java
@@ -62,20 +62,33 @@ import com.jogamp.opengl.util.glsl.fixedfunc.ShaderSelectionMode;
  */
 public class FixedFuncPipeline {
     protected static final boolean DEBUG = Debug.isPropertyDefined("jogl.debug.FixedFuncPipeline", true);
+    /** The maximum texture units which could be used, depending on {@link ShaderSelectionMode}. */
     public static final int MAX_TEXTURE_UNITS = 8;
     public static final int MAX_LIGHTS        = 8;
     
     public FixedFuncPipeline(GL2ES2 gl, ShaderSelectionMode mode, PMVMatrix pmvMatrix) {
-        init(gl, mode, pmvMatrix, FixedFuncPipeline.class, shaderSrcRootDef, 
-             shaderBinRootDef, vertexColorFileDef, vertexColorLightFileDef, fragmentColorFileDef, fragmentColorTextureFileDef);
-    }
-    public FixedFuncPipeline(GL2ES2 gl, ShaderSelectionMode mode, PMVMatrix pmvMatrix, Class<?> shaderRootClass, String shaderSrcRoot, 
-                       String shaderBinRoot,
-                       String vertexColorFile,
-                       String vertexColorLightFile,
-                       String fragmentColorFile, String fragmentColorTextureFile) {
-        init(gl, mode, pmvMatrix, shaderRootClass, shaderSrcRoot, 
-             shaderBinRoot, vertexColorFile, vertexColorLightFile, fragmentColorFile, fragmentColorTextureFile);
+        shaderRootClass = FixedFuncPipeline.class;
+        shaderSrcRoot = shaderSrcRootDef;
+        shaderBinRoot = shaderBinRootDef;
+        vertexColorFile = vertexColorFileDef;
+        vertexColorLightFile = vertexColorLightFileDef;
+        fragmentColorFile = fragmentColorFileDef;
+        fragmentColorTextureFile = fragmentColorTextureFileDef;
+        init(gl, mode, pmvMatrix);
+    }
+    public FixedFuncPipeline(GL2ES2 gl, ShaderSelectionMode mode, PMVMatrix pmvMatrix, 
+                             Class<?> shaderRootClass, String shaderSrcRoot, 
+                             String shaderBinRoot,
+                             String vertexColorFile, String vertexColorLightFile,
+                             String fragmentColorFile, String fragmentColorTextureFile) {
+        this.shaderRootClass = shaderRootClass;
+        this.shaderSrcRoot = shaderSrcRoot;
+        this.shaderBinRoot = shaderBinRoot;
+        this.vertexColorFile = vertexColorFile;
+        this.vertexColorLightFile = vertexColorLightFile;
+        this.fragmentColorFile = fragmentColorFile;
+        this.fragmentColorTextureFile = fragmentColorTextureFile;
+        init(gl, mode, pmvMatrix); 
     }
     
     public ShaderSelectionMode getShaderSelectionMode() { return shaderSelectionMode; }
@@ -98,10 +111,24 @@ public class FixedFuncPipeline {
     }
 
     public void destroy(GL2ES2 gl) {
-        shaderProgramColor.release(gl, true);
-        shaderProgramColorLight.release(gl, true);
-        shaderProgramColorTexture.release(gl, true);
-        shaderProgramColorTextureLight.release(gl, true);
+        if(null != shaderProgramColor) {
+            shaderProgramColor.release(gl, true);
+        }
+        if(null != shaderProgramColorLight) {
+            shaderProgramColorLight.release(gl, true);
+        }
+        if(null != shaderProgramColorTexture2) {
+            shaderProgramColorTexture2.release(gl, true);
+        }
+        if(null != shaderProgramColorTexture4) {
+            shaderProgramColorTexture4.release(gl, true);
+        }
+        if(null != shaderProgramColorTexture4) {
+            shaderProgramColorTexture4.release(gl, true);
+        }
+        if(null != shaderProgramColorTexture8Light) {
+            shaderProgramColorTexture8Light.release(gl, true);
+        }
         shaderState.destroy(gl);
     }
 
@@ -562,9 +589,10 @@ public class FixedFuncPipeline {
             // pre-validate shader switch
             if( 0 != textureEnabledBits ) {
                 if(lightingEnabled) {
-                    newMode = ShaderSelectionMode.COLOR_TEXTURE_LIGHT_PER_VERTEX;
+                    newMode = ShaderSelectionMode.COLOR_TEXTURE8_LIGHT_PER_VERTEX;
                 } else {
-                    newMode = ShaderSelectionMode.COLOR_TEXTURE;
+                    // in auto mode, we simply use max texture units
+                    newMode = ShaderSelectionMode.COLOR_TEXTURE8;
                 }
             } else {
                 if(lightingEnabled) {
@@ -683,9 +711,11 @@ public class FixedFuncPipeline {
         sb.append("\n\t lightingEnabled: "+lightingEnabled);
         sb.append(", lightsEnabled: "); Buffers.toString(sb, null, lightsEnabled);
         sb.append("\n\t, shaderProgramColor: "+shaderProgramColor);
-        sb.append("\n\t, shaderProgramColorTexture: "+shaderProgramColorTexture);
+        sb.append("\n\t, shaderProgramColorTexture2: "+shaderProgramColorTexture2);
+        sb.append("\n\t, shaderProgramColorTexture4: "+shaderProgramColorTexture4);
+        sb.append("\n\t, shaderProgramColorTexture8: "+shaderProgramColorTexture8);
         sb.append("\n\t, shaderProgramColorLight: "+shaderProgramColorLight);
-        sb.append("\n\t, shaderProgramColorTextureLight: "+shaderProgramColorTextureLight);
+        sb.append("\n\t, shaderProgramColorTexture8Light: "+shaderProgramColorTexture8Light);
         sb.append("\n\t, ShaderState: ");
         shaderState.toString(sb, alsoUnlocated);
         sb.append("]");
@@ -695,19 +725,126 @@ public class FixedFuncPipeline {
         return toString(null, DEBUG).toString();
     }
 
+    private static final String constMaxShader0 = "#define MAX_TEXTURE_UNITS 0\n";
+    private static final String constMaxShader2 = "#define MAX_TEXTURE_UNITS 2\n";
+    private static final String constMaxShader4 = "#define MAX_TEXTURE_UNITS 4\n";
+    private static final String constMaxShader8 = "#define MAX_TEXTURE_UNITS 8\n";
+    
+    private void loadShader(GL2ES2 gl, ShaderSelectionMode mode) {
+        final boolean loadColor = ShaderSelectionMode.COLOR == mode;
+        final boolean loadColorTexture2 = ShaderSelectionMode.COLOR_TEXTURE2 == mode;
+        final boolean loadColorTexture4 = ShaderSelectionMode.COLOR_TEXTURE4 == mode;
+        final boolean loadColorTexture8 = ShaderSelectionMode.COLOR_TEXTURE8 == mode;
+        final boolean loadColorTexture = loadColorTexture2 || loadColorTexture4 || loadColorTexture8 ; 
+        final boolean loadColorLightPerVertex = ShaderSelectionMode.COLOR_LIGHT_PER_VERTEX == mode;
+        final boolean loadColorTexture8LightPerVertex = ShaderSelectionMode.COLOR_TEXTURE8_LIGHT_PER_VERTEX == mode;
+
+        if( null != shaderProgramColor && loadColor ||
+            null != shaderProgramColorTexture2 && loadColorTexture2 ||
+            null != shaderProgramColorTexture4 && loadColorTexture4 ||
+            null != shaderProgramColorTexture8 && loadColorTexture8 ||
+            null != shaderProgramColorLight && loadColorLightPerVertex ||
+            null != shaderProgramColorTexture8Light && loadColorTexture8LightPerVertex ) {
+            return;
+        }
+        
+        if( loadColor ) {
+            final ShaderCode vp = ShaderCode.create( gl, GL2ES2.GL_VERTEX_SHADER, shaderRootClass, shaderSrcRoot,
+                                             shaderBinRoot, vertexColorFile, true);
+            final ShaderCode fp = ShaderCode.create( gl, GL2ES2.GL_FRAGMENT_SHADER, shaderRootClass, shaderSrcRoot,
+                                               shaderBinRoot, fragmentColorFile, true);
+            vp.insertShaderSource(0, 0, constMaxShader0);
+            fp.insertShaderSource(0, 0, constMaxShader0);
+            shaderProgramColor = new ShaderProgram();
+            shaderProgramColor.add(vp);
+            shaderProgramColor.add(fp);
+            if(!shaderProgramColor.link(gl, System.err)) {
+                throw new GLException("Couldn't link VertexColor program: "+shaderProgramColor);
+            }
+        } else  if( loadColorTexture ) {
+            final ShaderCode vp = ShaderCode.create( gl, GL2ES2.GL_VERTEX_SHADER, shaderRootClass, shaderSrcRoot, shaderBinRoot, vertexColorFile, true);
+            final ShaderCode fp = ShaderCode.create( gl, GL2ES2.GL_FRAGMENT_SHADER, shaderRootClass, shaderSrcRoot,
+                                                     shaderBinRoot, fragmentColorTextureFile, true);
+            
+            if( loadColorTexture2 ) {
+                vp.insertShaderSource(0, 0, constMaxShader2);
+                fp.insertShaderSource(0, 0, constMaxShader2);                
+                shaderProgramColorTexture2 = new ShaderProgram();
+                shaderProgramColorTexture2.add(vp);
+                shaderProgramColorTexture2.add(fp);
+                if(!shaderProgramColorTexture2.link(gl, System.err)) {
+                    throw new GLException("Couldn't link VertexColorTexture2 program: "+shaderProgramColorTexture2);
+                }
+            } else if( loadColorTexture4 ) {
+                vp.insertShaderSource(0, 0, constMaxShader4);
+                fp.insertShaderSource(0, 0, constMaxShader4);
+                shaderProgramColorTexture4 = new ShaderProgram();
+                shaderProgramColorTexture4.add(vp);
+                shaderProgramColorTexture4.add(fp);
+                if(!shaderProgramColorTexture4.link(gl, System.err)) {
+                    throw new GLException("Couldn't link VertexColorTexture4 program: "+shaderProgramColorTexture4);
+                }
+            } else if( loadColorTexture8 ) {
+                vp.insertShaderSource(0, 0, constMaxShader8);
+                fp.insertShaderSource(0, 0, constMaxShader8);
+                shaderProgramColorTexture8 = new ShaderProgram();
+                shaderProgramColorTexture8.add(vp);
+                shaderProgramColorTexture8.add(fp);
+                if(!shaderProgramColorTexture8.link(gl, System.err)) {
+                    throw new GLException("Couldn't link VertexColorTexture8 program: "+shaderProgramColorTexture8);
+                }
+            }
+        } else if( loadColorLightPerVertex ) {
+            final ShaderCode vp = ShaderCode.create( gl, GL2ES2.GL_VERTEX_SHADER, shaderRootClass, shaderSrcRoot,
+                                               shaderBinRoot, vertexColorLightFile, true);
+            final ShaderCode fp = ShaderCode.create( gl, GL2ES2.GL_FRAGMENT_SHADER, shaderRootClass, shaderSrcRoot,
+                                               shaderBinRoot, fragmentColorFile, true);
+            vp.insertShaderSource(0, 0, constMaxShader0);
+            fp.insertShaderSource(0, 0, constMaxShader0);
+            shaderProgramColorLight = new ShaderProgram();
+            shaderProgramColorLight.add(vp);
+            shaderProgramColorLight.add(fp);
+            if(!shaderProgramColorLight.link(gl, System.err)) {
+                throw new GLException("Couldn't link VertexColorLight program: "+shaderProgramColorLight);
+            }
+        }  else if( loadColorTexture8LightPerVertex ) {
+            final ShaderCode vp = ShaderCode.create( gl, GL2ES2.GL_VERTEX_SHADER, shaderRootClass, shaderSrcRoot,
+                                               shaderBinRoot, vertexColorLightFile, true);
+            final ShaderCode fp = ShaderCode.create( gl, GL2ES2.GL_FRAGMENT_SHADER, shaderRootClass, shaderSrcRoot,
+                                                     shaderBinRoot, fragmentColorTextureFile, true);
+            vp.insertShaderSource(0, 0, constMaxShader8);
+            fp.insertShaderSource(0, 0, constMaxShader8);
+            shaderProgramColorTexture8Light = new ShaderProgram();
+            shaderProgramColorTexture8Light.add(vp);
+            shaderProgramColorTexture8Light.add(fp);
+            if(!shaderProgramColorTexture8Light.link(gl, System.err)) {
+                throw new GLException("Couldn't link VertexColorLight program: "+shaderProgramColorTexture8Light);
+            }
+        }
+    }
+    
     private ShaderProgram selectShaderProgram(GL2ES2 gl, ShaderSelectionMode mode) {
+        if(ShaderSelectionMode.AUTO == mode) {
+            mode = ShaderSelectionMode.COLOR;
+        }
+        loadShader(gl, mode);
         final ShaderProgram sp;
         switch(mode) {
             case COLOR_LIGHT_PER_VERTEX:
                 sp = shaderProgramColorLight;
                 break;
-            case COLOR_TEXTURE:
-                sp = shaderProgramColorTexture;
+            case COLOR_TEXTURE2:
+                sp = shaderProgramColorTexture2;
+                break;
+            case COLOR_TEXTURE4:
+                sp = shaderProgramColorTexture4;
+                break;
+            case COLOR_TEXTURE8:
+                sp = shaderProgramColorTexture8;
                 break;
-            case COLOR_TEXTURE_LIGHT_PER_VERTEX:
-                sp = shaderProgramColorTextureLight;
+            case COLOR_TEXTURE8_LIGHT_PER_VERTEX:
+                sp = shaderProgramColorTexture8Light;
                 break;
-            case AUTO:
             case COLOR:
             default:
                 sp = shaderProgramColor;
@@ -715,12 +852,7 @@ public class FixedFuncPipeline {
         return sp;
     }
     
-    private void init(GL2ES2 gl, ShaderSelectionMode mode, PMVMatrix pmvMatrix, Class<?> shaderRootClass, String shaderSrcRoot, 
-                      String shaderBinRoot,
-                      String vertexColorFile,
-                      String vertexColorLightFile,
-                      String fragmentColorFile, String fragmentColorTextureFile) 
-   {
+    private void init(GL2ES2 gl, ShaderSelectionMode mode, PMVMatrix pmvMatrix) { 
         if(null==pmvMatrix) {
             throw new GLException("PMVMatrix is null");
         }
@@ -728,47 +860,6 @@ public class FixedFuncPipeline {
         this.shaderSelectionMode = mode;
         this.shaderState=new ShaderState();
         this.shaderState.setVerbose(verbose);
-        ShaderCode vertexColor, vertexColorLight, fragmentColor, fragmentColorTexture;
-
-        vertexColor = ShaderCode.create( gl, GL2ES2.GL_VERTEX_SHADER, shaderRootClass, shaderSrcRoot,
-                                         shaderBinRoot, vertexColorFile, false);
-
-        vertexColorLight = ShaderCode.create( gl, GL2ES2.GL_VERTEX_SHADER, shaderRootClass, shaderSrcRoot,
-                                           shaderBinRoot, vertexColorLightFile, false);
-
-        fragmentColor = ShaderCode.create( gl, GL2ES2.GL_FRAGMENT_SHADER, shaderRootClass, shaderSrcRoot,
-                                           shaderBinRoot, fragmentColorFile, false);
-
-        fragmentColorTexture = ShaderCode.create( gl, GL2ES2.GL_FRAGMENT_SHADER, shaderRootClass, shaderSrcRoot,
-                                                  shaderBinRoot, fragmentColorTextureFile, false);
-
-        shaderProgramColor = new ShaderProgram();
-        shaderProgramColor.add(vertexColor);
-        shaderProgramColor.add(fragmentColor);
-        if(!shaderProgramColor.link(gl, System.err)) {
-            throw new GLException("Couldn't link VertexColor program: "+shaderProgramColor);
-        }
-
-        shaderProgramColorTexture = new ShaderProgram();
-        shaderProgramColorTexture.add(vertexColor);
-        shaderProgramColorTexture.add(fragmentColorTexture);
-        if(!shaderProgramColorTexture.link(gl, System.err)) {
-            throw new GLException("Couldn't link VertexColorTexture program: "+shaderProgramColorTexture);
-        }
-
-        shaderProgramColorLight = new ShaderProgram();
-        shaderProgramColorLight.add(vertexColorLight);
-        shaderProgramColorLight.add(fragmentColor);
-        if(!shaderProgramColorLight.link(gl, System.err)) {
-            throw new GLException("Couldn't link VertexColorLight program: "+shaderProgramColorLight);
-        }
-
-        shaderProgramColorTextureLight = new ShaderProgram();
-        shaderProgramColorTextureLight.add(vertexColorLight);
-        shaderProgramColorTextureLight.add(fragmentColorTexture);
-        if(!shaderProgramColorTextureLight.link(gl, System.err)) {
-            throw new GLException("Couldn't link VertexColorLight program: "+shaderProgramColorTextureLight);
-        }
 
         shaderState.attachShaderProgram(gl, selectShaderProgram(gl, shaderSelectionMode), true);
 
@@ -854,9 +945,9 @@ public class FixedFuncPipeline {
     private PMVMatrix pmvMatrix;
     private ShaderState shaderState;
     private ShaderProgram shaderProgramColor;
-    private ShaderProgram shaderProgramColorTexture;
+    private ShaderProgram shaderProgramColorTexture2, shaderProgramColorTexture4, shaderProgramColorTexture8;
     private ShaderProgram shaderProgramColorLight;
-    private ShaderProgram shaderProgramColorTextureLight;
+    private ShaderProgram shaderProgramColorTexture8Light;
     
     private ShaderSelectionMode shaderSelectionMode = ShaderSelectionMode.AUTO;
 
@@ -904,11 +995,19 @@ public class FixedFuncPipeline {
     public static final FloatBuffer defMatEmission  = neut4f;
     public static final float       defMatShininess = 0f;
 
-    private static final String vertexColorFileDef          = "FixedFuncColor";
-    private static final String vertexColorLightFileDef     = "FixedFuncColorLight";
-    private static final String fragmentColorFileDef        = "FixedFuncColor";
-    private static final String fragmentColorTextureFileDef = "FixedFuncColorTexture";
-    private static final String shaderSrcRootDef            = "shaders" ;
-    private static final String shaderBinRootDef            = "shaders/bin" ;
+    private static final String vertexColorFileDef           = "FixedFuncColor";
+    private static final String vertexColorLightFileDef      = "FixedFuncColorLight";
+    private static final String fragmentColorFileDef         = "FixedFuncColor";
+    private static final String fragmentColorTextureFileDef  = "FixedFuncColorTexture";
+    private static final String shaderSrcRootDef             = "shaders" ;
+    private static final String shaderBinRootDef             = "shaders/bin" ;
+    
+    private final Class<?> shaderRootClass;
+    private final String shaderSrcRoot; 
+    private final String shaderBinRoot;
+    private final String vertexColorFile;
+    private final String vertexColorLightFile;
+    private final String fragmentColorFile;
+    private final String fragmentColorTextureFile;     
 }
 
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/FixedFuncColorTexture.fp b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/FixedFuncColorTexture.fp
index edaa00a57..9d02a0f6c 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/FixedFuncColorTexture.fp
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/FixedFuncColorTexture.fp
@@ -61,18 +61,23 @@ void main (void)
   } else {
       int texEnv = 0;
 
+      #if MAX_TEXTURE_UNITS >= 2
       if( 0 != mgl_TextureEnabled[0] ) {
         calcTexColor(color, texture2D(mgl_Texture0, mgl_TexCoords[0].st), mgl_TexFormat[0], mgl_TexEnvMode[0]);
       }
       if( 0 != mgl_TextureEnabled[1] ) {
         calcTexColor(color, texture2D(mgl_Texture1, mgl_TexCoords[1].st), mgl_TexFormat[1], mgl_TexEnvMode[1]);
       }
+      #endif
+      #if MAX_TEXTURE_UNITS >= 4
       if( 0 != mgl_TextureEnabled[2] ) {
         calcTexColor(color, texture2D(mgl_Texture2, mgl_TexCoords[2].st), mgl_TexFormat[2], mgl_TexEnvMode[2]);
       }
       if( 0 != mgl_TextureEnabled[3] ) {
         calcTexColor(color, texture2D(mgl_Texture3, mgl_TexCoords[3].st), mgl_TexFormat[3], mgl_TexEnvMode[3]);
       }
+      #endif
+      #if MAX_TEXTURE_UNITS >= 8
       if( 0 != mgl_TextureEnabled[4] ) {
         calcTexColor(color, texture2D(mgl_Texture4, mgl_TexCoords[4].st), mgl_TexFormat[4], mgl_TexEnvMode[4]);
       }
@@ -85,6 +90,7 @@ void main (void)
       if( 0 != mgl_TextureEnabled[7] ) {
         calcTexColor(color, texture2D(mgl_Texture7, mgl_TexCoords[7].st), mgl_TexFormat[7], mgl_TexEnvMode[7]);
       }
+      #endif
       if( mgl_AlphaTestFunc > 0 ) {
           alphaTest(color);
       }
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_attribute.glsl b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_attribute.glsl
index 09a11ec95..59dcb626f 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_attribute.glsl
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_attribute.glsl
@@ -7,13 +7,19 @@
 attribute HIGHP vec4    mgl_Vertex;
 attribute HIGHP vec4    mgl_Normal;
 attribute HIGHP vec4    mgl_Color;
+#if MAX_TEXTURE_UNITS >= 2
 attribute HIGHP vec4    mgl_MultiTexCoord0;
 attribute HIGHP vec4    mgl_MultiTexCoord1;
+#endif
+#if MAX_TEXTURE_UNITS >= 4
 attribute HIGHP vec4    mgl_MultiTexCoord2;
 attribute HIGHP vec4    mgl_MultiTexCoord3;
+#endif
+#if MAX_TEXTURE_UNITS >= 8
 attribute HIGHP vec4    mgl_MultiTexCoord4;
 attribute HIGHP vec4    mgl_MultiTexCoord5;
 attribute HIGHP vec4    mgl_MultiTexCoord6;
 attribute HIGHP vec4    mgl_MultiTexCoord7;
+#endif
 
 #endif // mgl_attribute_glsl
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_const.glsl b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_const.glsl
index d45b593e2..e8b7d5d41 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_const.glsl
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_const.glsl
@@ -4,7 +4,7 @@
 
 #include es_precision.glsl
 
-const   LOWP int     MAX_TEXTURE_UNITS = 8; // <=gl_MaxTextureImageUnits 
+// will be defined at runtime: MAX_TEXTURE_UNITS [0|2|4|8]
 const   LOWP int     MAX_LIGHTS = 8; 
 
 const  HIGHP float   EPSILON =  0.0000001;  // FIXME: determine proper hw-precision
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_settexcoord.vp b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_settexcoord.vp
index 1efe328d0..cbf0db642 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_settexcoord.vp
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_settexcoord.vp
@@ -22,14 +22,20 @@ void setTexCoord(in vec4 defpos) {
   mgl_TexCoords[7] = ( 0 != (mgl_TexCoordEnabled & 128) ) ? mgl_MultiTexCoord7 : defpos;
    */
   
+  #if MAX_TEXTURE_UNITS >= 2
   mgl_TexCoords[0] = ( 0 != mgl_TexCoordEnabled[0] ) ? mgl_MultiTexCoord0 : defpos;
   mgl_TexCoords[1] = ( 0 != mgl_TexCoordEnabled[1] ) ? mgl_MultiTexCoord1 : defpos;
+  #endif
+  #if MAX_TEXTURE_UNITS >= 4
   mgl_TexCoords[2] = ( 0 != mgl_TexCoordEnabled[2] ) ? mgl_MultiTexCoord2 : defpos;
   mgl_TexCoords[3] = ( 0 != mgl_TexCoordEnabled[3] ) ? mgl_MultiTexCoord3 : defpos;
+  #endif
+  #if MAX_TEXTURE_UNITS >= 8
   mgl_TexCoords[4] = ( 0 != mgl_TexCoordEnabled[4] ) ? mgl_MultiTexCoord4 : defpos;
   mgl_TexCoords[5] = ( 0 != mgl_TexCoordEnabled[5] ) ? mgl_MultiTexCoord5 : defpos;
   mgl_TexCoords[6] = ( 0 != mgl_TexCoordEnabled[6] ) ? mgl_MultiTexCoord6 : defpos;
   mgl_TexCoords[7] = ( 0 != mgl_TexCoordEnabled[7] ) ? mgl_MultiTexCoord7 : defpos;
+  #endif
 }
 
 #endif // mgl_settexcoord_vp
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_uniform.glsl b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_uniform.glsl
index aeaa1314d..a2d91aa73 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_uniform.glsl
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_uniform.glsl
@@ -11,19 +11,26 @@ uniform LOWP    int     mgl_ColorEnabled;
 uniform HIGHP   vec4    mgl_ColorStatic;
 uniform LOWP    int     mgl_AlphaTestFunc;
 uniform HIGHP   float   mgl_AlphaTestRef;
+#if MAX_TEXTURE_UNITS > 0
 uniform LOWP    int     mgl_TextureEnabled[MAX_TEXTURE_UNITS];
 uniform LOWP    int     mgl_TexCoordEnabled[MAX_TEXTURE_UNITS];
 uniform LOWP    int     mgl_TexEnvMode[MAX_TEXTURE_UNITS];
 uniform LOWP    int     mgl_TexFormat[MAX_TEXTURE_UNITS];
+#if MAX_TEXTURE_UNITS >= 2
 uniform   sampler2D     mgl_Texture0;
 uniform   sampler2D     mgl_Texture1;
+#endif
+#if MAX_TEXTURE_UNITS >= 4
 uniform   sampler2D     mgl_Texture2;
 uniform   sampler2D     mgl_Texture3;
+#endif
+#if MAX_TEXTURE_UNITS >= 8
 uniform   sampler2D     mgl_Texture4;
 uniform   sampler2D     mgl_Texture5;
 uniform   sampler2D     mgl_Texture6;
 uniform   sampler2D     mgl_Texture7;
-uniform   sampler2D     mgl_Texture8;
+#endif
+#endif
 uniform LOWP    int     mgl_CullFace;
 
 #endif // mgl_uniform_glsl
diff --git a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_varying.glsl b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_varying.glsl
index fc9f735d1..599ac4a53 100644
--- a/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_varying.glsl
+++ b/src/jogl/classes/jogamp/opengl/util/glsl/fixedfunc/shaders/mgl_varying.glsl
@@ -7,6 +7,8 @@
 #include mgl_const.glsl
 
 varying   vec4    frontColor;
+#if MAX_TEXTURE_UNITS > 0
 varying   vec4    mgl_TexCoords[MAX_TEXTURE_UNITS];
+#endif
 
 #endif // mgl_varying_glsl