/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*

Part of the Processing project - http://processing.org

Copyright (c) 2011-13 Ben Fry and Casey Reas

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General

Public License along with this library; if not, write to the

Free Software Foundation, Inc., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

*/

package processing.opengl;

import processing.core.PApplet;

import processing.core.PGraphics;

import java.io.IOException;

import java.net.URL;

import java.nio.Buffer;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import java.nio.IntBuffer;

import java.nio.ShortBuffer;

import java.util.Arrays;

/**

* Processing-OpenGL abstraction layer. Needs to be implemented by subclasses

* using specific OpenGL-Java bindings.

*

* It includes a full GLES 2.0 interface.

*

*/

public abstract class PGL {

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

// Basic fields

/** The PGraphics object using this interface */

protected PGraphicsOpenGL pg;

/** 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

protected static boolean USE_FBOLAYER_BY_DEFAULT = false;

protected static int REQUESTED_DEPTH_BITS = 24;

protected static int REQUESTED_STENCIL_BITS = 8;

protected 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;

/** This flag enables/disables a hack to make sure that anything drawn

* in setup will be maintained even a renderer restart (e.g.: smooth change).

* See the code and comments involving this constant in

* PGraphicsOpenGL.endDraw().

*/

protected static boolean SAVE_SURFACE_TO_PIXELS_HACK = true;

/** 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

* indices to be of type unsigned short. Since Java only supports signed

* shorts as primitive type we have 2^15 = 32768 as the maximum number of

* vertices that can be referred to within a single VBO.

*/

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

* trigger a flush in the immediate mode. It doesn't necessarily

* be equal to MAX_VERTEX_INDEX1, since the number of vertices can

* be effectively much large since the renderer uses offsets to

* refer to vertices beyond the MAX_VERTEX_INDEX limit.

*/

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

* algorithm that properly generates caps and joins.

*/

protected static float MIN_CAPS_JOINS_WEIGHT = 2f;

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

* full algorithm that generates accurate caps and joins.

*/

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

* order to make sure the lines are always on top of the fill geometry */

protected static float STROKE_DISPLACEMENT = 0.999f;

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

// FBO layer

protected boolean fboLayerRequested = false;

protected boolean fboLayerCreated = false;

protected boolean fboLayerInUse = false;

protected boolean firstFrame = true;

protected int reqNumSamples;

protected int numSamples;

protected IntBuffer glColorFbo;

protected IntBuffer glMultiFbo;

protected IntBuffer glColorBuf;

protected IntBuffer glColorTex;

protected IntBuffer glDepthStencil;

protected IntBuffer glDepth;

protected IntBuffer glStencil;

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;

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

// Error messages

protected static final String WIKI =

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

protected static final String FRAMEBUFFER_ERROR =

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

protected static final String MISSING_FBO_ERROR =

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

protected static final String MISSING_GLSL_ERROR =

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

protected static final String MISSING_GLFUNC_ERROR =

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

protected static final String UNSUPPORTED_GLPROF_ERROR =

"Unsupported OpenGL profile.";

protected static final String TEXUNIT_ERROR =

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

protected 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.";

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

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

}

/**

* Set to true if the host system is big endian (PowerPC, MIPS, SPARC), false

* if little endian (x86 Intel for Mac or PC).

*/

protected static boolean BIG_ENDIAN =

ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN;

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

// Initialization, finalization

public PGL() { }

public PGL(PGraphicsOpenGL pg) {

this.pg = pg;

if (glColorTex == null) {

glColorTex = allocateIntBuffer(2);

glColorFbo = allocateIntBuffer(1);

glMultiFbo = allocateIntBuffer(1);

glColorBuf = allocateIntBuffer(1);

glDepthStencil = allocateIntBuffer(1);

glDepth = allocateIntBuffer(1);

glStencil = allocateIntBuffer(1);

fboLayerCreated = false;

fboLayerInUse = false;

firstFrame = false;

}

byteBuffer = allocateByteBuffer(1);

intBuffer = allocateIntBuffer(1);

viewBuffer = allocateIntBuffer(4);

}

