PLine.java - processing - Project Hosting on Google Code

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

‹r5167

r7768

/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*
  Part of the Processing project - http://processing.org

  Copyright (c) 2004-07 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;


/**
 * Code for rendering lines with P2D and P3D.
 * @author rocha
 * @author fry
 */
public class PLine implements PConstants
{
  private int[]   m_pixels;
  private float[] m_zbuffer;
  //private int[]   m_stencil;

  private int m_index;

  static final int R_COLOR   = 0x1;
  static final int R_ALPHA   = 0x2;
  static final int R_SPATIAL = 0x8;
  static final int R_THICK   = 0x4;
  static final int R_SMOOTH  = 0x10;

  private int SCREEN_WIDTH;
  private int SCREEN_HEIGHT;
  private int SCREEN_WIDTH1;
  private int SCREEN_HEIGHT1;

  public boolean INTERPOLATE_RGB;
  public boolean INTERPOLATE_ALPHA;
  public boolean INTERPOLATE_Z;
  public boolean INTERPOLATE_THICK;

  // antialias
  private boolean SMOOTH;

  // blender
  //private boolean BLENDER;

  // stroke color
  private int m_stroke;

  // draw flags
  public int  m_drawFlags;

  // vertex coordinates
  private float[] x_array;
  private float[] y_array;
  private float[] z_array;

  // vertex intensity
  private float[] r_array;
  private float[] g_array;
  private float[] b_array;
  private float[] a_array;

  // vertex offsets
  private int o0;
  private int o1;

  // start values
  private float m_r0;
  private float m_g0;
  private float m_b0;
  private float m_a0;
  private float m_z0;

  // deltas
  private float dz;

  // rgba deltas
  private float dr;
  private float dg;
  private float db;
  private float da;

  private PGraphics parent;


  public PLine(PGraphics g) {
    INTERPOLATE_Z = false;

    x_array = new float[2];
    y_array = new float[2];
    z_array = new float[2];
    r_array = new float[2];
    g_array = new float[2];
    b_array = new float[2];
    a_array = new float[2];

    this.parent = g;
  }


  public void reset() {
    // reset these in case PGraphics was resized
    SCREEN_WIDTH = parent.width;
    SCREEN_HEIGHT = parent.height;
    SCREEN_WIDTH1 = SCREEN_WIDTH-1;
    SCREEN_HEIGHT1 = SCREEN_HEIGHT-1;

    m_pixels = parent.pixels;
    //m_stencil = parent.stencil;
    if (parent instanceof PGraphics3D) {
      m_zbuffer = ((PGraphics3D) parent).zbuffer;
    }

    // other things to reset

    INTERPOLATE_RGB = false;
    INTERPOLATE_ALPHA = false;
    //INTERPOLATE_Z = false;
    m_drawFlags = 0;
    m_index = 0;
    //BLENDER = false;
  }


  public void setVertices(float x0, float y0, float z0,
                          float x1, float y1, float z1) {
    // [rocha] fixed z drawing, so whenever a line turns on
    // z interpolation, all the lines are z interpolated
    if (z0 != z1 || z0 != 0.0f || z1 != 0.0f || INTERPOLATE_Z) {
      INTERPOLATE_Z = true;
      m_drawFlags |= R_SPATIAL;
    } else {
      INTERPOLATE_Z = false;
      m_drawFlags &= ~R_SPATIAL;
    }

    z_array[0] = z0;
    z_array[1] = z1;

    x_array[0] = x0;
    x_array[1] = x1;

    y_array[0] = y0;
    y_array[1] = y1;
  }


  public void setIntensities(float r0, float g0, float b0, float a0,
                             float r1, float g1, float b1, float a1) {
    a_array[0] = (a0 * 253f + 1.0f) * 65536f;
    a_array[1] = (a1 * 253f + 1.0f) * 65536f;

    // check if we need alpha or not?
    if ((a0 != 1.0f) || (a1 != 1.0f)) {
      INTERPOLATE_ALPHA = true;
      m_drawFlags |= R_ALPHA;
    } else {
      INTERPOLATE_ALPHA = false;
      m_drawFlags &= ~R_ALPHA;
    }

    // extra scaling added to prevent color "overflood" due to rounding errors
    r_array[0] = (r0 * 253f + 1.0f) * 65536f;
    r_array[1] = (r1 * 253f + 1.0f) * 65536f;

    g_array[0] = (g0 * 253f + 1.0f) * 65536f;
    g_array[1] = (g1 * 253f + 1.0f) * 65536f;

    b_array[0] = (b0 * 253f + 1.0f) * 65536f;
    b_array[1] = (b1 * 253f + 1.0f) * 65536f;

    // check if we need to interpolate the intensity values
    if (r0 != r1) {
      INTERPOLATE_RGB = true;
      m_drawFlags |= R_COLOR;

    } else if (g0 != g1) {
      INTERPOLATE_RGB = true;
      m_drawFlags |= R_COLOR;

    } else if (b0 != b1) {
      INTERPOLATE_RGB = true;
      m_drawFlags |= R_COLOR;

    } else {
      // when plain we use the stroke color of the first vertex
      m_stroke = 0xFF000000 |
        ((int)(255*r0) << 16) | ((int)(255*g0) << 8) | (int)(255*b0);
      INTERPOLATE_RGB = false;
      m_drawFlags &= ~R_COLOR;
    }
  }


