// Testing these constants, not use as they might go away...

static public final int POSITION = 0;

static public final int NORMAL = 1;

static public final int TEXCOORD = 2;

static public final int DIRECTION = 3;

static public final int OFFSET = 4;

static protected final int TRANSLATE = 0;

static protected final int ROTATE = 1;

static protected final int SCALE = 2;

static protected final int MATRIX = 3;

protected PGraphicsOpenGL pg;

protected PGL pgl;

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

protected PShapeOpenGL root;

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

// Input, tessellated geometry

protected InGeometry inGeo;

protected TessGeometry tessGeo;

protected Tessellator tessellator;

protected AttributeMap polyAttribs;

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

// Texturing

protected HashSet<PImage> textures;

protected boolean strokedTexture;

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

// OpenGL buffers

protected VertexBuffer bufPolyVertex;

protected VertexBuffer bufPolyColor;

protected VertexBuffer bufPolyNormal;

protected VertexBuffer bufPolyTexcoord;

protected VertexBuffer bufPolyAmbient;

protected VertexBuffer bufPolySpecular;

protected VertexBuffer bufPolyEmissive;

protected VertexBuffer bufPolyShininess;

protected VertexBuffer bufPolyIndex;

protected VertexBuffer bufLineVertex;

protected VertexBuffer bufLineColor;

protected VertexBuffer bufLineAttrib;

protected VertexBuffer bufLineIndex;

protected VertexBuffer bufPointVertex;

protected VertexBuffer bufPointColor;

protected VertexBuffer bufPointAttrib;

protected VertexBuffer bufPointIndex;

// Testing this field, not use as it might go away...

public int glUsage = PGL.STATIC_DRAW;

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

// Offsets for geometry aggregation and update.

protected int polyVertCopyOffset;

protected int polyIndCopyOffset;

protected int lineVertCopyOffset;

protected int lineIndCopyOffset;

protected int pointVertCopyOffset;

protected int pointIndCopyOffset;

protected int polyIndexOffset;

protected int polyVertexOffset;

protected int polyVertexAbs;

protected int polyVertexRel;

protected int lineIndexOffset;

protected int lineVertexOffset;

protected int lineVertexAbs;

protected int lineVertexRel;

protected int pointIndexOffset;

protected int pointVertexOffset;

protected int pointVertexAbs;

protected int pointVertexRel;

protected int firstPolyIndexCache;

protected int lastPolyIndexCache;

protected int firstLineIndexCache;

protected int lastLineIndexCache;

protected int firstPointIndexCache;

protected int lastPointIndexCache;

protected int firstPolyVertex;

protected int lastPolyVertex;

protected int firstLineVertex;

protected int lastLineVertex;

protected int firstPointVertex;

protected int lastPointVertex;

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

// Geometric transformations.

protected PMatrix transform;

protected Stack<PMatrix> transformStack;

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

// State/rendering flags

protected boolean tessellated;

protected boolean needBufferInit = false;

// Flag to indicate if the shape can have holes or not.

protected boolean solid = true;

protected boolean breakShape = false;

protected boolean shapeCreated = false;

// These variables indicate if the shape contains

// polygon, line and/or point geometry. In the case of

// 3D shapes, poly geometry is coincident with the fill

// triangles, as the lines and points are stored separately.

// However, for 2D shapes the poly geometry contains all of

// the three since the same rendering shader applies to

// fill, line and point geometry.

protected boolean hasPolys;

protected boolean hasLines;

protected boolean hasPoints;

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

// Bezier and Catmull-Rom curves

protected int bezierDetail;

protected int curveDetail;

protected float curveTightness;

protected int savedBezierDetail;

protected int savedCurveDetail;

protected float savedCurveTightness;

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

// Normals

protected float normalX, normalY, normalZ;

// normal calculated per triangle

static protected final int NORMAL_MODE_AUTO = 0;

// one normal manually specified per shape

static protected final int NORMAL_MODE_SHAPE = 1;

// normals specified for each shape vertex

static protected final int NORMAL_MODE_VERTEX = 2;

// Current mode for normals, one of AUTO, SHAPE, or VERTEX

protected int normalMode;

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

// Modification variables (used only by the root shape)

protected boolean modified;

protected boolean modifiedPolyVertices;

protected boolean modifiedPolyColors;

protected boolean modifiedPolyNormals;

protected boolean modifiedPolyTexCoords;

protected boolean modifiedPolyAmbient;

protected boolean modifiedPolySpecular;

protected boolean modifiedPolyEmissive;

protected boolean modifiedPolyShininess;

