[committed] JOGL Updates

I've got a raft of fixes which I believe completes the JOGL implementation (at least the visual aspects).  With these changes, the more complicated Tests now work (i.e. TestProjectedWater and TestShadowPass).  The changes address the following issues:


  • Checks for Additional capabilities GL_ARB_depth_texture and GL_ARB_shadow, along with the handling in JOGLTextureState.

  • Polygon offset handling for LINE and POINT.

  • Sanity checking in updateTextureSubImage().

  • Fix the JOGStippleState which incorrectly referenced CullState internally.

  • MipMap handling in JOGLTextureState.

  • Corrected count parameter in JOGLShaderUtil methods.

  • Request capabilities when creating a window: alpha bits, depth bits, stencil bits, and number of samples.

  • Updated some of the logging and coding style to match the LWJGL equivalent.




### Eclipse Workspace Patch 1.0
#P jme
Index: src/com/jme/scene/state/jogl/records/TextureStateRecord.java
===================================================================
--- src/com/jme/scene/state/jogl/records/TextureStateRecord.java   (revision 4337)
+++ src/com/jme/scene/state/jogl/records/TextureStateRecord.java   (working copy)
@@ -45,6 +45,9 @@
 import com.jme.image.Texture.CombinerOperandAlpha;
 import com.jme.image.Texture.CombinerOperandRGB;
 import com.jme.image.Texture.CombinerSource;
+import com.jme.image.Texture.DepthTextureCompareFunc;
+import com.jme.image.Texture.DepthTextureCompareMode;
+import com.jme.image.Texture.DepthTextureMode;
 import com.jme.image.Texture.MagnificationFilter;
 import com.jme.image.Texture.MinificationFilter;
 import com.jme.image.Texture.WrapMode;
@@ -375,6 +378,38 @@
         throw new IllegalArgumentException("Incorrect format set: "+format);
     }
 
