diff options
Diffstat (limited to 'src/demos/com')
| -rw-r--r-- | src/demos/com/jogamp/opengl/demos/Launcher0.java | 425 | ||||
| -rw-r--r-- | src/demos/com/jogamp/opengl/demos/MiscUtils.java | 259 | ||||
| -rw-r--r-- | src/demos/com/jogamp/opengl/demos/es2/GearsES2.java | 3 |
3 files changed, 684 insertions, 3 deletions
diff --git a/src/demos/com/jogamp/opengl/demos/Launcher0.java b/src/demos/com/jogamp/opengl/demos/Launcher0.java new file mode 100644 index 000000000..2898af1ab --- /dev/null +++ b/src/demos/com/jogamp/opengl/demos/Launcher0.java @@ -0,0 +1,425 @@ +/** + * Copyright 2019 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. + */ + +package com.jogamp.opengl.demos; + +import java.io.IOException; + +import com.jogamp.newt.Display; +import com.jogamp.newt.NewtFactory; +import com.jogamp.newt.Screen; +import com.jogamp.newt.Window; +import com.jogamp.newt.event.WindowEvent; +import com.jogamp.newt.event.TraceMouseAdapter; +import com.jogamp.newt.event.WindowAdapter; +import com.jogamp.newt.opengl.GLWindow; +import com.jogamp.newt.opengl.util.NEWTDemoListener; +import com.jogamp.newt.util.EDTUtil; +import com.jogamp.opengl.util.Animator; +import com.jogamp.opengl.util.AnimatorBase; +import com.jogamp.nativewindow.ScalableSurface; +import com.jogamp.nativewindow.util.Dimension; +import com.jogamp.nativewindow.util.Point; +import com.jogamp.nativewindow.util.PointImmutable; +import com.jogamp.nativewindow.util.DimensionImmutable; +import com.jogamp.opengl.GL; +import com.jogamp.opengl.GLAnimatorControl; +import com.jogamp.opengl.GLAutoDrawable; +import com.jogamp.opengl.GLCapabilities; +import com.jogamp.opengl.GLEventListener; +import com.jogamp.opengl.GLPipelineFactory; +import com.jogamp.opengl.GLProfile; +import com.jogamp.opengl.demos.es2.GearsES2; + +import jogamp.newt.DefaultEDTUtil; + +/** + * <p> + * The demo code uses {@link NEWTDemoListener} functionality. + * </p> + * <p> + * Manual invocation via main allows setting each tests's duration in milliseconds, e.g.{@code -duration 10000} and many more, see {@link #main(String[])} + * </p> + */ +public class Launcher0 { + static int screenIdx = 0; + static PointImmutable wpos; + static DimensionImmutable wsize = new Dimension(640, 480), rwsize=null; + static float[] reqSurfacePixelScale = new float[] { ScalableSurface.AUTOMAX_PIXELSCALE, ScalableSurface.AUTOMAX_PIXELSCALE }; + + static long duration = 500; // ms + static boolean opaque = true; + static int forceAlpha = -1; + static boolean undecorated = false; + static boolean alwaysOnTop = false; + static boolean alwaysOnBottom = false; + static boolean resizable = true; + static boolean sticky = false; + static boolean max_vert= false; + static boolean max_horz= false; + static boolean fullscreen = false; + static int swapInterval = 1; + static boolean waitForKey = false; + static boolean mouseVisible = true; + static boolean mouseConfined = false; + static boolean setPointerIcon = false; + static boolean showFPS = true; + static boolean forceES2 = false; + static boolean forceES3 = false; + static boolean forceGL3 = false; + static boolean forceGL2 = false; + static boolean useDoubleBuffer = true; + static boolean forceDebug = false; + static boolean forceTrace = false; + static boolean traceMouse = false; + static boolean exclusiveContext = false; + static boolean useAnimator = true; + static boolean useMappedBuffers = false; + + public void runTest() throws InterruptedException { + final GLProfile glp; + if(forceGL3) { + glp = GLProfile.get(GLProfile.GL3); + } else if(forceES3) { + glp = GLProfile.get(GLProfile.GLES3); + } else if(forceES2) { + glp = GLProfile.get(GLProfile.GLES2); + } else if(forceGL2) { + glp = GLProfile.get(GLProfile.GL2); + } else { + glp = GLProfile.getGL2ES2(); + } + final GLCapabilities caps = new GLCapabilities( glp ); + caps.setBackgroundOpaque(opaque); + if(-1 < forceAlpha) { + caps.setAlphaBits(forceAlpha); + } + caps.setDoubleBuffered(useDoubleBuffer); + + System.err.println("requested: vsync "+swapInterval+", "+caps); + final Display dpy = NewtFactory.createDisplay(null); + final Screen screen = NewtFactory.createScreen(dpy, screenIdx); + final GLWindow glWindow = GLWindow.create(screen, caps); + + glWindow.setSurfaceScale(reqSurfacePixelScale); + final float[] valReqSurfacePixelScale = glWindow.getRequestedSurfaceScale(new float[2]); + glWindow.setSize(wsize.getWidth(), wsize.getHeight()); + if(null != wpos) { + glWindow.setPosition(wpos.getX(), wpos.getY()); + } + glWindow.setUndecorated(undecorated); + glWindow.setAlwaysOnTop(alwaysOnTop); + glWindow.setAlwaysOnBottom(alwaysOnBottom); + glWindow.setResizable(resizable); + glWindow.setSticky(sticky); + glWindow.setMaximized(max_horz, max_vert); + glWindow.setFullscreen(fullscreen); + glWindow.setPointerVisible(mouseVisible); + glWindow.confinePointer(mouseConfined); + + final GLEventListener demo; + { + final GearsES2 gearsES2 = new GearsES2(swapInterval); + gearsES2.setUseMappedBuffers(useMappedBuffers); + gearsES2.setValidateBuffers(true); + demo = gearsES2; + } + if( forceDebug || forceTrace ) { + glWindow.addGLEventListener(new GLEventListener() { + @Override + public void init(final GLAutoDrawable drawable) { + GL _gl = drawable.getGL(); + if(forceDebug) { + try { + _gl = _gl.getContext().setGL( GLPipelineFactory.create("com.jogamp.opengl.Debug", null, _gl, null) ); + } catch (final Exception e) {e.printStackTrace();} + } + + if(forceTrace) { + try { + // Trace .. + _gl = _gl.getContext().setGL( GLPipelineFactory.create("com.jogamp.opengl.Trace", null, _gl, new Object[] { System.err } ) ); + } catch (final Exception e) {e.printStackTrace();} + } + } + @Override + public void dispose(final GLAutoDrawable drawable) {} + @Override + public void display(final GLAutoDrawable drawable) {} + @Override + public void reshape(final GLAutoDrawable drawable, final int x, final int y, final int width, final int height) {} + }); + } + + if( null != demo ) { + glWindow.addGLEventListener(demo); + } + + if(waitForKey) { + glWindow.addGLEventListener(new GLEventListener() { + public void init(final GLAutoDrawable drawable) { } + public void dispose(final GLAutoDrawable drawable) { } + public void display(final GLAutoDrawable drawable) { + final GLAnimatorControl actrl = drawable.getAnimator(); + if(waitForKey && actrl.getTotalFPSFrames() == 60*3) { + MiscUtils.waitForKey("3s mark"); + actrl.resetFPSCounter(); + waitForKey = false; + } + } + public void reshape(final GLAutoDrawable drawable, final int x, final int y, + final int width, final int height) { } + }); + } + + final Animator animator = useAnimator ? new Animator() : null; + if( useAnimator ) { + animator.setModeBits(false, AnimatorBase.MODE_EXPECT_AWT_RENDERING_THREAD); + animator.setExclusiveContext(exclusiveContext); + } + + glWindow.addWindowListener(new WindowAdapter() { + public void windowResized(final WindowEvent e) { + System.err.println("window resized: "+glWindow.getBounds()+" "+glWindow.getSurfaceWidth()+"x"+glWindow.getSurfaceHeight()); + NEWTDemoListener.setTitle(glWindow); + } + public void windowMoved(final WindowEvent e) { + System.err.println("window moved: "+glWindow.getBounds()+" "+glWindow.getSurfaceWidth()+"x"+glWindow.getSurfaceHeight()); + NEWTDemoListener.setTitle(glWindow); + } + }); + + final NEWTDemoListener newtDemoListener = new NEWTDemoListener(glWindow); + newtDemoListener.quitAdapterEnable(true); + glWindow.addKeyListener(newtDemoListener); + if( traceMouse ) { + glWindow.addMouseListener(new TraceMouseAdapter()); + } + glWindow.addMouseListener(newtDemoListener); + glWindow.addWindowListener(newtDemoListener); + + if( useAnimator ) { + animator.add(glWindow); + animator.start(); + } + + glWindow.setVisible(true); + if( useAnimator ) { + animator.setUpdateFPSFrames(60, showFPS ? System.err : null); + } else { + glWindow.setUpdateFPSFrames(60, showFPS ? System.err : null); + } + + System.err.println("Window Current State : "+glWindow.getStateMaskString()); + System.err.println("Window Supported States: "+glWindow.getSupportedStateMaskString()); + System.err.println("NW chosen: "+glWindow.getDelegatedWindow().getChosenCapabilities()); + System.err.println("GL chosen: "+glWindow.getChosenCapabilities()); + System.err.println("window pos/siz: "+glWindow.getX()+"/"+glWindow.getY()+" "+glWindow.getSurfaceWidth()+"x"+glWindow.getSurfaceHeight()+", "+glWindow.getInsets()); + + final float[] hasSurfacePixelScale1 = glWindow.getCurrentSurfaceScale(new float[2]); + System.err.println("HiDPI PixelScale: "+reqSurfacePixelScale[0]+"x"+reqSurfacePixelScale[1]+" (req) -> "+ + valReqSurfacePixelScale[0]+"x"+valReqSurfacePixelScale[1]+" (val) -> "+ + hasSurfacePixelScale1[0]+"x"+hasSurfacePixelScale1[1]+" (has)"); + NEWTDemoListener.setTitle(glWindow); + + if( null != rwsize ) { + Thread.sleep(500); // 500ms delay + glWindow.setSize(rwsize.getWidth(), rwsize.getHeight()); + System.err.println("window resize pos/siz: "+glWindow.getX()+"/"+glWindow.getY()+" "+glWindow.getSurfaceWidth()+"x"+glWindow.getSurfaceHeight()+", "+glWindow.getInsets()); + } + + final long t0 = System.currentTimeMillis(); + long t1 = t0; + while(!newtDemoListener.shouldQuit() && t1-t0<duration) { + if(!useAnimator) { + Thread.sleep(15); // little less than 60hz 16.67ms + glWindow.display(); + } else { + Thread.sleep(100); + } + t1 = System.currentTimeMillis(); + } + + if( useAnimator ) { + animator.stop(); + } + glWindow.destroy(); + } + + public static void main(final String args[]) throws IOException { + int x=0, y=0, w=640, h=480, rw=-1, rh=-1; + boolean usePos = false; + + for(int i=0; i<args.length; i++) { + if(args[i].equals("-time")) { + i++; + duration = MiscUtils.atol(args[i], duration); + } else if(args[i].equals("-translucent")) { + opaque = false; + } else if(args[i].equals("-forceAlpha")) { + i++; + forceAlpha = MiscUtils.atoi(args[i], 0); + } else if(args[i].equals("-undecorated")) { + undecorated = true; + } else if(args[i].equals("-atop")) { + alwaysOnTop = true; + } else if(args[i].equals("-abottom")) { + alwaysOnBottom = true; + } else if(args[i].equals("-noresize")) { + resizable = false; + } else if(args[i].equals("-sticky")) { + sticky = true; + } else if(args[i].equals("-maxv")) { + max_vert = true; + } else if(args[i].equals("-maxh")) { + max_horz = true; + } else if(args[i].equals("-fullscreen")) { + fullscreen = true; + } else if(args[i].equals("-vsync")) { + i++; + swapInterval = MiscUtils.atoi(args[i], swapInterval); + } else if(args[i].equals("-single")) { + useDoubleBuffer = false; + } else if(args[i].equals("-exclctx")) { + exclusiveContext = true; + } else if(args[i].equals("-noanim")) { + useAnimator = false; + } else if(args[i].equals("-es2")) { + forceES2 = true; + } else if(args[i].equals("-es3")) { + forceES3 = true; + } else if(args[i].equals("-gl3")) { + forceGL3 = true; + } else if(args[i].equals("-gl2")) { + forceGL2 = true; + } else if(args[i].equals("-debug")) { + forceDebug = true; + } else if(args[i].equals("-trace")) { + forceTrace = true; + } else if(args[i].equals("-mappedBuffers")) { + useMappedBuffers = true; + } else if(args[i].equals("-wait")) { + waitForKey = true; + } else if(args[i].equals("-mouseInvisible")) { + mouseVisible = false; + } else if(args[i].equals("-mouseConfine")) { + mouseConfined = true; + } else if(args[i].equals("-pointerIcon")) { + setPointerIcon = true; + } else if(args[i].equals("-showFPS")) { + showFPS = true; + } else if(args[i].equals("-width")) { + i++; + w = MiscUtils.atoi(args[i], w); + } else if(args[i].equals("-height")) { + i++; + h = MiscUtils.atoi(args[i], h); + } else if(args[i].equals("-x")) { + i++; + x = MiscUtils.atoi(args[i], x); + usePos = true; + } else if(args[i].equals("-y")) { + i++; + y = MiscUtils.atoi(args[i], y); + usePos = true; + } else if(args[i].equals("-pixelScale")) { + i++; + final float pS = MiscUtils.atof(args[i], reqSurfacePixelScale[0]); + reqSurfacePixelScale[0] = pS; + reqSurfacePixelScale[1] = pS; + } else if(args[i].equals("-rwidth")) { + i++; + rw = MiscUtils.atoi(args[i], rw); + } else if(args[i].equals("-rheight")) { + i++; + rh = MiscUtils.atoi(args[i], rh); + } else if(args[i].equals("-screen")) { + i++; + screenIdx = MiscUtils.atoi(args[i], 0); + } else if(args[i].equals("-traceMouse")) { + traceMouse = true; + } + } + wsize = new Dimension(w, h); + if( 0 < rw && 0 < rh ) { + rwsize = new Dimension(rw, rh); + } + + if(usePos) { + wpos = new Point(x, y); + } + System.err.println("position "+wpos); + System.err.println("size "+wsize); + System.err.println("resize "+rwsize); + System.err.println("screen "+screenIdx); + System.err.println("translucent "+(!opaque)); + System.err.println("forceAlpha "+forceAlpha); + System.err.println("undecorated "+undecorated); + System.err.println("atop "+alwaysOnTop); + System.err.println("abottom "+alwaysOnBottom); + System.err.println("resizable "+resizable); + System.err.println("sticky "+sticky); + System.err.println("max_vert "+max_vert); + System.err.println("max_horz "+max_horz); + System.err.println("fullscreen "+fullscreen); + System.err.println("mouseVisible "+mouseVisible); + System.err.println("mouseConfined "+mouseConfined); + System.err.println("pointerIcon "+setPointerIcon); + System.err.println("forceES2 "+forceES2); + System.err.println("forceES3 "+forceES3); + System.err.println("forceGL3 "+forceGL3); + System.err.println("forceGL2 "+forceGL2); + System.err.println("forceDebug "+forceDebug); + System.err.println("forceTrace "+forceTrace); + System.err.println("useDoubleBuffer "+useDoubleBuffer); + System.err.println("swapInterval "+swapInterval); + System.err.println("exclusiveContext "+exclusiveContext); + System.err.println("useAnimator "+useAnimator); + System.err.println("mappedBuffers "+useMappedBuffers); + System.err.println("traceMouse "+traceMouse); + + if(waitForKey) { + MiscUtils.waitForKey("Start"); + } + + final Launcher0 l = new Launcher0(); + try { + System.err.println("Start-Demo"); + l.runTest(); + System.err.println("End-Demo"); + } catch (final InterruptedException e) { + e.printStackTrace(); + } + if(waitForKey) { + MiscUtils.waitForKey("End-Pre-Shutdown"); + } + System.err.println("End-Pre-Shutdown"); + GLProfile.shutdown(); + System.err.println("End-Post-Shutdown"); + } +} diff --git a/src/demos/com/jogamp/opengl/demos/MiscUtils.java b/src/demos/com/jogamp/opengl/demos/MiscUtils.java new file mode 100644 index 000000000..304e4f18a --- /dev/null +++ b/src/demos/com/jogamp/opengl/demos/MiscUtils.java @@ -0,0 +1,259 @@ +/** + * Copyright 2010 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. + */ + + +package com.jogamp.opengl.demos; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.lang.reflect.*; +import java.nio.FloatBuffer; +import java.util.Iterator; +import java.util.List; + +import com.jogamp.opengl.GLContext; + +import com.jogamp.common.os.Platform; +import com.jogamp.common.util.InterruptSource; + +public class MiscUtils { + public static boolean atob(final String str, final boolean def) { + try { + return Boolean.parseBoolean(str); + } catch (final Exception ex) { + ex.printStackTrace(); + } + return def; + } + + public static int atoi(final String str, final int def) { + try { + return Integer.parseInt(str); + } catch (final Exception ex) { + ex.printStackTrace(); + } + return def; + } + + public static long atol(final String str, final long def) { + try { + return Long.parseLong(str); + } catch (final Exception ex) { + ex.printStackTrace(); + } + return def; + } + + public static float atof(final String str, final float def) { + try { + return Float.parseFloat(str); + } catch (final Exception ex) { + ex.printStackTrace(); + } + return def; + } + + public static String toHexString(final byte hex) { + return "0x" + Integer.toHexString( hex & 0x000000FF ); + } + + public static String toHexString(final short hex) { + return "0x" + Integer.toHexString( hex & 0x0000FFFF ); + } + + public static String toHexString(final int hex) { + return "0x" + Integer.toHexString( hex ); + } + + public static String toHexString(final long hex) { + return "0x" + Long.toHexString( hex ); + } + + public static void assertFloatBufferEquals(final String errmsg, final FloatBuffer expected, final FloatBuffer actual, final float delta) { + if(null == expected && null == actual) { + return; + } + final String msg = null != errmsg ? errmsg + " " : ""; + if(null == expected) { + throw new AssertionError(msg+"; Expected is null, but actual not: "+actual); + } + if(null == actual) { + throw new AssertionError(msg+"; Actual is null, but expected not: "+expected); + } + if(expected.remaining() != actual.remaining()) { + throw new AssertionError(msg+"; Expected has "+expected.remaining()+" remaining, but actual has "+actual.remaining()); + } + final int a0 = expected.position(); + final int b0 = actual.position(); + for(int i=0; i<expected.remaining(); i++) { + final float ai = expected.get(a0 + i); + final float bi = actual.get(b0 + i); + final float daibi = Math.abs(ai - bi); + if( daibi > delta ) { + throw new AssertionError(msg+"; Expected @ ["+a0+"+"+i+"] has "+ai+", but actual @ ["+b0+"+"+i+"] has "+bi+", it's delta "+daibi+" > "+delta); + } + } + } + + public static void assertFloatBufferNotEqual(final String errmsg, final FloatBuffer expected, final FloatBuffer actual, final float delta) { + if(null == expected || null == actual) { + return; + } + if(expected.remaining() != actual.remaining()) { + return; + } + final String msg = null != errmsg ? errmsg + " " : ""; + final int a0 = expected.position(); + final int b0 = actual.position(); + for(int i=0; i<expected.remaining(); i++) { + final float ai = expected.get(a0 + i); + final float bi = actual.get(b0 + i); + final float daibi = Math.abs(ai - bi); + if( daibi > delta ) { + return; + } + } + throw new AssertionError(msg+"; Expected and actual are equal."); + } + + public static boolean setFieldIfExists(final Object instance, final String fieldName, final Object value) { + try { + final Field f = instance.getClass().getField(fieldName); + if(value instanceof Boolean || f.getType().isInstance(value)) { + f.set(instance, value); + return true; + } else { + System.out.println(instance.getClass()+" '"+fieldName+"' field not assignable with "+value.getClass()+", it's a: "+f.getType()); + } + } catch (final IllegalAccessException ex) { + throw new RuntimeException(ex); + } catch (final NoSuchFieldException nsfe) { + // OK - throw new RuntimeException(instance.getClass()+" has no '"+fieldName+"' field", nsfe); + } + return false; + } + + public static void waitForKey(final String preMessage) { + final BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); + System.err.println(preMessage+"> Press enter to continue"); + try { + System.err.println(stdin.readLine()); + } catch (final IOException e) { e.printStackTrace(); } + } + + + public static class StreamDump extends InterruptSource.Thread { + final InputStream is; + final StringBuilder outString; + final OutputStream outStream; + final String prefix; + final Object sync; + volatile boolean eos = false; + + public StreamDump(final OutputStream out, final String prefix, final InputStream is, final Object sync) { + this.is = is; + this.outString = null; + this.outStream = out; + this.prefix = prefix; + this.sync = sync; + } + public StreamDump(final StringBuilder sb, final String prefix, final InputStream is, final Object sync) { + this.is = is; + this.outString = sb; + this.outStream = null; + this.prefix = prefix; + this.sync = sync; + } + public StreamDump(final StringBuilder sb, final InputStream is, final Object sync) { + this.is = is; + this.outString = sb; + this.outStream = null; + this.prefix = null; + this.sync = sync; + } + + public final boolean eos() { return eos; } + + @Override + public void run() { + synchronized ( sync ) { + try { + final BufferedReader in = new BufferedReader( new InputStreamReader(is) ); + String line = null; + while ((line = in.readLine()) != null) { + if( null != outString ) { + outString.append(line).append(Platform.getNewline()); + } else if( null != outStream ) { + if( null != prefix ) { + outStream.write(prefix.getBytes()); + } + outStream.write(line.getBytes()); + outStream.write(Platform.getNewline().getBytes()); + outStream.flush(); + } + } + } catch (final IOException ioe) { + System.err.println("Caught "+ioe.getClass().getName()+": "+ioe.getMessage()); + ioe.printStackTrace(); + } finally { + eos = true; + sync.notifyAll(); + } + } + } + } + + public static void dumpSharedGLContext(final String prefix, final GLContext self) { + int i = 0, j = 0; + final GLContext master = self.getSharedMaster(); + final int masterHash = null != master ? master.hashCode() : 0; + System.err.println(prefix+": hash 0x"+Integer.toHexString(self.hashCode())+", \t(isShared "+self.isShared()+", created "+self.isCreated()+", master 0x"+Integer.toHexString(masterHash)+")"); + { + final List<GLContext> set = self.getCreatedShares(); + for (final Iterator<GLContext> iter = set.iterator(); iter.hasNext(); ) { + final GLContext c = iter.next(); + System.err.println(" Created Ctx #"+(i++)+": hash 0x"+Integer.toHexString(c.hashCode())+", \t(created "+c.isCreated()+")"); + } + } + { + final List<GLContext> set = self.getDestroyedShares(); + for (final Iterator<GLContext> iter = set.iterator(); iter.hasNext(); ) { + final GLContext c = iter.next(); + System.err.println(" Destroyed Ctx #"+(j++)+": hash 0x"+Integer.toHexString(c.hashCode())+", \t(created "+c.isCreated()+")"); + } + } + System.err.println("\t Total created "+i+" + destroyed "+j+" = "+(i+j)); + System.err.println(); + } +} + + + diff --git a/src/demos/com/jogamp/opengl/demos/es2/GearsES2.java b/src/demos/com/jogamp/opengl/demos/es2/GearsES2.java index a2d0f5db7..ffb4f95d0 100644 --- a/src/demos/com/jogamp/opengl/demos/es2/GearsES2.java +++ b/src/demos/com/jogamp/opengl/demos/es2/GearsES2.java @@ -490,9 +490,6 @@ public class GearsES2 implements StereoGLEventListener, TileRendererBase.TileRen if( !isInit ) { return; } if(null != sharedGears && !sharedGears.isInit() ) { return; } final GLAnimatorControl anim = drawable.getAnimator(); - if( verbose && ( null == anim || !anim.isAnimating() ) ) { - System.err.println(Thread.currentThread()+" GearsES2.display "+sid()+" "+drawable.getSurfaceWidth()+"x"+drawable.getSurfaceHeight()+", swapInterval "+swapInterval+", drawable 0x"+Long.toHexString(drawable.getHandle())); - } final boolean repeatedFrame = 0 != ( CustomGLEventListener.DISPLAY_REPEAT & flags ); final boolean dontClear = 0 != ( CustomGLEventListener.DISPLAY_DONTCLEAR & flags ); |