Arduino/core/PGraphics2D.java

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