package processing.opengl;

import java.awt.BorderLayout;

import java.awt.Canvas;

import java.awt.Color;

import java.awt.FontMetrics;

import java.io.IOException;

import java.net.URL;

import java.nio.Buffer;

import java.nio.ByteBuffer;

import java.nio.FloatBuffer;

import java.nio.IntBuffer;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;

import javax.media.nativewindow.ScalableSurface;

import javax.media.opengl.GL;

import javax.media.opengl.GL2;

import javax.media.opengl.GL2ES1;

import javax.media.opengl.GL2ES2;

import javax.media.opengl.GL2ES3;

import javax.media.opengl.GL2GL3;

import javax.media.opengl.GLAutoDrawable;

import javax.media.opengl.GLCapabilities;

import javax.media.opengl.GLCapabilitiesImmutable;

import javax.media.opengl.GLContext;

import javax.media.opengl.GLDrawable;

import javax.media.opengl.GLEventListener;

import javax.media.opengl.GLException;

import javax.media.opengl.GLFBODrawable;

import javax.media.opengl.GLProfile;

import javax.media.opengl.awt.GLCanvas;

import javax.media.opengl.fixedfunc.GLMatrixFunc;

import javax.media.opengl.glu.GLU;

import processing.core.PApplet;

import processing.core.PConstants;

import processing.core.PGraphics;

import processing.event.KeyEvent;

import processing.event.MouseEvent;

import com.jogamp.newt.awt.NewtCanvasAWT;

import com.jogamp.newt.event.InputEvent;

import com.jogamp.newt.opengl.GLWindow;

import com.jogamp.opengl.FBObject;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.Shape;

import java.awt.font.FontRenderContext;

import java.awt.font.GlyphVector;

import java.awt.geom.PathIterator;

import javax.media.opengl.glu.GLUtessellator;

import javax.media.opengl.glu.GLUtessellatorCallbackAdapter;

