Commit: 2289ac83038140baeef31155d98bcea7324bd033 - MikuMikuStudio (git)

Main repository of MikuMikuStudio

Commit MetaInfo

• Revision: 2289ac83038140baeef31155d98bcea7324bd033 (tree)
• Zeit: 2013-07-06 10:37:54
• Autor: Kazuhiko Kobayashi <chototsu_moushinp@yaho...>
• Commiter: kobayasi

Log Message

Support Adreno320, Intel GPU

Ändern Zusammenfassung

• delete: engine/lib/lwjgl/lwjgl_hidden_switches.text
• modified: engine/src/android/com/jme3/renderer/android/OGLESShaderRenderer.java
• add: engine/src/bullet/native/com_jme3_bullet_PhysicsSpace_BroadphaseType.h
• modified: engine/src/core-data/Common/MatDefs/Water/simple_water.frag
• modified: engine/src/core/com/jme3/material/MatParam.java
• modified: engine/src/core/com/jme3/material/Material.java
• modified: engine/src/core/com/jme3/renderer/Renderer.java
• modified: engine/src/core/com/jme3/system/NullRenderer.java
• modified: engine/src/desktop/com/jme3/system/Natives.java
• delete: engine/src/lwjgl-ogl/com/jme3/renderer/lwjgl/LwjglGL1Renderer.java
• modified: engine/src/lwjgl-ogl/com/jme3/renderer/lwjgl/LwjglRenderer.java
• modified: engine/src/lwjgl-ogl/com/jme3/system/lwjgl/LwjglContext.java

Diff

--- a/engine/lib/lwjgl/lwjgl_hidden_switches.text
+++ /dev/null
@@ -1,25 +0,0 @@
-LWJGL "Hidden" switches:
-
-org.lwjgl.opengl.Display.noinput
-Do not initialize any controls when creating the display
-
-org.lwjgl.opengl.Display.nomouse
-Do not create the mouse when creating the display
-
-org.lwjgl.opengl.Display.nokeyboard
-Do not create the keyboard when creating the display
-
-org.lwjgl.util.Debug
-Whether to output debug info
-
-org.lwjgl.util.NoChecks
-Whether to disable runtime function/buffer checks and state tracking.
-
-org.lwjgl.opengl.Display.allowSoftwareOpenGL
-Whether to allow creation of a software only opengl context
-
-org.lwjgl.opengl.Window.undecorated
-Whether to create an undecorated window (no title bar)
-
-org.lwjgl.input.Mouse.allowNegativeMouseCoords
-Usually mouse is clamped to 0,0 - setting this to true will cause you to get negative values if dragging outside and below or left of window
\ No newline at end of file

--- a/engine/src/android/com/jme3/renderer/android/OGLESShaderRenderer.java
+++ b/engine/src/android/com/jme3/renderer/android/OGLESShaderRenderer.java
@@ -176,7 +176,7 @@ public final class OGLESShaderRenderer implements Renderer {
 //                    + "renderer!");
             versionStr = "";
         }
-        logger.info("GLES20.GL_SHADING_LANGUAGE_VERSION = "+versionStr);
+        logger.info("GLES20.GL_SHADING_LANGUAGE_VERSION = " + versionStr);
 
         // Fix issue in TestRenderToMemory when GL_FRONT is the main
         // buffer being used.
