GraphicsContext context;

static final WritablePixelFormat<IntBuffer> argbFormat =

PixelFormat.getIntArgbInstance();

WritableImage snapshotImage;

Path2D workPath = new Path2D();

Path2D auxPath = new Path2D();

boolean openContour;

/// break the shape at the next vertex (next vertex() call is a moveto())

boolean breakShape;

private float pathCoordsBuffer[] = new float[6];

/// coordinates for internal curve calculation

float[] curveCoordX;

float[] curveCoordY;

float[] curveDrawX;

float[] curveDrawY;

int transformCount;

Affine transformStack[] = new Affine[MATRIX_STACK_DEPTH];

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

// INTERNAL

public PGraphicsFX2D() { }

//public void setParent(PApplet parent)

//public void setPrimary(boolean primary)

//public void setPath(String path)

//public void setSize(int width, int height)

//public void dispose()

@Override

public PSurface createSurface() {

return surface = new PSurfaceFX(this);

}

/** Returns the javafx.scene.canvas.GraphicsContext used by this renderer. */

@Override

public Object getNative() {

return context;

}

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

// FRAME

@Override

public void beginDraw() {

checkSettings();

resetMatrix(); // reset model matrix

vertexCount = 0;

}

@Override

public void endDraw() {

flush();

if (!primaryGraphics) {

// TODO this is probably overkill for most tasks...

loadPixels();

}

}

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

// SETTINGS

//protected void checkSettings()

//protected void defaultSettings()

//protected void reapplySettings()

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

// HINT

//public void hint(int which)

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

// SHAPE CREATION

//protected PShape createShapeFamily(int type)

//protected PShape createShapePrimitive(int kind, float... p)

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

// SHAPE

@Override

public void beginShape(int kind) {

shape = kind;

vertexCount = 0;

workPath.reset();

auxPath.reset();

flushPixels();

if (drawingThinLines()) {

pushMatrix();

translate(0.5f, 0.5f);

}

}

//public boolean edge(boolean e)

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

//public void textureMode(int mode)

@Override

public void texture(PImage image) {

showMethodWarning("texture");

}

@Override

public void vertex(float x, float y) {

if (vertexCount == vertices.length) {

float temp[][] = new float[vertexCount<<1][VERTEX_FIELD_COUNT];

System.arraycopy(vertices, 0, temp, 0, vertexCount);

vertices = temp;

//message(CHATTER, "allocating more vertices " + vertices.length);

}

// not everyone needs this, but just easier to store rather

// than adding another moving part to the code...

vertices[vertexCount][X] = x;

vertices[vertexCount][Y] = y;

vertexCount++;

switch (shape) {

case POINTS:

point(x, y);

break;

case LINES:

if ((vertexCount % 2) == 0) {

line(vertices[vertexCount-2][X],

vertices[vertexCount-2][Y], x, y);

}

break;

case TRIANGLES:

if ((vertexCount % 3) == 0) {

triangle(vertices[vertexCount - 3][X],

vertices[vertexCount - 3][Y],

vertices[vertexCount - 2][X],

vertices[vertexCount - 2][Y],

x, y);

}

break;

case TRIANGLE_STRIP:

if (vertexCount >= 3) {

triangle(vertices[vertexCount - 2][X],

vertices[vertexCount - 2][Y],

vertices[vertexCount - 1][X],

vertices[vertexCount - 1][Y],

vertices[vertexCount - 3][X],

vertices[vertexCount - 3][Y]);

}

break;

case TRIANGLE_FAN:

if (vertexCount >= 3) {

// This is an unfortunate implementation because the stroke for an

// adjacent triangle will be repeated. However, if the stroke is not

// redrawn, it will replace the adjacent line (when it lines up

// perfectly) or show a faint line (when off by a small amount).

// The alternative would be to wait, then draw the shape as a

// polygon fill, followed by a series of vertices. But that's a

// poor method when used with PDF, DXF, or other recording objects,

// since discrete triangles would likely be preferred.

triangle(vertices[0][X],

vertices[0][Y],

vertices[vertexCount - 2][X],

vertices[vertexCount - 2][Y],

x, y);

}

break;

case QUAD:

case QUADS:

if ((vertexCount % 4) == 0) {

quad(vertices[vertexCount - 4][X],

vertices[vertexCount - 4][Y],

vertices[vertexCount - 3][X],

vertices[vertexCount - 3][Y],

vertices[vertexCount - 2][X],

vertices[vertexCount - 2][Y],

x, y);

}

break;

case QUAD_STRIP:

// 0---2---4

// | | |

// 1---3---5

if ((vertexCount >= 4) && ((vertexCount % 2) == 0)) {

quad(vertices[vertexCount - 4][X],

vertices[vertexCount - 4][Y],

vertices[vertexCount - 2][X],

vertices[vertexCount - 2][Y],

x, y,

vertices[vertexCount - 3][X],

vertices[vertexCount - 3][Y]);

}

break;

case POLYGON:

if (workPath.getNumCommands() == 0 || breakShape) {

workPath.moveTo(x, y);

breakShape = false;

} else {

workPath.lineTo(x, y);

}

break;

}

}