+    public static int getGLDepthTextureMode(DepthTextureMode mode) {
+        switch (mode) {
+        case Alpha:
+                return GL.GL_ALPHA;
+        case Luminance:
+                return GL.GL_LUMINANCE;
+        case Intensity:
+        default:
+                return GL.GL_INTENSITY;
+        }
+    }
+    
+    public static int getGLDepthTextureCompareMode(DepthTextureCompareMode mode) {
+        switch (mode) {
+        case RtoTexture:
+                return GL.GL_COMPARE_R_TO_TEXTURE_ARB;
+        case None:
+        default:
+                return GL.GL_NONE;
+        }
+    }
+    
+    public static int getGLDepthTextureCompareFunc(DepthTextureCompareFunc func) {
+        switch (func) {
+        case GreaterThanEqual:
+                return GL.GL_GEQUAL;
+        case LessThanEqual:
+        default:
+                return GL.GL_LEQUAL;
+        }
+    }
+
     public static int getGLMagFilter(MagnificationFilter magFilter) {
         switch (magFilter) {
             case Bilinear:
Index: src/com/jme/scene/state/jogl/shader/JOGLShaderUtil.java
===================================================================
--- src/com/jme/scene/state/jogl/shader/JOGLShaderUtil.java   (revision 4337)
+++ src/com/jme/scene/state/jogl/shader/JOGLShaderUtil.java   (working copy)
@@ -183,7 +183,7 @@
         final GL gl = GLU.getCurrentGL();
 
         shaderUniform.matrixBuffer.rewind();
-        gl.glUniformMatrix2fv(shaderUniform.variableID, shaderUniform.matrixBuffer.limit(),
+        gl.glUniformMatrix2fv(shaderUniform.variableID, 1,
                 shaderUniform.rowMajor, shaderUniform.matrixBuffer); // TODO Check <count>
     }
 
@@ -192,7 +192,7 @@
         final GL gl = GLU.getCurrentGL();
 
         shaderUniform.matrixBuffer.rewind();
-        gl.glUniformMatrix3fv(shaderUniform.variableID, shaderUniform.matrixBuffer.limit(),
+        gl.glUniformMatrix3fv(shaderUniform.variableID, 1,
                 shaderUniform.rowMajor, shaderUniform.matrixBuffer); // TODO Check <count>
     }
 
@@ -201,7 +201,7 @@
         final GL gl = GLU.getCurrentGL();
 
         shaderUniform.matrixBuffer.rewind();
-        gl.glUniformMatrix4fv(shaderUniform.variableID, shaderUniform.matrixBuffer.limit(),
+        gl.glUniformMatrix4fv(shaderUniform.variableID, 1,
                 shaderUniform.rowMajor, shaderUniform.matrixBuffer); // TODO Check <count>
     }
 
@@ -210,8 +210,8 @@
         final GL gl = GLU.getCurrentGL();
        
         shaderUniform.matrixBuffer.rewind();
-        gl.glUniformMatrix4fv(shaderUniform.variableID, shaderUniform.matrixBuffer.limit(),
-                shaderUniform.rowMajor, shaderUniform.matrixBuffer);
+        gl.glUniformMatrix4fv(shaderUniform.variableID, 1,
+                shaderUniform.rowMajor, shaderUniform.matrixBuffer); // TODO Check <count>
     }
 
     /**
Index: src/com/jme/renderer/jogl/JOGLTextureRenderer.java
===================================================================
--- src/com/jme/renderer/jogl/JOGLTextureRenderer.java   (revision 4337)
+++ src/com/jme/renderer/jogl/JOGLTextureRenderer.java   (working copy)
@@ -32,6 +32,8 @@
 
 package com.jme.renderer.jogl;
 
+import java.nio.ByteBuffer;
+import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 import java.util.ArrayList;
 import java.util.LinkedList;
@@ -145,14 +147,14 @@
             }
         }
 
-        logger.fine("Creating FBO sized: "+width+" x "+height);
+        logger.log(Level.FINE, "Creating FBO sized: {0} x {1}", new Integer[] {width, height});
 
         IntBuffer buffer = BufferUtils.createIntBuffer(1);
         gl.glGenFramebuffersEXT(buffer.limit(),buffer); // TODO Check <size> // generate id
         fboID = buffer.get(0);
 
         if (fboID <= 0) {
-            logger.severe("Invalid FBO id returned! " + fboID);
+            logger.log(Level.SEVERE, "Invalid FBO id returned! {0}", fboID);
             isSupported = false;
             return;
         }
@@ -249,6 +251,7 @@
 
         if (tex.getTextureId() != 0) {
             ibuf.put(tex.getTextureId());
+            ibuf.rewind();
             gl.glDeleteTextures(ibuf.limit(),ibuf); // TODO Check <size>
             ibuf.clear();
         }
@@ -259,10 +262,9 @@
         TextureManager.registerForCleanup(tex.getTextureKey(), tex
                 .getTextureId());
 
-        JOGLTextureState.doTextureBind(tex.getTextureId(), 0,
-      Texture.Type.TwoDimensional);
+        JOGLTextureState.doTextureBind(tex.getTextureId(), 0, Texture.Type.TwoDimensional);
+        int format = GL.GL_RGBA;
    int components = GL.GL_RGBA8;
-   int format = GL.GL_RGBA;
    int dataType = GL.GL_UNSIGNED_BYTE;
    switch (tex.getRTTSource()) {
    case RGBA:
@@ -464,8 +466,15 @@
    }
 
         // Initialize our texture with some default data.
-       gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, components, width, height, 0,
-          format, dataType, null);
+   // NOTE: JOGL doesn't differentiate between the two buffer calls, but
+   //       the code format is maintained to ease migration.
+        if (dataType == GL.GL_UNSIGNED_BYTE) {
+            gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, components, width, height,
+                    0, format, dataType, (ByteBuffer) null);
+        } else {
+            gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, components, width, height,
+                    0, format, dataType, (FloatBuffer) null);
+        }
 
         // Initialize mipmapping for this texture, if requested
         if (tex.getMinificationFilter().usesMipMapLevels()) {
@@ -783,8 +792,7 @@
     public void copyToTexture(Texture tex, int width, int height) {
         final GL gl = GLU.getCurrentGL();
 
-        JOGLTextureState.doTextureBind(tex.getTextureId(), 0,
-      Texture.Type.TwoDimensional);
+        JOGLTextureState.doTextureBind(tex.getTextureId(), 0, Texture.Type.TwoDimensional);
 
    int source = GL.GL_RGBA;
    switch (tex.getRTTSource()) {
Index: src/com/jme/system/jogl/JOGLDisplaySystem.java
===================================================================
--- src/com/jme/system/jogl/JOGLDisplaySystem.java   (revision 4337)
+++ src/com/jme/system/jogl/JOGLDisplaySystem.java   (working copy)
@@ -282,6 +282,7 @@
                 logger.warning("Interruped while waiting for makeCurrent()");
             }
         }
+
         // Now it is time to request the focus because the canvas
         // is displayable, focusable, visible and its ancestor is
         // visible too
@@ -359,6 +364,11 @@
         final GLCapabilities caps = new GLCapabilities();
         caps.setHardwareAccelerated(true);
         caps.setDoubleBuffered(true);
+        DisplaySystem ds = DisplaySystem.getDisplaySystem();
+        caps.setAlphaBits(ds.getMinAlphaBits());
+        caps.setDepthBits(ds.getMinDepthBits());
+        caps.setStencilBits(ds.getMinStencilBits());
+        caps.setNumSamples(ds.getMinSamples());
 
         // Create the OpenGL canvas,
         final JOGLAWTCanvas glCanvas = new JOGLAWTCanvas(caps);
@@ -656,6 +722,9 @@
                 logger.log(Level.WARNING, "Failed to release OpenGL Context"
                         + autoDrawable, releaseFailure);
             }
+            finally {
+                autoDrawable = null;
+            }
         }
 
         // Dispose of any window resources.
Index: src/com/jme/scene/state/jogl/JOGLStippleState.java
===================================================================
--- src/com/jme/scene/state/jogl/JOGLStippleState.java   (revision 4337)
+++ src/com/jme/scene/state/jogl/JOGLStippleState.java   (working copy)
@@ -56,8 +56,8 @@
     public void apply() {
         // ask for the current state record
         RenderContext<?> context = DisplaySystem.getDisplaySystem().getCurrentContext();
-        CullStateRecord record = (CullStateRecord) context.getStateRecord(StateType.Cull);
-        context.currentStates[StateType.Cull.ordinal()] = this;
+        StippleStateRecord record = (StippleStateRecord) context.getStateRecord(StateType.Stipple);
+        context.currentStates[StateType.Stipple.ordinal()] = this;
         final GL gl = GLU.getCurrentGL();
 
         if (isEnabled()) {
Index: src/com/jme/renderer/jogl/JOGLRenderer.java
===================================================================
--- src/com/jme/renderer/jogl/JOGLRenderer.java   (revision 4337)
+++ src/com/jme/renderer/jogl/JOGLRenderer.java   (working copy)
@@ -538,7 +538,8 @@
             if (Debug.stats) {
                 StatCollector.startStat(StatType.STAT_DISPLAYSWAP_TIMER);
             }
-            // TODO Check replacement for LWJGL Display.update()
+            // LWJGL Display.update() checks for errors and swaps the buffer.
+            checkCardError();
             GLContext.getCurrent().getGLDrawable().swapBuffers();
             if (Debug.stats) {
                 StatCollector.endStat(StatType.STAT_DISPLAYSWAP_TIMER);
@@ -1714,6 +1715,8 @@
         final GL gl = GLU.getCurrentGL();
 
         gl.glEnable(GL.GL_POLYGON_OFFSET_FILL);
+        gl.glEnable(GL.GL_POLYGON_OFFSET_LINE);
+        gl.glEnable(GL.GL_POLYGON_OFFSET_POINT);
         gl.glPolygonOffset(factor, offset);
     }
 
@@ -1722,6 +1725,8 @@
         final GL gl = GLU.getCurrentGL();
 
         gl.glDisable(GL.GL_POLYGON_OFFSET_FILL);
+        gl.glDisable(GL.GL_POLYGON_OFFSET_LINE);
+        gl.glDisable(GL.GL_POLYGON_OFFSET_POINT);
     }
 
     /**
@@ -1816,6 +1821,12 @@
             throws JmeException {
         GL gl = GLU.getCurrentGL();
 
+        // We can't update a non-existent texture.
+        if (dstTexture.getTextureId() <= 0) {
+            logger.warning("Attempting to update a non-existent texture");
+            return;
+        }
+
         // Check that the texture type is supported.
         if (dstTexture.getType() != Texture.Type.TwoDimensional)
             throw new UnsupportedOperationException(
@@ -1862,25 +1873,58 @@
             gl.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, srcY);
 
         // Upload the image region into the texture.
-        gl.glTexSubImage2D(GL.GL_TEXTURE_2D, 0, dstX, dstY, width, height,
-                pixelFormat, GL.GL_UNSIGNED_BYTE, data);
+        try {
+            gl.glTexSubImage2D(GL.GL_TEXTURE_2D, 0, dstX, dstY, width, height,
+                    pixelFormat, GL.GL_UNSIGNED_BYTE, data);
+        } catch (GLException updateFailure) {
+            // Attempt to determine the root cause of the problem.
+            final Image dstImage = dstTexture.getImage();
+            final int b = (dstTexture.hasBorder()) ? 1 : 0;
+            if (srcX < -b || (srcX + width) > (dstImage.getWidth() - b)) {
+                throw new JmeException("Invalid Parameters: Source X=" + srcX
+                        + " and width=" + width + ": Texture width="
+                        + dstImage.getWidth());
+            }
+            if (srcY < -b || (srcY + height) > (dstImage.getHeight() - b)) {
+                throw new JmeException("Invalid Parameters: Source Y=" + srcY
+                        + " and height=" + height + ": Texture height="
+                        + dstImage.getHeight());
+            }
+            if (dstX < -b || (dstX + width) > (dstImage.getWidth() - b)) {
+                throw new JmeException("Invalid Parameters: Source X=" + dstX
+                        + " and width=" + width + ": Texture width="
+                        + dstImage.getWidth());
+            }
+            if (dstY < -b || (dstY + height) > (dstImage.getHeight() - b)) {
+                throw new JmeException("Invalid Parameters: Source Y=" + dstY
+                        + " and height=" + height + ": Texture height="
+                        + dstImage.getHeight());
+            }
 
-        // Restore the texture configuration (when necessary).
-        // Restore the texture binding.
-        if (origTexBinding[0] != dstTexture.getTextureId())
-            gl.glBindTexture(GL.GL_TEXTURE_2D, origTexBinding[0]);
-        // Restore alignment.
-        if (origAlignment[0] != alignment)
-            gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, origAlignment[0]);
-        // Restore row length.
-        if (origRowLength != rowLength)
-            gl.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, origRowLength);
-        // Restore skip pixels.
-        if (origSkipPixels != srcX)
-            gl.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, origSkipPixels);
-        // Restore skip rows.
-        if (origSkipRows != srcY)
-            gl.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, origSkipRows);
+            // As a default case, simply throw a generic exception.
+            throw new JmeException("Unable to update the texture",
+                    updateFailure);
+        }
+        // Try to clean up any changes in a safe way so that the caller can
+        // recover gracefully.
+        finally {
+            // Restore the texture configuration (when necessary).
+            // Restore the texture binding.
+            if (origTexBinding[0] != dstTexture.getTextureId())
+                gl.glBindTexture(GL.GL_TEXTURE_2D, origTexBinding[0]);
+            // Restore alignment.
+            if (origAlignment[0] != alignment)
+                gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, origAlignment[0]);
+            // Restore row length.
+            if (origRowLength != rowLength)
+                gl.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, origRowLength);
+            // Restore skip pixels.
+            if (origSkipPixels != srcX)
+                gl.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, origSkipPixels);
+            // Restore skip rows.
+            if (origSkipRows != srcY)
+                gl.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, origSkipRows);
+        }
     }
 
     @Override
Index: src/com/jme/renderer/jogl/JOGLFont.java
===================================================================
--- src/com/jme/renderer/jogl/JOGLFont.java   (revision 4337)
+++ src/com/jme/renderer/jogl/JOGLFont.java   (working copy)
@@ -171,7 +171,7 @@
         scratch.flip();
         matRecord.setCurrentColor(fontColor);
         //call the list for each letter in the string.
-        gl.glCallLists(scratch.limit(), GL.GL_BYTE,scratch); // TODO Check <count> and assumed <type> GL_BYTE
+        gl.glCallLists(scratch.limit(), GL.GL_UNSIGNED_BYTE, scratch);
         //set color back to white
         matRecord.setCurrentColor(1,1,1,1);
 
Index: src/com/jme/scene/state/jogl/records/TextureRecord.java
===================================================================
--- src/com/jme/scene/state/jogl/records/TextureRecord.java   (revision 4337)
+++ src/com/jme/scene/state/jogl/records/TextureRecord.java   (working copy)
@@ -41,6 +41,7 @@
 
     public int wrapS, wrapT, wrapR;
     public int magFilter, minFilter;
+    public int depthTextureMode, depthTextureFunc, depthTextureCompareMode;
     public float anisoLevel = -1;
     public static FloatBuffer colorBuffer = BufferUtils.createColorBuffer(1);
     public ColorRGBA borderColor = new ColorRGBA(-1,-1,-1,-1);
@@ -55,6 +56,7 @@
         super.invalidate();
         wrapS = wrapT = wrapR = 0;
         magFilter = minFilter = 0;
+        depthTextureMode = depthTextureFunc = depthTextureCompareMode = 0;
         anisoLevel = -1;
         borderColor.set(-1,-1,-1,-1);
     }
Index: src/com/jme/renderer/jogl/JOGLContextCapabilities.java
===================================================================
--- src/com/jme/renderer/jogl/JOGLContextCapabilities.java   (revision 4337)
+++ src/com/jme/renderer/jogl/JOGLContextCapabilities.java   (working copy)
@@ -74,6 +74,8 @@
 
     public boolean GL_EXT_blend_subtract;
 
+    public boolean GL_ARB_depth_texture;
+
     public boolean GL_EXT_fog_coord;
    
     public boolean GL_EXT_compiled_vertex_array;
@@ -144,6 +146,8 @@
 
     public boolean GL_ARB_vertex_buffer_object;
 
+    public boolean GL_ARB_shadow;
+
     public JOGLContextCapabilities(GLAutoDrawable autodrawable) {
         init(autodrawable.getGL());
     }
@@ -153,7 +157,6 @@
     }
 
     public void init(final GL gl) {
-
         // See Renderer
         GL_ARB_vertex_buffer_object = gl
                 .isExtensionAvailable("GL_ARB_vertex_buffer_object");
@@ -185,6 +188,10 @@
         GL_ARB_shading_language_100 = gl
                 .isExtensionAvailable("GL_ARB_shading_language_100");
 
+        // See TextureState
+        GL_ARB_depth_texture = gl.isExtensionAvailable("GL_ARB_depth_texture");
+        GL_ARB_shadow = gl.isExtensionAvailable("GL_ARB_shadow");
+
         try {
             gl.glGetIntegerv(GL.GL_MAX_VERTEX_ATTRIBS_ARB, intBuf);
             GL_MAX_VERTEX_ATTRIBS_ARB = intBuf.get(0);

This is the remaining code updates (1st post exceeded 20000 character limit).



Index: src/com/jme/scene/state/jogl/JOGLTextureState.java
===================================================================
--- src/com/jme/scene/state/jogl/JOGLTextureState.java   (revision 4337)
+++ src/com/jme/scene/state/jogl/JOGLTextureState.java   (working copy)
@@ -36,6 +36,7 @@
 import java.nio.IntBuffer;
 import java.util.ArrayList;
 import java.util.Stack;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import javax.media.opengl.GL;
@@ -122,6 +123,9 @@
             // Check for support of automatic mipmap generation
             automaticMipMaps = automaticMipMapsDetected = caps.GL_SGIS_generate_mipmap;
 
+            supportsDepthTexture = caps.GL_ARB_depth_texture;
+            supportsShadow = caps.GL_ARB_shadow;
+
             // If we do support multitexturing, find out how many textures we
             // can handle.
             if (supportsMultiTexture) {
@@ -190,7 +194,32 @@
         }
     }
 
-    // TODO Dropped utility class LWJGLMipMap
+    /**
+     * Helper methods
+     */
+    protected static class JOGLMipMap {
+        /**
+         * @see org.lwjgl.util.glu.MipMap#glGetIntegerv(int)
+         */
+        protected static int glGetIntegerv(int what) {
+            return com.jme.util.jogl.JOGLUtil.glGetIntegerv(what);
+        }
+
+        /**
+         * @see org.lwjgl.util.glu.MipMap#nearestPower(int)
+         */
+        protected static int nearestPower(int value) {
+            return com.jme.util.jogl.JOGLUtil.nearestPower(value);
+        }
+
+        /**
+         * @see org.lwjgl.util.glu.MipMap#bytesPerPixel(int, int)
+         */
+        protected static int bytesPerPixel(int format, int type) {
+            return com.jme.util.jogl.JOGLUtil.bytesPerPixel(format, type);
+        }
+    }
+
 
     @Override
     public final void load(int unit) {
@@ -232,6 +261,11 @@
             }
         }
 