public void setPrimary(boolean primary) {

primaryPGL = primary;

}

/**

* Return the native canvas the OpenGL context associated to this PGL object

* is rendering to (if any).

*/

public abstract Object getCanvas();

protected abstract void setFps(float fps);

protected abstract void initSurface(int antialias);

protected abstract void reinitSurface();

protected abstract void registerListeners();

protected void deleteSurface() {

if (threadIsCurrent() && fboLayerCreated) {

deleteTextures(2, glColorTex);

deleteFramebuffers(1, glColorFbo);

deleteFramebuffers(1, glMultiFbo);

deleteRenderbuffers(1, glColorBuf);

deleteRenderbuffers(1, glDepthStencil);

deleteRenderbuffers(1, glDepth);

deleteRenderbuffers(1, glStencil);

}

fboLayerCreated = false;

fboLayerInUse = false;

firstFrame = false;

}

protected int getReadFramebuffer() {

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

}

protected int getDrawFramebuffer() {

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

glColorFbo.get(0);

else return 0;

}

protected int getDefaultDrawBuffer() {

return fboLayerInUse ? COLOR_ATTACHMENT0 : FRONT;

}

protected int getDefaultReadBuffer() {

return fboLayerInUse ? COLOR_ATTACHMENT0 : FRONT;

}

protected boolean isFBOBacked() {;

return fboLayerInUse;

}

protected void requestFBOLayer() {

fboLayerRequested = true;

}

protected boolean isMultisampled() {

return 1 < numSamples;

}

protected int getDepthBits() {

intBuffer.rewind();

getIntegerv(DEPTH_BITS, intBuffer);

return intBuffer.get(0);

}

protected int getStencilBits() {

intBuffer.rewind();

getIntegerv(STENCIL_BITS, intBuffer);

return intBuffer.get(0);

}

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(pg);

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

glColorTex.get(backTex), TEXTURE_2D, RGBA,

fboWidth, fboHeight, NEAREST, NEAREST,

CLAMP_TO_EDGE, CLAMP_TO_EDGE);

texture.invertedY(true);

texture.colorBuffer(true);

pg.setCache(pg, texture);

} else {

texture.glName = glColorTex.get(backTex);

}

return texture;

}

protected Texture wrapFrontTexture(Texture texture) {

if (texture == null) {

texture = new Texture(pg);

texture.init(pg.width, pg.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));

blitFramebuffer(0, 0, fboWidth, fboHeight,

0, 0, fboWidth, fboHeight,

COLOR_BUFFER_BIT, NEAREST);

}

}

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

// Frame rendering

