PMatrix2D ctm = new PMatrix2D();

//PPolygon polygon; // general polygon to use for shape

PPolygon fpolygon; // used to fill polys for tri or quad strips

PPolygon spolygon; // stroke/line polygon

float svertices[][]; // temp vertices used for stroking end of poly

PPolygon tpolygon;

int[] vertexOrder;

PLine line;

float[][] matrixStack = new float[MATRIX_STACK_DEPTH][6];

int matrixStackDepth;

DirectColorModel cm;

MemoryImageSource mis;

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

public PGraphics2D() { }

//public void setParent(PApplet parent)

//public void setPrimary(boolean primary)

//public void setPath(String path)

//public void setSize(int iwidth, int iheight)

protected void allocate() {

pixelCount = width * height;

pixels = new int[pixelCount];

if (primarySurface) {

cm = new DirectColorModel(32, 0x00ff0000, 0x0000ff00, 0x000000ff);;

mis = new MemoryImageSource(width, height, pixels, 0, width);

mis.setFullBufferUpdates(true);

mis.setAnimated(true);

image = Toolkit.getDefaultToolkit().createImage(mis);

}

}

//public void dispose()

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

public boolean canDraw() {

return true;

}

public void beginDraw() {

// need to call defaults(), but can only be done when it's ok to draw

// (i.e. for OpenGL, no drawing can be done outside beginDraw/endDraw).

if (!settingsInited) {

defaultSettings();

fpolygon = new PPolygon(this);

spolygon = new PPolygon(this);

spolygon.vertexCount = 4;

svertices = new float[2][];

}

resetMatrix(); // reset model matrix

// reset vertices

vertexCount = 0;

}

public void endDraw() {

if (mis != null) {

mis.newPixels(pixels, cm, 0, width);

}

// mark pixels as having been updated, so that they'll work properly

// when this PGraphics is drawn using image().

updatePixels();

}

// public void flush()

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

//protected void checkSettings()

//protected void defaultSettings()

//protected void reapplySettings()

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

//public void hint(int which)

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

//public void beginShape()

public void beginShape(int kind) {

shape = kind;

vertexCount = 0;

curveVertexCount = 0;

fpolygon.reset(4);

spolygon.reset(4);

textureImage = null;

}

//public void edge(boolean e)

//public void normal(float nx, float ny, float nz)

//public void textureMode(int mode)

//public void texture(PImage image)