public class PJOGL extends PGL {

// OpenGL profile to use (2, 3 or 4)

public static int PROFILE = 2;

// Enables/disables Retina support on OSX

public static boolean RETINA = false;

// The two windowing toolkits available to use in JOGL:

public static final int AWT = 0; // http://jogamp.org/wiki/index.php/Using_JOGL_in_AWT_SWT_and_Swing

public static final int NEWT = 1; // http://jogamp.org/jogl/doc/NEWT-Overview.html

// ........................................................

// Public members to access the underlying GL objects and context

/** Basic GL functionality, common to all profiles */

public GL gl;

/** GLU interface **/

public GLU glu;

/** The rendering context (holds rendering state info) */

public GLContext context;

/** The canvas where OpenGL rendering takes place */

public Canvas canvas;

/** Selected GL profile */

public static GLProfile profile;

// ........................................................

// Additional parameters

/** Time that the Processing's animation thread will wait for JOGL's rendering

* thread to be done with a single frame.

*/

protected static int DRAW_TIMEOUT_MILLIS = 500;

// ........................................................

// OS-specific configuration

protected static int WINDOW_TOOLKIT;

protected static int EVENTS_TOOLKIT;

protected static boolean USE_JOGL_FBOLAYER;

static {

if (PApplet.platform == PConstants.WINDOWS) {

// Using AWT on Windows because NEWT displays a black background while

// initializing, and the cursor functions don't work. GLWindow has some

// functions for basic cursor handling (hide/show):

// GLWindow.setPointerVisible(false);

// but apparently nothing to set the cursor icon:

// https://jogamp.org/bugzilla/show_bug.cgi?id=409

WINDOW_TOOLKIT = AWT;

EVENTS_TOOLKIT = AWT;

USE_FBOLAYER_BY_DEFAULT = false;

USE_JOGL_FBOLAYER = false;

} else if (PApplet.platform == PConstants.MACOSX) {

// Note: The JOGL FBO layer (in 2.0.2) seems incompatible with NEWT.

WINDOW_TOOLKIT = AWT;

EVENTS_TOOLKIT = AWT;

USE_FBOLAYER_BY_DEFAULT = true;

USE_JOGL_FBOLAYER = true;

} else if (PApplet.platform == PConstants.LINUX) {

WINDOW_TOOLKIT = AWT;

EVENTS_TOOLKIT = AWT;

USE_FBOLAYER_BY_DEFAULT = false;

USE_JOGL_FBOLAYER = false;

} else if (PApplet.platform == PConstants.OTHER) {

WINDOW_TOOLKIT = NEWT; // NEWT works on the Raspberry pi?

EVENTS_TOOLKIT = NEWT;

USE_FBOLAYER_BY_DEFAULT = false;

USE_JOGL_FBOLAYER = false;

}

}

// ........................................................

// Protected JOGL-specific objects needed to access the GL profiles

/** The capabilities of the OpenGL rendering surface */

protected GLCapabilitiesImmutable capabilities;

/** The rendering surface */

protected GLDrawable drawable;

/** GLES2 functionality (shaders, etc) */

protected GL2ES2 gl2;

/** GL3 interface */

protected GL2GL3 gl3;

/** GL2 desktop functionality (blit framebuffer, map buffer range,

* multisampled renerbuffers) */

protected GL2 gl2x;

/** The AWT-OpenGL canvas */

protected GLCanvas canvasAWT;

/** The NEWT window */

protected GLWindow windowNEWT;

/** The NEWT-OpenGL canvas */

protected NewtCanvasAWT canvasNEWT;

/** The listener that fires the frame rendering in Processing */

protected PGLListener listener;

/** This countdown latch is used to maintain the synchronization between

* Processing's drawing thread and JOGL's rendering thread */

protected CountDownLatch drawLatch = new CountDownLatch(0);

/** Flag used to do request final display() call to make sure that the

* buffers are properly swapped.

*/

protected boolean prevCanDraw = false;

// ........................................................

// JOGL's FBO-layer

/** Back (== draw, current frame) buffer */

protected FBObject backFBO;

/** Sink buffer, used in the multisampled case */

protected FBObject sinkFBO;

/** Front (== read, previous frame) buffer */

protected FBObject frontFBO;

protected FBObject.TextureAttachment backTexAttach;

protected FBObject.TextureAttachment frontTexAttach;

protected boolean changedFrontTex = false;

protected boolean changedBackTex = false;

// ........................................................

// Retina support

int retf = 1;

// ........................................................

// Utility arrays to copy projection/modelview matrices to GL

protected float[] projMatrix;

protected float[] mvMatrix;

// ........................................................

// Static initialization for some parameters that need to be different for

// JOGL

static {

MIN_DIRECT_BUFFER_SIZE = 2;

INDEX_TYPE = GL.GL_UNSIGNED_SHORT;

}

///////////////////////////////////////////////////////////////

// Initialization, finalization

public PJOGL(PGraphicsOpenGL pg) {

super(pg);

glu = new GLU();

}

@Override

public Canvas getCanvas() {

return canvas;

}

@Override

protected void setFps(float fps) {

if (!setFps || targetFps != fps) {

if (60 < fps) {

// Disables v-sync

gl.setSwapInterval(0);

} else if (30 < fps) {

gl.setSwapInterval(1);

} else {

gl.setSwapInterval(2);

}

targetFps = currentFps = fps;

setFps = true;

}

}

@Override

protected void initSurface(int antialias) {

if (profile == null) {

if (PROFILE == 2) {

try {

profile = GLProfile.getGL2ES1();

} catch (GLException ex) {

profile = GLProfile.getMaxFixedFunc(true);

}

} else if (PROFILE == 3) {

try {

profile = GLProfile.getGL2GL3();

} catch (GLException ex) {

profile = GLProfile.getMaxProgrammable(true);

}

if (!profile.isGL3()) {

PGraphics.showWarning("Requested profile GL3 but is not available, got: " + profile);

}

} else if (PROFILE == 4) {

try {

profile = GLProfile.getGL4ES3();

} catch (GLException ex) {

profile = GLProfile.getMaxProgrammable(true);

}

if (!profile.isGL4()) {

PGraphics.showWarning("Requested profile GL4 but is not available, got: " + profile);

}

} else throw new RuntimeException(UNSUPPORTED_GLPROF_ERROR);

if (2 < PROFILE) {

texVertShaderSource = convertVertexSource(texVertShaderSource, 120, 150);

tex2DFragShaderSource = convertFragmentSource(tex2DFragShaderSource, 120, 150);

texRectFragShaderSource = convertFragmentSource(texRectFragShaderSource, 120, 150);

}

}

if (canvasAWT != null || canvasNEWT != null) {

// Restarting...

if (canvasAWT != null) {

canvasAWT.removeGLEventListener(listener);

pg.parent.removeListeners(canvasAWT);

pg.parent.remove(canvasAWT);

} else if (canvasNEWT != null) {

windowNEWT.removeGLEventListener(listener);

pg.parent.remove(canvasNEWT);

}

sinkFBO = backFBO = frontFBO = null;

}

// Setting up the desired capabilities;

GLCapabilities caps = new GLCapabilities(profile);

caps.setAlphaBits(REQUESTED_ALPHA_BITS);

caps.setDepthBits(REQUESTED_DEPTH_BITS);

caps.setStencilBits(REQUESTED_STENCIL_BITS);

caps.setBackgroundOpaque(true);

caps.setOnscreen(true);

if (USE_FBOLAYER_BY_DEFAULT) {

if (USE_JOGL_FBOLAYER) {

caps.setPBuffer(false);

caps.setFBO(true);

if (1 < antialias) {

caps.setSampleBuffers(true);

caps.setNumSamples(antialias);

} else {

caps.setSampleBuffers(false);

}

fboLayerRequested = false;

} else {

caps.setPBuffer(false);

caps.setFBO(false);

caps.setSampleBuffers(false);

fboLayerRequested = 1 < antialias;

}

} else {

if (1 < antialias) {

caps.setSampleBuffers(true);

caps.setNumSamples(antialias);

} else {

caps.setSampleBuffers(false);

}

fboLayerRequested = false;

}

caps.setDepthBits(REQUESTED_DEPTH_BITS);

caps.setStencilBits(REQUESTED_STENCIL_BITS);

caps.setAlphaBits(REQUESTED_ALPHA_BITS);

reqNumSamples = qualityToSamples(antialias);

if (WINDOW_TOOLKIT == AWT) {

canvasAWT = new GLCanvas(caps);

if (RETINA) {

canvasAWT.setSurfaceScale(new int[] { ScalableSurface.AUTOMAX_PIXELSCALE,

ScalableSurface.AUTOMAX_PIXELSCALE });

retf = 2;

} else {

canvasAWT.setSurfaceScale(new int[] { ScalableSurface.IDENTITY_PIXELSCALE,

ScalableSurface.IDENTITY_PIXELSCALE });

}

canvasAWT.setBounds(0, 0, pg.width, pg.height);

canvasAWT.setBackground(new Color(pg.backgroundColor, true));

canvasAWT.setFocusable(true);

pg.parent.setLayout(new BorderLayout());

pg.parent.add(canvasAWT, BorderLayout.CENTER);

canvasAWT.requestFocusInWindow();

canvas = canvasAWT;

canvasNEWT = null;

} else if (WINDOW_TOOLKIT == NEWT) {

windowNEWT = GLWindow.create(caps);

canvasNEWT = new NewtCanvasAWT(windowNEWT);

canvasNEWT.setBounds(0, 0, pg.width, pg.height);

canvasNEWT.setBackground(new Color(pg.backgroundColor, true));

canvasNEWT.setFocusable(true);

pg.parent.setLayout(new BorderLayout());

pg.parent.add(canvasNEWT, BorderLayout.CENTER);

canvasNEWT.requestFocusInWindow();

int[] reqSurfacePixelScale = new int[] { ScalableSurface.AUTOMAX_PIXELSCALE, ScalableSurface.AUTOMAX_PIXELSCALE };

windowNEWT.setSurfaceScale(reqSurfacePixelScale);

canvas = canvasNEWT;

canvasAWT = null;

}

pg.parent.defaultSize = false;

registerListeners();

fboLayerCreated = false;

fboLayerInUse = false;

firstFrame = true;

setFps = false;

}

@Override

protected void reinitSurface() {

sinkFBO = backFBO = frontFBO = null;

fboLayerCreated = false;

fboLayerInUse = false;

firstFrame = true;

pg.parent.defaultSize = false;

}

@Override

protected void registerListeners() {

if (WINDOW_TOOLKIT == AWT) {

pg.parent.addListeners(canvasAWT);

listener = new PGLListener();

canvasAWT.addGLEventListener(listener);

} else if (WINDOW_TOOLKIT == NEWT) {

if (EVENTS_TOOLKIT == NEWT) {

NEWTMouseListener mouseListener = new NEWTMouseListener();

windowNEWT.addMouseListener(mouseListener);

NEWTKeyListener keyListener = new NEWTKeyListener();

windowNEWT.addKeyListener(keyListener);

NEWTWindowListener winListener = new NEWTWindowListener();

windowNEWT.addWindowListener(winListener);

} else if (EVENTS_TOOLKIT == AWT) {

pg.parent.addListeners(canvasNEWT);

}

listener = new PGLListener();

windowNEWT.addGLEventListener(listener);

}

if (canvas != null) {

canvas.setFocusTraversalKeysEnabled(false);

}

}

@Override

protected void deleteSurface() {

super.deleteSurface();

if (canvasAWT != null) {

canvasAWT.removeGLEventListener(listener);

pg.parent.removeListeners(canvasAWT);

} else if (canvasNEWT != null) {

windowNEWT.removeGLEventListener(listener);

}

}

@Override

protected int getReadFramebuffer() {

if (fboLayerInUse) {

return glColorFbo.get(0);

} else if (capabilities.isFBO()) {

return context.getDefaultReadFramebuffer();

} else {

return 0;

}

}

@Override

protected int getDrawFramebuffer() {

if (fboLayerInUse) {

if (1 < numSamples) {

return glMultiFbo.get(0);

} else {

return glColorFbo.get(0);

}

} else if (capabilities.isFBO()) {

return context.getDefaultDrawFramebuffer();

} else {

return 0;

}

}

@Override

protected int getDefaultDrawBuffer() {

if (fboLayerInUse) {

return COLOR_ATTACHMENT0;

} else if (capabilities.isFBO()) {

return GL.GL_COLOR_ATTACHMENT0;

} else if (capabilities.getDoubleBuffered()) {

return GL.GL_BACK;

} else {

return GL.GL_FRONT;

}

}

@Override

protected int getDefaultReadBuffer() {

if (fboLayerInUse) {

return COLOR_ATTACHMENT0;

} else if (capabilities.isFBO()) {

return GL.GL_COLOR_ATTACHMENT0;

} else if (capabilities.getDoubleBuffered()) {

return GL.GL_BACK;

} else {

return GL.GL_FRONT;

}

}

@Override

protected boolean isFBOBacked() {

return super.isFBOBacked() || capabilities.isFBO();

}

@Override

protected int getDepthBits() {

return capabilities.getDepthBits();

}

@Override

protected int getStencilBits() {

return capabilities.getStencilBits();

}

@Override

protected Texture wrapBackTexture(Texture texture) {

if (texture == null || changedBackTex) {

if (USE_JOGL_FBOLAYER) {

texture = new Texture(pg);

texture.init(pg.width, pg.height,

backTexAttach.getName(), TEXTURE_2D, RGBA,

backTexAttach.getWidth(), backTexAttach.getHeight(),

backTexAttach.minFilter, backTexAttach.magFilter,

backTexAttach.wrapS, backTexAttach.wrapT);

texture.invertedY(true);

texture.colorBuffer(true);

pg.setCache(pg, texture);

} else {

texture = super.wrapBackTexture(null);

}

} else {

if (USE_JOGL_FBOLAYER) {

texture.glName = backTexAttach.getName();

} else {

texture = super.wrapBackTexture(texture);

}

}

return texture;

}

@Override

protected Texture wrapFrontTexture(Texture texture) {

if (texture == null || changedFrontTex) {

if (USE_JOGL_FBOLAYER) {

texture = new Texture(pg);

texture.init(pg.width, pg.height,

backTexAttach.getName(), TEXTURE_2D, RGBA,

frontTexAttach.getWidth(), frontTexAttach.getHeight(),

frontTexAttach.minFilter, frontTexAttach.magFilter,

frontTexAttach.wrapS, frontTexAttach.wrapT);

texture.invertedY(true);

texture.colorBuffer(true);

} else {

texture = super.wrapFrontTexture(null);

}

} else {

if (USE_JOGL_FBOLAYER) {

texture.glName = frontTexAttach.getName();

} else {

texture = super.wrapFrontTexture(texture);

}

}

return texture;

}

@Override

protected void bindFrontTexture() {

if (USE_JOGL_FBOLAYER) {

usingFrontTex = true;

if (!texturingIsEnabled(TEXTURE_2D)) {

enableTexturing(TEXTURE_2D);

}

bindTexture(TEXTURE_2D, frontTexAttach.getName());

} else super.bindFrontTexture();

}

@Override

protected void unbindFrontTexture() {

if (USE_JOGL_FBOLAYER) {

if (textureIsBound(TEXTURE_2D, frontTexAttach.getName())) {

// We don't want to unbind another texture

// that might be bound instead of this one.

if (!texturingIsEnabled(TEXTURE_2D)) {

enableTexturing(TEXTURE_2D);

bindTexture(TEXTURE_2D, 0);

disableTexturing(TEXTURE_2D);

} else {

bindTexture(TEXTURE_2D, 0);

}

}

} else super.unbindFrontTexture();

}

@Override

protected void syncBackTexture() {

if (USE_JOGL_FBOLAYER) {

if (usingFrontTex) needSepFrontTex = true;

if (1 < numSamples && backFBO != null) {

backFBO.syncSamplingSink(gl);

backFBO.bind(gl);

}

} else super.syncBackTexture();

}

@Override

protected void beginDraw(boolean clear0) {

if (!setFps) setFps(targetFps);

if (USE_JOGL_FBOLAYER) return;

super.beginDraw(clear0);

}

@Override

protected void endDraw(boolean clear0) {

if (isFBOBacked()) {

if (USE_JOGL_FBOLAYER) {

if (!clear0 && isFBOBacked() && !isMultisampled() &&

frontFBO != null && backFBO != null) {

// Draw the back texture into the front texture, which will be used as

// back texture in the next frame. Otherwise flickering will occur if

// the sketch uses "incremental drawing" (background() not called).

frontFBO.bind(gl);

gl.glDisable(GL.GL_BLEND);

drawTexture(TEXTURE_2D, backTexAttach.getName(),

backTexAttach.getWidth(), backTexAttach.getHeight(),

pg.width, pg.height,

0, 0, pg.width, pg.height, 0, 0, pg.width, pg.height);

backFBO.bind(gl);

}

} else {

super.endDraw(clear0);

}

}

}

@Override

protected void getGL(PGL pgl) {

PJOGL pjogl = (PJOGL)pgl;

this.drawable = pjogl.drawable;

this.context = pjogl.context;

this.glContext = pjogl.glContext;

this.glThread = pjogl.glThread;

this.gl = pjogl.gl;

this.gl2 = pjogl.gl2;

this.gl2x = pjogl.gl2x;

this.gl3 = pjogl.gl3;

}

protected void getGL(GLAutoDrawable glDrawable) {

context = glDrawable.getContext();

glContext = context.hashCode();

glThread = Thread.currentThread();

gl = context.getGL();

gl2 = gl.getGL2ES2();

try {

gl2x = gl.getGL2();

} catch (javax.media.opengl.GLException e) {

gl2x = null;

}

try {

gl3 = gl.getGL2GL3();

} catch (javax.media.opengl.GLException e) {

gl3 = null;

}

}

@Override

protected boolean canDraw() {

return pg.initialized && pg.parent.isDisplayable();

}

@Override

protected void requestFocus() { }

@Override

protected void requestDraw() {

boolean canDraw = pg.parent.canDraw();

if (pg.initialized && (canDraw || prevCanDraw)) {

try {

drawLatch = new CountDownLatch(1);

if (WINDOW_TOOLKIT == AWT) {

canvasAWT.display();

} else if (WINDOW_TOOLKIT == NEWT) {

windowNEWT.display();

}

try {

drawLatch.await(DRAW_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);

} catch (InterruptedException e) {

e.printStackTrace();

}

if (canDraw) prevCanDraw = true;

else prevCanDraw = false;

} catch (GLException e) {

// Unwrap GLException so that only the causing exception is shown.

Throwable tr = e.getCause();

if (tr instanceof RuntimeException) {

throw (RuntimeException)tr;

} else {

throw new RuntimeException(tr);

}

}

}

}

@Override

protected void swapBuffers() {

if (WINDOW_TOOLKIT == AWT) {

canvasAWT.swapBuffers();

} else if (WINDOW_TOOLKIT == NEWT) {

windowNEWT.swapBuffers();

}

}

@Override

protected void beginGL() {

if (gl2x != null) {

if (projMatrix == null) {

projMatrix = new float[16];

}

gl2x.glMatrixMode(GLMatrixFunc.GL_PROJECTION);

projMatrix[ 0] = pg.projection.m00;

projMatrix[ 1] = pg.projection.m10;

projMatrix[ 2] = pg.projection.m20;

projMatrix[ 3] = pg.projection.m30;

projMatrix[ 4] = pg.projection.m01;

projMatrix[ 5] = pg.projection.m11;

projMatrix[ 6] = pg.projection.m21;

projMatrix[ 7] = pg.projection.m31;

projMatrix[ 8] = pg.projection.m02;

projMatrix[ 9] = pg.projection.m12;

projMatrix[10] = pg.projection.m22;

projMatrix[11] = pg.projection.m32;

projMatrix[12] = pg.projection.m03;

projMatrix[13] = pg.projection.m13;

projMatrix[14] = pg.projection.m23;

projMatrix[15] = pg.projection.m33;

gl2x.glLoadMatrixf(projMatrix, 0);

if (mvMatrix == null) {

mvMatrix = new float[16];

}

gl2x.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);

mvMatrix[ 0] = pg.modelview.m00;

mvMatrix[ 1] = pg.modelview.m10;

mvMatrix[ 2] = pg.modelview.m20;

mvMatrix[ 3] = pg.modelview.m30;

mvMatrix[ 4] = pg.modelview.m01;

mvMatrix[ 5] = pg.modelview.m11;

mvMatrix[ 6] = pg.modelview.m21;

mvMatrix[ 7] = pg.modelview.m31;

mvMatrix[ 8] = pg.modelview.m02;

mvMatrix[ 9] = pg.modelview.m12;

mvMatrix[10] = pg.modelview.m22;

mvMatrix[11] = pg.modelview.m32;

mvMatrix[12] = pg.modelview.m03;

mvMatrix[13] = pg.modelview.m13;

mvMatrix[14] = pg.modelview.m23;

mvMatrix[15] = pg.modelview.m33;

gl2x.glLoadMatrixf(mvMatrix, 0);

}

}

