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

// Basic fields

/** The PGraphics and PApplet objects using this interface */

protected PGraphicsOpenGL graphics;

protected PApplet sketch;

/** OpenGL thread */

protected Thread glThread;

/** ID of the GL context associated to the surface **/

protected int glContext;

/** true if this is the GL interface for a primary surface PGraphics */

public boolean primaryPGL;

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

// Parameters

public static int REQUESTED_DEPTH_BITS = 24;

public static int REQUESTED_STENCIL_BITS = 8;

public static int REQUESTED_ALPHA_BITS = 8;

/** Switches between the use of regular and direct buffers. */

protected static boolean USE_DIRECT_BUFFERS = true;

protected static int MIN_DIRECT_BUFFER_SIZE = 1;

/** Enables/disables mipmap use. */

protected static boolean MIPMAPS_ENABLED = true;

/** Initial sizes for arrays of input and tessellated data. */

protected static int DEFAULT_IN_VERTICES = 64;

protected static int DEFAULT_IN_EDGES = 128;

protected static int DEFAULT_IN_TEXTURES = 64;

protected static int DEFAULT_TESS_VERTICES = 64;

protected static int DEFAULT_TESS_INDICES = 128;

/** Maximum lights by default is 8, the minimum defined by OpenGL. */

protected static int MAX_LIGHTS = 8;

/** Maximum index value of a tessellated vertex. GLES restricts the vertex

protected static int MAX_VERTEX_INDEX = 32767;

protected static int MAX_VERTEX_INDEX1 = MAX_VERTEX_INDEX + 1;

/** Count of tessellated fill, line or point vertices that will

protected static int FLUSH_VERTEX_COUNT = MAX_VERTEX_INDEX1;

/** Minimum/maximum dimensions of a texture used to hold font data. */

protected static int MIN_FONT_TEX_SIZE = 256;

protected static int MAX_FONT_TEX_SIZE = 1024;

/** Minimum stroke weight needed to apply the full path stroking

protected static float MIN_CAPS_JOINS_WEIGHT = 2f;

/** Maximum length of linear paths to be stroked with the

protected static int MAX_CAPS_JOINS_LENGTH = 5000;

/** Minimum array size to use arrayCopy method(). */

protected static int MIN_ARRAYCOPY_SIZE = 2;

/** Factor used to displace the stroke vertices towards the camera in

protected static float STROKE_DISPLACEMENT = 0.999f;

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

// Variables to handle single-buffered situations (i.e.: Android)

protected IntBuffer firstFrame;

protected static boolean SINGLE_BUFFERED = false;

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

// FBO layer

protected boolean fboLayerEnabled = false;

protected boolean fboLayerCreated = false;

protected boolean fboLayerEnabledReq = false;

protected boolean fboLayerDisableReq = false;

protected boolean fbolayerResetReq = false;

public int reqNumSamples;

protected int numSamples;

protected IntBuffer glColorFbo;

protected IntBuffer glColorTex;

protected IntBuffer glDepthStencil;

protected IntBuffer glDepth;

protected IntBuffer glStencil;

protected IntBuffer glMultiFbo;

protected IntBuffer glMultiColor;

protected IntBuffer glMultiDepthStencil;

protected IntBuffer glMultiDepth;

protected IntBuffer glMultiStencil;

protected int fboWidth, fboHeight;

protected int backTex, frontTex;

/** Flags used to handle the creation of a separate front texture */

protected boolean usingFrontTex = false;

protected boolean needSepFrontTex = false;

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

// Texture rendering

protected boolean loadedTex2DShader = false;

protected int tex2DShaderProgram;

protected int tex2DVertShader;

protected int tex2DFragShader;

protected int tex2DShaderContext;

protected int tex2DVertLoc;

protected int tex2DTCoordLoc;

protected int tex2DSamplerLoc;

protected int tex2DGeoVBO;

protected boolean loadedTexRectShader = false;

protected int texRectShaderProgram;

protected int texRectVertShader;

protected int texRectFragShader;

protected int texRectShaderContext;

protected int texRectVertLoc;

protected int texRectTCoordLoc;