  public void setIndex(int index) {
    m_index = index;
    //BLENDER = false;
    if (m_index != -1) {
      //BLENDER = true;
    } else {
      m_index = 0;
    }
  }


  public void draw() {
    int xi;
    int yi;
    int length;
    boolean visible = true;

    if (parent.smooth) {
      SMOOTH = true;
      m_drawFlags |= R_SMOOTH;

    } else {
      SMOOTH = false;
      m_drawFlags &= ~R_SMOOTH;
    }

    /*
    // line hack
    if (parent.hints[DISABLE_FLYING_POO]) {
      float nwidth2 = -SCREEN_WIDTH;
      float nheight2 = -SCREEN_HEIGHT;
      float width2 = SCREEN_WIDTH * 2;
      float height2 = SCREEN_HEIGHT * 2;
      if ((x_array[1] < nwidth2) ||
          (x_array[1] > width2) ||
          (x_array[0] < nwidth2) ||
          (x_array[0] > width2) ||
          (y_array[1] < nheight2) ||
          (y_array[1] > height2) ||
          (y_array[0] < nheight2) ||
          (y_array[0] > height2)) {
        return;  // this is a bad line
      }
    }
    */

    ///////////////////////////////////////
    // line clipping
    visible = lineClipping();
    if (!visible) {
      return;
    }

    ///////////////////////////////////////
    // calculate line values
    int shortLen;
    int longLen;
    boolean yLonger;
    int dt;

    yLonger = false;

    // HACK for drawing lines left-to-right for rev 0069
    // some kind of bug exists with the line-stepping algorithm
    // that causes strange patterns in the anti-aliasing.
    // [040228 fry]
    //
    // swap rgba as well as the coords.. oops
    // [040712 fry]
    //
    if (x_array[1] < x_array[0]) {
      float t;

      t = x_array[1]; x_array[1] = x_array[0]; x_array[0] = t;
      t = y_array[1]; y_array[1] = y_array[0]; y_array[0] = t;
      t = z_array[1]; z_array[1] = z_array[0]; z_array[0] = t;

      t = r_array[1]; r_array[1] = r_array[0]; r_array[0] = t;
      t = g_array[1]; g_array[1] = g_array[0]; g_array[0] = t;
      t = b_array[1]; b_array[1] = b_array[0]; b_array[0] = t;
      t = a_array[1]; a_array[1] = a_array[0]; a_array[0] = t;
    }

    // important - don't change the casts
    // is needed this way for line drawing algorithm
    longLen  = (int)x_array[1] - (int)x_array[0];
    shortLen = (int)y_array[1] - (int)y_array[0];

    if (Math.abs(shortLen) > Math.abs(longLen)) {
      int swap = shortLen;
      shortLen = longLen;
      longLen = swap;
      yLonger = true;
    }

    // now we sort points so longLen is always positive
    // and we always start drawing from x[0], y[0]
    if (longLen < 0) {
      // swap order
      o0 = 1;
      o1 = 0;

      xi = (int) x_array[1];
      yi = (int) y_array[1];

      length = -longLen;

    } else {
      o0 = 0;
      o1 = 1;

      xi = (int) x_array[0];
      yi = (int) y_array[0];

      length = longLen;
    }

    // calculate dt
    if (length == 0) {
      dt = 0;
    } else {
      dt = (shortLen << 16) / longLen;
    }

    m_r0 = r_array[o0];
    m_g0 = g_array[o0];
    m_b0 = b_array[o0];

    if (INTERPOLATE_RGB) {
      dr = (r_array[o1] - r_array[o0]) / length;
      dg = (g_array[o1] - g_array[o0]) / length;
      db = (b_array[o1] - b_array[o0]) / length;
    } else {
      dr = 0;
      dg = 0;
      db = 0;
    }

    m_a0 = a_array[o0];

    if (INTERPOLATE_ALPHA) {
      da = (a_array[o1] - a_array[o0]) / length;
    } else {
      da = 0;
    }

    m_z0 = z_array[o0];
    //z0 += -0.001f; // [rocha] ugly fix for z buffer precision

    if (INTERPOLATE_Z) {
      dz = (z_array[o1] - z_array[o0]) / length;
    } else {
      dz = 0;
    }

    // draw thin points
    if (length == 0) {
      if (INTERPOLATE_ALPHA) {
        drawPoint_alpha(xi, yi);
      } else {
        drawPoint(xi, yi);
      }
      return;
    }

    /*
    // draw antialias polygon lines for non stroked polygons
    if (BLENDER && SMOOTH) {
      // fix for endpoints not being drawn
      // [rocha]
      drawPoint_alpha((int)x_array[0], (int)x_array[0]);
      drawPoint_alpha((int)x_array[1], (int)x_array[1]);

      drawline_blender(x_array[0], y_array[0], x_array[1], y_array[1]);
      return;
    }
    */

    // draw normal strokes
    if (SMOOTH) {
//      if ((m_drawFlags & R_SPATIAL) != 0) {
//        drawLine_smooth_spatial(xi, yi, dt, length, yLonger);
//      } else {
      drawLine_smooth(xi, yi, dt, length, yLonger);
//      }

    } else {
      if (m_drawFlags == 0) {
        drawLine_plain(xi, yi, dt, length, yLonger);

      } else if (m_drawFlags == R_ALPHA) {
        drawLine_plain_alpha(xi, yi, dt, length, yLonger);

      } else if (m_drawFlags == R_COLOR) {
        drawLine_color(xi, yi, dt, length, yLonger);

      } else if (m_drawFlags == (R_COLOR + R_ALPHA)) {
        drawLine_color_alpha(xi, yi, dt, length, yLonger);

      } else if (m_drawFlags == R_SPATIAL) {
        drawLine_plain_spatial(xi, yi, dt, length, yLonger);

      } else if (m_drawFlags == (R_SPATIAL + R_ALPHA)) {
        drawLine_plain_alpha_spatial(xi, yi, dt, length, yLonger);

      } else if (m_drawFlags == (R_SPATIAL + R_COLOR)) {
        drawLine_color_spatial(xi, yi, dt, length, yLonger);

      } else if (m_drawFlags == (R_SPATIAL + R_COLOR + R_ALPHA)) {
        drawLine_color_alpha_spatial(xi, yi, dt, length, yLonger);
      }
    }
  }