@Override

protected boolean hasFBOs() {

if (context.hasBasicFBOSupport()) return true;

else return super.hasFBOs();

}

@Override

protected boolean hasShaders() {

if (context.hasGLSL()) return true;

else return super.hasShaders();

}

///////////////////////////////////////////////////////////

// JOGL event listeners

protected class PGLListener implements GLEventListener {

public PGLListener() {}

@Override

public void display(GLAutoDrawable glDrawable) {

getGL(glDrawable);

if (USE_JOGL_FBOLAYER && capabilities.isFBO()) {

// The onscreen drawing surface is backed by an FBO layer.

GLFBODrawable fboDrawable = null;

if (WINDOW_TOOLKIT == AWT) {

GLCanvas glCanvas = (GLCanvas)glDrawable;

fboDrawable = (GLFBODrawable)glCanvas.getDelegatedDrawable();

} else {

GLWindow glWindow = (GLWindow)glDrawable;

fboDrawable = (GLFBODrawable)glWindow.getDelegatedDrawable();

}

if (fboDrawable != null) {

backFBO = fboDrawable.getFBObject(GL.GL_BACK);

if (1 < numSamples) {

if (needSepFrontTex) {

// When using multisampled FBO, the back buffer is the MSAA

// surface so it cannot be read from. The sink buffer contains

// the readable 2D texture.

// In this case, we create an auxiliary "front" buffer that it is

// swapped with the sink buffer at the beginning of each frame.

// In this way, we always have a readable copy of the previous

// frame in the front texture, while the back is synchronized

// with the contents of the MSAA back buffer when requested.

if (frontFBO == null) {

// init

frontFBO = new FBObject();

frontFBO.reset(gl, pg.width, pg.height);

frontFBO.attachTexture2D(gl, 0, true);

sinkFBO = backFBO.getSamplingSinkFBO();

changedFrontTex = changedBackTex = true;

} else {

// swap

FBObject temp = sinkFBO;

sinkFBO = frontFBO;

frontFBO = temp;

backFBO.setSamplingSink(sinkFBO);

changedFrontTex = changedBackTex = false;

}

backTexAttach = (FBObject.TextureAttachment) sinkFBO.

getColorbuffer(0);

frontTexAttach = (FBObject.TextureAttachment)frontFBO.

getColorbuffer(0);

} else {

changedFrontTex = changedBackTex = sinkFBO == null;

// Default setting (to save resources): the front and back

// textures are the same.

sinkFBO = backFBO.getSamplingSinkFBO();

backTexAttach = (FBObject.TextureAttachment) sinkFBO.

getColorbuffer(0);

frontTexAttach = backTexAttach;

}

} else {

// w/out multisampling, rendering is done on the back buffer.

frontFBO = fboDrawable.getFBObject(GL.GL_FRONT);

backTexAttach = (FBObject.TextureAttachment) backFBO.getColorbuffer(0);

frontTexAttach = (FBObject.TextureAttachment) frontFBO.getColorbuffer(0);

}

}

}

pg.parent.handleDraw();

drawLatch.countDown();

}

@Override

public void dispose(GLAutoDrawable adrawable) {

}

@Override

public void init(GLAutoDrawable glDrawable) {

getGL(glDrawable);

capabilities = glDrawable.getChosenGLCapabilities();

if (!hasFBOs()) {

throw new RuntimeException(MISSING_FBO_ERROR);

}

if (!hasShaders()) {

throw new RuntimeException(MISSING_GLSL_ERROR);

}

if (USE_JOGL_FBOLAYER && capabilities.isFBO()) {

int maxs = maxSamples();

numSamples = PApplet.min(capabilities.getNumSamples(), maxs);

}

}

@Override

public void reshape(GLAutoDrawable glDrawable, int x, int y, int w, int h) {

//getGL(glDrawable);

}

// private void getGL(GLAutoDrawable glDrawable) {

// drawable = glDrawable;

// context = glDrawable.getContext();

// glContext = context.hashCode();

// glThread = Thread.currentThread();

//

// gl = context.getGL();

// gl2 = gl.getGL2ES2();

// try {

// gl2x = gl.getGL2();

// } catch (javax.media.opengl.GLException e) {

// gl2x = null;

// }

// try {

// gl3 = gl.getGL2GL3();

// } catch (javax.media.opengl.GLException e) {

// gl3 = null;

// }

// }

}

