{

static final float PIXEL_CENTER = 0.5f; // for polygon aa

static final int R_GOURAUD = 0x1;

static final int R_TEXTURE8 = 0x2;

static final int R_TEXTURE24 = 0x4;

static final int R_TEXTURE32 = 0x8;

static final int R_ALPHA = 0x10;

private int[] m_pixels;

private int[] m_texture;

//private int[] m_stencil;

private float[] m_zbuffer;

private int SCREEN_WIDTH;

private int SCREEN_HEIGHT;

//private int SCREEN_WIDTH1;

//private int SCREEN_HEIGHT1;

private int TEX_WIDTH;

private int TEX_HEIGHT;

private float F_TEX_WIDTH;

private float F_TEX_HEIGHT;

public boolean INTERPOLATE_UV;

public boolean INTERPOLATE_RGB;

public boolean INTERPOLATE_ALPHA;

// the power of 2 that tells how many pixels to interpolate

// for between exactly computed texture coordinates

private static final int DEFAULT_INTERP_POWER = 3;

private static int TEX_INTERP_POWER = DEFAULT_INTERP_POWER;

// Vertex coordinates

private float[] x_array;

private float[] y_array;

private float[] z_array;

private float[] camX;

private float[] camY;

private float[] camZ;

// U,V coordinates

private float[] u_array;

private float[] v_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;

private int o2;

/* rgb & a */

private float r0;

private float r1;

private float r2;

private float g0;

private float g1;

private float g2;

private float b0;

private float b1;

private float b2;

private float a0;

private float a1;

private float a2;

/* accurate texture uv coordinates */

private float u0;

private float u1;

private float u2;

private float v0;

private float v1;

private float v2;

/* deltas */

//private float dx0;

//private float dx1;

private float dx2;

private float dy0;

private float dy1;

private float dy2;

private float dz0;

//private float dz1;

private float dz2;

/* texture deltas */

private float du0;

//private float du1;

private float du2;

private float dv0;

//private float dv1;

private float dv2;

/* rgba deltas */

private float dr0;

//private float dr1;

private float dr2;

private float dg0;

//private float dg1;

private float dg2;

private float db0;

//private float db1;

private float db2;

private float da0;

//private float da1;

private float da2;

/* */

private float uleft;

private float vleft;

private float uleftadd;

private float vleftadd;

/* polyedge positions & adds */

private float xleft;

private float xrght;

private float xadd1;

private float xadd2;

private float zleft;

private float zleftadd;

/* rgba positions & adds */

private float rleft;

private float gleft;

private float bleft;

private float aleft;

private float rleftadd;

private float gleftadd;

private float bleftadd;

private float aleftadd;

/* other somewhat useful variables :) */

private float dta;

//private float dta2;

private float temp;

private float width;

/* integer poly UV adds */

private int iuadd;

private int ivadd;

private int iradd;

private int igadd;

private int ibadd;

private int iaadd;

private float izadd;

/* fill color */

private int m_fill;

/* draw flags */

public int m_drawFlags;

/* current poly number */

/** */

private PGraphics3D parent;

private boolean noDepthTest;

//private boolean argbSurface;

/** */

private boolean m_culling;

/** */

private boolean m_singleRight;

/**

private boolean m_bilinear = true; // always set to true

// Vectors needed in accurate texture code

// We store them as class members to avoid too much code duplication

private float ax,ay,az;

private float bx,by,bz;

private float cx,cy,cz;

private float nearPlaneWidth;

private float nearPlaneHeight;

private float nearPlaneDepth;

private float xmult;

private float ymult;

// optimization vars...not pretty, but save a couple mults per pixel

private float newax,newbx,newcx;

// are we currently drawing the first piece of the triangle,

// or have we already done so?

private boolean firstSegment;

public PTriangle(PGraphics3D g) {

x_array = new float[3];

y_array = new float[3];

z_array = new float[3];

u_array = new float[3];

v_array = new float[3];

r_array = new float[3];

g_array = new float[3];

b_array = new float[3];

a_array = new float[3];

camX = new float[3];

camY = new float[3];

camZ = new float[3];

this.parent = g;

reset();

}

/**

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_zbuffer = parent.zbuffer;

noDepthTest = parent.hints[DISABLE_DEPTH_TEST];

//argbSurface = parent.format == PConstants.ARGB;

// other things to reset

INTERPOLATE_UV = false;

INTERPOLATE_RGB = false;

INTERPOLATE_ALPHA = false;

//m_tImage = null;

m_texture = null;

m_drawFlags = 0;

}

/**

public void setCulling(boolean tf) {

m_culling = tf;

}

/**

public void setVertices(float x0, float y0, float z0,

float x1, float y1, float z1,

float x2, float y2, float z2) {

x_array[0] = x0;

x_array[1] = x1;

x_array[2] = x2;

y_array[0] = y0;

y_array[1] = y1;

y_array[2] = y2;

z_array[0] = z0;

z_array[1] = z1;

z_array[2] = z2;

}

/**

public void setCamVertices(float x0, float y0, float z0,

float x1, float y1, float z1,

float x2, float y2, float z2) {

camX[0] = x0;

camX[1] = x1;

camX[2] = x2;

camY[0] = y0;

camY[1] = y1;

camY[2] = y2;

camZ[0] = z0;

camZ[1] = z1;

camZ[2] = z2;

}

/**

public void setUV(float u0, float v0,

float u1, float v1,

float u2, float v2) {

// sets & scales uv texture coordinates to center of the pixel

u_array[0] = (u0 * F_TEX_WIDTH + 0.5f) * 65536f;

u_array[1] = (u1 * F_TEX_WIDTH + 0.5f) * 65536f;

u_array[2] = (u2 * F_TEX_WIDTH + 0.5f) * 65536f;

v_array[0] = (v0 * F_TEX_HEIGHT + 0.5f) * 65536f;

v_array[1] = (v1 * F_TEX_HEIGHT + 0.5f) * 65536f;

v_array[2] = (v2 * F_TEX_HEIGHT + 0.5f) * 65536f;

}

/**

public void setIntensities(float r0, float g0, float b0, float a0,

float r1, float g1, float b1, float a1,

float r2, float g2, float b2, float a2) {

// Check if we need alpha or not?

if ((a0 != 1.0f) || (a1 != 1.0f) || (a2 != 1.0f)) {

INTERPOLATE_ALPHA = true;

a_array[0] = (a0 * 253f + 1.0f) * 65536f;

a_array[1] = (a1 * 253f + 1.0f) * 65536f;

a_array[2] = (a2 * 253f + 1.0f) * 65536f;

m_drawFlags|=R_ALPHA;

} else {

INTERPOLATE_ALPHA = false;

m_drawFlags&=~R_ALPHA;

}

// Check if we need to interpolate the intensity values

if ((r0 != r1) || (r1 != r2)) {

INTERPOLATE_RGB = true;

m_drawFlags |= R_GOURAUD;

} else if ((g0 != g1) || (g1 != g2)) {

INTERPOLATE_RGB = true;

m_drawFlags |= R_GOURAUD;

} else if ((b0 != b1) || (b1 != b2)) {

INTERPOLATE_RGB = true;

m_drawFlags |= R_GOURAUD;

} else {

//m_fill = parent.filli;

m_drawFlags &=~ R_GOURAUD;

}

// push values to arrays.. some extra scaling is added

// to prevent possible color "overflood" due to rounding errors

r_array[0] = (r0 * 253f + 1.0f) * 65536f;

r_array[1] = (r1 * 253f + 1.0f) * 65536f;

r_array[2] = (r2 * 253f + 1.0f) * 65536f;

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

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

g_array[2] = (g2 * 253f + 1.0f) * 65536f;

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

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

b_array[2] = (b2 * 253f + 1.0f) * 65536f;

// for plain triangles

m_fill = 0xFF000000 |

((int)(255*r0) << 16) | ((int)(255*g0) << 8) | (int)(255*b0);

}

/**

public void setTexture(PImage image) {

//m_tImage = image;

m_texture = image.pixels;

TEX_WIDTH = image.width;

TEX_HEIGHT = image.height;

F_TEX_WIDTH = TEX_WIDTH-1;

F_TEX_HEIGHT = TEX_HEIGHT-1;

INTERPOLATE_UV = true;

if (image.format == ARGB) {

m_drawFlags |= R_TEXTURE32;

} else if (image.format == RGB) {

m_drawFlags |= R_TEXTURE24;

} else if (image.format == ALPHA) {

m_drawFlags |= R_TEXTURE8;

}

}

/**

public void setUV(float[] u, float[] v) {

if (m_bilinear) {

// sets & scales uv texture coordinates to edges of pixels

u_array[0] = (u[0] * F_TEX_WIDTH) * 65500f;

u_array[1] = (u[1] * F_TEX_WIDTH) * 65500f;

u_array[2] = (u[2] * F_TEX_WIDTH) * 65500f;

v_array[0] = (v[0] * F_TEX_HEIGHT) * 65500f;

v_array[1] = (v[1] * F_TEX_HEIGHT) * 65500f;

v_array[2] = (v[2] * F_TEX_HEIGHT) * 65500f;

} else {

// sets & scales uv texture coordinates to center of the pixel

u_array[0] = (u[0] * TEX_WIDTH) * 65500f;

u_array[1] = (u[1] * TEX_WIDTH) * 65500f;

u_array[2] = (u[2] * TEX_WIDTH) * 65500f;

v_array[0] = (v[0] * TEX_HEIGHT) * 65500f;

v_array[1] = (v[1] * TEX_HEIGHT) * 65500f;

v_array[2] = (v[2] * TEX_HEIGHT) * 65500f;

}

}

/**

public void render() {

float x0, x1, x2;

float z0, z1, z2;

float y0 = y_array[0];

float y1 = y_array[1];

float y2 = y_array[2];

//System.out.println(PApplet.hex(m_drawFlags));

// For accurate texture interpolation, need to mark whether

// we've already pre-calculated for the triangle

firstSegment = true;

// do backface culling?

if (m_culling) {

x0 = x_array[0];

if ((x_array[2]-x0)*(y1-y0) < (x_array[1]-x0)*(y2-y0))

return;

}

/* get vertex order from top -> down */

if (y0 < y1) {

if (y2 < y1) {

if (y2 < y0) { // 2,0,1

o0 = 2;

o1 = 0;

o2 = 1;

} else { // 0,2,1

o0 = 0;

o1 = 2;

o2 = 1;

}

} else { // 0,1,2

o0 = 0;

o1 = 1;

o2 = 2;

}

} else {

if (y2 > y1) {

if (y2 < y0) { // 1,2,0

o0 = 1;

o1 = 2;

o2 = 0;

} else { // 1,0,2

o0 = 1;

o1 = 0;

o2 = 2;

}

} else { // 2,1,0

o0 = 2;

o1 = 1;

o2 = 0;

}

}

/**

y0 = y_array[o0];

int yi0 = (int) (y0 + PIXEL_CENTER);

if (yi0 > SCREEN_HEIGHT) {

return;

} else if (yi0 < 0) {

yi0 = 0;

}

y2 = y_array[o2];

int yi2 = (int) (y2 + PIXEL_CENTER);

if (yi2 < 0) {

return;

} else if (yi2 > SCREEN_HEIGHT) {

yi2 = SCREEN_HEIGHT;

}

// Does the poly actually cross a scanline?

if (yi2 > yi0) {

x0 = x_array[o0];

x1 = x_array[o1];

x2 = x_array[o2];

// get mid Y and clip it

y1 = y_array[o1];

int yi1 = (int) (y1 + PIXEL_CENTER);

if (yi1 < 0)

yi1 = 0;

if (yi1 > SCREEN_HEIGHT)

yi1 = SCREEN_HEIGHT;

// calculate deltas etc.

dx2 = x2 - x0;

dy0 = y1 - y0;

dy2 = y2 - y0;

xadd2 = dx2 / dy2; // xadd for "single" edge

temp = dy0 / dy2;

width = temp * dx2 + x0 - x1;

// calculate alpha blend interpolation

if (INTERPOLATE_ALPHA) {

a0 = a_array[o0];

a1 = a_array[o1];

a2 = a_array[o2];

da0 = a1-a0;

da2 = a2-a0;

iaadd = (int) ((temp * da2 - da0) / width); // alpha add

}

// calculate intensity interpolation

if (INTERPOLATE_RGB) {

r0 = r_array[o0];

r1 = r_array[o1];

r2 = r_array[o2];

g0 = g_array[o0];

g1 = g_array[o1];

g2 = g_array[o2];

b0 = b_array[o0];

b1 = b_array[o1];

b2 = b_array[o2];

dr0 = r1-r0;

dg0 = g1-g0;

db0 = b1-b0;

dr2 = r2-r0;

dg2 = g2-g0;

db2 = b2-b0;

iradd = (int) ((temp * dr2 - dr0) / width); // r add

igadd = (int) ((temp * dg2 - dg0) / width); // g add

ibadd = (int) ((temp * db2 - db0) / width); // b add

}

// calculate UV interpolation

if (INTERPOLATE_UV) {

u0 = u_array[o0];

u1 = u_array[o1];

u2 = u_array[o2];

v0 = v_array[o0];

v1 = v_array[o1];

v2 = v_array[o2];

du0 = u1-u0;

dv0 = v1-v0;

du2 = u2-u0;

dv2 = v2-v0;

iuadd = (int) ((temp * du2 - du0) / width); // u add

ivadd = (int) ((temp * dv2 - dv0) / width); // v add

}

z0 = z_array[o0];

z1 = z_array[o1];

z2 = z_array[o2];

dz0 = z1-z0;

dz2 = z2-z0;

izadd = (temp * dz2 - dz0) / width;

// draw the upper poly segment if it's visible

if (yi1 > yi0) {

dta = (yi0 + PIXEL_CENTER) - y0;

xadd1 = (x1 - x0) / dy0;

// we can determine which side is "single" side

// by comparing left/right edge adds

if (xadd2 > xadd1) {

xleft = x0 + dta * xadd1;

xrght = x0 + dta * xadd2;

zleftadd = dz0 / dy0;

zleft = dta*zleftadd+z0;

if (INTERPOLATE_UV) {

uleftadd = du0 / dy0;

vleftadd = dv0 / dy0;

uleft = dta*uleftadd+u0;

vleft = dta*vleftadd+v0;

}

if (INTERPOLATE_RGB) {

rleftadd = dr0 / dy0;

gleftadd = dg0 / dy0;

bleftadd = db0 / dy0;

rleft = dta*rleftadd+r0;

gleft = dta*gleftadd+g0;

bleft = dta*bleftadd+b0;

}

if (INTERPOLATE_ALPHA) {

aleftadd = da0 / dy0;

aleft = dta*aleftadd+a0;

if (m_drawFlags == R_ALPHA) {

drawsegment_plain_alpha(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_ALPHA)) {

drawsegment_gouraud_alpha(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == (R_TEXTURE8 + R_ALPHA)) {

drawsegment_texture8_alpha(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == (R_TEXTURE24 + R_ALPHA)) {

drawsegment_texture24_alpha(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == (R_TEXTURE32 + R_ALPHA)) {

drawsegment_texture32_alpha(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE8 + R_ALPHA)) {

drawsegment_gouraud_texture8_alpha(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE24 + R_ALPHA)) {

drawsegment_gouraud_texture24_alpha(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE32 + R_ALPHA)) {

drawsegment_gouraud_texture32_alpha(xadd1,xadd2, yi0,yi1);

}

} else {

if (m_drawFlags == 0) {

drawsegment_plain(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == R_GOURAUD) {

drawsegment_gouraud(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == R_TEXTURE8) {

drawsegment_texture8(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == R_TEXTURE24) {

drawsegment_texture24(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == R_TEXTURE32) {

drawsegment_texture32(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE8)) {

drawsegment_gouraud_texture8(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE24)) {

drawsegment_gouraud_texture24(xadd1,xadd2, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE32)) {

drawsegment_gouraud_texture32(xadd1,xadd2, yi0,yi1);

}

}

m_singleRight = true;

} else {

xleft = x0 + dta * xadd2;

xrght = x0 + dta * xadd1;

zleftadd = dz2 / dy2;

zleft = dta*zleftadd+z0;

//

if (INTERPOLATE_UV) {

uleftadd = du2 / dy2;

vleftadd = dv2 / dy2;

uleft = dta*uleftadd+u0;

vleft = dta*vleftadd+v0;

}

//

if (INTERPOLATE_RGB) {

rleftadd = dr2 / dy2;

gleftadd = dg2 / dy2;

bleftadd = db2 / dy2;

rleft = dta*rleftadd+r0;

gleft = dta*gleftadd+g0;

bleft = dta*bleftadd+b0;

}

if (INTERPOLATE_ALPHA) {

aleftadd = da2 / dy2;

aleft = dta*aleftadd+a0;

if (m_drawFlags == R_ALPHA) {

drawsegment_plain_alpha(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_ALPHA)) {

drawsegment_gouraud_alpha(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == (R_TEXTURE8 + R_ALPHA)) {

drawsegment_texture8_alpha(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == (R_TEXTURE24 + R_ALPHA)) {

drawsegment_texture24_alpha(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == (R_TEXTURE32 + R_ALPHA)) {

drawsegment_texture32_alpha(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE8 + R_ALPHA)) {

drawsegment_gouraud_texture8_alpha(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE24 + R_ALPHA)) {

drawsegment_gouraud_texture24_alpha(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE32 + R_ALPHA)) {

drawsegment_gouraud_texture32_alpha(xadd2, xadd1, yi0,yi1);

}

} else {

if (m_drawFlags == 0) {

drawsegment_plain(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == R_GOURAUD) {

drawsegment_gouraud(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == R_TEXTURE8) {

drawsegment_texture8(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == R_TEXTURE24) {

drawsegment_texture24(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == R_TEXTURE32) {

drawsegment_texture32(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE8)) {

drawsegment_gouraud_texture8(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE24)) {

drawsegment_gouraud_texture24(xadd2, xadd1, yi0,yi1);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE32)) {

drawsegment_gouraud_texture32(xadd2, xadd1, yi0,yi1);

}

}

m_singleRight = false;

}

// if bottom segment height is zero, return

if (yi2 == yi1) return;

// calculate xadd 1

dy1 = y2 - y1;

xadd1 = (x2 - x1) / dy1;

} else {

// top seg height was zero, calculate & clip single edge X

dy1 = y2 - y1;

xadd1 = (x2 - x1) / dy1;

// which edge is left?

if (xadd2 < xadd1) {

xrght = ((yi1 + PIXEL_CENTER) - y0) * xadd2 + x0;

m_singleRight = true;

} else {

dta = (yi1 + PIXEL_CENTER) - y0;

xleft = dta * xadd2 + x0;

zleftadd = dz2 / dy2;

zleft = dta * zleftadd + z0;

if (INTERPOLATE_UV) {

uleftadd = du2 / dy2;

vleftadd = dv2 / dy2;

uleft = dta * uleftadd + u0;

vleft = dta * vleftadd + v0;

}

if (INTERPOLATE_RGB) {

rleftadd = dr2 / dy2;

gleftadd = dg2 / dy2;

bleftadd = db2 / dy2;

rleft = dta * rleftadd + r0;

gleft = dta * gleftadd + g0;

bleft = dta * bleftadd + b0;

}

//

if (INTERPOLATE_ALPHA) {

aleftadd = da2 / dy2;

aleft = dta * aleftadd + a0;

}

m_singleRight = false;

}

}

// draw the lower segment

if (m_singleRight) {

dta = (yi1 + PIXEL_CENTER) - y1;

xleft = dta * xadd1 + x1;

zleftadd = (z2 - z1) / dy1;

zleft = dta * zleftadd + z1;

if (INTERPOLATE_UV) {

uleftadd = (u2 - u1) / dy1;

vleftadd = (v2 - v1) / dy1;

uleft = dta * uleftadd + u1;

vleft = dta * vleftadd + v1;

}

if (INTERPOLATE_RGB) {

rleftadd = (r2 - r1) / dy1;

gleftadd = (g2 - g1) / dy1;

bleftadd = (b2 - b1) / dy1;

rleft = dta * rleftadd + r1;

gleft = dta * gleftadd + g1;

bleft = dta * bleftadd + b1;

}

if (INTERPOLATE_ALPHA) {

aleftadd = (a2 - a1) / dy1;

aleft = dta * aleftadd + a1;

if (m_drawFlags == R_ALPHA) {

drawsegment_plain_alpha(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_ALPHA)) {

drawsegment_gouraud_alpha(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == (R_TEXTURE8 + R_ALPHA)) {

drawsegment_texture8_alpha(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == (R_TEXTURE24 + R_ALPHA)) {

drawsegment_texture24_alpha(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == (R_TEXTURE32 + R_ALPHA)) {

drawsegment_texture32_alpha(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE8 + R_ALPHA)) {

drawsegment_gouraud_texture8_alpha(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE24 + R_ALPHA)) {

drawsegment_gouraud_texture24_alpha(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE32 + R_ALPHA)) {

drawsegment_gouraud_texture32_alpha(xadd1, xadd2, yi1,yi2);

}

} else {

if (m_drawFlags == 0) {

drawsegment_plain(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == R_GOURAUD) {

drawsegment_gouraud(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == R_TEXTURE8) {

drawsegment_texture8(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == R_TEXTURE24) {

drawsegment_texture24(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == R_TEXTURE32) {

drawsegment_texture32(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE8)) {

drawsegment_gouraud_texture8(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE24)) {

drawsegment_gouraud_texture24(xadd1, xadd2, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE32)) {

drawsegment_gouraud_texture32(xadd1, xadd2, yi1,yi2);

}

}

} else {

xrght = ((yi1 + PIXEL_CENTER)- y1) * xadd1 + x1;

if (INTERPOLATE_ALPHA) {

if (m_drawFlags == R_ALPHA) {

drawsegment_plain_alpha(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_ALPHA)) {

drawsegment_gouraud_alpha(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == (R_TEXTURE8 + R_ALPHA)) {

drawsegment_texture8_alpha(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == (R_TEXTURE24 + R_ALPHA)) {

drawsegment_texture24_alpha(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == (R_TEXTURE32 + R_ALPHA)) {

drawsegment_texture32_alpha(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE8 + R_ALPHA)) {

drawsegment_gouraud_texture8_alpha(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE24 + R_ALPHA)) {

drawsegment_gouraud_texture24_alpha(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE32 + R_ALPHA)) {

drawsegment_gouraud_texture32_alpha(xadd2, xadd1, yi1,yi2);

}

} else {

if (m_drawFlags == 0) {

drawsegment_plain(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == R_GOURAUD) {

drawsegment_gouraud(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == R_TEXTURE8) {

drawsegment_texture8(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == R_TEXTURE24) {

drawsegment_texture24(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == R_TEXTURE32) {

drawsegment_texture32(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE8)) {

drawsegment_gouraud_texture8(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE24)) {

drawsegment_gouraud_texture24(xadd2, xadd1, yi1,yi2);

} else if (m_drawFlags == (R_GOURAUD + R_TEXTURE32)) {

drawsegment_gouraud_texture32(xadd2, xadd1, yi1,yi2);

}

}

}

}

}

/**

/**

private boolean precomputeAccurateTexturing() {

// rescale u/v_array values when inverting matrix and performing other calcs

float myFact = 65500.0f;

float myFact2 = 65500.0f;

//Matrix inversion to find affine transform between (u,v,(1)) -> (x,y,z)

// OPTIMIZE: There should be a way to avoid the inversion here, which is

// quite expensive (~150 mults). Also it might crap out due to loss of

// precision depending on the scaling of the u/v_arrays. Nothing clever

// currently happens if the inversion fails, since this means the

// transformation is degenerate - we just pass false back to the caller

// and let it handle the situation. [There is no good solution to this

// case from within this function, since the way the calculation proceeds

// presumes a non-degenerate transformation matrix between camera space

// and uv space]

// Obvious optimization: if the vertices are actually at the appropriate

// texture coordinates (e.g. (0,0), (TEX_WIDTH,0), and (0,TEX_HEIGHT))

// then we can immediately return the right solution without the inversion.

// This is fairly common, so could speed up many cases of drawing.

// [not implemented]

// Furthermore, we could cache the p,resultT0,result0T vectors in the

// triangle's basis, since we could then do a look-up and generate the

// resulting coordinates very simply. This would include the above

// optimization as a special case - we could pre-populate the cache with

// special cases like that and dynamically add more. The idea here is that

// most people simply paste textures onto triangles and move the triangles

// from frame to frame, so any per-triangle-per-frame code is likely

// wasted effort. [not implemented]

// Note: o0, o1, and o2 vary depending on view angle to triangle,

// but p, n, and m should not depend on ordering differences

if (firstSegment){

PMatrix3D myMatrix =