/**

protected static final int TEX2D = 0;

/**

protected static final int TEXRECT = 1;

/** Point sampling: both magnification and minification filtering are set

protected static final int POINT = 2;

/** Linear sampling: magnification filtering is nearest, minification set

protected static final int LINEAR = 3;

/** Bilinear sampling: both magnification filtering is set to linear and

protected static final int BILINEAR = 4;

/** Trilinear sampling: magnification filtering set to linear, minification to

protected static final int TRILINEAR = 5;

// This constant controls how many times pixelBuffer and rgbaPixels can be

// accessed before they are not released anymore. The idea is that if they

// have been used only a few times, it doesn't make sense to keep them around.

protected static final int MAX_UPDATES = 10;

// The minimum amount of free JVM's memory (in MB) before pixelBuffer and

// rgbaPixels are released every time after they are used.

protected static final int MIN_MEMORY = 5;

public int width, height;

public int glName;

public int glTarget;

public int glFormat;

public int glMinFilter;

public int glMagFilter;

public int glWrapS;

public int glWrapT;

public int glWidth;

public int glHeight;

private GLResourceTexture glres;

protected PGraphicsOpenGL pg;

protected PGL pgl; // The interface between Processing and OpenGL.

protected int context; // The context that created this texture.

protected boolean colorBuffer; // true if it is the color attachment of

// FrameBuffer object.

protected boolean usingMipmaps;

protected boolean usingRepeat;

protected float maxTexcoordU;

protected float maxTexcoordV;

protected boolean bound;

protected boolean invertedX;

protected boolean invertedY;

protected int[] rgbaPixels = null;

protected IntBuffer pixelBuffer = null;

protected int[] edgePixels = null;

protected IntBuffer edgeBuffer = null;

protected FrameBuffer tempFbo = null;

protected int pixBufUpdateCount = 0;

protected int rgbaPixUpdateCount = 0;

/** Modified portion of the texture */

protected boolean modified;

protected int mx1, my1, mx2, my2;

protected Object bufferSource;

protected LinkedList<BufferData> bufferCache = null;

protected LinkedList<BufferData> usedBuffers = null;

protected Method disposeBufferMethod;

public static final int MAX_BUFFER_CACHE_SIZE = 3;

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

// Constructors.

public Texture(PGraphicsOpenGL pg) {

this.pg = pg;

pgl = pg.pgl;

context = pgl.createEmptyContext();

colorBuffer = false;

glName = 0;

}