protected void nativeMouseEvent(com.jogamp.newt.event.MouseEvent nativeEvent,

int peAction) {

int modifiers = nativeEvent.getModifiers();

int peModifiers = modifiers &

(InputEvent.SHIFT_MASK |

InputEvent.CTRL_MASK |

InputEvent.META_MASK |

InputEvent.ALT_MASK);

int peButton = 0;

if ((modifiers & InputEvent.BUTTON1_MASK) != 0) {

peButton = PConstants.LEFT;

} else if ((modifiers & InputEvent.BUTTON2_MASK) != 0) {

peButton = PConstants.CENTER;

} else if ((modifiers & InputEvent.BUTTON3_MASK) != 0) {

peButton = PConstants.RIGHT;

}

if (PApplet.platform == PConstants.MACOSX) {

//if (nativeEvent.isPopupTrigger()) {

if ((modifiers & InputEvent.CTRL_MASK) != 0) {

peButton = PConstants.RIGHT;

}

}

int peCount = 0;

if (peAction == MouseEvent.WHEEL) {

peCount = nativeEvent.isShiftDown() ? (int)nativeEvent.getRotation()[0] :

(int)nativeEvent.getRotation()[1];

} else {

peCount = nativeEvent.getClickCount();

}

MouseEvent me = new MouseEvent(nativeEvent, nativeEvent.getWhen(),

peAction, peModifiers,

nativeEvent.getX(), nativeEvent.getY(),

peButton,

peCount);

pg.parent.postEvent(me);

}

protected void nativeKeyEvent(com.jogamp.newt.event.KeyEvent nativeEvent,

int peAction) {

int peModifiers = nativeEvent.getModifiers() &

(InputEvent.SHIFT_MASK |

InputEvent.CTRL_MASK |

InputEvent.META_MASK |

InputEvent.ALT_MASK);

char keyChar;

if (nativeEvent.getKeyChar() == 0) {

keyChar = PConstants.CODED;

} else {

keyChar = nativeEvent.getKeyChar();

}

KeyEvent ke = new KeyEvent(nativeEvent, nativeEvent.getWhen(),

peAction, peModifiers,

keyChar,

nativeEvent.getKeyCode());

pg.parent.postEvent(ke);

}

protected class NEWTWindowListener implements com.jogamp.newt.event.WindowListener {

public NEWTWindowListener() {

super();

}

@Override

public void windowGainedFocus(com.jogamp.newt.event.WindowEvent arg0) {

pg.parent.focusGained(null);

}

@Override

public void windowLostFocus(com.jogamp.newt.event.WindowEvent arg0) {

pg.parent.focusLost(null);

}

@Override

public void windowDestroyNotify(com.jogamp.newt.event.WindowEvent arg0) {

}