rooty/Arduino
1
0
Fork 0
mirror of https://github.com/arduino/Arduino.git synced 2024-12-10 21:24:12 +01:00
Code Issues Releases Activity
40cbd63fc4
Arduino/core/PGraphics2D.java

1673 lines
48 KiB
Java
Raw Blame History

/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
Part of the Processing project - http://processing.org
Copyright (c) 2006 Ben Fry and Casey Reas
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General
Public License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330,
Boston, MA 02111-1307 USA
*/
package processing.core;
import java.awt.Toolkit;
import java.awt.image.DirectColorModel;
import java.awt.image.MemoryImageSource;
/**
* Subclass of PGraphics that handles fast 2D rendering,
* more commonly referred to as P2D. This class uses no Java2D
* and will run with Java 1.1.
*/
public class PGraphics2D extends PGraphics {
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
// polygon that handles tesselation
private PPolygon tpolygon;
private int TPOLYGON_MAX_VERTICES = 512;
private int tpolygon_vertex_order[]; // = new int[MAX_VERTICES];
PLine line;
//boolean untransformed;
boolean strokeChanged = true;
boolean fillChanged = true;
static final int CVERTEX_ALLOC = 128;
float cvertex[][] = new float[CVERTEX_ALLOC][VERTEX_FIELD_COUNT];
int cvertexIndex;
//////////////////////////////////////////////////////////////
//protected PGraphics2D() { }
/*
public PGraphics2D(int iwidth, int iheight) {
this(iwidth, iheight, null);
}
*/
public PGraphics2D(int iwidth, int iheight, PApplet applet) {
super(iwidth, iheight, applet);
/*
if (applet != null) {
this.parent = applet;
applet.addListeners();
}
resize(iwidth, iheight);
*/
}
//resize handled by superclass
//requestDisplay handled by superclass
protected void allocate() {
pixelCount = width * height;
pixels = new int[pixelCount];
// because of a java 1.1 bug, pixels must be registered as
// opaque before their first run, the memimgsrc will flicker
// and run very slowly.
backgroundColor |= 0xff000000; // just for good measure
for (int i = 0; i < pixelCount; i++) pixels[i] = backgroundColor;
//for (int i = 0; i < pixelCount; i++) pixels[i] = 0xffffffff;
//if (parent != null) {
if (mainDrawingSurface) {
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);
}
// can't un-set this because this may be only a resize (Bug #463)
//defaultsInited = false;
}
//////////////////////////////////////////////////////////////
public void beginDraw() {
insideResizeWait();
insideDraw = true;
// 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 (!defaultsInited) {
defaults();
polygon = new PPolygon(this);
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() {
// moving this back here (post-68) because of macosx thread problem
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();
insideDraw = false;
}
//////////////////////////////////////////////////////////////
public void beginShape(int kind) {
shape = kind;
vertexCount = 0;
splineVertexCount = 0;
polygon.reset(0);
fpolygon.reset(4);
spolygon.reset(4);
polygon.interpUV = false;
}
// PGraphics will throw a depthError
//public void normal(float nx, float ny, float nz)
// PGraphics will handle setting these
//public void textureMode(int mode)
//public void texture(PImage image)
//protected void textureVertex(float u, float v)
public void vertex(float x, float y) {
float vertex[] = polygon.nextVertex();
cvertexIndex = 0; // reset curves to start
vertex[MX] = x;
vertex[MY] = y;
if (fill) {
vertex[R] = fillR;
vertex[G] = fillG;
vertex[B] = fillB;
vertex[A] = fillA;
}
if (stroke) {
vertex[SR] = strokeR;
vertex[SG] = strokeG;
vertex[SB] = strokeB;
vertex[SA] = strokeA;
vertex[SW] = strokeWeight;
}
// this complicated if construct may defeat the purpose
if (textureImage != null) {
vertex[U] = textureU;
vertex[V] = textureV;
}
}
public void vertex(float x, float y, float u, float v) {
textureVertex(u, v);
vertex(x, y);
}
public void vertex(float x, float y, float z) {
depthErrorXYZ("vertex");
}
public void vertex(float x, float y, float z, float u, float v) {
depthErrorXYZ("vertex");
}
public void endShape(int mode) {
// clear the 'shape drawing' flag in case of early exit
//shape = 0;
// hm can't do anymore..
int polyVertexCount = polygon.vertexCount;
float polyVertices[][] = polygon.vertices;
if (untransformed()) {
for (int i = 0; i < polyVertexCount; i++) {
polyVertices[i][X] = polyVertices[i][MX];
polyVertices[i][Y] = polyVertices[i][MY];
}
} else {
for (int i = 0; i < polyVertexCount; i++) {
polyVertices[i][X] = m00*polyVertices[i][MX] + m01*polyVertices[i][MY] + m03;
polyVertices[i][Y] = m10*polyVertices[i][MX] + m11*polyVertices[i][MY] + m13;
}
}
// ------------------------------------------------------------------
// TEXTURES
if (polygon.interpUV) {
fpolygon.texture(textureImage); //polygon.timage);
}
// ------------------------------------------------------------------
// COLORS
// calculate RGB for each vertex
spolygon.interpARGB = strokeChanged; //false;
fpolygon.interpARGB = 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:
if (untransformed() && (strokeWeight == 1)) {
if (!strokeChanged) {
for (int i = 0; i < polyVertexCount; i++) {
thin_point((int) polyVertices[i][X], (int) polyVertices[i][Y],
0, strokeColor);
}
} else {
for (int i = 0; i < polyVertexCount; i++) {
thin_point((int) polyVertices[i][X], (int) polyVertices[i][Y],
0, float_color(polyVertices[i][SR],
polyVertices[i][SG],
polyVertices[i][SB]));
}
//strokei = strokeiSaved;
}
} else {
float f[] = polyVertices[0];
for (int i = 0; i < polyVertexCount; i++) {
float v[] = polyVertices[i];
// if this is the first time (i == 0)
// or if lighting is enabled
// or the stroke color has changed inside beginShape/endShape
// then re-calculate the color at this vertex
if ((i == 0) || strokeChanged) {
// push calculated color into 'f' (this way, f is always valid)
calc_lighting(v[SR], v[SG], v[SB],
v[X], v[Y], v[Z],
v[NX], v[NY], v[NZ], f, R);
}
// uses [SA], since stroke alpha isn't moved into [A] the
// way that [SR] goes to [R] etc on the calc_lighting call
// (there's no sense in copying it to [A], except consistency
// in the code.. but why the extra slowness?)
thick_point(v[X], v[Y], v[Z], f[R], f[G], f[B], f[SA]);
}
}
break;
case LINES:
//case LINE_STRIP:
//case LINE_LOOP:
if (!stroke) return;
// if it's a line loop, copy the vertex data to the last element
//if (shape == LINE_LOOP) {
if (mode == CLOSE) {
float v0[] = polygon.vertices[0];
float v1[] = polygon.nextVertex();
polyVertexCount++; // since it had already been read above
v1[X] = v0[X]; v1[Y] = v0[Y]; v1[Z] = v0[Z];
v1[SR] = v0[SR]; v1[SG] = v0[SG]; v1[SB] = v0[SB];
}
// increment by two for individual lines
increment = (shape == LINES) ? 2 : 1;
draw_lines(polyVertices, polyVertexCount-1, 1, increment, 0);
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) {
fpolygon.vertexCount = 3;
for (int i = 0; i < polyVertexCount-2; i += increment) {
for (int j = 0; j < 3; j++) {
fpolygon.vertices[j][R] = polyVertices[i+j][R];
fpolygon.vertices[j][G] = polyVertices[i+j][G];
fpolygon.vertices[j][B] = polyVertices[i+j][B];
fpolygon.vertices[j][A] = polyVertices[i+j][A];
fpolygon.vertices[j][X] = polyVertices[i+j][X];
fpolygon.vertices[j][Y] = polyVertices[i+j][Y];
fpolygon.vertices[j][Z] = polyVertices[i+j][Z];
if (polygon.interpUV) {
fpolygon.vertices[j][U] = polyVertices[i+j][U];
fpolygon.vertices[j][V] = polyVertices[i+j][V];
}
}
fpolygon.render();
}
}
if (stroke) {
// first draw all vertices as a line strip
if (shape == TRIANGLE_STRIP) {
draw_lines(polyVertices, polyVertexCount-1, 1, 1, 0);
} else {
draw_lines(polyVertices, polyVertexCount-1, 1, 1, 3);
}
// then draw from vertex (n) to (n+2)
// incrementing n using the same as above
draw_lines(polyVertices, polyVertexCount-2, 2, increment, 0);
// changed this to vertexCount-2, because it seemed
// to be adding an extra (nonexistant) line
}
break;
case QUADS:
case QUAD_STRIP:
//System.out.println("pooping out a quad");
increment = (shape == QUADS) ? 4 : 2;
if (fill) {
fpolygon.vertexCount = 4;
for (int i = 0; i < polyVertexCount-3; i += increment) {
for (int j = 0; j < 4; j++) {
fpolygon.vertices[j][R] = polyVertices[i+j][R];
fpolygon.vertices[j][G] = polyVertices[i+j][G];
fpolygon.vertices[j][B] = polyVertices[i+j][B];
fpolygon.vertices[j][A] = polyVertices[i+j][A];
fpolygon.vertices[j][X] = polyVertices[i+j][X];
fpolygon.vertices[j][Y] = polyVertices[i+j][Y];
fpolygon.vertices[j][Z] = polyVertices[i+j][Z];
if (polygon.interpUV) {
fpolygon.vertices[j][U] = polyVertices[i+j][U];
fpolygon.vertices[j][V] = polyVertices[i+j][V];
}
}
fpolygon.render();
}
}
if (stroke) {
// first draw all vertices as a line strip
if (shape == QUAD_STRIP) {
draw_lines(polyVertices, polyVertexCount-1, 1, 1, 0);
} else { // skip every few for quads
draw_lines(polyVertices, polyVertexCount, 1, 1, 4);
}
// then draw from vertex (n) to (n+3)
// incrementing n by the same increment as above
draw_lines(polyVertices, polyVertexCount-2, 3, increment, 0);
}
break;
case POLYGON:
if (isConvex()) {
if (fill) {
polygon.render();
if (stroke) polygon.unexpand();
}
if (stroke) {
draw_lines(polyVertices, polyVertexCount-1, 1, 1, 0);
// draw the last line connecting back to the first point in poly
svertices[0] = polyVertices[polyVertexCount-1];
svertices[1] = polyVertices[0];
draw_lines(svertices, 1, 1, 1, 0);
}
} else {
if (fill) {
// 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(polyVertices, polyVertexCount-1, 1, 1, 0);
// draw the last line connecting back
// to the first point in poly
svertices[0] = polyVertices[polyVertexCount-1];
svertices[1] = polyVertices[0];
draw_lines(svertices, 1, 1, 1, 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;
int flag = 0;
float z;
//float tol = 0.001f;
if (n < 3)
// ERROR: this is a line or a point, render with CONVEX
return true;
// iterate along border doing dot product.
// if the sign of the result changes, then is concave
for (int i=0;i<n;i++) {
j = (i + 1) % n;
k = (i + 2) % n;
z = (v[j][X] - v[i][X]) * (v[k][Y] - v[j][Y]);
z -= (v[j][Y] - v[i][Y]) * (v[k][X] - v[j][X]);
if (z < 0)
flag |= 1;
else if (z > 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;
}
// triangulate the current polygon
private void concaveRender() {
// WARNING: code is not in optimum form
// local initiations of some variables are made to
// keep the code modular and easy to integrate
// restet triangle
float polyVertices[][] = polygon.vertices;
if (tpolygon == null) {
// allocate on first use, rather than slowing
// the startup of the class.
tpolygon = new PPolygon(this);
tpolygon_vertex_order = new int[TPOLYGON_MAX_VERTICES];
}
tpolygon.reset(3);
// copy render parameters
if (textureImage != null) {
tpolygon.texture(textureImage); //polygon.timage);
}
tpolygon.interpX = polygon.interpX;
tpolygon.interpZ = polygon.interpZ;
tpolygon.interpUV = polygon.interpUV;
tpolygon.interpARGB = polygon.interpARGB;
// simple ear clipping polygon triangulation
// addapted from code by john w. ratcliff (jratcliff@verant.com)
// 1 - first we check if the polygon goes CW or CCW
// CW-CCW ordering adapted from code by
// Joseph O'Rourke orourke@cs.smith.edu
// 1A - we start by finding the lowest-right most vertex
boolean ccw = false; // clockwise
int n = polygon.vertexCount;
int mm; // postion for LR vertex
float min[] = new float[2];
min[X] = polyVertices[0][X];
min[Y] = polyVertices[0][Y];
mm = 0;
for(int i = 0; i < n; i++ ) {
if( (polyVertices[i][Y] < min[Y]) ||
( (polyVertices[i][Y] == min[Y]) && (polyVertices[i][X] > min[X]) )
) {
mm = i;
min[X] = polyVertices[mm][X];
min[Y] = polyVertices[mm][Y];
}
}
// 1B - now we compute the cross product of the edges of this vertex
float cp;
int mm1;
// just for renaming
float a[] = new float[2];
float b[] = new float[2];
float c[] = new float[2];
mm1 = (mm + (n-1)) % n;
// assign a[0] to point to poly[m1][0] etc.
for(int i = 0; i < 2; i++ ) {
a[i] = polyVertices[mm1][i];
b[i] = polyVertices[mm][i];
c[i] = polyVertices[(mm+1)%n][i];
}
cp = a[0] * b[1] - a[1] * b[0] +
a[1] * c[0] - a[0] * c[1] +
b[0] * c[1] - c[0] * b[1];
if ( cp > 0 )
ccw = true; // CCW
else
ccw = false; // CW
// 1C - then we sort the vertices so they
// are always in a counterclockwise order
//int j = 0;
if (!ccw) {
// keep the same order
for (int i = 0; i < n; i++) {
tpolygon_vertex_order[i] = i;
}
} else {
// invert the order
for (int i = 0; i < n; i++) {
tpolygon_vertex_order[i] = (n - 1) - i;
}
}
// 2 - begin triangulation
// resulting triangles are stored in the triangle array
// remove vc-2 Vertices, creating 1 triangle every time
int vc = n;
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
// triangle A B C
float Ax, Ay, Bx, By, Cx, Cy, Px, Py;
Ax = -polyVertices[tpolygon_vertex_order[u]][X];
Ay = polyVertices[tpolygon_vertex_order[u]][Y];
Bx = -polyVertices[tpolygon_vertex_order[v]][X];
By = polyVertices[tpolygon_vertex_order[v]][Y];
Cx = -polyVertices[tpolygon_vertex_order[w]][X];
Cy = polyVertices[tpolygon_vertex_order[w]][Y];
if ( EPSILON > (((Bx-Ax) * (Cy-Ay)) - ((By-Ay) * (Cx-Ax)))) {
continue;
}
for (int p = 0; p < vc; p++) {
// this part is a bit osbscure, basically what it does
// is test if this tree vertices are and ear or not, looking for
// intersections with the remaining vertices using a cross product
float ax, ay, bx, by, cx, cy, apx, apy, bpx, bpy, cpx, cpy;
float cCROSSap, bCROSScp, aCROSSbp;
if( (p == u) || (p == v) || (p == w) ) {
continue;
}
Px = -polyVertices[tpolygon_vertex_order[p]][X];
Py = polyVertices[tpolygon_vertex_order[p]][Y];
ax = Cx - Bx; ay = Cy - By;
bx = Ax - Cx; by = Ay - Cy;
cx = Bx - Ax; cy = By - Ay;
apx= Px - Ax; apy= Py - Ay;
bpx= Px - Bx; bpy= Py - By;
cpx= Px - Cx; cpy= Py - Cy;
aCROSSbp = ax * bpy - ay * bpx;
cCROSSap = cx * apy - cy * apx;
bCROSScp = bx * cpy - by * cpx;
if ((aCROSSbp >= 0.0f) && (bCROSScp >= 0.0f) && (cCROSSap >= 0.0f)) {
snip = false;
}
}
if (snip) {
// yes, the trio is an ear, render it and cut it
int triangle_vertices[] = new int[3];
int s,t;
// true names of the vertices
triangle_vertices[0] = tpolygon_vertex_order[u];
triangle_vertices[1] = tpolygon_vertex_order[v];
triangle_vertices[2] = tpolygon_vertex_order[w];
// create triangle
//render_triangle(triangle_vertices);
//private final void render_triangle(int[] triangle_vertices) {
// copy all fields of the triangle vertices
for (int i = 0; i < 3; i++) {
float[] src = polygon.vertices[triangle_vertices[i]];
float[] dest = tpolygon.vertices[i];
for (int k = 0; k < VERTEX_FIELD_COUNT; k++) {
dest[k] = src[k];
}
}
// render triangle
tpolygon.render();
//}
m++;
// remove v from remaining polygon
for( s = v, t = v + 1; t < vc; s++, t++) {
tpolygon_vertex_order[s] = tpolygon_vertex_order[t];
}
vc--;
// resest error detection counter
count = 2 * vc;
}
}
}
//////////////////////////////////////////////////////////////
// RECT
protected void rectImpl(float x1f, float y1f, float x2f, float y2f) {
if (untransformed() && !fillAlpha) {
int x1 = (int) x1f;
int y1 = (int) y1f;
int x2 = (int) x2f;
int y2 = (int) y2f;
rectImplFillUntranSolidRGB(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, fillR, fillG, fillB, fillA,
x2, y1, fillR, fillG, fillB, fillA);
thick_flat_line(x2, y1, fillR, fillG, fillB, fillA,
x2, y2, fillR, fillG, fillB, fillA);
thick_flat_line(x2, y2, fillR, fillG, fillB, fillA,
x1, y2, fillR, fillG, fillB, fillA);
thick_flat_line(x1, y2, fillR, fillG, fillB, fillA,
x1, y1, fillR, fillG, fillB, fillA);
}
}
} else {
beginShape(QUADS);
vertex(x1f, y1f);
vertex(x2f, y1f);
vertex(x2f, y2f);
vertex(x1f, y2f);
endShape();
}
}
/**
* Draw an untransformed rectangle with no alpha.
*/
private void rectImplFillUntranSolidRGB(int x1, int y1, int x2, int y2) {
//System.out.println("flat quad");
if (y2 < y1) {
int temp = y1; y1 = y2; y2 = temp;
}
if (x2 < x1) {
int temp = x1; x1 = x2; x2 = temp;
}
// checking to watch out for boogers
if ((x1 > width1) || (x2 < 0) ||
(y1 > height1) || (y2 < 0)) return;
//if (fill) {
int fx1 = x1;
int fy1 = y1;
int fx2 = x2;
int fy2 = y2;
// these only affect the fill, not the stroke
// (otherwise strange boogers at edges b/c frame changes shape)
if (fx1 < 0) fx1 = 0;
if (fx2 > width) fx2 = width;
if (fy1 < 0) fy1 = 0;
if (fy2 > height) fy2 = height;
// [toxi 031223]
// on avg. 20-25% faster fill routine using System.arraycopy()
int ww = fx2 - fx1;
int hh = fy2 - fy1;
int[] row = new int[ww];
for (int i = 0; i < ww; i++) row[i] = fillColor;
int idx = fy1 * width + fx1;
for (int y = 0; y < hh; y++) {
System.arraycopy(row, 0, pixels, idx, ww);
idx += width;
}
row = null;
//}
}
//////////////////////////////////////////////////////////////
// ELLIPSE AND ARC
public void ellipseImpl(float x1, float y1, float w, float h) {
if (!smooth && (strokeWeight == 1) &&
!fillAlpha && !strokeAlpha && untransformed()) {
float hradius = w / 2f;
float vradius = h / 2f;
int centerX = (int) (x1 + hradius);
int centerY = (int) (y1 + vradius);
if (hradius == vradius) {
flat_circle(centerX, centerY, (int)hradius);
} else {
flat_ellipse(centerX, centerY, (int)hradius, (int)vradius);
}
} else {
super.ellipseImpl(x1, y1, w, h);
}
}
private void flat_circle(int centerX, int centerY, int radius) {
if (unwarped()) {
float x = m00*centerX + m01*centerY + m02;
float y = m10*centerX + m11*centerY + m12;
centerX = (int)x;
centerY = (int)y;
}
if (fill) flat_circle_fill(centerX, centerY, radius);
if (stroke) flat_circle_stroke(centerX, centerY, radius);
}
/**
* Draw the outline around a flat circle using a bresenham-style
* algorithm. Adapted from drawCircle function in "Computer Graphics
* for Java Programmers" by Leen Ammeraal, p. 110.
* <P/>
* This function is included because the quality is so much better,
* and the drawing significantly faster than with adaptive ellipses
* drawn using the sine/cosine tables.
* <P/>
* Circle quadrants break down like so:
* <PRE>
* |
* \ NNW | NNE /
* \ | /
* WNW \ | / ENE
* -------------------
* WSW / | \ ESE
* / | \
* / SSW | SSE \
* |
* </PRE>
* @param xc x center
* @param yc y center
* @param r radius
*/
private void flat_circle_stroke(int xC, int yC, int r) {
int x = 0, y = r, u = 1, v = 2 * r - 1, E = 0;
while (x < y) {
thin_point(xC + x, yC + y, 0, strokeColor); // NNE
thin_point(xC + y, yC - x, 0, strokeColor); // ESE
thin_point(xC - x, yC - y, 0, strokeColor); // SSW
thin_point(xC - y, yC + x, 0, strokeColor); // WNW
x++; E += u; u += 2;
if (v < 2 * E) {
y--; E -= v; v -= 2;
}
if (x > y) break;
thin_point(xC + y, yC + x, 0, strokeColor); // ENE
thin_point(xC + x, yC - y, 0, strokeColor); // SSE
thin_point(xC - y, yC - x, 0, strokeColor); // WSW
thin_point(xC - x, yC + y, 0, strokeColor); // NNW
}
}
/**
* Heavily adapted version of the above algorithm that handles
* filling the ellipse. Works by drawing from the center and
* outwards to the points themselves. Has to be done this way
* because the values for the points are changed halfway through
* the function, making it impossible to just store a series of
* left and right edges to be drawn more quickly.
*
* @param xc x center
* @param yc y center
* @param r radius
*/
private void flat_circle_fill(int xc, int yc, int r) {
int x = 0, y = r, u = 1, v = 2 * r - 1, E = 0;
while (x < y) {
for (int xx = xc; xx < xc + x; xx++) { // NNE
thin_point(xx, yc + y, 0, fillColor);
}
for (int xx = xc; xx < xc + y; xx++) { // ESE
thin_point(xx, yc - x, 0, fillColor);
}
for (int xx = xc - x; xx < xc; xx++) { // SSW
thin_point(xx, yc - y, 0, fillColor);
}
for (int xx = xc - y; xx < xc; xx++) { // WNW
thin_point(xx, yc + x, 0, fillColor);
}
x++; E += u; u += 2;
if (v < 2 * E) {
y--; E -= v; v -= 2;
}
if (x > y) break;
for (int xx = xc; xx < xc + y; xx++) { // ENE
thin_point(xx, yc + x, 0, fillColor);
}
for (int xx = xc; xx < xc + x; xx++) { // SSE
thin_point(xx, yc - y, 0, fillColor);
}
for (int xx = xc - y; xx < xc; xx++) { // WSW
thin_point(xx, yc - x, 0, fillColor);
}
for (int xx = xc - x; xx < xc; xx++) { // NNW
thin_point(xx, yc + y, 0, fillColor);
}
}
}
// unfortunately this can't handle fill and stroke simultaneously,
// because the fill will later replace some of the stroke points
private final void flat_ellipse_symmetry(int centerX, int centerY,
int ellipseX, int ellipseY,
boolean filling) {
if (filling) {
for (int i = centerX - ellipseX + 1; i < centerX + ellipseX; i++) {
thin_point(i, centerY - ellipseY, 0, fillColor);
thin_point(i, centerY + ellipseY, 0, fillColor);
}
} else {
thin_point(centerX - ellipseX, centerY + ellipseY, 0, strokeColor);
thin_point(centerX + ellipseX, centerY + ellipseY, 0, strokeColor);
thin_point(centerX - ellipseX, centerY - ellipseY, 0, strokeColor);
thin_point(centerX + ellipseX, centerY - ellipseY, 0, strokeColor);
}
}
/**
* Bresenham-style ellipse drawing function, adapted from a posting to
* comp.graphics.algortihms.
*
* This function is included because the quality is so much better,
* and the drawing significantly faster than with adaptive ellipses
* drawn using the sine/cosine tables.
*
* @param centerX x coordinate of the center
* @param centerY y coordinate of the center
* @param a horizontal radius
* @param b vertical radius
*/
private void flat_ellipse_internal(int centerX, int centerY,
int a, int b, boolean filling) {
int x, y, a2, b2, s, t;
a2 = a*a;
b2 = b*b;
x = 0;
y = b;
s = a2*(1-2*b) + 2*b2;
t = b2 - 2*a2*(2*b-1);
flat_ellipse_symmetry(centerX, centerY, x, y, filling);
do {
if (s < 0) {
s += 2*b2*(2*x+3);
t += 4*b2*(x+1);
x++;
} else if (t < 0) {
s += 2*b2*(2*x+3) - 4*a2*(y-1);
t += 4*b2*(x+1) - 2*a2*(2*y-3);
x++;
y--;
} else {
s -= 4*a2*(y-1);
t -= 2*a2*(2*y-3);
y--;
}
flat_ellipse_symmetry(centerX, centerY, x, y, filling);
} while (y > 0);
}
private void flat_ellipse(int centerX, int centerY, int a, int b) {
if (unwarped()) {
float x = m00*centerX + m01*centerY + m02;
float y = m10*centerX + m11*centerY + m12;
centerX = (int)x;
centerY = (int)y;
}
if (fill) flat_ellipse_internal(centerX, centerY, a, b, true);
if (stroke) flat_ellipse_internal(centerX, centerY, a, b, false);
}
// TODO really need a decent arc function in here..
//protected void arcImpl(float x1, float y1, float w, float h,
// float start, float stop)
//////////////////////////////////////////////////////////////
// BOX & SPHERE
// The PGraphics superclass will throw errors for these fellas
//////////////////////////////////////////////////////////////
// BEZIER & CURVE
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) {
depthErrorXYZ("bezier");
}
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) {
depthErrorXYZ("curve");
}
//////////////////////////////////////////////////////////////
// IMAGE
protected void imageImpl(PImage image,
float x1, float y1, float x2, float y2,
int u1, int v1, int u2, int v2) {
if ((x2 - x1 == image.width) &&
(y2 - y1 == image.height) &&
!tint && unwarped()) {
flat_image(image, (int) (x1 + m02), (int) (y1 + m12), u1, v1, u2, v2);
} else {
super.imageImpl(image, x1, y1, x2, y2, u1, v1, u2, v2);
}
}
/**
* Image drawn in flat "screen space", with no scaling or warping.
* this is so common that a special routine is included for it,
* because the alternative is much slower.
*
* @param image image to be drawn
* @param sx1 x coordinate of upper-lefthand corner in screen space
* @param sy1 y coordinate of upper-lefthand corner in screen space
*/
private void flat_image(PImage image, int sx1, int sy1,
int ix1, int iy1, int ix2, int iy2) {
/*
int ix1 = 0;
int iy1 = 0;
int ix2 = image.width;
int iy2 = image.height;
*/
if (imageMode == CENTER) {
sx1 -= image.width / 2;
sy1 -= image.height / 2;
}
int sx2 = sx1 + image.width;
int sy2 = sy1 + image.height;
// don't draw if completely offscreen
// (without this check, ArrayIndexOutOfBoundsException)
if ((sx1 > width1) || (sx2 < 0) ||
(sy1 > height1) || (sy2 < 0)) return;
if (sx1 < 0) { // off left edge
ix1 -= sx1;
sx1 = 0;
}
if (sy1 < 0) { // off top edge
iy1 -= sy1;
sy1 = 0;
}
if (sx2 > width) { // off right edge
ix2 -= sx2 - width;
sx2 = width;
}
if (sy2 > height) { // off bottom edge
iy2 -= sy2 - height;
sy2 = height;
}
int source = iy1 * image.width + ix1;
int target = sy1 * width;
if (image.format == ARGB) {
for (int y = sy1; y < sy2; y++) {
int tx = 0;
for (int x = sx1; x < sx2; x++) {
pixels[target + x] =
_blend(pixels[target + x],
image.pixels[source + tx],
image.pixels[source + tx++] >>> 24);
}
source += image.width;
target += width;
}
} else if (image.format == ALPHA) {
for (int y = sy1; y < sy2; y++) {
int tx = 0;
for (int x = sx1; x < sx2; x++) {
pixels[target + x] =
_blend(pixels[target + x],
fillColor,
image.pixels[source + tx++]);
}
source += image.width;
target += width;
}
} else if (image.format == RGB) {
target += sx1;
int tw = sx2 - sx1;
for (int y = sy1; y < sy2; y++) {
System.arraycopy(image.pixels, source, pixels, target, tw);
// should set z coordinate in here
// or maybe not, since dims=0, meaning no relevant z
source += image.width;
target += width;
}
}
}
//////////////////////////////////////////////////////////////
// TEXT/FONTS
// These will be handled entirely by PGraphics.
//////////////////////////////////////////////////////////////
// expects properly clipped coords, hence does
// NOT check if x/y are in bounds [toxi]
private void thin_pointAt(int x, int y, float z, int color) {
int index = y*width+x; // offset values are pre-calced in constructor
pixels[index] = color;
zbuffer[index] = z;
}
// expects offset/index in pixelbuffer array instead of x/y coords
// used by optimized parts of thin_flat_line() [toxi]
private void thin_pointAtIndex(int offset, float z, int color) {
pixels[offset] = color;
zbuffer[offset] = z;
}
// points are inherently flat, but always tangent
// to the screen surface. the z is only so that things
// get scaled properly if the pt is way in back
private void thick_point(float x, float y, float z, // note floats
float r, float g, float b, float a) {
spolygon.reset(4);
spolygon.interpARGB = false; // no changes for vertices of a point
float strokeWidth2 = strokeWeight/2.0f;
float svertex[] = spolygon.vertices[0];
svertex[X] = x - strokeWidth2;
svertex[Y] = y - strokeWidth2;
svertex[Z] = z;
svertex[R] = r;
svertex[G] = g;
svertex[B] = b;
svertex[A] = a;
svertex = spolygon.vertices[1];
svertex[X] = x + strokeWidth2;
svertex[Y] = y - strokeWidth2;
svertex[Z] = z;
svertex = spolygon.vertices[2];
svertex[X] = x + strokeWidth2;
svertex[Y] = y + strokeWidth2;
svertex[Z] = z;
svertex = spolygon.vertices[3];
svertex[X] = x - strokeWidth2;
svertex[Y] = y + strokeWidth2;
svertex[Z] = z;
spolygon.render();
}
// new bresenham clipping code, as old one was buggy [toxi]
private void thin_flat_line(int x1, int y1, int x2, int y2) {
int nx1,ny1,nx2,ny2;
// get the "dips" for the points to clip
int code1 = thin_flat_lineClipCode(x1, y1);
int code2 = thin_flat_lineClipCode(x2, y2);
if ((code1 & code2)!=0) {
return;
} else {
int dip = code1 | code2;
if (dip != 0) {
// now calculate the clipped points
float a1 = 0, a2 = 1, a = 0;
for (int i=0;i<4;i++) {
if (((dip>>i)%2)==1) {
a = thin_flat_lineSlope((float)x1, (float)y1,
(float)x2, (float)y2, i+1);
if (((code1>>i)%2)==1) {
a1 = (float)Math.max(a, a1);
} else {
a2 = (float)Math.min(a, a2);
}
}
}
if (a1>a2) return;
else {
nx1=(int) (x1+a1*(x2-x1));
ny1=(int) (y1+a1*(y2-y1));
nx2=(int) (x1+a2*(x2-x1));
ny2=(int) (y1+a2*(y2-y1));
}
// line is fully visible/unclipped
} else {
nx1=x1; nx2=x2;
ny1=y1; ny2=y2;
}
}
// new "extremely fast" line code
// adapted from http://www.edepot.com/linee.html
boolean yLonger=false;
int shortLen=ny2-ny1;
int longLen=nx2-nx1;
if (Math.abs(shortLen)>Math.abs(longLen)) {
int swap=shortLen;
shortLen=longLen;
longLen=swap;
yLonger=true;
}
int decInc;
if (longLen==0) decInc=0;
else decInc = (shortLen << 16) / longLen;
if (nx1==nx2) {
// special case: vertical line
if (ny1>ny2) { int ty=ny1; ny1=ny2; ny2=ty; }
int offset=ny1*width+nx1;
for(int j=ny1; j<=ny2; j++) {
thin_pointAtIndex(offset,0,strokeColor);
offset+=width;
}
return;
} else if (ny1==ny2) {
// special case: horizontal line
if (nx1>nx2) { int tx=nx1; nx1=nx2; nx2=tx; }
int offset=ny1*width+nx1;
for(int j=nx1; j<=nx2; j++) thin_pointAtIndex(offset++,0,strokeColor);
return;
} else if (yLonger) {
if (longLen>0) {
longLen+=ny1;
for (int j=0x8000+(nx1<<16);ny1<=longLen;++ny1) {
thin_pointAt(j>>16, ny1, 0, strokeColor);
j+=decInc;
}
return;
}
longLen+=ny1;
for (int j=0x8000+(nx1<<16);ny1>=longLen;--ny1) {
thin_pointAt(j>>16, ny1, 0, strokeColor);
j-=decInc;
}
return;
} else if (longLen>0) {
longLen+=nx1;
for (int j=0x8000+(ny1<<16);nx1<=longLen;++nx1) {
thin_pointAt(nx1, j>>16, 0, strokeColor);
j+=decInc;
}
return;
}
longLen+=nx1;
for (int j=0x8000+(ny1<<16);nx1>=longLen;--nx1) {
thin_pointAt(nx1, j>>16, 0, strokeColor);
j-=decInc;
}
}
private int thin_flat_lineClipCode(float x, float y) {
return ((y < 0 ? 8 : 0) | (y > height1 ? 4 : 0) |
(x < 0 ? 2 : 0) | (x > width1 ? 1 : 0));
}
private float thin_flat_lineSlope(float x1, float y1,
float x2, float y2, int border) {
switch (border) {
case 4: {
return (-y1)/(y2-y1);
}
case 3: {
return (height1-y1)/(y2-y1);
}
case 2: {
return (-x1)/(x2-x1);
}
case 1: {
return (width1-x1)/(x2-x1);
}
}
return -1f;
}
private boolean flat_line_retribution(float x1, float y1,
float x2, float y2,
float r1, float g1, float b1) {
/*
// assume that if it is/isn't big in one dir, then the
// other doesn't matter, cuz that's a weird case
float lwidth = m00*strokeWeight + m01*strokeWeight;
//float lheight = m10*strokeWeight + m11*strokeWeight;
// lines of stroke thickness 1 can be anywhere from -1.41 to 1.41
if ((strokeWeight < TWO) && (!hints[SCALE_STROKE_WIDTH])) {
//if (abs(lwidth) < 1.5f) {
//System.out.println("flat line retribution " + r1 + " " + g1 + " " + b1);
int strokeSaved = strokeColor;
strokeColor = float_color(r1, g1, b1);
thin_flat_line((int)x1, (int)y1, (int)x2, (int)y2);
strokeColor = strokeSaved;
return true;
}
*/
return false;
}
private void thick_flat_line(float ox1, float oy1,
float r1, float g1, float b1, float a1,
float ox2, float oy2,
float r2, float g2, float b2, float a2) {
spolygon.interpARGB = (r1 != r2) || (g1 != g2) || (b1 != b2) || (a1 != a2);
spolygon.interpZ = false;
if (!spolygon.interpARGB &&
flat_line_retribution(ox1, oy1, ox2, oy2, r1, g1, b1)) {
return;
}
float dX = ox2-ox1 + EPSILON;
float dY = oy2-oy1 + EPSILON;
float len = sqrt(dX*dX + dY*dY);
// TODO strokeWidth should be transformed!
float rh = strokeWeight / len;
float dx0 = rh * dY;
float dy0 = rh * dX;
float dx1 = rh * dY;
float dy1 = rh * dX;
spolygon.reset(4);
float svertex[] = spolygon.vertices[0];
svertex[X] = ox1+dx0;
svertex[Y] = oy1-dy0;
svertex[R] = r1;
svertex[G] = g1;
svertex[B] = b1;
svertex[A] = a1;
svertex = spolygon.vertices[1];
svertex[X] = ox1-dx0;
svertex[Y] = oy1+dy0;
svertex[R] = r1;
svertex[G] = g1;
svertex[B] = b1;
svertex[A] = a1;
svertex = spolygon.vertices[2];
svertex[X] = ox2-dx1;
svertex[Y] = oy2+dy1;
svertex[R] = r2;
svertex[G] = g2;
svertex[B] = b2;
svertex[A] = a2;
svertex = spolygon.vertices[3];
svertex[X] = ox2+dx1;
svertex[Y] = oy2-dy1;
svertex[R] = r2;
svertex[G] = g2;
svertex[B] = b2;
svertex[A] = a2;
spolygon.render();
}
/*
// OPT version without z coords can save 8 multiplies and some other
private void spatial_line(float x1, float y1,
float r1, float g1, float b1,
float x2, float y2,
float r2, float g2, float b2) {
spatial_line(x1, y1, 0, r1, g1, b1,
x2, y2, 0, r2, g2, b2);
}
// the incoming values are transformed,
// and the colors have been calculated
private void spatial_line(float x1, float y1, float z1,
float r1, float g1, float b1,
float x2, float y2, float z2,
float r2, float g2, float b2) {
spolygon.interpARGB = (r1 != r2) || (g1 != g2) || (b1 != b2);
if (!spolygon.interpARGB &&
flat_line_retribution(x1, y1, x2, y2, r1, g1, b1)) {
return;
}
spolygon.interpZ = true;
float ox1 = x1; float oy1 = y1; float oz1 = z1;
float ox2 = x2; float oy2 = y2; float oz2 = z2;
float dX = ox2-ox1 + 0.0001f;
float dY = oy2-oy1 + 0.0001f;
float len = sqrt(dX*dX + dY*dY);
//float x0 = m00*0 + m01*0 + m03;
float rh = strokeWeight / len;
float dx0 = rh * dY;
float dy0 = rh * dX;
float dx1 = rh * dY;
float dy1 = rh * dX;
spolygon.reset(4);
float svertex[] = spolygon.vertices[0];
svertex[X] = ox1+dx0;
svertex[Y] = oy1-dy0;
svertex[Z] = oz1;
svertex[R] = r1; //calcR1;
svertex[G] = g1; //calcG1;
svertex[B] = b1; //calcB1;
svertex = spolygon.vertices[1];
svertex[X] = ox1-dx0;
svertex[Y] = oy1+dy0;
svertex[Z] = oz1;
svertex[R] = r1; //calcR1;
svertex[G] = g1; //calcG1;
svertex[B] = b1; //calcB1;
svertex = spolygon.vertices[2];
svertex[X] = ox2-dx1;
svertex[Y] = oy2+dy1;
svertex[Z] = oz2;
svertex[R] = r2; //calcR2;
svertex[G] = g2; //calcG2;
svertex[B] = b2; //calcB2;
svertex = spolygon.vertices[3];
svertex[X] = ox2+dx1;
svertex[Y] = oy2-dy1;
svertex[Z] = oz2;
svertex[R] = r2; //calcR2;
svertex[G] = g2; //calcG2;
svertex[B] = b2; //calcB2;
spolygon.render();
}
*/
// max is what to count to
// offset is offset to the 'next' vertex
// increment is how much to increment in the loop
private void draw_lines(float vertices[][], int max,
int offset, int increment, int skip) {
if (strokeWeight < 2) {
for (int i = 0; i < max; i += increment) {
if ((skip != 0) && (((i+offset) % skip) == 0)) continue;
float a[] = vertices[i];
float b[] = vertices[i+offset];
if (line == null) line = new PLine(this);
line.reset();
line.setIntensities(a[SR], a[SG], a[SB], a[SA],
b[SR], b[SG], b[SB], b[SA]);
line.setVertices(a[X], a[Y], a[Z],
b[X], b[Y], b[Z]);
line.draw();
}
} else { // use old line code for thickness > 1
if ((strokeWeight < 2) && !strokeChanged) {
// need to set color at least once?
// THIS PARTICULAR CASE SHOULD NO LONGER BE REACHABLE
for (int i = 0; i < max; i += increment) {
if ((skip != 0) && (((i+offset) % skip) == 0)) continue;
thin_flat_line((int) vertices[i][X],
(int) vertices[i][Y],
(int) vertices[i+offset][X],
(int) vertices[i+offset][Y]);
}
} else {
for (int i = 0; i < max; i += increment) {
if ((skip != 0) && (((i+offset) % skip) == 0)) continue;
float v1[] = vertices[i];
float v2[] = vertices[i+offset];
thick_flat_line(v1[X], v1[Y], v1[SR], v1[SG], v1[SB], v1[SA],
v2[X], v2[Y], v2[SR], v2[SG], v2[SB], v2[SA]);
}
}
}
}
//////////////////////////////////////////////////////////////
// UGLY RENDERING SHIT
private void thin_point(int x, int y, float z, int color) {
// necessary? [fry] yes! [toxi]
if (x<0 || x>width1 || y<0 || y>height1) return;
int index = y*width + x;
if ((color & 0xff000000) == 0xff000000) { // opaque
pixels[index] = color;
} else { // transparent
// couldn't seem to get this working correctly
//pixels[index] = _blend(pixels[index],
// color & 0xffffff, (color >> 24) & 0xff);
// a1 is how much of the orig pixel
int a2 = (color >> 24) & 0xff;
int a1 = a2 ^ 0xff;
int p2 = strokeColor;
int p1 = pixels[index];
int r = (a1 * ((p1 >> 16) & 0xff) + a2 * ((p2 >> 16) & 0xff)) & 0xff00;
int g = (a1 * ((p1 >> 8) & 0xff) + a2 * ((p2 >> 8) & 0xff)) & 0xff00;
int b = (a1 * ( p1 & 0xff) + a2 * ( p2 & 0xff)) >> 8;
pixels[index] = 0xff000000 | (r << 8) | g | b;
//pixels[index] = _blend(pixels[index],
// color & 0xffffff, (color >> 24) & 0xff);
/*
pixels[index] = 0xff000000 |
((((a1 * ((pixels[index] >> 16) & 0xff) +
a2 * ((color >> 16) & 0xff)) & 0xff00) << 24) << 8) |
(((a1 * ((pixels[index] >> 8) & 0xff) +
a2 * ((color >> 8) & 0xff)) & 0xff00) << 16) |
(((a1 * ( pixels[index] & 0xff) +
a2 * ( color & 0xff)) >> 8));
*/
}
zbuffer[index] = z;
}
//////////////////////////////////////////////////////////////
// BACKGROUND AND FRIENDS
/**
* Clear the pixel buffer.
*/
protected void clear() {
for (int i = 0; i < pixelCount; i++) {
pixels[i] = backgroundColor;
}
}
//////////////////////////////////////////////////////////////
// INTERNAL SCHIZZLE
private boolean untransformed() {
return ((m00 == 1) && (m01 == 0) && (m02 == 0) &&
(m10 == 0) && (m11 == 1) && (m12 == 0));
}
private boolean unwarped() {
return ((m00 == 1) && (m01 == 0) && (m10 == 0) && (m11 == 1));
}
// doesn't really do lighting per se...
private void calc_lighting(float r, float g, float b,
float ix, float iy, float iz,
float nx, float ny, float nz,
float target[], int toffset) {
target[toffset + 0] = r;
target[toffset + 1] = g;
target[toffset + 2] = b;
}
static private final int float_color(float r, float g, float b) {
return (0xff000000 |
((int) (255.0f * r)) << 16 |
((int) (255.0f * g)) << 8 |
((int) (255.0f * b)));
}
public final static int _blend(int p1, int p2, int a2) {
// scale alpha by alpha of incoming pixel
a2 = (a2 * (p2 >>> 24)) >> 8;
int a1 = a2 ^ 0xff;
int r = (a1 * ((p1 >> 16) & 0xff) + a2 * ((p2 >> 16) & 0xff)) & 0xff00;
int g = (a1 * ((p1 >> 8) & 0xff) + a2 * ((p2 >> 8) & 0xff)) & 0xff00;
int b = (a1 * ( p1 & 0xff) + a2 * ( p2 & 0xff)) >> 8;
return 0xff000000 | (r << 8) | g | b;
}
}
Reference in New Issue View Git Blame Copy Permalink