@Override

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

showDepthWarningXYZ("vertex");

}

@Override

public void vertex(float[] v) {

vertex(v[X], v[Y]);

}

@Override

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

showVariationWarning("vertex(x, y, u, v)");

}

@Override

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

showDepthWarningXYZ("vertex");

}

@Override

public void beginContour() {

if (openContour) {

PGraphics.showWarning("Already called beginContour()");

return;

}

// draw contours to auxiliary path so main path can be closed later

Path2D contourPath = auxPath;

auxPath = workPath;

workPath = contourPath;

if (contourPath.getNumCommands() > 0) { // first contour does not break

breakShape = true;

}

openContour = true;

}

@Override

public void endContour() {

if (!openContour) {

PGraphics.showWarning("Need to call beginContour() first");

return;

}

if (workPath.getNumCommands() > 0) workPath.closePath();

Path2D temp = workPath;

workPath = auxPath;

auxPath = temp;

openContour = false;

}

@Override

public void endShape(int mode) {

if (openContour) { // correct automagically, notify user

endContour();

PGraphics.showWarning("Missing endContour() before endShape()");

}

if (workPath.getNumCommands() > 0) {

if (shape == POLYGON) {

if (mode == CLOSE) {

workPath.closePath();

}

if (auxPath.getNumCommands() > 0) {

workPath.append(auxPath, false);

}

drawShape(workPath);

}

}

shape = 0;

if (drawingThinLines()) {

popMatrix();

}

loaded = false;

}

private void drawShape(Shape s) {

context.beginPath();

PathIterator pi = s.getPathIterator(null);

while (!pi.isDone()) {

int pitype = pi.currentSegment(pathCoordsBuffer);

switch (pitype) {

case PathIterator.SEG_MOVETO:

context.moveTo(pathCoordsBuffer[0], pathCoordsBuffer[1]);

break;

case PathIterator.SEG_LINETO:

context.lineTo(pathCoordsBuffer[0], pathCoordsBuffer[1]);

break;

case PathIterator.SEG_QUADTO:

context.quadraticCurveTo(pathCoordsBuffer[0], pathCoordsBuffer[1],

pathCoordsBuffer[2], pathCoordsBuffer[3]);

break;

case PathIterator.SEG_CUBICTO:

context.bezierCurveTo(pathCoordsBuffer[0], pathCoordsBuffer[1],

pathCoordsBuffer[2], pathCoordsBuffer[3],

pathCoordsBuffer[4], pathCoordsBuffer[5]);

break;

case PathIterator.SEG_CLOSE:

context.closePath();

break;

default:

showWarning("Unknown segment type " + pitype);

}

pi.next();

}

if (fill) context.fill();

if (stroke) context.stroke();

}

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

// CLIPPING

@Override

protected void clipImpl(float x1, float y1, float x2, float y2) {

//g2.setClip(new Rectangle2D.Float(x1, y1, x2 - x1, y2 - y1));

showTodoWarning("clip()", 3274);

}

@Override

public void noClip() {

//g2.setClip(null);

showTodoWarning("noClip()", 3274);

}

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

// BLEND

@Override

protected void blendModeImpl() {

BlendMode mode = BlendMode.SRC_OVER;

switch (blendMode) {

case REPLACE: showWarning("blendMode(REPLACE) is not supported"); break;

case BLEND: break; // this is SRC_OVER, the default

case ADD: mode = BlendMode.ADD; break; // everyone's favorite

case SUBTRACT: showWarning("blendMode(SUBTRACT) is not supported"); break;

case LIGHTEST: mode = BlendMode.LIGHTEN; break;

case DARKEST: mode = BlendMode.DARKEN; break;

case DIFFERENCE: mode = BlendMode.DIFFERENCE; break;

case EXCLUSION: mode = BlendMode.EXCLUSION; break;

case MULTIPLY: mode = BlendMode.MULTIPLY; break;

case SCREEN: mode = BlendMode.SCREEN; break;

case OVERLAY: mode = BlendMode.OVERLAY; break;

case HARD_LIGHT: mode = BlendMode.HARD_LIGHT; break;

case SOFT_LIGHT: mode = BlendMode.SOFT_LIGHT; break;

case DODGE: mode = BlendMode.COLOR_DODGE; break;

case BURN: mode = BlendMode.COLOR_BURN; break;

}

context.setGlobalBlendMode(mode);

}

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