  public boolean lineClipping() {
    // new cohen-sutherland clipping code, as old one was buggy [toxi]
    // get the "dips" for the points to clip
    int code1 = lineClipCode(x_array[0], y_array[0]);
    int code2 = lineClipCode(x_array[1], y_array[1]);
    int dip = code1 | code2;

    if ((code1 & code2)!=0) {

      return false;

    } else if (dip != 0) {

      // now calculate the clipped points
      float a0 = 0, a1 = 1, a = 0;

      for (int i = 0; i < 4; i++) {
        if (((dip>>i)%2)==1){
          a = lineSlope(x_array[0], y_array[0], x_array[1], y_array[1], i+1);
          if (((code1 >> i) % 2) == 1) {
            a0 = (a>a0)?a:a0; // max(a,a0)
          } else {
            a1 = (a<a1)?a:a1; // min(a,a1)
          }
        }
      }

      if (a0 > a1) {
        return false;
      } else {
        float xt =  x_array[0];
        float yt =  y_array[0];

        x_array[0] = xt + a0 * (x_array[1] - xt);
        y_array[0] = yt + a0 * (y_array[1] - yt);
        x_array[1] = xt + a1 * (x_array[1] - xt);
        y_array[1] = yt + a1 * (y_array[1] - yt);

        // interpolate remaining parameters
        if (INTERPOLATE_RGB) {
          float t = r_array[0];
          r_array[0] = t + a0 * (r_array[1] - t);
          r_array[1] = t + a1 * (r_array[1] - t);
          t = g_array[0];
          g_array[0] = t + a0 * (g_array[1] - t);
          g_array[1] = t + a1 * (g_array[1] - t);
          t = b_array[0];
          b_array[0] = t + a0 * (b_array[1] - t);
          b_array[1] = t + a1 * (b_array[1] - t);
        }

        if (INTERPOLATE_ALPHA) {
          float t = a_array[0];
          a_array[0] = t + a0 * (a_array[1] - t);
          a_array[1] = t + a1 * (a_array[1] - t);
        }
      }
    }
    return true;
  }


  private int lineClipCode(float xi, float yi) {
    int xmin = 0;
    int ymin = 0;
    int xmax = SCREEN_WIDTH1;
    int ymax = SCREEN_HEIGHT1;

    //return ((yi < ymin ? 8 : 0) | (yi > ymax ? 4 : 0) |
    //        (xi < xmin ? 2 : 0) | (xi > xmax ? 1 : 0));
    //(int) added by ewjordan 6/13/07 because otherwise we sometimes clip last pixel when it should actually be displayed.
        //Currently the min values are okay because values less than 0 should not be rendered; however, bear in mind that
        //(int) casts towards zero, so without this clipping, values between -1+eps and +1-eps would all be rendered as 0.
    return ((yi < ymin ? 8 : 0) | ((int)yi > ymax ? 4 : 0) |
            (xi < xmin ? 2 : 0) | ((int)xi > xmax ? 1 : 0));
  }