protected int texRectSamplerLoc;

protected int texRectGeoVBO;

protected float[] texCoords = {

// X, Y, U, V

-1.0f, -1.0f, 0.0f, 0.0f,

+1.0f, -1.0f, 1.0f, 0.0f,

-1.0f, +1.0f, 0.0f, 1.0f,

+1.0f, +1.0f, 1.0f, 1.0f

};

protected FloatBuffer texData;

protected static final String SHADER_PREPROCESSOR_DIRECTIVE =

"#ifdef GL_ES\n" +

"precision mediump float;\n" +

"precision mediump int;\n" +

"#endif\n";

protected static String[] texVertShaderSource = {

"attribute vec2 position;",

"attribute vec2 texCoord;",

"varying vec2 vertTexCoord;",

"void main() {",

" gl_Position = vec4(position, 0, 1);",

" vertTexCoord = texCoord;",

"}"

};

protected static String[] tex2DFragShaderSource = {

SHADER_PREPROCESSOR_DIRECTIVE,

"uniform sampler2D texMap;",

"varying vec2 vertTexCoord;",

"void main() {",

" gl_FragColor = texture2D(texMap, vertTexCoord.st);",

"}"

};

protected static String[] texRectFragShaderSource = {

SHADER_PREPROCESSOR_DIRECTIVE,

"uniform sampler2DRect texMap;",

"varying vec2 vertTexCoord;",

"void main() {",

" gl_FragColor = texture2DRect(texMap, vertTexCoord.st);",

"}"

};

/** Which texturing targets are enabled */

protected boolean[] texturingTargets = { false, false };

/** Used to keep track of which textures are bound to each target */

protected int maxTexUnits;

protected int activeTexUnit = 0;

protected int[][] boundTextures;

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

// Framerate handling

protected float targetFps = 60;

protected float currentFps = 60;

protected boolean setFps = false;

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

// Utility buffers

protected ByteBuffer byteBuffer;

protected IntBuffer intBuffer;

protected IntBuffer viewBuffer;

protected IntBuffer colorBuffer;

protected FloatBuffer depthBuffer;

protected ByteBuffer stencilBuffer;

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

// Rendering information

/** Used to register amount of geometry rendered in each frame. */

protected int geomCount = 0;

protected int pgeomCount;

/** Used to register calls to background. */

protected boolean clearColor = false;

protected boolean pclearColor;

protected boolean clearDepth = false;

protected boolean pclearDepth;

protected boolean clearStencil = false;

protected boolean pclearStencil;

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

// Error messages

public static final String WIKI =

" Read http://wiki.processing.org/w/OpenGL_Issues for help.";

public static final String FRAMEBUFFER_ERROR =

"Framebuffer error (%1$s), rendering will probably not work as expected" + WIKI;

public static final String MISSING_FBO_ERROR =

"Framebuffer objects are not supported by this hardware (or driver)" + WIKI;

public static final String MISSING_GLSL_ERROR =

"GLSL shaders are not supported by this hardware (or driver)" + WIKI;

public static final String MISSING_GLFUNC_ERROR =

"GL function %1$s is not available on this hardware (or driver)" + WIKI;

public static final String UNSUPPORTED_GLPROF_ERROR =

"Unsupported OpenGL profile.";

public static final String TEXUNIT_ERROR =

"Number of texture units not supported by this hardware (or driver)" + WIKI;

public static final String NONPRIMARY_ERROR =

"The renderer is trying to call a PGL function that can only be called on a primary PGL. " +

"This is most likely due to a bug in the renderer's code, please report it with an " +

"issue on Processing's github page https://github.com/processing/processing/issues?state=open " +

"if using any of the built-in OpenGL renderers. If you are using a contributed " +

"library, contact the library's developers.";

protected static final String DEPTH_READING_NOT_ENABLED_ERROR =

"Reading depth and stencil values from this multisampled buffer is not enabled. " +

"You can enable it by calling hint(ENABLE_DEPTH_READING) once. " +

"If your sketch becomes too slow, disable multisampling with noSmooth() instead.";

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

// Constants