protected boolean modifiedLineVertices;

protected boolean modifiedLineColors;

protected boolean modifiedLineAttributes;

protected boolean modifiedPointVertices;

protected boolean modifiedPointColors;

protected boolean modifiedPointAttributes;

protected int firstModifiedPolyVertex;

protected int lastModifiedPolyVertex;

protected int firstModifiedPolyColor;

protected int lastModifiedPolyColor;

protected int firstModifiedPolyNormal;

protected int lastModifiedPolyNormal;

protected int firstModifiedPolyTexcoord;

protected int lastModifiedPolyTexcoord;

protected int firstModifiedPolyAmbient;

protected int lastModifiedPolyAmbient;

protected int firstModifiedPolySpecular;

protected int lastModifiedPolySpecular;

protected int firstModifiedPolyEmissive;

protected int lastModifiedPolyEmissive;

protected int firstModifiedPolyShininess;

protected int lastModifiedPolyShininess;

protected int firstModifiedLineVertex;

protected int lastModifiedLineVertex;

protected int firstModifiedLineColor;

protected int lastModifiedLineColor;

protected int firstModifiedLineAttribute;

protected int lastModifiedLineAttribute;

protected int firstModifiedPointVertex;

protected int lastModifiedPointVertex;

protected int firstModifiedPointColor;

protected int lastModifiedPointColor;

protected int firstModifiedPointAttribute;

protected int lastModifiedPointAttribute;

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

// Saved style variables to style can be re-enabled after disableStyle,

// although it won't work if properties are defined on a per-vertex basis.

protected boolean savedStroke;

protected int savedStrokeColor;

protected float savedStrokeWeight;

protected int savedStrokeCap;

protected int savedStrokeJoin;

protected boolean savedFill;

protected int savedFillColor;

protected boolean savedTint;

protected int savedTintColor;

protected int savedAmbientColor;

protected int savedSpecularColor;

protected int savedEmissiveColor;

protected float savedShininess;

protected int savedTextureMode;

PShapeOpenGL() {

}

public PShapeOpenGL(PGraphicsOpenGL pg, int family) {

this.pg = pg;

this.family = family;

pgl = pg.pgl;

context = pgl.createEmptyContext();

bufPolyVertex = null;

bufPolyColor = null;

bufPolyNormal = null;

bufPolyTexcoord = null;

bufPolyAmbient = null;

bufPolySpecular = null;

bufPolyEmissive = null;

bufPolyShininess = null;

bufPolyIndex = null;

bufLineVertex = null;

bufLineColor = null;

bufLineAttrib = null;

bufLineIndex = null;

bufPointVertex = null;

bufPointColor = null;

bufPointAttrib = null;

bufPointIndex = null;

this.tessellator = pg.tessellator;

this.root = this;

this.parent = null;

this.tessellated = false;

if (family == GEOMETRY || family == PRIMITIVE || family == PATH) {

polyAttribs = PGraphicsOpenGL.newAttributeMap();

inGeo = PGraphicsOpenGL.newInGeometry(pg, polyAttribs, PGraphicsOpenGL.RETAINED);

}

// Style parameters are retrieved from the current values in the renderer.

textureMode = pg.textureMode;

colorMode(pg.colorMode,

pg.colorModeX, pg.colorModeY, pg.colorModeZ, pg.colorModeA);

// Initial values for fill, stroke and tint colors are also imported from

// the renderer. This is particular relevant for primitive shapes, since is

// not possible to set their color separately when creating them, and their

// input vertices are actually generated at rendering time, by which the

// color configuration of the renderer might have changed.

fill = pg.fill;

fillColor = pg.fillColor;

stroke = pg.stroke;

strokeColor = pg.strokeColor;

strokeWeight = pg.strokeWeight;

strokeCap = pg.strokeCap;

strokeJoin = pg.strokeJoin;

tint = pg.tint;

tintColor = pg.tintColor;

setAmbient = pg.setAmbient;

ambientColor = pg.ambientColor;

specularColor = pg.specularColor;

emissiveColor = pg.emissiveColor;

shininess = pg.shininess;

sphereDetailU = pg.sphereDetailU;

sphereDetailV = pg.sphereDetailV;

bezierDetail = pg.bezierDetail;

curveDetail = pg.curveDetail;

curveTightness = pg.curveTightness;

rectMode = pg.rectMode;

ellipseMode = pg.ellipseMode;

normalX = normalY = 0;

normalZ = 1;

normalMode = NORMAL_MODE_AUTO;

// To make sure that the first vertex is marked as a break.

// Same behavior as in the immediate mode.

breakShape = false;

if (family == GROUP) {

// GROUP shapes are always marked as ended.

shapeCreated = true;

}

// OpenGL supports per-vertex coloring (unlike Java2D)

perVertexStyles = true;

}

