/** Selected GL profile */

public static GLProfile profile;

public PJOGL pgl;

protected GLWindow window;

protected FPSAnimator animator;

protected Rectangle screenRect;

protected PApplet sketch;

protected PGraphics graphics;

protected int sketchX;

protected int sketchY;

protected int sketchWidth0;

protected int sketchHeight0;

protected int sketchWidth;

protected int sketchHeight;

protected Display display;

protected Screen screen;

protected List<MonitorDevice> monitors;

protected MonitorDevice displayDevice;

protected Throwable drawException;

protected Object waitObject = new Object();

protected NewtCanvasAWT canvas;

protected float[] currentPixelScale = {0, 0};

protected boolean external = false;

public PSurfaceJOGL(PGraphics graphics) {

this.graphics = graphics;

this.pgl = (PJOGL) ((PGraphicsOpenGL)graphics).pgl;

}

public void initOffscreen(PApplet sketch) {

this.sketch = sketch;

sketchWidth = sketch.sketchWidth();

sketchHeight = sketch.sketchHeight();

if (window != null) {

canvas = new NewtCanvasAWT(window);

canvas.setBounds(0, 0, window.getWidth(), window.getHeight());

canvas.setFocusable(true);

}

}

public void initFrame(PApplet sketch) {

this.sketch = sketch;

initIcons();

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

File mesaLib = new File("/usr/lib/arm-linux-gnueabihf/libGLESv2.so.2");

if (mesaLib.exists()) {

System.out.println("\nIf you are receiving an error regarding the undefined symbol bcm_host_init, " +

"make sure you have the package libgles2-mesa deinstalled. This can be done " +

"by executing \"sudo aptitude remove libgles2-mesa\" in the terminal, and is " +

"a known issue with the Raspbian distribution.\n");

}

initDisplay();

initGL();

initWindow();

initListeners();

initAnimator();

}

public Object getNative() {

return window;

}

protected void initDisplay() {

Display tmpDisplay = NewtFactory.createDisplay(null);

tmpDisplay.addReference();

Screen tmpScreen = NewtFactory.createScreen(tmpDisplay, 0);

tmpScreen.addReference();

monitors = new ArrayList<MonitorDevice>();

GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();

GraphicsDevice[] awtDevices = environment.getScreenDevices();

List<MonitorDevice> newtDevices = tmpScreen.getMonitorDevices();

// AWT and NEWT name devices in different ways, depending on the platform,

// and also appear to order them in different ways. The following code

// tries to address the differences.

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

for (GraphicsDevice device: awtDevices) {

String did = device.getIDstring();

String[] parts = did.split("\\.");

String id1 = "";

if (1 < parts.length) {

id1 = parts[1].trim();

}

MonitorDevice monitor = null;

int id0 = newtDevices.size() > 0 ? newtDevices.get(0).getId() : 0;

for (int i = 0; i < newtDevices.size(); i++) {

MonitorDevice mon = newtDevices.get(i);

String mid = String.valueOf(mon.getId() - id0);

if (id1.equals(mid)) {

monitor = mon;

break;

}

}

if (monitor != null) {

monitors.add(monitor);

}

}

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

// NEWT display id is == (adapterId << 8 | monitorId),

// should be in the same order as AWT

monitors.addAll(newtDevices);

} else { // MAC OSX and others

for (GraphicsDevice device: awtDevices) {

String did = device.getIDstring();

String[] parts = did.split("Display");

String id1 = "";

if (1 < parts.length) {

id1 = parts[1].trim();

}

MonitorDevice monitor = null;

for (int i = 0; i < newtDevices.size(); i++) {

MonitorDevice mon = newtDevices.get(i);

String mid = String.valueOf(mon.getId());

if (id1.equals(mid)) {

monitor = mon;

break;

}

}

if (monitor == null) {

// Didn't find a matching monitor, try using less stringent id check

for (int i = 0; i < newtDevices.size(); i++) {

MonitorDevice mon = newtDevices.get(i);

String mid = String.valueOf(mon.getId());

if (-1 < did.indexOf(mid)) {

monitor = mon;

break;

}

}

}

if (monitor != null) {

monitors.add(monitor);

}

}

}

displayDevice = null;

int displayNum = sketch.sketchDisplay();

if (displayNum > 0) { // if -1, use the default device

if (displayNum <= monitors.size()) {

displayDevice = monitors.get(displayNum - 1);

} else {

System.err.format("Display %d does not exist, " +

"using the default display instead.%n", displayNum);

for (int i = 0; i < monitors.size(); i++) {

System.err.format("Display %d is %s%n", i+1, monitors.get(i));

}

}

} else if (0 < monitors.size()) {

displayDevice = monitors.get(0);

}

