aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorDan Krisher <[email protected]>2011-11-14 12:42:11 -0500
committerDan Krisher <[email protected]>2011-11-14 12:42:11 -0500
commiteca59450698e832b329169ba12fa5953f6052bce (patch)
treefdde706d6e85f3c05e398529cd1965b8a8eebc34 /src
parent48bc1b090b57eb8ec3cb2f9ff33b69c9d99704d7 (diff)
[WIP] Added an SWT based GLCanvas implementation nearly identical to the AWT version. Modified build to produce a jogl.swt.jar, and include this in jogl.all.jar. Presently there is no unit test (just a 'main' in the jogamp.opengl.swt.GLCanvas), and this does not support correct selection of GLCapabilities (FIXME and TODO tags in the source state why).
Diffstat (limited to 'src')
-rw-r--r--src/jogl/classes/jogamp/opengl/swt/GLCanvas.java673
1 files changed, 673 insertions, 0 deletions
diff --git a/src/jogl/classes/jogamp/opengl/swt/GLCanvas.java b/src/jogl/classes/jogamp/opengl/swt/GLCanvas.java
new file mode 100644
index 000000000..88c8d4d94
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/swt/GLCanvas.java
@@ -0,0 +1,673 @@
+/**
+ *
+ */
+package jogamp.opengl.swt;
+
+import javax.media.nativewindow.AbstractGraphicsConfiguration;
+import javax.media.nativewindow.AbstractGraphicsDevice;
+import javax.media.nativewindow.AbstractGraphicsScreen;
+import javax.media.nativewindow.GraphicsConfigurationFactory;
+import javax.media.nativewindow.NativeSurface;
+import javax.media.nativewindow.ProxySurface;
+import javax.media.opengl.GL;
+import javax.media.opengl.GLAnimatorControl;
+import javax.media.opengl.GLAutoDrawable;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLCapabilitiesImmutable;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLDrawable;
+import javax.media.opengl.GLDrawableFactory;
+import javax.media.opengl.GLEventListener;
+import javax.media.opengl.GLException;
+import javax.media.opengl.GLProfile;
+import javax.media.opengl.GLRunnable;
+import javax.media.opengl.Threading;
+
+import jogamp.nativewindow.swt.SWTAccessor;
+import jogamp.opengl.GLContextImpl;
+import jogamp.opengl.GLDrawableHelper;
+import jogamp.opengl.ThreadingImpl;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.ControlAdapter;
+import org.eclipse.swt.events.ControlEvent;
+import org.eclipse.swt.events.PaintEvent;
+import org.eclipse.swt.events.PaintListener;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.widgets.Canvas;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+
+import com.jogamp.common.util.locks.LockFactory;
+import com.jogamp.common.util.locks.RecursiveLock;
+
+/**
+ *
+ */
+public class GLCanvas extends Canvas implements GLAutoDrawable {
+
+ /*
+ * Flag for whether the SWT thread should be used for OpenGL calls when in single-threaded mode. This is controlled
+ * by the setting of the threading mode to worker (do not use SWT thread), awt (use SWT thread), or false (always use
+ * calling thread).
+ *
+ * @see Threading
+ *
+ * Now done dynamically to avoid early loading of gluegen library.
+ */
+ //private static final boolean useSWTThread = ThreadingImpl.getMode() != ThreadingImpl.WORKER;
+
+ /* GL Stuff */
+ private final GLDrawableHelper drawableHelper = new GLDrawableHelper();
+ private GLDrawable drawable;
+ private GLContext context;
+
+ /* Native window surface */
+ private AbstractGraphicsDevice device;
+ private final long nativeWindowHandle;
+ private final ProxySurface proxySurface;
+
+ /* Construction parameters stored for GLAutoDrawable accessor methods */
+ private int ctxCreationFlags = 0;
+
+// private final AbstractGraphicsConfiguration graphicsConfiguration;
+ private final GLCapabilitiesImmutable glCapsRequested;
+
+ /*
+ * Lock for access to GLDrawable, as used in GLCanvas,
+ */
+ private final RecursiveLock lock = LockFactory.createRecursiveLock();
+
+ /* Flag indicating whether an unprocessed reshape is pending. */
+ private volatile boolean sendReshape;
+
+ /*
+ * Invokes init(...) on all GLEventListeners. Assumes context is current when run.
+ */
+ private final Runnable initAction = new Runnable() {
+ @Override
+ public void run() {
+ drawableHelper.init(GLCanvas.this);
+ }
+ };
+
+ /*
+ * Action to handle display in OpenGL, also processes reshape since they should be done at the same time.
+ *
+ * Assumes GLContext is current when run.
+ */
+ private final Runnable displayAction = new Runnable() {
+ @Override
+ public void run() {
+ if (sendReshape) {
+ drawableHelper.reshape(GLCanvas.this, 0, 0, getWidth(), getHeight());
+ sendReshape = false;
+ }
+ drawableHelper.display(GLCanvas.this);
+ }
+ };
+
+ /* Action to make specified context current prior to running displayAction */
+ private final Runnable makeCurrentAndDisplayAction = new Runnable() {
+ @Override
+ public void run() {
+ drawableHelper.invokeGL(drawable, context, displayAction, initAction);
+ }
+ };
+
+ /* Swaps buffers, assuming the GLContext is current */
+ private final Runnable swapBuffersAction = new Runnable() {
+ @Override
+ public void run() {
+ drawable.swapBuffers();
+ }
+ };
+
+ /* Swaps buffers, making the GLContext current first */
+ private final Runnable makeCurrentAndSwapBuffersAction = new Runnable() {
+ @Override
+ public void run() {
+ drawableHelper.invokeGL(drawable, context, swapBuffersAction, initAction);
+ }
+ };
+
+ /*
+ * Disposes of OpenGL resources
+ */
+ private final Runnable disposeGLAction = new Runnable() {
+ @Override
+ public void run() {
+ drawableHelper.dispose(GLCanvas.this);
+
+ if (null != context) {
+ context.makeCurrent(); // implicit wait for lock ..
+ context.destroy();
+ context = null;
+ }
+
+ if (null != drawable) {
+ drawable.setRealized(false);
+ drawable = null;
+ }
+ }
+ };
+
+ private final Runnable makeCurrentAndDisposeGLAction = new Runnable() {
+ @Override
+ public void run() {
+ drawableHelper.invokeGL(drawable, context, disposeGLAction, null);
+ }
+ };
+
+ private final Runnable disposeGraphicsDeviceAction = new Runnable() {
+ @Override
+ public void run() {
+ if (null != device) {
+ device.close();
+ device = null;
+ }
+ }
+ };
+
+ /**
+ * Creates a new SWT GLCanvas.
+ *
+ * @param parent
+ * Required (non-null) parent Composite.
+ * @param style
+ * Optional SWT style bit-field. The {@link SWT#NO_BACKGROUND} bit is set before passing this up to the
+ * Canvas constructor, so OpenGL handles the background.
+ * @param caps
+ * Optional GLCapabilities. If not provided, the default capabilities for the default GLProfile for the
+ * graphics device determined by the parent Composite are used. Note that the GLCapabilities that are
+ * actually used may differ based on the capabilities of the graphics device.
+ * @param chooser
+ * Optional GLCapabilitiesChooser to customize the selection of the used GLCapabilities based on the
+ * requested GLCapabilities, and the available capabilities of the graphics device.
+ * @param shareWith
+ * Optional GLContext to share state (textures, vbos, shaders, etc.) with.
+ */
+ public GLCanvas(final Composite parent, final int style, final GLCapabilities caps,
+ final GLCapabilitiesChooser chooser, final GLContext shareWith) {
+ /* NO_BACKGROUND required to avoid clearing bg in native SWT widget (we do this in the GL display) */
+ super(parent, style | SWT.NO_BACKGROUND);
+
+ SWTAccessor.setRealized(this, true);
+
+ /* Get the nativewindow-Graphics Device associated with this control (which is determined by the parent Composite) */
+ device = SWTAccessor.getDevice(this);
+ /* Native handle for the control, used to associate with GLContext */
+ nativeWindowHandle = SWTAccessor.getWindowHandle(this);
+
+ /* Select default GLCapabilities if none was provided, otherwise clone provided caps to ensure safety */
+ final GLCapabilitiesImmutable fixedCaps = (caps == null) ? new GLCapabilities(GLProfile.getDefault(device))
+ : (GLCapabilitiesImmutable) caps.cloneMutable();
+ glCapsRequested = fixedCaps;
+
+// this.graphicsConfiguration = chooseGraphicsConfiguration(fixedCaps, fixedCaps, chooser);
+
+ final GLDrawableFactory glFactory = GLDrawableFactory.getFactory(fixedCaps.getGLProfile());
+
+ /* Create a NativeWindow proxy for the SWT canvas */
+ proxySurface = glFactory.createProxySurface(device, nativeWindowHandle, fixedCaps, null);
+
+ /* Associate a GL surface with the proxy */
+ drawable = glFactory.createGLDrawable(proxySurface);
+ drawable.setRealized(true);
+
+ context = drawable.createContext(shareWith);
+
+ /* Register SWT listeners (e.g. PaintListener) to render/resize GL surface. */
+ /* TODO: verify that these do not need to be manually de-registered when destroying the SWT component */
+ addPaintListener(new PaintListener() {
+
+ @Override
+ public void paintControl(final PaintEvent arg0) {
+ if (!drawableHelper.isExternalAnimatorAnimating()) {
+ display();
+ }
+ }
+ });
+ addControlListener(new ControlAdapter() {
+
+ @Override
+ public void controlResized(final ControlEvent arg0) {
+ /* Mark for OpenGL reshape next time the control is painted */
+ sendReshape = true;
+ }
+ });
+ }
+
+ private AbstractGraphicsConfiguration chooseGraphicsConfiguration(final GLCapabilitiesImmutable capsChosen,
+ final GLCapabilitiesImmutable capsRequested,
+ final GLCapabilitiesChooser chooser) {
+ //FIXME: Need to get platform specific screen implementation...
+ //TODO: is this safe to run in any thread? Probably should be run in SWT thread.
+ final AbstractGraphicsScreen screen = null;
+ return GraphicsConfigurationFactory.getFactory(device.getClass()).chooseGraphicsConfiguration(capsChosen,
+ capsRequested,
+ chooser, screen);
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#addGLEventListener(javax.media.opengl.GLEventListener)
+ */
+ @Override
+ public void addGLEventListener(final GLEventListener arg0) {
+ drawableHelper.addGLEventListener(arg0);
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#addGLEventListener(int, javax.media.opengl.GLEventListener)
+ */
+ @Override
+ public void addGLEventListener(final int arg0, final GLEventListener arg1) throws IndexOutOfBoundsException {
+ drawableHelper.addGLEventListener(arg0, arg1);
+ }
+
+ /**
+ * {@inheritDoc}
+ * <p>
+ * Also disposes of the SWT component.
+ */
+ @Override
+ public void destroy() {
+ drawable.setRealized(false);
+ dispose();
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#display()
+ */
+ @Override
+ public void display() {
+ runInGLThread(makeCurrentAndDisplayAction, displayAction);
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#getAnimator()
+ */
+ @Override
+ public GLAnimatorControl getAnimator() {
+ return drawableHelper.getAnimator();
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#getAutoSwapBufferMode()
+ */
+ @Override
+ public boolean getAutoSwapBufferMode() {
+ return drawableHelper.getAutoSwapBufferMode();
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#getContext()
+ */
+ @Override
+ public GLContext getContext() {
+ return context;
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#getContextCreationFlags()
+ */
+ @Override
+ public int getContextCreationFlags() {
+ return ctxCreationFlags;
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#getGL()
+ */
+ @Override
+ public GL getGL() {
+ final GLContext ctx = getContext();
+ return (ctx == null) ? null : ctx.getGL();
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#invoke(boolean, javax.media.opengl.GLRunnable)
+ */
+ @Override
+ public void invoke(final boolean wait, final GLRunnable run) {
+ /* Queue task for running during the next display(). */
+ drawableHelper.invoke(this, wait, run);
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#removeGLEventListener(javax.media.opengl.GLEventListener)
+ */
+ @Override
+ public void removeGLEventListener(final GLEventListener arg0) {
+ drawableHelper.removeGLEventListener(arg0);
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#setAnimator(javax.media.opengl.GLAnimatorControl)
+ */
+ @Override
+ public void setAnimator(final GLAnimatorControl arg0) throws GLException {
+ drawableHelper.setAnimator(arg0);
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#setAutoSwapBufferMode(boolean)
+ */
+ @Override
+ public void setAutoSwapBufferMode(final boolean arg0) {
+ drawableHelper.setAutoSwapBufferMode(arg0);
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#setContext(javax.media.opengl.GLContext)
+ */
+ @Override
+ public void setContext(final GLContext ctx) {
+ this.context = ctx;
+ if (ctx instanceof GLContextImpl) {
+ ((GLContextImpl) ctx).setContextCreationFlags(ctxCreationFlags);
+ }
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#setContextCreationFlags(int)
+ */
+ @Override
+ public void setContextCreationFlags(final int arg0) {
+ ctxCreationFlags = arg0;
+ }
+
+ /*
+ * @see javax.media.opengl.GLAutoDrawable#setGL(javax.media.opengl.GL)
+ */
+ @Override
+ public GL setGL(final GL arg0) {
+ final GLContext ctx = getContext();
+ if (ctx != null) {
+ ctx.setGL(arg0);
+ return arg0;
+ }
+ return null;
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#createContext(javax.media.opengl.GLContext)
+ */
+ @Override
+ public GLContext createContext(final GLContext arg0) {
+ lock.lock();
+ try {
+ final GLDrawable drawable = this.drawable;
+ return (drawable != null) ? drawable.createContext(arg0) : null;
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#getChosenGLCapabilities()
+ */
+ @Override
+ public GLCapabilitiesImmutable getChosenGLCapabilities() {
+ return glCapsRequested;
+ /* FIXME: once the chooseGraphicsConfiguration method is correct, then do the following instead: */
+// return (GLCapabilitiesImmutable)graphicsConfiguration.getChosenCapabilities();
+ }
+
+ /**
+ * Accessor for the GLCapabilities that were requested (via the constructor parameter).
+ *
+ * @return Non-null GLCapabilities.
+ */
+ public GLCapabilitiesImmutable getRequestedGLCapabilities() {
+ return glCapsRequested;
+ /* FIXME: once the chooseGraphicsConfiguration method is correct, then do the following instead: */
+ //return (GLCapabilitiesImmutable)graphicsConfiguration.getRequestedCapabilities();
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#getFactory()
+ */
+ @Override
+ public GLDrawableFactory getFactory() {
+ lock.lock();
+ try {
+ final GLDrawable drawable = this.drawable;
+ return (drawable != null) ? drawable.getFactory() : null;
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#getGLProfile()
+ */
+ @Override
+ public GLProfile getGLProfile() {
+ return glCapsRequested.getGLProfile();
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#getHandle()
+ */
+ @Override
+ public long getHandle() {
+ lock.lock();
+ try {
+ final GLDrawable drawable = this.drawable;
+ return (drawable != null) ? drawable.getHandle() : 0;
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#getHeight()
+ */
+ @Override
+ public int getHeight() {
+ return getClientArea().height;
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#getNativeSurface()
+ */
+ @Override
+ public NativeSurface getNativeSurface() {
+ lock.lock();
+ try {
+ final GLDrawable drawable = this.drawable;
+ return (drawable != null) ? drawable.getNativeSurface() : null;
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#getWidth()
+ */
+ @Override
+ public int getWidth() {
+ return getClientArea().width;
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#isRealized()
+ */
+ @Override
+ public boolean isRealized() {
+ lock.lock();
+ try {
+ final GLDrawable drawable = this.drawable;
+ return (drawable != null) ? drawable.isRealized() : false;
+ } finally {
+ lock.unlock();
+ }
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#setRealized(boolean)
+ */
+ @Override
+ public void setRealized(final boolean arg0) {
+ /* Intentionally empty */
+ }
+
+ /*
+ * @see javax.media.opengl.GLDrawable#swapBuffers()
+ */
+ @Override
+ public void swapBuffers() throws GLException {
+ runInGLThread(makeCurrentAndSwapBuffersAction, swapBuffersAction);
+ }
+
+ /*
+ * @see mil.afrl.rrs.ifsb.jview.graph.graph3d.RenderSurface#update()
+ */
+ @Override
+ public void update() {
+// display();
+ }
+
+ /*
+ * @see mil.afrl.rrs.ifsb.jview.graph.graph3d.RenderSurface#dispose()
+ */
+ @Override
+ public void dispose() {
+ lock.lock();
+ try {
+ final Display display = getDisplay();
+
+ if (null != context) {
+ boolean animatorPaused = false;
+ final GLAnimatorControl animator = getAnimator();
+ if (null != animator) {
+ // can't remove us from animator for recreational addNotify()
+ animatorPaused = animator.pause();
+ }
+ if (Threading.isSingleThreaded() && !Threading.isOpenGLThread()) {
+ runInDesignatedGLThread(makeCurrentAndDisposeGLAction);
+ } else if (context.isCreated()) {
+ drawableHelper.invokeGL(drawable, context, disposeGLAction, null);
+ }
+
+ if (animatorPaused) {
+ animator.resume();
+ }
+ }
+ if (display.getThread() == Thread.currentThread())
+ disposeGraphicsDeviceAction.run();
+ else
+ display.syncExec(disposeGraphicsDeviceAction);
+ } finally {
+ lock.unlock();
+ }
+ super.dispose();
+ }
+
+ /**
+ * Determines whether the current thread is the appropriate thread to use the GLContext in. If we are using one of
+ * the single-threaded policies in {@link Threading}, than this is either the SWT event dispatch thread, or the
+ * OpenGL worker thread depending on the state of {@link #useSWTThread}. Otherwise this always returns true because
+ * the threading model is user defined.
+ * <p>
+ * TODO: should this be moved to {@link Threading}?
+ *
+ * @return true if the calling thread is the correct thread to execute OpenGL calls in, false otherwise.
+ */
+ protected boolean isRenderThread() {
+ if (Threading.isSingleThreaded()) {
+ if (ThreadingImpl.getMode() != ThreadingImpl.WORKER) {
+ final Display display = getDisplay();
+ return display != null && display.getThread() == Thread.currentThread();
+ }
+ return Threading.isOpenGLThread();
+ }
+ /*
+ * For multi-threaded rendering, the render thread is not defined...
+ */
+ return true;
+ }
+
+ /**
+ * Runs the specified action in the designated OpenGL thread. If the current thread is designated, then the
+ * syncAction is run synchronously, otherwise the asyncAction is dispatched to the appropriate worker thread.
+ *
+ * @param asyncAction
+ * The non-null action to dispatch to an OpenGL worker thread. This action should not assume that a
+ * GLContext is current when invoked.
+ * @param syncAction
+ * The non-null action to run synchronously if the current thread is designated to handle OpenGL calls.
+ * This action may assume the GLContext is current.
+ */
+ private void runInGLThread(final Runnable asyncAction, final Runnable syncAction) {
+ if (Threading.isSingleThreaded() && !isRenderThread()) {
+ /* Run in designated GL thread */
+ runInDesignatedGLThread(asyncAction);
+ } else {
+ /* Run in current thread... */
+ drawableHelper.invokeGL(drawable, context, syncAction, initAction);
+ }
+ }
+
+ /**
+ * Dispatches the specified runnable to the appropriate OpenGL worker thread (either the SWT event dispatch thread,
+ * or the OpenGL worker thread depending on the state of {@link #useSWTThread}).
+ *
+ * @param makeCurrentAndRunAction
+ * The non-null action to dispatch.
+ */
+ private void runInDesignatedGLThread(final Runnable makeCurrentAndRunAction) {
+ if (ThreadingImpl.getMode() != ThreadingImpl.WORKER) {
+ final Display display = getDisplay();
+ assert display.getThread() != Thread.currentThread() : "Incorrect use of thread dispatching.";
+ display.syncExec(makeCurrentAndRunAction);
+ } else {
+ Threading.invokeOnOpenGLThread(makeCurrentAndRunAction);
+ }
+ }
+
+
+ public static void main(final String[] args) {
+ GLProfile.initSingleton(true);
+ final Display display = new Display();
+ final Shell shell = new Shell(display);
+ shell.setSize(800,600);
+ shell.setLayout(new FillLayout());
+
+ final GLCanvas canvas = new GLCanvas(shell,
+ 0, null, null, null);
+
+ canvas.addGLEventListener(new GLEventListener() {
+
+ @Override
+ public void reshape(final GLAutoDrawable drawable, final int x, final int y, final int width, final int height) {
+ System.out.println("Reshape");
+ }
+
+ @Override
+ public void init(final GLAutoDrawable drawable) {
+ System.out.println("Init");
+ }
+
+ @Override
+ public void dispose(final GLAutoDrawable drawable) {
+ System.out.println("Dispose");
+ }
+
+ @Override
+ public void display(final GLAutoDrawable drawable) {
+ System.out.println("Display");
+ }
+ });
+ shell.setSize(500, 500);
+ shell.open();
+ while (!shell.isDisposed()) {
+ if (!display.readAndDispatch())
+ display.sleep();
+ }
+ display.dispose();
+ }
+}