/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */ /* Part of the Processing project - http://processing.org Copyright (c) 2004-08 Ben Fry and Casey Reas Copyright (c) 2001-04 Massachusetts Institute of Technology 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; /** * Smoothed triangle renderer for P3D. * * Based off of the PPolygon class in old versions of Processing. * Name and location of this class will change in a future release. */ public class PSmoothTriangle implements PConstants { // really this is "debug" but.. private static final boolean EWJORDAN = false; private static final boolean FRY = false; // identical to the constants from PGraphics static final int X = 0; // transformed xyzw static final int Y = 1; // formerly SX SY SZ static final int Z = 2; static final int R = 3; // actual rgb, after lighting static final int G = 4; // fill stored here, transform in place static final int B = 5; static final int A = 6; static final int U = 7; // texture static final int V = 8; static final int DEFAULT_SIZE = 64; // this is needed for spheres float vertices[][] = new float[DEFAULT_SIZE][PGraphics.VERTEX_FIELD_COUNT]; int vertexCount; // after some fiddling, this seems to produce the best results static final int ZBUFFER_MIN_COVERAGE = 204; float r[] = new float[DEFAULT_SIZE]; // storage used by incrementalize float dr[] = new float[DEFAULT_SIZE]; float l[] = new float[DEFAULT_SIZE]; // more storage for incrementalize float dl[] = new float[DEFAULT_SIZE]; float sp[] = new float[DEFAULT_SIZE]; // temporary storage for scanline float sdp[] = new float[DEFAULT_SIZE]; // color and xyz are always interpolated boolean interpX; boolean interpZ; boolean interpUV; // is this necessary? could just check timage != null boolean interpARGB; int rgba; int r2, g2, b2, a2, a2orig; boolean noDepthTest; PGraphics3D parent; int pixels[]; float[] zbuffer; // the parent's width/height, // or if smooth is enabled, parent's w/h scaled // up by the smooth dimension int width, height; int width1, height1; PImage timage; int tpixels[]; int theight, twidth; int theight1, twidth1; int tformat; // temp fix to behave like SMOOTH_IMAGES // TODO ewjordan: can probably remove this variable boolean texture_smooth; // for anti-aliasing static final int SUBXRES = 8; static final int SUBXRES1 = 7; static final int SUBYRES = 8; static final int SUBYRES1 = 7; static final int MAX_COVERAGE = SUBXRES * SUBYRES; boolean smooth; int firstModY; int lastModY; int lastY; int aaleft[] = new int[SUBYRES]; int aaright[] = new int[SUBYRES]; int aaleftmin, aarightmin; int aaleftmax, aarightmax; int aaleftfull, aarightfull; /* Variables needed for accurate texturing. */ //private PMatrix textureMatrix = new PMatrix3D(); private float[] camX = new float[3]; private float[] camY = new float[3]; private float[] camZ = new float[3]; private float ax,ay,az; private float bx,by,bz; private float cx,cy,cz; private float nearPlaneWidth, nearPlaneHeight, nearPlaneDepth; //private float newax, newbx, newcx; private float xmult, ymult; final private int MODYRES(int y) { return (y & SUBYRES1); } public PSmoothTriangle(PGraphics3D iparent) { parent = iparent; reset(0); } public void reset(int count) { vertexCount = count; interpX = true; interpZ = true; interpUV = false; interpARGB = true; timage = null; } public float[] nextVertex() { if (vertexCount == vertices.length) { //parent.message(CHATTER, "re-allocating for " + // (vertexCount*2) + " vertices"); float temp[][] = new float[vertexCount<<1][PGraphics.VERTEX_FIELD_COUNT]; System.arraycopy(vertices, 0, temp, 0, vertexCount); vertices = temp; r = new float[vertices.length]; dr = new float[vertices.length]; l = new float[vertices.length]; dl = new float[vertices.length]; sp = new float[vertices.length]; sdp = new float[vertices.length]; } return vertices[vertexCount++]; // returns v[0], sets vc to 1 } public void texture(PImage image) { this.timage = image; this.tpixels = image.pixels; this.twidth = image.width; this.theight = image.height; this.tformat = image.format; twidth1 = twidth - 1; theight1 = theight - 1; interpUV = true; } public void render() { if (vertexCount < 3) return; smooth = true;//TODO // these may have changed due to a resize() // so they should be refreshed here pixels = parent.pixels; zbuffer = parent.zbuffer; noDepthTest = false;//parent.hints[DISABLE_DEPTH_TEST]; // In 0148+, should always be true if this code is called at all //smooth = parent.smooth; // by default, text turns on smooth for the textures // themselves. but this should be shut off if the hint // for DISABLE_TEXT_SMOOTH is set. texture_smooth = true; width = smooth ? parent.width*SUBXRES : parent.width; height = smooth ? parent.height*SUBYRES : parent.height; width1 = width - 1; height1 = height - 1; if (!interpARGB) { r2 = (int) (vertices[0][R] * 255); g2 = (int) (vertices[0][G] * 255); b2 = (int) (vertices[0][B] * 255); a2 = (int) (vertices[0][A] * 255); a2orig = a2; // save an extra copy rgba = 0xff000000 | (r2 << 16) | (g2 << 8) | b2; } for (int i = 0; i < vertexCount; i++) { r[i] = 0; dr[i] = 0; l[i] = 0; dl[i] = 0; } if (smooth) { for (int i = 0; i < vertexCount; i++) { vertices[i][X] *= SUBXRES; vertices[i][Y] *= SUBYRES; } firstModY = -1; } // find top vertex (y is zero at top, higher downwards) int topi = 0; float ymin = vertices[0][Y]; float ymax = vertices[0][Y]; // fry 031001 for (int i = 1; i < vertexCount; i++) { if (vertices[i][Y] < ymin) { ymin = vertices[i][Y]; topi = i; } if (vertices[i][Y] > ymax) ymax = vertices[i][Y]; } // the last row is an exceptional case, because there won't // necessarily be 8 rows of subpixel lines that will force // the final line to render. so instead, the algo keeps track // of the lastY (in subpixel resolution) that will be rendered // and that will force a scanline to happen the same as // every eighth in the other situations //lastY = -1; // fry 031001 lastY = (int) (ymax - 0.5f); // global to class bc used by other fxns int lefti = topi; // li, index of left vertex int righti = topi; // ri, index of right vertex int y = (int) (ymin + 0.5f); // current scan line int lefty = y - 1; // lower end of left edge int righty = y - 1; // lower end of right edge interpX = true; int remaining = vertexCount; // scan in y, activating new edges on left & right // as scan line passes over new vertices while (remaining > 0) { // advance left edge? while ((lefty <= y) && (remaining > 0)) { remaining--; // step ccw down left side int i = (lefti != 0) ? (lefti-1) : (vertexCount-1); incrementalize_y(vertices[lefti], vertices[i], l, dl, y); lefty = (int) (vertices[i][Y] + 0.5f); lefti = i; } // advance right edge? while ((righty <= y) && (remaining > 0)) { remaining--; // step cw down right edge int i = (righti != vertexCount-1) ? (righti + 1) : 0; incrementalize_y(vertices[righti], vertices[i], r, dr, y); righty = (int) (vertices[i][Y] + 0.5f); righti = i; } // do scanlines till end of l or r edge while (y < lefty && y < righty) { // this doesn't work because it's not always set here //if (remaining == 0) { //lastY = (lefty < righty) ? lefty-1 : righty-1; //System.out.println("lastY is " + lastY); //} if ((y >= 0) && (y < height)) { //try { // hopefully this bug is fixed if (l[X] <= r[X]) scanline(y, l, r); else scanline(y, r, l); //} catch (ArrayIndexOutOfBoundsException e) { //e.printStackTrace(); //} } y++; // this increment probably needs to be different // UV and RGB shouldn't be incremented until line is emitted increment(l, dl); increment(r, dr); } } //if (smooth) { //System.out.println("y/lasty/lastmody = " + y + " " + lastY + " " + lastModY); //} } public void unexpand() { if (smooth) { for (int i = 0; i < vertexCount; i++) { vertices[i][X] /= SUBXRES; vertices[i][Y] /= SUBYRES; } } } private void scanline(int y, float l[], float r[]) { //System.out.println("scanline " + y); for (int i = 0; i < vertexCount; i++) { // should be moved later sp[i] = 0; sdp[i] = 0; } // this rounding doesn't seem to be relevant with smooth int lx = (int) (l[X] + 0.49999f); // ceil(l[X]-.5); if (lx < 0) lx = 0; int rx = (int) (r[X] - 0.5f); if (rx > width1) rx = width1; if (lx > rx) return; if (smooth) { int mody = MODYRES(y); aaleft[mody] = lx; aaright[mody] = rx; if (firstModY == -1) { firstModY = mody; aaleftmin = lx; aaleftmax = lx; aarightmin = rx; aarightmax = rx; } else { if (aaleftmin > aaleft[mody]) aaleftmin = aaleft[mody]; if (aaleftmax < aaleft[mody]) aaleftmax = aaleft[mody]; if (aarightmin > aaright[mody]) aarightmin = aaright[mody]; if (aarightmax < aaright[mody]) aarightmax = aaright[mody]; } lastModY = mody; // moved up here (before the return) 031001 // not the eighth (or lastY) line, so not scanning this time if ((mody != SUBYRES1) && (y != lastY)) return; //lastModY = mody; // eeK! this was missing //return; //if (y == lastY) { //System.out.println("y is lasty"); //} //lastModY = mody; aaleftfull = aaleftmax/SUBXRES + 1; aarightfull = aarightmin/SUBXRES - 1; } // this is the setup, based on lx incrementalize_x(l, r, sp, sdp, lx); //System.out.println(l[V] + " " + r[V] + " " +sp[V] + " " +sdp[V]); // scan in x, generating pixels // using parent.width to get actual pixel index // rather than scaled by smooth factor int offset = smooth ? parent.width * (y / SUBYRES) : parent.width*y; int truelx = 0, truerx = 0; if (smooth) { truelx = lx / SUBXRES; truerx = (rx + SUBXRES1) / SUBXRES; lx = aaleftmin / SUBXRES; rx = (aarightmax + SUBXRES1) / SUBXRES; if (lx < 0) lx = 0; if (rx > parent.width1) rx = parent.width1; } // System.out.println("P3D interp uv " + interpUV + " " + // vertices[2][U] + " " + vertices[2][V]); interpX = false; int tr, tg, tb, ta; //System.out.println("lx: "+lx + "\nrx: "+rx); for (int x = lx; x <= rx; x++) { // added == because things on same plane weren't replacing each other // makes for strangeness in 3D [ewj: yup!], but totally necessary for 2D //if (noDepthTest || (sp[Z] < zbuffer[offset+x])) { if (noDepthTest || (sp[Z] <= zbuffer[offset+x])) { //if (true) { // map texture based on U, V coords in sp[U] and sp[V] if (interpUV) { int tu = (int)sp[U]; int tv = (int)sp[V]; if (tu > twidth1) tu = twidth1; if (tv > theight1) tv = theight1; if (tu < 0) tu = 0; if (tv < 0) tv = 0; int txy = tv*twidth + tu; //System.out.println("tu: "+tu+" ; tv: "+tv+" ; txy: "+txy); float[] uv = new float[2]; txy = getTextureIndex(x, y*1.0f/SUBYRES, uv); // txy = getTextureIndex(x* 1.0f/SUBXRES, y*1.0f/SUBYRES, uv); tu = (int)uv[0]; tv = (int)uv[1]; // if (tu > twidth1) tu = twidth1; // if (tv > theight1) tv = theight1; // if (tu < 0) tu = 0; // if (tv < 0) tv = 0; txy = twidth*tv + tu; // if (EWJORDAN) System.out.println("x/y/txy:"+x + " " + y + " " +txy); //PApplet.println(sp); //smooth = true; if (smooth || texture_smooth) { //if (FRY) System.out.println("sp u v = " + sp[U] + " " + sp[V]); //System.out.println("sp u v = " + sp[U] + " " + sp[V]); // tuf1/tvf1 is the amount of coverage for the adjacent // pixel, which is the decimal percentage. // int tuf1 = (int) (255f * (sp[U] - (float)tu)); // int tvf1 = (int) (255f * (sp[V] - (float)tv)); int tuf1 = (int) (255f * (uv[0] - tu)); int tvf1 = (int) (255f * (uv[1] - tv)); // the closer sp[U or V] is to the decimal being zero // the more coverage it should get of the original pixel int tuf = 255 - tuf1; int tvf = 255 - tvf1; // this code sucks! filled with bugs and slow as hell! int pixel00 = tpixels[txy]; int pixel01 = (tv < theight1) ? tpixels[txy + twidth] : tpixels[txy]; int pixel10 = (tu < twidth1) ? tpixels[txy + 1] : tpixels[txy]; int pixel11 = ((tv < theight1) && (tu < twidth1)) ? tpixels[txy + twidth + 1] : tpixels[txy]; //System.out.println("1: "+pixel00); //check int p00, p01, p10, p11; int px0, px1; //, pxy; if (tformat == ALPHA) { px0 = (pixel00*tuf + pixel10*tuf1) >> 8; px1 = (pixel01*tuf + pixel11*tuf1) >> 8; ta = (((px0*tvf + px1*tvf1) >> 8) * (interpARGB ? ((int) (sp[A]*255)) : a2orig)) >> 8; } else if (tformat == ARGB) { p00 = (pixel00 >> 24) & 0xff; p01 = (pixel01 >> 24) & 0xff; p10 = (pixel10 >> 24) & 0xff; p11 = (pixel11 >> 24) & 0xff; px0 = (p00*tuf + p10*tuf1) >> 8; px1 = (p01*tuf + p11*tuf1) >> 8; ta = (((px0*tvf + px1*tvf1) >> 8) * (interpARGB ? ((int) (sp[A]*255)) : a2orig)) >> 8; } else { // RGB image, no alpha //ACCTEX: Getting here when smooth is on ta = interpARGB ? ((int) (sp[A]*255)) : a2orig; //System.out.println("4: "+ta + " " +interpARGB + " " + sp[A] + " " + a2orig); //check } if ((tformat == RGB) || (tformat == ARGB)) { p00 = (pixel00 >> 16) & 0xff; // red p01 = (pixel01 >> 16) & 0xff; p10 = (pixel10 >> 16) & 0xff; p11 = (pixel11 >> 16) & 0xff; px0 = (p00*tuf + p10*tuf1) >> 8; px1 = (p01*tuf + p11*tuf1) >> 8; tr = (((px0*tvf + px1*tvf1) >> 8) * (interpARGB ? ((int) (sp[R]*255)) : r2)) >> 8; p00 = (pixel00 >> 8) & 0xff; // green p01 = (pixel01 >> 8) & 0xff; p10 = (pixel10 >> 8) & 0xff; p11 = (pixel11 >> 8) & 0xff; px0 = (p00*tuf + p10*tuf1) >> 8; px1 = (p01*tuf + p11*tuf1) >> 8; tg = (((px0*tvf + px1*tvf1) >> 8) * (interpARGB ? ((int) (sp[G]*255)) : g2)) >> 8; p00 = pixel00 & 0xff; // blue p01 = pixel01 & 0xff; p10 = pixel10 & 0xff; p11 = pixel11 & 0xff; px0 = (p00*tuf + p10*tuf1) >> 8; px1 = (p01*tuf + p11*tuf1) >> 8; tb = (((px0*tvf + px1*tvf1) >> 8) * (interpARGB ? ((int) (sp[B]*255)) : b2)) >> 8; //System.out.println("5: "+tr + " " + tg + " " +tb); //check } else { // alpha image, only use current fill color if (interpARGB) { tr = (int) (sp[R] * 255); tg = (int) (sp[G] * 255); tb = (int) (sp[B] * 255); } else { tr = r2; tg = g2; tb = b2; } } // get coverage for pixel if smooth // checks smooth again here because of // hints[SMOOTH_IMAGES] used up above int weight = smooth ? coverage(x) : 255; if (weight != 255) ta = (ta*weight) >> 8; //System.out.println(ta); //System.out.println("8"); //check } else { // no smooth, just get the pixels int tpixel = tpixels[txy]; // TODO i doubt splitting these guys really gets us // all that much speed.. is it worth it? if (tformat == ALPHA) { ta = tpixel; if (interpARGB) { tr = (int) (sp[R]*255); tg = (int) (sp[G]*255); tb = (int) (sp[B]*255); if (sp[A] != 1) { ta = (((int) (sp[A]*255)) * ta) >> 8; } } else { tr = r2; tg = g2; tb = b2; ta = (a2orig * ta) >> 8; } } else { // RGB or ARGB ta = (tformat == RGB) ? 255 : (tpixel >> 24) & 0xff; if (interpARGB) { tr = (((int) (sp[R]*255)) * ((tpixel >> 16) & 0xff)) >> 8; tg = (((int) (sp[G]*255)) * ((tpixel >> 8) & 0xff)) >> 8; tb = (((int) (sp[B]*255)) * ((tpixel) & 0xff)) >> 8; ta = (((int) (sp[A]*255)) * ta) >> 8; } else { tr = (r2 * ((tpixel >> 16) & 0xff)) >> 8; tg = (g2 * ((tpixel >> 8) & 0xff)) >> 8; tb = (b2 * ((tpixel) & 0xff)) >> 8; ta = (a2orig * ta) >> 8; } } } if ((ta == 254) || (ta == 255)) { // if (ta & 0xf8) would be good // no need to blend pixels[offset+x] = 0xff000000 | (tr << 16) | (tg << 8) | tb; zbuffer[offset+x] = sp[Z]; } else { // blend with pixel on screen int a1 = 255-ta; int r1 = (pixels[offset+x] >> 16) & 0xff; int g1 = (pixels[offset+x] >> 8) & 0xff; int b1 = (pixels[offset+x]) & 0xff; pixels[offset+x] = 0xff000000 | (((tr*ta + r1*a1) >> 8) << 16) | ((tg*ta + g1*a1) & 0xff00) | ((tb*ta + b1*a1) >> 8); //System.out.println("17"); //check if (ta > ZBUFFER_MIN_COVERAGE) zbuffer[offset+x] = sp[Z]; } //System.out.println("18"); //check } else { // no image applied int weight = smooth ? coverage(x) : 255; if (interpARGB) { r2 = (int) (sp[R] * 255); g2 = (int) (sp[G] * 255); b2 = (int) (sp[B] * 255); if (sp[A] != 1) weight = (weight * ((int) (sp[A] * 255))) >> 8; if (weight == 255) { rgba = 0xff000000 | (r2 << 16) | (g2 << 8) | b2; } } else { if (a2orig != 255) weight = (weight * a2orig) >> 8; } if (weight == 255) { // no blend, no aa, just the rgba pixels[offset+x] = rgba; zbuffer[offset+x] = sp[Z]; } else { int r1 = (pixels[offset+x] >> 16) & 0xff; int g1 = (pixels[offset+x] >> 8) & 0xff; int b1 = (pixels[offset+x]) & 0xff; a2 = weight; int a1 = 255 - a2; pixels[offset+x] = (0xff000000 | ((r1*a1 + r2*a2) >> 8) << 16 | // use & instead of >> and << below ((g1*a1 + g2*a2) >> 8) << 8 | ((b1*a1 + b2*a2) >> 8)); if (a2 > ZBUFFER_MIN_COVERAGE) zbuffer[offset+x] = sp[Z]; } } } // if smooth enabled, don't increment values // for the pixel in the stretch out version // of the scanline used to get smooth edges. if (!smooth || ((x >= truelx) && (x <= truerx))) { //if (!smooth) increment(sp, sdp); } } firstModY = -1; interpX = true; } // x is in screen, not huge 8x coordinates private int coverage(int x) { if ((x >= aaleftfull) && (x <= aarightfull) && // important since not all SUBYRES lines may have been covered (firstModY == 0) && (lastModY == SUBYRES1)) { return 255; } int pixelLeft = x*SUBXRES; // huh? int pixelRight = pixelLeft + 8; int amt = 0; for (int i = firstModY; i <= lastModY; i++) { if ((aaleft[i] > pixelRight) || (aaright[i] < pixelLeft)) { continue; } // does this need a +1 ? amt += ((aaright[i] < pixelRight ? aaright[i] : pixelRight) - (aaleft[i] > pixelLeft ? aaleft[i] : pixelLeft)); } amt <<= 2; return (amt == 256) ? 255 : amt; } private void incrementalize_y(float p1[], float p2[], float p[], float dp[], int y) { float delta = p2[Y] - p1[Y]; if (delta == 0) delta = 1; float fraction = y + 0.5f - p1[Y]; if (interpX) { dp[X] = (p2[X] - p1[X]) / delta; p[X] = p1[X] + dp[X] * fraction; } if (interpZ) { dp[Z] = (p2[Z] - p1[Z]) / delta; p[Z] = p1[Z] + dp[Z] * fraction; } if (interpARGB) { dp[R] = (p2[R] - p1[R]) / delta; dp[G] = (p2[G] - p1[G]) / delta; dp[B] = (p2[B] - p1[B]) / delta; dp[A] = (p2[A] - p1[A]) / delta; p[R] = p1[R] + dp[R] * fraction; p[G] = p1[G] + dp[G] * fraction; p[B] = p1[B] + dp[B] * fraction; p[A] = p1[A] + dp[A] * fraction; } if (interpUV) { dp[U] = (p2[U] - p1[U]) / delta; dp[V] = (p2[V] - p1[V]) / delta; //if (smooth) { //p[U] = p1[U]; //+ dp[U] * fraction; //p[V] = p1[V]; //+ dp[V] * fraction; //} else { p[U] = p1[U] + dp[U] * fraction; p[V] = p1[V] + dp[V] * fraction; //} if (FRY) System.out.println("inc y p[U] p[V] = " + p[U] + " " + p[V]); } } //incrementalize_x(l, r, sp, sdp, lx); private void incrementalize_x(float p1[], float p2[], float p[], float dp[], int x) { float delta = p2[X] - p1[X]; if (delta == 0) delta = 1; float fraction = x + 0.5f - p1[X]; if (smooth) { delta /= SUBXRES; fraction /= SUBXRES; } if (interpX) { dp[X] = (p2[X] - p1[X]) / delta; p[X] = p1[X] + dp[X] * fraction; } if (interpZ) { dp[Z] = (p2[Z] - p1[Z]) / delta; p[Z] = p1[Z] + dp[Z] * fraction; //System.out.println(p2[Z]+" " +p1[Z]+" " +dp[Z]); } if (interpARGB) { dp[R] = (p2[R] - p1[R]) / delta; dp[G] = (p2[G] - p1[G]) / delta; dp[B] = (p2[B] - p1[B]) / delta; dp[A] = (p2[A] - p1[A]) / delta; p[R] = p1[R] + dp[R] * fraction; p[G] = p1[G] + dp[G] * fraction; p[B] = p1[B] + dp[B] * fraction; p[A] = p1[A] + dp[A] * fraction; } if (interpUV) { if (FRY) System.out.println("delta, frac = " + delta + ", " + fraction); dp[U] = (p2[U] - p1[U]) / delta; dp[V] = (p2[V] - p1[V]) / delta; //if (smooth) { //p[U] = p1[U]; // offset for the damage that will be done by the // 8 consecutive calls to scanline // agh.. this won't work b/c not always 8 calls before render // maybe lastModY - firstModY + 1 instead? if (FRY) System.out.println("before inc x p[V] = " + p[V] + " " + p1[V] + " " + p2[V]); //p[V] = p1[V] - SUBXRES1 * fraction; //} else { p[U] = p1[U] + dp[U] * fraction; p[V] = p1[V] + dp[V] * fraction; //} } } private void increment(float p[], float dp[]) { if (interpX) p[X] += dp[X]; if (interpZ) p[Z] += dp[Z]; if (interpARGB) { p[R] += dp[R]; p[G] += dp[G]; p[B] += dp[B]; p[A] += dp[A]; } if (interpUV) { if (FRY) System.out.println("increment() " + p[V] + " " + dp[V]); p[U] += dp[U]; p[V] += dp[V]; } } /** * Pass camera-space coordinates for the triangle. * Needed to render if hint(ENABLE_ACCURATE_TEXTURES) enabled. * Generally this will not need to be called manually, * currently called from PGraphics3D.render_triangles() */ public void setCamVertices(float x0, float y0, float z0, float x1, float y1, float z1, float x2, float y2, float z2) { camX[0] = x0; camX[1] = x1; camX[2] = x2; camY[0] = y0; camY[1] = y1; camY[2] = y2; camZ[0] = z0; camZ[1] = z1; camZ[2] = z2; } public void setVertices(float x0, float y0, float z0, float x1, float y1, float z1, float x2, float y2, float z2) { vertices[0][X] = x0; vertices[1][X] = x1; vertices[2][X] = x2; vertices[0][Y] = y0; vertices[1][Y] = y1; vertices[2][Y] = y2; vertices[0][Z] = z0; vertices[1][Z] = z1; vertices[2][Z] = z2; } /** * Precompute a bunch of variables needed to perform * texture mapping. * @return True unless texture mapping is degenerate */ boolean precomputeAccurateTexturing() { int o0 = 0; int o1 = 1; int o2 = 2; PMatrix3D myMatrix = new PMatrix3D(vertices[o0][U], vertices[o0][V], 1, 0, vertices[o1][U], vertices[o1][V], 1, 0, vertices[o2][U], vertices[o2][V], 1, 0, 0, 0, 0, 1); // A 3x3 inversion would be more efficient here, // given that the fourth r/c are unity boolean invertSuccess = myMatrix.invert();// = myMatrix.invert(); // If the matrix inversion had trouble, let the caller know. // Note that this does not catch everything that could go wrong // here, like if the renderer is in ortho() mode (which really // must be caught in PGraphics3D instead of here). if (!invertSuccess) return false; float m00, m01, m02, m10, m11, m12, m20, m21, m22; m00 = myMatrix.m00*camX[o0]+myMatrix.m01*camX[o1]+myMatrix.m02*camX[o2]; m01 = myMatrix.m10*camX[o0]+myMatrix.m11*camX[o1]+myMatrix.m12*camX[o2]; m02 = myMatrix.m20*camX[o0]+myMatrix.m21*camX[o1]+myMatrix.m22*camX[o2]; m10 = myMatrix.m00*camY[o0]+myMatrix.m01*camY[o1]+myMatrix.m02*camY[o2]; m11 = myMatrix.m10*camY[o0]+myMatrix.m11*camY[o1]+myMatrix.m12*camY[o2]; m12 = myMatrix.m20*camY[o0]+myMatrix.m21*camY[o1]+myMatrix.m22*camY[o2]; m20 = -(myMatrix.m00*camZ[o0]+myMatrix.m01*camZ[o1]+myMatrix.m02*camZ[o2]); m21 = -(myMatrix.m10*camZ[o0]+myMatrix.m11*camZ[o1]+myMatrix.m12*camZ[o2]); m22 = -(myMatrix.m20*camZ[o0]+myMatrix.m21*camZ[o1]+myMatrix.m22*camZ[o2]); float px = m02; float py = m12; float pz = m22; float TEX_WIDTH = this.twidth; float TEX_HEIGHT = this.theight; float resultT0x = m00*TEX_WIDTH+m02; float resultT0y = m10*TEX_WIDTH+m12; float resultT0z = m20*TEX_WIDTH+m22; float result0Tx = m01*TEX_HEIGHT+m02; float result0Ty = m11*TEX_HEIGHT+m12; float result0Tz = m21*TEX_HEIGHT+m22; float mx = resultT0x-m02; float my = resultT0y-m12; float mz = resultT0z-m22; float nx = result0Tx-m02; float ny = result0Ty-m12; float nz = result0Tz-m22; //avec = p x n ax = (py*nz-pz*ny)*TEX_WIDTH; //F_TEX_WIDTH/HEIGHT? ay = (pz*nx-px*nz)*TEX_WIDTH; az = (px*ny-py*nx)*TEX_WIDTH; //bvec = m x p bx = (my*pz-mz*py)*TEX_HEIGHT; by = (mz*px-mx*pz)*TEX_HEIGHT; bz = (mx*py-my*px)*TEX_HEIGHT; //cvec = n x m cx = ny*mz-nz*my; cy = nz*mx-nx*mz; cz = nx*my-ny*mx; //System.out.println("a/b/c: "+ax+" " + ay + " " + az + " " + bx + " " + by + " " + bz + " " + cx + " " + cy + " " + cz); nearPlaneWidth = (parent.rightScreen-parent.leftScreen); nearPlaneHeight = (parent.topScreen-parent.bottomScreen); nearPlaneDepth = parent.nearPlane; // one pixel width in nearPlane coordinates xmult = nearPlaneWidth / parent.width; ymult = nearPlaneHeight / parent.height; // Extra scalings to map screen plane units to pixel units // newax = ax*xmult; // newbx = bx*xmult; // newcx = cx*xmult; // System.out.println("nearplane: "+ nearPlaneWidth + " " + nearPlaneHeight + " " + nearPlaneDepth); // System.out.println("mults: "+ xmult + " " + ymult); // System.out.println("news: "+ newax + " " + newbx + " " + newcx); return true; } /** * Get the texture map location based on the current screen * coordinates. Assumes precomputeAccurateTexturing() has * been called already for this texture mapping. * @param sx * @param sy * @return */ private int getTextureIndex(float sx, float sy, float[] uv) { if (EWJORDAN) System.out.println("Getting texel at "+sx + ", "+sy); //System.out.println("Screen: "+ sx + " " + sy); sx = xmult*(sx-(parent.width/2.0f) +.5f);//+.5f) sy = ymult*(sy-(parent.height/2.0f)+.5f);//+.5f) //sx /= SUBXRES; //sy /= SUBYRES; float sz = nearPlaneDepth; float a = sx * ax + sy * ay + sz * az; float b = sx * bx + sy * by + sz * bz; float c = sx * cx + sy * cy + sz * cz; int u = (int)(a / c); int v = (int)(b / c); uv[0] = a / c; uv[1] = b / c; if (uv[0] < 0) { uv[0] = u = 0; } if (uv[1] < 0) { uv[1] = v = 0; } if (uv[0] >= twidth) { uv[0] = twidth-1; u = twidth-1; } if (uv[1] >= theight) { uv[1] = theight-1; v = theight-1; } int result = v*twidth + u; //System.out.println("a/b/c: "+a + " " + b + " " + c); //System.out.println("cx/y/z: "+cx + " " + cy + " " + cz); //if (result < 0) result = 0; //if (result >= timage.pixels.length-2) result = timage.pixels.length - 2; if (EWJORDAN) System.out.println("Got texel "+result); return result; } public void setIntensities(float ar, float ag, float ab, float aa, float br, float bg, float bb, float ba, float cr, float cg, float cb, float ca) { vertices[0][R] = ar; vertices[0][G] = ag; vertices[0][B] = ab; vertices[0][A] = aa; vertices[1][R] = br; vertices[1][G] = bg; vertices[1][B] = bb; vertices[1][A] = ba; vertices[2][R] = cr; vertices[2][G] = cg; vertices[2][B] = cb; vertices[2][A] = ca; } }