// BEZIER VERTICES

@Override

protected void bezierVertexCheck() {

if (shape == 0 || shape != POLYGON) {

throw new RuntimeException("beginShape() or beginShape(POLYGON) " +

"must be used before bezierVertex() or quadraticVertex()");

}

if (workPath.getNumCommands() == 0) {

throw new RuntimeException("vertex() must be used at least once " +

"before bezierVertex() or quadraticVertex()");

}

}

@Override

public void bezierVertex(float x1, float y1,

float x2, float y2,

float x3, float y3) {

bezierVertexCheck();

workPath.curveTo(x1, y1, x2, y2, x3, y3);

}

@Override

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

float x3, float y3, float z3,

float x4, float y4, float z4) {

showDepthWarningXYZ("bezierVertex");

}

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

// QUADRATIC BEZIER VERTICES

@Override

public void quadraticVertex(float ctrlX, float ctrlY,

float endX, float endY) {

bezierVertexCheck();

workPath.quadTo(ctrlX, ctrlY, endX, endY);

}

@Override

public void quadraticVertex(float x2, float y2, float z2,

float x4, float y4, float z4) {

showDepthWarningXYZ("quadVertex");

}

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

// CURVE VERTICES

@Override

protected void curveVertexCheck() {

if (shape != POLYGON) {

throw new RuntimeException("You must use beginShape() or " +

"beginShape(POLYGON) before curveVertex()");

}

curveInitCheck();

if (curveCoordX == null) {

curveCoordX = new float[4];

curveCoordY = new float[4];

curveDrawX = new float[4];

curveDrawY = new float[4];

}

}

@Override

protected void curveVertexSegment(float x1, float y1,

float x2, float y2,

float x3, float y3,

float x4, float y4) {

curveCoordX[0] = x1;

curveCoordY[0] = y1;

curveCoordX[1] = x2;

curveCoordY[1] = y2;

curveCoordX[2] = x3;

curveCoordY[2] = y3;

curveCoordX[3] = x4;

curveCoordY[3] = y4;

curveToBezierMatrix.mult(curveCoordX, curveDrawX);

curveToBezierMatrix.mult(curveCoordY, curveDrawY);

// since the paths are continuous,

// only the first point needs the actual moveto

if (workPath.getNumCommands() == 0) {

workPath.moveTo(curveDrawX[0], curveDrawY[0]);

breakShape = false;

}

workPath.curveTo(curveDrawX[1], curveDrawY[1],

curveDrawX[2], curveDrawY[2],

curveDrawX[3], curveDrawY[3]);

}

@Override

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

showDepthWarningXYZ("curveVertex");

}

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

// RENDERER

@Override

public void flush() {

flushPixels();

}

protected void flushPixels() {

boolean hasPixels = modified && pixels != null;

if (hasPixels) {

// If the user has been manipulating individual pixels,

// the changes need to be copied to the screen before

// drawing any new geometry.

int mx1 = getModifiedX1();

int mx2 = getModifiedX2();

int my1 = getModifiedY1();

int my2 = getModifiedY2();

int mw = mx2 - mx1;

int mh = my2 - my1;

PixelWriter pw = context.getPixelWriter();

pw.setPixels(mx1, my1, mw, mh, argbFormat, pixels,

mx1 + my1 * pixelWidth, pixelWidth);

}

modified = false;

}

protected void beforeContextDraw() {

flushPixels();

loaded = false;

}

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

// POINT, LINE, TRIANGLE, QUAD

@Override

public void point(float x, float y) {

if (stroke) {

line(x, y, x + EPSILON, y + EPSILON);

}

}

@Override

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

beforeContextDraw();

if (drawingThinLines()) {

x1 += 0.5f;

x2 += 0.5f;

y1 += 0.5f;

y2 += 0.5f;

}

context.strokeLine(x1, y1, x2, y2);

}

@Override

public void triangle(float x1, float y1, float x2, float y2,

float x3, float y3) {

beforeContextDraw();

if (drawingThinLines()) {

x1 += 0.5f;

x2 += 0.5f;

x3 += 0.5f;

y1 += 0.5f;

y2 += 0.5f;

y3 += 0.5f;

}

context.beginPath();

context.moveTo(x1, y1);

context.lineTo(x2, y2);

context.lineTo(x3, y3);

context.closePath();

if (fill) context.fill();

if (stroke) context.stroke();

}