if (displayDevice != null) {

screen = displayDevice.getScreen();

display = screen.getDisplay();

} else {

screen = tmpScreen;

display = tmpDisplay;

displayDevice = screen.getPrimaryMonitor();

}

}

protected void initGL() {

if (profile == null) {

if (PJOGL.profile == 1) {

try {

profile = GLProfile.getGL2ES1();

} catch (GLException ex) {

profile = GLProfile.getMaxFixedFunc(true);

}

} else if (PJOGL.profile == 2) {

try {

profile = GLProfile.getGL2ES2();

} catch (GLException ex) {

profile = GLProfile.getMaxProgrammable(true);

}

} else if (PJOGL.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 (PJOGL.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(PGL.UNSUPPORTED_GLPROF_ERROR);

}

// Setting up the desired capabilities;

GLCapabilities caps = new GLCapabilities(profile);

caps.setAlphaBits(PGL.REQUESTED_ALPHA_BITS);

caps.setDepthBits(PGL.REQUESTED_DEPTH_BITS);

caps.setStencilBits(PGL.REQUESTED_STENCIL_BITS);

caps.setSampleBuffers(true);

caps.setNumSamples(PGL.smoothToSamples(graphics.smooth));

caps.setBackgroundOpaque(true);

caps.setOnscreen(true);

pgl.setCaps(caps);

}

protected void initWindow() {

window = GLWindow.create(screen, pgl.getCaps());

boolean spanDisplays = sketch.sketchDisplay() == PConstants.SPAN;

screenRect = spanDisplays ?

new Rectangle(0, 0, screen.getWidth(), screen.getHeight()) :

new Rectangle(0, 0,

displayDevice.getViewportInWindowUnits().getWidth(),

displayDevice.getViewportInWindowUnits().getHeight());

// Set the displayWidth/Height variables inside PApplet, so that they're

// usable and can even be returned by the sketchWidth()/Height() methods.

sketch.displayWidth = screenRect.width;

sketch.displayHeight = screenRect.height;

sketchWidth0 = sketch.sketchWidth();

sketchHeight0 = sketch.sketchHeight();

/*

sketchWidth = sketch.sketchWidth();

sketchHeight = sketch.sketchHeight();

boolean fullScreen = sketch.sketchFullScreen();

// Removing the section below because sometimes people want to do the

// full screen size in a window, and it also breaks insideSettings().

// With 3.x, fullScreen() is so easy, that it's just better that way.

// https://github.com/processing/processing/issues/3545

/*

if (fullScreen || spanDisplays) {

sketchWidth = screenRect.width;

sketchHeight = screenRect.height;

}

float[] reqSurfacePixelScale;

if (graphics.is2X()) {

// Retina

reqSurfacePixelScale = new float[] { ScalableSurface.AUTOMAX_PIXELSCALE,

ScalableSurface.AUTOMAX_PIXELSCALE };

} else {

// Non-retina

reqSurfacePixelScale = new float[] { ScalableSurface.IDENTITY_PIXELSCALE,

ScalableSurface.IDENTITY_PIXELSCALE };

}

window.setSurfaceScale(reqSurfacePixelScale);

window.setSize(sketchWidth, sketchHeight);

window.setResizable(false);

setSize(sketchWidth, sketchHeight);

sketchX = displayDevice.getViewportInWindowUnits().getX();

sketchY = displayDevice.getViewportInWindowUnits().getY();

if (fullScreen) {

PApplet.hideMenuBar();

window.setTopLevelPosition(sketchX, sketchY);

if (spanDisplays) {

window.setFullscreen(monitors);

} else {

List<MonitorDevice> display = Collections.singletonList(displayDevice);

window.setFullscreen(display);

}

}

}

protected void initListeners() {

NEWTMouseListener mouseListener = new NEWTMouseListener();

window.addMouseListener(mouseListener);

NEWTKeyListener keyListener = new NEWTKeyListener();

window.addKeyListener(keyListener);

NEWTWindowListener winListener = new NEWTWindowListener();

window.addWindowListener(winListener);

DrawListener drawlistener = new DrawListener();

window.addGLEventListener(drawlistener);

}

protected void initAnimator() {

animator = new FPSAnimator(window, 60);

drawException = null;

animator.setUncaughtExceptionHandler(new GLAnimatorControl.UncaughtExceptionHandler() {

@Override

public void uncaughtException(final GLAnimatorControl animator,

final GLAutoDrawable drawable,

final Throwable cause) {

synchronized (waitObject) {

drawException = cause;

waitObject.notify();

}

}

});

new Thread(new Runnable() {

public void run() {

synchronized (waitObject) {

try {

if (drawException == null) waitObject.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

if (drawException != null) {

Throwable cause = drawException.getCause();

if (cause instanceof ThreadDeath) {

} else if (cause instanceof RuntimeException) {

throw (RuntimeException)cause;

} else if (cause instanceof UnsatisfiedLinkError) {

throw new UnsatisfiedLinkError(cause.getMessage());

} else if (cause == null) {

throw new RuntimeException(drawException.getMessage());

} else {

throw new RuntimeException(cause);

}

}

}

}

}).start();

}

@Override

public void setTitle(final String title) {

display.getEDTUtil().invoke(false, new Runnable() {

@Override

public void run() {

window.setTitle(title);

}

});

}

@Override

public void setVisible(final boolean visible) {

display.getEDTUtil().invoke(false, new Runnable() {

@Override

public void run() {

window.setVisible(visible);

}

});

}

@Override

public void setResizable(final boolean resizable) {

display.getEDTUtil().invoke(false, new Runnable() {

@Override

public void run() {

window.setResizable(resizable);

}

});

}

public void setIcon(PImage icon) {

PGraphics.showWarning("Window icons for OpenGL sketches can only be set in settings()\n" +

"using PJOGL.setIcon(filename).");

}

@Override

public void setAlwaysOnTop(final boolean always) {

display.getEDTUtil().invoke(false, new Runnable() {

@Override

public void run() {

window.setAlwaysOnTop(always);

}

});

}

protected void initIcons() {

IOUtil.ClassResources res = null;

if (PJOGL.icons == null || PJOGL.icons.length == 0) {

// Default Processing icons

final int[] sizes = { 16, 32, 48, 64, 128, 256, 512 };

String[] iconImages = new String[sizes.length];

for (int i = 0; i < sizes.length; i++) {

iconImages[i] = "/icon/icon-" + sizes[i] + ".png";

}

res = new ClassResources(iconImages,

PApplet.class.getClassLoader(),

PApplet.class);

} else {

// Loading custom icons from user-provided files.

String[] iconImages = new String[PJOGL.icons.length];

for (int i = 0; i < PJOGL.icons.length; i++) {

iconImages[i] = resourceFilename(PJOGL.icons[i]);

}

res = new ClassResources(iconImages,

sketch.getClass().getClassLoader(),

sketch.getClass());

}

NewtFactory.setWindowIcons(res);

}

@SuppressWarnings("resource")

private String resourceFilename(String filename) {

// The code below comes from PApplet.createInputRaw() with a few adaptations

InputStream stream = null;

try {

// First see if it's in a data folder. This may fail by throwing

// a SecurityException. If so, this whole block will be skipped.

File file = new File(sketch.dataPath(filename));

if (!file.exists()) {

// next see if it's just in the sketch folder

file = sketch.sketchFile(filename);

}

if (file.exists() && !file.isDirectory()) {

try {

// handle case sensitivity check

String filePath = file.getCanonicalPath();

String filenameActual = new File(filePath).getName();

// make sure there isn't a subfolder prepended to the name

String filenameShort = new File(filename).getName();

// if the actual filename is the same, but capitalized

// differently, warn the user.

//if (filenameActual.equalsIgnoreCase(filenameShort) &&

//!filenameActual.equals(filenameShort)) {

if (!filenameActual.equals(filenameShort)) {

throw new RuntimeException("This file is named " +

filenameActual + " not " +

filename + ". Rename the file " +

"or change your code.");

}

} catch (IOException e) { }

}

stream = new FileInputStream(file);

if (stream != null) {

stream.close();

return file.getCanonicalPath();

}

// have to break these out because a general Exception might

// catch the RuntimeException being thrown above

} catch (IOException ioe) {

} catch (SecurityException se) { }

ClassLoader cl = sketch.getClass().getClassLoader();

try {

// by default, data files are exported to the root path of the jar.

// (not the data folder) so check there first.

stream = cl.getResourceAsStream("data/" + filename);

if (stream != null) {

String cn = stream.getClass().getName();

// this is an irritation of sun's java plug-in, which will return

// a non-null stream for an object that doesn't exist. like all good

// things, this is probably introduced in java 1.5. awesome!

// http://dev.processing.org/bugs/show_bug.cgi?id=359

if (!cn.equals("sun.plugin.cache.EmptyInputStream")) {

stream.close();

return "data/" + filename;

}

}

// When used with an online script, also need to check without the

// data folder, in case it's not in a subfolder called 'data'.

// http://dev.processing.org/bugs/show_bug.cgi?id=389

stream = cl.getResourceAsStream(filename);

if (stream != null) {

String cn = stream.getClass().getName();

if (!cn.equals("sun.plugin.cache.EmptyInputStream")) {

stream.close();

return filename;

}

}

} catch (IOException e) { }

try {

// attempt to load from a local file, used when running as

// an application, or as a signed applet

try { // first try to catch any security exceptions

try {

String path = sketch.dataPath(filename);

stream = new FileInputStream(path);

if (stream != null) {

stream.close();

return path;

}

} catch (IOException e2) { }

try {

String path = sketch.sketchPath(filename);

stream = new FileInputStream(path);

if (stream != null) {

stream.close();

return path;

}

} catch (Exception e) { } // ignored

try {

stream = new FileInputStream(filename);

if (stream != null) {

stream.close();

return filename;

}

} catch (IOException e1) { }

} catch (SecurityException se) { } // online, whups

} catch (Exception e) {

//die(e.getMessage(), e);

e.printStackTrace();

}

return "";

}

@Override

public void placeWindow(int[] location, int[] editorLocation) {

int x = window.getX() - window.getInsets().getLeftWidth();

int y = window.getY() - window.getInsets().getTopHeight();

int w = window.getWidth() + window.getInsets().getTotalWidth();

int h = window.getHeight() + window.getInsets().getTotalHeight();

if (location != null) {

window.setTopLevelPosition(location[0], location[1]);

} else if (editorLocation != null) {

int locationX = editorLocation[0] - 20;

int locationY = editorLocation[1];

if (locationX - w > 10) {

// if it fits to the left of the window

window.setTopLevelPosition(locationX - w, locationY);

} else { // doesn't fit

/*

locationX = (sketch.displayWidth - w) / 2;

locationY = (sketch.displayHeight - h) / 2;

/*

window.setTopLevelPosition(locationX, locationY);

}

} else { // just center on screen

// Can't use frame.setLocationRelativeTo(null) because it sends the

// frame to the main display, which undermines the --display setting.

int sketchX = displayDevice.getViewportInWindowUnits().getX();

int sketchY = displayDevice.getViewportInWindowUnits().getY();

window.setTopLevelPosition(sketchX + screenRect.x + (screenRect.width - sketchWidth) / 2,

sketchY + screenRect.y + (screenRect.height - sketchHeight) / 2);

}

Point frameLoc = new Point(x, y);

if (frameLoc.y < 0) {

// Windows actually allows you to place frames where they can't be

// closed. Awesome. http://dev.processing.org/bugs/show_bug.cgi?id=1508

window.setTopLevelPosition(frameLoc.x, 30);

}

}

public void placePresent(int stopColor) {

pgl.initPresentMode(0.5f * (screenRect.width - sketchWidth),

0.5f * (screenRect.height - sketchHeight), stopColor);

window.setSize(screenRect.width, screenRect.height);

PApplet.hideMenuBar();

window.setTopLevelPosition(sketchX + screenRect.x,

sketchY + screenRect.y);

window.setFullscreen(true);

}

public void setupExternalMessages() {

external = true;

}

public void startThread() {

if (animator != null) {

animator.start();

}

}

public void pauseThread() {

if (animator != null) {

animator.pause();

}

}

public void resumeThread() {

if (animator != null) {

animator.resume();

}

}

public boolean stopThread() {

if (animator != null) {

return animator.stop();

} else {

return false;

}

}

public boolean isStopped() {

if (animator != null) {

return !animator.isAnimating();

} else {

return true;

}

}

public void setLocation(final int x, final int y) {

display.getEDTUtil().invoke(false, new Runnable() {

@Override

public void run() {

window.setTopLevelPosition(x, y);

}

});

}

public void setSize(final int width, final int height) {

if (width == sketch.width && height == sketch.height) {

return;

}

if (!pgl.presentMode()) {

sketch.setSize(width, height);

sketchWidth = width;

sketchHeight = height;

graphics.setSize(width, height);

window.setSize(width, height);

}

}

public float getPixelScale() {

if (graphics.is2X()) {

// Even if the graphics are retina, the user might have moved the window

// into a non-retina monitor, so we need to check

window.getCurrentSurfaceScale(currentPixelScale);

return currentPixelScale[0];

} else {

return 1;

}

}

public Component getComponent() {

return canvas;

}

public void setSmooth(int level) {

pgl.reqNumSamples = level;

GLCapabilities caps = new GLCapabilities(profile);

caps.setAlphaBits(PGL.REQUESTED_ALPHA_BITS);

caps.setDepthBits(PGL.REQUESTED_DEPTH_BITS);

caps.setStencilBits(PGL.REQUESTED_STENCIL_BITS);

caps.setSampleBuffers(true);

caps.setNumSamples(pgl.reqNumSamples);

caps.setBackgroundOpaque(true);

caps.setOnscreen(true);

NativeSurface target = window.getNativeSurface();

MutableGraphicsConfiguration config = (MutableGraphicsConfiguration) target.getGraphicsConfiguration();

config.setChosenCapabilities(caps);

}

public void setFrameRate(float fps) {

if (animator != null) {

animator.stop();

animator.setFPS((int)fps);

pgl.setFps(fps);

animator.start();

}

}

public void requestFocus() {

display.getEDTUtil().invoke(false, new Runnable() {

@Override

public void run() {

window.requestFocus();

}

});

}

class DrawListener implements GLEventListener {

public void display(GLAutoDrawable drawable) {

if (display.getEDTUtil().isCurrentThreadEDT()) {

// For some reason, the first two frames of the animator are run on the

// EDT, skipping rendering Processing's frame in that case.

return;

}

if (sketch.frameCount == 0) {

if (sketchWidth < sketchWidth0 || sketchHeight < sketchHeight0) {

PGraphics.showWarning("The sketch has been automatically resized to fit the screen resolution");

}

requestFocus();

}

pgl.getGL(drawable);

int pframeCount = sketch.frameCount;

sketch.handleDraw();

if (pframeCount == sketch.frameCount) {

// This hack allows the FBO layer to be swapped normally even if

// the sketch is no looping, otherwise background artifacts will occur.

pgl.beginRender();

pgl.endRender(sketch.sketchWindowColor());

}

PGraphicsOpenGL.completeFinishedPixelTransfers();

if (sketch.exitCalled()) {

PGraphicsOpenGL.completeAllPixelTransfers();

sketch.dispose(); // calls stopThread(), which stops the animator.

sketch.exitActual();

}

}

public void dispose(GLAutoDrawable drawable) {

sketch.dispose();

}

public void init(GLAutoDrawable drawable) {

pgl.getGL(drawable);

pgl.init(drawable);

sketch.start();

int c = graphics.backgroundColor;

pgl.clearColor(((c >> 16) & 0xff) / 255f,

((c >> 8) & 0xff) / 255f,

((c >> 0) & 0xff) / 255f,

((c >> 24) & 0xff) / 255f);

pgl.clear(PGL.COLOR_BUFFER_BIT);

}

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

pgl.resetFBOLayer();

window.getCurrentSurfaceScale(currentPixelScale);

pgl.getGL(drawable);

setSize((int)(w/currentPixelScale[0]), (int)(h/currentPixelScale[1]));

}

}

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

public NEWTWindowListener() {

super();

}

@Override

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

sketch.focused = true;

sketch.focusGained();

}

@Override

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

sketch.focused = false;

sketch.focusLost();

}

@Override

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

sketch.exit();

}

@Override

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

}

@Override

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

if (external) {

sketch.frameMoved(window.getX(), window.getY());

}

}

@Override

public void windowRepaint(com.jogamp.newt.event.WindowUpdateEvent arg0) {

}

@Override

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

}

}

// NEWT mouse listener

protected class NEWTMouseListener extends com.jogamp.newt.event.MouseAdapter {

public NEWTMouseListener() {

super();

}

@Override

public void mousePressed(com.jogamp.newt.event.MouseEvent e) {

nativeMouseEvent(e, MouseEvent.PRESS);

}

@Override

public void mouseReleased(com.jogamp.newt.event.MouseEvent e) {

nativeMouseEvent(e, MouseEvent.RELEASE);

}

@Override

public void mouseClicked(com.jogamp.newt.event.MouseEvent e) {

nativeMouseEvent(e, MouseEvent.CLICK);

}

@Override

public void mouseDragged(com.jogamp.newt.event.MouseEvent e) {

nativeMouseEvent(e, MouseEvent.DRAG);

}

@Override

public void mouseMoved(com.jogamp.newt.event.MouseEvent e) {

nativeMouseEvent(e, MouseEvent.MOVE);