aboutsummaryrefslogtreecommitdiffstats
path: root/src/demos/com/jogamp
diff options
context:
space:
mode:
Diffstat (limited to 'src/demos/com/jogamp')
-rw-r--r--src/demos/com/jogamp/opengl/demos/Launcher0.java484
-rw-r--r--src/demos/com/jogamp/opengl/demos/MiscUtils.java259
2 files changed, 743 insertions, 0 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..c5e736733
--- /dev/null
+++ b/src/demos/com/jogamp/opengl/demos/Launcher0.java
@@ -0,0 +1,484 @@
+/**
+ * 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 = false;
+ static boolean forceES2 = false;
+ static boolean forceES3 = false;
+ static boolean forceGL3 = false;
+ static boolean forceGL2 = false;
+ static boolean forceDebug = false;
+ static boolean forceTrace = false;
+ static boolean traceMouse = false;
+ static boolean exclusiveContext = false;
+ static boolean useAnimator = true;
+ static boolean useMappedBuffers = false;
+ static enum SysExit { none, testExit, testError, testEDTError, displayExit, displayError, displayEDTError };
+ static SysExit sysExit = SysExit.none;
+
+ 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);
+ }
+
+ 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();
+ }
+
+ if( SysExit.displayError == sysExit || SysExit.displayExit == sysExit || SysExit.displayEDTError == sysExit ) {
+ glWindow.addGLEventListener(new GLEventListener() {
+ @Override
+ public void init(final GLAutoDrawable drawable) {}
+ @Override
+ public void dispose(final GLAutoDrawable drawable) { }
+ @Override
+ public void display(final GLAutoDrawable drawable) {
+ final GLAnimatorControl anim = drawable.getAnimator();
+ if( null != anim && anim.isAnimating() ) {
+ final long ms = anim.getTotalFPSDuration();
+ if( ms >= duration/2 || ms >= 3000 ) { // max 3s wait until provoking error
+ if( SysExit.displayError == sysExit ) {
+ throw new Error("test error send from GLEventListener.display - "+Thread.currentThread());
+ } else if ( SysExit.displayExit == sysExit ) {
+ System.err.println("exit(0) send from GLEventListener");
+ System.exit(0);
+ } else if ( SysExit.displayEDTError == sysExit ) {
+ final Object upstream = drawable.getUpstreamWidget();
+ System.err.println("EDT invokeAndWaitError: upstream type "+upstream.getClass().getName());
+ if( upstream instanceof Window ) {
+ final EDTUtil edt = ((Window)upstream).getScreen().getDisplay().getEDTUtil();
+ System.err.println("EDT invokeAndWaitError: edt type "+edt.getClass().getName());
+ if( edt instanceof DefaultEDTUtil ) {
+ newtDemoListener.doQuit();
+ ((DefaultEDTUtil)edt).invokeAndWaitError(new Runnable() {
+ public void run() {
+ throw new RuntimeException("XXX Should never ever be seen! - "+Thread.currentThread());
+ }
+ });
+ }
+ }
+ }
+ }
+ } else {
+ System.exit(0);
+ }
+ }
+ @Override
+ public void reshape(final GLAutoDrawable drawable, final int x, final int y, final int width, final int height) { }
+ });
+ }
+
+ glWindow.setVisible(true);
+ if( useAnimator ) {
+ animator.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) {
+ Thread.sleep(100);
+ t1 = System.currentTimeMillis();
+ if( SysExit.testError == sysExit || SysExit.testExit == sysExit || SysExit.testEDTError == sysExit) {
+ final long ms = t1-t0;
+ if( ms >= duration/2 || ms >= 3000 ) { // max 3s wait until provoking error
+ if( SysExit.testError == sysExit ) {
+ throw new Error("test error send from test thread");
+ } else if ( SysExit.testExit == sysExit ) {
+ System.err.println("exit(0) send from test thread");
+ System.exit(0);
+ } else if ( SysExit.testEDTError == sysExit ) {
+ final EDTUtil edt = glWindow.getScreen().getDisplay().getEDTUtil();
+ System.err.println("EDT invokeAndWaitError: edt type "+edt.getClass().getName());
+ if( edt instanceof DefaultEDTUtil ) {
+ newtDemoListener.doQuit();
+ ((DefaultEDTUtil)edt).invokeAndWaitError(new Runnable() {
+ public void run() {
+ throw new RuntimeException("XXX Should never ever be seen!");
+ }
+ });
+ }
+ }
+ }
+ }
+ }
+
+ 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("-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("-sysExit")) {
+ i++;
+ sysExit = SysExit.valueOf(args[i]);
+ } 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("swapInterval "+swapInterval);
+ System.err.println("exclusiveContext "+exclusiveContext);
+ System.err.println("useAnimator "+useAnimator);
+ System.err.println("sysExitWithin "+sysExit);
+ 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();
+ }
+}
+
+
+