+        // FIXME Remove the need for this hack.
+        int tmpErrorCode = gl.glGetError();
+        if (tmpErrorCode != 0)
+            logger.warning ("Unexpected Error Code = " + tmpErrorCode);
+       
         IntBuffer id = BufferUtils.createIntBuffer(1);
         id.clear();
         gl.glGenTextures(id.limit(),id); // TODO Check <size>
@@ -266,30 +300,30 @@
             if (!supportsNonPowerTwo
                     && (!FastMath.isPowerOfTwo(image.getWidth()) || !FastMath
                             .isPowerOfTwo(image.getHeight()))) {
-                logger
-                        .warning("(card unsupported) Attempted to apply texture with size that is not power of 2: "
-                                + image.getWidth() + " x " + image.getHeight());
+                logger.log(Level.WARNING, "(card unsupported) Attempted to apply texture with size that is not power of 2: "
+                        + "{0}x{1}", new Integer[] {image.getWidth(), image.getHeight()});
 
-                final int maxSize = com.jme.util.jogl.JOGLUtil.glGetIntegerv(GL.GL_MAX_TEXTURE_SIZE);
+                final int maxSize = JOGLMipMap
+                        .glGetIntegerv(GL.GL_MAX_TEXTURE_SIZE);
 
                 int actualWidth = image.getWidth();
-                int w = com.jme.util.jogl.JOGLUtil.nearestPower(actualWidth);
+                int w = JOGLMipMap.nearestPower(actualWidth);
                 if (w > maxSize) {
                     w = maxSize;
                 }
 
                 int actualHeight = image.getHeight();
-                int h = com.jme.util.jogl.JOGLUtil.nearestPower(actualHeight);
+                int h = JOGLMipMap.nearestPower(actualHeight);
                 if (h > maxSize) {
                     h = maxSize;
                 }
-                logger.warning("Rescaling image to " + w + " x " + h + " !!!");
+                logger.log(Level.WARNING, "Rescaling image to {0} x {1} !!!", new Integer[]{w, h});
 
                 // must rescale image to get "top" mipmap texture image
                 int format = TextureStateRecord.getGLPixelFormat(image
                         .getFormat());
                 int dType = GL.GL_UNSIGNED_BYTE;
-                int bpp = com.jme.util.jogl.JOGLUtil.bytesPerPixel(format, dType);
+                int bpp = JOGLMipMap.bytesPerPixel(format, dType);
                 ByteBuffer scaledImage = BufferUtils.createByteBuffer((w + 4)
                         * h * bpp);
                 int error = glu.gluScaleImage(format, actualWidth,
@@ -397,7 +431,7 @@
                             }
                         } else {
                             logger
-                                    .warning("This card does not support Cubemaps.");
+                                     .warning("This card does not support Cubemaps.");
                         }
                         break;
                 }