@Override

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

float x3, float y3, float x4, float y4) {

beforeContextDraw();

if (drawingThinLines()) {

x1 += 0.5f;

x2 += 0.5f;

x3 += 0.5f;

x4 += 0.5f;

y1 += 0.5f;

y2 += 0.5f;

y3 += 0.5f;

y4 += 0.5f;

}

context.beginPath();

context.moveTo(x1, y1);

context.lineTo(x2, y2);

context.lineTo(x3, y3);

context.lineTo(x4, y4);

context.closePath();

if (fill) context.fill();

if (stroke) context.stroke();

}

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

// RECT

//public void rectMode(int mode)

//public void rect(float a, float b, float c, float d)

@Override

protected void rectImpl(float x1, float y1, float x2, float y2) {

beforeContextDraw();

if (drawingThinLines()) {

x1 += 0.5f;

x2 += 0.5f;

y1 += 0.5f;

y2 += 0.5f;

}

if (fill) context.fillRect(x1, y1, x2 - x1, y2 - y1);

if (stroke) context.strokeRect(x1, y1, x2 - x1, y2 - y1);

}

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

// ELLIPSE

//public void ellipseMode(int mode)

//public void ellipse(float a, float b, float c, float d)

@Override

protected void ellipseImpl(float x, float y, float w, float h) {

beforeContextDraw();

if (drawingThinLines()) {

x += 0.5f;

y += 0.5f;

}

if (fill) context.fillOval(x, y, w, h);

if (stroke) context.strokeOval(x, y, w, h);

}

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

// ARC

//public void arc(float a, float b, float c, float d,

// float start, float stop)

@Override

protected void arcImpl(float x, float y, float w, float h,

float start, float stop, int mode) {

beforeContextDraw();

if (drawingThinLines()) {

x += 0.5f;

y += 0.5f;

}

// 0 to 90 in java would be 0 to -90 for p5 renderer

// but that won't work, so -90 to 0?

start = -start;

stop = -stop;

float sweep = stop - start;

// The defaults, before 2.0b7, were to stroke as Arc2D.OPEN, and then fill

// using Arc2D.PIE. That's a little wonky, but it's here for compatability.

ArcType fillMode = ArcType.ROUND; // Arc2D.PIE

ArcType strokeMode = ArcType.OPEN;

if (mode == OPEN) {

fillMode = ArcType.OPEN;

} else if (mode == PIE) {

strokeMode = ArcType.ROUND; // PIE

} else if (mode == CHORD) {

fillMode = ArcType.CHORD;

strokeMode = ArcType.CHORD;

}

if (fill) {

context.fillArc(x, y, w, h, PApplet.degrees(start), PApplet.degrees(sweep), fillMode);

}

if (stroke) {

context.strokeArc(x, y, w, h, PApplet.degrees(start), PApplet.degrees(sweep), strokeMode);

}

}

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

// BOX

//public void box(float size)

@Override

public void box(float w, float h, float d) {

showMethodWarning("box");

}

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

// SPHERE

//public void sphereDetail(int res)

//public void sphereDetail(int ures, int vres)

@Override

public void sphere(float r) {

showMethodWarning("sphere");

}

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

// BEZIER

//public float bezierPoint(float a, float b, float c, float d, float t)

//public float bezierTangent(float a, float b, float c, float d, float t)

//protected void bezierInitCheck()

//protected void bezierInit()

/** Ignored (not needed) by this renderer. */

@Override

public void bezierDetail(int detail) { }

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

// float x2, float y2,

// float x3, float y3,

// float x4, float y4)

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

// float x2, float y2, float z2,

// float x3, float y3, float z3,

// float x4, float y4, float z4)

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

// CURVE

//public float curvePoint(float a, float b, float c, float d, float t)

//public float curveTangent(float a, float b, float c, float d, float t)

/** Ignored (not needed) by this renderer. */

@Override

public void curveDetail(int detail) { }

//public void curveTightness(float tightness)

//protected void curveInitCheck()

//protected void curveInit()

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

// float x2, float y2,

// float x3, float y3,

// float x4, float y4)

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

// float x2, float y2, float z2,

// float x3, float y3, float z3,

// float x4, float y4, float z4)

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

// SMOOTH

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

// IMAGE

//public void imageMode(int mode)

//public void image(PImage image, float x, float y)

//public void image(PImage image, float x, float y, float c, float d)

//public void image(PImage image,