protected void beginDraw(boolean clear0) {

if (needFBOLayer(clear0)) {

if (!fboLayerCreated) createFBOLayer();

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

framebufferTexture2D(FRAMEBUFFER, COLOR_ATTACHMENT0,

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

if (1 < numSamples) {

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

}

if (firstFrame) {

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

int argb = pg.backgroundColor;

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

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

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

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

clearColor(r, g, b, a);

clear(COLOR_BUFFER_BIT);

} else if (!clear0) {

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

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

drawTexture(TEXTURE_2D, glColorTex.get(frontTex),

fboWidth, fboHeight, pg.width, pg.height,

0, 0, pg.width, pg.height,

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

}

fboLayerInUse = true;

} else {

fboLayerInUse = false;

}

if (firstFrame) {

firstFrame = false;

}

if (!USE_FBOLAYER_BY_DEFAULT) {

// The result of this assignment is the following: if the user requested

// at some point the use of the FBO layer, but subsequently didn't

// request it again, then the rendering won't render to the FBO layer if

// not needed by the condif, since it is slower than simple onscreen

// rendering.

fboLayerRequested = false;

}

}

protected void endDraw(boolean clear0) {

if (fboLayerInUse) {

syncBackTexture();

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

bindFramebufferImpl(FRAMEBUFFER, 0);

clearDepth(1);

clearColor(0, 0, 0, 0);

clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);

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

disable(BLEND);

drawTexture(TEXTURE_2D, glColorTex.get(backTex),

fboWidth, fboHeight, pg.width, pg.height,

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

// Swapping front and back textures.

int temp = frontTex;

frontTex = backTex;

backTex = temp;

}

}

protected abstract void getGL(PGL pgl);

protected abstract boolean canDraw();

protected abstract void requestFocus();

protected abstract void requestDraw();

protected abstract void swapBuffers();

protected boolean threadIsCurrent() {

return Thread.currentThread() == glThread;

}

protected void beginGL() { }

protected void endGL() { }

private boolean needFBOLayer(boolean clear0) {

// TODO: need to revise this, on windows we might not want to use FBO layer

// even with anti-aliasing enabled...

return !clear0 || fboLayerRequested || 1 < numSamples;

}

private void createFBOLayer() {

String ext = getString(EXTENSIONS);

if (-1 < ext.indexOf("texture_non_power_of_two")) {

fboWidth = pg.width;

fboHeight = pg.height;

} else {

fboWidth = nextPowerOfTwo(pg.width);

fboHeight = nextPowerOfTwo(pg.height);

}

int maxs = maxSamples();

if (-1 < ext.indexOf("_framebuffer_multisample") && 1 < maxs) {

numSamples = PApplet.min(reqNumSamples, maxs);

} else {

numSamples = 1;

}

boolean multisample = 1 < numSamples;

boolean packed = ext.indexOf("packed_depth_stencil") != -1;

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, pg.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) {

// Creating multisampled FBO

genFramebuffers(1, glMultiFbo);

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

// color render buffer...

genRenderbuffers(1, glColorBuf);

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

renderbufferStorageMultisample(RENDERBUFFER, numSamples,

RGBA8, fboWidth, fboHeight);

framebufferRenderbuffer(FRAMEBUFFER, COLOR_ATTACHMENT0,

RENDERBUFFER, glColorBuf.get(0));

}

// Creating depth and stencil buffers

if (packed && depthBits == 24 && stencilBits == 8) {

// packed depth+stencil buffer

genRenderbuffers(1, glDepthStencil);

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

if (multisample) {

renderbufferStorageMultisample(RENDERBUFFER, numSamples,

DEPTH24_STENCIL8, fboWidth, fboHeight);

} else {

renderbufferStorage(RENDERBUFFER, DEPTH24_STENCIL8,

fboWidth, fboHeight);

}

framebufferRenderbuffer(FRAMEBUFFER, DEPTH_ATTACHMENT, RENDERBUFFER,

glDepthStencil.get(0));

framebufferRenderbuffer(FRAMEBUFFER, STENCIL_ATTACHMENT, RENDERBUFFER,

glDepthStencil.get(0));

} else {

// separate depth and stencil buffers

if (0 < depthBits) {

int depthComponent = DEPTH_COMPONENT16;

if (depthBits == 32) {

depthComponent = DEPTH_COMPONENT32;

} else if (depthBits == 24) {

depthComponent = DEPTH_COMPONENT24;

} else if (depthBits == 16) {

depthComponent = DEPTH_COMPONENT16;

}

genRenderbuffers(1, glDepth);

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

if (multisample) {

renderbufferStorageMultisample(RENDERBUFFER, numSamples,

depthComponent, fboWidth, fboHeight);

} else {

renderbufferStorage(RENDERBUFFER, depthComponent,

fboWidth, fboHeight);

}

framebufferRenderbuffer(FRAMEBUFFER, DEPTH_ATTACHMENT,

RENDERBUFFER, glDepth.get(0));

}

if (0 < stencilBits) {

int stencilIndex = STENCIL_INDEX1;

if (stencilBits == 8) {

stencilIndex = STENCIL_INDEX8;

} else if (stencilBits == 4) {

stencilIndex = STENCIL_INDEX4;

} else if (stencilBits == 1) {

stencilIndex = STENCIL_INDEX1;

}

genRenderbuffers(1, glStencil);

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

if (multisample) {

renderbufferStorageMultisample(RENDERBUFFER, numSamples,

stencilIndex, fboWidth, fboHeight);

} else {

renderbufferStorage(RENDERBUFFER, stencilIndex,

fboWidth, fboHeight);

}

framebufferRenderbuffer(FRAMEBUFFER, STENCIL_ATTACHMENT,

RENDERBUFFER, glStencil.get(0));

}

}

validateFramebuffer();

// Clear all buffers.

clearDepth(1);

clearStencil(0);

int argb = pg.backgroundColor;

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

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

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

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

clearColor(r, g, b, a);

clear(DEPTH_BUFFER_BIT | STENCIL_BUFFER_BIT | COLOR_BUFFER_BIT);

bindFramebufferImpl(FRAMEBUFFER, 0);

fboLayerCreated = true;

}

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

// Context interface

protected int createEmptyContext() {

return -1;

}

protected int getCurrentContext() {

return glContext;

}

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

// Utility functions

protected boolean contextIsCurrent(int other) {

return other == -1 || other == glContext;

}

protected void enableTexturing(int target) {

if (target == TEXTURE_2D) {

texturingTargets[0] = true;

} else if (target == TEXTURE_RECTANGLE) {

texturingTargets[1] = true;

}

}

protected void disableTexturing(int target) {

if (target == TEXTURE_2D) {

texturingTargets[0] = false;

} else if (target == TEXTURE_RECTANGLE) {

texturingTargets[1] = false;

}

}

protected boolean texturingIsEnabled(int target) {

if (target == TEXTURE_2D) {

return texturingTargets[0];

} else if (target == TEXTURE_RECTANGLE) {

return texturingTargets[1];

} else {

return false;

}

}

protected boolean textureIsBound(int target, int id) {

if (boundTextures == null) return false;

if (target == TEXTURE_2D) {

return boundTextures[activeTexUnit][0] == id;

} else if (target == TEXTURE_RECTANGLE) {

return boundTextures[activeTexUnit][1] == id;

} else {

return false;

}

}

protected void initTexture(int target, int format, int width, int height) {

initTexture(target, format, width, height, 0);

}

protected void initTexture(int target, int format, int width, int height,

int initColor) {

int[] glcolor = new int[16 * 16];

Arrays.fill(glcolor, javaToNativeARGB(initColor));

IntBuffer texels = allocateDirectIntBuffer(16 * 16);

texels.put(glcolor);

texels.rewind();

for (int y = 0; y < height; y += 16) {

int h = PApplet.min(16, height - y);

for (int x = 0; x < width; x += 16) {

int w = PApplet.min(16, width - x);

texSubImage2D(target, 0, x, y, w, h, format, UNSIGNED_BYTE, texels);

}

}

}

protected void copyToTexture(int target, int format, int id, int x, int y,

int w, int h, IntBuffer buffer) {

activeTexture(TEXTURE0);

boolean enabledTex = false;

if (!texturingIsEnabled(target)) {

enableTexturing(target);

enabledTex = true;

}

bindTexture(target, id);

texSubImage2D(target, 0, x, y, w, h, format, UNSIGNED_BYTE, buffer);

bindTexture(target, 0);

if (enabledTex) {

disableTexturing(target);

}

}

/**

* Not an approved function, this will change or be removed in the future.

*/

public void drawTexture(int target, int id, int width, int height,

int X0, int Y0, int X1, int Y1) {

drawTexture(target, id, width, height, width, height,

X0, Y0, X1, Y1, X0, Y0, X1, Y1);

}

/**

* Not an approved function, this will change or be removed in the future.

*/

public void drawTexture(int target, int id,

int texW, int texH, int scrW, int scrH,

int texX0, int texY0, int texX1, int texY1,

int scrX0, int scrY0, int scrX1, int scrY1) {

if (target == TEXTURE_2D) {

drawTexture2D(id, texW, texH, scrW, scrH,

texX0, texY0, texX1, texY1,

scrX0, scrY0, scrX1, scrY1);

} else if (target == TEXTURE_RECTANGLE) {

drawTextureRect(id, texW, texH, scrW, scrH,

texX0, texY0, texX1, texY1,

scrX0, scrY0, scrX1, scrY1);

}

}

protected PGL initTex2DShader() {

PGL ppgl = primaryPGL ? this : pg.getPrimaryPGL();

if (!ppgl.loadedTex2DShader || ppgl.tex2DShaderContext != ppgl.glContext) {

String vertSource = PApplet.join(texVertShaderSource, "\n");

String fragSource = PApplet.join(tex2DFragShaderSource, "\n");

ppgl.tex2DVertShader = createShader(VERTEX_SHADER, vertSource);

ppgl.tex2DFragShader = createShader(FRAGMENT_SHADER, fragSource);

if (0 < ppgl.tex2DVertShader && 0 < ppgl.tex2DFragShader) {

ppgl.tex2DShaderProgram = createProgram(ppgl.tex2DVertShader, ppgl.tex2DFragShader);

}

if (0 < ppgl.tex2DShaderProgram) {

ppgl.tex2DVertLoc = getAttribLocation(ppgl.tex2DShaderProgram, "position");

ppgl.tex2DTCoordLoc = getAttribLocation(ppgl.tex2DShaderProgram, "texCoord");

ppgl.tex2DSamplerLoc = getUniformLocation(ppgl.tex2DShaderProgram, "texMap");

}

ppgl.loadedTex2DShader = true;

ppgl.tex2DShaderContext = ppgl.glContext;

genBuffers(1, intBuffer);

ppgl.tex2DGeoVBO = intBuffer.get(0);

bindBuffer(ARRAY_BUFFER, ppgl.tex2DGeoVBO);

bufferData(ARRAY_BUFFER, 16 * SIZEOF_FLOAT, null, STATIC_DRAW);

}

if (texData == null) {

texData = allocateDirectFloatBuffer(texCoords.length);

}

return ppgl;

}

protected void drawTexture2D(int id, int texW, int texH, int scrW, int scrH,

int texX0, int texY0, int texX1, int texY1,

int scrX0, int scrY0, int scrX1, int scrY1) {

PGL ppgl = initTex2DShader();

if (0 < ppgl.tex2DShaderProgram) {

// The texture overwrites anything drawn earlier.

boolean depthTest = getDepthTest();

disable(DEPTH_TEST);

// When drawing the texture we don't write to the

// depth mask, so the texture remains in the background

// and can be occluded by anything drawn later, even if

// if it is behind it.

boolean depthMask = getDepthWriteMask();

depthMask(false);

// Making sure that the viewport matches the provided screen dimensions

viewBuffer.rewind();

getIntegerv(VIEWPORT, viewBuffer);

viewport(0, 0, scrW, scrH);

useProgram(ppgl.tex2DShaderProgram);

enableVertexAttribArray(ppgl.tex2DVertLoc);

enableVertexAttribArray(ppgl.tex2DTCoordLoc);

// Vertex coordinates of the textured quad are specified

// in normalized screen space (-1, 1):

// Corner 1

texCoords[ 0] = 2 * (float)scrX0 / scrW - 1;

texCoords[ 1] = 2 * (float)scrY0 / scrH - 1;

texCoords[ 2] = (float)texX0 / texW;

texCoords[ 3] = (float)texY0 / texH;

// Corner 2

texCoords[ 4] = 2 * (float)scrX1 / scrW - 1;

texCoords[ 5] = 2 * (float)scrY0 / scrH - 1;

texCoords[ 6] = (float)texX1 / texW;

texCoords[ 7] = (float)texY0 / texH;

// Corner 3

texCoords[ 8] = 2 * (float)scrX0 / scrW - 1;

texCoords[ 9] = 2 * (float)scrY1 / scrH - 1;

texCoords[10] = (float)texX0 / texW;

texCoords[11] = (float)texY1 / texH;

// Corner 4

texCoords[12] = 2 * (float)scrX1 / scrW - 1;

texCoords[13] = 2 * (float)scrY1 / scrH - 1;

texCoords[14] = (float)texX1 / texW;

texCoords[15] = (float)texY1 / texH;

texData.rewind();

texData.put(texCoords);

activeTexture(TEXTURE0);

boolean enabledTex = false;

if (!texturingIsEnabled(TEXTURE_2D)) {