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

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

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;

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

protected static boolean SAVE_SURFACE_TO_PIXELS_HACK = false;

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

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

// FBO layer

protected boolean fboLayerRequested = false;

protected boolean fboLayerCreated = false;

protected boolean fboLayerInUse = false;

protected boolean firstFrame = true;

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;

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

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

public boolean presentMode = false;

public float offsetX;

public float offsetY;

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

// Initialization, finalization

public PGL() { }

public PGL(PGraphicsOpenGL pg) {

this.pg = 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);

fboLayerCreated = false;

fboLayerInUse = false;

firstFrame = false;

}

byteBuffer = allocateByteBuffer(1);

intBuffer = allocateIntBuffer(1);

viewBuffer = allocateIntBuffer(4);

}

public void setPrimary(boolean primary) {

primaryPGL = primary;

}

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

}

}

protected void deleteSurface() {

if (threadIsCurrent() && fboLayerCreated) {

deleteFramebuffers(1, glColorFbo);

deleteTextures(2, glColorTex);

deleteRenderbuffers(1, glDepthStencil);

deleteRenderbuffers(1, glDepth);

deleteRenderbuffers(1, glStencil);

deleteFramebuffers(1, glMultiFbo);

deleteRenderbuffers(1, glMultiColor);

deleteRenderbuffers(1, glMultiDepthStencil);

deleteRenderbuffers(1, glMultiDepth);

deleteRenderbuffers(1, glMultiStencil);

}

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 : BACK;

}

protected int getDefaultReadBuffer() {

return fboLayerInUse ? COLOR_ATTACHMENT0 : FRONT;

}

protected boolean isFBOBacked() {;

return fboLayerInUse;

}

public void requestFBOLayer() {

fboLayerRequested = 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(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));

int mask = COLOR_BUFFER_BIT;

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

mask |= DEPTH_BUFFER_BIT | STENCIL_BUFFER_BIT;

}

blitFramebuffer(0, 0, fboWidth, fboHeight,

0, 0, fboWidth, fboHeight,

mask, 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")

int x = 0;

int y = 0;

if (presentMode) {

x = (int)offsetX;

y = (int)offsetY;

}

float scale = pg.getPixelScale();

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

x, y, pg.width, pg.height,

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

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

}

fboLayerInUse = true;

} else {

fboLayerInUse = false;

}

if (firstFrame) {

firstFrame = false;

}

// 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 config, since it is slower than simple onscreen

// rendering.

}

IntBuffer labelTex;

protected void endDraw(boolean clear, int windowColor) {

if (fboLayerInUse) {

syncBackTexture();

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

bindFramebufferImpl(FRAMEBUFFER, 0);

if (presentMode) {

int argb = windowColor;

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;

clearDepth(1);

clearColor(r, g, b, a);

clear(COLOR_BUFFER_BIT | DEPTH_BUFFER_BIT);

if (labelTex == null) {

labelTex = allocateIntBuffer(1);

genTextures(1, labelTex);

bindTexture(TEXTURE_2D, labelTex.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, 100, 50, 0, RGBA, UNSIGNED_BYTE, null);

IntBuffer buf = allocateIntBuffer(labelPix);

copyToTexture(TEXTURE_2D, RGBA, labelTex.get(0), 0, 0, 100, 50, buf);

bindTexture(TEXTURE_2D, 0);

}

drawTexture(TEXTURE_2D, labelTex.get(0), 100, 50,

0, 0, 20 + 100, 20 + 50,

0, 50, 100, 0,

20, 20, 20 + 100, 20 + 50);

} 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)offsetX;

y = (int)offsetY;

}

float scale = pg.getPixelScale();

drawTexture(TEXTURE_2D, glColorTex.get(backTex),

fboWidth, fboHeight,

x, y, pg.width, pg.height,

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

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

// Swapping front and back textures.

int temp = frontTex;

frontTex = backTex;

backTex = temp;

} else if (!clear && pg.parent.frameCount == 1) {

//requestFBOLayer();

}

}

protected abstract void getGL(PGL pgl);

public boolean threadIsCurrent() {

return Thread.currentThread() == glThread;

}

public void setThread(Thread thread) {

glThread = thread;

}

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

}

private void createFBOLayer() {

float scale = pg.getPixelScale();

if (hasNpotTexSupport()) {

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

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

} else {

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

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

}

int maxs = maxSamples();

if (hasFboMultisampleSupport() && 1 < maxs) {

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

}

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;

}

private void createDepthAndStencilBuffer(boolean multisample, int depthBits,

int stencilBits, boolean packed) {

// Creating depth and stencil buffers

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

// packed depth+stencil buffer

IntBuffer depthStencilBuf =

multisample ? glMultiDepthStencil : glDepthStencil;

genRenderbuffers(1, depthStencilBuf);

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

if (multisample) {

renderbufferStorageMultisample(RENDERBUFFER, numSamples,

DEPTH24_STENCIL8, fboWidth, fboHeight);

} else {

renderbufferStorage(RENDERBUFFER, DEPTH24_STENCIL8,

fboWidth, fboHeight);

}

framebufferRenderbuffer(FRAMEBUFFER, DEPTH_ATTACHMENT, RENDERBUFFER,

depthStencilBuf.get(0));

framebufferRenderbuffer(FRAMEBUFFER, STENCIL_ATTACHMENT, RENDERBUFFER,

depthStencilBuf.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;

}

IntBuffer depthBuf = multisample ? glMultiDepth : glDepth;

genRenderbuffers(1, depthBuf);

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

if (multisample) {

renderbufferStorageMultisample(RENDERBUFFER, numSamples,

depthComponent, fboWidth, fboHeight);

} else {

renderbufferStorage(RENDERBUFFER, depthComponent,

fboWidth, fboHeight);

}

framebufferRenderbuffer(FRAMEBUFFER, DEPTH_ATTACHMENT,

RENDERBUFFER, depthBuf.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;

}

IntBuffer stencilBuf = multisample ? glMultiStencil : glStencil;

genRenderbuffers(1, stencilBuf);

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

if (multisample) {

renderbufferStorageMultisample(RENDERBUFFER, numSamples,

stencilIndex, fboWidth, fboHeight);

} else {

renderbufferStorage(RENDERBUFFER, stencilIndex,

fboWidth, fboHeight);

}

framebufferRenderbuffer(FRAMEBUFFER, STENCIL_ATTACHMENT,

RENDERBUFFER, stencilBuf.get(0));

}

}

}

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

// 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, int[] buffer) {

copyToTexture(target, format, id, x, y, w, h, IntBuffer.wrap(buffer));

}

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

int w, int h, IntBuffer buffer) {