/** Size of different types in bytes */

protected static int SIZEOF_SHORT = Short.SIZE / 8;

protected static int SIZEOF_INT = Integer.SIZE / 8;

protected static int SIZEOF_FLOAT = Float.SIZE / 8;

protected static int SIZEOF_BYTE = Byte.SIZE / 8;

protected static int SIZEOF_INDEX = SIZEOF_SHORT;

protected static int INDEX_TYPE = 0x1403; // GL_UNSIGNED_SHORT

/** Machine Epsilon for float precision. */

protected static float FLOAT_EPS = Float.MIN_VALUE;

// Calculation of the Machine Epsilon for float precision. From:

// http://en.wikipedia.org/wiki/Machine_epsilon#Approximation_using_Java

static {

float eps = 1.0f;

do {

eps /= 2.0f;

} while ((float)(1.0 + (eps / 2.0)) != 1.0);

FLOAT_EPS = eps;

}

/**

protected static boolean BIG_ENDIAN =

ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN;

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

// Present mode

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

// Present mode

protected boolean presentMode = false;

protected boolean showStopButton = true;

public float presentX;

public float presentY;

protected IntBuffer closeButtonTex;

protected int stopButtonColor;

protected int stopButtonWidth = 28;

protected int stopButtonHeight = 12;

protected int stopButtonX = 21; // The position of the close button is relative to the

protected int closeButtonY = 21; // lower left corner

protected static int[] closeButtonPix = {

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, 0, 0, 0, -1, -1, -1, -1, -1, 0, 0, 0, -1,

-1, -1, 0, 0, 0, -1, -1, -1, -1, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0,

0, 0, 0, -1, -1, 0, -1, -1, 0, 0, -1, -1, 0, -1, -1, 0, 0, -1, 0, 0, 0, 0, 0,

0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, -1,

-1, -1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1,

0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, -1,

0, 0, 0, -1, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, -1, 0, -1,

-1, 0, 0, -1, -1, 0, -1, -1, 0, 0, 0, -1, -1, -1, 0, 0, 0, 0, 0, -1, -1, -1,

0, 0, 0, -1, -1, -1, 0, 0, 0, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0};

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

// Initialization, finalization

public PGL() { }

public PGL(PGraphicsOpenGL pg) {

this.graphics = pg;

if (glColorTex == null) {

glColorFbo = allocateIntBuffer(1);

glColorTex = allocateIntBuffer(2);

glDepthStencil = allocateIntBuffer(1);

glDepth = allocateIntBuffer(1);

glStencil = allocateIntBuffer(1);

glMultiFbo = allocateIntBuffer(1);

glMultiColor = allocateIntBuffer(1);

glMultiDepthStencil = allocateIntBuffer(1);

glMultiDepth = allocateIntBuffer(1);

glMultiStencil = allocateIntBuffer(1);

}

byteBuffer = allocateByteBuffer(1);

intBuffer = allocateIntBuffer(1);

viewBuffer = allocateIntBuffer(4);

}

public void dispose() {

destroyFBOLayer();

}

public void setPrimary(boolean primary) {

primaryPGL = primary;

}

static public int smoothToSamples(int smooth) {

if (smooth == 0) {

// smooth(0) is noSmooth(), which is 1x sampling

return 1;

} else if (smooth == 1) {

// smooth(1) means "default smoothing", which is 2x for OpenGL

return 2;

} else {

// smooth(N) can be used for 4x, 8x, etc

return smooth;

}

}

abstract public Object getNative();

abstract protected void setFrameRate(float fps);

abstract protected void initSurface(int antialias);

abstract protected void reinitSurface();

abstract protected void registerListeners();

protected int getReadFramebuffer() {

return fboLayerEnabled ? glColorFbo.get(0) : 0;

}

protected int getDrawFramebuffer() {

if (fboLayerEnabled) return 1 < numSamples ? glMultiFbo.get(0) :

glColorFbo.get(0);

else return 0;

}

protected int getDefaultDrawBuffer() {

return fboLayerEnabled ? COLOR_ATTACHMENT0 : BACK;

}

protected int getDefaultReadBuffer() {

return fboLayerEnabled ? COLOR_ATTACHMENT0 : FRONT;

}

protected boolean isFBOBacked() {

return fboLayerEnabled;

}

@Deprecated

public void requestFBOLayer() {

enableFBOLayer();

}

public void enableFBOLayer() {

fboLayerEnabledReq = true;

}

public void disableFBOLayer() {

fboLayerDisableReq = true;

}

public void resetFBOLayer() {

fbolayerResetReq = true;

}

protected boolean isMultisampled() {

return 1 < numSamples;

}

abstract protected int getDepthBits();

abstract protected int getStencilBits();

protected boolean getDepthTest() {

intBuffer.rewind();

getBooleanv(DEPTH_TEST, intBuffer);

return intBuffer.get(0) == 0 ? false : true;

}

protected boolean getDepthWriteMask() {

intBuffer.rewind();

getBooleanv(DEPTH_WRITEMASK, intBuffer);

return intBuffer.get(0) == 0 ? false : true;

}

protected Texture wrapBackTexture(Texture texture) {

if (texture == null) {

texture = new Texture(graphics);

texture.init(graphics.width, graphics.height,

glColorTex.get(backTex), TEXTURE_2D, RGBA,

fboWidth, fboHeight, NEAREST, NEAREST,

CLAMP_TO_EDGE, CLAMP_TO_EDGE);

texture.invertedY(true);

texture.colorBuffer(true);

graphics.setCache(graphics, texture);

} else {

texture.glName = glColorTex.get(backTex);

}

return texture;

}

protected Texture wrapFrontTexture(Texture texture) {

if (texture == null) {

texture = new Texture(graphics);

texture.init(graphics.width, graphics.height,

glColorTex.get(frontTex), TEXTURE_2D, RGBA,

fboWidth, fboHeight, NEAREST, NEAREST,

CLAMP_TO_EDGE, CLAMP_TO_EDGE);

texture.invertedY(true);

texture.colorBuffer(true);

} else {

texture.glName = glColorTex.get(frontTex);

}

return texture;

}

protected void bindFrontTexture() {

usingFrontTex = true;

if (!texturingIsEnabled(TEXTURE_2D)) {

enableTexturing(TEXTURE_2D);

}

bindTexture(TEXTURE_2D, glColorTex.get(frontTex));

}

protected void unbindFrontTexture() {

if (textureIsBound(TEXTURE_2D, glColorTex.get(frontTex))) {

// 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);

}

}

}

protected void syncBackTexture() {

if (usingFrontTex) needSepFrontTex = true;

if (1 < numSamples) {

bindFramebufferImpl(READ_FRAMEBUFFER, glMultiFbo.get(0));

bindFramebufferImpl(DRAW_FRAMEBUFFER, glColorFbo.get(0));

int mask = COLOR_BUFFER_BIT;

if (graphics.getHint(PConstants.ENABLE_BUFFER_READING)) {

mask |= DEPTH_BUFFER_BIT | STENCIL_BUFFER_BIT;

}

blitFramebuffer(0, 0, fboWidth, fboHeight,

0, 0, fboWidth, fboHeight,

mask, NEAREST);

}

}

abstract protected float getPixelScale();

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

// Present mode

public void initPresentMode(float x, float y, int stopColor) {

presentMode = true;

showStopButton = stopColor != 0;

stopButtonColor = stopColor;

presentX = x;

presentY = y;

enableFBOLayer();

}

public boolean presentMode() {

return presentMode;

}

public float presentX() {

return presentX;

}

public float presentY() {

return presentY;

}

public boolean insideStopButton(float x, float y) {

if (!showStopButton) return false;

return stopButtonX < x && x < stopButtonX + stopButtonWidth &&

-(closeButtonY + stopButtonHeight) < y && y < -closeButtonY;

}

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

// Frame rendering

protected void clearDepthStencil() {

if (!pclearDepth && !pclearStencil) {

depthMask(true);

clearDepth(1);

clearStencil(0);

clear(DEPTH_BUFFER_BIT | STENCIL_BUFFER_BIT);

} else if (!pclearDepth) {

depthMask(true);

clearDepth(1);

clear(DEPTH_BUFFER_BIT);

} else if (!pclearStencil) {

clearStencil(0);

clear(STENCIL_BUFFER_BIT);

}

}

protected void clearBackground(float r, float g, float b, float a,

boolean depth, boolean stencil) {

clearColor(r, g, b, a);

if (depth && stencil) {

clearDepth(1);

clearStencil(0);

clear(DEPTH_BUFFER_BIT | STENCIL_BUFFER_BIT | COLOR_BUFFER_BIT);

if (0 < sketch.frameCount) {

clearDepth = true;

clearStencil = true;

}

} else if (depth) {

clearDepth(1);

clear(DEPTH_BUFFER_BIT | COLOR_BUFFER_BIT);

if (0 < sketch.frameCount) {

clearDepth = true;

}

} else if (stencil) {

clearStencil(0);

clear(STENCIL_BUFFER_BIT | COLOR_BUFFER_BIT);

if (0 < sketch.frameCount) {

clearStencil = true;

}

} else {

clear(PGL.COLOR_BUFFER_BIT);

}

if (0 < sketch.frameCount) {

clearColor = true;

}

}

protected void beginRender() {

if (sketch == null) {

sketch = graphics.parent;

}

pgeomCount = geomCount;

geomCount = 0;

pclearColor = clearColor;

clearColor = false;

pclearDepth = clearDepth;

clearDepth = false;

pclearStencil = clearStencil;

clearStencil = false;

if (SINGLE_BUFFERED && sketch.frameCount == 1) {

restoreFirstFrame();

}

if (fboLayerEnabledReq) {

fboLayerEnabled = true;

fboLayerEnabledReq = false;

}

if (fboLayerEnabled) {

if (fbolayerResetReq) {

destroyFBOLayer();

fbolayerResetReq = false;

}

if (!fboLayerCreated) {

createFBOLayer();

}

// Draw to the back texture

bindFramebufferImpl(FRAMEBUFFER, glColorFbo.get(0));

framebufferTexture2D(FRAMEBUFFER, COLOR_ATTACHMENT0,

TEXTURE_2D, glColorTex.get(backTex), 0);

if (1 < numSamples) {

bindFramebufferImpl(FRAMEBUFFER, glMultiFbo.get(0));

}

if (sketch.frameCount == 0) {

// No need to draw back color buffer because we are in the first frame.

int argb = graphics.backgroundColor;

float ba = ((argb >> 24) & 0xff) / 255.0f;

float br = ((argb >> 16) & 0xff) / 255.0f;

float bg = ((argb >> 8) & 0xff) / 255.0f;

float bb = ((argb) & 0xff) / 255.0f;

clearColor(br, bg, bb, ba);

clear(COLOR_BUFFER_BIT);

} else if (!pclearColor || !sketch.isLooping()) {

// Render previous back texture (now is the front) as background,

// because no background() is being used ("incremental drawing")

int x = 0;

int y = 0;

if (presentMode) {

x = (int)presentX;

y = (int)presentY;

}

float scale = getPixelScale();

drawTexture(TEXTURE_2D, glColorTex.get(frontTex), fboWidth, fboHeight,

x, y, graphics.width, graphics.height,

0, 0, (int)(scale * graphics.width), (int)(scale * graphics.height),

0, 0, graphics.width, graphics.height);

}

}

}

protected void endRender(int windowColor) {

if (fboLayerEnabled) {

syncBackTexture();

// Draw the contents of the back texture to the screen framebuffer.

bindFramebufferImpl(FRAMEBUFFER, 0);

if (presentMode) {

float wa = ((windowColor >> 24) & 0xff) / 255.0f;

float wr = ((windowColor >> 16) & 0xff) / 255.0f;

float wg = ((windowColor >> 8) & 0xff) / 255.0f;

float wb = (windowColor & 0xff) / 255.0f;

clearDepth(1);

clearColor(wr, wg, wb, wa);

clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);

if (showStopButton) {

if (closeButtonTex == null) {

closeButtonTex = allocateIntBuffer(1);

genTextures(1, closeButtonTex);

bindTexture(TEXTURE_2D, closeButtonTex.get(0));

texParameteri(TEXTURE_2D, TEXTURE_MIN_FILTER, NEAREST);

texParameteri(TEXTURE_2D, TEXTURE_MAG_FILTER, NEAREST);

texParameteri(TEXTURE_2D, TEXTURE_WRAP_S, CLAMP_TO_EDGE);

texParameteri(TEXTURE_2D, TEXTURE_WRAP_T, CLAMP_TO_EDGE);

texImage2D(TEXTURE_2D, 0, RGBA, stopButtonWidth, stopButtonHeight, 0, RGBA, UNSIGNED_BYTE, null);

int[] color = new int[closeButtonPix.length];

PApplet.arrayCopy(closeButtonPix, color);

// Multiply the texture by the button color

float ba = ((stopButtonColor >> 24) & 0xFF) / 255f;

float br = ((stopButtonColor >> 16) & 0xFF) / 255f;

float bg = ((stopButtonColor >> 8) & 0xFF) / 255f;

float bb = ((stopButtonColor >> 0) & 0xFF) / 255f;

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

int c = closeButtonPix[i];

int a = (int)(ba * ((c >> 24) & 0xFF));

int r = (int)(br * ((c >> 16) & 0xFF));

int g = (int)(bg * ((c >> 8) & 0xFF));

int b = (int)(bb * ((c >> 0) & 0xFF));

color[i] = javaToNativeARGB((a << 24) | (r << 16) | (g << 8) | b);

}

IntBuffer buf = allocateIntBuffer(color);

copyToTexture(TEXTURE_2D, RGBA, closeButtonTex.get(0), 0, 0, stopButtonWidth, stopButtonHeight, buf);

bindTexture(TEXTURE_2D, 0);

}

drawTexture(TEXTURE_2D, closeButtonTex.get(0), stopButtonWidth, stopButtonHeight,

0, 0, stopButtonX + stopButtonWidth, closeButtonY + stopButtonHeight,

0, stopButtonHeight, stopButtonWidth, 0,

stopButtonX, closeButtonY, stopButtonX + stopButtonWidth, closeButtonY + stopButtonHeight);

}

} else {

clearDepth(1);

clearColor(0, 0, 0, 0);

clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);

}

// Render current back texture to screen, without blending.

disable(BLEND);

int x = 0;

int y = 0;

if (presentMode) {

x = (int)presentX;

y = (int)presentY;

}

float scale = getPixelScale();

drawTexture(TEXTURE_2D, glColorTex.get(backTex),

fboWidth, fboHeight,

x, y, graphics.width, graphics.height,

0, 0, (int)(scale * graphics.width), (int)(scale * graphics.height),

0, 0, graphics.width, graphics.height);

// Swapping front and back textures.

int temp = frontTex;

frontTex = backTex;

backTex = temp;

if (fboLayerDisableReq) {

fboLayerEnabled = false;

fboLayerDisableReq = false;

}

} else {

if (SINGLE_BUFFERED && sketch.frameCount == 0) {

saveFirstFrame();

}

if (!clearColor && 0 < sketch.frameCount || !sketch.isLooping()) {

enableFBOLayer();

if (SINGLE_BUFFERED) {

createFBOLayer();

}

}

}

}

protected abstract void getGL(PGL pgl);

protected abstract boolean canDraw();

protected abstract void requestFocus();

protected abstract void requestDraw();

protected abstract void swapBuffers();

public boolean threadIsCurrent() {

return Thread.currentThread() == glThread;

}

public void setThread(Thread thread) {

glThread = thread;

}

protected void beginGL() { }

protected void endGL() { }

private void createFBOLayer() {

float scale = getPixelScale();

if (hasNpotTexSupport()) {

fboWidth = (int)(scale * graphics.width);

fboHeight = (int)(scale * graphics.height);

} else {

fboWidth = nextPowerOfTwo((int)(scale * graphics.width));

fboHeight = nextPowerOfTwo((int)(scale * graphics.height));

}

if (hasFboMultisampleSupport()) {

int maxs = maxSamples();

numSamples = PApplet.min(reqNumSamples, maxs);

} else {

numSamples = 1;

}

boolean multisample = 1 < numSamples;

boolean packed = hasPackedDepthStencilSupport();

int depthBits = PApplet.min(REQUESTED_DEPTH_BITS, getDepthBits());

int stencilBits = PApplet.min(REQUESTED_STENCIL_BITS, getStencilBits());

genTextures(2, glColorTex);

for (int i = 0; i < 2; i++) {

bindTexture(TEXTURE_2D, glColorTex.get(i));

texParameteri(TEXTURE_2D, TEXTURE_MIN_FILTER, NEAREST);

texParameteri(TEXTURE_2D, TEXTURE_MAG_FILTER, NEAREST);

texParameteri(TEXTURE_2D, TEXTURE_WRAP_S, CLAMP_TO_EDGE);

texParameteri(TEXTURE_2D, TEXTURE_WRAP_T, CLAMP_TO_EDGE);

texImage2D(TEXTURE_2D, 0, RGBA, fboWidth, fboHeight, 0,

RGBA, UNSIGNED_BYTE, null);

initTexture(TEXTURE_2D, RGBA, fboWidth, fboHeight, graphics.backgroundColor);

}

bindTexture(TEXTURE_2D, 0);

backTex = 0;

frontTex = 1;

genFramebuffers(1, glColorFbo);

bindFramebufferImpl(FRAMEBUFFER, glColorFbo.get(0));

framebufferTexture2D(FRAMEBUFFER, COLOR_ATTACHMENT0, TEXTURE_2D,

glColorTex.get(backTex), 0);

if (!multisample || graphics.getHint(PConstants.ENABLE_BUFFER_READING)) {

// If not multisampled, this is the only depth and stencil buffer.

// If multisampled and depth reading enabled, these are going to

// hold downsampled depth and stencil buffers.

createDepthAndStencilBuffer(false, depthBits, stencilBits, packed);

}

if (multisample) {

// Creating multisampled FBO

genFramebuffers(1, glMultiFbo);

bindFramebufferImpl(FRAMEBUFFER, glMultiFbo.get(0));

// color render buffer...

genRenderbuffers(1, glMultiColor);

bindRenderbuffer(RENDERBUFFER, glMultiColor.get(0));

renderbufferStorageMultisample(RENDERBUFFER, numSamples,

RGBA8, fboWidth, fboHeight);

framebufferRenderbuffer(FRAMEBUFFER, COLOR_ATTACHMENT0,

RENDERBUFFER, glMultiColor.get(0));

// Creating multisampled depth and stencil buffers

createDepthAndStencilBuffer(true, depthBits, stencilBits, packed);

}

int status = validateFramebuffer();

if (status == FRAMEBUFFER_INCOMPLETE_MULTISAMPLE && 1 < numSamples) {

System.err.println("Continuing with multisampling disabled");

reqNumSamples = 1;

destroyFBOLayer();

// try again

createFBOLayer();

return;

}

// Clear all buffers.

clearDepth(1);

clearStencil(0);

int argb = graphics.backgroundColor;

float ba = ((argb >> 24) & 0xff) / 255.0f;

float br = ((argb >> 16) & 0xff) / 255.0f;

float bg = ((argb >> 8) & 0xff) / 255.0f;

float bb = ((argb) & 0xff) / 255.0f;

clearColor(br, bg, bb, ba);

clear(DEPTH_BUFFER_BIT | STENCIL_BUFFER_BIT | COLOR_BUFFER_BIT);

bindFramebufferImpl(FRAMEBUFFER, 0);

initFBOLayer();

fboLayerCreated = true;

}

protected abstract void initFBOLayer();

protected void saveFirstFrame() {

firstFrame = allocateDirectIntBuffer(graphics.width * graphics.height);

if (hasReadBuffer()) readBuffer(BACK);

readPixelsImpl(0, 0, graphics.width, graphics.height, RGBA, UNSIGNED_BYTE, firstFrame);

}