@@ -552,8 +586,7 @@
                                 }
                             }
                         } else {
-                            logger
-                                    .warning("This card does not support Cubemaps.");
+                            logger.warning("This card does not support Cubemaps.");
                             return;
                         }
                         break;
@@ -565,7 +598,65 @@
                 // Get mipmap data sizes and amount of mipmaps to send to
                 // opengl. Then loop through all mipmaps and send them.
                 int[] mipSizes = image.getMipMapSizes();
-                ByteBuffer data = image.getData(0);
+                ByteBuffer data = null;
+                if (type == Type.CubeMap) {
+                    if (supportsTextureCubeMap) {
+                            for (TextureCubeMap.Face face : TextureCubeMap.Face.values()) {
+                                    data = image.getData(face.ordinal());
+                                    int pos = 0;
+                                    int max = 1;
+
+                                    if (mipSizes == null) {
+                                            mipSizes = new int[] { data.capacity() };
+                                    } else if (texture.getMinificationFilter().usesMipMapLevels()) {
+                                            max = mipSizes.length;
+                                    }
+
+                                    for (int m = 0; m < max; m++) {
+                                            int width = Math.max(1, image.getWidth() >> m);
+                                            int height = type != Type.OneDimensional ? Math.max(1, image.getHeight() >> m) : 0;
+
+                                data.position(pos);
+                                data.limit(pos + mipSizes[m]);
+
+                                if (TextureStateRecord.isCompressedType(image.getFormat())) {
+                                    gl.glCompressedTexImage2D(
+                                                    getGLCubeMapFace(face),
+                                                    m,
+                                                    TextureStateRecord
+                                                    .getGLDataFormat(image
+                                                                    .getFormat()),
+                                                                    width, height,
+                                                                    hasBorder ? 1 : 0, GL.GL_UNSIGNED_BYTE, data);
+                                } else {
+                                    gl.glTexImage2D(
+                                                    getGLCubeMapFace(face),
+                                                    m,
+                                                    TextureStateRecord
+                                                    .getGLDataFormat(image
+                                                                    .getFormat()),
+                                                                    width, height,
+                                                                    hasBorder ? 1 : 0,
+                                                                    TextureStateRecord.getGLPixelFormat(image.getFormat()),
+                                                                                    GL.GL_UNSIGNED_BYTE, data);
+                                }
+                                pos += mipSizes[m];
+                                    }
+                            }
+                    } else {
+                            logger.warning("This card does not support CubeMaps.");
+                            return;
+                    }
+            } else {
+                data = image.getData(0);
+                int pos = 0;
+                int max = 1;
+               
+                if (mipSizes == null) {
+                    mipSizes = new int[] { data.capacity() };
+                } else if (texture.getMinificationFilter().usesMipMapLevels()) {
+                    max = mipSizes.length;
+                }
                 if (type == Type.ThreeDimensional) {
                     if (supportsTexture3D) {
                         // concat data into single buffer:
@@ -594,13 +685,6 @@
                         return;
                     }
                 }
-                int max = 1;
-                int pos = 0;
-                if (mipSizes == null) {
-                    mipSizes = new int[] { data.capacity() };
-                } else if (texture.getMinificationFilter().usesMipMapLevels()) {
-                    max = mipSizes.length;
-                }
 
                 for (int m = 0; m < max; m++) {
                     int width = Math.max(1, image.getWidth() >> m);
@@ -623,7 +707,7 @@
                                                         .getGLDataFormat(image
                                                                 .getFormat()),
                                                 width, height, hasBorder ? 1
-                                                        : 0, data.limit(), data); // TODO Check <size>
+                                                        : 0, mipSizes[m], data); // TODO Check <size>
                             } else {
                                 gl.glTexImage2D(GL.GL_TEXTURE_2D, m,
                                         TextureStateRecord
@@ -645,7 +729,7 @@
                                                 TextureStateRecord
                                                         .getGLDataFormat(image
                                                                 .getFormat()),
-                                                width, hasBorder ? 1 : 0, data.limit(), data); // TODO Check <size>
+                                                width, hasBorder ? 1 : 0, mipSizes[m], data); // TODO Check <size>
                             } else {
                                 gl.glTexImage1D(GL.GL_TEXTURE_1D, m,
                                         TextureStateRecord
@@ -668,7 +752,7 @@
                                                         .getGLDataFormat(image
                                                                 .getFormat()),
                                                 width, height, depth,
-                                                hasBorder ? 1 : 0, data.limit(), data); // TODO Check <size>
+                                                hasBorder ? 1 : 0, mipSizes[m], data); // TODO Check <size>
                             } else {
                                 gl.glTexImage3D(GL.GL_TEXTURE_3D, m,
                                         TextureStateRecord
@@ -681,44 +765,17 @@
                                         GL.GL_UNSIGNED_BYTE, data);
                             }
                             break;
