{

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 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 normal strokes

if (SMOOTH) {

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;