Copied JOGL_2_SANDBOX r1957 on to trunk; JOGL_2_SANDBOX branch is now closed

git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@1959 232f8b59-042b-4e1e-8c03-345bb8c30851

28 files changed, 3210 insertions, 0 deletions

diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/GLSLArrayHandler.java b/src/jogl/classes/com/sun/opengl/util/glsl/GLSLArrayHandler.java
new file mode 100644
index 000000000..1ef9874e4
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/GLSLArrayHandler.java
@@ -0,0 +1,60 @@
+
+package com.sun.opengl.util.glsl;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+import com.sun.opengl.util.*;
+import com.sun.opengl.util.glsl.ShaderState;
+import java.nio.*;
+
+public class GLSLArrayHandler implements GLArrayHandler {
+  private GLArrayDataEditable ad;
+
+  public GLSLArrayHandler(GLArrayDataEditable ad) {
+    this.ad = ad;
+  }
+
+  protected final void passVertexAttribPointer(GL2ES2 gl, ShaderState st) {
+    st.glVertexAttribPointer(gl, ad);
+  }
+
+  public void enableBuffer(GL gl, boolean enable) {
+    if(!gl.isGL2ES2()) {
+        throw new GLException("GLSLArrayHandler expects a GL2ES2 implementation");
+    }
+    GL2ES2 glsl = gl.getGL2ES2();
+    ShaderState st = ShaderState.getCurrent();
+    if(null==st) {
+        throw new GLException("No ShaderState current");
+    }
+
+    if(enable) {
+        st.glEnableVertexAttribArray(glsl, ad.getName());
+
+        Buffer buffer = ad.getBuffer();
+
+        if(ad.isVBO()) {
+            // always bind and refresh the VBO mgr,
+            // in case more than one gl*Pointer objects are in use
+            glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, ad.getVBOName());
+            if(!ad.isBufferWritten()) {
+                if(null!=buffer) {
+                    glsl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit() * ad.getComponentSize(), buffer, ad.getBufferUsage());
+                }
+                ad.setBufferWritten(true);
+            }
+            passVertexAttribPointer(glsl, st);
+        } else if(null!=buffer) {
+            passVertexAttribPointer(glsl, st);
+            ad.setBufferWritten(true);
+        }
+    } else {
+        if(ad.isVBO()) {
+            glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+        }
+        st.glDisableVertexAttribArray(glsl, ad.getName());
+    }
+  }
+
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/ShaderCode.java b/src/jogl/classes/com/sun/opengl/util/glsl/ShaderCode.java
new file mode 100644
index 000000000..6e7512e6a
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/ShaderCode.java
@@ -0,0 +1,367 @@
+
+package com.sun.opengl.util.glsl;
+
+import javax.media.opengl.*;
+import com.sun.opengl.util.*;
+
+import java.util.*;
+import java.nio.*;
+import java.io.*;
+import java.net.*;
+
+public class ShaderCode {
+    public static final String SUFFIX_VERTEX_SOURCE   =  "vp" ;
+    public static final String SUFFIX_VERTEX_BINARY   = "bvp" ;
+    public static final String SUFFIX_FRAGMENT_SOURCE =  "fp" ;
+    public static final String SUFFIX_FRAGMENT_BINARY = "bfp" ;
+    
+    public static final String SUB_PATH_NVIDIA = "nvidia" ;
+
+    public ShaderCode(int type, int number, String[][] source) {
+        switch (type) {
+            case GL2ES2.GL_VERTEX_SHADER:
+            case GL2ES2.GL_FRAGMENT_SHADER:
+                break;
+            default:
+                throw new GLException("Unknown shader type: "+type);
+        }
+        shaderSource = source;
+        shaderBinaryFormat = -1;
+        shaderBinary = null;
+        shaderType   = type;
+        shader = BufferUtil.newIntBuffer(number);
+        id = getNextID();
+    }
+
+    public ShaderCode(int type, int number, int binFormat, Buffer binary) {
+        switch (type) {
+            case GL2ES2.GL_VERTEX_SHADER:
+            case GL2ES2.GL_FRAGMENT_SHADER:
+                break;
+            default:
+                throw new GLException("Unknown shader type: "+type);
+        }
+        shaderSource = null;
+        shaderBinaryFormat = binFormat;
+        shaderBinary = binary;
+        shaderType   = type;
+        shader = BufferUtil.newIntBuffer(number);
+        id = getNextID();
+    }
+
+    public static ShaderCode create(GL2ES2 gl, int type, int number, Class context, String[] sourceFiles) {
+        if(!ShaderUtil.isShaderCompilerAvailable(gl)) return null;
+
+        String[][] shaderSources = null;
+        if(null!=sourceFiles) {
+            shaderSources = new String[sourceFiles.length][1];
+            for(int i=0; null!=shaderSources && i<sourceFiles.length; i++) {
+                shaderSources[i][0] = readShaderSource(context, sourceFiles[i]);
+                if(null == shaderSources[i][0]) {
+                    shaderSources = null;
+                }
+            }
+        }
+        if(null==shaderSources) {
+            return null;
+        }
+        return new ShaderCode(type, number, shaderSources);
+    }
+
+    public static ShaderCode create(int type, int number, Class context, int binFormat, String binaryFile) {
+        ByteBuffer shaderBinary = null;
+        if(null!=binaryFile && 0<=binFormat) {
+            shaderBinary = readShaderBinary(context, binaryFile);
+            if(null == shaderBinary) {
+                binFormat = -1;
+            }
+        }
+        if(null==shaderBinary) {
+            return null;
+        }
+        return new ShaderCode(type, number, binFormat, shaderBinary);
+    }
+
+    public static String getFileSuffix(boolean binary, int type) {
+        switch (type) {
+            case GL2ES2.GL_VERTEX_SHADER:
+                return binary?SUFFIX_VERTEX_BINARY:SUFFIX_VERTEX_SOURCE;
+            case GL2ES2.GL_FRAGMENT_SHADER:
+                return binary?SUFFIX_FRAGMENT_BINARY:SUFFIX_FRAGMENT_SOURCE;
+            default:
+                throw new GLException("illegal shader type: "+type);
+        }
+    }
+
+    public static String getBinarySubPath(int binFormat) {
+        switch (binFormat) {
+            case GLES2.GL_NVIDIA_PLATFORM_BINARY_NV:
+                return SUB_PATH_NVIDIA;
+            default:
+                throw new GLException("unsupported binary format: "+binFormat);
+        }
+    }
+
+    public static ShaderCode create(GL2ES2 gl, int type, int number, Class context, 
+                                    String srcRoot, String binRoot, String basename) {
+        ShaderCode res = null;
+        String srcFileName = null;
+        String binFileName = null;
+
+        if(ShaderUtil.isShaderCompilerAvailable(gl)) {
+            String srcPath[] = new String[1];
+            srcFileName = srcRoot + '/' + basename + "." + getFileSuffix(false, type);
+            srcPath[0] = srcFileName;
+            res = create(gl, type, number, context, srcPath);
+            if(null!=res) {
+                return res;
+            }
+        }
+        Set binFmts = ShaderUtil.getShaderBinaryFormats(gl);
+        for(Iterator iter=binFmts.iterator(); null==res && iter.hasNext(); ) {
+            int bFmt = ((Integer)(iter.next())).intValue();
+            String bFmtPath = getBinarySubPath(bFmt);
+            if(null==bFmtPath) continue;
+            binFileName = binRoot + '/' + bFmtPath + '/' + basename + "." + getFileSuffix(true, type);
+            res = create(type, number, context, bFmt, binFileName);
+        }
+
+        if(null==res) {
+            throw new GLException("No shader code found (source nor binary) for src: "+srcFileName+
+                                  ", bin: "+binFileName);
+        }
+
+        return res;
+    }
+
+    public static boolean createAndLoadShader(GL2ES2 gl, IntBuffer shader, int shaderType,
+                                              int binFormat, java.nio.Buffer bin,
+                                              PrintStream verboseOut)
+    {
+        int err = gl.glGetError(); // flush previous errors ..
+        if(err!=GL.GL_NO_ERROR && null!=verboseOut) {
+            verboseOut.println("createAndLoadShader: Pre GL Error: 0x"+Integer.toHexString(err));
+        }
+
+        ShaderUtil.createShader(gl, shaderType, shader);
+        err = gl.glGetError(); 
+        if(err!=GL.GL_NO_ERROR) {
+            throw new GLException("createAndLoadShader: CreateShader failed, GL Error: 0x"+Integer.toHexString(err));
+        }
+
+
+        ShaderUtil.shaderBinary(gl, shader, binFormat, bin);
+
+        err = gl.glGetError();
+        if(err!=GL.GL_NO_ERROR && null!=verboseOut) {
+            verboseOut.println("createAndLoadShader: ShaderBinary failed, GL Error: 0x"+Integer.toHexString(err));
+        }
+        return err == GL.GL_NO_ERROR;
+    }
+
+    public static boolean createAndCompileShader(GL2ES2 gl, IntBuffer shader, int shaderType,
+                                                 java.lang.String[][] sources, 
+                                                 PrintStream verboseOut)
+    {
+        int err = gl.glGetError(); // flush previous errors ..
+        if(err!=GL.GL_NO_ERROR && null!=verboseOut) {
+            verboseOut.println("createAndCompileShader: Pre GL Error: 0x"+Integer.toHexString(err));
+        }
+
+        ShaderUtil.createShader(gl, shaderType, shader);
+        err = gl.glGetError(); 
+        if(err!=GL.GL_NO_ERROR) {
+            throw new GLException("createAndCompileShader: CreateShader failed, GL Error: 0x"+Integer.toHexString(err));
+        }
+
+        ShaderUtil.shaderSource(gl, shader, sources);
+        err = gl.glGetError(); 
+        if(err!=GL.GL_NO_ERROR) {
+            throw new GLException("createAndCompileShader: ShaderSource failed, GL Error: 0x"+Integer.toHexString(err));
+        }
+
+        ShaderUtil.compileShader(gl, shader);
+        err = gl.glGetError(); 
+        if(err!=GL.GL_NO_ERROR && null!=verboseOut) {
+            verboseOut.println("createAndCompileShader: CompileShader failed, GL Error: 0x"+Integer.toHexString(err));
+        }
+
+        return ShaderUtil.isShaderStatusValid(gl, shader, gl.GL_COMPILE_STATUS, verboseOut) && err == GL.GL_NO_ERROR;
+    }
+
+    /**
+     * returns the uniq shader id as an integer
+     * @see #key()
+     */
+    public int        id() { return id.intValue(); }
+
+    /**
+     * returns the uniq shader id as an Integer
+     *
+     * @see #id()
+     */
+    public Integer    key() { return id; }
+
+    public int        shaderType() { return shaderType; }
+    public String     shaderTypeStr() { return shaderTypeStr(shaderType); }
+
+    public static String shaderTypeStr(int type) { 
+        switch (type) {
+            case GL2ES2.GL_VERTEX_SHADER:
+                return "VERTEX_SHADER";
+            case GL2ES2.GL_FRAGMENT_SHADER:
+                return "FRAGMENT_SHADER";
+        }
+        return "UNKNOWN_SHADER";
+    }
+
+    public int        shaderBinaryFormat() { return shaderBinaryFormat; }
+    public Buffer     shaderBinary() { return shaderBinary; }
+    public String[][] shaderSource() { return shaderSource; }
+
+    public boolean    isValid() { return valid; }
+
+    public IntBuffer  shader() { return shader; }
+
+    public boolean compile(GL2ES2 gl) {
+        return compile(gl, null);
+    }
+    public boolean compile(GL2ES2 gl, PrintStream verboseOut) {
+        if(isValid()) return true;
+
+        // Create & Compile the vertex/fragment shader objects
+        if(null!=shaderSource) {
+            valid=createAndCompileShader(gl, shader, shaderType,
+                                         shaderSource, verboseOut);
+        } else if(null!=shaderBinary) {
+            valid=createAndLoadShader(gl, shader, shaderType,
+                                      shaderBinaryFormat, shaderBinary, verboseOut);
+        } else {
+            throw new GLException("no code (source or binary)");
+        }
+        return valid;
+    }
+
+    public void destroy(GL2ES2 gl) {
+        if(isValid()) {
+            if(null!=gl) {
+                ShaderUtil.deleteShader(gl, shader());
+            }
+            valid=false;
+        }
+        if(null!=shaderBinary) {
+            shaderBinary.clear();
+            shaderBinary=null;
+        }
+        shaderSource=null;
+        shaderBinaryFormat=-1;
+        shaderType=-1;
+        id=null;
+    }
+
+    public boolean equals(Object obj) {
+        if(this==obj) return true;
+        if(obj instanceof ShaderCode) {
+            return id()==((ShaderCode)obj).id();
+        }
+        return false;
+    }
+    public int hashCode() {
+        return id.intValue();
+    }
+    public String toString() {
+        StringBuffer buf = new StringBuffer("ShaderCode [id="+id+", type="+shaderTypeStr()+", valid="+valid+", shader: ");
+        for(int i=0; i<shader.remaining(); i++) {
+            buf.append(" "+shader.get(i));
+        }
+        if(null!=shaderSource) {
+            buf.append(", source]");
+        } else if(null!=shaderBinary) {
+            buf.append(", binary "+shaderBinary+"]");
+        }
+        return buf.toString();
+    }
+
+    public static void readShaderSource(ClassLoader context, String path, URL url, StringBuffer result) {
+        try {
+            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
+            String line = null;
+            while ((line = reader.readLine()) != null) {
+                if (line.startsWith("#include ")) {
+                    String includeFile = line.substring(9).trim();
+                    // Try relative path first
+                    String next = Locator.getRelativeOf(path, includeFile);
+                    URL nextURL = Locator.getResource(next, context);
+                    if (nextURL == null) {
+                        // Try absolute path
+                        next = includeFile;
+                        nextURL = Locator.getResource(next, context);
+                    }
+                    if (nextURL == null) {
+                        // Fail
+                        throw new FileNotFoundException("Can't find include file " + includeFile);
+                    }
+                    readShaderSource(context, next, nextURL, result);
+                } else {
+                    result.append(line + "\n");
+                }
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static String readShaderSource(Class context, String path) {
+        ClassLoader contextCL = (null!=context)?context.getClassLoader():null;
+        URL url = Locator.getResource(path, contextCL);
+        if (url == null && null!=context) {
+            // Try again by scoping the path within the class's package
+            String className = context.getName().replace('.', '/');
+            int lastSlash = className.lastIndexOf('/');
+            if (lastSlash >= 0) {
+                String tmpPath = className.substring(0, lastSlash + 1) + path;
+                url = Locator.getResource(tmpPath, contextCL);
+                if (url != null) {
+                    path = tmpPath;
+                }
+            }
+        }
+        if (url == null) {
+            return null;
+        }
+        StringBuffer result = new StringBuffer();
+        readShaderSource(contextCL, path, url, result);
+        return result.toString();
+    }
+
+    public static ByteBuffer readShaderBinary(Class context, String path) {
+        try {
+            URL url = Locator.getResource(context, path);
+            if (url == null) {
+                return null;
+            }
+            return StreamUtil.readAll2Buffer(new BufferedInputStream(url.openStream()));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    protected String[][] shaderSource = null;
+    protected Buffer     shaderBinary = null;
+    protected int        shaderBinaryFormat = -1;
+    protected IntBuffer  shader = null;
+    protected int        shaderType = -1;
+    protected Integer    id = null;
+
+    protected boolean valid=false;
+
+    private static synchronized Integer getNextID() {
+        return new Integer(nextID++);
+    }
+    protected static int nextID = 1;
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/ShaderProgram.java b/src/jogl/classes/com/sun/opengl/util/glsl/ShaderProgram.java
new file mode 100644
index 000000000..c06eae383
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/ShaderProgram.java
@@ -0,0 +1,212 @@
+
+package com.sun.opengl.util.glsl;
+
+import javax.media.opengl.*;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.nio.*;
+import java.io.PrintStream;
+
+public class ShaderProgram {
+    public ShaderProgram() {
+        id = getNextID();
+    }
+
+    public boolean linked() {
+        return programLinked;
+    }
+
+    public boolean inUse() {
+        return programInUse;
+    }
+
+    public int program() { return shaderProgram; }
+
+    /**
+     * returns the uniq shader id as an integer
+     * @see #key()
+     */
+    public int        id() { return id.intValue(); }
+
+    /**
+     * returns the uniq shader id as an Integer
+     *
+     * @see #id()
+     */
+    public Integer    key() { return id; }
+
+    /**
+     * Detaches all shader codes and deletes the program.
+     * Destroys the shader codes as well.
+     * Calls release(gl, true)
+     *
+     * @see #release(GL2ES2, boolean)
+     */
+    public synchronized void destroy(GL2ES2 gl) {
+        release(gl, true);
+    }
+
+    /**
+     * Detaches all shader codes and deletes the program.
+     * Calls release(gl, false)
+     *
+     * @see #release(GL2ES2, boolean)
+     */
+    public synchronized void release(GL2ES2 gl) {
+        release(gl, false);
+    }
+
+    /**
+     * Detaches all shader codes and deletes the program.
+     * If releaseShaderToo is true, destroys the shader codes as well.
+     */
+    public synchronized void release(GL2ES2 gl, boolean releaseShaderToo) {
+        glUseProgram(gl, false);
+        for(Iterator iter=shaderMap.values().iterator(); iter.hasNext(); ) {
+            ShaderCode shaderCode = (ShaderCode) iter.next();
+            ShaderUtil.detachShader(gl, shaderProgram, shaderCode.shader());
+            if(releaseShaderToo) {
+                shaderCode.destroy(gl);
+            }
+        }
+        shaderMap.clear();
+        gl.glDeleteProgram(shaderProgram);
+        shaderProgram=-1;
+    }
+
+    //
+    // ShaderCode handling
+    //
+
+    /**
+     * Adds a new shader to a this non running program.
+     *
+     * @return false if the program is in use, or the shader already exist,
+     *         otherwise true.
+     */
+    public synchronized boolean add(ShaderCode shaderCode) {
+        if(shaderMap.containsKey(shaderCode.key())) return false;
+        shaderMap.put(shaderCode.key(), shaderCode);
+        return true;
+    }
+
+    public synchronized ShaderCode getShader(int id) {
+        return (ShaderCode) shaderMap.get(new Integer(id));
+    }
+
+    //
+    // Program handling
+    //
+
+    /**
+     * Replace a shader in a 'running' program.
+     * Refetches all previously bin/get attribute names
+     * and resets all attribute data as well
+     *
+     * @see getAttribLocation
+     * @param gl 
+     * @param oldShaderID the to be replace Shader
+     * @param newShader   the new ShaderCode
+     * @param verboseOut  the optional verbose outputstream
+     * @throws GLException is the program is not linked
+     *
+     * @see #glRefetchAttribLocations
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public synchronized boolean glReplaceShader(GL2ES2 gl, int oldShaderID, ShaderCode newShader, PrintStream verboseOut) {
+        if(!programLinked) throw new GLException("Program is not linked");
+        boolean shaderWasInUse = programInUse;
+        glUseProgram(gl, false);
+        if(!newShader.compile(gl, verboseOut)) {
+            return false;
+        } 
+        if(oldShaderID>=0) {
+            ShaderCode oldShader = (ShaderCode) shaderMap.remove(new Integer(oldShaderID));
+            if(null!=oldShader) {
+                ShaderUtil.detachShader(gl, shaderProgram, oldShader.shader());
+            }
+        }
+        add(newShader);
+
+        ShaderUtil.attachShader(gl, shaderProgram, newShader.shader());
+        gl.glLinkProgram(shaderProgram);
+        if ( ! ShaderUtil.isProgramValid(gl, shaderProgram, System.err) )  {
+            return false;
+        }
+
+        if(shaderWasInUse) {
+            glUseProgram(gl, true);
+        }
+        return true;
+    }
+
+    public synchronized boolean link(GL2ES2 gl, PrintStream verboseOut) {
+        if(programLinked) throw new GLException("Program is already linked");
+
+        if(0>shaderProgram) {
+            shaderProgram = gl.glCreateProgram();
+        }
+
+        for(Iterator iter=shaderMap.values().iterator(); iter.hasNext(); ) {
+            ShaderCode shaderCode = (ShaderCode) iter.next();
+            if(!shaderCode.compile(gl, verboseOut)) {
+                return false;
+            }
+            ShaderUtil.attachShader(gl, shaderProgram, shaderCode.shader());
+        }
+
+        // Link the program
+        gl.glLinkProgram(shaderProgram);
+
+        programLinked = ShaderUtil.isProgramValid(gl, shaderProgram, System.err);
+
+        return programLinked;
+    }
+
+    public boolean equals(Object obj) {
+        if(this==obj) return true;
+        if(obj instanceof ShaderCode) {
+            return id()==((ShaderCode)obj).id();
+        }
+        return false;
+    }
+    public int hashCode() {
+        return id.intValue();
+    }
+    public String toString() {
+        StringBuffer buf = new StringBuffer();
+        buf.append("ShaderProgram[id="+id);
+        buf.append(", linked="+programLinked+", inUse="+programInUse+", program: "+shaderProgram+", [");
+        for(Iterator iter=shaderMap.values().iterator(); iter.hasNext(); ) {
+            buf.append((ShaderCode) iter.next());
+            buf.append(" ");
+        }
+        buf.append("]");
+        return buf.toString();
+    }
+
+    protected synchronized void glUseProgram(GL2ES2 gl, boolean on) {
+        if(!programLinked) throw new GLException("Program is not linked");
+        if(programInUse==on) return;
+        gl.glUseProgram(on?shaderProgram:0);
+        programInUse = on;
+
+        //Throwable tX = new Throwable("Info: ShaderProgram.glUseProgram: "+on);
+        //tX.printStackTrace();
+
+    }
+
+    protected boolean programLinked = false;
+    protected boolean programInUse = false;
+    protected int shaderProgram=-1;
+    protected HashMap shaderMap = new HashMap();
+    protected Integer    id = null;
+
+    private static synchronized Integer getNextID() {
+        return new Integer(nextID++);
+    }
+    protected static int nextID = 1;
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/ShaderState.java b/src/jogl/classes/com/sun/opengl/util/glsl/ShaderState.java
new file mode 100644
index 000000000..bab9ef4f3
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/ShaderState.java
@@ -0,0 +1,648 @@
+
+package com.sun.opengl.util.glsl;
+
+import javax.media.opengl.*;
+import com.sun.opengl.util.*;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.nio.*;
+import java.io.PrintStream;
+
+public class ShaderState {
+
+    public ShaderState() {
+    }
+
+    public boolean verbose() { return verbose; }
+
+    public void setVerbose(boolean v) { verbose=v; }
+
+    /**
+     * Fetches the current shader state from the thread local storage (TLS)
+     *
+     * @see javax.media.opengl.glsl.ShaderState#glUseProgram(GL2ES2, boolean)
+     * @see javax.media.opengl.glsl.ShaderState#getCurrent()
+     */
+    public static synchronized ShaderState getCurrent() { 
+        GLContext current = GLContext.getCurrent();
+        if(null==current) {
+            throw new GLException("No context is current on this thread");
+        }
+        return (ShaderState) current.getAttachedObject(ShaderState.class.getName());
+    }
+
+    /**
+     * Turns the shader program on or off.<br>
+     * Puts this ShaderState to to the thread local storage (TLS),
+     * if <code>on</code> is <code>true</code>.
+     *
+     * @see javax.media.opengl.glsl.ShaderState#glUseProgram(GL2ES2, boolean)
+     * @see javax.media.opengl.glsl.ShaderState#getCurrent()
+     */
+    public synchronized void glUseProgram(GL2ES2 gl, boolean on) {
+        if(on) {
+            if(null!=shaderProgram) {
+                shaderProgram.glUseProgram(gl, true);
+            } else {
+                throw new GLException("No program is attached");
+            }
+            // update the current ShaderState to the TLS ..
+            gl.getContext().putAttachedObject(ShaderState.class.getName(), this);
+        } else if(null!=shaderProgram) {
+            shaderProgram.glUseProgram(gl, false);
+        }
+    }
+
+    public boolean linked() {
+        return (null!=shaderProgram)?shaderProgram.linked():false;
+    }
+
+    public boolean inUse() {
+        return (null!=shaderProgram)?shaderProgram.inUse():false;
+    }
+
+    /**
+     * Attach or switch a shader program
+     *
+     * Attaching a shader program the first time, 
+     * as well as switching to another program on the fly,
+     * while managing all attribute and uniform data.
+     */
+    public synchronized void attachShaderProgram(GL2ES2 gl, ShaderProgram prog) {
+        boolean prgInUse = false; // earmarked state
+
+        if(DEBUG) {
+            int curId = (null!=shaderProgram)?shaderProgram.id():-1;
+            int newId = (null!=prog)?prog.id():-1;
+            System.err.println("Info: attachShaderProgram: "+curId+" -> "+newId+"\n\t"+shaderProgram+"\n\t"+prog);
+            Throwable tX = new Throwable("Info: attachShaderProgram: Trace");
+            tX.printStackTrace();
+        }
+        if(null!=shaderProgram) {
+            if(shaderProgram.equals(prog)) {
+                // nothing to do ..
+                if(DEBUG) {
+                    System.err.println("Info: attachShaderProgram: NOP: equal id: "+shaderProgram.id());
+                }
+                return;
+            }
+            prgInUse = shaderProgram.inUse();
+            shaderProgram.glUseProgram(gl, false);
+        }
+
+        // register new one
+        shaderProgram = prog;
+
+        if(null!=shaderProgram) {
+            // reinstall all data ..
+            shaderProgram.glUseProgram(gl, true);
+            glResetAllVertexAttributes(gl);
+            glResetAllUniforms(gl);
+            if(!prgInUse) {
+                shaderProgram.glUseProgram(gl, false);
+            }
+        }
+        if(DEBUG) {
+            System.err.println("Info: attachShaderProgram: END");
+        }
+    }
+
+    public ShaderProgram shaderProgram() { return shaderProgram; }
+
+    /**
+     * Calls release(gl, true, true)
+     *
+     * @see #glReleaseAllVertexAttributes
+     * @see #glReleaseAllUniforms
+     * @see #release(GL2ES2, boolean, boolean)
+     */
+    public synchronized void destroy(GL2ES2 gl) {
+        release(gl, true, true);
+    }
+
+    /**
+     * Calls release(gl, false, false)
+     *
+     * @see #glReleaseAllVertexAttributes
+     * @see #glReleaseAllUniforms
+     * @see #release(GL2ES2, boolean, boolean)
+     */
+    public synchronized void releaseAllData(GL2ES2 gl) {
+        release(gl, false, false);
+    }
+
+    /**
+     * @see #glReleaseAllVertexAttributes
+     * @see #glReleaseAllUniforms
+     * @see ShaderProgram#release(GL2ES2, boolean)
+     */
+    public synchronized void release(GL2ES2 gl, boolean releaseProgramToo, boolean releaseShaderToo) {
+        boolean prgInUse = false;
+        if(null!=shaderProgram) {
+            prgInUse = shaderProgram.inUse();
+            if(!prgInUse) {
+                shaderProgram.glUseProgram(gl, true);
+            }
+        }
+        glReleaseAllVertexAttributes(gl);
+        glReleaseAllUniforms(gl);
+        if(null!=shaderProgram) {
+            if(releaseProgramToo) {
+                shaderProgram.release(gl, releaseShaderToo);
+            } else if(!prgInUse) {
+                shaderProgram.glUseProgram(gl, false);
+            }
+        }
+    }
+
+    //
+    // Shader attribute handling
+    //
+
+    /**
+     * Binds an attribute to the shader.
+     * This must be done before the program is linked !
+     * n name - 1 idx, where name is a uniq key
+     *
+     * @throws GLException is the program is already linked
+     *
+     * @see #glBindAttribLocation
+     * @see javax.media.opengl.GL2ES2#glBindAttribLocation
+     * @see #glGetAttribLocation
+     * @see javax.media.opengl.GL2ES2#glGetAttribLocation
+     * @see #getAttribLocation
+     * @see #glReplaceShader
+     */
+    public void glBindAttribLocation(GL2ES2 gl, int index, String name) {
+        if(null==shaderProgram) throw new GLException("No program is attached");
+        if(shaderProgram.linked()) throw new GLException("Program is already linked");
+        Integer idx = new Integer(index);
+        if(!attribMap2Idx.containsKey(name)) {
+            attribMap2Idx.put(name, idx);
+            gl.glBindAttribLocation(shaderProgram.program(), index, name);
+        }
+    }
+
+    /**
+     * Gets the index of a shader attribute.
+     * This must be done after the program is linked !
+     *
+     * @return -1 if there is no such attribute available, 
+     *         otherwise >= 0
+     * @throws GLException is the program is not linked
+     *
+     * @see #glBindAttribLocation
+     * @see javax.media.opengl.GL2ES2#glBindAttribLocation
+     * @see #glGetAttribLocation
+     * @see javax.media.opengl.GL2ES2#glGetAttribLocation
+     * @see #getAttribLocation
+     * @see #glReplaceShader
+     */
+    public int glGetAttribLocation(GL2ES2 gl, String name) {
+        if(!shaderProgram.linked()) throw new GLException("Program is not linked");
+        int index = getAttribLocation(name);
+        if(0>index) {
+            index = gl.glGetAttribLocation(shaderProgram.program(), name);
+            if(0<=index) {
+                Integer idx = new Integer(index);
+                attribMap2Idx.put(name, idx);
+                if(DEBUG) {
+                    System.err.println("Info: glGetAttribLocation: "+name+", loc: "+index);
+                }
+            } else if(verbose) {
+                Throwable tX = new Throwable("Info: glGetAttribLocation failed, no location for: "+name+", index: "+index);
+                tX.printStackTrace();
+            }
+        }
+        return index;
+    }
+
+    protected int getAttribLocation(String name) {
+        Integer idx = (Integer) attribMap2Idx.get(name);
+        return (null!=idx)?idx.intValue():-1;
+    }
+
+
+    //
+    // Enabled Vertex Arrays and its data
+    //
+
+    /**
+     * Enable a vertex attribute array
+     *
+     * Even if the attribute is not found in the current shader,
+     * it is stored in this state.
+     *
+     * @returns false, if the name is not found, otherwise true
+     *
+     * @throws GLException if the program is not in use
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public boolean glEnableVertexAttribArray(GL2ES2 gl, String name) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        enabledVertexAttribArraySet.add(name);
+        int index = glGetAttribLocation(gl, name);
+        if(0>index) {
+            if(verbose) {
+                Throwable tX = new Throwable("Info: glEnableVertexAttribArray failed, no index for: "+name);
+                tX.printStackTrace();
+            }
+            return false;
+        }
+        if(DEBUG) {
+            System.err.println("Info: glEnableVertexAttribArray: "+name+", loc: "+index);
+        }
+        gl.glEnableVertexAttribArray(index);
+        return true;
+    }
+
+    public boolean isVertexAttribArrayEnabled(String name) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        return enabledVertexAttribArraySet.contains(name);
+    }
+
+    /**
+     * Disables a vertex attribute array
+     *
+     * Even if the attribute is not found in the current shader,
+     * it is removed from this state.
+     *
+     * @returns false, if the name is not found, otherwise true
+     *
+     * @throws GLException if the program is not in use
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public boolean glDisableVertexAttribArray(GL2ES2 gl, String name) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        enabledVertexAttribArraySet.remove(name);
+        int index = glGetAttribLocation(gl, name);
+        if(0>index) {
+            if(verbose) {
+                Throwable tX = new Throwable("Info: glDisableVertexAttribArray failed, no index for: "+name);
+                tX.printStackTrace();
+            }
+            return false;
+        }
+        if(DEBUG) {
+            System.err.println("Info: glDisableVertexAttribArray: "+name);
+        }
+        gl.glDisableVertexAttribArray(index);
+        return true;
+    }
+
+    /**
+     * Set the vertex attribute data.
+     * Enable the attribute, if it is not enabled yet.
+     *
+     * Even if the attribute is not found in the current shader,
+     * it is stored in this state.
+     *
+     * @arg data the GLArrayData's name must match the attributes one,
+     *      it's index will be set with the attribute's location,
+     *      if found.
+     *
+     * @returns false, if the name is not found, otherwise true
+     *
+     * @throws GLException if the program is not in use
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public boolean glVertexAttribPointer(GL2ES2 gl, GLArrayData data) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        if(!enabledVertexAttribArraySet.contains(data.getName())) {
+            if(!glEnableVertexAttribArray(gl, data.getName())) {
+                if(verbose) {
+                    Throwable tX = new Throwable("Info: glVertexAttribPointer: couldn't enable: "+data);
+                    tX.printStackTrace();
+                }
+            }
+        }
+        int index = getAttribLocation(data.getName());
+        if(0>index) {
+            if(verbose) {
+                Throwable tX = new Throwable("Info: glVertexAttribPointer failed, no index for: "+data);
+                tX.printStackTrace();
+            }
+        }
+        data.setLocation(index);
+        vertexAttribMap2Data.put(data.getName(), data);
+        if(0<=index) {
+            // only pass the data, if the attribute exists in the current shader
+            if(DEBUG) {
+                System.err.println("Info: glVertexAttribPointer: "+data);
+            }
+            gl.glVertexAttribPointer(data);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Get the vertex attribute data, previously set.
+     *
+     * @returns the GLArrayData object, null if not previously set.
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public GLArrayData getVertexAttribPointer(String name) {
+        return (GLArrayData) vertexAttribMap2Data.get(name);
+    }
+
+    /**
+     * Releases all mapped vertex attribute data,
+     * disables all enabled attributes and loses all indices
+     *
+     * @throws GLException is the program is not in use but the shaderProgram is set
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public void glReleaseAllVertexAttributes(GL2ES2 gl) {
+        if(null!=shaderProgram) {
+            if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+            for(Iterator iter = vertexAttribMap2Data.keySet().iterator(); iter.hasNext(); ) {
+                if(!glDisableVertexAttribArray(gl, (String) iter.next())) {
+                    throw new GLException("Internal Error: mapped vertex attribute couldn't be disabled");
+                }
+            }
+            for(Iterator iter = enabledVertexAttribArraySet.iterator(); iter.hasNext(); ) {
+                if(!glDisableVertexAttribArray(gl, (String) iter.next())) {
+                    throw new GLException("Internal Error: prev enabled vertex attribute couldn't be disabled");
+                }
+            }
+        }
+        vertexAttribMap2Data.clear();
+        enabledVertexAttribArraySet.clear();
+        attribMap2Idx.clear();
+    }
+        
+    /**
+     * Disables all vertex attribute arrays.
+     *
+     * Their enabled stated will be removed from this state only
+     * if 'removeFromState' is true.
+     *
+     * This method purpose is more for debugging. 
+     *
+     * @throws GLException is the program is not in use but the shaderProgram is set
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public void glDisableAllVertexAttributeArrays(GL2ES2 gl, boolean removeFromState) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+
+        for(Iterator iter = enabledVertexAttribArraySet.iterator(); iter.hasNext(); ) {
+            String name = (String) iter.next();
+            if(removeFromState) {
+                enabledVertexAttribArraySet.remove(name);
+            }
+            int index = glGetAttribLocation(gl, name);
+            if(0<=index) {
+                gl.glDisableVertexAttribArray(index);
+            }
+        }
+    }
+
+    /**
+     * Reset all previously enabled mapped vertex attribute data,
+     * incl enabling them
+     *
+     * @throws GLException is the program is not in use
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public void glResetAllVertexAttributes(GL2ES2 gl) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        attribMap2Idx.clear();
+
+        /**
+         *
+        for(Iterator iter = enabledVertexAttribArraySet.iterator(); iter.hasNext(); ) {
+            glEnableVertexAttribArray(gl, (String) iter.next());
+        }
+        for(Iterator iter = vertexAttribMap2Data.values().iterator(); iter.hasNext(); ) {
+            GLArrayData data = (GLArrayData) iter.next();
+
+            ...
+        } */
+
+        for(Iterator iter = enabledVertexAttribArraySet.iterator(); iter.hasNext(); ) {
+            // get new location ..
+            String name = (String) iter.next();
+            int loc = glGetAttribLocation(gl, name);
+
+            // get & update data ..
+            GLArrayData data = getVertexAttribPointer(name);
+            data.setLocation(loc);
+            vertexAttribMap2Data.put(name, data);
+
+            if(0>loc) {
+                // not used in shader
+                continue;
+            }
+
+            // enable attrib, VBO and pass location/data
+            gl.glEnableVertexAttribArray(loc);
+
+            if( data.isVBO() ) {
+                gl.glBindBuffer(GL.GL_ARRAY_BUFFER, data.getVBOName());
+            } 
+
+            gl.glVertexAttribPointer(data);
+        }
+    }
+
+    //
+    // Shader Uniform handling
+    //
+
+    /**
+     * Gets the index of a shader uniform.
+     * This must be done when the program is in use !
+     *
+     * @return -1 if there is no such attribute available,
+     *         otherwise >= 0
+
+     * @throws GLException is the program is not linked
+     *
+     * @see #glGetUniformLocation
+     * @see javax.media.opengl.GL2ES2#glGetUniformLocation
+     * @see #getUniformLocation
+     * @see #glReplaceShader
+     */
+    protected int glGetUniformLocation(GL2ES2 gl, String name) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        int index = getUniformLocation(name);
+        if(0>index) {
+            index = gl.glGetUniformLocation(shaderProgram.program(), name);
+            if(0<=index) {
+                Integer idx = new Integer(index);
+                uniformMap2Idx.put(name, idx);
+            } else if(verbose) {
+                Throwable tX = new Throwable("Info: glUniform failed, no location for: "+name+", index: "+index);
+                tX.printStackTrace();
+            }
+        }
+        return index;
+    }
+
+    protected int getUniformLocation(String name) {
+        Integer idx = (Integer) uniformMap2Idx.get(name);
+        return (null!=idx)?idx.intValue():-1;
+    }
+
+    /**
+     * Set the uniform data.
+     *
+     * Even if the uniform is not found in the current shader,
+     * it is stored in this state.
+     *
+     * @arg data the GLUniforms's name must match the uniform one,
+     *      it's index will be set with the uniforms's location,
+     *      if found.
+     *
+     *
+     * @returns false, if the name is not found, otherwise true
+     *
+     * @throws GLException if the program is not in use
+     *
+     * @see #glGetUniformLocation
+     * @see javax.media.opengl.GL2ES2#glGetUniformLocation
+     * @see #getUniformLocation
+     * @see #glReplaceShader
+     */
+    public boolean glUniform(GL2ES2 gl, GLUniformData data) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        int location = glGetUniformLocation(gl, data.getName());
+        data.setLocation(location);
+        uniformMap2Data.put(data.getName(), data);
+        if(0<=location) {
+            // only pass the data, if the uniform exists in the current shader
+            if(DEBUG) {
+                System.err.println("Info: glUniform: "+data);
+            }
+            gl.glUniform(data);
+        }
+        return true;
+    }
+
+    /**
+     * Get the uniform data, previously set.
+     *
+     * @returns the GLUniformData object, null if not previously set.
+     */
+    public GLUniformData getUniform(String name) {
+        return (GLUniformData) uniformMap2Data.get(name);
+    }
+
+    /**
+     * Releases all mapped uniform data
+     * and loses all indices
+     *
+     * @throws GLException is the program is not in use
+     */
+    public void glReleaseAllUniforms(GL2ES2 gl) {
+        uniformMap2Data.clear();
+        uniformMap2Idx.clear();
+    }
+        
+    /**
+     * Reset all previously mapped uniform data
+     *
+     * @throws GLException is the program is not in use
+     */
+    public void glResetAllUniforms(GL2ES2 gl) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        uniformMap2Idx.clear();
+        for(Iterator iter = uniformMap2Data.values().iterator(); iter.hasNext(); ) {
+            glUniform(gl, (GLUniformData) iter.next());
+        }
+    }
+
+    public String toString() {
+        StringBuffer buf = new StringBuffer();
+        buf.append("ShaderState[");
+        buf.append(shaderProgram.toString());
+        buf.append(",EnabledStates: [");
+        for(Iterator iter = enabledVertexAttribArraySet.iterator(); iter.hasNext(); ) {
+            buf.append("\n  ");
+            buf.append((String)iter.next());
+        }
+        buf.append("], [");
+        for(Iterator iter = vertexAttribMap2Data.values().iterator(); iter.hasNext(); ) {
+            GLArrayData data = (GLArrayData) iter.next();
+            if(data.getLocation()>=0) {
+                buf.append("\n  ");
+                buf.append(data);
+            }
+        }
+        buf.append("], [");
+        for(Iterator iter=uniformMap2Data.values().iterator(); iter.hasNext(); ) {
+            GLUniformData data = (GLUniformData) iter.next();
+            if(data.getLocation()>=0) {
+                buf.append("\n  ");
+                buf.append(data);
+            }
+        }
+        buf.append("]");
+        return buf.toString();
+    }
+
+    protected static final boolean DEBUG = false;
+    protected boolean verbose = false;
+    protected ShaderProgram shaderProgram=null;
+    protected HashMap attribMap2Idx = new HashMap();
+    protected HashSet enabledVertexAttribArraySet = new HashSet();
+    protected HashMap vertexAttribMap2Data = new HashMap();
+    protected HashMap uniformMap2Idx = new HashMap();
+    protected HashMap uniformMap2Data = new HashMap();
+
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/ShaderUtil.java b/src/jogl/classes/com/sun/opengl/util/glsl/ShaderUtil.java
new file mode 100644
index 000000000..d1bb8b32b
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/ShaderUtil.java
@@ -0,0 +1,398 @@
+/*
+ * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ */
+
+package com.sun.opengl.util.glsl;
+
+import java.io.PrintStream;
+import java.nio.*;
+import java.util.*;
+
+import javax.media.opengl.*;
+
+public class ShaderUtil {
+    static abstract class Impl {
+        public abstract String getShaderInfoLog(GL gl, int shaderObj);
+        public abstract String getProgramInfoLog(GL gl, int programObj);
+        public abstract boolean isShaderStatusValid(GL gl, int shaderObj, int name);
+        public abstract boolean isShaderStatusValid(GL gl, int shaderObj, int name, PrintStream verboseOut);
+        public abstract boolean isShaderStatusValid(GL gl, IntBuffer shaders, int name);
+        public abstract boolean isShaderStatusValid(GL gl, IntBuffer shaders, int name, PrintStream verboseOut);
+        public abstract boolean isProgramStatusValid(GL gl, int programObj, int name);
+        public abstract boolean isProgramValid(GL gl, int programObj);
+        public abstract boolean isProgramValid(GL gl, int programObj, PrintStream verboseOut);
+        public abstract void createShader(GL gl, int type, IntBuffer shaders);
+        public abstract Set getShaderBinaryFormats(GL gl);
+        public abstract boolean isShaderCompilerAvailable(GL gl);
+        public abstract void shaderSource(GL gl, int shader, java.lang.String[] source);
+        public abstract void shaderSource(GL gl, IntBuffer shaders, java.lang.String[][] sources);
+        public abstract void shaderBinary(GL gl, IntBuffer shaders, int binFormat, java.nio.Buffer bin);
+        public abstract void compileShader(GL gl, IntBuffer shaders);
+        public abstract void attachShader(GL gl, int program, IntBuffer shaders);
+        public abstract void detachShader(GL gl, int program, IntBuffer shaders);
+        public abstract void deleteShader(GL gl, IntBuffer shaders);
+    }
+
+    static class GL2ES2Impl extends Impl {
+        public String getShaderInfoLog(GL _gl, int shaderObj) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int[] infoLogLength=new int[1];
+            gl.glGetShaderiv(shaderObj, gl.GL_INFO_LOG_LENGTH, infoLogLength, 0);
+
+            if(infoLogLength[0]==0) {
+                return "(no info log)";
+            }
+            int[] charsWritten=new int[1];
+            byte[] infoLogBytes = new byte[infoLogLength[0]];
+            gl.glGetShaderInfoLog(shaderObj, infoLogLength[0], charsWritten, 0, infoLogBytes, 0);
+
+            return new String(infoLogBytes, 0, charsWritten[0]);
+        }
+
+        public String getProgramInfoLog(GL _gl, int programObj) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int[] infoLogLength=new int[1];
+            gl.glGetProgramiv(programObj, gl.GL_INFO_LOG_LENGTH, infoLogLength, 0);
+
+            if(infoLogLength[0]==0) {
+                return "(no info log)";
+            }
+            int[] charsWritten=new int[1];
+            byte[] infoLogBytes = new byte[infoLogLength[0]];
+            gl.glGetProgramInfoLog(programObj, infoLogLength[0], charsWritten, 0, infoLogBytes, 0);
+
+            return new String(infoLogBytes, 0, charsWritten[0]);
+        }
+
+        public boolean isShaderStatusValid(GL _gl, int shaderObj, int name) {
+            return isShaderStatusValid(_gl, shaderObj, name, null);
+        }
+
+        public boolean isShaderStatusValid(GL _gl, int shaderObj, int name, PrintStream verboseOut) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int[] ires = new int[1];
+            gl.glGetShaderiv(shaderObj, name, ires, 0);
+
+            boolean res = ires[0]==1;
+            if(!res && null!=verboseOut) {
+                verboseOut.println("Shader status invalid: "+ getShaderInfoLog(gl, shaderObj));
+            }
+            return res;
+        }
+
+        public boolean isShaderStatusValid(GL _gl, IntBuffer shaders, int name) {
+            return isShaderStatusValid(_gl, shaders, name, null);
+        }
+
+        public boolean isShaderStatusValid(GL _gl, IntBuffer shaders, int name, PrintStream verboseOut) {
+            boolean res = true;
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                res = isShaderStatusValid(_gl, shaders.get(i), name, verboseOut) && res;
+            }
+            return res;
+        }
+
+        public boolean isProgramStatusValid(GL _gl, int programObj, int name) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int[] ires = new int[1];
+            gl.glGetProgramiv(programObj, name, ires, 0);
+
+            return ires[0]==1;
+        }
+
+        public boolean isProgramValid(GL _gl, int programObj) {
+            return isProgramValid(_gl, programObj, null);
+        }
+
+        public boolean isProgramValid(GL _gl, int programObj, PrintStream verboseOut) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int[] ires = new int[1];
+            if(!gl.glIsProgram(programObj)) {
+                if(null!=verboseOut) {
+                    verboseOut.println("Program name invalid: "+programObj);
+                }
+                return false;
+            }
+            if(!isProgramStatusValid(gl, programObj, gl.GL_LINK_STATUS)) {
+                if(null!=verboseOut) {
+                    verboseOut.println("Program link failed: "+programObj+"\n\t"+ getProgramInfoLog(gl, programObj));
+                }
+                return false;
+            }
+            if ( !gl.isGLES2() || isShaderCompilerAvailable(gl) ) {
+                // failed on APX2500 (ES2.0, no compiler) for valid programs
+                gl.glValidateProgram(programObj);
+                if(!isProgramStatusValid(gl, programObj, gl.GL_VALIDATE_STATUS)) {
+                    if(null!=verboseOut) {
+                        verboseOut.println("Program validation failed: "+programObj+"\n\t"+ getProgramInfoLog(gl, programObj));
+                    }
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        public void createShader(GL _gl, int type, IntBuffer shaders) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                shaders.put(i, gl.glCreateShader(type));
+            }
+        }
+
+        private Boolean shaderCompilerAvailable = null;
+        private Set shaderBinaryFormats = null;
+
+        public Set getShaderBinaryFormats(GL _gl) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            if(null==shaderBinaryFormats) {
+                if(gl.getContext()!=GLContext.getCurrent()) {
+                    return new HashSet(0); // bail out
+                }
+
+                int[] param = new int[1];
+                shaderBinaryFormats = new HashSet();
+
+                if (gl.isGLES2()) {
+                    gl.glGetIntegerv(GL2ES2.GL_NUM_SHADER_BINARY_FORMATS, param, 0);
+                    int numFormats = param[0];
+                    if(numFormats>0) {
+                        int[] formats = new int[numFormats];
+                        gl.glGetIntegerv(GL2ES2.GL_SHADER_BINARY_FORMATS, formats, 0);
+                        for(int i=0; i<numFormats; i++) {
+                            shaderBinaryFormats.add(new Integer(formats[i]));
+                        }
+                    }
+                }
+            }
+            return shaderBinaryFormats;
+        }
+
+
+        public boolean isShaderCompilerAvailable(GL _gl) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            if(null==shaderCompilerAvailable) {
+                if(gl.getContext()!=GLContext.getCurrent()) {
+                    return false; // bail out
+                }
+                Set bfs = getShaderBinaryFormats(gl);
+                if(gl.isGLES2()) {
+                    byte[] param = new byte[1];
+                    gl.glGetBooleanv(GL2ES2.GL_SHADER_COMPILER, param, 0);
+                    boolean v = param[0]!=(byte)0x00;
+                    if(!v && bfs.size()==0) {
+                        // no supported binary formats, hence a compiler must be available!
+                        v = true;
+                    }
+                    shaderCompilerAvailable = new Boolean(v);
+                } else if( gl.isGL2() || gl.isGL2ES2() ) {
+                    shaderCompilerAvailable = new Boolean(true);
+                } else {
+                    throw new GLException("Invalid OpenGL profile");
+                }
+            }
+            return shaderCompilerAvailable.booleanValue();
+        }
+
+        public void shaderSource(GL _gl, int shader, java.lang.String[] source)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            if(!isShaderCompilerAvailable(_gl)) {
+                throw new GLException("No compiler is available");
+            }
+
+            int count = (null!=source)?source.length:0;
+            if(count==0) {
+                throw new GLException("No sources specified");
+            }
+
+            int[] lengths = new int[count];
+            for(int i=0; i<count; i++) {
+                lengths[i] = source[i].length();
+            }
+            gl.glShaderSource(shader, count, source, lengths, 0);
+        }
+
+        public void shaderSource(GL _gl, IntBuffer shaders, java.lang.String[][] sources)
+        {
+            int sourceNum = (null!=sources)?sources.length:0;
+            int shaderNum = (null!=shaders)?shaders.remaining():0;
+            if(shaderNum<=0 || sourceNum<=0 || shaderNum!=sourceNum) {
+                throw new GLException("Invalid number of shaders and/or sources: shaders="+
+                                      shaderNum+", sources="+sourceNum);
+            }
+            for(int i=0; i<sourceNum; i++) {
+                shaderSource(_gl, shaders.get(shaders.position() + i), sources[i]);
+            }
+        }
+
+        public void shaderBinary(GL _gl, IntBuffer shaders, int binFormat, java.nio.Buffer bin)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            if(getShaderBinaryFormats(gl).size()<=0) {
+                throw new GLException("No binary formats are supported");
+            }
+
+            int shaderNum = shaders.remaining();
+            if(shaderNum<=0) {
+                throw new GLException("No shaders specified");
+            }
+            if(null==bin) {
+                throw new GLException("Null shader binary");
+            }
+            int binLength = bin.remaining();
+            if(0>=binLength) {
+                throw new GLException("Empty shader binary (remaining == 0)");
+            }
+            gl.glShaderBinary(shaderNum, shaders, binFormat, bin, binLength);
+        }
+
+        public void compileShader(GL _gl, IntBuffer shaders)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                gl.glCompileShader(shaders.get(i));
+            }
+        }
+
+        public void attachShader(GL _gl, int program, IntBuffer shaders)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                gl.glAttachShader(program, shaders.get(i));
+            }
+        }
+
+        public void detachShader(GL _gl, int program, IntBuffer shaders)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                gl.glDetachShader(program, shaders.get(i));
+            }
+        }
+
+        public void deleteShader(GL _gl, IntBuffer shaders)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                gl.glDeleteShader(shaders.get(i));
+
+            }
+        }
+    }
+
+    public static String getShaderInfoLog(GL gl, int shaderObj) {
+        return getImpl(gl).getShaderInfoLog(gl, shaderObj);
+    }
+
+    public static String getProgramInfoLog(GL gl, int programObj) {
+        return getImpl(gl).getProgramInfoLog(gl, programObj);
+    }
+
+    public static boolean isShaderStatusValid(GL gl, int shaderObj, int name) {
+        return getImpl(gl).isShaderStatusValid(gl, shaderObj, name);
+    }
+
+    public static boolean isShaderStatusValid(GL gl, int shaderObj, int name, PrintStream verboseOut) {
+        return getImpl(gl).isShaderStatusValid(gl, shaderObj, name, verboseOut);
+    }
+
+    public static boolean isShaderStatusValid(GL gl, IntBuffer shaders, int name) {
+        return getImpl(gl).isShaderStatusValid(gl, shaders, name);
+    }
+
+    public static boolean isShaderStatusValid(GL gl, IntBuffer shaders, int name, PrintStream verboseOut) {
+        return getImpl(gl).isShaderStatusValid(gl, shaders, name, verboseOut);
+    }
+
+    public static boolean isProgramStatusValid(GL gl, int programObj, int name) {
+        return getImpl(gl).isProgramStatusValid(gl, programObj, name);
+    }
+
+    public static boolean isProgramValid(GL gl, int programObj) {
+        return getImpl(gl).isProgramValid(gl, programObj);
+    }
+
+    public static boolean isProgramValid(GL gl, int programObj, PrintStream verboseOut) {
+        return getImpl(gl).isProgramValid(gl, programObj, verboseOut);
+    }
+
+    public static void createShader(GL gl, int type, IntBuffer shaders) {
+        getImpl(gl).createShader(gl, type, shaders);
+    }
+
+    public static Set getShaderBinaryFormats(GL gl) {
+        return getImpl(gl).getShaderBinaryFormats(gl);
+    }
+
+    public static boolean isShaderCompilerAvailable(GL gl) {
+        return getImpl(gl).isShaderCompilerAvailable(gl);
+    }
+
+    public static void shaderSource(GL gl, int shader, java.lang.String[] source) {
+        getImpl(gl).shaderSource(gl, shader, source);
+    }
+
+    public static void shaderSource(GL gl, IntBuffer shaders, java.lang.String[][] sources) {
+        getImpl(gl).shaderSource(gl, shaders, sources);
+    }
+
+    public static void shaderBinary(GL gl, IntBuffer shaders, int binFormat, java.nio.Buffer bin) {
+        getImpl(gl).shaderBinary(gl, shaders, binFormat, bin);
+    }
+
+    public static void compileShader(GL gl, IntBuffer shaders) {
+        getImpl(gl).compileShader(gl, shaders);
+    }
+
+    public static void attachShader(GL gl, int program, IntBuffer shaders) {
+        getImpl(gl).attachShader(gl, program, shaders);
+    }
+
+    public static void detachShader(GL gl, int program, IntBuffer shaders) {
+        getImpl(gl).detachShader(gl, program, shaders);
+    }
+
+    public static void deleteShader(GL gl, IntBuffer shaders) {
+        getImpl(gl).deleteShader(gl, shaders);
+    }
+
+    private static Impl getImpl(GL _gl) {
+        GL2ES2 gl = _gl.getGL2ES2();
+        GLContext context = gl.getContext();
+        Impl impl = (Impl) context.getAttachedObject(ShaderUtil.class.getName());
+        if (impl == null) {
+            impl = new GL2ES2Impl();
+            context.putAttachedObject(ShaderUtil.class.getName(), impl);
+        }
+        return impl;
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/FixedFuncUtil.java b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/FixedFuncUtil.java
new file mode 100644
index 000000000..9c8a65173
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/FixedFuncUtil.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
+ */
+
+package com.sun.opengl.util.glsl.fixedfunc;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+
+import com.sun.opengl.util.glsl.fixedfunc.impl.*;
+
+/**
+ * Tool to pipeline GL2ES2 into a fixed function emulation implementing GL2ES1.
+ */
+public class FixedFuncUtil {
+    /**
+     * @return If gl is a GL2ES1, return the type cast object,
+     *         otherwise create a fixed function emulation pipeline with the GL2ES2 impl.
+     * @throws GLException if the GL object is neither GL2ES1 nor GL2ES2
+     */
+    public static final GL2ES1 getFixedFuncImpl(GL gl) {
+        if(gl.isGL2ES1()) {
+            return gl.getGL2ES1();
+        } else if(gl.isGL2ES2()) {
+            GL2ES2 es2 = gl.getGL2ES2();
+            FixedFuncHook hook = new FixedFuncHook(es2);
+            FixedFuncImpl impl = new FixedFuncImpl(es2, hook);
+            gl.getContext().setGL(impl);
+            return impl;
+        }
+        throw new GLException("GL Object is neither GL2ES1 nor GL2ES2");
+    }
+
+    /**
+     * Mapping fixed function (client) array indices to 
+     * GLSL array attribute names.
+     *
+     * Useful for uniq mapping of canonical array index names as listed.
+     * 
+     * @see #mgl_Vertex
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#GL_VERTEX_ARRAY
+     * @see #mgl_Normal
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#GL_NORMAL_ARRAY
+     * @see #mgl_Color
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#GL_COLOR_ARRAY
+     * @see #mgl_MultiTexCoord
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#GL_TEXTURE_COORD_ARRAY
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#glEnableClientState
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#glVertexPointer
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#glColorPointer
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#glNormalPointer
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#glTexCoordPointer
+     */
+    public static String getPredefinedArrayIndexName(int glArrayIndex) {
+        return FixedFuncPipeline.getPredefinedArrayIndexName(glArrayIndex);
+    }
+
+    /**
+     * String name for
+     * @see javax.media.opengl.GL#GL_VERTEX_ARRAY
+     */
+    public static final String mgl_Vertex = FixedFuncPipeline.mgl_Vertex;
+
+    /**
+     * String name for
+     * @see javax.media.opengl.GL#GL_NORMAL_ARRAY
+     */
+    public static final String mgl_Normal = FixedFuncPipeline.mgl_Normal;
+
+    /**
+     * String name for
+     * @see javax.media.opengl.GL#GL_COLOR_ARRAY
+     */
+    public static final String mgl_Color = FixedFuncPipeline.mgl_Color;
+
+    /**
+     * String name for
+     * @see javax.media.opengl.GL#GL_TEXTURE_COORD_ARRAY
+     */
+    public static final String mgl_MultiTexCoord = FixedFuncPipeline.mgl_MultiTexCoord;
+}
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/FixedFuncHook.java b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/FixedFuncHook.java
new file mode 100755
index 000000000..6f44f10b7
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/FixedFuncHook.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
+ */
+
+package com.sun.opengl.util.glsl.fixedfunc.impl;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+import javax.media.opengl.glu.*;
+import com.sun.gluegen.runtime.BufferFactory;
+import com.sun.opengl.util.*;
+import com.sun.opengl.util.glsl.*;
+import java.nio.*;
+
+public class FixedFuncHook implements GLLightingFunc, GLMatrixFunc, GLPointerFunc {
+    public static final int MAX_TEXTURE_UNITS = 8;
+
+    protected FixedFuncPipeline fixedFunction=null;
+    protected PMVMatrix pmvMatrix=null;
+    protected GL2ES2 gl=null;
+
+    public FixedFuncHook (GL2ES2 gl) {
+        this(gl, null);
+    }
+
+    public FixedFuncHook (GL2ES2 gl, PMVMatrix matrix) {
+        this.gl = gl;
+        pmvMatrix = (null!=matrix)?matrix:new PMVMatrix();
+
+        fixedFunction = new FixedFuncPipeline(gl, pmvMatrix);
+    }
+
+    public FixedFuncHook(GL2ES2 gl, PMVMatrix matrix, 
+                       Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, 
+                       String vertexColorFile,
+                       String vertexColorLightFile,
+                       String fragmentColorFile,
+                       String fragmentColorTextureFile) {
+        this.gl = gl;
+        pmvMatrix = matrix;
+
+        fixedFunction = new FixedFuncPipeline(gl, pmvMatrix,
+                                              shaderRootClass, shaderSrcRoot, shaderBinRoot, 
+                                              vertexColorFile, vertexColorLightFile, fragmentColorFile, fragmentColorTextureFile);
+    }
+
+    public void destroy() {
+        fixedFunction.destroy(gl);
+        fixedFunction = null;
+    }
+
+    public PMVMatrix getMatrix() { return pmvMatrix; }
+
+    //
+    // FixedFuncHookIf - hooks 
+    //
+    public void glDrawArrays(int mode, int first, int count) {
+        fixedFunction.validate(gl); 
+        gl.glDrawArrays(mode, first, count);
+    }
+    public void glDrawElements(int mode, int count, int type, java.nio.Buffer indices) {
+        fixedFunction.validate(gl); 
+        gl.glDrawElements(mode, count, type, indices);
+    }
+    public void glDrawElements(int mode, int count, int type, long indices_buffer_offset) {
+        fixedFunction.validate(gl); 
+        gl.glDrawElements(mode, count, type, indices_buffer_offset);
+    }
+
+    public void glActiveTexture(int texture) {
+        fixedFunction.glActiveTexture(gl, texture);
+        gl.glActiveTexture(texture);
+    }
+    public void glEnable(int cap) {
+        if(fixedFunction.glEnable(gl, cap, true)) {
+            gl.glEnable(cap);
+        }
+    }
+    public void glDisable(int cap) {
+        if(fixedFunction.glEnable(gl, cap, false)) {
+            gl.glDisable(cap);
+        }
+    }
+    public void glCullFace(int faceName) {
+        fixedFunction.glCullFace(gl, faceName);
+        gl.glCullFace(faceName);
+    }
+
+    public void glGetFloatv(int pname, java.nio.FloatBuffer params) {
+        if(pmvMatrix.isMatrixGetName(pname)) {
+            pmvMatrix.glGetFloatv(pname, params);
+            return;
+        }
+        gl.glGetFloatv(pname, params);
+    }
+    public void glGetFloatv(int pname, float[] params, int params_offset) {
+        if(pmvMatrix.isMatrixGetName(pname)) {
+            pmvMatrix.glGetFloatv(pname, params, params_offset);
+            return;
+        }
+        gl.glGetFloatv(pname, params, params_offset);
+    }
+    public void glGetIntegerv(int pname, IntBuffer params) {
+        if(pmvMatrix.isMatrixGetName(pname)) {
+            pmvMatrix.glGetIntegerv(pname, params);
+            return;
+        }
+        gl.glGetIntegerv(pname, params);
+    }
+    public void glGetIntegerv(int pname, int[] params, int params_offset) {
+        if(pmvMatrix.isMatrixGetName(pname)) {
+            pmvMatrix.glGetIntegerv(pname, params, params_offset);
+            return;
+        }
+        gl.glGetIntegerv(pname, params, params_offset);
+    }
+
+    // 
+    // MatrixIf
+    //
+    public int  glGetMatrixMode() {
+        return pmvMatrix.glGetMatrixMode();
+    }
+    public void glMatrixMode(int mode) {
+        pmvMatrix.glMatrixMode(mode);
+    }
+    public void glLoadMatrixf(java.nio.FloatBuffer m) {
+        pmvMatrix.glLoadMatrixf(m);
+    }
+    public void glLoadMatrixf(float[] m, int m_offset) {
+        glLoadMatrixf(BufferUtil.newFloatBuffer(m, m_offset));
+    }
+    public void glPopMatrix() {
+        pmvMatrix.glPopMatrix();
+    }
+    public void glPushMatrix() {
+        pmvMatrix.glPushMatrix();
+    }
+    public void glLoadIdentity() {
+        pmvMatrix.glLoadIdentity();
+    }
+    public void glMultMatrixf(java.nio.FloatBuffer m) {
+        pmvMatrix.glMultMatrixf(m);
+    }
+    public void glMultMatrixf(float[] m, int m_offset) {
+        glMultMatrixf(BufferUtil.newFloatBuffer(m, m_offset));
+    }
+    public void glTranslatef(float x, float y, float z) {
+        pmvMatrix.glTranslatef(x, y, z);
+    }
+    public void glRotatef(float angdeg, float x, float y, float z) {
+        pmvMatrix.glRotatef(angdeg, x, y, z);
+    }
+    public void glScalef(float x, float y, float z) {
+        pmvMatrix.glScalef(x, y, z);
+    }
+    public void glOrthof(float left, float right, float bottom, float top, float zNear, float zFar) {
+        pmvMatrix.glOrthof(left, right, bottom, top, zNear, zFar);
+    }
+    public void glFrustumf(float left, float right, float bottom, float top, float zNear, float zFar) {
+        pmvMatrix.glFrustumf(left, right, bottom, top, zNear, zFar);
+    }
+
+    // 
+    // LightingIf
+    //
+    public void glColor4f(float red, float green, float blue, float alpha) {
+      fixedFunction.glColor4fv(gl, BufferUtil.newFloatBuffer(new float[] { red, green, blue, alpha })); 
+    }
+
+    public void glLightfv(int light, int pname, java.nio.FloatBuffer params) {
+      fixedFunction.glLightfv(gl, light, pname, params);
+    }
+    public void glLightfv(int light, int pname, float[] params, int params_offset) {
+        glLightfv(light, pname, BufferUtil.newFloatBuffer(params, params_offset));
+    }
+    public void glMaterialfv(int face, int pname, java.nio.FloatBuffer params) {
+      fixedFunction.glMaterialfv(gl, face, pname, params);
+    }
+    public void glMaterialfv(int face, int pname, float[] params, int params_offset) {
+        glMaterialfv(face, pname, BufferUtil.newFloatBuffer(params, params_offset));
+    }
+    public void glMaterialf(int face, int pname, float param) {
+        glMaterialfv(face, pname, BufferUtil.newFloatBuffer(new float[] { param }));
+    }
+    public void glShadeModel(int mode) {
+      fixedFunction.glShadeModel(gl, mode);
+    }
+
+    //
+    // PointerIf
+    //
+    public void glEnableClientState(int glArrayIndex) {
+      fixedFunction.glEnableClientState(gl, glArrayIndex);
+    }
+    public void glDisableClientState(int glArrayIndex) {
+      fixedFunction.glDisableClientState(gl, glArrayIndex);
+    }
+
+    public void glVertexPointer(GLArrayData array) {
+      if(array.isVBO()) {
+          if(!gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not enabled: "+array);
+          }
+      } else {
+          if(gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not disabled: "+array);
+          }
+          BufferFactory.rangeCheck(array.getBuffer(), 1);
+          if (!BufferFactory.isDirect(array.getBuffer())) {
+            throw new GLException("Argument \"pointer\" was not a direct buffer"); }
+      }
+      fixedFunction.glVertexPointer(gl, array);
+    }
+
+    public void glVertexPointer(int size, int type, int stride, java.nio.Buffer pointer) {
+      glVertexPointer(GLArrayDataWrapper.createFixed(gl, GL_VERTEX_ARRAY, size, type, false, stride, pointer, 0, 0));
+    }
+    public void glVertexPointer(int size, int type, int stride, long pointer_buffer_offset) {
+      int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER);
+      if(vboName==0) {
+        throw new GLException("no GL_ARRAY_BUFFER VBO bound");
+      }
+      glVertexPointer(GLArrayDataWrapper.createFixed(gl, GL_VERTEX_ARRAY, size, type, false, 
+                                                     stride, null, vboName, pointer_buffer_offset));
+    }
+
+    public void glColorPointer(GLArrayData array) {
+      if(array.isVBO()) {
+          if(!gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not enabled: "+array);
+          }
+      } else {
+          if(gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not disabled: "+array);
+          }
+          BufferFactory.rangeCheck(array.getBuffer(), 1);
+          if (!BufferFactory.isDirect(array.getBuffer())) {
+            throw new GLException("Argument \"pointer\" was not a direct buffer"); }
+      }
+      fixedFunction.glColorPointer(gl, array);
+    }
+    public void glColorPointer(int size, int type, int stride, java.nio.Buffer pointer) {
+      glColorPointer(GLArrayDataWrapper.createFixed(gl, GL_COLOR_ARRAY, size, type, false, 
+                                                    stride, pointer, 0, 0));
+    }
+    public void glColorPointer(int size, int type, int stride, long pointer_buffer_offset) {
+      int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER);
+      if(vboName==0) {
+        throw new GLException("no GL_ARRAY_BUFFER VBO bound");
+      }
+      glColorPointer(GLArrayDataWrapper.createFixed(gl, GL_COLOR_ARRAY, size, type, false, 
+                                                   stride, null, vboName, pointer_buffer_offset));
+    }
+
+    public void glNormalPointer(GLArrayData array) {
+      if(array.getComponentNumber()!=3) {
+        throw new GLException("Only 3 components per normal allowed");
+      }
+      if(array.isVBO()) {
+          if(!gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not enabled: "+array);
+          }
+      } else {
+          if(gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not disabled: "+array);
+          }
+          BufferFactory.rangeCheck(array.getBuffer(), 1);
+          if (!BufferFactory.isDirect(array.getBuffer())) {
+            throw new GLException("Argument \"pointer\" was not a direct buffer"); }
+      }
+      fixedFunction.glNormalPointer(gl, array);
+    }
+    public void glNormalPointer(int type, int stride, java.nio.Buffer pointer) {
+      glNormalPointer(GLArrayDataWrapper.createFixed(gl, GL_NORMAL_ARRAY, 3, type, false, 
+                                                     stride, pointer, 0, 0));
+    }
+    public void glNormalPointer(int type, int stride, long pointer_buffer_offset) {
+      int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER);
+      if(vboName==0) {
+        throw new GLException("no GL_ARRAY_BUFFER VBO bound");
+      }
+      glNormalPointer(GLArrayDataWrapper.createFixed(gl, GL_NORMAL_ARRAY, 3, type, false, 
+                                                     stride, null, vboName, pointer_buffer_offset));
+    }
+
+    public void glTexCoordPointer(GLArrayData array) {
+      if(array.isVBO()) {
+          if(!gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not enabled: "+array);
+          }
+      } else {
+          if(gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not disabled: "+array);
+          }
+          BufferFactory.rangeCheck(array.getBuffer(), 1);
+          if (!BufferFactory.isDirect(array.getBuffer())) {
+            throw new GLException("Argument \"pointer\" was not a direct buffer"); }
+      }
+      fixedFunction.glTexCoordPointer(gl, array);
+    }
+    public void glTexCoordPointer(int size, int type, int stride, java.nio.Buffer pointer) {
+      glTexCoordPointer(
+        GLArrayDataWrapper.createFixed(gl, GL_TEXTURE_COORD_ARRAY, size, type, false, stride, pointer, 0,0));
+    }
+    public void glTexCoordPointer(int size, int type, int stride, long pointer_buffer_offset) {
+      int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER);
+      if(vboName==0) {
+        throw new GLException("no GL_ARRAY_BUFFER VBO bound");
+      }
+      glTexCoordPointer(
+        GLArrayDataWrapper.createFixed(gl, GL_TEXTURE_COORD_ARRAY, size, type, false, 
+                                       stride, null, vboName, pointer_buffer_offset) );
+    }
+
+    public final String toString() {
+          StringBuffer buf = new StringBuffer();
+          buf.append(getClass().getName()+" (");
+          if(null!=pmvMatrix) {
+              buf.append(", matrixDirty: "+pmvMatrix.isDirty());
+          }
+          buf.append("\n\t, FixedFunction: "+fixedFunction);
+          buf.append(gl);
+          buf.append(" )");
+
+          return buf.toString();
+    }
+
+}
+
+
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/FixedFuncPipeline.java b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/FixedFuncPipeline.java
new file mode 100644
index 000000000..1b8dd1f11
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/FixedFuncPipeline.java
@@ -0,0 +1,554 @@
+
+package com.sun.opengl.util.glsl.fixedfunc.impl;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+import com.sun.opengl.util.*;
+import com.sun.opengl.util.glsl.*;
+import com.sun.opengl.util.glsl.fixedfunc.*;
+import java.nio.*;
+
+public class FixedFuncPipeline {
+    public static final int MAX_TEXTURE_UNITS = 8;
+    public static final int MAX_LIGHTS        = 8;
+
+    // We can't have any dependencies on the FixedFuncUtil class for build bootstrapping reasons
+    public static final String mgl_Vertex = "mgl_Vertex";
+    public static final String mgl_Normal = "mgl_Normal";
+    public static final String mgl_Color = "mgl_Color";
+    public static final String mgl_MultiTexCoord = "mgl_MultiTexCoord" ;
+
+    public static String getPredefinedArrayIndexName(int glArrayIndex) {
+        switch(glArrayIndex) {
+            case GLPointerFunc.GL_VERTEX_ARRAY:
+                return mgl_Vertex;
+            case GLPointerFunc.GL_NORMAL_ARRAY:
+                return mgl_Normal;
+            case GLPointerFunc.GL_COLOR_ARRAY:
+                return mgl_Color;
+            case GLPointerFunc.GL_TEXTURE_COORD_ARRAY:
+                return mgl_MultiTexCoord;
+        }
+        return null;
+    }
+
+    public FixedFuncPipeline(GL2ES2 gl, PMVMatrix pmvMatrix) {
+        init(gl, pmvMatrix, FixedFuncPipeline.class, shaderSrcRootDef, shaderBinRootDef, 
+             vertexColorFileDef, vertexColorLightFileDef, fragmentColorFileDef, fragmentColorTextureFileDef);
+    }
+    public FixedFuncPipeline(GL2ES2 gl, PMVMatrix pmvMatrix, Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, 
+                       String vertexColorFile,
+                       String vertexColorLightFile,
+                       String fragmentColorFile,
+                       String fragmentColorTextureFile) {
+        init(gl, pmvMatrix, shaderRootClass, shaderSrcRoot, shaderBinRoot, 
+             vertexColorFile, vertexColorLightFile, fragmentColorFile, fragmentColorTextureFile);
+    }
+
+    public boolean verbose() { return verbose; }
+
+    public void setVerbose(boolean v) { verbose=v; }
+
+    public boolean isValid() {
+        return shaderState.linked();
+    }
+
+    public ShaderState getShaderState() {
+        return shaderState;
+    }
+
+    public int getActiveTextureUnit() {
+        return activeTextureUnit;
+    }
+
+    public String getArrayIndexName(int glArrayIndex) {
+      String name = getPredefinedArrayIndexName(glArrayIndex); 
+      switch(glArrayIndex) {
+          case GLPointerFunc.GL_VERTEX_ARRAY:
+          case GLPointerFunc.GL_NORMAL_ARRAY:
+          case GLPointerFunc.GL_COLOR_ARRAY:
+              break;
+          case GLPointerFunc.GL_TEXTURE_COORD_ARRAY:
+              name = name + activeTextureUnit;
+      }
+      return name;
+    }
+
+    public void destroy(GL2ES2 gl) {
+        shaderProgramColor.release(gl, true);
+        shaderProgramColorLight.release(gl, true);
+        shaderProgramColorTexture.release(gl, true);
+        shaderProgramColorTextureLight.release(gl, true);
+        shaderState.destroy(gl);
+    }
+
+    public void glEnableClientState(GL2ES2 gl, int glArrayIndex) {
+        shaderState.glUseProgram(gl, true);
+
+        shaderState.glEnableVertexAttribArray(gl, getArrayIndexName(glArrayIndex));
+        // textureCoordsEnabled |=  (1 << activeTextureUnit);
+        if ( textureCoordsEnabled.get(activeTextureUnit) != 1 ) {
+            textureCoordsEnabled.put(activeTextureUnit, 1);
+            textureCoordsEnabledDirty = true;
+        }
+    }
+
+    public void glDisableClientState(GL2ES2 gl, int glArrayIndex) {
+        shaderState.glUseProgram(gl, true);
+
+        shaderState.glDisableVertexAttribArray(gl, getArrayIndexName(glArrayIndex));
+        // textureCoordsEnabled &= ~(1 << activeTextureUnit);
+        if ( textureCoordsEnabled.get(activeTextureUnit) != 0 ) {
+            textureCoordsEnabled.put(activeTextureUnit, 0);
+            textureCoordsEnabledDirty = true;
+        }
+    }
+
+    public void glVertexPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glColorPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glColor4fv(GL2ES2 gl, FloatBuffer data ) {
+        shaderState.glUseProgram(gl, true);
+        GLUniformData ud = shaderState.getUniform(mgl_ColorStatic);
+        if(null!=ud) {
+            ud.setData(data);
+            shaderState.glUniform(gl, ud);
+        }
+    }
+
+    public void glNormalPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glTexCoordPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        data.setName( getArrayIndexName(data.getIndex()) );
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glLightfv(GL2ES2 gl, int light, int pname, java.nio.FloatBuffer params) {
+        shaderState.glUseProgram(gl, true);
+        light -=GLLightingFunc.GL_LIGHT0;
+        if(0 <= light && light < MAX_LIGHTS) {
+            GLUniformData ud = null;
+            switch(pname) {
+                case  GLLightingFunc.GL_AMBIENT:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].ambient");
+                    break;
+                case  GLLightingFunc.GL_DIFFUSE:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].diffuse");
+                    break;
+                case  GLLightingFunc.GL_SPECULAR:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].specular");
+                    break;
+                case GLLightingFunc.GL_POSITION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].position");
+                    break;
+                case GLLightingFunc.GL_SPOT_DIRECTION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotDirection");
+                    break;
+                case GLLightingFunc.GL_SPOT_EXPONENT:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotExponent");
+                    break;
+                case GLLightingFunc.GL_SPOT_CUTOFF:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotCutoff");
+                    break;
+                case GLLightingFunc.GL_CONSTANT_ATTENUATION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].constantAttenuation");
+                    break;
+                case GLLightingFunc.GL_LINEAR_ATTENUATION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].linearAttenuation");
+                    break;
+                case GLLightingFunc.GL_QUADRATIC_ATTENUATION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].quadraticAttenuation");
+                    break;
+                default:
+                    if(verbose) {
+                        System.err.println("glLightfv pname not within [GL_AMBIENT GL_DIFFUSE GL_SPECULAR GL_POSITION GL_SPOT_DIRECTION]: "+pname);
+                    }
+                    return;
+            }
+            if(null!=ud) {
+                ud.setData(params);
+                shaderState.glUniform(gl, ud);
+            }
+        } else if(verbose) {
+            System.err.println("glLightfv light not within [0.."+MAX_LIGHTS+"]: "+light);
+        }
+    }
+
+    public void glMaterialfv(GL2ES2 gl, int face, int pname, java.nio.FloatBuffer params) {
+        shaderState.glUseProgram(gl, true);
+
+        switch (face) {
+            case GL.GL_FRONT:
+            case GL.GL_FRONT_AND_BACK:
+                break;
+            case GL.GL_BACK:
+                if(verbose) {
+                    System.err.println("glMaterialfv face GL_BACK currently not supported");
+                }
+                break;
+            default:
+        }
+
+        GLUniformData ud = null;
+        switch(pname) {
+            case  GLLightingFunc.GL_AMBIENT:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".ambient");
+                break;
+            case  GLLightingFunc.GL_AMBIENT_AND_DIFFUSE:
+                glMaterialfv(gl, face, GLLightingFunc.GL_AMBIENT, params);
+                // fall through intended ..
+            case  GLLightingFunc.GL_DIFFUSE:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".diffuse");
+                break;
+            case  GLLightingFunc.GL_SPECULAR:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".specular");
+                break;
+            case  GLLightingFunc.GL_EMISSION:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".emission");
+                break;
+            case  GLLightingFunc.GL_SHININESS:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".shininess");
+                break;
+            default:
+                if(verbose) {
+                    System.err.println("glMaterialfv pname not within [GL_AMBIENT GL_DIFFUSE GL_SPECULAR GL_EMISSION GL_SHININESS]: "+pname);
+                }
+                return;
+        }
+        if(null!=ud) {
+            ud.setData(params);
+            shaderState.glUniform(gl, ud);
+        }
+    }
+
+    public void glShadeModel(GL2ES2 gl, int mode) {
+        shaderState.glUseProgram(gl, true);
+        GLUniformData ud = shaderState.getUniform(mgl_ShadeModel);
+        if(null!=ud) {
+            ud.setData(mode);
+            shaderState.glUniform(gl, ud);
+        }
+    }
+
+    public void glActiveTexture(GL2ES2 gl, int textureUnit) {
+        textureUnit -= GL.GL_TEXTURE0;
+        if(0 <= textureUnit && textureUnit<MAX_TEXTURE_UNITS) {
+            shaderState.glUseProgram(gl, true);
+            GLUniformData ud;
+            ud = shaderState.getUniform(mgl_ActiveTexture);
+            if(null!=ud) {
+                ud.setData(textureUnit);
+                shaderState.glUniform(gl, ud);
+            }
+            ud = shaderState.getUniform(mgl_ActiveTextureIdx);
+            if(null!=ud) {
+                ud.setData(textureUnit);
+                shaderState.glUniform(gl, ud);
+            }
+            activeTextureUnit = textureUnit;
+        } else {
+            throw new GLException("glActivateTexture textureUnit not within GL_TEXTURE0 + [0.."+MAX_TEXTURE_UNITS+"]: "+textureUnit);
+        }
+    }
+
+    /**
+     * @return false if digested in regard to GL2ES2 spec, 
+     *         eg this call must not be passed to an underlying ES2 implementation.
+     *         true if this call shall be passed to an underlying GL2ES2/ES2 implementation as well.
+     */
+    public boolean glEnable(GL2ES2 gl, int cap, boolean enable) {
+        switch(cap) {
+            case GL.GL_TEXTURE_2D:
+                textureEnabled=enable;
+                return true;
+            case GLLightingFunc.GL_LIGHTING:
+                lightingEnabled=enable;
+                return false;
+            case GL.GL_CULL_FACE:
+                cullFace=Math.abs(cullFace);
+                if(!enable) {
+                    cullFace*=-1;
+                }
+                return true;
+        }
+
+        int light = cap - GLLightingFunc.GL_LIGHT0;
+        if(0 <= light && light < MAX_LIGHTS) {
+            if ( (lightsEnabled.get(light)==1) != enable ) {
+                lightsEnabled.put(light, enable?1:0);
+                lightsEnabledDirty = true;
+                return false;
+            }
+        }
+        return true; // pass it on ..
+    }
+
+    public void glCullFace(GL2ES2 gl, int faceName) {
+        switch(faceName) {
+            case GL.GL_FRONT:
+                faceName = 1; break;
+            case GL.GL_BACK:
+                faceName = 2; break;
+            case GL.GL_FRONT_AND_BACK:
+                faceName = 3; break;
+        }
+        if(0>cullFace) {
+            faceName *= -1;
+        }
+        cullFace = faceName;
+    }
+
+    public void validate(GL2ES2 gl) {
+        shaderState.glUseProgram(gl, true);
+        GLUniformData ud;
+        if(pmvMatrix.update()) {
+            ud = shaderState.getUniform(mgl_PMVMatrix);
+            if(null!=ud) {
+                // same data object ..
+                shaderState.glUniform(gl, ud);
+            } else {
+                throw new GLException("Failed to update: mgl_PMVMatrix");
+            }
+            ud = shaderState.getUniform(mgl_NormalMatrix);
+            if(null!=ud) {
+                // same data object ..
+                shaderState.glUniform(gl, ud);
+            }
+        }
+        ud = shaderState.getUniform(mgl_ColorEnabled);
+        if(null!=ud) {
+            int ca = (shaderState.isVertexAttribArrayEnabled(mgl_Color)==true)?1:0;
+            if(ca!=ud.intValue()) {
+                ud.setData(ca);
+                shaderState.glUniform(gl, ud);
+            }
+        }
+        ud = shaderState.getUniform(mgl_CullFace);
+        if(null!=ud) {
+            if(cullFace!=ud.intValue()) {
+                ud.setData(cullFace);
+                shaderState.glUniform(gl, ud);
+            }
+        }
+
+        if(lightsEnabledDirty) {
+            ud = shaderState.getUniform(mgl_LightsEnabled);
+            if(null!=ud) {
+                // same data object 
+                shaderState.glUniform(gl, ud);
+            }
+            lightsEnabledDirty=false;
+        }
+
+        if(textureCoordsEnabledDirty) {
+            ud = shaderState.getUniform(mgl_TexCoordEnabled);
+            if(null!=ud) {
+                // same data object 
+                shaderState.glUniform(gl, ud);
+            }
+            textureCoordsEnabledDirty=false;
+        }
+
+        if(textureEnabled) {
+            if(lightingEnabled) {
+                shaderState.attachShaderProgram(gl, shaderProgramColorTextureLight);
+            } else {
+                shaderState.attachShaderProgram(gl, shaderProgramColorTexture);
+            }
+        } else {
+            if(lightingEnabled) {
+                shaderState.attachShaderProgram(gl, shaderProgramColorLight);
+            } else {
+                shaderState.attachShaderProgram(gl, shaderProgramColor);
+            }
+        }
+        if(DEBUG) {
+            System.err.println("validate: "+this);
+        }
+    }
+
+    public String toString() {
+        return "FixedFuncPipeline[pmv: "+pmvMatrix+
+               ", textureEnabled: "+textureEnabled+
+               ", textureCoordsEnabled: "+textureCoordsEnabled+
+               ", lightingEnabled: "+lightingEnabled+
+               ", lightsEnabled: "+lightsEnabled+
+               "\n\t, shaderProgramColor: "+shaderProgramColor+
+               "\n\t, shaderProgramColorTexture: "+shaderProgramColorTexture+
+               "\n\t, shaderProgramColorLight: "+shaderProgramColorLight+
+               "\n\t, shaderProgramColorTextureLight: "+shaderProgramColorTextureLight+
+               "\n\t, ShaderState: "+shaderState+
+               "]";
+    }
+
+    protected void init(GL2ES2 gl, PMVMatrix pmvMatrix, Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, 
+                       String vertexColorFile,
+                       String vertexColorLightFile,
+                       String fragmentColorFile,
+                       String fragmentColorTextureFile) 
+   {
+        if(null==pmvMatrix) {
+            throw new GLException("PMVMatrix is null");
+        }
+        this.pmvMatrix=pmvMatrix;
+        this.shaderState=new ShaderState();
+        this.shaderState.setVerbose(verbose);
+        ShaderCode vertexColor, vertexColorLight, fragmentColor, fragmentColorTexture;
+
+        vertexColor = ShaderCode.create( gl, gl.GL_VERTEX_SHADER, 1, shaderRootClass,
+                                         shaderSrcRoot, shaderBinRoot, vertexColorFile);
+
+        vertexColorLight = ShaderCode.create( gl, gl.GL_VERTEX_SHADER, 1, shaderRootClass,
+                                           shaderSrcRoot, shaderBinRoot, vertexColorLightFile);
+
+        fragmentColor = ShaderCode.create( gl, gl.GL_FRAGMENT_SHADER, 1, shaderRootClass,
+                                           shaderSrcRoot, shaderBinRoot, fragmentColorFile);
+
+        fragmentColorTexture = ShaderCode.create( gl, gl.GL_FRAGMENT_SHADER, 1, shaderRootClass,
+                                                  shaderSrcRoot, shaderBinRoot, fragmentColorTextureFile);
+
+        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, shaderProgramColor);
+        shaderState.glUseProgram(gl, true);
+
+        // mandatory ..
+        if(!shaderState.glUniform(gl, new GLUniformData(mgl_PMVMatrix, 4, 4, pmvMatrix.glGetPMvMviMatrixf()))) {
+            throw new GLException("Error setting PMVMatrix in shader: "+this);
+        }
+
+        // optional parameter ..
+        shaderState.glUniform(gl, new GLUniformData(mgl_NormalMatrix, 3, 3, pmvMatrix.glGetNormalMatrixf()));
+
+        shaderState.glUniform(gl, new GLUniformData(mgl_ColorEnabled,  0));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ColorStatic, 4, zero4f));
+        shaderState.glUniform(gl, new GLUniformData(mgl_TexCoordEnabled,  1, textureCoordsEnabled));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ActiveTexture, activeTextureUnit));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ActiveTextureIdx, activeTextureUnit));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ShadeModel, 0));
+        shaderState.glUniform(gl, new GLUniformData(mgl_CullFace, cullFace));
+        for(int i=0; i<MAX_LIGHTS; i++) {
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].ambient", 4, defAmbient));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].diffuse", 4, defDiffuse));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].specular", 4, defSpecular));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].position", 4, defPosition));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].spotDirection", 3, defSpotDir));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].spotExponent", defSpotExponent));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].spotCutoff", defSpotCutoff));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].constantAttenuation", defConstantAtten));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].linearAttenuation", defLinearAtten));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].quadraticAttenuation", defQuadraticAtten));
+        }
+        shaderState.glUniform(gl, new GLUniformData(mgl_LightsEnabled,  1, lightsEnabled));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".ambient", 4, defMatAmbient));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".diffuse", 4, defMatDiffuse));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".specular", 4, defMatSpecular));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".emission", 4, defMatEmission));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".shininess", defMatShininess));
+
+        shaderState.glUseProgram(gl, false);
+    }
+
+    protected static final boolean DEBUG=false;
+    protected boolean verbose=false;
+
+    protected boolean textureEnabled=false;
+    protected IntBuffer textureCoordsEnabled = BufferUtil.newIntBuffer(new int[] { 0, 0, 0, 0, 0, 0, 0, 0 });
+    protected boolean textureCoordsEnabledDirty = false;
+    protected int     activeTextureUnit=0;
+
+    protected int cullFace=-2; // <=0 disabled, 1: front, 2: back (default, but disabled), 3: front & back
+
+    protected boolean lightingEnabled=false;
+    protected IntBuffer lightsEnabled = BufferUtil.newIntBuffer(new int[] { 0, 0, 0, 0, 0, 0, 0, 0 });
+    protected boolean   lightsEnabledDirty = false;
+
+    protected PMVMatrix pmvMatrix;
+    protected ShaderState shaderState;
+    protected ShaderProgram shaderProgramColor;
+    protected ShaderProgram shaderProgramColorTexture;
+    protected ShaderProgram shaderProgramColorLight;
+    protected ShaderProgram shaderProgramColorTextureLight;
+
+    // uniforms ..
+    protected static final String mgl_PMVMatrix        = "mgl_PMVMatrix";       // m4fv[3]
+    protected static final String mgl_NormalMatrix     = "mgl_NormalMatrix";    // m4fv
+    protected static final String mgl_ColorEnabled     = "mgl_ColorEnabled";    //  1i
+    protected static final String mgl_ColorStatic      = "mgl_ColorStatic";     //  4fv
+
+    protected static final String mgl_LightSource      = "mgl_LightSource";     //  struct mgl_LightSourceParameters[MAX_LIGHTS]
+    protected static final String mgl_FrontMaterial    = "mgl_FrontMaterial";   //  struct mgl_MaterialParameters
+    protected static final String mgl_LightsEnabled    = "mgl_LightsEnabled";   //  int mgl_LightsEnabled[MAX_LIGHTS];
+
+    protected static final String mgl_ShadeModel       = "mgl_ShadeModel";      //  1i
+
+    protected static final String mgl_TexCoordEnabled  = "mgl_TexCoordEnabled"; //  int mgl_TexCoordEnabled[MAX_TEXTURE_UNITS];
+    protected static final String mgl_ActiveTexture    = "mgl_ActiveTexture";   //  1i
+    protected static final String mgl_ActiveTextureIdx = "mgl_ActiveTextureIdx";//  1i
+
+    protected static final String mgl_CullFace         = "mgl_CullFace";   //  1i
+
+    protected static final FloatBuffer zero4f     = BufferUtil.newFloatBuffer(new float[] { 0.0f, 0.0f, 0.0f, 0.0f });
+
+    public static final FloatBuffer defAmbient = BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 0f, 1f });
+    public static final FloatBuffer defDiffuse = zero4f;
+    public static final FloatBuffer defSpecular= zero4f;
+    public static final FloatBuffer defPosition= BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 1f, 0f });
+    public static final FloatBuffer defSpotDir = BufferUtil.newFloatBuffer(new float[] { 0f, 0f, -1f });
+    public static final float defSpotExponent  = 0f;
+    public static final float defSpotCutoff    = 180f;
+    public static final float defConstantAtten = 1f;
+    public static final float defLinearAtten   = 0f;
+    public static final float defQuadraticAtten= 0f;
+
+    public static final FloatBuffer defMatAmbient = BufferUtil.newFloatBuffer(new float[] { 0.2f, 0.2f, 0.2f, 1.0f });
+    public static final FloatBuffer defMatDiffuse = BufferUtil.newFloatBuffer(new float[] { 0.8f, 0.8f, 0.8f, 1.0f });
+    public static final FloatBuffer defMatSpecular= BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 0f, 1f});
+    public static final FloatBuffer defMatEmission= BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 0f, 1f});
+    public static final float       defMatShininess = 0f;
+
+    protected static final String vertexColorFileDef          = "FixedFuncColor";
+    protected static final String vertexColorLightFileDef    = "FixedFuncColorLight";
+    protected static final String fragmentColorFileDef        = "FixedFuncColor";
+    protected static final String fragmentColorTextureFileDef = "FixedFuncColorTexture";
+    protected static final String shaderSrcRootDef = "shaders" ;
+    protected static final String shaderBinRootDef = "shaders/bin" ;
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.fp b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.fp
new file mode 100644
index 000000000..408ff7251
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.fp
@@ -0,0 +1,16 @@
+#include es_precision.glsl
+
+#include mgl_uniform.glsl
+#include mgl_varying.glsl
+
+void main (void)
+{
+  if( mgl_CullFace > 0 && 
+      ( ( mgl_CullFace == 1 && gl_FrontFacing ) ||
+        ( mgl_CullFace == 2 && !gl_FrontFacing ) ||
+        ( mgl_CullFace == 3 ) ) ) {
+    discard;
+  }
+  gl_FragColor = frontColor;
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.vp b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.vp
new file mode 100644
index 000000000..346e40196
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.vp
@@ -0,0 +1,22 @@
+#include es_precision.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_attribute.glsl
+#include mgl_varying.glsl
+
+#include mgl_settexcoord.vp
+
+void main(void)
+{
+  if(mgl_ColorEnabled>0) {
+    frontColor=mgl_Color;
+  } else {
+    frontColor=mgl_ColorStatic;
+  }
+
+  gl_Position = mgl_PMVMatrix[0] * mgl_PMVMatrix[1] * mgl_Vertex;
+
+  setTexCoord(gl_Position);
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorLight.vp b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorLight.vp
new file mode 100644
index 000000000..ce203cfb9
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorLight.vp
@@ -0,0 +1,70 @@
+#include es_precision.glsl
+#include mgl_lightdef.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_uniform_light.glsl
+#include mgl_attribute.glsl
+#include mgl_varying.glsl
+
+#include mgl_settexcoord.vp
+
+void main(void)
+{
+  vec4 position;
+  vec3 normal, lightDir, cameraDir, halfDir;
+  vec4 ambient, diffuse, specular;
+  float NdotL, NdotHV, dist, attenuation;
+  int i;
+
+  position  = mgl_PMVMatrix[1] * mgl_Vertex; // vertex eye position 
+
+  normal = normalize(mgl_NormalMatrix * mgl_Normal); 
+  // cameraPosition:      (mgl_PMVMatrix[2] * vec4(0,0,0,1.0)).xyz                   
+  cameraDir  = normalize( (mgl_PMVMatrix[2] * vec4(0,0,0,1.0)).xyz - mgl_Vertex.xyz ); 
+
+  ambient = vec4(0,0,0,0);
+  diffuse = vec4(0,0,0,0);
+  specular = vec4(0,0,0,0);
+
+  bool lightEnabled = false;
+
+  for(i=0; i<MAX_LIGHTS; i++) {
+    if( 0!= mgl_LightsEnabled[i] ) {
+      lightEnabled = true;
+      ambient += mgl_LightSource[i].ambient;
+      lightDir = mgl_LightSource[i].position.xyz - position.xyz;
+      dist     = length(lightDir);
+      lightDir = normalize(lightDir);
+      attenuation = 1.0 / ( 
+                       mgl_LightSource[i].constantAttenuation+ 
+                       mgl_LightSource[i].linearAttenuation    * dist +   
+                       mgl_LightSource[i].quadraticAttenuation * dist * dist );
+      NdotL = max(0.0, dot(normal, lightDir));
+      diffuse += mgl_LightSource[i].diffuse * NdotL * attenuation;
+      if (NdotL != 0.0) {
+        halfDir  = normalize (lightDir + cameraDir); 
+        NdotHV   = max(0.0, dot(normal, halfDir));
+        specular += mgl_LightSource[i].specular * 
+                    pow(NdotHV,mgl_FrontMaterial.shininess) * attenuation;
+      }
+    }
+  }
+  ambient  += mgl_FrontMaterial.ambient;
+  diffuse  *= mgl_FrontMaterial.diffuse;
+  specular *= mgl_FrontMaterial.specular;
+
+  if(mgl_ColorEnabled>0) {
+    frontColor=mgl_Color;
+  } else {
+    frontColor=mgl_ColorStatic;
+  }
+  if( lightEnabled ) {
+    frontColor *= ambient + diffuse + specular;
+  }
+
+  gl_Position  = mgl_PMVMatrix[0] * position;
+
+  setTexCoord(gl_Position);
+}
+
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorTexture.fp b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorTexture.fp
new file mode 100644
index 000000000..86e6ace73
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorTexture.fp
@@ -0,0 +1,47 @@
+
+#include es_precision.glsl
+#include mgl_lightdef.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_varying.glsl
+
+vec4 getTexColor(in sampler2D tex, in int idx) {
+    vec4 coord;
+    if(idx==0) {
+        coord= mgl_TexCoords[0];
+    } else if(idx==1) {
+        coord= mgl_TexCoords[1];
+    } else if(idx==2) {
+        coord= mgl_TexCoords[2];
+    } else if(idx==3) {
+        coord= mgl_TexCoords[3];
+    } else if(idx==4) {
+        coord= mgl_TexCoords[4];
+    } else if(idx==5) {
+        coord= mgl_TexCoords[5];
+    } else if(idx==6) {
+        coord= mgl_TexCoords[6];
+    } else {
+        coord= mgl_TexCoords[7];
+    }
+    return texture2D(tex, coord.st);
+}
+
+void main (void)
+{
+  if( mgl_CullFace > 0 && 
+      ( ( mgl_CullFace == 1 && gl_FrontFacing ) ||
+        ( mgl_CullFace == 2 && !gl_FrontFacing ) ||
+        ( mgl_CullFace == 3 ) ) ) {
+    discard;
+  }
+
+  vec4 texColor = getTexColor(mgl_ActiveTexture,mgl_ActiveTextureIdx);
+
+  if(length(texColor.rgb)>0.0) {
+    gl_FragColor = vec4(frontColor.rgb*texColor.rgb, frontColor.a) ;
+  } else {
+    gl_FragColor = frontColor;
+  }
+}
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bfp b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bfp
new file mode 100755
index 000000000..3ebaaee1d
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bfp
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bvp b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bvp
new file mode 100755
index 000000000..279ef72c7
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bvp
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorLight.bvp b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorLight.bvp
new file mode 100755
index 000000000..5a9deea71
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorLight.bvp
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorTexture.bfp b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorTexture.bfp
new file mode 100755
index 000000000..ce1397fe1
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorTexture.bfp
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/es_precision.glsl b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/es_precision.glsl
new file mode 100644
index 000000000..fd6abe54e
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/es_precision.glsl
@@ -0,0 +1,14 @@
+#ifndef es_precision_glsl
+#define es_precision_glsl
+
+#ifdef GL_ES
+  #define MEDIUMP mediump
+  #define HIGHP highp
+  #define LOWP  lowp
+#else
+  #define MEDIUMP
+  #define HIGHP
+  #define LOWP
+#endif
+
+#endif // es_precision_glsl
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_attribute.glsl b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_attribute.glsl
new file mode 100644
index 000000000..b09bdb05a
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_attribute.glsl
@@ -0,0 +1,19 @@
+
+#ifndef mgl_attribute_glsl
+#define mgl_attribute_glsl
+
+#include es_precision.glsl
+
+attribute HIGHP vec4    mgl_Vertex;
+attribute HIGHP vec3    mgl_Normal;
+attribute HIGHP vec4    mgl_Color;
+attribute HIGHP vec4    mgl_MultiTexCoord0;
+attribute HIGHP vec4    mgl_MultiTexCoord1;
+attribute HIGHP vec4    mgl_MultiTexCoord2;
+attribute HIGHP vec4    mgl_MultiTexCoord3;
+attribute HIGHP vec4    mgl_MultiTexCoord4;
+attribute HIGHP vec4    mgl_MultiTexCoord5;
+attribute HIGHP vec4    mgl_MultiTexCoord6;
+attribute HIGHP vec4    mgl_MultiTexCoord7;
+
+#endif // mgl_attribute_glsl
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_const.glsl b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_const.glsl
new file mode 100644
index 000000000..1a464a1cb
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_const.glsl
@@ -0,0 +1,10 @@
+
+#ifndef mgl_const_glsl
+#define mgl_const_glsl
+
+#include es_precision.glsl
+
+const   LOWP int     MAX_TEXTURE_UNITS = 8; // <=gl_MaxTextureImageUnits 
+const   LOWP int     MAX_LIGHTS = 8; 
+
+#endif // mgl_const_glsl
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_lightdef.glsl b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_lightdef.glsl
new file mode 100644
index 000000000..98e214139
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_lightdef.glsl
@@ -0,0 +1,26 @@
+#ifndef mgl_lightdef_glsl
+#define mgl_lightdef_glsl
+
+struct mgl_LightSourceParameters {
+   vec4 ambient; 
+   vec4 diffuse; 
+   vec4 specular; 
+   vec4 position; 
+   // vec4 halfVector; // is computed here
+   vec3 spotDirection; 
+   float spotExponent; 
+   float spotCutoff; // (range: [0.0,90.0], 180.0)
+   //float spotCosCutoff; // (range: [1.0,0.0],-1.0)
+   float constantAttenuation; 
+   float linearAttenuation; 
+   float quadraticAttenuation; 
+};
+struct mgl_MaterialParameters {
+   vec4 ambient;    
+   vec4 diffuse;    
+   vec4 specular;   
+   vec4 emission;   
+   float shininess; 
+};
+
+#endif // mgl_lightdef_glsl
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_settexcoord.vp b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_settexcoord.vp
new file mode 100644
index 000000000..1efe328d0
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_settexcoord.vp
@@ -0,0 +1,35 @@
+#ifndef mgl_settexcoord_vp
+#define mgl_settexcoord_vp
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_attribute.glsl
+#include mgl_varying.glsl
+
+void setTexCoord(in vec4 defpos) {
+  /**
+   * bitwise operator not supported on APX 2500 ES 2.0
+   *
+  mgl_TexCoords[0] = ( 0 != (mgl_TexCoordEnabled &   1) ) ? mgl_MultiTexCoord0 : defpos;
+  mgl_TexCoords[1] = ( 0 != (mgl_TexCoordEnabled &   2) ) ? mgl_MultiTexCoord1 : defpos;
+  mgl_TexCoords[2] = ( 0 != (mgl_TexCoordEnabled &   4) ) ? mgl_MultiTexCoord2 : defpos;
+  mgl_TexCoords[3] = ( 0 != (mgl_TexCoordEnabled &   8) ) ? mgl_MultiTexCoord3 : defpos;
+  mgl_TexCoords[4] = ( 0 != (mgl_TexCoordEnabled &  16) ) ? mgl_MultiTexCoord4 : defpos;
+  mgl_TexCoords[5] = ( 0 != (mgl_TexCoordEnabled &  32) ) ? mgl_MultiTexCoord5 : defpos;
+  mgl_TexCoords[6] = ( 0 != (mgl_TexCoordEnabled &  64) ) ? mgl_MultiTexCoord6 : defpos;
+  mgl_TexCoords[7] = ( 0 != (mgl_TexCoordEnabled & 128) ) ? mgl_MultiTexCoord7 : defpos;
+   */
+  
+  mgl_TexCoords[0] = ( 0 != mgl_TexCoordEnabled[0] ) ? mgl_MultiTexCoord0 : defpos;
+  mgl_TexCoords[1] = ( 0 != mgl_TexCoordEnabled[1] ) ? mgl_MultiTexCoord1 : defpos;
+  mgl_TexCoords[2] = ( 0 != mgl_TexCoordEnabled[2] ) ? mgl_MultiTexCoord2 : defpos;
+  mgl_TexCoords[3] = ( 0 != mgl_TexCoordEnabled[3] ) ? mgl_MultiTexCoord3 : defpos;
+  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 // mgl_settexcoord_vp
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform.glsl b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform.glsl
new file mode 100644
index 000000000..d8b3c7f95
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform.glsl
@@ -0,0 +1,18 @@
+
+#ifndef mgl_uniform_glsl
+#define mgl_uniform_glsl
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+
+uniform   HIGHP mat4    mgl_PMVMatrix[3]; // P, Mv, and Mvi
+uniform   HIGHP mat3    mgl_NormalMatrix; // transpose(inverse(ModelView)).3x3
+uniform LOWP    int     mgl_ColorEnabled;
+uniform HIGHP   vec4    mgl_ColorStatic;
+uniform LOWP    int     mgl_TexCoordEnabled[MAX_TEXTURE_UNITS];
+uniform       sampler2D mgl_ActiveTexture;
+uniform LOWP    int     mgl_ActiveTextureIdx;
+uniform LOWP    int     mgl_CullFace;
+
+#endif // mgl_uniform_glsl
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform_light.glsl b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform_light.glsl
new file mode 100644
index 000000000..0dedb5d5d
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform_light.glsl
@@ -0,0 +1,15 @@
+
+#ifndef mgl_uniform_light_glsl
+#define mgl_uniform_light_glsl
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+#include mgl_lightdef.glsl
+
+uniform LOWP    int     mgl_LightsEnabled[MAX_LIGHTS];
+
+uniform mgl_LightSourceParameters mgl_LightSource[MAX_LIGHTS];
+uniform mgl_MaterialParameters    mgl_FrontMaterial;
+
+#endif // mgl_uniform_light_glsl
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_varying.glsl b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_varying.glsl
new file mode 100644
index 000000000..fc9f735d1
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/mgl_varying.glsl
@@ -0,0 +1,12 @@
+
+#ifndef mgl_varying_glsl
+#define mgl_varying_glsl
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+
+varying   vec4    frontColor;
+varying   vec4    mgl_TexCoords[MAX_TEXTURE_UNITS];
+
+#endif // mgl_varying_glsl
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc-ff.bat b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc-ff.bat
new file mode 100755
index 000000000..002dca8ef
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc-ff.bat
@@ -0,0 +1,9 @@
+REM 
+REM You have to call it from the 'shaders' directory, e.g.:
+REM   scripts\nvidia-apx\glslc-ff.bat 
+REM
+IF !"%JOGLDIR%"==""! GOTO YESPATH
+set JOGLDIR=..\lib
+:YESPATH
+   
+java -cp %JOGLDIR%\jogl.core.jar;%JOGLDIR%\jogl.gles2.jar;%JOGLDIR%\jogl.fixed.jar;%JOGLDIR%\jogl.sdk.jar com.sun.opengl.util.glsl.sdk.CompileShaderNVidia FixedFuncColor.fp FixedFuncColorTexture.fp FixedFuncColorLight.vp FixedFuncColor.vp
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc.bat b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc.bat
new file mode 100755
index 000000000..9b5a4b39c
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc.bat
@@ -0,0 +1,9 @@
+REM 
+REM You have to call it from the 'shaders' directory, e.g.:
+REM   scripts\nvidia-apx\glslc.bat <FileName>
+REM
+IF !"%JOGLDIR%"==""! GOTO YESPATH
+set JOGLDIR=..\lib
+:YESPATH
+
+java -cp %JOGLDIR%\jogl.core.jar;%JOGLDIR%\jogl.gles2.jar;%JOGLDIR%\jogl.fixed.jar;%JOGLDIR%\jogl.sdk.jar com.sun.opengl.util.glsl.sdk.CompileShaderNVidia %1
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/sdk/CompileShader.java b/src/jogl/classes/com/sun/opengl/util/glsl/sdk/CompileShader.java
new file mode 100755
index 000000000..f18005feb
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/sdk/CompileShader.java
@@ -0,0 +1,184 @@
+package com.sun.opengl.util.glsl.sdk;
+
+import javax.media.opengl.*;
+import com.sun.opengl.util.*;
+import com.sun.opengl.util.glsl.*;
+
+import java.io.*;
+import java.net.*;
+
+/** Precompiles a shader into a vendor binary format. Input is the
+    resource name of the shader, such as
+    "com/sun/opengl/impl/glsl/fixed/shader/a.fp".
+    Output is "com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/a.bfp". 
+
+    All path and suffixes are determined by the ShaderCode class,
+    which ensures runtime compatibility.
+
+    @see javax.media.opengl.glsl.ShaderCode
+  */
+
+public abstract class CompileShader {
+
+    public abstract int getBinaryFormat();
+
+    public abstract File getSDKCompilerDir();
+
+    public abstract String getVertexShaderCompiler();
+
+    public abstract String getFragmentShaderCompiler();
+
+    public void processOneShader(String resourceName)
+        throws IOException, UnsupportedEncodingException, InterruptedException
+    {
+        int type = -1;
+        String outName=null;
+        int suffixLen = -1;
+        if(resourceName.endsWith(ShaderCode.getFileSuffix(false, GL2ES2.GL_FRAGMENT_SHADER))) {
+            suffixLen = 2;
+            type = GL2ES2.GL_FRAGMENT_SHADER;
+        } else if(resourceName.endsWith(".frag")) {
+            suffixLen = 4;
+            type = GL2ES2.GL_FRAGMENT_SHADER;
+        } else if(resourceName.endsWith(ShaderCode.getFileSuffix(false, GL2ES2.GL_VERTEX_SHADER))) {
+            suffixLen = 2;
+            type = GL2ES2.GL_VERTEX_SHADER;
+        } else if(resourceName.endsWith(".vert")) {
+            suffixLen = 4;
+            type = GL2ES2.GL_VERTEX_SHADER;
+        }
+        String justName = basename(resourceName);
+        outName = justName.substring(0, justName.length() - suffixLen) +
+                  ShaderCode.getFileSuffix(true, type);
+        URL resourceURL = Locator.getResource(null, resourceName);
+        String dirName = dirname(resourceURL.getPath());
+
+        outName = dirName + File.separator + "bin" + File.separator + 
+                  ShaderCode.getBinarySubPath(getBinaryFormat()) + File.separator + 
+                  outName;
+        processOneShader(resourceName, outName, type);
+    }
+
+    public void processOneShader(String resourceName, String outName, int type)
+        throws IOException, UnsupportedEncodingException, InterruptedException
+    {
+        URL resourceURL = Locator.getResource(null, resourceName);
+        String dirName = dirname(resourceURL.getPath());
+
+        String shader = ShaderCode.readShaderSource(null, resourceName);
+        if(null==shader) {
+            System.err.println("Can't find shader source " + resourceName + " - ignored");
+            return;
+        }
+        System.err.println("Preprocessing: "+ resourceName+", in dir: "+dirName);
+        String justName = basename(resourceName);
+        String processor;
+        switch (type) {
+            case GL2ES2.GL_VERTEX_SHADER:
+                processor = getVertexShaderCompiler();
+                break;
+            case GL2ES2.GL_FRAGMENT_SHADER:
+                processor = getFragmentShaderCompiler();
+                break;
+            default:
+                throw new GLException("Unknown shader type: "+type);
+        }
+        File outputFile = new File(outName);
+
+        // Write shader to a file in java.io.tmpdir
+        File tmpDir = new File(dirName+File.separator+"tmp");
+        tmpDir.mkdirs();
+        File tmpFile = new File(tmpDir, justName);
+        Writer writer = new BufferedWriter(new FileWriter(tmpFile));
+        writer.write(shader, 0, shader.length());
+        writer.flush();
+        writer.close();
+        System.err.println("Preprocessed: "+ tmpFile.getAbsolutePath());
+
+        File processorDir = getSDKCompilerDir();
+
+        System.err.println("SDK: "+ processorDir.getAbsolutePath() + ", compiler: "+processor);
+
+        System.err.println("Output: "+ outputFile.getAbsolutePath());
+
+        // Run the tool
+        Process process = Runtime.getRuntime().exec(new String[] {
+                processorDir.getAbsolutePath() + File.separator + processor,
+                tmpFile.getAbsolutePath(),
+                outputFile.getAbsolutePath()
+            }); // , null, processorDir);
+        new StreamMonitor(process.getInputStream());
+        new StreamMonitor(process.getErrorStream());
+        process.waitFor();
+        // Delete the temporary file
+        // tmpFile.delete();
+    }
+
+    protected static String basename(String path) {
+        int lastSlash = path.lastIndexOf("/");
+        if (lastSlash < 0) {
+            lastSlash = path.lastIndexOf("\\");
+        }
+        String basename;
+        if (lastSlash < 0) {
+            basename = path;
+        } else {
+            basename = path.substring(lastSlash + 1);
+        }
+        return basename;
+    }
+
+    protected static String dirname(String path) {
+        int lastSlash = path.lastIndexOf("/");
+        if (lastSlash < 0) {
+            lastSlash = path.lastIndexOf("\\");
+        }
+        String dirname;
+        if (lastSlash < 0) {
+            dirname = new String();
+        } else {
+            dirname = path.substring(0, lastSlash + 1);
+        }
+        return dirname;
+    }
+
+    public void run(String[] args) {
+        try {
+            for (int i = 0; i < args.length; i++) {
+                processOneShader(args[i]);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static class StreamMonitor implements Runnable {
+        private InputStream istream;
+        public StreamMonitor(InputStream stream) {
+            istream = stream;
+            new Thread(this, "Output Reader Thread").start();
+        }
+
+        public void run()
+        {
+            byte[] buffer = new byte[4096];
+            try {
+                int numRead = 0;
+                do {
+                    numRead = istream.read(buffer);
+                    if (numRead > 0) {
+                        System.out.write(buffer, 0, numRead);
+                        System.out.flush();
+                    }
+                } while (numRead >= 0);
+            }
+            catch (IOException e) {
+                try {
+                    istream.close();
+                } catch (IOException e2) {
+                }
+                // Should allow clean exit when process shuts down
+            }
+        }
+    }
+}
diff --git a/src/jogl/classes/com/sun/opengl/util/glsl/sdk/CompileShaderNVidia.java b/src/jogl/classes/com/sun/opengl/util/glsl/sdk/CompileShaderNVidia.java
new file mode 100755
index 000000000..387ccf732
--- /dev/null
+++ b/src/jogl/classes/com/sun/opengl/util/glsl/sdk/CompileShaderNVidia.java
@@ -0,0 +1,53 @@
+package com.sun.opengl.util.glsl.sdk;
+
+import javax.media.opengl.*;
+
+import java.io.*;
+
+/** Precompiles a shader into NVidia binary format. Input is the
+    resource name of the shader, such as
+    "com/sun/opengl/impl/glsl/fixed/shader/a.fp".
+    Output is "com/sun/opengl/impl/glsl/fixed/shader/bin/nvidia/a.bfp". */
+
+public class CompileShaderNVidia extends CompileShader {
+    private static final String NVAPSDK;
+
+    static {
+        String nvapSDKProp = System.getProperty("NVAPSDK");
+        if (nvapSDKProp != null) {
+            NVAPSDK = nvapSDKProp;
+        } else {
+            NVAPSDK = "C:\\nvap_sdk_0_3_x";
+        }
+    }
+
+    public int getBinaryFormat() {
+        return GLES2.GL_NVIDIA_PLATFORM_BINARY_NV;
+    }
+
+    public File getSDKCompilerDir() {
+        File compilerDir = new File( NVAPSDK + File.separator + "tools" + File.separator );
+        File compilerFile = new File( compilerDir, getVertexShaderCompiler());
+        if(!compilerFile.exists()) {
+            compilerDir = new File( NVAPSDK );
+            compilerFile = new File( compilerDir, getVertexShaderCompiler());
+        }
+        if(!compilerFile.exists()) {
+            throw new GLException("Can't find compiler: "+getVertexShaderCompiler() + " in : " +
+                                  NVAPSDK+", "+NVAPSDK + File.separator + "tools");
+        }
+        return compilerDir;
+    }
+
+    public String getVertexShaderCompiler() {
+        return "glslv.bat";
+    }
+
+    public String getFragmentShaderCompiler() {
+        return "glslf.bat";
+    }
+
+    public static void main(String[] args) {
+        new CompileShaderNVidia().run(args);
+    }
+}