-                        case CubeMap:
-                            if (supportsTextureCubeMap) {
-                                for (TextureCubeMap.Face face : TextureCubeMap.Face
-                                        .values()) {
-                                    if (TextureStateRecord
-                                            .isCompressedType(image.getFormat())) {
-                                        gl
-                                                .glCompressedTexImage2D(
-                                                        getGLCubeMapFace(face),
-                                                        m,
-                                                        TextureStateRecord
-                                                                .getGLDataFormat(image
-                                                                        .getFormat()),
-                                                        width, height,
-                                                        hasBorder ? 1 : 0, data.limit(), data); // TODO Check <size>
-                                    } else {
-                                        gl.glTexImage2D(
-                                                getGLCubeMapFace(face), m,
-                                                TextureStateRecord
-                                                        .getGLDataFormat(image
-                                                                .getFormat()),
-                                                width, height, hasBorder ? 1
-                                                        : 0, TextureStateRecord
-                                                        .getGLPixelFormat(image
-                                                                .getFormat()),
-                                                GL.GL_UNSIGNED_BYTE, data);
-                                    }
-                                }
-                            }
-                            break;
                     }
 
                     pos += mipSizes[m];
                 }
+            }
+            if (data != null) {
                 data.clear();
             }
         }
     }
+    }
 
     /**
      * <code>apply</code> manages the textures being described by the state.
@@ -853,6 +910,7 @@
                     // texture specific params
                     applyFilter(texture, texRecord, i, record);
                     applyWrap(texture, texRecord, i, record);
+                    applyShadow(texture, texRecord, i, record);
 
                     // Set our border color, if needed.
                     applyBorderColor(texture, texRecord, i, record);
@@ -1658,6 +1716,54 @@
     /**
      * Check if the filter settings of this particular texture have been changed
      * and apply as needed.
+     *
+     * @param texture
+     *            our texture object
+     * @param texRecord
+     *            our record of the last state of the texture in gl
+     * @param record
+     */
+    public static void applyShadow(Texture texture, TextureRecord texRecord,
+            int unit, TextureStateRecord record) {
+        final GL gl = GLU.getCurrentGL();
+
+        Type type = texture.getType();
+
+        if (supportsDepthTexture) {
+                int depthMode = TextureStateRecord.getGLDepthTextureMode(texture.getDepthMode());
+                // set up magnification filter
+                if (!texRecord.isValid() || texRecord.depthTextureMode != depthMode) {
+                    checkAndSetUnit(unit, record);
+                    gl.glTexParameteri(getGLType(type), GL.GL_DEPTH_TEXTURE_MODE_ARB,
+                                depthMode);
+                    texRecord.depthTextureMode = depthMode;
+                }
+        }
+       
+        if (supportsShadow) {
+                int depthCompareMode = TextureStateRecord.getGLDepthTextureCompareMode(texture.getDepthCompareMode());
+                // set up magnification filter
+                if (!texRecord.isValid() || texRecord.depthTextureFunc != depthCompareMode) {
+                    checkAndSetUnit(unit, record);
+                    gl.glTexParameteri(getGLType(type), GL.GL_TEXTURE_COMPARE_MODE_ARB,
+                                depthCompareMode);
+                    texRecord.depthTextureFunc = depthCompareMode;
+                }
+               
+                int depthCompareFunc = TextureStateRecord.getGLDepthTextureCompareFunc(texture.getDepthCompareFunc());
+                // set up magnification filter
+                if (!texRecord.isValid() || texRecord.depthTextureFunc != depthCompareFunc) {
+                    checkAndSetUnit(unit, record);
+                    gl.glTexParameteri(getGLType(type), GL.GL_TEXTURE_COMPARE_FUNC_ARB,
+                                depthCompareFunc);
+                    texRecord.depthTextureFunc = depthCompareFunc;
+                }
+        }
+    }
+
+    /**
+     * Check if the filter settings of this particular texture have been changed
+     * and apply as needed.
      *
      * @param texture
      *            our texture object

Hi!



Do you have the right to commit it? It is very interesting, I thank you a lot, it is an excellent piece of news for all JME/JOGL users  :smiley: Day by day, the JOGL renderer becomes more reliable.

nice work

are you registered as contributor woody or do you want someone else to commit it ?

Core-Dump said:

are you registered as contributor woody or do you want someone else to commit it ?

If you want, I can test it and commit it. What do you suggest?

sure

Ok I will do it when I'm less tired, I want to have all my available neurons :slight_smile:

I cannot use my usual account on google code. Can you add my gmail account to allow me to submit these changes?

Sorry for the long delay, but the changes have now been committed.

Ok it is perfect. However, you wrote "1" instead of buffer.limit(), are you sure it is the best solution?

I assume you are referring to the changes in JOGLShaderUtil.  The following three methods all call OpenGL glUniformMatrix, passing a single matrix along with an array of values:


  • updateShaderUniform(ShaderVariableMatrix2) - a single 2x2 matrix (buffer.limit() = 4)

  • updateShaderUniform(ShaderVariableMatrix3) - a single 3x3 matrix (buffer.limit() = 9)

  • updateShaderUniform(ShaderVariableMatrix4) - a single 4x4 matrix (buffer.limit() = 16)


The constant tells OpenGL that the values represent a single matrix.

The other method in that class which I updated passed an array of matrices, and had to calculate the number of matrices:

  • updateShaderUniform(ShaderVariableMatrix4Array) - multiple 4x4 matrices (buffer.limit() = 16 * matrixNumber)



With these changes, many of the tests now function using JOGL.