/**

public Texture(PGraphicsOpenGL pg, int width, int height) {

this(pg, width, height, new Parameters());

}

/**

public Texture(PGraphicsOpenGL pg, int width, int height, Object params) {

this.pg = pg;

pgl = pg.pgl;

context = pgl.createEmptyContext();

colorBuffer = false;

glName = 0;

init(width, height, (Parameters)params);

}

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

// Init, resize methods

/**

public void init(int width, int height) {

Parameters params;

if (0 < glName) {

// Re-initializing a pre-existing texture.

// We use the current parameters as default:

params = getParameters();

} else {

// Just built-in default parameters otherwise:

params = new Parameters();

}

init(width, height, params);

}

/**

public void init(int width, int height, Parameters params) {

setParameters(params);

setSize(width, height);

allocate();

}

/**

public void init(int width, int height,

int glName, int glTarget, int glFormat,

int glWidth, int glHeight,

int glMinFilter, int glMagFilter,

int glWrapS, int glWrapT) {

this.width = width;

this.height = height;

this.glName = glName;

this.glTarget = glTarget;

this.glFormat = glFormat;

this.glWidth = glWidth;

this.glHeight = glHeight;

this.glMinFilter = glMinFilter;

this.glMagFilter = glMagFilter;

this.glWrapS = glWrapS;

this.glWrapT = glWrapT;

maxTexcoordU = (float)width / glWidth;

maxTexcoordV = (float)height / glHeight;

usingMipmaps = glMinFilter == PGL.LINEAR_MIPMAP_NEAREST ||

glMinFilter == PGL.LINEAR_MIPMAP_LINEAR;

usingRepeat = glWrapS == PGL.REPEAT || glWrapT == PGL.REPEAT;

}

public void resize(int wide, int high) {

// Disposing current resources.

dispose();

// Creating new texture with the appropriate size.

Texture tex = new Texture(pg, wide, high, getParameters());

// Copying the contents of this texture into tex.

tex.set(this);

// Now, overwriting "this" with tex.

copyObject(tex);

// Nullifying some utility objects so they are recreated with the

// appropriate size when needed.

tempFbo = null;

}

/**

public boolean available() {

return 0 < glName;

}

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

// Set methods

public void set(Texture tex) {

copyTexture(tex, 0, 0, tex.width, tex.height, true);

}

public void set(Texture tex, int x, int y, int w, int h) {

copyTexture(tex, x, y, w, h, true);

}

public void set(int texTarget, int texName, int texWidth, int texHeight,

int w, int h) {

copyTexture(texTarget, texName, texWidth, texHeight, 0, 0, w, h, true);

}

public void set(int texTarget, int texName, int texWidth, int texHeight,

int target, int tex, int x, int y, int w, int h) {

copyTexture(texTarget, texName, texWidth, texHeight, x, y, w, h, true);

}

public void set(int[] pixels) {

set(pixels, 0, 0, width, height, ARGB);

}

public void set(int[] pixels, int format) {

set(pixels, 0, 0, width, height, format);

}

public void set(int[] pixels, int x, int y, int w, int h) {

set(pixels, x, y, w, h, ARGB);

}

public void set(int[] pixels, int x, int y, int w, int h, int format) {

if (pixels == null) {

PGraphics.showWarning("The pixels array is null.");

return;

}

if (pixels.length < w * h) {

PGraphics.showWarning("The pixel array has a length of " +

pixels.length + ", but it should be at least " +

w * h);

return;

}

if (pixels.length == 0 || w == 0 || h == 0) {

return;

}

boolean enabledTex = false;

if (!pgl.texturingIsEnabled(glTarget)) {

pgl.enableTexturing(glTarget);

enabledTex = true;

}

pgl.bindTexture(glTarget, glName);

loadPixels(w * h);

convertToRGBA(pixels, format, w, h);

updatePixelBuffer(rgbaPixels);

pgl.texSubImage2D(glTarget, 0, x, y, w, h, PGL.RGBA, PGL.UNSIGNED_BYTE,

pixelBuffer);

fillEdges(x, y, w, h);

if (usingMipmaps) {

if (PGraphicsOpenGL.autoMipmapGenSupported) {

pgl.generateMipmap(glTarget);

} else {

manualMipmap();

}

}

pgl.bindTexture(glTarget, 0);

if (enabledTex) {

pgl.disableTexturing(glTarget);

}

releasePixelBuffer();

releaseRGBAPixels();

updateTexels(x, y, w, h);

}

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

// Native set methods

public void setNative(int[] pixels) {

setNative(pixels, 0, 0, width, height);

}

public void setNative(int[] pixels, int x, int y, int w, int h) {

updatePixelBuffer(pixels);

setNative(pixelBuffer, x, y, w, h);

releasePixelBuffer();

}

public void setNative(IntBuffer pixBuf, int x, int y, int w, int h) {

if (pixBuf == null) {

pixBuf = null;

PGraphics.showWarning("The pixel buffer is null.");

return;

}

if (pixBuf.capacity() < w * h) {

PGraphics.showWarning("The pixel bufer has a length of " +

pixBuf.capacity() + ", but it should be at least " +

w * h);

return;

}

if (pixBuf.capacity() == 0) {

// Nothing to do (means that w == h == 0) but not an erroneous situation

return;

}

boolean enabledTex = false;

if (!pgl.texturingIsEnabled(glTarget)) {

pgl.enableTexturing(glTarget);

enabledTex = true;

}

pgl.bindTexture(glTarget, glName);

pgl.texSubImage2D(glTarget, 0, x, y, w, h, PGL.RGBA, PGL.UNSIGNED_BYTE,

pixBuf);

fillEdges(x, y, w, h);

if (usingMipmaps) {

if (PGraphicsOpenGL.autoMipmapGenSupported) {

pgl.generateMipmap(glTarget);

} else {

manualMipmap();

}

}

pgl.bindTexture(glTarget, 0);

if (enabledTex) {

pgl.disableTexturing(glTarget);

}

updateTexels(x, y, w, h);

}

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

// Get methods

/**

public void get(int[] pixels) {

if (pixels == null) {

throw new RuntimeException("Trying to copy texture to null pixels array");

}

if (pixels.length != width * height) {

throw new RuntimeException("Trying to copy texture to pixels array of " +

"wrong size");

}

if (tempFbo == null) {

tempFbo = new FrameBuffer(pg, glWidth, glHeight);

}

// Attaching the texture to the color buffer of a FBO, binding the FBO and

// reading the pixels from the current draw buffer (which is the color

// buffer of the FBO).

tempFbo.setColorBuffer(this);

pg.pushFramebuffer();

pg.setFramebuffer(tempFbo);

tempFbo.readPixels();

pg.popFramebuffer();

tempFbo.getPixels(pixels);

convertToARGB(pixels);

if (invertedX) flipArrayOnX(pixels, 1);

if (invertedY) flipArrayOnY(pixels, 1);

}

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

// Put methods (the source texture is not resized to cover the entire

// destination).

public void put(Texture tex) {

copyTexture(tex, 0, 0, tex.width, tex.height, false);

}

public void put(Texture tex, int x, int y, int w, int h) {

copyTexture(tex, x, y, w, h, false);

}

public void put(int texTarget, int texName, int texWidth, int texHeight,

int w, int h) {

copyTexture(texTarget, texName, texWidth, texHeight, 0, 0, w, h, false);

}

public void put(int texTarget, int texName, int texWidth, int texHeight,

int target, int tex, int x, int y, int w, int h) {

copyTexture(texTarget, texName, texWidth, texHeight, x, y, w, h, false);

}

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

// Get OpenGL parameters

/**

public boolean usingMipmaps() {

return usingMipmaps;

}

public void usingMipmaps(boolean mipmaps, int sampling) {

int glMagFilter0 = glMagFilter;

int glMinFilter0 = glMinFilter;

if (mipmaps) {

if (sampling == POINT) {

glMagFilter = PGL.NEAREST;

glMinFilter = PGL.NEAREST;

usingMipmaps = false;

} else if (sampling == LINEAR) {

glMagFilter = PGL.NEAREST;

glMinFilter =

PGL.MIPMAPS_ENABLED ? PGL.LINEAR_MIPMAP_NEAREST : PGL.LINEAR;

usingMipmaps = true;

} else if (sampling == BILINEAR) {

glMagFilter = PGL.LINEAR;

glMinFilter =

PGL.MIPMAPS_ENABLED ? PGL.LINEAR_MIPMAP_NEAREST : PGL.LINEAR;

usingMipmaps = true;

} else if (sampling == TRILINEAR) {

glMagFilter = PGL.LINEAR;

glMinFilter =

PGL.MIPMAPS_ENABLED ? PGL.LINEAR_MIPMAP_LINEAR : PGL.LINEAR;

usingMipmaps = true;

} else {

throw new RuntimeException("Unknown texture filtering mode");

}

} else {

usingMipmaps = false;

if (sampling == POINT) {

glMagFilter = PGL.NEAREST;

glMinFilter = PGL.NEAREST;

} else if (sampling == LINEAR) {

glMagFilter = PGL.NEAREST;

glMinFilter = PGL.LINEAR;

} else if (sampling == BILINEAR || sampling == TRILINEAR) {

glMagFilter = PGL.LINEAR;

glMinFilter = PGL.LINEAR;

} else {

throw new RuntimeException("Unknown texture filtering mode");

}

}

if (glMagFilter0 != glMagFilter || glMinFilter0 != glMinFilter) {

bind();

pgl.texParameteri(glTarget, PGL.TEXTURE_MIN_FILTER, glMinFilter);

pgl.texParameteri(glTarget, PGL.TEXTURE_MAG_FILTER, glMagFilter);

if (usingMipmaps) {

if (PGraphicsOpenGL.autoMipmapGenSupported) {

pgl.generateMipmap(glTarget);

} else {

manualMipmap();

}

}

unbind();

}

}

/**

public boolean usingRepeat() {

return usingRepeat;

}

public void usingRepeat(boolean repeat) {

if (repeat) {

glWrapS = PGL.REPEAT;

glWrapT = PGL.REPEAT;

usingRepeat = true;

} else {

glWrapS = PGL.CLAMP_TO_EDGE;

glWrapT = PGL.CLAMP_TO_EDGE;

usingRepeat = false;

}

bind();

pgl.texParameteri(glTarget, PGL.TEXTURE_WRAP_S, glWrapS);

pgl.texParameteri(glTarget, PGL.TEXTURE_WRAP_T, glWrapT);

unbind();

}

/**

public float maxTexcoordU() {

return maxTexcoordU;

}

/**

public float maxTexcoordV() {

return maxTexcoordV;

}

/**

public boolean invertedX() {

return invertedX;

}

/**

public void invertedX(boolean v) {

invertedX = v;

}

/**

public boolean invertedY() {

return invertedY;

}

/**

public void invertedY(boolean v) {

invertedY = v;

}

public int currentSampling() {

if (glMagFilter == PGL.NEAREST && glMinFilter == PGL.NEAREST) {

return POINT;

} else if (glMagFilter == PGL.NEAREST &&

glMinFilter == (PGL.MIPMAPS_ENABLED ? PGL.LINEAR_MIPMAP_NEAREST : PGL.LINEAR)) {

return LINEAR;

} else if (glMagFilter == PGL.LINEAR &&

glMinFilter == (PGL.MIPMAPS_ENABLED ? PGL.LINEAR_MIPMAP_NEAREST : PGL.LINEAR)) {

return BILINEAR;

} else if (glMagFilter == PGL.LINEAR &&

glMinFilter == PGL.LINEAR_MIPMAP_LINEAR) {

return TRILINEAR;

} else {

return -1;

}

}

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

// Bind/unbind

public void bind() {

// Binding a texture automatically enables texturing for the

// texture target from that moment onwards. Unbinding the texture

// won't disable texturing.

if (!pgl.texturingIsEnabled(glTarget)) {

pgl.enableTexturing(glTarget);

}

pgl.bindTexture(glTarget, glName);

bound = true;

}

public void unbind() {

if (pgl.textureIsBound(glTarget, glName)) {

// We don't want to unbind another texture

// that might be bound instead of this one.

if (!pgl.texturingIsEnabled(glTarget)) {

pgl.enableTexturing(glTarget);

pgl.bindTexture(glTarget, 0);

pgl.disableTexturing(glTarget);

} else {

pgl.bindTexture(glTarget, 0);

}

}

bound = false;

}

public boolean bound() {

// A true result might not necessarily mean that texturing is enabled

// (a texture can be bound to the target, but texturing is disabled).

return bound;

}

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

// Modified flag

public boolean isModified() {

return modified;

}

public void setModified() {

modified = true;

}

public void setModified(boolean m) {

modified = m;

}

public int getModifiedX1() {

return mx1;

}

public int getModifiedX2() {

return mx2;

}

public int getModifiedY1() {

return my1;

}

public int getModifiedY2() {

return my2;

}

public void updateTexels() {

updateTexelsImpl(0, 0, width, height);

}

public void updateTexels(int x, int y, int w, int h) {

updateTexelsImpl(x, y, w, h);

}

protected void updateTexelsImpl(int x, int y, int w, int h) {

int x2 = x + w;

int y2 = y + h;

if (!modified) {

mx1 = PApplet.max(0, x);

mx2 = PApplet.min(width - 1, x2);

my1 = PApplet.max(0, y);

my2 = PApplet.min(height - 1, y2);

modified = true;

} else {

if (x < mx1) mx1 = PApplet.max(0, x);

if (x > mx2) mx2 = PApplet.min(width - 1, x);

if (y < my1) my1 = PApplet.max(0, y);

if (y > my2) my2 = y;

if (x2 < mx1) mx1 = PApplet.max(0, x2);

if (x2 > mx2) mx2 = PApplet.min(width - 1, x2);

if (y2 < my1) my1 = PApplet.max(0, y2);

if (y2 > my2) my2 = PApplet.min(height - 1, y2);

}

}

protected void loadPixels(int len) {

if (rgbaPixels == null || rgbaPixels.length < len) {

rgbaPixels = new int[len];

}

}

protected void updatePixelBuffer(int[] pixels) {

pixelBuffer = PGL.updateIntBuffer(pixelBuffer, pixels, true);

pixBufUpdateCount++;

}

protected void manualMipmap() {

// TODO: finish manual mipmap generation,

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

}

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

// Buffer sink interface.

public void setBufferSource(Object source) {

bufferSource = source;

getSourceMethods();

}

public void copyBufferFromSource(Object natRef, ByteBuffer byteBuf,

int w, int h) {

if (bufferCache == null) {

bufferCache = new LinkedList<BufferData>();

}

if (bufferCache.size() + 1 <= MAX_BUFFER_CACHE_SIZE) {

bufferCache.add(new BufferData(natRef, byteBuf.asIntBuffer(), w, h));

} else {

// The buffer cache reached the maximum size, so we just dispose

// the new buffer by adding it to the list of used buffers.

try {

usedBuffers.add(new BufferData(natRef, byteBuf.asIntBuffer(), w, h));

} catch (Exception e) {

e.printStackTrace();

}

}

}

public void disposeSourceBuffer() {

if (usedBuffers == null) return;

while (0 < usedBuffers.size()) {

BufferData data = null;

try {

data = usedBuffers.remove(0);

} catch (NoSuchElementException ex) {

PGraphics.showWarning("Cannot remove used buffer");

}

if (data != null) {

data.dispose();

}

}

}

public void getBufferPixels(int[] pixels) {

// We get the buffer either from the used buffers or the cache, giving

// priority to the used buffers. Why? Because the used buffer was already

// transferred to the texture, so the pixels should be in sync with the

// texture.

BufferData data = null;

if (usedBuffers != null && 0 < usedBuffers.size()) {

data = usedBuffers.getLast();

} else if (bufferCache != null && 0 < bufferCache.size()) {

data = bufferCache.getLast();

}

if (data != null) {

if ((data.w != width) || (data.h != height)) {

init(data.w, data.h);

}

data.rgbBuf.rewind();

data.rgbBuf.get(pixels);

convertToARGB(pixels);

// In order to avoid a cached buffer to overwrite the texture when the

// renderer draws the texture, and hence put the pixels put of sync, we

// simply empty the cache.

if (usedBuffers == null) {

usedBuffers = new LinkedList<BufferData>();

}

while (0 < bufferCache.size()) {

data = bufferCache.remove(0);

usedBuffers.add(data);

}

}

}

public boolean hasBufferSource() {

return bufferSource != null;

}

public boolean hasBuffers() {

return bufferSource != null && bufferCache != null &&

0 < bufferCache.size();

}

protected boolean bufferUpdate() {

BufferData data = null;

try {

data = bufferCache.remove(0);

} catch (NoSuchElementException ex) {

PGraphics.showWarning("Don't have pixel data to copy to texture");

}

if (data != null) {

if ((data.w != width) || (data.h != height)) {

init(data.w, data.h);

}

data.rgbBuf.rewind();

setNative(data.rgbBuf, 0, 0, width, height);

// Putting the buffer in the used buffers list to dispose at the end of

// draw.

if (usedBuffers == null) {

usedBuffers = new LinkedList<BufferData>();

}

usedBuffers.add(data);

return true;

} else {

return false;

}

}

protected void getSourceMethods() {

try {

disposeBufferMethod = bufferSource.getClass().

getMethod("disposeBuffer", new Class[] { Object.class });

} catch (Exception e) {

throw new RuntimeException("Provided source object doesn't have a " +

"disposeBuffer method.");

}

}

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

// Utilities

/**

protected void flipArrayOnX(int[] intArray, int mult) {

int index = 0;

int xindex = mult * (width - 1);

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

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

int i = index + mult * y * width;

int j = xindex + mult * y * width;

for (int c = 0; c < mult; c++) {

int temp = intArray[i];

intArray[i] = intArray[j];

intArray[j] = temp;

i++;

j++;

}

}

index += mult;

xindex -= mult;

}

}

/**

protected void flipArrayOnY(int[] intArray, int mult) {

int index = 0;

int yindex = mult * (height - 1) * width;

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

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

int temp = intArray[index];

intArray[index] = intArray[yindex];

intArray[yindex] = temp;

index++;

yindex++;

}

yindex -= mult * width * 2;

}

}

/**

protected void convertToRGBA(int[] pixels, int format, int w, int h) {

if (PGL.BIG_ENDIAN) {