PSmoothTriangle.java - processing - Project Hosting on Google Code

Source path: svn/ trunk/ processing/ core/ src/ processing/ core/ PSmoothTriangle.java

‹r5147

r7768

/* -*- 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;
  }
}

Show details Hide details

Change log

r5283 by fry on Nov 23, 2008 Diff

stroked lines drawing on top of everything
else in P3D (bug #1032)

Go to:

Older revisions

r5147 by fry on Nov 18, 2008 Diff

get images/textures working with P2D

r4927 by fry on Oct 15, 2008 Diff

unused vars

r4926 by fry on Oct 15, 2008 Diff

fixing indents to match the rest of
core

All revisions of this file

File info

Size: 31678 bytes, 968 lines

View raw file