/** Create a shape from the PRIMITIVE family, using this kind and these params */

public PShapeOpenGL(PGraphicsOpenGL pg, int kind, float... p) {

this(pg, PRIMITIVE);

setKind(kind);

setParams(p);

}

@Override

public void addChild(PShape who) {

if (who instanceof PShapeOpenGL) {

if (family == GROUP) {

PShapeOpenGL c3d = (PShapeOpenGL)who;

super.addChild(c3d);

c3d.updateRoot(root);

markForTessellation();

if (c3d.family == GROUP) {

if (c3d.textures != null) {

for (PImage tex: c3d.textures) {

addTexture(tex);

}

}

if (c3d.strokedTexture) {

strokedTexture(true);

}

} else {

if (c3d.image != null) {

addTexture(c3d.image);

if (c3d.stroke) {

strokedTexture(true);

}

}

}

} else {

PGraphics.showWarning("Cannot add child shape to non-group shape.");

}

} else {

PGraphics.showWarning("Shape must be OpenGL to be added to the group.");

}

}

@Override

public void addChild(PShape who, int idx) {

if (who instanceof PShapeOpenGL) {

if (family == GROUP) {

PShapeOpenGL c3d = (PShapeOpenGL)who;

super.addChild(c3d, idx);

c3d.updateRoot(root);

markForTessellation();

if (c3d.family == GROUP) {

if (c3d.textures != null) {

for (PImage tex: c3d.textures) {

addTexture(tex);

}

}

if (c3d.strokedTexture) {

strokedTexture(true);

}

} else {

if (c3d.image != null) {

addTexture(c3d.image);

if (c3d.stroke) {

strokedTexture(true);

}

}

}

} else {

PGraphics.showWarning("Cannot add child shape to non-group shape.");

}

} else {

PGraphics.showWarning("Shape must be OpenGL to be added to the group.");

}

}

@Override

public void removeChild(int idx) {

super.removeChild(idx);

markForTessellation();

}

protected void updateRoot(PShape root) {

this.root = (PShapeOpenGL) root;

if (family == GROUP) {

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

PShapeOpenGL child = (PShapeOpenGL)children[i];

child.updateRoot(root);

}

}

}

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

//

// Shape creation (temporary hack)

public static PShapeOpenGL createShape(PGraphicsOpenGL pg, PShape src) {

PShapeOpenGL dest = null;

if (src.getFamily() == GROUP) {

//dest = PGraphics3D.createShapeImpl(pg, GROUP);

dest = (PShapeOpenGL) pg.createShapeFamily(GROUP);

copyGroup(pg, src, dest);

} else if (src.getFamily() == PRIMITIVE) {

//dest = PGraphics3D.createShapeImpl(pg, src.getKind(), src.getParams());

dest = (PShapeOpenGL) pg.createShapePrimitive(src.getKind(), src.getParams());

PShape.copyPrimitive(src, dest);

} else if (src.getFamily() == GEOMETRY) {

//dest = PGraphics3D.createShapeImpl(pg, PShape.GEOMETRY);

dest = (PShapeOpenGL) pg.createShapeFamily(PShape.GEOMETRY);

PShape.copyGeometry(src, dest);

} else if (src.getFamily() == PATH) {

dest = (PShapeOpenGL) pg.createShapeFamily(PShape.PATH);

//dest = PGraphics3D.createShapeImpl(pg, PATH);

PShape.copyPath(src, dest);

}

dest.setName(src.getName());

dest.width = src.width;

dest.height = src.height;

dest.depth = src.depth;

return dest;

}