/*

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

showDepthWarningXYZ("vertex");

}

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

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

showDepthWarningXYZ("vertex");

}

//protected void vertexTexture(float u, float v);

public void breakShape() {

showWarning("This renderer cannot handle concave shapes " +

"or shapes with holes.");

}

//public void endShape()

public void endShape(int mode) {

if (ctm.isIdentity()) {

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

vertices[i][TX] = vertices[i][X];

vertices[i][TY] = vertices[i][Y];

}

} else {

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

vertices[i][TX] = ctm.multX(vertices[i][X], vertices[i][Y]);

vertices[i][TY] = ctm.multY(vertices[i][X], vertices[i][Y]);

}

}

// ------------------------------------------------------------------

// TEXTURES

fpolygon.texture(textureImage);

// ------------------------------------------------------------------

// COLORS

// calculate RGB for each vertex

spolygon.interpARGB = true; //strokeChanged; //false;

fpolygon.interpARGB = true; //fillChanged; //false;

// all the values for r, g, b have been set with calls to vertex()

// (no need to re-calculate anything here)

// ------------------------------------------------------------------

// RENDER SHAPES

int increment;

switch (shape) {

case POINTS:

// stroke cannot change inside beginShape(POINTS);

if (stroke) {

if ((ctm.m00 == ctm.m11) && (strokeWeight == 1)) {

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

thin_point(vertices[i][TX], vertices[i][TY], strokeColor);

}

} else {

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

float[] v = vertices[i];

thick_point(v[TX], v[TY], v[TZ], v[SR], v[SG], v[SB], v[SA]);

}

}

}

break;

case LINES:

if (stroke) {

// increment by two for individual lines

increment = (shape == LINES) ? 2 : 1;

draw_lines(vertices, vertexCount-1, 1, increment, 0);

}

break;

case TRIANGLE_FAN:

// do fill and stroke separately because otherwise

// the lines will be stroked more than necessary

if (fill || textureImage != null) {

fpolygon.vertexCount = 3;

for (int i = 1; i < vertexCount-1; i++) {

fpolygon.vertices[2][R] = vertices[0][R];

fpolygon.vertices[2][G] = vertices[0][G];

fpolygon.vertices[2][B] = vertices[0][B];

fpolygon.vertices[2][A] = vertices[0][A];

fpolygon.vertices[2][TX] = vertices[0][TX];

fpolygon.vertices[2][TY] = vertices[0][TY];

if (textureImage != null) {

fpolygon.vertices[2][U] = vertices[0][U];

fpolygon.vertices[2][V] = vertices[0][V];

}

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

fpolygon.vertices[j][R] = vertices[i+j][R];

fpolygon.vertices[j][G] = vertices[i+j][G];

fpolygon.vertices[j][B] = vertices[i+j][B];

fpolygon.vertices[j][A] = vertices[i+j][A];

fpolygon.vertices[j][TX] = vertices[i+j][TX];

fpolygon.vertices[j][TY] = vertices[i+j][TY];

if (textureImage != null) {

fpolygon.vertices[j][U] = vertices[i+j][U];

fpolygon.vertices[j][V] = vertices[i+j][V];

}

}

fpolygon.render();

}

}

if (stroke) {

// draw internal lines

for (int i = 1; i < vertexCount; i++) {

draw_line(vertices[0], vertices[i]);

}

// draw a ring around the outside

for (int i = 1; i < vertexCount-1; i++) {

draw_line(vertices[i], vertices[i+1]);

}

// close the shape

draw_line(vertices[vertexCount-1], vertices[1]);

}

break;

case TRIANGLES:

case TRIANGLE_STRIP:

increment = (shape == TRIANGLES) ? 3 : 1;

// do fill and stroke separately because otherwise

// the lines will be stroked more than necessary

if (fill || textureImage != null) {

fpolygon.vertexCount = 3;

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

for (int j = 0; j < 3; j++) {

fpolygon.vertices[j][R] = vertices[i+j][R];

fpolygon.vertices[j][G] = vertices[i+j][G];

fpolygon.vertices[j][B] = vertices[i+j][B];

fpolygon.vertices[j][A] = vertices[i+j][A];

fpolygon.vertices[j][TX] = vertices[i+j][TX];

fpolygon.vertices[j][TY] = vertices[i+j][TY];

fpolygon.vertices[j][TZ] = vertices[i+j][TZ];

if (textureImage != null) {

fpolygon.vertices[j][U] = vertices[i+j][U];

fpolygon.vertices[j][V] = vertices[i+j][V];

}

}

fpolygon.render();

}

}

if (stroke) {

// first draw all vertices as a line strip

if (shape == TRIANGLE_STRIP) {

draw_lines(vertices, vertexCount-1, 1, 1, 0);

} else {

draw_lines(vertices, vertexCount-1, 1, 1, 3);

}

// then draw from vertex (n) to (n+2)

// incrementing n using the same as above

draw_lines(vertices, vertexCount-2, 2, increment, 0);

// changed this to vertexCount-2, because it seemed

// to be adding an extra (nonexistant) line

}

break;

case QUADS:

if (fill || textureImage != null) {

fpolygon.vertexCount = 4;

for (int i = 0; i < vertexCount-3; i += 4) {

for (int j = 0; j < 4; j++) {

int jj = i+j;

fpolygon.vertices[j][R] = vertices[jj][R];

fpolygon.vertices[j][G] = vertices[jj][G];

fpolygon.vertices[j][B] = vertices[jj][B];

fpolygon.vertices[j][A] = vertices[jj][A];

fpolygon.vertices[j][TX] = vertices[jj][TX];

fpolygon.vertices[j][TY] = vertices[jj][TY];

fpolygon.vertices[j][TZ] = vertices[jj][TZ];

if (textureImage != null) {

fpolygon.vertices[j][U] = vertices[jj][U];

fpolygon.vertices[j][V] = vertices[jj][V];

}

}

fpolygon.render();

}

}

if (stroke) {

for (int i = 0; i < vertexCount-3; i += 4) {

draw_line(vertices[i+0], vertices[i+1]);

draw_line(vertices[i+1], vertices[i+2]);

draw_line(vertices[i+2], vertices[i+3]);

draw_line(vertices[i+3], vertices[i+0]);

}

}

break;

case QUAD_STRIP:

if (fill || textureImage != null) {

fpolygon.vertexCount = 4;

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

for (int j = 0; j < 4; j++) {

int jj = i+j;

if (j == 2) jj = i+3; // swap 2nd and 3rd vertex

if (j == 3) jj = i+2;

fpolygon.vertices[j][R] = vertices[jj][R];

fpolygon.vertices[j][G] = vertices[jj][G];

fpolygon.vertices[j][B] = vertices[jj][B];

fpolygon.vertices[j][A] = vertices[jj][A];

fpolygon.vertices[j][TX] = vertices[jj][TX];

fpolygon.vertices[j][TY] = vertices[jj][TY];

fpolygon.vertices[j][TZ] = vertices[jj][TZ];

if (textureImage != null) {

fpolygon.vertices[j][U] = vertices[jj][U];

fpolygon.vertices[j][V] = vertices[jj][V];

}

}

fpolygon.render();

}

}

if (stroke) {

draw_lines(vertices, vertexCount-1, 1, 2, 0); // inner lines

draw_lines(vertices, vertexCount-2, 2, 1, 0); // outer lines

}

break;

case POLYGON:

if (isConvex()) {

if (fill || textureImage != null) {

//System.out.println("convex");

fpolygon.renderPolygon(vertices, vertexCount);

//if (stroke) polygon.unexpand();

}

if (stroke) {

draw_lines(vertices, vertexCount-1, 1, 1, 0);

if (mode == CLOSE) {

// draw the last line connecting back to the first point in poly

//svertices[0] = vertices[vertexCount-1];

//svertices[1] = vertices[0];

//draw_lines(svertices, 1, 1, 1, 0);

draw_line(vertices[vertexCount-1], vertices[0]);

}

}

} else { // not convex

//System.out.println("concave");

if (fill || textureImage != null) {

// the triangulator produces polygons that don't align

// when smoothing is enabled. but if there is a stroke around

// the polygon, then smoothing can be temporarily disabled.

boolean smoov = smooth;

//if (stroke && !hints[DISABLE_SMOOTH_HACK]) smooth = false;

if (stroke) smooth = false;

concaveRender();

//if (stroke && !hints[DISABLE_SMOOTH_HACK]) smooth = smoov;

if (stroke) smooth = smoov;

}

if (stroke) {

draw_lines(vertices, vertexCount-1, 1, 1, 0);

if (mode == CLOSE) {

// draw the last line connecting back

// to the first point in poly

draw_line(vertices[vertexCount-1], vertices[0]);

}

}

}

break;

}

// to signify no shape being drawn

shape = 0;

}

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

// CONCAVE/CONVEX POLYGONS

private boolean isConvex() {

//float v[][] = polygon.vertices;

//int n = polygon.vertexCount;

//int j,k;

//float tol = 0.001f;

if (vertexCount < 3) {

// ERROR: this is a line or a point, render as convex

return true;

}

int flag = 0;

// iterate along border doing dot product.

// if the sign of the result changes, then is concave

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

float[] vi = vertices[i];

float[] vj = vertices[(i + 1) % vertexCount];

float[] vk = vertices[(i + 2) % vertexCount];

float calc = ((vj[TX] - vi[TX]) * (vk[TY] - vj[TY]) -

(vj[TY] - vi[TY]) * (vk[TX] - vj[TX]));

if (calc < 0) {

flag |= 1;

} else if (calc > 0) {

flag |= 2;

}

if (flag == 3) {

return false; // CONCAVE

}

}

if (flag != 0) {

return true; // CONVEX

} else {

// ERROR: colinear points, self intersection

// treat as CONVEX

return true;

}

}

/**

protected void concaveRender() {

if (vertexOrder == null || vertexOrder.length != vertices.length) {

vertexOrder = new int[vertices.length];

}

if (tpolygon == null) {

tpolygon = new PPolygon(this);

}

tpolygon.reset(3);

// first we check if the polygon goes clockwise or counterclockwise

float area = 0;

for (int p = vertexCount - 1, q = 0; q < vertexCount; p = q++) {

area += (vertices[q][X] * vertices[p][Y] -

vertices[p][X] * vertices[q][Y]);

}

// ain't nuthin there

if (area == 0) return;

// don't allow polygons to come back and meet themselves,

// otherwise it will anger the triangulator

// http://dev.processing.org/bugs/show_bug.cgi?id=97

float vfirst[] = vertices[0];

float vlast[] = vertices[vertexCount-1];

if ((Math.abs(vfirst[X] - vlast[X]) < EPSILON) &&

(Math.abs(vfirst[Y] - vlast[Y]) < EPSILON) &&

(Math.abs(vfirst[Z] - vlast[Z]) < EPSILON)) {

vertexCount--;

}

// then sort the vertices so they are always in a counterclockwise order

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

vertexOrder[i] = (area > 0) ? i : (vertexCount-1 - i);

}

// remove vc-2 Vertices, creating 1 triangle every time

int vc = vertexCount; // vc will be decremented while working

int count = 2*vc; // complex polygon detection

for (int m = 0, v = vc - 1; vc > 2; ) {

boolean snip = true;

// if we start over again, is a complex polygon

if (0 >= (count--)) {

break; // triangulation failed

}

// get 3 consecutive vertices <u,v,w>

int u = v ; if (vc <= u) u = 0; // previous

v = u + 1; if (vc <= v) v = 0; // current

int w = v + 1; if (vc <= w) w = 0; // next

// Upgrade values to doubles, and multiply by 10 so that we can have

// some better accuracy as we tessellate. This seems to have negligible

// speed differences on Windows and Intel Macs, but causes a 50% speed

// drop for PPC Macs with the bug's example code that draws ~200 points

// in a concave polygon. Apple has abandoned PPC so we may as well too.

// http://dev.processing.org/bugs/show_bug.cgi?id=774

// triangle A B C

double Ax = -10 * vertices[vertexOrder[u]][X];

double Ay = 10 * vertices[vertexOrder[u]][Y];

double Bx = -10 * vertices[vertexOrder[v]][X];

double By = 10 * vertices[vertexOrder[v]][Y];

double Cx = -10 * vertices[vertexOrder[w]][X];

double Cy = 10 * vertices[vertexOrder[w]][Y];

// first we check if <u,v,w> continues going ccw

if (EPSILON > (((Bx-Ax) * (Cy-Ay)) - ((By-Ay) * (Cx-Ax)))) {

continue;

}

for (int p = 0; p < vc; p++) {

if ((p == u) || (p == v) || (p == w)) {

continue;

}

double Px = -10 * vertices[vertexOrder[p]][X];

double Py = 10 * vertices[vertexOrder[p]][Y];

double ax = Cx - Bx; double ay = Cy - By;

double bx = Ax - Cx; double by = Ay - Cy;

double cx = Bx - Ax; double cy = By - Ay;

double apx = Px - Ax; double apy = Py - Ay;

double bpx = Px - Bx; double bpy = Py - By;

double cpx = Px - Cx; double cpy = Py - Cy;

double aCROSSbp = ax * bpy - ay * bpx;

double cCROSSap = cx * apy - cy * apx;

double bCROSScp = bx * cpy - by * cpx;

if ((aCROSSbp >= 0.0) && (bCROSScp >= 0.0) && (cCROSSap >= 0.0)) {

snip = false;

}

}

if (snip) {

tpolygon.renderTriangle(vertices[vertexOrder[u]],

vertices[vertexOrder[v]],

vertices[vertexOrder[w]]);

m++;

// remove v from remaining polygon

for (int s = v, t = v + 1; t < vc; s++, t++) {

vertexOrder[s] = vertexOrder[t];

}

vc--;

// reset error detection counter

count = 2 * vc;

}

}

}

/*

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

// BEZIER VERTICES

//public void bezierVertex(float x2, float y2,

// float x3, float y3,

// float x4, float y4)

//public void bezierVertex(float x2, float y2, float z2,

// float x3, float y3, float z3,

// float x4, float y4, float z4)

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

// CURVE VERTICES

//public void curveVertex(float x, float y)

//public void curveVertex(float x, float y, float z)

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

// FLUSH

//public void flush()

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

// PRIMITIVES

//public void point(float x, float y)

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

showDepthWarningXYZ("point");

}

//public void line(float x1, float y1, float x2, float y2)

//public void line(float x1, float y1, float z1,

// float x2, float y2, float z2)

//public void triangle(float x1, float y1,

// float x2, float y2,

// float x3, float y3)

//public void quad(float x1, float y1, float x2, float y2,

// float x3, float y3, float x4, float y4)

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

// RECT

protected void rectImpl(float x1f, float y1f, float x2f, float y2f) {

if (smooth || strokeAlpha || ctm.isWarped()) {

// screw the efficiency, send this off to beginShape().

super.rectImpl(x1f, y1f, x2f, y2f);

} else {

int x1 = (int) (x1f + ctm.m02);

int y1 = (int) (y1f + ctm.m12);

int x2 = (int) (x2f + ctm.m02);

int y2 = (int) (y2f + ctm.m12);

if (fill) {

simple_rect_fill(x1, y1, x2, y2);

}

if (stroke) {

if (strokeWeight == 1) {

thin_flat_line(x1, y1, x2, y1);

thin_flat_line(x2, y1, x2, y2);

thin_flat_line(x2, y2, x1, y2);

thin_flat_line(x1, y2, x1, y1);

} else {

thick_flat_line(x1, y1, strokeR, strokeG, strokeB, strokeA,

x2, y1, strokeR, strokeG, strokeB, strokeA);

thick_flat_line(x2, y1, strokeR, strokeG, strokeB, strokeA,

x2, y2, strokeR, strokeG, strokeB, strokeA);

thick_flat_line(x2, y2, strokeR, strokeG, strokeB, strokeA,

x1, y2, strokeR, strokeG, strokeB, strokeA);

thick_flat_line(x1, y2, strokeR, strokeG, strokeB, strokeA,

x1, y1, strokeR, strokeG, strokeB, strokeA);

}

}

}

}

/**

private void simple_rect_fill(int x1, int y1, int x2, int y2) {

if (y2 < y1) {

int temp = y1; y1 = y2; y2 = temp;

}

if (x2 < x1) {

int temp = x1; x1 = x2; x2 = temp;

}

// check to see if completely off-screen (e.g. if the left edge of the

// rectangle is bigger than the width, and so on.)

if ((x1 > width1) || (x2 < 0) ||

(y1 > height1) || (y2 < 0)) return;

// these only affect the fill, not the stroke

// (otherwise strange boogers at edges b/c frame changes shape)

if (x1 < 0) x1 = 0;

if (x2 > width) x2 = width;

if (y1 < 0) y1 = 0;