From d74ac55906a39aedfd96d9190e589b136e1dddc2 Mon Sep 17 00:00:00 2001 From: benfry Date: Wed, 17 Nov 2004 17:00:58 +0000 Subject: [PATCH] the poo continues --- processing/core/PApplet.java | 21 +- processing/core/PGraphics.java | 545 +++++++++++++++++++++++++-------- processing/core/PMethods.java | 10 +- processing/core/PTriangle.java | 47 ++- 4 files changed, 463 insertions(+), 160 deletions(-) diff --git a/processing/core/PApplet.java b/processing/core/PApplet.java index 525a91d68..2dad02501 100644 --- a/processing/core/PApplet.java +++ b/processing/core/PApplet.java @@ -4406,6 +4406,23 @@ public class PApplet extends Applet } + public void arcMode(int mode) { + g.arcMode(mode); + } + + + public void arc(float start, float stop, + float x, float y, float radius) { + g.arc(start, stop, x, y, radius); + } + + + public void arc(float start, float stop, + float x, float y, float hr, float vr) { + g.arc(start, stop, x, y, hr, vr); + } + + public void ellipseMode(int mode) { g.ellipseMode(mode); } @@ -4866,8 +4883,8 @@ public class PApplet extends Applet } - public void strokeMiter(int miter) { - g.strokeMiter(miter); + public void strokeCap(int cap) { + g.strokeCap(cap); } diff --git a/processing/core/PGraphics.java b/processing/core/PGraphics.java index 92910ebaa..19631c65f 100644 --- a/processing/core/PGraphics.java +++ b/processing/core/PGraphics.java @@ -4,8 +4,8 @@ PGraphics - main graphics and rendering context Part of the Processing project - http://processing.org + Copyright (c) 2004- Ben Fry and Casey Reas Copyright (c) 2001-04 Massachusetts Institute of Technology - (Except where noted that the author is not Ben Fry) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public @@ -140,8 +140,8 @@ public class PGraphics extends PImage implements PMethods, PConstants { /** Set by strokeJoin(), read-only */ public int strokeJoin; - /** Set by strokeMiter(), read-only */ - public int strokeMiter; + /** Set by strokeCap(), read-only */ + public int strokeCap; // lighting static final int MAX_LIGHTS = 10; @@ -278,7 +278,7 @@ public class PGraphics extends PImage implements PMethods, PConstants { // ........................................................ - // curve vertices + // spline vertices static final int SPLINE_VERTEX_ALLOC = 128; float spline_vertex[][]; @@ -314,6 +314,7 @@ public class PGraphics extends PImage implements PMethods, PConstants { public int rectMode; public int ellipseMode; + public int arcMode; // [toxi031031] new & faster sphere code w/ support flexibile resolutions // will be set by sphereDetail() or 1st call to sphere() @@ -476,6 +477,7 @@ public class PGraphics extends PImage implements PMethods, PConstants { textureMode = IMAGE_SPACE; rectMode = CORNER; ellipseMode = CENTER; + arcMode = CENTER; angleMode = RADIANS; // no current font @@ -537,11 +539,11 @@ public class PGraphics extends PImage implements PMethods, PConstants { // (but can't return, since needs to update memimgsrc if (hints[DEPTH_SORT]) { if (triangleCount > 0) { - depth_sort_triangles(); + //depth_sort_triangles(); // not yet render_triangles(); } if (lineCount > 0) { - depth_sort_lines(); + //depth_sort_lines(); // not yet render_lines(); } } @@ -1291,7 +1293,7 @@ public class PGraphics extends PImage implements PMethods, PConstants { lines[lineCount][PB] = b; lines[lineCount][LI] = -1; - lines[lineCount][SM] = strokeMiter | strokeJoin; + lines[lineCount][SM] = strokeCap | strokeJoin; lineCount++; } @@ -1318,8 +1320,8 @@ public class PGraphics extends PImage implements PMethods, PConstants { } - protected void depth_sort_triangles() { - } + //protected void depth_sort_triangles() { + //} protected void render_triangles() { for (int i = 0; i < triangleCount; i ++) { @@ -1350,8 +1352,8 @@ public class PGraphics extends PImage implements PMethods, PConstants { } - protected void depth_sort_lines() { - } + //protected void depth_sort_lines() { + //} public void render_lines() { for (int i = 0; i < lineCount; i ++) { @@ -1672,22 +1674,98 @@ public class PGraphics extends PImage implements PMethods, PConstants { public void point(float x, float y) { - beginShape(POINTS); - vertex(x, y); - endShape(); + point(x, y, 0); } public void point(float x, float y, float z) { - beginShape(POINTS); - vertex(x, y, z); - endShape(); + if (depth) { + if (strokeWeight < 2) { + // just a single dot on the screen with a z value + // TODO what is lighting calculation for this point? + point0(screenX(x, y, z), + screenY(x, y, z), + screenZ(x, y, z), strokeColor); + + } else { + float cx = screenX(x, y, z); + float cy = screenX(x, y, z); + float hsw = strokeWeight / 2f; + + if (strokeCap == ROUND_ENDCAP) { + // non-smoothed, filled circle + circle0_rough_fill(cx, cy, z, hsw, strokeColor); + + } else { // otherwise one of the square endcaps + //if ((strokeCap == PROJECTED_ENDCAP) || + // (strokeCap == SQUARE_ENDCAP)) { + // technically, if SQUARE_ENDCAP, nothing should be drawn + // but we'll go easy on the lads + // non-smoothed (since 3D), filled square + + int x1 = (int) (cx - hsw + 0.5f); + int y1 = (int) (cy - hsw + 0.5f); + int x2 = (int) (cx + hsw + 0.5f); + int y2 = (int) (cy + hsw + 0.5f); + + rect0_rough_fill(x1, y1, x2, y2, z, strokeColor); + } + } + + } else { // noDepth + if (strokeWeight < 2) { + point0(screenX(x, y), screenY(x, y), 0, strokeColor); + + } else { + float hsw = strokeWeight / 2f; + + if ((strokeCap == PROJECTED_ENDCAP) || + (strokeCap == SQUARE_ENDCAP)) { + rect0_fill(x - hsw, y - hsw, x + hsw, y + hsw, 0, strokeColor); + + } else if (strokeCap == ROUND_ENDCAP) { + circle0_fill(x - hsw, y - hsw, 0, hsw, strokeColor); + } + } + } } - 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; + private void point3(float x, float y, float z, int color) { + // need to get scaled version of the stroke + float x1 = screenX(x - 0.5f, y - 0.5f, z); + float y1 = screenY(x - 0.5f, y - 0.5f, z); + float x2 = screenX(x + 0.5f, y + 0.5f, z); + float y2 = screenY(x + 0.5f, y + 0.5f, z); + + float weight = (abs(x2 - x1) + abs(y2 - y1)) / 2f; + if (weight < 1.5f) { + int xx = (int) ((x1 + x2) / 2f); + int yy = (int) ((y1 + y2) / 2f); + point0(xx, yy, z, color); + zbuffer[yy*width + xx] = screenZ(x, y, z); + //stencil? + + } else { + // actually has some weight, need to draw shapes instead + // these will be + } + } + + + private void point2(float x, float y, int color) { + + } + + + private void point0(float xx, float yy, float z, int color) { + point0((int) (xx + 0.5f), (int) (yy + 0.5f), z, color); + } + + + private void point0(int x, int y, float z, int color) { + if ((x < 0) || (x > width1) || + (y < 0) || (y > height1)) return; int index = y*width + x; if ((color & 0xff000000) == 0xff000000) { // opaque @@ -1707,7 +1785,7 @@ public class PGraphics extends PImage implements PMethods, PConstants { pixels[index] = 0xff000000 | (r << 8) | g | b; } - zbuffer[index] = z; + if (zbuffer != null) zbuffer[index] = z; } @@ -1977,36 +2055,55 @@ public class PGraphics extends PImage implements PMethods, PConstants { protected void rect2_fill(float x1, float y1, float x2, float y2) { if ((m01 != 0) || (m10 != 0)) { // this is actually transformed, transform points and draw a quad - quad0(screenX(x1, y1), screenY(x1, y1), - screenX(x2, y1), screenY(x2, y1), - screenX(x2, y2), screenY(x2, y2), - screenX(x1, y2), screenY(x1, y2)); + quad0_fill(screenX(x1, y1), screenY(x1, y1), + screenX(x2, y1), screenY(x2, y1), + screenX(x2, y2), screenY(x2, y2), + screenX(x1, y2), screenY(x1, y2), fillColor); } else { if ((m00 == 1) && (m11 == 1)) { // no scale, but maybe a translate - rect0_fill(x1 + m02, y1 + m12, x2 + m02, y2 + m12); + rect0_fill(x1 + m02, y1 + m12, x2 + m02, y2 + m12, 0, fillColor); } else { // scaled, maybe translated rect0_fill(screenX(x1, y1), screenY(x1, y1), - screenX(x2, y2), screenY(x2, y2)); + screenX(x2, y2), screenY(x2, y2), 0, fillColor); } } } - protected void rect0_fill(float x1, float y1, float x2, float y2) { + protected void rect0_fill(float x1, float y1, float x2, float y2, + float z, int color) { + if (smooth) { + rect0_smooth_fill(x1, y1, x2, y2, z, color); + + } else { + rect0_rough_fill((int) (x1+0.5f), (int) (y1+0.5f), + (int) (x2+0.5f), (int) (y2+0.5f), z, color); + } + } + + + protected void rect0_smooth_fill(float x1, float y1, float x2, float y2, + float z, int color) { + quad0_smooth_fill(x1, y1, x2, y1, x2, y2, x1, y2, color); + } + + + protected void rect0_rough_fill(int x1, int y1, int x2, int y2, + float z, int color) { // needs to check if smooth // or if there's an affine transform on the shape // also the points are now floats instead of ints //System.out.println("flat quad"); if (y2 < y1) { - float temp = y1; y1 = y2; y2 = temp; + int temp = y1; y1 = y2; y2 = temp; } if (x2 < x1) { - float temp = x1; x1 = x2; x2 = temp; + int temp = x1; x1 = x2; x2 = temp; } // checking to watch out for boogers if ((x1 > width1) || (x2 < 0) || @@ -2078,8 +2175,58 @@ public class PGraphics extends PImage implements PMethods, PConstants { } - public void quad0(float x1, float y1, float x2, float y2, - float x3, float y3, float x4, float y4) { + protected void quad0_fill(float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + int color) { + if (smooth) { + quad0_smooth_fill(x1, y1, x2, y2, x3, y3, x4, y4, color); + + } else { + quad0_rough_fill((int) (x1+0.5f), (int) (y1+0.5f), + (int) (x2+0.5f), (int) (y2+0.5f), + (int) (x3+0.5f), (int) (y3+0.5f), + (int) (x4+0.5f), (int) (y4+0.5f), + color); + } + } + + + protected void quad0_smooth_fill(float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + int color) { + } + + + protected void quad0_rough_fill(float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + int color) { + } + + + protected void quad0_stroke(float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + int color) { + if (smooth) { + quad0_smooth_stroke(x1, y1, x2, y2, x3, y3, x4, y4, color); + + } else { + quad0_rough_stroke((int) (x1+0.5f), (int) (y1+0.5f), + (int) (x2+0.5f), (int) (y2+0.5f), + (int) (x3+0.5f), (int) (y3+0.5f), + (int) (x4+0.5f), (int) (y4+0.5f), color); + } + } + + + protected void quad0_smooth_stroke(float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + int color) { + } + + + protected void quad0_rough_stroke(float x1, float y1, float x2, float y2, + float x3, float y3, float x4, float y4, + int color) { } @@ -2201,6 +2348,73 @@ public class PGraphics extends PImage implements PMethods, PConstants { + ////////////////////////////////////////////////////////////// + + // ARC + + + public void arcMode(int mode) { + arcMode = mode; + } + + + public void arc(float start, float stop, + float x, float y, float radius) { + arc(start, stop, x, y, radius, radius); + } + + + public void arc(float start, float stop, + float x, float y, float hr, float vr) { + switch (arcMode) { + case CENTER_RADIUS: + break; + case CENTER: + hr /= 2f; vr /= 2f; + break; + case CORNER: + hr /= 2f; vr /= 2f; + x += hr; y += vr; + break; + case CORNERS: + hr = (hr - x) / 2f; + vr = (vr - y) / 2f; + x += hr; + y += vr; + break; + } + + if (depth) { + if (fill) arc3_fill(start, stop, x, y, hr, vr); + if (stroke) arc3_stroke(start, stop, x, y, hr, vr); + + } else { + if (fill) arc2_fill(start, stop, x, y, hr, vr); + if (stroke) arc2_stroke(start, stop, x, y, hr, vr); + } + } + + + protected void arc3_fill(float start, float stop, + float x, float y, float hr, float vr) { + } + + + protected void arc3_stroke(float start, float stop, + float x, float y, float hr, float vr) { + } + + + protected void arc2_fill(float start, float stop, + float x, float y, float hr, float vr) { + } + + + protected void arc2_stroke(float start, float stop, + float x, float y, float hr, float vr) { + } + + ////////////////////////////////////////////////////////////// // ELLIPSE @@ -2231,7 +2445,7 @@ public class PGraphics extends PImage implements PMethods, PConstants { hradius = (hradius - x) / 2f; vradius = (vradius - y) / 2f; x += hradius; - y += hradius; + y += vradius; break; } @@ -2258,6 +2472,7 @@ public class PGraphics extends PImage implements PMethods, PConstants { protected void ellipse2_stroke(float x, float y, float h, float v) { } + /* protected void ellipse_mess(float x, float y, float hradius, float vradius) { // adapt accuracy to radii used w/ a minimum of 4 segments [toxi] @@ -2286,10 +2501,10 @@ public class PGraphics extends PImage implements PMethods, PConstants { if (plain && flat) { if (hradius == vradius) { - flat_circle((int)x, (int)y, (int)hradius); + circle0((int)x, (int)y, (int)hradius); } else { - flat_ellipse((int)x, (int)y, (int)hradius, (int)vradius); + ellipse0((int)x, (int)y, (int)hradius, (int)vradius); } } else { @@ -2306,16 +2521,128 @@ public class PGraphics extends PImage implements PMethods, PConstants { endShape(); } } + */ + /* + private void flat_ellipse(int centerX, int centerY, int a, int b) { + //FIXME + //if (dimensions == 2) { // probably a translate but no scale + centerX = (int) screenX(centerX, centerY, 0); + centerY = (int) screenY(centerX, centerY, 0); + //} + if (fill) flat_ellipse_internal(centerX, centerY, a, b, true); + if (stroke) flat_ellipse_internal(centerX, centerY, a, b, false); + } + */ + + + private void ellipse0_stroke_rough(int cx, int cy, int a, int b) { + ellipse0_rough(cx, cy, a, b, false); + } + + + private void ellipse0_fill_rough(int cx, int cy, int a, int b) { + ellipse0_rough(cx, cy, a, b, true); + } + + + /** + * 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 ellipse0_rough(int centerX, int centerY, + int a, int b, boolean filling) { + //int x, y, a2, b2, s, t; + + int a2 = a*a; + int b2 = b*b; + int x = 0; + int y = b; + int s = a2*(1-2*b) + 2*b2; + int t = b2 - 2*a2*(2*b-1); + ellipse0_rough_internal(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--; + } + ellipse0_rough_internal(centerX, centerY, x, y, filling); + + } while (y > 0); + } + + private final void ellipse0_rough_internal(int centerX, int centerY, + int ellipseX, int ellipseY, + boolean filling) { + // unfortunately this can't handle fill and stroke simultaneously, + // because the fill will later replace some of the stroke points + + if (filling) { + for (int i = centerX - ellipseX + 1; i < centerX + ellipseX; i++) { + point0(i, centerY - ellipseY, 0, fillColor); + point0(i, centerY + ellipseY, 0, fillColor); + } + } else { + point0(centerX - ellipseX, centerY + ellipseY, 0, strokeColor); + point0(centerX + ellipseX, centerY + ellipseY, 0, strokeColor); + point0(centerX - ellipseX, centerY - ellipseY, 0, strokeColor); + point0(centerX + ellipseX, centerY - ellipseY, 0, strokeColor); + } + } + + + /* private void flat_circle(int centerX, int centerY, int radius) { // FIXME //if (dimensions == 2) { // translate but no scale centerX = (int) screenX(centerX, centerY, 0); centerY = (int) screenY(centerX, centerY, 0); //} - if (fill) flat_circle_fill(centerX, centerY, radius); - if (stroke) flat_circle_stroke(centerX, centerY, radius); + if (fill) circle0_fill(centerX, centerY, radius); + if (stroke) circle0_stroke(centerX, centerY, radius); + } + */ + + + private void circle0(float x, float y, float r) { + if (fill) circle0_fill(x, y, 0, r, fillColor); + if (stroke) circle0_stroke(x, y, 0, r, strokeColor); + } + + + private void circle0_stroke(float x, float y, float z, float r, int color) { + if (smooth) { + circle0_stroke_smooth(x, y, z, r, color); + } else { + circle0_stroke_rough(x, y, z, r, color); + } + } + + + private void circle0_stroke_smooth(float x, float y, float z, + float r, int color) { + // TODO draw a circle that's smoothed in screen space coords } @@ -2343,13 +2670,18 @@ public class PGraphics extends PImage implements PMethods, PConstants { * @param yc y center * @param r radius */ - private void flat_circle_stroke(int xC, int yC, int r) { + private void circle0_stroke_rough(float xcf, float ycf, float z, + float rf, int color) { + int xc = (int) (xcf + 0.5f); + int yc = (int) (ycf + 0.5f); + int r = (int) (rf + 0.5f); + 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 + point0(xc + x, yc + y, z, color); // NNE + point0(xc + y, yc - x, z, color); // ESE + point0(xc - x, yc - y, z, color); // SSW + point0(xc - y, yc + x, z, color); // WNW x++; E += u; u += 2; if (v < 2 * E) { @@ -2357,13 +2689,23 @@ public class PGraphics extends PImage implements PMethods, PConstants { } 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 + point0(xc + y, yc + x, z, color); // ENE + point0(xc + x, yc - y, z, color); // SSE + point0(xc - y, yc - x, z, color); // WSW + point0(xc - x, yc + y, z, color); // NNW } } + + private void circle0_fill(float x, float y, float z, float r, int color) { + if (smooth) { + circle0_smooth_fill(x, y, z, r, color); + } else { + circle0_rough_fill(x, y, z, r, color); + } + } + + /** * Heavily adapted version of the above algorithm that handles * filling the ellipse. Works by drawing from the center and @@ -2376,20 +2718,25 @@ public class PGraphics extends PImage implements PMethods, PConstants { * @param yc y center * @param r radius */ - private void flat_circle_fill(int xc, int yc, int r) { + private void circle0_rough_fill(float xcf, float ycf, float z, + float rf, int color) { + int xc = (int) (xcf + 0.5f); + int yc = (int) (ycf + 0.5f); + int r = (int) (rf + 0.5f); + 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); + point0(xx, yc + y, z, color); } for (int xx = xc; xx < xc + y; xx++) { // ESE - thin_point(xx, yc - x, 0, fillColor); + point0(xx, yc - x, z, color); } for (int xx = xc - x; xx < xc; xx++) { // SSW - thin_point(xx, yc - y, 0, fillColor); + point0(xx, yc - y, z, color); } for (int xx = xc - y; xx < xc; xx++) { // WNW - thin_point(xx, yc + x, 0, fillColor); + point0(xx, yc + x, z, color); } x++; E += u; u += 2; @@ -2399,98 +2746,26 @@ public class PGraphics extends PImage implements PMethods, PConstants { if (x > y) break; for (int xx = xc; xx < xc + y; xx++) { // ENE - thin_point(xx, yc + x, 0, fillColor); + point0(xx, yc + x, z, color); } for (int xx = xc; xx < xc + x; xx++) { // SSE - thin_point(xx, yc - y, 0, fillColor); + point0(xx, yc - y, z, color); } for (int xx = xc - y; xx < xc; xx++) { // WSW - thin_point(xx, yc - x, 0, fillColor); + point0(xx, yc - x, z, color); } for (int xx = xc - x; xx < xc; xx++) { // NNW - thin_point(xx, yc + y, 0, fillColor); + point0(xx, yc + y, z, color); } } } - // 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); - } + private void circle0_smooth_fill(float x, float y, float z, + float r, int color) { } - /** - * 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) { - //FIXME - //if (dimensions == 2) { // probably a translate but no scale - centerX = (int) screenX(centerX, centerY, 0); - centerY = (int) screenY(centerX, centerY, 0); - //} - if (fill) flat_ellipse_internal(centerX, centerY, a, b, true); - if (stroke) flat_ellipse_internal(centerX, centerY, a, b, false); - } - - - ////////////////////////////////////////////////////////////// // IMAGE @@ -3026,7 +3301,7 @@ public class PGraphics extends PImage implements PMethods, PConstants { ////////////////////////////////////////////////////////////// - // 3D SHAPES, DRAWN FROM CENTER + // 3D BOX // solid or wire depends on settings for stroke and fill @@ -3097,6 +3372,12 @@ public class PGraphics extends PImage implements PMethods, PConstants { } + + ////////////////////////////////////////////////////////////// + + // 3D SPHERE + + // [toxi031031] used by the new sphere code below // precompute vertices along unit sphere with new detail setting @@ -4311,8 +4592,8 @@ public class PGraphics extends PImage implements PMethods, PConstants { } - public void strokeMiter(int miter) { - strokeMiter = miter; + public void strokeCap(int cap) { + strokeCap = cap; } diff --git a/processing/core/PMethods.java b/processing/core/PMethods.java index 33dcdfb69..2d4486daf 100755 --- a/processing/core/PMethods.java +++ b/processing/core/PMethods.java @@ -117,6 +117,14 @@ public interface PMethods { public void cache(PImage images[]); + public void arcMode(int mode); + + public void arc(float start, float stop, + float x, float y, float radius); + + public void arc(float start, float stop, + float x, float y, float hr, float vr); + public void ellipseMode(int mode); public void ellipse(float x, float y, float hradius, float vradius); @@ -319,7 +327,7 @@ public interface PMethods { public void strokeJoin(int join); - public void strokeMiter(int miter); + public void strokeCap(int cap); public void noStroke(); diff --git a/processing/core/PTriangle.java b/processing/core/PTriangle.java index cf6ecb7fd..870bec67e 100644 --- a/processing/core/PTriangle.java +++ b/processing/core/PTriangle.java @@ -37,34 +37,31 @@ public class PTriangle implements PConstants static final int R_TEXTURE32 = 0x8; static final int R_ALPHA = 0x10; - // - private int[] m_pixels; - private int[] m_stencil; - private int[] m_texture; - private float[] m_zbuffer; + private int[] m_pixels; + private int[] m_texture; + private int[] m_stencil; + private float[] m_zbuffer; - // texture image - private PImage m_tImage; + //private PImage m_tImage; - // - private int SCREEN_WIDTH; - private int SCREEN_HEIGHT; - private int SCREEN_WIDTH1; - private int SCREEN_HEIGHT1; - private int TEX_WIDTH; - private int TEX_HEIGHT; - private float F_TEX_WIDTH; - private float F_TEX_HEIGHT; + private int SCREEN_WIDTH; + private int SCREEN_HEIGHT; + private int SCREEN_WIDTH1; + private int SCREEN_HEIGHT1; - // - public boolean INTERPOLATE_UV; - public boolean INTERPOLATE_RGB; - public boolean INTERPOLATE_ALPHA; + private int TEX_WIDTH; + private int TEX_HEIGHT; + private float F_TEX_WIDTH; + private float F_TEX_HEIGHT; + + public boolean INTERPOLATE_UV; + public boolean INTERPOLATE_RGB; + public boolean INTERPOLATE_ALPHA; // Vertex coordinates - private float[] x_array; - private float[] y_array; - private float[] z_array; + private float[] x_array; + private float[] y_array; + private float[] z_array; // U,V coordinates private float[] u_array; @@ -240,7 +237,7 @@ public class PTriangle implements PConstants INTERPOLATE_UV = false; INTERPOLATE_RGB = false; INTERPOLATE_ALPHA = false; - m_tImage = null; + //m_tImage = null; m_texture = null; m_drawFlags = 0; } @@ -343,7 +340,7 @@ public class PTriangle implements PConstants * Sets texture image used for the polygon */ public void setTexture(PImage image) { - m_tImage = image; + //m_tImage = image; m_texture = image.pixels; TEX_WIDTH = image.width; TEX_HEIGHT = image.height;