/*

static public void copyGroup(PGraphicsOpenGL pg, PShape src, PShape dest) {

copyMatrix(src, dest);

copyStyles(src, dest);

copyImage(src, dest);

for (int i = 0; i < src.getChildCount(); i++) {

PShape c = createShape(pg, src.getChild(i));

dest.addChild(c);

}

}

/*

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

//

// Query methods

@Override

public float getWidth() {

PVector min = new PVector(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY,

Float.POSITIVE_INFINITY);

PVector max = new PVector(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY,

Float.NEGATIVE_INFINITY);

if (shapeCreated) {

getVertexMin(min);

getVertexMax(max);

}

width = max.x - min.x;

return width;

}

@Override

public float getHeight() {

PVector min = new PVector(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY,

Float.POSITIVE_INFINITY);

PVector max = new PVector(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY,

Float.NEGATIVE_INFINITY);

if (shapeCreated) {

getVertexMin(min);

getVertexMax(max);

}

height = max.y - min.y;

return height;

}

@Override

public float getDepth() {

PVector min = new PVector(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY,

Float.POSITIVE_INFINITY);

PVector max = new PVector(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY,

Float.NEGATIVE_INFINITY);

if (shapeCreated) {

getVertexMin(min);

getVertexMax(max);

}

depth = max.z - min.z;

return depth;

}

protected void getVertexMin(PVector min) {

updateTessellation();

if (family == GROUP) {

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

PShapeOpenGL child = (PShapeOpenGL) children[i];

child.getVertexMin(min);

}

} else {

if (hasPolys) {

tessGeo.getPolyVertexMin(min, firstPolyVertex, lastPolyVertex);

}

if (is3D()) {

if (hasLines) {

tessGeo.getLineVertexMin(min, firstLineVertex, lastLineVertex);

}

if (hasPoints) {

tessGeo.getPointVertexMin(min, firstPointVertex, lastPointVertex);

}

}

}

}

protected void getVertexMax(PVector max) {

updateTessellation();

if (family == GROUP) {

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

PShapeOpenGL child = (PShapeOpenGL) children[i];

child.getVertexMax(max);

}

} else {

if (hasPolys) {

tessGeo.getPolyVertexMax(max, firstPolyVertex, lastPolyVertex);

}

if (is3D()) {

if (hasLines) {

tessGeo.getLineVertexMax(max, firstLineVertex, lastLineVertex);

}

if (hasPoints) {

tessGeo.getPointVertexMax(max, firstPointVertex, lastPointVertex);

}

}

}

}

protected int getVertexSum(PVector sum, int count) {

updateTessellation();

if (family == GROUP) {

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

PShapeOpenGL child = (PShapeOpenGL) children[i];

count += child.getVertexSum(sum, count);

}

} else {

if (hasPolys) {

count += tessGeo.getPolyVertexSum(sum, firstPolyVertex, lastPolyVertex);

}

if (is3D()) {

if (hasLines) {

count += tessGeo.getLineVertexSum(sum, firstLineVertex,

lastLineVertex);

}

if (hasPoints) {

count += tessGeo.getPointVertexSum(sum, firstPointVertex,

lastPointVertex);

}

}

}

return count;

}

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

//

// Drawing methods

@Override

public void setTextureMode(int mode) {

if (openShape) {

PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setTextureMode()");

return;

}

if (family == GROUP) {

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

PShapeOpenGL child = (PShapeOpenGL) children[i];

child.setTextureMode(mode);

}

} else {

setTextureModeImpl(mode);

}

}

protected void setTextureModeImpl(int mode) {

if (textureMode == mode) return;

textureMode = mode;

if (image != null) {

float uFactor = image.width;

float vFactor = image.height;

if (textureMode == NORMAL) {

uFactor = 1.0f / uFactor;

vFactor = 1.0f / vFactor;

}

scaleTextureUV(uFactor, vFactor);

}

}

@Override

public void setTexture(PImage tex) {

if (openShape) {

PGraphics.showWarning(INSIDE_BEGIN_END_ERROR, "setTexture()");

return;

}

if (family == GROUP) {

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

PShapeOpenGL child = (PShapeOpenGL) children[i];

child.setTexture(tex);

}

} else {

setTextureImpl(tex);

}

}

protected void setTextureImpl(PImage tex) {

PImage image0 = image;

image = tex;

if (textureMode == IMAGE && image0 != image) {

// Need to rescale the texture coordinates

float uFactor = 1;

float vFactor = 1;

if (image != null) {

uFactor /= image.width;

vFactor /= image.height;

}

if (image0 != null) {

uFactor *= image0.width;

vFactor *= image0.height;

}

scaleTextureUV(uFactor, vFactor);

}

if (image0 != tex && parent != null) {

((PShapeOpenGL)parent).removeTexture(tex);

}

if (parent != null) {

((PShapeOpenGL)parent).addTexture(image);

if (is2D() && stroke) {

((PShapeOpenGL)parent).strokedTexture(true);

}

}

}

protected void scaleTextureUV(float uFactor, float vFactor) {

if (PGraphicsOpenGL.same(uFactor, 1) &&

PGraphicsOpenGL.same(vFactor, 1)) return;

for (int i = 0; i < inGeo.vertexCount; i++) {

float u = inGeo.texcoords[2 * i + 0];

float v = inGeo.texcoords[2 * i + 1];

inGeo.texcoords[2 * i + 0] = PApplet.min(1, u * uFactor);

inGeo.texcoords[2 * i + 1] = PApplet.min(1, v * uFactor);

}

if (shapeCreated && tessellated && hasPolys) {

int last1 = 0;

if (is3D()) {

last1 = lastPolyVertex + 1;

} else if (is2D()) {

last1 = lastPolyVertex + 1;

if (-1 < firstLineVertex) last1 = firstLineVertex;

if (-1 < firstPointVertex) last1 = firstPointVertex;

}

for (int i = firstLineVertex; i < last1; i++) {

float u = tessGeo.polyTexCoords[2 * i + 0];

float v = tessGeo.polyTexCoords[2 * i + 1];

tessGeo.polyTexCoords[2 * i + 0] = PApplet.min(1, u * uFactor);

tessGeo.polyTexCoords[2 * i + 1] = PApplet.min(1, v * uFactor);

}

root.setModifiedPolyTexCoords(firstPolyVertex, last1 - 1);

}

}

protected void addTexture(PImage tex) {

if (textures == null) {

textures = new HashSet<PImage>();

}

textures.add(tex);

if (parent != null) {

((PShapeOpenGL)parent).addTexture(tex);

}

}

protected void removeTexture(PImage tex) {

if (textures == null || !textures.contains(tex)) return; // Nothing to remove.

// First check that none of the child shapes

// have texture tex...

boolean childHasTex = false;

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

PShapeOpenGL child = (PShapeOpenGL) children[i];

if (child.hasTexture(tex)) {

childHasTex = true;

break;

}

}

if (!childHasTex) {

// ...if not, it is safe to remove from this shape.

textures.remove(tex);

if (textures.size() == 0) {

textures = null;

}

}

// Since this shape and all its child shapes don't contain

// tex anymore, we now can remove it from the parent.

if (parent != null) {

((PShapeOpenGL)parent).removeTexture(tex);

}

}

protected void strokedTexture(boolean newValue) {

if (strokedTexture == newValue) return; // Nothing to change.

if (newValue) {

strokedTexture = true;

} else {

// First check that none of the child shapes

// have have a stroked texture...

boolean childHasStrokedTex = false;

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

PShapeOpenGL child = (PShapeOpenGL) children[i];

if (child.hasStrokedTexture()) {

childHasStrokedTex = true;

break;

}

}

if (!childHasStrokedTex) {

// ...if not, it is safe to mark this shape as without

// stroked texture.

strokedTexture = false;

}

}

// Now we can update the parent shape.

if (parent != null) {

((PShapeOpenGL)parent).strokedTexture(newValue);

}

}

protected boolean hasTexture(PImage tex) {

if (family == GROUP) {

return textures != null && textures.contains(tex);

} else {

return image == tex;

}

}

protected boolean hasStrokedTexture() {

if (family == GROUP) {

return strokedTexture;

} else {

return image != null && stroke;

}

}

@Override

public void solid(boolean solid) {

if (family == GROUP) {

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

PShapeOpenGL child = (PShapeOpenGL) children[i];

child.solid(solid);

}

} else {

this.solid = solid;

}

}

@Override

protected void beginContourImpl() {

breakShape = true;

}

@Override

protected void endContourImpl() {

}

@Override

public void vertex(float x, float y) {

vertexImpl(x, y, 0, 0, 0);

if (image != null)

PGraphics.showWarning(PGraphicsOpenGL.MISSING_UV_TEXCOORDS_ERROR);

}

@Override

public void vertex(float x, float y, float u, float v) {

vertexImpl(x, y, 0, u, v);

}

@Override

public void vertex(float x, float y, float z) {

vertexImpl(x, y, z, 0, 0);

if (image != null)

PGraphics.showWarning(PGraphicsOpenGL.MISSING_UV_TEXCOORDS_ERROR);

}

@Override

public void vertex(float x, float y, float z, float u, float v) {

vertexImpl(x, y, z, u, v);

}

protected void vertexImpl(float x, float y, float z, float u, float v) {

if (!openShape) {

PGraphics.showWarning(OUTSIDE_BEGIN_END_ERROR, "vertex()");

return;

}

if (family == GROUP) {

PGraphics.showWarning("Cannot add vertices to GROUP shape");

return;

}

boolean textured = image != null;

int fcolor = 0x00;

if (fill || textured) {

if (!textured) {

fcolor = fillColor;

} else {

if (tint) {

fcolor = tintColor;

} else {

fcolor = 0xffFFFFFF;

}