  private float lineSlope(float x1, float y1, float x2, float y2, int border) {
    int xmin = 0;
    int ymin = 0;
    int xmax = SCREEN_WIDTH1;
    int ymax = SCREEN_HEIGHT1;

    switch (border) {
    case 4: return (ymin-y1)/(y2-y1);
    case 3: return (ymax-y1)/(y2-y1);
    case 2: return (xmin-x1)/(x2-x1);
    case 1: return (xmax-x1)/(x2-x1);
    }
    return -1f;
  }


  private void drawPoint(int x0, int y0) {
    float iz = m_z0;
    int offset = y0 * SCREEN_WIDTH + x0;

    if (m_zbuffer == null) {
      m_pixels[offset] = m_stroke;
      
    } else {
      if (iz <= m_zbuffer[offset]) {
        m_pixels[offset] = m_stroke;
        m_zbuffer[offset] = iz;
      }
    }
  }


  private void drawPoint_alpha(int x0, int y0) {
    int ia = (int) a_array[0];
    int pr = m_stroke & 0xFF0000;
    int pg = m_stroke & 0xFF00;
    int pb = m_stroke & 0xFF;
    float iz = m_z0;
    int offset = y0 * SCREEN_WIDTH + x0;

    if ((m_zbuffer == null) || iz <= m_zbuffer[offset]) {
      int alpha = ia >> 16;
      int r0 = m_pixels[offset];
      int g0 = r0 & 0xFF00;
      int b0 = r0 & 0xFF;
      r0 &= 0xFF0000;

      r0 = r0 + (((pr - r0) * alpha) >> 8);
      g0 = g0 + (((pg - g0) * alpha) >> 8);
      b0 = b0 + (((pb - b0) * alpha) >> 8);

      m_pixels[offset] = 0xFF000000 |
        (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
      if (m_zbuffer != null) m_zbuffer[offset] = iz;
    }
  }


  private void drawLine_plain(int x0, int y0, int dt,
                              int length, boolean vertical) {
    // new "extremely fast" line code
    // adapted from http://www.edepot.com/linee.html
    // first version modified by [toxi]
    // simplified by [rocha]
    // length must be >= 0

    //assert length>=0:length;

    int offset = 0;

    if (vertical) {
      // vertical
      length += y0;
      for (int j = 0x8000 + (x0<<16); y0 <= length; ++y0) {
        offset = y0 * SCREEN_WIDTH + (j>>16);
        m_pixels[offset] = m_stroke;
        if (m_zbuffer != null) m_zbuffer[offset] = m_z0;
        j+=dt;
      }

    } else {
      // horizontal
      length += x0;
      for (int j = 0x8000 + (y0<<16); x0 <= length; ++x0) {
        offset = (j>>16) * SCREEN_WIDTH + x0;
        m_pixels[offset] = m_stroke;
        if (m_zbuffer != null) m_zbuffer[offset] = m_z0;
        j+=dt;
      }
    }
  }


  private void drawLine_plain_alpha(int x0, int y0, int dt,
                                    int length, boolean vertical)  {
    int offset = 0;

    int pr = m_stroke & 0xFF0000;
    int pg = m_stroke & 0xFF00;
    int pb = m_stroke & 0xFF;

    int ia = (int) (m_a0);

    if (vertical) {
      length += y0;
      for (int j = 0x8000 + (x0<<16); y0 <= length; ++y0) {
        offset = y0 * SCREEN_WIDTH + (j>>16);

        int alpha = ia >> 16;
        int r0 = m_pixels[offset];
        int g0 = r0 & 0xFF00;
        int b0 = r0 & 0xFF;
        r0 &= 0xFF0000;
        r0 = r0 + (((pr - r0) * alpha) >> 8);
        g0 = g0 + (((pg - g0) * alpha) >> 8);
        b0 = b0 + (((pb - b0) * alpha) >> 8);

        m_pixels[offset] = 0xFF000000 |
          (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
        //m_zbuffer[offset] = m_z0;  // don't set zbuffer w/ alpha lines

        ia += da;
        j += dt;
      }

    } else {  // horizontal
      length += x0;
      for (int j = 0x8000 + (y0<<16); x0 <= length; ++x0) {
        offset = (j>>16) * SCREEN_WIDTH + x0;

        int alpha = ia >> 16;
        int r0 = m_pixels[offset];
        int g0 = r0 & 0xFF00;
        int b0 = r0 & 0xFF;
        r0&=0xFF0000;
        r0 = r0 + (((pr - r0) * alpha) >> 8);
        g0 = g0 + (((pg - g0) * alpha) >> 8);
        b0 = b0 + (((pb - b0) * alpha) >> 8);

        m_pixels[offset] = 0xFF000000 |
          (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
        //m_zbuffer[offset] = m_z0;  // no zbuffer w/ alpha lines

        ia += da;
        j += dt;
      }
    }
  }


  private void drawLine_color(int x0, int y0, int dt,
                              int length, boolean vertical)  {
    int offset = 0;

    int ir = (int) m_r0;
    int ig = (int) m_g0;
    int ib = (int) m_b0;

    if (vertical) {
      length += y0;
      for (int j = 0x8000 + (x0<<16); y0 <= length; ++y0) {
        offset = y0 * SCREEN_WIDTH + (j>>16);
        m_pixels[offset] = 0xFF000000 |
          ((ir & 0xFF0000) | ((ig >> 8) & 0xFF00) | (ib >> 16));
        if (m_zbuffer != null) m_zbuffer[offset] = m_z0;
        ir += dr;
        ig += dg;
        ib += db;
        j +=dt;
      }

    } else {  // horizontal
      length += x0;
      for (int j = 0x8000 + (y0<<16); x0 <= length; ++x0) {
        offset = (j>>16) * SCREEN_WIDTH + x0;
        m_pixels[offset] = 0xFF000000 |
          ((ir & 0xFF0000) | ((ig >> 8) & 0xFF00) | (ib >> 16));
        if (m_zbuffer != null) m_zbuffer[offset] = m_z0;
        ir += dr;
        ig += dg;
        ib += db;
        j += dt;
      }
    }
  }


  private void drawLine_color_alpha(int x0, int y0, int dt,
                                    int length, boolean vertical)  {
    int offset = 0;

    int ir = (int) m_r0;
    int ig = (int) m_g0;
    int ib = (int) m_b0;
    int ia = (int) m_a0;

    if (vertical) {
      length += y0;
      for (int j = 0x8000 + (x0<<16); y0 <= length; ++y0) {
        offset = y0 * SCREEN_WIDTH + (j>>16);

        int pr = ir & 0xFF0000;
        int pg = (ig >> 8) & 0xFF00;
        int pb = (ib >> 16);

        int r0 = m_pixels[offset];
        int g0 = r0 & 0xFF00;
        int b0 = r0 & 0xFF;
        r0&=0xFF0000;

        int alpha = ia >> 16;

        r0 = r0 + (((pr - r0) * alpha) >> 8);
        g0 = g0 + (((pg - g0) * alpha) >> 8);
        b0 = b0 + (((pb - b0) * alpha) >> 8);

        m_pixels[offset] = 0xFF000000 |
          (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
        if (m_zbuffer != null) m_zbuffer[offset] = m_z0;

        ir+= dr;
        ig+= dg;
        ib+= db;
        ia+= da;
        j+=dt;
      }

    } else {  // horizontal
      length += x0;
      for (int j = 0x8000 + (y0<<16); x0 <= length; ++x0) {
        offset = (j>>16) * SCREEN_WIDTH + x0;

        int pr = ir & 0xFF0000;
        int pg = (ig >> 8) & 0xFF00;
        int pb = (ib >> 16);

        int r0 = m_pixels[offset];
        int g0 = r0 & 0xFF00;
        int b0 = r0 & 0xFF;
        r0&=0xFF0000;

        int alpha = ia >> 16;

        r0 = r0 + (((pr - r0) * alpha) >> 8);
        g0 = g0 + (((pg - g0) * alpha) >> 8);
        b0 = b0 + (((pb - b0) * alpha) >> 8);

        m_pixels[offset] = 0xFF000000 |
          (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
        if (m_zbuffer != null) m_zbuffer[offset] = m_z0;

        ir+= dr;
        ig+= dg;
        ib+= db;
        ia+= da;
        j+=dt;
      }
    }
  }


  private void drawLine_plain_spatial(int x0, int y0, int dt,
                                      int length, boolean vertical)  {
    int offset = 0;
    float iz = m_z0;

    if (vertical) {
      length += y0;
      for (int j = 0x8000 + (x0<<16); y0 <= length; ++y0) {
        offset = y0 * SCREEN_WIDTH + (j>>16);
        if (offset < m_pixels.length) {
          if (iz <= m_zbuffer[offset]) {
            m_pixels[offset] = m_stroke;
            m_zbuffer[offset] = iz;
          }
        }
        iz+=dz;
        j+=dt;
      }

    } else {  // horizontal
      length += x0;
      for (int j = 0x8000 + (y0<<16); x0 <= length; ++x0) {
        offset = (j>>16) * SCREEN_WIDTH + x0;
        if (offset < m_pixels.length) {
          if (iz <= m_zbuffer[offset]) {
            m_pixels[offset] = m_stroke;
            m_zbuffer[offset] = iz;
          }
        }
        iz+=dz;
        j+=dt;
      }
    }
  }


  private void drawLine_plain_alpha_spatial(int x0, int y0, int dt,
                                            int length, boolean vertical) {
    int offset = 0;
    float iz = m_z0;

    int pr = m_stroke & 0xFF0000;
    int pg = m_stroke & 0xFF00;
    int pb = m_stroke & 0xFF;

    int ia = (int) m_a0;

    if (vertical) {
      length += y0;
      for (int j = 0x8000 + (x0<<16); y0 <= length; ++y0) {
        offset = y0 * SCREEN_WIDTH + (j>>16);
        if (offset < m_pixels.length) {
          if (iz <= m_zbuffer[offset]) {
            int alpha = ia >> 16;
            int r0 = m_pixels[offset];
            int g0 = r0 & 0xFF00;
            int b0 = r0 & 0xFF;
            r0 &= 0xFF0000;
            r0 = r0 + (((pr - r0) * alpha) >> 8);
            g0 = g0 + (((pg - g0) * alpha) >> 8);
            b0 = b0 + (((pb - b0) * alpha) >> 8);

            m_pixels[offset] = 0xFF000000 |
              (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
            m_zbuffer[offset] = iz;
          }
        }
        iz +=dz;
        ia += da;
        j += dt;
      }

    } else {  // horizontal
      length += x0;
      for (int j = 0x8000 + (y0<<16); x0 <= length; ++x0) {
        offset = (j>>16) * SCREEN_WIDTH + x0;

        if (offset < m_pixels.length) {
          if (iz <= m_zbuffer[offset]) {
            int alpha = ia >> 16;
            int r0 = m_pixels[offset];
            int g0 = r0 & 0xFF00;
            int b0 = r0 & 0xFF;
            r0&=0xFF0000;
            r0 = r0 + (((pr - r0) * alpha) >> 8);
            g0 = g0 + (((pg - g0) * alpha) >> 8);
            b0 = b0 + (((pb - b0) * alpha) >> 8);

            m_pixels[offset] = 0xFF000000 |
              (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
            m_zbuffer[offset] = iz;
          }
        }
        iz += dz;
        ia += da;
        j += dt;
      }
    }
  }


  private void drawLine_color_spatial(int x0, int y0, int dt,
                                      int length, boolean vertical)  {
    int offset = 0;
    float iz = m_z0;

    int ir = (int) m_r0;
    int ig = (int) m_g0;
    int ib = (int) m_b0;

    if (vertical) {
      length += y0;
      for (int j = 0x8000 + (x0<<16); y0 <= length; ++y0) {
        offset = y0 * SCREEN_WIDTH + (j>>16);

        if (iz <= m_zbuffer[offset]) {
          m_pixels[offset] = 0xFF000000 |
            ((ir & 0xFF0000) | ((ig >> 8) & 0xFF00) | (ib >> 16));
          m_zbuffer[offset] = iz;
        }
        iz +=dz;
        ir += dr;
        ig += dg;
        ib += db;
        j += dt;
      }
    } else {  // horizontal
      length += x0;
      for (int j = 0x8000 + (y0<<16); x0 <= length; ++x0) {
        offset = (j>>16) * SCREEN_WIDTH + x0;
        if (iz <= m_zbuffer[offset]) {
          m_pixels[offset] = 0xFF000000 |
            ((ir & 0xFF0000) | ((ig >> 8) & 0xFF00) | (ib >> 16));
          m_zbuffer[offset] = iz;
        }
        iz += dz;
        ir += dr;
        ig += dg;
        ib += db;
        j += dt;
      }
      return;
    }
  }


  private void drawLine_color_alpha_spatial(int x0, int y0, int dt,
                                            int length, boolean vertical)  {
    int offset = 0;
    float iz = m_z0;

    int ir = (int) m_r0;
    int ig = (int) m_g0;
    int ib = (int) m_b0;
    int ia = (int) m_a0;

    if (vertical) {
      length += y0;
      for (int j = 0x8000 + (x0<<16); y0 <= length; ++y0) {
        offset = y0 * SCREEN_WIDTH + (j>>16);

        if (iz <= m_zbuffer[offset]) {
          int pr = ir & 0xFF0000;
          int pg = (ig >> 8) & 0xFF00;
          int pb = (ib >> 16);

          int r0 = m_pixels[offset];
          int g0 = r0 & 0xFF00;
          int b0 = r0 & 0xFF;
          r0&=0xFF0000;

          int alpha = ia >> 16;

          r0 = r0 + (((pr - r0) * alpha) >> 8);
          g0 = g0 + (((pg - g0) * alpha) >> 8);
          b0 = b0 + (((pb - b0) * alpha) >> 8);

          m_pixels[offset] = 0xFF000000 |
            (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
          m_zbuffer[offset] = iz;
        }
        iz+=dz;
        ir+= dr;
        ig+= dg;
        ib+= db;
        ia+= da;
        j+=dt;
      }

    } else {  // horizontal
      length += x0;
      for (int j = 0x8000 + (y0<<16); x0 <= length; ++x0) {
        offset = (j>>16) * SCREEN_WIDTH + x0;

        if (iz <= m_zbuffer[offset]) {
          int pr = ir & 0xFF0000;
          int pg = (ig >> 8) & 0xFF00;
          int pb = (ib >> 16);

          int r0 = m_pixels[offset];
          int g0 = r0 & 0xFF00;
          int b0 = r0 & 0xFF;
          r0 &= 0xFF0000;

          int alpha = ia >> 16;

          r0 = r0 + (((pr - r0) * alpha) >> 8);
          g0 = g0 + (((pg - g0) * alpha) >> 8);
          b0 = b0 + (((pb - b0) * alpha) >> 8);

          m_pixels[offset] = 0xFF000000 |
            (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
          m_zbuffer[offset] = iz;
        }
        iz += dz;
        ir += dr;
        ig += dg;
        ib += db;
        ia += da;
        j += dt;
      }
    }
  }


  private void drawLine_smooth(int x0, int y0, int dt,
                               int length, boolean vertical) {
    int xi, yi; // these must be >=32 bits
    int offset = 0;
    int temp;
    int end;

    float iz = m_z0;

    int ir = (int) m_r0;
    int ig = (int) m_g0;
    int ib = (int) m_b0;
    int ia = (int) m_a0;

    if (vertical) {
      xi = x0 << 16;
      yi = y0 << 16;

      end = length + y0;

      while ((yi >> 16) < end) {

        offset = (yi>>16) * SCREEN_WIDTH + (xi>>16);

        int pr = ir & 0xFF0000;
        int pg = (ig >> 8) & 0xFF00;
        int pb = (ib >> 16);

        if ((m_zbuffer == null) || (iz <= m_zbuffer[offset])) {
          int alpha = (((~xi >> 8) & 0xFF) * (ia >> 16)) >> 8;

          int r0 = m_pixels[offset];
          int g0 = r0 & 0xFF00;
          int b0 = r0 & 0xFF;
          r0&=0xFF0000;

          r0 = r0 + (((pr - r0) * alpha) >> 8);
          g0 = g0 + (((pg - g0) * alpha) >> 8);
          b0 = b0 + (((pb - b0) * alpha) >> 8);

          m_pixels[offset] = 0xFF000000 |
            (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
          if (m_zbuffer != null) m_zbuffer[offset] = iz;
        }

        // this if() makes things slow. there should be a better way to check 
        // if the second pixel is within the image array [rocha]
        temp = ((xi>>16)+1);
        if (temp >= SCREEN_WIDTH) {
          xi += dt;
          yi += (1 << 16);
          continue;
        }

        offset = (yi>>16) * SCREEN_WIDTH + temp;

        if ((m_zbuffer == null) || (iz <= m_zbuffer[offset])) {
          int alpha = (((xi >> 8) & 0xFF) * (ia >> 16)) >> 8;

          int r0 = m_pixels[offset];
          int g0 = r0 & 0xFF00;
          int b0 = r0 & 0xFF;
          r0 &= 0xFF0000;

          r0 = r0 + (((pr - r0) * alpha) >> 8);
          g0 = g0 + (((pg - g0) * alpha) >> 8);
          b0 = b0 + (((pb - b0) * alpha) >> 8);

          m_pixels[offset] = 0xFF000000 |
            (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
          if (m_zbuffer != null) m_zbuffer[offset] = iz;
        }

        xi += dt;
        yi += (1 << 16);

        iz+=dz;
        ir+= dr;
        ig+= dg;
        ib+= db;
        ia+= da;
      }

    } else {  // horizontal
      xi = x0 << 16;
      yi = y0 << 16;
      end = length + x0;

      while ((xi >> 16) < end) {
        offset = (yi>>16) * SCREEN_WIDTH + (xi>>16);

        int pr = ir & 0xFF0000;
        int pg = (ig >> 8) & 0xFF00;
        int pb = (ib >> 16);

        if ((m_zbuffer == null) || (iz <= m_zbuffer[offset])) {
          int alpha = (((~yi >> 8) & 0xFF) * (ia >> 16)) >> 8;

          int r0 = m_pixels[offset];
          int g0 = r0 & 0xFF00;
          int b0 = r0 & 0xFF;
          r0 &= 0xFF0000;

          r0 = r0 + (((pr - r0) * alpha) >> 8);
          g0 = g0 + (((pg - g0) * alpha) >> 8);
          b0 = b0 + (((pb - b0) * alpha) >> 8);

          m_pixels[offset] = 0xFF000000 |
            (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
          if (m_zbuffer != null) m_zbuffer[offset] = iz;
        }

        // see above [rocha]
        temp = ((yi>>16)+1);
        if (temp >= SCREEN_HEIGHT) {
          xi += (1 << 16);
          yi += dt;
          continue;
        }

        offset = temp * SCREEN_WIDTH + (xi>>16);

        if ((m_zbuffer == null) || (iz <= m_zbuffer[offset])) {
          int alpha = (((yi >> 8) & 0xFF) * (ia >> 16)) >> 8;

          int r0 = m_pixels[offset];
          int g0 = r0 & 0xFF00;
          int b0 = r0 & 0xFF;
          r0&=0xFF0000;

          r0 = r0 + (((pr - r0) * alpha) >> 8);
          g0 = g0 + (((pg - g0) * alpha) >> 8);
          b0 = b0 + (((pb - b0) * alpha) >> 8);

          m_pixels[offset] = 0xFF000000 |
            (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);
          if (m_zbuffer != null) m_zbuffer[offset] = iz;
        }

        xi += (1 << 16);
        yi += dt;

        iz += dz;
        ir += dr;
        ig += dg;
        ib += db;
        ia += da;
      }
    }
  }

  
  /*
  void drawLine_smooth(int x0, int y0, int dt,
                       int length, boolean vertical) {
    int xi, yi; // these must be >=32 bits
    int offset = 0;
    int temp;
    int end;

    int ir = (int) m_r0;
    int ig = (int) m_g0;
    int ib = (int) m_b0;
    int ia = (int) m_a0;

    if (vertical) {
      xi = x0 << 16;
      yi = y0 << 16;

      end = length + y0;

      while ((yi >> 16) < end) {
        offset = (yi>>16) * SCREEN_WIDTH + (xi>>16);

        int pr = ir & 0xFF0000;
        int pg = (ig >> 8) & 0xFF00;
        int pb = (ib >> 16);

        int alpha = (((~xi >> 8) & 0xFF) * (ia >> 16)) >> 8;

        int r0 = m_pixels[offset];
        int g0 = r0 & 0xFF00;
        int b0 = r0 & 0xFF;
        r0 &= 0xFF0000;

        r0 = r0 + (((pr - r0) * alpha) >> 8);
        g0 = g0 + (((pg - g0) * alpha) >> 8);
        b0 = b0 + (((pb - b0) * alpha) >> 8);

        m_pixels[offset] = 0xFF000000 |
          (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);

        // this if() makes things slow. there should be a better way to check 
        // if the second pixel is within the image array [rocha]
        temp = ((xi>>16)+1);
        if (temp >= SCREEN_WIDTH) {
          xi += dt;
          yi += (1 << 16);
          continue;
        }

        offset = (yi>>16) * SCREEN_WIDTH + temp;

        alpha = (((xi >> 8) & 0xFF) * (ia >> 16)) >> 8;

        r0 = m_pixels[offset];
        g0 = r0 & 0xFF00;
        b0 = r0 & 0xFF;
        r0 &= 0xFF0000;

        r0 = r0 + (((pr - r0) * alpha) >> 8);
        g0 = g0 + (((pg - g0) * alpha) >> 8);
        b0 = b0 + (((pb - b0) * alpha) >> 8);

        m_pixels[offset] = 0xFF000000 |
          (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);

        xi += dt;
        yi += (1 << 16);

        ir += dr;
        ig += dg;
        ib += db;
        ia += da;
      }

    } else {  // horizontal
      xi = x0 << 16;
      yi = y0 << 16;
      end = length + x0;

      while ((xi >> 16) < end) {
        offset = (yi>>16) * SCREEN_WIDTH + (xi>>16);

        int pr = ir & 0xFF0000;
        int pg = (ig >> 8) & 0xFF00;
        int pb = (ib >> 16);

        int alpha = (((~yi >> 8) & 0xFF) * (ia >> 16)) >> 8;

        int r0 = m_pixels[offset];
        int g0 = r0 & 0xFF00;
        int b0 = r0 & 0xFF;
        r0 &= 0xFF0000;

        r0 = r0 + (((pr - r0) * alpha) >> 8);
        g0 = g0 + (((pg - g0) * alpha) >> 8);
        b0 = b0 + (((pb - b0) * alpha) >> 8);

        m_pixels[offset] = 0xFF000000 |
          (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);

        // see above [rocha]
        temp = ((yi>>16)+1);
        if (temp >= SCREEN_HEIGHT) {
          xi += (1 << 16);
          yi += dt;
          continue;
        }

        offset = temp * SCREEN_WIDTH + (xi>>16);

        alpha = (((yi >> 8) & 0xFF) * (ia >> 16)) >> 8;

        r0 = m_pixels[offset];
        g0 = r0 & 0xFF00;
        b0 = r0 & 0xFF;
        r0 &= 0xFF0000;

        r0 = r0 + (((pr - r0) * alpha) >> 8);
        g0 = g0 + (((pg - g0) * alpha) >> 8);
        b0 = b0 + (((pb - b0) * alpha) >> 8);

        m_pixels[offset] = 0xFF000000 |
          (r0 & 0xFF0000) | (g0 & 0xFF00) | (b0 & 0xFF);

        xi += (1 << 16);
        yi += dt;

        ir+= dr;
        ig+= dg;
        ib+= db;
        ia+= da;
      }
    }
  }
  */
}

Show details Hide details

Change log

r5182 by fry on Nov 20, 2008 Diff

trying to track down additional accuracy
issues

Go to:

Older revisions

r5167 by fry on Nov 19, 2008 Diff

more zbuffer trouble in PLine (bug
#1023)

r5141 by fry on Nov 18, 2008 Diff

major work to bring back P2D... so far
rect() set up properly, now dealing
with begin/endShape issues

r4937 by fry on Oct 17, 2008 Diff

tweaks and finishing up release 0151

All revisions of this file

File info

Size: 33086 bytes, 1278 lines

View raw file