@@ -192,7 +192,7 @@ public final class OGLESShaderRenderer implements Renderer {
         float version = 1;
         try {
             version = Float.parseFloat(versionStr);
-        } catch(Exception ex) {
+        } catch (Exception ex) {
         }
         glslVer = (int) (version * 100);
 
@@ -271,7 +271,7 @@ public final class OGLESShaderRenderer implements Renderer {
          */
         GLES20.glGetIntegerv(GLES20.GL_MAX_TEXTURE_SIZE, intBuf16);
         maxTexSize = intBuf16.get(0);
-        logger.log(Level.INFO, "Maximum Texture Resolution: {0}"+ maxTexSize);
+        logger.log(Level.INFO, "Maximum Texture Resolution: {0}" + maxTexSize);
 
         GLES20.glGetIntegerv(GLES20.GL_MAX_CUBE_MAP_TEXTURE_SIZE, intBuf16);
         maxCubeTexSize = intBuf16.get(0);
@@ -406,15 +406,15 @@ public final class OGLESShaderRenderer implements Renderer {
 //	checkGLError();
 
         useVBO = false;
-        
+
         // NOTE: SDK_INT is only available since 1.6, 
         // but for jME3 it doesn't matter since android versions 1.5 and below
         // are not supported.
-        if (Build.VERSION.SDK_INT >= 9){
+        if (Build.VERSION.SDK_INT >= 9) {
             useVBO = true;
         }
         // chekc Adreno200,205,220 bug
-        if (GLES20.glGetString(GLES20.GL_RENDERER).indexOf("Adreno") >=0) {
+        if (GLES20.glGetString(GLES20.GL_RENDERER).indexOf("Adreno") >= 0) {
             adreno_finish_bug = true;
         }
         logger.log(Level.INFO, "Caps: {0}", caps);
@@ -734,7 +734,7 @@ public final class OGLESShaderRenderer implements Renderer {
     public void setClipRect(int x, int y, int width, int height) {
         if (!context.clipRectEnabled) {
 //            if (verboseLogging) {
-                logger.info("GLES20.glEnable(GLES20.GL_SCISSOR_TEST)");
+            logger.info("GLES20.glEnable(GLES20.GL_SCISSOR_TEST)");
 //            }
             GLES20.glEnable(GLES20.GL_SCISSOR_TEST);
             checkGLError();
@@ -1035,10 +1035,10 @@ public final class OGLESShaderRenderer implements Renderer {
             logger.info("GLES20.glShaderSource(" + id + ")");
         }
         if (source.getType().equals(ShaderType.Vertex)
-                && GLES20.glGetString(GLES20.GL_RENDERER).indexOf("PowerVR")>=0) {
+                && GLES20.glGetString(GLES20.GL_RENDERER).indexOf("PowerVR") >= 0) {
             GLES20.glShaderSource(
                     id,
-                     source.getDefines()
+                    source.getDefines()
                     + source.getSource());
         } else {
             GLES20.glShaderSource(
@@ -1090,7 +1090,7 @@ public final class OGLESShaderRenderer implements Renderer {
                 logger.log(Level.FINE, "compile success: " + source.getName());
             }
         } else {
-           logger.log(Level.WARNING, "Bad compile of:\n{0}{1}",
+            logger.log(Level.WARNING, "Bad compile of:\n{0}{1}",
                     new Object[]{source.getDefines(), source.getSource()});
             if (infoLog != null) {
                 throw new RendererException("compile error in:" + source + " error:" + infoLog);
@@ -1297,6 +1297,79 @@ public final class OGLESShaderRenderer implements Renderer {
         }
     }
 
+    public void setShaderWithoutUpdateUniforms(Shader shader) {
+        if (verboseLogging) {
+            logger.info("setShader(" + shader + ")");
+        }
+
+        if (shader == null) {
+            if (context.boundShaderProgram > 0) {
+
+                if (verboseLogging) {
+                    logger.info("GLES20.glUseProgram(0)");
+                }
+
+                GLES20.glUseProgram(0);
+
+                statistics.onShaderUse(null, true);
+                context.boundShaderProgram = 0;
+                boundShader = null;
+            }
+        } else {
+            if (shader.isUpdateNeeded()) {
+                updateShaderData(shader);
+            }
+
+            // NOTE: might want to check if any of the 
+            // sources need an update?
+
+            if (!shader.isUsable()) {
+                logger.warning("shader is not usable.");
+                return;
+            }
+
+            assert shader.getId() > 0;
+
+            if (context.boundShaderProgram != shader.getId()) {
+                if (VALIDATE_SHADER) {
+                    // check if shader can be used
+                    // with current state
+                    if (verboseLogging) {
+                        logger.info("GLES20.glValidateProgram(" + shader.getId() + ")");
+                    }
+
+                    GLES20.glValidateProgram(shader.getId());
+
+                    if (verboseLogging) {
+                        logger.info("GLES20.glGetProgramiv(" + shader.getId() + ", GLES20.GL_VALIDATE_STATUS, buffer)");
+                    }
+
+                    GLES20.glGetProgramiv(shader.getId(), GLES20.GL_VALIDATE_STATUS, intBuf1);
+
+                    boolean validateOK = intBuf1.get(0) == GLES20.GL_TRUE;
+
+                    if (validateOK) {
+                        logger.fine("shader validate success");
+                    } else {
+                        logger.warning("shader validate failure");
+                    }
+                }
+
+                if (verboseLogging) {
+                    logger.info("GLES20.glUseProgram(" + shader.getId() + ")");
+                }
+
+                GLES20.glUseProgram(shader.getId());
+
+                statistics.onShaderUse(shader, true);
+                context.boundShaderProgram = shader.getId();
+                boundShader = shader;
+            } else {
+                statistics.onShaderUse(shader, false);
+            }
+        }
+    }
+
     public void deleteShaderSource(ShaderSource source) {
         if (source.getId() < 0) {
             logger.warning("Shader source is not uploaded to GPU, cannot delete.");
@@ -1577,9 +1650,9 @@ public final class OGLESShaderRenderer implements Renderer {
     }
      */
 
-    public void setMainFrameBufferOverride(FrameBuffer fb){
+    public void setMainFrameBufferOverride(FrameBuffer fb) {
     }
-    
+
     public void setFrameBuffer(FrameBuffer fb) {
         if (verboseLogging) {
             logger.warning("setFrameBuffer is not supported.");
@@ -1716,6 +1789,8 @@ public final class OGLESShaderRenderer implements Renderer {
 
     private void deleteRenderBuffer(FrameBuffer fb, RenderBuffer rb) {
         logger.warning("deleteRenderBuffer is not supported.");
+        intBuf1.put(0, rb.getId());
+        GLES20.glDeleteRenderbuffers(1, intBuf1);
     }
     /*
     private void deleteRenderBuffer(FrameBuffer fb, RenderBuffer rb){
@@ -1726,6 +1801,25 @@ public final class OGLESShaderRenderer implements Renderer {
 
     public void deleteFrameBuffer(FrameBuffer fb) {
         logger.warning("deleteFrameBuffer is not supported.");
+        if (fb.getId() != -1) {
+            if (context.boundFBO == fb.getId()) {
+                GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+                context.boundFBO = 0;
+            }
+
+            if (fb.getDepthBuffer() != null) {
+                deleteRenderBuffer(fb, fb.getDepthBuffer());
+            }
+            if (fb.getColorBuffer() != null) {
+                deleteRenderBuffer(fb, fb.getColorBuffer());
+            }
+
+            intBuf1.put(0, fb.getId());
+            GLES20.glDeleteFramebuffers(1, intBuf1);
+            fb.resetObject();
+
+            statistics.onDeleteFrameBuffer();
+        }
     }
     /*
     public void deleteFrameBuffer(FrameBuffer fb) {
@@ -1917,14 +2011,14 @@ public final class OGLESShaderRenderer implements Renderer {
 
         // bind texture
         int target = convertTextureType(type);
-            if (context.boundTextureUnit != 0) {
-                if (verboseLogging) {
-                    logger.info("GLES20.glActiveTexture(GLES20.GL_TEXTURE0)");
-                }
-
-                GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
-                context.boundTextureUnit = 0;
+        if (context.boundTextureUnit != 0) {
+            if (verboseLogging) {
+                logger.info("GLES20.glActiveTexture(GLES20.GL_TEXTURE0)");
             }
+
+            GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+            context.boundTextureUnit = 0;
+        }
         if (context.boundTextures[0] != img) {
 
             if (verboseLogging) {
@@ -2454,11 +2548,11 @@ public final class OGLESShaderRenderer implements Renderer {
                 }
 
                 Android22Workaround.glVertexAttribPointer(loc,
-                                    vb.getNumComponents(),
-                                    convertFormat(vb.getFormat()),
-                                    vb.isNormalized(),
-                                    vb.getStride(),
-                                    vb.getOffset());
+                        vb.getNumComponents(),
+                        convertFormat(vb.getFormat()),
+                        vb.isNormalized(),
+                        vb.getStride(),
+                        vb.getOffset());
 
                 attribs[loc] = vb;
             }
@@ -2646,9 +2740,9 @@ public final class OGLESShaderRenderer implements Renderer {
         }
 
         ArrayList<VertexBuffer> buffersList = mesh.getBufferList();
-        for (int i = 0; i < buffersList.size(); i++){
+        for (int i = 0; i < buffersList.size(); i++) {
             VertexBuffer vb = buffersList.get(i);
-      
+
             if (vb.getBufferType() == Type.InterleavedData
                     || vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers
                     || vb.getBufferType() == Type.Index) {
@@ -2676,7 +2770,7 @@ public final class OGLESShaderRenderer implements Renderer {
             logger.info("renderMeshVertexArray");
         }
 
-      //  IntMap<VertexBuffer> buffers = mesh.getBuffers();
+        //  IntMap<VertexBuffer> buffers = mesh.getBuffers();
         IntMap<VertexBuffer> buffers = mesh.getBuffers();
         IntMap.Entry<VertexBuffer> table[] = buffers.getTable();
         for (IntMap.Entry<VertexBuffer> entry : table) {
@@ -2713,7 +2807,7 @@ public final class OGLESShaderRenderer implements Renderer {
             drawTriangleList_Array(indices, mesh, count);
         } else {
             if (verboseLogging) {
-                logger.log(Level.INFO, "GLES20.glDrawArrays({0}, {1}, {2})", 
+                logger.log(Level.INFO, "GLES20.glDrawArrays({0}, {1}, {2})",
                         new Object[]{mesh.getMode(), 0, mesh.getVertexCount()});
             }
 
@@ -2723,7 +2817,7 @@ public final class OGLESShaderRenderer implements Renderer {
 
     private void renderMeshDefault(Mesh mesh, int lod, int count) {
         if (verboseLogging) {
-            logger.log(Level.INFO, "renderMeshDefault({0}, {1}, {2})", 
+            logger.log(Level.INFO, "renderMeshDefault({0}, {1}, {2})",
                     new Object[]{mesh, lod, count});
         }
         VertexBuffer indices = null;
@@ -2740,9 +2834,9 @@ public final class OGLESShaderRenderer implements Renderer {
             indices = mesh.getBuffer(Type.Index);// buffers.get(Type.Index.ordinal());
         }
         ArrayList<VertexBuffer> buffersList = mesh.getBufferList();
-        for (int i = 0; i < buffersList.size(); i++){
+        for (int i = 0; i < buffersList.size(); i++) {
             VertexBuffer vb = buffersList.get(i);
-         
+
             if (vb.getBufferType() == Type.InterleavedData
                     || vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers
                     || vb.getBufferType() == Type.Index) {
@@ -2764,7 +2858,7 @@ public final class OGLESShaderRenderer implements Renderer {
         } else {
 //            throw new UnsupportedOperationException("Cannot render without index buffer");
             if (verboseLogging) {
-                logger.log(Level.INFO, "GLES20.glDrawArrays({0}, 0, {1})", 
+                logger.log(Level.INFO, "GLES20.glDrawArrays({0}, 0, {1})",
                         new Object[]{convertElementMode(mesh.getMode()), mesh.getVertexCount()});
             }
 
@@ -2815,8 +2909,8 @@ public final class OGLESShaderRenderer implements Renderer {
     }
 
     private void checkGLError() {
-        
     }
+
     private void checkGLError2() {
         int error;
         while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
@@ -2950,18 +3044,18 @@ public final class OGLESShaderRenderer implements Renderer {
 
                 if (verboseLogging) {
                     logger.log(Level.INFO,
-                            "GLES20.glVertexAttribPointer(" + 
-                            "location={0}, " +
-                            "numComponents={1}, " +
-                            "format={2}, " + 
-                            "isNormalized={3}, " + 
-                            "stride={4}, " + 
-                            "data.capacity={5})", 
-                            new Object[]{loc, vb.getNumComponents(), 
-                                         vb.getFormat(), 
-                                         vb.isNormalized(), 
-                                         vb.getStride(), 
-                                         avb.getData().capacity()});
+                            "GLES20.glVertexAttribPointer("
+                            + "location={0}, "
+                            + "numComponents={1}, "
+                            + "format={2}, "
+                            + "isNormalized={3}, "
+                            + "stride={4}, "
+                            + "data.capacity={5})",
+                            new Object[]{loc, vb.getNumComponents(),
+                                vb.getFormat(),
+                                vb.isNormalized(),
+                                vb.getStride(),
+                                avb.getData().capacity()});
                 }
 
 
@@ -3005,6 +3099,7 @@ public final class OGLESShaderRenderer implements Renderer {
         boundShader = null;
         lastFb = null;
     }
+
     public void resetBoundsTexture() {
         context.boundTextures[0] = null;
         if (context.boundTextureUnit != 0) {
@@ -3012,8 +3107,8 @@ public final class OGLESShaderRenderer implements Renderer {
             context.boundTextureUnit = 0;
         }
 //        GLES20.glDisable(GLES20.GL_TEXTURE_2D);
-            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);         
-            //        context.boundTextureUnit = -2;
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+        //        context.boundTextureUnit = -2;
 //        context.boundElementArrayVBO = -2;
 //        context.boundShaderProgram = -1;
 //        context.boundArrayVBO = -1;

--- /dev/null
+++ b/engine/src/bullet/native/com_jme3_bullet_PhysicsSpace_BroadphaseType.h
@@ -0,0 +1,13 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class com_jme3_bullet_PhysicsSpace_BroadphaseType */
+
+#ifndef _Included_com_jme3_bullet_PhysicsSpace_BroadphaseType
+#define _Included_com_jme3_bullet_PhysicsSpace_BroadphaseType
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif

--- a/engine/src/core-data/Common/MatDefs/Water/simple_water.frag
+++ b/engine/src/core-data/Common/MatDefs/Water/simple_water.frag
@@ -102,7 +102,8 @@ void main(void)
     vec4 E=normalize(viewCamDir);
      vec4 vRef = normalize(reflect(-L,vNorm));
      float stemp =max(0.0, dot( vRef,E) );
-     vec4 specular;
+     //initializing to 0 to avoid artifacts on old intel cards
+     vec4 specular = vec4(0.0,0.0,0.0,0.0);
     if(stemp>0.0){
          stemp = pow(stemp, exponent);
          specular = vec4(stemp);

--- a/engine/src/core/com/jme3/material/MatParam.java
+++ b/engine/src/core/com/jme3/material/MatParam.java
@@ -44,7 +44,6 @@ import com.jme3.math.Quaternion;
 import com.jme3.math.Vector2f;
 import com.jme3.math.Vector3f;
 import com.jme3.math.Vector4f;
-import com.jme3.renderer.GL1Renderer;
 import com.jme3.renderer.Renderer;
 import com.jme3.shader.VarType;
 import com.jme3.texture.Texture;
@@ -279,9 +278,6 @@ public class MatParam implements Savable, Cloneable {
             }
             technique.updateUniformParam(getPrefixedName(), getVarType(), value, true);
         }
-        if (ffBinding != null && r instanceof GL1Renderer) {
-            ((GL1Renderer) r).setFixedFuncBinding(ffBinding, getValue());
-        }
     }
     void apply(Renderer r, Technique technique, int paramIndex) {
         TechniqueDef techDef = technique.getDef();
@@ -295,9 +291,6 @@ public class MatParam implements Savable, Cloneable {
             }
             technique.updateUniformParam(paramIndex, getVarType(), value, true);
         }
-        if (ffBinding != null && r instanceof GL1Renderer) {
-            ((GL1Renderer) r).setFixedFuncBinding(ffBinding, getValue());
-        }
     }
 
     /**

--- a/engine/src/core/com/jme3/material/Material.java
+++ b/engine/src/core/com/jme3/material/Material.java
@@ -1034,7 +1034,7 @@ public class Material implements Asset, Cloneable, Savable, Comparable<Material>
         Renderer r = rm.getRenderer();
 
         TechniqueDef techDef = technique.getDef();
-
+        r.setShaderWithoutUpdateUniforms(technique.getShader());
         if (techDef.getLightMode() == LightMode.MultiPass
                 && geom.getWorldLightList().size() == 0) {
             return;

--- a/engine/src/core/com/jme3/renderer/Renderer.java
+++ b/engine/src/core/com/jme3/renderer/Renderer.java
@@ -175,6 +175,7 @@ public interface Renderer {
      * @param shader The shader to use for rendering.
      */
     public void setShader(Shader shader);
+    public void setShaderWithoutUpdateUniforms(Shader shader);
 
     /**
      * Deletes a shader. This method also deletes

--- a/engine/src/core/com/jme3/system/NullRenderer.java
+++ b/engine/src/core/com/jme3/system/NullRenderer.java
@@ -149,4 +149,7 @@ public class NullRenderer implements Renderer {
     public void setAlphaToCoverage(boolean value) {
     }
 
+    public void setShaderWithoutUpdateUniforms(Shader shader) {
+    }
+
 }

--- a/engine/src/desktop/com/jme3/system/Natives.java
+++ b/engine/src/desktop/com/jme3/system/Natives.java
@@ -172,7 +172,7 @@ public class Natives {
         if (needLWJGL) {
             logger.log(Level.INFO, "Extraction Directory #1: {0}", getExtractionDir());
             logger.log(Level.INFO, "Extraction Directory #2: {0}", workingDir.toString());
-            logger.log(Level.INFO, "Extraction Directory #3: {0}", System.getProperty("user.dir"));
+//            logger.log(Level.INFO, "Extraction Directory #3: {0}", System.getProperty("user.dir"));
             // LWJGL supports this feature where
             // it can load libraries from this path.
             // This is a fallback method in case the OS doesn't load

--- a/engine/src/lwjgl-ogl/com/jme3/renderer/lwjgl/LwjglGL1Renderer.java
+++ /dev/null
@@ -1,1178 +0,0 @@
-package com.jme3.renderer.lwjgl;
-
-import com.jme3.light.SpotLight;
-import java.util.ArrayList;
-import com.jme3.light.PointLight;
-import com.jme3.math.Vector3f;
-import com.jme3.light.DirectionalLight;
-import com.jme3.light.Light;
-import org.lwjgl.opengl.GL14;
-import com.jme3.math.FastMath;
-import com.jme3.renderer.GL1Renderer;
-import com.jme3.shader.Shader;
-import com.jme3.shader.Shader.ShaderSource;
-import com.jme3.texture.FrameBuffer;
-import java.nio.ShortBuffer;
-import java.nio.Buffer;
-import com.jme3.scene.Mesh.Mode;
-import com.jme3.scene.VertexBuffer.Usage;
-import com.jme3.scene.VertexBuffer.Type;
-import com.jme3.util.IntMap.Entry;
-import com.jme3.util.IntMap;
-import com.jme3.scene.Mesh;
-import com.jme3.scene.VertexBuffer;
-import com.jme3.texture.Image;
-import com.jme3.texture.Texture.WrapAxis;
-import com.jme3.texture.Texture;
-import com.jme3.light.LightList;
-import com.jme3.material.FixedFuncBinding;
-import java.nio.FloatBuffer;
-import com.jme3.math.Matrix4f;
-import java.util.logging.Level;
-import com.jme3.material.RenderState;
-import com.jme3.math.ColorRGBA;
-import com.jme3.renderer.Caps;
-import com.jme3.util.NativeObjectManager;
-import com.jme3.renderer.RenderContext;
-import com.jme3.renderer.Statistics;
-import com.jme3.util.BufferUtils;
-import java.nio.ByteBuffer;
-import java.nio.IntBuffer;
-import java.util.EnumSet;
-import java.util.logging.Logger;
-import jme3tools.converters.MipMapGenerator;
-import org.lwjgl.opengl.GL12;
-import org.lwjgl.opengl.GLContext;
-
-import static org.lwjgl.opengl.GL11.*;
-
-public class LwjglGL1Renderer implements GL1Renderer {
-
-    private static final Logger logger = Logger.getLogger(LwjglRenderer.class.getName());
-    private final ByteBuffer nameBuf = BufferUtils.createByteBuffer(250);
-    private final StringBuilder stringBuf = new StringBuilder(250);
-    private final IntBuffer ib1 = BufferUtils.createIntBuffer(1);
-    private final IntBuffer intBuf16 = BufferUtils.createIntBuffer(16);
-    private final FloatBuffer fb16 = BufferUtils.createFloatBuffer(16);
-    private final FloatBuffer fb4Null = BufferUtils.createFloatBuffer(4);
-    private final RenderContext context = new RenderContext();
-    private final NativeObjectManager objManager = new NativeObjectManager();
-    private final EnumSet<Caps> caps = EnumSet.noneOf(Caps.class);
-    private int maxTexSize;
-    private int maxCubeTexSize;
-    private int maxVertCount;
-    private int maxTriCount;
-    private int maxLights;
-    private boolean gl12 = false;
-    private final Statistics statistics = new Statistics();
-    private int vpX, vpY, vpW, vpH;
-    private int clipX, clipY, clipW, clipH;
-    
-    private Matrix4f worldMatrix = new Matrix4f();
-    private Matrix4f viewMatrix = new Matrix4f();
-    
-    private ArrayList<Light> lightList = new ArrayList<Light>(8);
-    private ColorRGBA materialAmbientColor = new ColorRGBA();
-    private Vector3f tempVec = new Vector3f();
-
-    protected void updateNameBuffer() {
-        int len = stringBuf.length();
-
-        nameBuf.position(0);
-        nameBuf.limit(len);
-        for (int i = 0; i < len; i++) {
-            nameBuf.put((byte) stringBuf.charAt(i));
-        }
-
-        nameBuf.rewind();
-    }
-
-    public Statistics getStatistics() {
-        return statistics;
-    }
-
-    public EnumSet<Caps> getCaps() {
-        return caps;
-    }
-
-    public void initialize() {
-        if (GLContext.getCapabilities().OpenGL12){
-            gl12 = true;
-        }
-        
-        // Default values for certain GL state.
-        glShadeModel(GL_SMOOTH);
-        glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
-        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
-        
-		// Enable rescaling/normaling of normal vectors.
-		// Fixes lighting issues with scaled models.
-        if (gl12){
-            glEnable(GL12.GL_RESCALE_NORMAL);
-        }else{
-            glEnable(GL_NORMALIZE);
-        }
-
-        if (GLContext.getCapabilities().GL_ARB_texture_non_power_of_two) {
-            caps.add(Caps.NonPowerOfTwoTextures);
-        } else {
-            logger.log(Level.WARNING, "Your graphics card does not "
-                    + "support non-power-of-2 textures. "
-                    + "Some features might not work.");
-        }
-        
-        maxLights = glGetInteger(GL_MAX_LIGHTS);
-        
-    }
-    
-    public void invalidateState() {
-        context.reset();
-    }
-
-    public void resetGLObjects() {
-        logger.log(Level.INFO, "Reseting objects and invalidating state");
-        objManager.resetObjects();
-        statistics.clearMemory();
-        invalidateState();
-    }
-
-    public void cleanup() {
-        logger.log(Level.INFO, "Deleting objects and invalidating state");
-        objManager.deleteAllObjects(this);
-        statistics.clearMemory();
-        invalidateState();
-    }
-
-    public void setDepthRange(float start, float end) {
-        glDepthRange(start, end);
-    }
-
-    public void clearBuffers(boolean color, boolean depth, boolean stencil) {
-        int bits = 0;
-        if (color) {
-            //See explanations of the depth below, we must enable color write to be able to clear the color buffer
-            if (context.colorWriteEnabled == false) {
-                glColorMask(true, true, true, true);
-                context.colorWriteEnabled = true;
-            }
-            bits = GL_COLOR_BUFFER_BIT;
-        }
-        if (depth) {
-
-            //glClear(GL_DEPTH_BUFFER_BIT) seems to not work when glDepthMask is false
-            //here s some link on openl board
-            //http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=257223
-            //if depth clear is requested, we enable the depthMask
-            if (context.depthWriteEnabled == false) {
-                glDepthMask(true);
-                context.depthWriteEnabled = true;
-            }
-            bits |= GL_DEPTH_BUFFER_BIT;
-        }
-        if (stencil) {
-            bits |= GL_STENCIL_BUFFER_BIT;
-        }
-        if (bits != 0) {
-            glClear(bits);
-        }
-    }
-
-    public void setBackgroundColor(ColorRGBA color) {
-        glClearColor(color.r, color.g, color.b, color.a);
-    }
-
-    private void setMaterialColor(int type, ColorRGBA color, ColorRGBA defaultColor) {
-        if (color != null){
-            fb16.put(color.r).put(color.g).put(color.b).put(color.a).flip();
-        }else{
-            fb16.put(defaultColor.r).put(defaultColor.g).put(defaultColor.b).put(defaultColor.a).flip();
-        }
-        glMaterial(GL_FRONT_AND_BACK, type, fb16);
-    }
-    
-    /**
-     * Applies fixed function bindings from the context to OpenGL
-     */
-    private void applyFixedFuncBindings(boolean forLighting){
-        if (forLighting){
-            glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, context.shininess);
-            setMaterialColor(GL_AMBIENT,  context.ambient,  ColorRGBA.DarkGray);
-            setMaterialColor(GL_DIFFUSE,  context.diffuse,  ColorRGBA.White);
-            setMaterialColor(GL_SPECULAR, context.specular, ColorRGBA.Black);
-            
-            if (context.useVertexColor){
-                glEnable(GL_COLOR_MATERIAL);
-            }else{
-                glDisable(GL_COLOR_MATERIAL);
-            }
-        }else{
-            // Ignore other values as they have no effect when 
-            // GL_LIGHTING is disabled.
-            ColorRGBA color = context.color;
-            if (color != null){
-                glColor4f(color.r, color.g, color.b, color.a);
-            }else{
-                glColor4f(1,1,1,1);
-            }
-        }
-    }
-    
-    /**
-     * Reset fixed function bindings to default values.
-     */
-    private void resetFixedFuncBindings(){
-        context.color = null;
-        context.ambient = null;
-        context.diffuse = null;
-        context.specular = null;
-        context.shininess = 0;
-        context.useVertexColor = false;
-    }
-    
-    public void setFixedFuncBinding(FixedFuncBinding ffBinding, Object val) {
-        switch (ffBinding) {
-            case Color:
-                context.color = (ColorRGBA) val;
-                break;
-            case MaterialAmbient:
-                context.ambient = (ColorRGBA) val;
-                break;
-            case MaterialDiffuse:
-                context.diffuse = (ColorRGBA) val;
-                break;
-            case MaterialSpecular:
-                context.specular = (ColorRGBA) val;
-                break;
-            case MaterialShininess:
-                context.shininess = (Float) val;
-                break;
-            case UseVertexColor:
-                context.useVertexColor = (Boolean) val;
-                break;
-        }
-    }
-    
-    public void applyRenderState(RenderState state) {
-        if (state.isWireframe() && !context.wireframe) {
-            glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-            context.wireframe = true;
-        } else if (!state.isWireframe() && context.wireframe) {
-            glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-            context.wireframe = false;
-        }
-
-        if (state.isDepthTest() && !context.depthTestEnabled) {
-            glEnable(GL_DEPTH_TEST);
-            glDepthFunc(GL_LEQUAL);
-            context.depthTestEnabled = true;
-        } else if (!state.isDepthTest() && context.depthTestEnabled) {
-            glDisable(GL_DEPTH_TEST);
-            context.depthTestEnabled = false;
-        }
-
-        if (state.isAlphaTest() && !context.alphaTestEnabled) {
-            glEnable(GL_ALPHA_TEST);
-            glAlphaFunc(GL_GREATER, state.getAlphaFallOff());
-            context.alphaTestEnabled = true;
-        } else if (!state.isAlphaTest() && context.alphaTestEnabled) {
-            glDisable(GL_ALPHA_TEST);
-            context.alphaTestEnabled = false;
-        }
-
-        if (state.isDepthWrite() && !context.depthWriteEnabled) {
-            glDepthMask(true);
-            context.depthWriteEnabled = true;
-        } else if (!state.isDepthWrite() && context.depthWriteEnabled) {
-            glDepthMask(false);
-            context.depthWriteEnabled = false;
-        }
-
-        if (state.isColorWrite() && !context.colorWriteEnabled) {
-            glColorMask(true, true, true, true);
-            context.colorWriteEnabled = true;
-        } else if (!state.isColorWrite() && context.colorWriteEnabled) {
-            glColorMask(false, false, false, false);
-            context.colorWriteEnabled = false;
-        }
-
-        if (state.isPointSprite()) {
-            logger.log(Level.WARNING, "Point Sprite unsupported!");
-        }
-
-        if (state.isPolyOffset()) {
-            if (!context.polyOffsetEnabled) {
-                glEnable(GL_POLYGON_OFFSET_FILL);
-                glPolygonOffset(state.getPolyOffsetFactor(),
-                        state.getPolyOffsetUnits());
-                context.polyOffsetEnabled = true;
-                context.polyOffsetFactor = state.getPolyOffsetFactor();
-                context.polyOffsetUnits = state.getPolyOffsetUnits();
-            } else {
-                if (state.getPolyOffsetFactor() != context.polyOffsetFactor
-                        || state.getPolyOffsetUnits() != context.polyOffsetUnits) {
-                    glPolygonOffset(state.getPolyOffsetFactor(),
-                            state.getPolyOffsetUnits());
-                    context.polyOffsetFactor = state.getPolyOffsetFactor();
-                    context.polyOffsetUnits = state.getPolyOffsetUnits();
-                }
-            }
-        } else {
-            if (context.polyOffsetEnabled) {
-                glDisable(GL_POLYGON_OFFSET_FILL);
-                context.polyOffsetEnabled = false;
-                context.polyOffsetFactor = 0;
-                context.polyOffsetUnits = 0;
-            }
-        }
-        if (state.getFaceCullMode() != context.cullMode) {
-            if (state.getFaceCullMode() == RenderState.FaceCullMode.Off) {
-                glDisable(GL_CULL_FACE);
-            } else {
-                glEnable(GL_CULL_FACE);
-            }
-
-            switch (state.getFaceCullMode()) {
-                case Off:
-                    break;
-                case Back:
-                    glCullFace(GL_BACK);
-                    break;
-                case Front:
-                    glCullFace(GL_FRONT);
-                    break;
-                case FrontAndBack:
-                    glCullFace(GL_FRONT_AND_BACK);
-                    break;
-                default:
-                    throw new UnsupportedOperationException("Unrecognized face cull mode: "
-                            + state.getFaceCullMode());
-            }
-
-            context.cullMode = state.getFaceCullMode();
-        }
-
-        if (state.getBlendMode() != context.blendMode) {
-            if (state.getBlendMode() == RenderState.BlendMode.Off) {
-                glDisable(GL_BLEND);
-            } else {
-                glEnable(GL_BLEND);
-                switch (state.getBlendMode()) {
-                    case Off:
-                        break;
-                    case Additive:
-                        glBlendFunc(GL_ONE, GL_ONE);
-                        break;
-                    case AlphaAdditive:
-                        glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-                        break;
-                    case Color:
-                        glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
-                        break;
-                    case Alpha:
-                        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-                        break;
-                    case PremultAlpha:
-                        glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-                        break;
-                    case Modulate:
-                        glBlendFunc(GL_DST_COLOR, GL_ZERO);
-                        break;
-                    case ModulateX2:
-                        glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
-                        break;
-                    default:
-                        throw new UnsupportedOperationException("Unrecognized blend mode: "
-                                + state.getBlendMode());
-                }
-            }
-
-            context.blendMode = state.getBlendMode();
-        }
-
-        if (state.isStencilTest()) {
-            throw new UnsupportedOperationException("OpenGL 1.1 doesn't support two sided stencil operations.");
-        }
-
-    }
-
-    public void setViewPort(int x, int y, int w, int h) {
-        if (x != vpX || vpY != y || vpW != w || vpH != h) {
-            glViewport(x, y, w, h);
-            vpX = x;
-            vpY = y;
-            vpW = w;
-            vpH = h;
-        }
-    }
-
-    public void setClipRect(int x, int y, int width, int height) {
-        if (!context.clipRectEnabled) {
-            glEnable(GL_SCISSOR_TEST);
-            context.clipRectEnabled = true;
-        }
-        if (clipX != x || clipY != y || clipW != width || clipH != height) {
-            glScissor(x, y, width, height);
-            clipX = x;
-            clipY = y;
-            clipW = width;
-            clipH = height;
-        }
-    }
-
-    public void clearClipRect() {
-        if (context.clipRectEnabled) {
-            glDisable(GL_SCISSOR_TEST);
-            context.clipRectEnabled = false;
-
-            clipX = 0;
-            clipY = 0;
-            clipW = 0;
-            clipH = 0;
-        }
-    }
-
-    public void onFrame() {
-        objManager.deleteUnused(this);
-//        statistics.clearFrame();
-    }
-
-    private FloatBuffer storeMatrix(Matrix4f matrix, FloatBuffer store) {
-        store.clear();
-        matrix.fillFloatBuffer(store, true);
-        store.clear();
-        return store;
-    }
-    
-    private void setModelView(Matrix4f modelMatrix, Matrix4f viewMatrix){
-        if (context.matrixMode != GL_MODELVIEW) {
-            glMatrixMode(GL_MODELVIEW);
-            context.matrixMode = GL_MODELVIEW;
-        }
-
-        glLoadMatrix(storeMatrix(viewMatrix, fb16));
-        glMultMatrix(storeMatrix(modelMatrix, fb16));
-    }
-    
-    private void setProjection(Matrix4f projMatrix){
-        if (context.matrixMode != GL_PROJECTION) {
-            glMatrixMode(GL_PROJECTION);
-            context.matrixMode = GL_PROJECTION;
-        }
-
-        glLoadMatrix(storeMatrix(projMatrix, fb16));
-    }
-
-    public void setWorldMatrix(Matrix4f worldMatrix) {
-        this.worldMatrix.set(worldMatrix);
-    }
-
-    public void setViewProjectionMatrices(Matrix4f viewMatrix, Matrix4f projMatrix) {
-        this.viewMatrix.set(viewMatrix);
-        setProjection(projMatrix);
-    }
-
-    public void setLighting(LightList list) {
-        // XXX: This is abuse of setLighting() to
-		// apply fixed function bindings
-        // and do other book keeping.
-        if (list == null || list.size() == 0){
-            glDisable(GL_LIGHTING);
-            applyFixedFuncBindings(false);
-            setModelView(worldMatrix, viewMatrix);
-            return;
-        }
-        
-        // Number of lights set previously
-        int numLightsSetPrev = lightList.size();
-        
-        // If more than maxLights are defined, they will be ignored.
-        // The GL1 renderer is not permitted to crash due to a 
-        // GL1 limitation. It must render anything that the GL2 renderer
-        // can render (even incorrectly).
-        lightList.clear();
-        materialAmbientColor.set(0, 0, 0, 0);
-        
-        for (int i = 0; i < list.size(); i++){
-            Light l = list.get(i);
-            if (l.getType() == Light.Type.Ambient){
-                // Gather
-                materialAmbientColor.addLocal(l.getColor());
-            }else{
-                // Add to list
-                lightList.add(l);
-                
-                // Once maximum lights reached, exit loop.
-                if (lightList.size() >= maxLights){
-                    break;
-                }
-            }
-        }
-        
-        applyFixedFuncBindings(true);
-        
-        glEnable(GL_LIGHTING);
-        
-        fb16.clear();
-        fb16.put(materialAmbientColor.r)
-            .put(materialAmbientColor.g)
-            .put(materialAmbientColor.b)
-            .put(1).flip();
-        
-        glLightModel(GL_LIGHT_MODEL_AMBIENT, fb16);
-        
-        if (context.matrixMode != GL_MODELVIEW) {
-            glMatrixMode(GL_MODELVIEW);
-            context.matrixMode = GL_MODELVIEW;
-        }
-        // Lights are already in world space, so just convert
-        // them to view space.
-        glLoadMatrix(storeMatrix(viewMatrix, fb16));
-        
-        for (int i = 0; i < lightList.size(); i++){
-            int glLightIndex = GL_LIGHT0 + i;
-            Light light = lightList.get(i);
-            Light.Type lightType = light.getType();
-            ColorRGBA col = light.getColor();
-            Vector3f pos;
-            
-            // Enable the light
-            glEnable(glLightIndex);
-            
-            // OGL spec states default value for light ambient is black
-            switch (lightType){
-                case Directional:
-                    DirectionalLight dLight = (DirectionalLight) light;
-
-                    fb16.clear();
-                    fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
-                    glLight(glLightIndex, GL_DIFFUSE, fb16);
-                    glLight(glLightIndex, GL_SPECULAR, fb16);
-
-                    pos = tempVec.set(dLight.getDirection()).negateLocal().normalizeLocal();
-                    fb16.clear();
-                    fb16.put(pos.x).put(pos.y).put(pos.z).put(0.0f).flip();
-                    glLight(glLightIndex, GL_POSITION, fb16);
-                    glLightf(glLightIndex, GL_SPOT_CUTOFF, 180);
-                    break;
-                case Point:
-                    PointLight pLight = (PointLight) light;
-      
-                    fb16.clear();
-                    fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
-                    glLight(glLightIndex, GL_DIFFUSE, fb16);
-                    glLight(glLightIndex, GL_SPECULAR, fb16);
-
-                    pos = pLight.getPosition();
-                    fb16.clear();
-                    fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip();
-                    glLight(glLightIndex, GL_POSITION, fb16);
-                    glLightf(glLightIndex, GL_SPOT_CUTOFF, 180);
-
-                    if (pLight.getRadius() > 0) {
-                        // Note: this doesn't follow the same attenuation model
-                        // as the one used in the lighting shader.
-                        glLightf(glLightIndex, GL_CONSTANT_ATTENUATION,  1);
-                        glLightf(glLightIndex, GL_LINEAR_ATTENUATION,    pLight.getInvRadius() * 2);
-                        glLightf(glLightIndex, GL_QUADRATIC_ATTENUATION, pLight.getInvRadius() * pLight.getInvRadius()); 
-                    }else{
-                        glLightf(glLightIndex, GL_CONSTANT_ATTENUATION,  1);
-                        glLightf(glLightIndex, GL_LINEAR_ATTENUATION,    0);
-                        glLightf(glLightIndex, GL_QUADRATIC_ATTENUATION, 0);
-                    }
-
-                    break;
-                case Spot:
-                    SpotLight sLight = (SpotLight) light;
-
-                    fb16.clear();
-                    fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip();
-                    glLight(glLightIndex, GL_DIFFUSE, fb16);
-                    glLight(glLightIndex, GL_SPECULAR, fb16);
-
-                    pos = sLight.getPosition();
-                    fb16.clear();
-                    fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip();
-                    glLight(glLightIndex, GL_POSITION, fb16);
-
-                    Vector3f dir = sLight.getDirection();
-                    fb16.clear();
-                    fb16.put(dir.x).put(dir.y).put(dir.z).put(1.0f).flip();
-                    glLight(glLightIndex, GL_SPOT_DIRECTION, fb16);
-
-                    float outerAngleRad = sLight.getSpotOuterAngle();
-                    float innerAngleRad = sLight.getSpotInnerAngle();
-                    float spotCut = outerAngleRad * FastMath.RAD_TO_DEG;
-                    float spotExpo = 0.0f;
-                    if (outerAngleRad > 0) {
-                        spotExpo = (1.0f - (innerAngleRad / outerAngleRad)) * 128.0f;
-                    }
-
-                    glLightf(glLightIndex, GL_SPOT_CUTOFF, spotCut);
-                    glLightf(glLightIndex, GL_SPOT_EXPONENT, spotExpo);
-
-                    if (sLight.getSpotRange() > 0) {
-                        glLightf(glLightIndex, GL_LINEAR_ATTENUATION, sLight.getInvSpotRange());
-                    }else{
-                        glLightf(glLightIndex, GL_LINEAR_ATTENUATION, 0);
-                    }
-
-                    break;
-                default:
-                    throw new UnsupportedOperationException(
-                            "Unrecognized light type: " + lightType);
-            }
-        }
-        
-        // Disable lights after the index
-        for (int i = lightList.size(); i < numLightsSetPrev; i++){
-            glDisable(GL_LIGHT0 + i);
-        }
-        
-        // This will set view matrix as well.
-        setModelView(worldMatrix, viewMatrix);
-    }
-
-    private int convertTextureType(Texture.Type type) {
-        switch (type) {
-            case TwoDimensional:
-                return GL_TEXTURE_2D;
-//            case ThreeDimensional:
-//                return GL_TEXTURE_3D;
-//            case CubeMap:
-//                return GL_TEXTURE_CUBE_MAP;
-            default:
-                throw new UnsupportedOperationException("Unknown texture type: " + type);
-        }
-    }
-
-    private int convertMagFilter(Texture.MagFilter filter) {
-        switch (filter) {
-            case Bilinear:
-                return GL_LINEAR;
-            case Nearest:
-                return GL_NEAREST;
-            default:
-                throw new UnsupportedOperationException("Unknown mag filter: " + filter);
-        }
-    }
-
-    private int convertMinFilter(Texture.MinFilter filter) {
-        switch (filter) {
-            case Trilinear:
-                return GL_LINEAR_MIPMAP_LINEAR;
-            case BilinearNearestMipMap:
-                return GL_LINEAR_MIPMAP_NEAREST;
-            case NearestLinearMipMap:
-                return GL_NEAREST_MIPMAP_LINEAR;
-            case NearestNearestMipMap:
-                return GL_NEAREST_MIPMAP_NEAREST;
-            case BilinearNoMipMaps:
-                return GL_LINEAR;
-            case NearestNoMipMaps:
-                return GL_NEAREST;
-            default:
-                throw new UnsupportedOperationException("Unknown min filter: " + filter);
-        }
-    }
-
-    private int convertWrapMode(Texture.WrapMode mode) {
-        switch (mode) {
-            case EdgeClamp:
-            case Clamp:
-            case BorderClamp:
-                return GL_CLAMP;
-            case Repeat:
-                return GL_REPEAT;
-            default:
-                throw new UnsupportedOperationException("Unknown wrap mode: " + mode);
-        }
-    }
-
-    private void setupTextureParams(Texture tex) {
-        int target = convertTextureType(tex.getType());
-
-        // filter things
-        int minFilter = convertMinFilter(tex.getMinFilter());
-        int magFilter = convertMagFilter(tex.getMagFilter());
-        glTexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilter);
-        glTexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilter);
-
-        // repeat modes
-        switch (tex.getType()) {
-//            case ThreeDimensional:
-//            case CubeMap:
-//                glTexParameteri(target, GL_TEXTURE_WRAP_R, convertWrapMode(tex.getWrap(WrapAxis.R)));
-            case TwoDimensional:
-                glTexParameteri(target, GL_TEXTURE_WRAP_T, convertWrapMode(tex.getWrap(WrapAxis.T)));
-                // fall down here is intentional..
-//            case OneDimensional:
-                glTexParameteri(target, GL_TEXTURE_WRAP_S, convertWrapMode(tex.getWrap(WrapAxis.S)));
-                break;
-            default:
-                throw new UnsupportedOperationException("Unknown texture type: " + tex.getType());
-        }
-    }
-
-    public void updateTexImageData(Image img, Texture.Type type, boolean mips, int unit) {
-        int texId = img.getId();
-        if (texId == -1) {
-            // create texture
-            glGenTextures(ib1);
-            texId = ib1.get(0);
-            img.setId(texId);
-            objManager.registerForCleanup(img);
-
-            statistics.onNewTexture();
-        }
-
-        // bind texture
-        int target = convertTextureType(type);
-//        if (context.boundTextureUnit != unit) {
-//            glActiveTexture(GL_TEXTURE0 + unit);
-//            context.boundTextureUnit = unit;
-//        }
-        if (context.boundTextures[unit] != img) {
-            glEnable(target);
-            glBindTexture(target, texId);
-            context.boundTextures[unit] = img;
-
-            statistics.onTextureUse(img, true);
-        }
-
-        // Check sizes if graphics card doesn't support NPOT
-        if (!GLContext.getCapabilities().GL_ARB_texture_non_power_of_two) {
-            if (img.getWidth() != 0 && img.getHeight() != 0) {
-                if (!FastMath.isPowerOfTwo(img.getWidth())
-                        || !FastMath.isPowerOfTwo(img.getHeight())) {
-
-                    // Resize texture to Power-of-2 size
-                    MipMapGenerator.resizeToPowerOf2(img);
-
-                }
-            }
-        }
-
-        if (!img.hasMipmaps() && mips) {
-            // No pregenerated mips available,
-            // generate from base level if required
-
-            // Check if hardware mips are supported
-            if (GLContext.getCapabilities().OpenGL14) {
-                glTexParameteri(target, GL14.GL_GENERATE_MIPMAP, GL_TRUE);
-            } else {
-                MipMapGenerator.generateMipMaps(img);
-            }
-        } else {
-        }
-
-        /*
-        if (target == GL_TEXTURE_CUBE_MAP) {
-        List<ByteBuffer> data = img.getData();
-        if (data.size() != 6) {
-        logger.log(Level.WARNING, "Invalid texture: {0}\n"
-        + "Cubemap textures must contain 6 data units.", img);
-        return;
-        }
-        for (int i = 0; i < 6; i++) {
-        TextureUtil.uploadTexture(img, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, i, 0, tdc);
-        }
-        } else if (target == EXTTextureArray.GL_TEXTURE_2D_ARRAY_EXT) {
-        List<ByteBuffer> data = img.getData();
-        // -1 index specifies prepare data for 2D Array
-        TextureUtil.uploadTexture(img, target, -1, 0, tdc);
-        for (int i = 0; i < data.size(); i++) {
-        // upload each slice of 2D array in turn
-        // this time with the appropriate index
-        TextureUtil.uploadTexture(img, target, i, 0, tdc);
-        }
-        } else {*/
-        TextureUtil.uploadTexture(img, target, 0, 0, false);
-        //}
-
-        img.clearUpdateNeeded();
-    }
-
-    public void setTexture(int unit, Texture tex) {
-        if (unit != 0 || tex.getType() != Texture.Type.TwoDimensional) {
-            //throw new UnsupportedOperationException();
-            return;
-        }
-
-        Image image = tex.getImage();
-        if (image.isUpdateNeeded()) {
-            updateTexImageData(image, tex.getType(), tex.getMinFilter().usesMipMapLevels(), unit);
-        }
-
-        int texId = image.getId();
-        assert texId != -1;
-
-        Image[] textures = context.boundTextures;
-
-        int type = convertTextureType(tex.getType());
-//        if (!context.textureIndexList.moveToNew(unit)) {
-//             if (context.boundTextureUnit != unit){
-//                glActiveTexture(GL_TEXTURE0 + unit);
-//                context.boundTextureUnit = unit;
-//             }
-//             glEnable(type);
-//        }
-
-//        if (context.boundTextureUnit != unit) {
-//            glActiveTexture(GL_TEXTURE0 + unit);
-//            context.boundTextureUnit = unit;
-//        }
-
-        if (textures[unit] != image) {
-            glEnable(type);
-            glBindTexture(type, texId);
-            textures[unit] = image;
-
-            statistics.onTextureUse(image, true);
-        } else {
-            statistics.onTextureUse(image, false);
-        }
-
-        setupTextureParams(tex);
-    }
-
-    private void clearTextureUnits() {
-        Image[] textures = context.boundTextures;
-        if (textures[0] != null) {
-            glDisable(GL_TEXTURE_2D);
-            textures[0] = null;
-        }
-    }
-
-    public void deleteImage(Image image) {
-        int texId = image.getId();
-        if (texId != -1) {
-            ib1.put(0, texId);
-            ib1.position(0).limit(1);
-            glDeleteTextures(ib1);
-            image.resetObject();
-        }
-    }
-
-    private int convertArrayType(VertexBuffer.Type type) {
-        switch (type) {
-            case Position:
-                return GL_VERTEX_ARRAY;
-            case Normal:
-                return GL_NORMAL_ARRAY;
-            case TexCoord:
-                return GL_TEXTURE_COORD_ARRAY;
-            case Color:
-                return GL_COLOR_ARRAY;
-            default:
-                return -1; // unsupported
-        }
-    }
-
-    private int convertVertexFormat(VertexBuffer.Format fmt) {
-        switch (fmt) {
-            case Byte:
-                return GL_BYTE;
-            case Float:
-                return GL_FLOAT;
-            case Int:
-                return GL_INT;
-            case Short:
-                return GL_SHORT;
-            case UnsignedByte:
-                return GL_UNSIGNED_BYTE;
-            case UnsignedInt:
-                return GL_UNSIGNED_INT;
-            case UnsignedShort:
-                return GL_UNSIGNED_SHORT;
-            default:
-                throw new UnsupportedOperationException("Unrecognized vertex format: " + fmt);
-        }
-    }
-
-    private int convertElementMode(Mesh.Mode mode) {
-        switch (mode) {
-            case Points:
-                return GL_POINTS;
-            case Lines:
-                return GL_LINES;
-            case LineLoop:
-                return GL_LINE_LOOP;
-            case LineStrip:
-                return GL_LINE_STRIP;
-            case Triangles:
-                return GL_TRIANGLES;
-            case TriangleFan:
-                return GL_TRIANGLE_FAN;
-            case TriangleStrip:
-                return GL_TRIANGLE_STRIP;
-            default:
-                throw new UnsupportedOperationException("Unrecognized mesh mode: " + mode);
-        }
-    }
-
-    public void drawTriangleArray(Mesh.Mode mode, int count, int vertCount) {
-        if (count > 1) {
-            throw new UnsupportedOperationException();
-        }
-
-        glDrawArrays(convertElementMode(mode), 0, vertCount);
-    }
-
-    public void setVertexAttrib(VertexBuffer vb, VertexBuffer idb) {
-        int arrayType = convertArrayType(vb.getBufferType());
-        if (arrayType == -1) {
-            return; // unsupported
-        }
-        glEnableClientState(arrayType);
-        context.boundAttribs[vb.getBufferType().ordinal()] = vb;
-
-        if (vb.getBufferType() == Type.Normal) {
-            // normalize if requested
-            if (vb.isNormalized() && !context.normalizeEnabled) {
-                glEnable(GL_NORMALIZE);
-                context.normalizeEnabled = true;
-            } else if (!vb.isNormalized() && context.normalizeEnabled) {
-                glDisable(GL_NORMALIZE);
-                context.normalizeEnabled = false;
-            }
-        }
-
-        // NOTE: Use data from interleaved buffer if specified
-        Buffer data = idb != null ? idb.getData() : vb.getData();
-        int comps = vb.getNumComponents();
-        int type = convertVertexFormat(vb.getFormat());
-
-        data.rewind();
-
-        switch (vb.getBufferType()) {
-            case Position:
-                if (!(data instanceof FloatBuffer)) {
-                    throw new UnsupportedOperationException();
-                }
-
-                glVertexPointer(comps, vb.getStride(), (FloatBuffer) data);
-                break;
-            case Normal:
-                if (!(data instanceof FloatBuffer)) {
-                    throw new UnsupportedOperationException();
-                }
-
-                glNormalPointer(vb.getStride(), (FloatBuffer) data);
-                break;
-            case Color:
-                if (data instanceof FloatBuffer) {
-                    glColorPointer(comps, vb.getStride(), (FloatBuffer) data);
-                } else if (data instanceof ByteBuffer) {
-                    glColorPointer(comps, true, vb.getStride(), (ByteBuffer) data);
-                } else {
-                    throw new UnsupportedOperationException();
-                }
-                break;
-            case TexCoord:
-                if (!(data instanceof FloatBuffer)) {
-                    throw new UnsupportedOperationException();
-                }
-
-                glTexCoordPointer(comps, vb.getStride(), (FloatBuffer) data);
-                break;
-            default:
-                // Ignore, this is an unsupported attribute for OpenGL1.
-                break;
-        }
-    }
-
-    public void setVertexAttrib(VertexBuffer vb) {
-        setVertexAttrib(vb, null);
-    }
-
-    private void drawElements(int mode, int format, Buffer data) {
-        switch (format) {
-            case GL_UNSIGNED_BYTE:
-                glDrawElements(mode, (ByteBuffer) data);
-                break;
-            case GL_UNSIGNED_SHORT:
-                glDrawElements(mode, (ShortBuffer) data);
-                break;
-            case GL_UNSIGNED_INT:
-                glDrawElements(mode, (IntBuffer) data);
-                break;
-            default:
-                throw new UnsupportedOperationException();
-        }
-    }
-
-    public void drawTriangleList(VertexBuffer indexBuf, Mesh mesh, int count) {
-        Mesh.Mode mode = mesh.getMode();
-
-        Buffer indexData = indexBuf.getData();
-        indexData.rewind();
-
-        if (mesh.getMode() == Mode.Hybrid) {
-            throw new UnsupportedOperationException();
-            /*
-            int[] modeStart = mesh.getModeStart();
-            int[] elementLengths = mesh.getElementLengths();
-            
-            int elMode = convertElementMode(Mode.Triangles);
-            int fmt = convertVertexFormat(indexBuf.getFormat());
-            //            int elSize = indexBuf.getFormat().getComponentSize();
-            //            int listStart = modeStart[0];
-            int stripStart = modeStart[1];
-            int fanStart = modeStart[2];
-            int curOffset = 0;
-            for (int i = 0; i < elementLengths.length; i++) {
-            if (i == stripStart) {
-            elMode = convertElementMode(Mode.TriangleStrip);
-            } else if (i == fanStart) {
-            elMode = convertElementMode(Mode.TriangleStrip);
-            }
-            int elementLength = elementLengths[i];
-            indexData.position(curOffset);
-            
-            drawElements(elMode,
-            fmt,
-            indexData);
-            
-            curOffset += elementLength;
-            }*/
-        } else {
-            drawElements(convertElementMode(mode),
-                    convertVertexFormat(indexBuf.getFormat()),
-                    indexData);
-        }
-    }
-
-    public void clearVertexAttribs() {
-        for (int i = 0; i < 16; i++) {
-            VertexBuffer vb = context.boundAttribs[i];
-            if (vb != null) {
-                int arrayType = convertArrayType(vb.getBufferType());
-                glDisableClientState(arrayType);
-                context.boundAttribs[vb.getBufferType().ordinal()] = null;
-            }
-        }
-    }
-
-    private void renderMeshDefault(Mesh mesh, int lod, int count) {
-        VertexBuffer indices = null;
-
-        VertexBuffer interleavedData = mesh.getBuffer(Type.InterleavedData);
-        if (interleavedData != null && interleavedData.isUpdateNeeded()) {
-            updateBufferData(interleavedData);
-        }
-
-        IntMap<VertexBuffer> buffers = mesh.getBuffers();
-        if (mesh.getNumLodLevels() > 0) {
-            indices = mesh.getLodLevel(lod);
-        } else {
-            indices = buffers.get(Type.Index.ordinal());
-        }
-        for (Entry<VertexBuffer> entry : buffers) {
-            VertexBuffer vb = entry.getValue();
-
-            if (vb.getBufferType() == Type.InterleavedData
-                    || vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers
-                    || vb.getBufferType() == Type.Index) {
-                continue;
-            }
-
-            if (vb.getStride() == 0) {
-                // not interleaved
-                setVertexAttrib(vb);
-            } else {
-                // interleaved
-                setVertexAttrib(vb, interleavedData);
-            }
-        }
-
-        if (indices != null) {
-            drawTriangleList(indices, mesh, count);
-        } else {
-            glDrawArrays(convertElementMode(mesh.getMode()), 0, mesh.getVertexCount());
-        }
-        
-        // TODO: Fix these to use IDList??
-        clearVertexAttribs();
-        clearTextureUnits();
-        resetFixedFuncBindings();
-    }
-
-    public void renderMesh(Mesh mesh, int lod, int count) {
-        if (mesh.getVertexCount() == 0) {
-            return;
-        }
-
-        if (context.pointSize != mesh.getPointSize()) {
-            glPointSize(mesh.getPointSize());
-            context.pointSize = mesh.getPointSize();
-        }
-        if (context.lineWidth != mesh.getLineWidth()) {
-            glLineWidth(mesh.getLineWidth());
-            context.lineWidth = mesh.getLineWidth();
-        }
-        
-        boolean dynamic = false;
-        if (mesh.getBuffer(Type.InterleavedData) != null) {
-            throw new UnsupportedOperationException("Interleaved meshes are not supported");
-        }
-
-        if (mesh.getNumLodLevels() == 0) {
-            IntMap<VertexBuffer> bufs = mesh.getBuffers();
-            for (Entry<VertexBuffer> entry : bufs) {
-                if (entry.getValue().getUsage() != VertexBuffer.Usage.Static) {
-                    dynamic = true;
-                    break;
-                }
-            }
-        } else {
-            dynamic = true;
-        }
-
-        statistics.onMeshDrawn(mesh, lod);
-
-//        if (!dynamic) {
-        // dealing with a static object, generate display list
-//            renderMeshDisplayList(mesh);
-//        } else {
-        renderMeshDefault(mesh, lod, count);
-//        }
-
-
-    }
-
-    public void setAlphaToCoverage(boolean value) {
-    }
-
-    public void setShader(Shader shader) {
-    }
-
-    public void deleteShader(Shader shader) {
-    }
-
-    public void deleteShaderSource(ShaderSource source) {
-    }
-
-    public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst) {
-    }
-
-    public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst, boolean copyDepth) {
-    }
-
-    public void setMainFrameBufferOverride(FrameBuffer fb){
-    }
-    
-    public void setFrameBuffer(FrameBuffer fb) {
-    }
-
-    public void readFrameBuffer(FrameBuffer fb, ByteBuffer byteBuf) {
-    }
-
-    public void deleteFrameBuffer(FrameBuffer fb) {
-    }
-
-    public void updateBufferData(VertexBuffer vb) {
-    }
-
-    public void deleteBuffer(VertexBuffer vb) {
-    }
-}

--- a/engine/src/lwjgl-ogl/com/jme3/renderer/lwjgl/LwjglRenderer.java
+++ b/engine/src/lwjgl-ogl/com/jme3/renderer/lwjgl/LwjglRenderer.java
@@ -1187,6 +1187,54 @@ public class LwjglRenderer implements Renderer {
         }
     }
 
+    public void setShaderWithoutUpdateUniforms(Shader shader) {
+        if (shader == null) {
+            throw new IllegalArgumentException("shader cannot be null");
+//            if (context.boundShaderProgram > 0) {
+//                glUseProgram(0);
+//                statistics.onShaderUse(null, true);
+//                context.boundShaderProgram = 0;
+//                boundShader = null;
+//            }
+        } else {
+            if (shader.isUpdateNeeded()) {
+                updateShaderData(shader);
+            }
+
+            // NOTE: might want to check if any of the
+            // sources need an update?
+
+            if (!shader.isUsable()) {
+                return;
+            }
+
+            assert shader.getId() > 0;
+
+//            updateShaderUniforms(shader);
+            if (context.boundShaderProgram != shader.getId()) {
+                if (VALIDATE_SHADER) {
+                    // check if shader can be used
+                    // with current state
+                    glValidateProgram(shader.getId());
+                    glGetProgram(shader.getId(), GL_VALIDATE_STATUS, intBuf1);
+                    boolean validateOK = intBuf1.get(0) == GL_TRUE;
+                    if (validateOK) {
+                        logger.fine("shader validate success");
+                    } else {
+                        logger.warning("shader validate failure");
+                    }
+                }
+
+                glUseProgram(shader.getId());
+                statistics.onShaderUse(shader, true);
+                context.boundShaderProgram = shader.getId();
+                boundShader = shader;
+            } else {
+                statistics.onShaderUse(shader, false);
+            }
+        }
+    }
+
     public void deleteShaderSource(ShaderSource source) {
         if (source.getId() < 0) {
             logger.warning("Shader source is not uploaded to GPU, cannot delete.");

--- a/engine/src/lwjgl-ogl/com/jme3/system/lwjgl/LwjglContext.java
+++ b/engine/src/lwjgl-ogl/com/jme3/system/lwjgl/LwjglContext.java
@@ -36,7 +36,6 @@ import com.jme3.input.lwjgl.JInputJoyInput;
 import com.jme3.input.lwjgl.LwjglKeyInput;
 import com.jme3.input.lwjgl.LwjglMouseInput;
 import com.jme3.renderer.Renderer;
-import com.jme3.renderer.lwjgl.LwjglGL1Renderer;
 import com.jme3.renderer.lwjgl.LwjglRenderer;
 import com.jme3.system.AppSettings;
 import com.jme3.system.SystemListener;
@@ -118,14 +117,10 @@ public abstract class LwjglContext implements JmeContext {
         if (settings.getRenderer().equals(AppSettings.LWJGL_OPENGL2)
          || settings.getRenderer().equals(AppSettings.LWJGL_OPENGL3)){
             renderer = new LwjglRenderer();
-        }else if (settings.getRenderer().equals(AppSettings.LWJGL_OPENGL1)){
-            renderer = new LwjglGL1Renderer();
         }else if (settings.getRenderer().equals(AppSettings.LWJGL_OPENGL_ANY)){
             // Choose an appropriate renderer based on capabilities
             if (GLContext.getCapabilities().OpenGL20){
                 renderer = new LwjglRenderer();
-            }else{
-                renderer = new LwjglGL1Renderer();
             }
         }else{
             throw new UnsupportedOperationException("Unsupported renderer: " + settings.getRenderer());
@@ -134,8 +129,6 @@ public abstract class LwjglContext implements JmeContext {
         // Init renderer
         if (renderer instanceof LwjglRenderer){
             ((LwjglRenderer)renderer).initialize();
-        }else if (renderer instanceof LwjglGL1Renderer){
-            ((LwjglGL1Renderer)renderer).initialize();
         }else{
             assert false;
         }