605 2012-07-11 12:47:27 +0200 Use of accumulation buffer flips image 2012-10-06 05:00:06 +0200 1 1 3 JogAmp Jogl macosx 2 All macosx RESOLVED INVALID --- major --- 0 karelknoest sgothel --- jogl d3033e42faa909f6c1055f5ba3c7925766a3e583 --- oldest_to_newest 1704 0 362 karelknoest 2012-07-11 12:47:27 +0200 Created attachment 362 Test code Overview: On Mac OS X, the use of the accumulation buffer flips the resulting image vertically. This behavior happens both for pBuffer and GLCanvas. Steps to Reproduce: See bottom of post and attached file. Build Date & Platform: JOGL v2.0-RC9, MacBook Pro 6.1, GeForce GT 300M, Mac OS X 10.6.8, Java 6u33 Additional Builds and Platforms: The vertical flip does not occur on any Windows machine so far. Also, another Mac (Mac OS X 10.7, Oracle Java 7u5) doesn't have the problem. ------------------- /** * Copyright 2011 JogAmp Community. All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are * permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this list of * conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright notice, this list * of conditions and the following disclaimer in the documentation and/or other materials * provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * The views and conclusions contained in the software and documentation are those of the * authors and should not be interpreted as representing official policies, either expressed * or implied, of JogAmp Community. */ import java.awt.image.BufferedImage; import javax.media.opengl.GL2; import javax.media.opengl.GLAutoDrawable; import javax.media.opengl.GLCapabilities; import javax.media.opengl.GLDrawableFactory; import javax.media.opengl.GLEventListener; import javax.media.opengl.GLException; import javax.media.opengl.GLPbuffer; import javax.media.opengl.GLProfile; import com.jogamp.opengl.util.awt.Screenshot; public class FlippedImageTest implements GLEventListener { GLPbuffer glPBuffer = null; public FlippedImageTest() { GLProfile glp = GLProfile.get(GLProfile.GL2); GLCapabilities caps = new GLCapabilities(glp); GLDrawableFactory glFactory = GLDrawableFactory.getFactory(glp); caps.setAccumRedBits(16); caps.setAccumGreenBits(16); caps.setAccumBlueBits(16); caps.setStencilBits(8); caps.setDoubleBuffered(true); caps.setHardwareAccelerated(true); try { glPBuffer = glFactory.createGLPbuffer(null, caps, null, 4, 4, null); } catch (GLException exc) { } glPBuffer.addGLEventListener(this); } /** * @param args */ public static void main(String[] args) { FlippedImageTest demo = new FlippedImageTest(); demo.glPBuffer.display(); demo.glPBuffer.createContext(null).makeCurrent(); BufferedImage image = Screenshot.readToBufferedImage(4, 4); int above = image.getRGB(0, 0); int below = image.getRGB(0, 3); if (above == 0xff00ff00 && below == 0xffff0000) { System.out.println("image right side up"); } else if (above == 0xffff0000 && below == 0xff00ff00) { System.out.println("image is flipped"); } else { System.out.println("error in test"); } } public void display(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); gl.glMatrixMode(GL2.GL_PROJECTION); gl.glLoadIdentity(); gl.glMatrixMode(GL2.GL_MODELVIEW); gl.glLoadIdentity(); // red below gl.glColor3f(1, 0, 0); gl.glRectf(-1, -1, 1, 0); // green above gl.glColor3f(0, 1, 0); gl.glRectf(-1, 0, 1, 1); gl.glFinish(); gl.glAccum(GL2.GL_ACCUM, 1.0f); gl.glAccum(GL2.GL_RETURN, 1.0f); gl.glEnd(); gl.glFlush(); } public void init(GLAutoDrawable drawable) { } public void reshape(GLAutoDrawable glDrawable, int x, int y, int w, int h) { } public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) { } public void dispose(GLAutoDrawable drawable) { } } 1747 1 karelknoest 2012-08-10 10:25:40 +0200 Going from JOGL RC9 to RC10, the problem seems to be fixed on the machine that previously displayed the flipped result. 1748 2 sgothel 2012-08-14 04:08:56 +0200 See Comment 1 .. reporter validated the erroneous behavior is gone in RC10. Even though the root cause is unknown, we close this one. Maybe it's regarding the fixed GLCaps & alpha: <http://jogamp.org/git/?p=jogl.git;a=commit;h=4a08de4511a627c3d87d6a33debbd561962c0312> 1750 3 karelknoest 2012-08-20 16:17:50 +0200 Upon further inspection, I just discovered that this bug still is valid. The faulty worksforme came from another improvement to our product prevented this bug from being triggered. 1807 4 sgothel 2012-09-17 07:56:00 +0200 probably a selected software renderer ? same happens on windows w/ offscreen - bitmap. not really a bug .. if so. 1808 5 karelknoest 2012-09-17 12:09:00 +0200 Hi Sven, Thanks for the feedback. We're currently not choosing between software and hardware anti-aliasing explicitly, so that could be the case. One thing I do wonder is whether the result should be correctly oriented, independent of the selected renderer? 1888 6 sgothel 2012-10-06 05:00:06 +0200 See: <http://jogamp.org/git/?p=jogl.git;a=commit;h=d3033e42faa909f6c1055f5ba3c7925766a3e583> Added 2 unit tests, mostly your code (NEWT / AWT), works - closed. Note-1: Unit tests use the new API for generating offscreen-auto-drawable. Note-2: On my machine all hw renderer were picked. So if you see y-flipped results, it might be the sw renderer .. and it's not us who causes the bug. +++ OSX 10.7.5, Java6 (latest) .++++ UITestCase.setUp: com.jogamp.opengl.test.junit.jogl.caps.TestBug605FlippedImageAWT - test01AccumStencilPBuffer GL_RENDERER: NVIDIA GeForce 320M OpenGL Engine GL_VERSION: 2.1 NVIDIA-7.32.12 below: 0xff0000 above: 0xff00 Image right side up XXX GLCaps[rgba 0x8/8/8/8, opaque, accum-rgba 32/32/32/32, dp/st/ms: 24/8/0, dbl, mono , hw, GLProfile[GL2/GL2.hw], offscr[pbuffer [r2t 0, r2tr 0, float 0]]] XXX 2.1 (Compatibility profile, arb, FBO, hardware) - 2.1 NVIDIA-7.32.12 ++++ UITestCase.tearDown: com.jogamp.opengl.test.junit.jogl.caps.TestBug605FlippedImageAWT - test01AccumStencilPBuffer SLOCK [T Thread-4-UserApp-TestBug605FlippedImageAWT @ 1349491975782 ms --- localhost/127.0.0.1:59999 - Unlock ok 362 2012-07-11 12:47:27 +0200 2012-07-11 12:47:27 +0200 Test code test_vertical_flip.txt text/plain 4322 karelknoest LyoqDQogKiBDb3B5cmlnaHQgMjAxMSBKb2dBbXAgQ29tbXVuaXR5LiBBbGwgcmlnaHRzIHJlc2Vy dmVkLg0KICoNCiAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkg Zm9ybXMsIHdpdGggb3Igd2l0aG91dCBtb2RpZmljYXRpb24sIGFyZQ0KICogcGVybWl0dGVkIHBy b3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZSBtZXQ6DQogKg0KICogICAg MS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBj b3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YNCiAqICAgICAgIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4NCiAqDQogKiAgICAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UsIHRo aXMgbGlzdA0KICogICAgICAgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMNCiAqICAgICAg IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4NCiAqDQogKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEpvZ0FtcCBDb21tdW5pdHkgYGBBUyBJUycnIEFORCBBTlkgRVhQUkVTUyBP UiBJTVBMSUVEDQogKiBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywg VEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EDQogKiBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hB TEwgSm9nQW1wIENvbW11bml0eSBPUg0KICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1INCiAq IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBS T0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1INCiAqIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENB VVNFRCBBTkQgT04NCiAqIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcNCiAqIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBT T0ZUV0FSRSwgRVZFTiBJRg0KICogQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuDQogKg0KICogVGhlIHZpZXdzIGFuZCBjb25jbHVzaW9ucyBjb250YWluZWQgaW4gdGhl IHNvZnR3YXJlIGFuZCBkb2N1bWVudGF0aW9uIGFyZSB0aG9zZSBvZiB0aGUNCiAqIGF1dGhvcnMg YW5kIHNob3VsZCBub3QgYmUgaW50ZXJwcmV0ZWQgYXMgcmVwcmVzZW50aW5nIG9mZmljaWFsIHBv bGljaWVzLCBlaXRoZXIgZXhwcmVzc2VkDQogKiBvciBpbXBsaWVkLCBvZiBKb2dBbXAgQ29tbXVu aXR5Lg0KICovDQoNCmltcG9ydCBqYXZhLmF3dC5pbWFnZS5CdWZmZXJlZEltYWdlOw0KDQppbXBv cnQgamF2YXgubWVkaWEub3BlbmdsLkdMMjsNCmltcG9ydCBqYXZheC5tZWRpYS5vcGVuZ2wuR0xB dXRvRHJhd2FibGU7DQppbXBvcnQgamF2YXgubWVkaWEub3BlbmdsLkdMQ2FwYWJpbGl0aWVzOw0K aW1wb3J0IGphdmF4Lm1lZGlhLm9wZW5nbC5HTERyYXdhYmxlRmFjdG9yeTsNCmltcG9ydCBqYXZh eC5tZWRpYS5vcGVuZ2wuR0xFdmVudExpc3RlbmVyOw0KaW1wb3J0IGphdmF4Lm1lZGlhLm9wZW5n bC5HTEV4Y2VwdGlvbjsNCmltcG9ydCBqYXZheC5tZWRpYS5vcGVuZ2wuR0xQYnVmZmVyOw0KaW1w b3J0IGphdmF4Lm1lZGlhLm9wZW5nbC5HTFByb2ZpbGU7DQoNCmltcG9ydCBjb20uam9nYW1wLm9w ZW5nbC51dGlsLmF3dC5TY3JlZW5zaG90Ow0KDQoNCnB1YmxpYyBjbGFzcyBGbGlwcGVkSW1hZ2VU ZXN0IGltcGxlbWVudHMgR0xFdmVudExpc3RlbmVyIHsNCg0KICAgIEdMUGJ1ZmZlciBnbFBCdWZm ZXIgPSBudWxsOw0KDQoJcHVibGljIEZsaXBwZWRJbWFnZVRlc3QoKSB7DQoJICAgICAgICANCgkJ R0xQcm9maWxlIGdscCA9IEdMUHJvZmlsZS5nZXQoR0xQcm9maWxlLkdMMik7DQoJCUdMQ2FwYWJp bGl0aWVzIGNhcHMgPSBuZXcgR0xDYXBhYmlsaXRpZXMoZ2xwKTsNCgkJR0xEcmF3YWJsZUZhY3Rv cnkgZ2xGYWN0b3J5ID0gR0xEcmF3YWJsZUZhY3RvcnkuZ2V0RmFjdG9yeShnbHApOw0KCQljYXBz LnNldEFjY3VtUmVkQml0cygxNik7DQoJCWNhcHMuc2V0QWNjdW1HcmVlbkJpdHMoMTYpOw0KCQlj YXBzLnNldEFjY3VtQmx1ZUJpdHMoMTYpOw0KCQljYXBzLnNldFN0ZW5jaWxCaXRzKDgpOw0KCQlj YXBzLnNldERvdWJsZUJ1ZmZlcmVkKHRydWUpOw0KCQljYXBzLnNldEhhcmR3YXJlQWNjZWxlcmF0 ZWQodHJ1ZSk7DQoJICAgICAgIA0KICAgICAgICB0cnkgew0KICAgICAgICAJZ2xQQnVmZmVyID0g Z2xGYWN0b3J5LmNyZWF0ZUdMUGJ1ZmZlcihudWxsLCBjYXBzLCBudWxsLCA0LCA0LCBudWxsKTsN CiAgICAgICAgfSBjYXRjaCAoR0xFeGNlcHRpb24gZXhjKSB7CSAgICAgICAgICAgIA0KICAgICAg ICB9DQoNCiANCiAgICAgICAgZ2xQQnVmZmVyLmFkZEdMRXZlbnRMaXN0ZW5lcih0aGlzKTsNCgl9 DQoJDQoJDQoJLyoqDQoJICogQHBhcmFtIGFyZ3MNCgkgKi8NCglwdWJsaWMgc3RhdGljIHZvaWQg bWFpbihTdHJpbmdbXSBhcmdzKSB7DQoJCUZsaXBwZWRJbWFnZVRlc3QgZGVtbyA9IG5ldyBGbGlw cGVkSW1hZ2VUZXN0KCk7DQogICAgICAgIA0KICAgICAgICBkZW1vLmdsUEJ1ZmZlci5kaXNwbGF5 KCk7DQogICAgICAgIGRlbW8uZ2xQQnVmZmVyLmNyZWF0ZUNvbnRleHQobnVsbCkubWFrZUN1cnJl bnQoKTsNCiAgICAgICAgQnVmZmVyZWRJbWFnZSBpbWFnZSA9IFNjcmVlbnNob3QucmVhZFRvQnVm ZmVyZWRJbWFnZSg0LCA0KTsNCiAgICAgICAgDQogICAgICAgIGludCBhYm92ZSA9IGltYWdlLmdl dFJHQigwLCAwKTsNCiAgICAgICAgaW50IGJlbG93ID0gaW1hZ2UuZ2V0UkdCKDAsIDMpOw0KDQog ICAgICAgIGlmIChhYm92ZSA9PSAweGZmMDBmZjAwICYmIGJlbG93ID09IDB4ZmZmZjAwMDApIHsN CiAgICAgICAgICAgIFN5c3RlbS5vdXQucHJpbnRsbigiaW1hZ2UgcmlnaHQgc2lkZSB1cCIpOw0K ICAgICAgICB9IGVsc2UgaWYgKGFib3ZlID09IDB4ZmZmZjAwMDAgJiYgYmVsb3cgPT0gMHhmZjAw ZmYwMCkgew0KICAgICAgICAJU3lzdGVtLm91dC5wcmludGxuKCJpbWFnZSBpcyBmbGlwcGVkIik7 DQogICAgICAgIH0gZWxzZSB7DQogICAgICAgIAlTeXN0ZW0ub3V0LnByaW50bG4oImVycm9yIGlu IHRlc3QiKTsNCiAgICAgICAgfQ0KDQoJfQ0KCQ0KCXB1YmxpYyB2b2lkIGRpc3BsYXkoR0xBdXRv RHJhd2FibGUgZHJhd2FibGUpIHsNCgkJR0wyIGdsID0gZHJhd2FibGUuZ2V0R0woKS5nZXRHTDIo KTsNCiAgICAgICAgZ2wuZ2xNYXRyaXhNb2RlKEdMMi5HTF9QUk9KRUNUSU9OKTsNCiAgICAgICAg Z2wuZ2xMb2FkSWRlbnRpdHkoKTsNCiAgICAgICAgZ2wuZ2xNYXRyaXhNb2RlKEdMMi5HTF9NT0RF TFZJRVcpOw0KICAgICAgICBnbC5nbExvYWRJZGVudGl0eSgpOw0KDQogICAgICAgIC8vIHJlZCBi ZWxvdw0KICAgICAgICBnbC5nbENvbG9yM2YoMSwgMCwgMCk7DQogICAgICAgIGdsLmdsUmVjdGYo LTEsIC0xLCAxLCAwKTsNCg0KICAgICAgICAvLyBncmVlbiBhYm92ZQ0KICAgICAgICBnbC5nbENv bG9yM2YoMCwgMSwgMCk7DQogICAgICAgIGdsLmdsUmVjdGYoLTEsIDAsIDEsIDEpOw0KICAgICAg ICBnbC5nbEZpbmlzaCgpOw0KDQogICAgICAgIGdsLmdsQWNjdW0oR0wyLkdMX0FDQ1VNLCAxLjBm KTsNCiAgICAgICAgZ2wuZ2xBY2N1bShHTDIuR0xfUkVUVVJOLCAxLjBmKTsNCg0KCQlnbC5nbEVu ZCgpOw0KCQlnbC5nbEZsdXNoKCk7DQoJfQ0KIA0KCXB1YmxpYyB2b2lkIGluaXQoR0xBdXRvRHJh d2FibGUgZHJhd2FibGUpIHsNCgl9DQogDQoJcHVibGljIHZvaWQgcmVzaGFwZShHTEF1dG9EcmF3 YWJsZSBnbERyYXdhYmxlLCBpbnQgeCwgaW50IHksIGludCB3LCBpbnQgaCkgew0KCX0NCg0KCXB1 YmxpYyB2b2lkIGRpc3BsYXlDaGFuZ2VkKEdMQXV0b0RyYXdhYmxlIGRyYXdhYmxlLCBib29sZWFu IG1vZGVDaGFuZ2VkLCBib29sZWFuIGRldmljZUNoYW5nZWQpIHsNCgl9DQoNCglwdWJsaWMgdm9p ZCBkaXNwb3NlKEdMQXV0b0RyYXdhYmxlIGRyYXdhYmxlKSB7DQoJfQ0KDQp9DQo=