mirror of
https://github.com/arduino/Arduino.git
synced 2024-12-11 22:24:13 +01:00
3828 lines
119 KiB
Java
3828 lines
119 KiB
Java
|
/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
|
||
|
|
|
||
|
|
/*
|
||
|
|
Part of the Processing project - http://processing.org
|
||
|
|
|
||
|
|
Copyright (c) 2004-06 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;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Handles rendering of single (tesselated) triangles in 3D.
|
||
|
|
* <P>
|
||
|
|
* Written by sami www.sumea.com
|
||
|
|
*/
|
||
|
|
public class PTriangle implements PConstants
|
||
|
|
{
|
||
|
|
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 int m_index;
|
||
|
|
|
||
|
|
/** */
|
||
|
|
private PGraphics3D parent;
|
||
|
|
|
||
|
|
private boolean noDepthTest;
|
||
|
|
|
||
|
|
/** */
|
||
|
|
private boolean m_culling;
|
||
|
|
|
||
|
|
/** */
|
||
|
|
private boolean m_singleRight;
|
||
|
|
|
||
|
|
/** */
|
||
|
|
private boolean m_bilinear;
|
||
|
|
|
||
|
|
|
||
|
|
//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;
|
||
|
|
private float newax,newbx,newcx; //optimization vars...not pretty, but save a couple mults per pixel
|
||
|
|
private boolean firstSegment; //are we currently drawing the first piece of the triangle, or have we already done so?
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
public PTriangle(PGraphics3D g) {
|
||
|
|
//SCREEN_WIDTH = g.width;
|
||
|
|
//SCREEN_HEIGHT = g.height;
|
||
|
|
//SCREEN_WIDTH1 = SCREEN_WIDTH-1;
|
||
|
|
//SCREEN_HEIGHT1 = SCREEN_HEIGHT-1;
|
||
|
|
|
||
|
|
//m_pixels = g.pixels;
|
||
|
|
//m_stencil = g.stencil;
|
||
|
|
//m_zbuffer = g.zbuffer;
|
||
|
|
|
||
|
|
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();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Resets polygon attributes
|
||
|
|
*/
|
||
|
|
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;
|
||
|
|
m_zbuffer = parent.zbuffer;
|
||
|
|
|
||
|
|
noDepthTest = parent.hints[DISABLE_DEPTH_TEST];
|
||
|
|
|
||
|
|
// other things to reset
|
||
|
|
|
||
|
|
INTERPOLATE_UV = false;
|
||
|
|
INTERPOLATE_RGB = false;
|
||
|
|
INTERPOLATE_ALPHA = false;
|
||
|
|
//m_tImage = null;
|
||
|
|
m_texture = null;
|
||
|
|
m_drawFlags = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets backface culling on/off
|
||
|
|
*/
|
||
|
|
public void setCulling(boolean tf) {
|
||
|
|
m_culling = tf;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets vertex coordinates for the triangle
|
||
|
|
*/
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Pass camera-space coordinates for the triangle (needed to render if ENABLE_ACCURATE_TEXTURES is hinted).
|
||
|
|
*/
|
||
|
|
public void setCamVertices(float x0, float y0, float z0,
|
||
|
|
float x1, float y1, float z1,
|
||
|
|
float x2, float y2, float z2) {
|
||
|
|
//Generally this will not need to be called manually, currently called if hints[ENABLE_ACCURATE_TEXTURES]
|
||
|
|
//from PGraphics3D.render_triangles()
|
||
|
|
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets the UV coordinates of the texture
|
||
|
|
*/
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets vertex intensities in 0xRRGGBBAA format
|
||
|
|
*/
|
||
|
|
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 = ((int)(255*r0) << 16) | ((int)(255*g0) << 8) | (int)(255*b0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets texture image used for the polygon
|
||
|
|
*/
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
//if (parent.hints[SMOOTH_IMAGES]) {
|
||
|
|
/*
|
||
|
|
if (parent.smooth) {
|
||
|
|
m_bilinear = true;
|
||
|
|
} else {
|
||
|
|
m_bilinear = false;
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
m_bilinear = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
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 setIndex(int index) {
|
||
|
|
m_index = index;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Renders the polygon
|
||
|
|
*/
|
||
|
|
public void render() {
|
||
|
|
// removed. done in PGraphics [rocha]
|
||
|
|
// increase polygon offset
|
||
|
|
//m_index = (m_index + 1) & 0xFFFFFFF;
|
||
|
|
|
||
|
|
// draw the polygon
|
||
|
|
draw();
|
||
|
|
|
||
|
|
// removed. replaced by external antialiasing [rocha]
|
||
|
|
// smooth edges?
|
||
|
|
//if (parent.smooth )
|
||
|
|
//{
|
||
|
|
// drawline_blender(x_array[0], y_array[0], x_array[1], y_array[1]);
|
||
|
|
// drawline_blender(x_array[1], y_array[1], x_array[2], y_array[2]);
|
||
|
|
// drawline_blender(x_array[2], y_array[2], x_array[0], y_array[0]);
|
||
|
|
//}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void draw() {
|
||
|
|
// y-coordinates
|
||
|
|
float x0;
|
||
|
|
float x1;
|
||
|
|
float x2;
|
||
|
|
|
||
|
|
//
|
||
|
|
float z0;
|
||
|
|
float z1;
|
||
|
|
float z2;
|
||
|
|
|
||
|
|
//
|
||
|
|
float y0 = y_array[0];
|
||
|
|
float y1 = y_array[1];
|
||
|
|
float y2 = y_array[2];
|
||
|
|
|
||
|
|
// 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;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* o0 = "top" vertex offset
|
||
|
|
* o1 = "mid" vertex offset
|
||
|
|
* o2 = "bot" vertex offset
|
||
|
|
*/
|
||
|
|
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
Accurate texturing code by ewjordan@gmail.com, April 14, 2007
|
||
|
|
The getColorFromTexture() function should be inlined and optimized so that most of the heavy lifting
|
||
|
|
happens outside the per-pixel loop. The unoptimized generic algorithm looks like this (unless noted,
|
||
|
|
all of these variables are vectors, so the actual code will look messier):
|
||
|
|
|
||
|
|
p = camera space vector where u == 0, v == 0;
|
||
|
|
m = vector from p to location where u == TEX_WIDTH;
|
||
|
|
n = vector from p to location where v == TEX_HEIGHT;
|
||
|
|
|
||
|
|
A = p cross n;
|
||
|
|
B = m cross p;
|
||
|
|
C = n cross m;
|
||
|
|
A *= texture.width;
|
||
|
|
B *= texture.height;
|
||
|
|
|
||
|
|
for (scanlines in triangle){
|
||
|
|
float a = S * A;
|
||
|
|
float b = S * B;
|
||
|
|
float c = S * C;
|
||
|
|
for (pixels in scanline){
|
||
|
|
int u = a/c;
|
||
|
|
int v = b/c;
|
||
|
|
color = texture[v * texture.width + u];
|
||
|
|
a += A.x;
|
||
|
|
b += B.x;
|
||
|
|
c += C.x;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
We don't use this exact algorithm here, however, because of the extra overhead from the divides.
|
||
|
|
Instead we compute the exact u and v (labelled iu and iv in the code) at the start of each scanline
|
||
|
|
and we perform a linear interpolation for every linearInterpLength = 1 << TEX_INTERP_POWER pixels.
|
||
|
|
This means that we only perform the true calculation once in a while, and the rest of the time
|
||
|
|
the algorithm functions exactly as in the fast inaccurate case, at least in theory. In practice,
|
||
|
|
even if we set linearInterpLength very high we still incur some speed penalty due to the preprocessing
|
||
|
|
that must take place per-scanline. A similar method could be applied per scanline to avoid this, but
|
||
|
|
it would only be worthwhile in the case that we never compute more than one exact calculation per
|
||
|
|
scanline. If we want something like this, however, it would be best to create another mode of calculation
|
||
|
|
called "constant-z" interpolation, which could be used for things like floors and ceilings where the
|
||
|
|
distance from the camera plane never changes over the course of a scanline. We could also add the
|
||
|
|
vertical analogue for drawing vertical walls. In any case, these are not critical as the current
|
||
|
|
algorithm runs fairly well, perhaps ~10% slower than the default perspective-less one.
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Solve for camera space coordinates of critical texture points and set up per-triangle variables for accurate texturing
|
||
|
|
*/
|
||
|
|
private boolean precomputeAccurateTexturing(){
|
||
|
|
//Sets all class variables relevant to accurate texture computation
|
||
|
|
//Should be called once per triangle - checks firstSegment to see if we've already called
|
||
|
|
|
||
|
|
float myFact = 65500.0f; //rescale u/v_array values when inverting matrix and performing other calcs
|
||
|
|
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){
|
||
|
|
|
||
|
|
PMatrix myMatrix = new PMatrix( u_array[o0]/myFact, v_array[o0]/myFact2, 1, 0,
|
||
|
|
u_array[o1]/myFact, v_array[o1]/myFact2, 1, 0,
|
||
|
|
u_array[o2]/myFact, v_array[o2]/myFact2, 1, 0,
|
||
|
|
0, 0, 0, 1);
|
||
|
|
myMatrix = myMatrix.invert(); //A 3x3 inversion would be more efficient here, given that the fourth r/c are unity
|
||
|
|
if (myMatrix == null) {return false;} //if the matrix inversion had trouble, let the caller know
|
||
|
|
float m00, m01, m02, m10, m11, m12, m20, m21, m22;
|
||
|
|
m00 = myMatrix.m00*camX[o0]+myMatrix.m01*camX[o1]+myMatrix.m02*camX[o2];
|
||
|
|
m01 = myMatrix.m10*camX[o0]+myMatrix.m11*camX[o1]+myMatrix.m12*camX[o2];
|
||
|
|
m02 = myMatrix.m20*camX[o0]+myMatrix.m21*camX[o1]+myMatrix.m22*camX[o2];
|
||
|
|
m10 = myMatrix.m00*camY[o0]+myMatrix.m01*camY[o1]+myMatrix.m02*camY[o2];
|
||
|
|
m11 = myMatrix.m10*camY[o0]+myMatrix.m11*camY[o1]+myMatrix.m12*camY[o2];
|
||
|
|
m12 = myMatrix.m20*camY[o0]+myMatrix.m21*camY[o1]+myMatrix.m22*camY[o2];
|
||
|
|
m20 = -(myMatrix.m00*camZ[o0]+myMatrix.m01*camZ[o1]+myMatrix.m02*camZ[o2]);
|
||
|
|
m21 = -(myMatrix.m10*camZ[o0]+myMatrix.m11*camZ[o1]+myMatrix.m12*camZ[o2]);
|
||
|
|
m22 = -(myMatrix.m20*camZ[o0]+myMatrix.m21*camZ[o1]+myMatrix.m22*camZ[o2]);
|
||
|
|
|
||
|
|
float px = m02;
|
||
|
|
float py = m12;
|
||
|
|
float pz = m22;
|
||
|
|
float resultT0x = m00*TEX_WIDTH+m02; //Bugfix: possibly we should use F_TEX_WIDTH/HEIGHT instead? Seems to read off end of array in that case, though...
|
||
|
|
float resultT0y = m10*TEX_WIDTH+m12;
|
||
|
|
float resultT0z = m20*TEX_WIDTH+m22;
|
||
|
|
float result0Tx = m01*TEX_HEIGHT+m02;
|
||
|
|
float result0Ty = m11*TEX_HEIGHT+m12;
|
||
|
|
float result0Tz = m21*TEX_HEIGHT+m22;
|
||
|
|
float mx = resultT0x-m02;
|
||
|
|
float my = resultT0y-m12;
|
||
|
|
float mz = resultT0z-m22;
|
||
|
|
float nx = result0Tx-m02;
|
||
|
|
float ny = result0Ty-m12;
|
||
|
|
float nz = result0Tz-m22;
|
||
|
|
|
||
|
|
//avec = p x n
|
||
|
|
ax = (py*nz-pz*ny)*TEX_WIDTH; //F_TEX_WIDTH/HEIGHT?
|
||
|
|
ay = (pz*nx-px*nz)*TEX_WIDTH;
|
||
|
|
az = (px*ny-py*nx)*TEX_WIDTH;
|
||
|
|
//bvec = m x p
|
||
|
|
bx = (my*pz-mz*py)*TEX_HEIGHT;
|
||
|
|
by = (mz*px-mx*pz)*TEX_HEIGHT;
|
||
|
|
bz = (mx*py-my*px)*TEX_HEIGHT;
|
||
|
|
//cvec = n x m
|
||
|
|
cx = ny*mz-nz*my;
|
||
|
|
cy = nz*mx-nx*mz;
|
||
|
|
cz = nx*my-ny*mx;
|
||
|
|
}
|
||
|
|
|
||
|
|
nearPlaneWidth = parent.rightScreen-parent.leftScreen;
|
||
|
|
nearPlaneHeight = parent.topScreen-parent.bottomScreen;
|
||
|
|
nearPlaneDepth = parent.nearPlane;
|
||
|
|
xmult = nearPlaneWidth / SCREEN_WIDTH; //one pixel width in nearPlane coordinates
|
||
|
|
ymult = nearPlaneHeight / SCREEN_HEIGHT;
|
||
|
|
newax = ax*xmult;//Extra scalings to map screen plane units to pixel units
|
||
|
|
newbx = bx*xmult;
|
||
|
|
newcx = cx*xmult;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set the power of two used for linear interpolation of texture coordinates.
|
||
|
|
* A true texture coordinate is computed every 2^pwr pixels along a scanline.
|
||
|
|
*/
|
||
|
|
static public void setInterpPower(int pwr){
|
||
|
|
//Currently must be invoked from P5 as PTriangle.setInterpPower(...)
|
||
|
|
TEX_INTERP_POWER = pwr;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Plain color
|
||
|
|
*/
|
||
|
|
private void drawsegment_plain
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int f = m_fill;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
m_zbuffer[xstart] = iz;
|
||
|
|
m_pixels[xstart] = f;
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Plain color, interpolated alpha
|
||
|
|
*/
|
||
|
|
private void drawsegment_plain_alpha
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
|
||
|
|
int pr = m_fill & 0xFF0000;
|
||
|
|
int pg = m_fill & 0xFF00;
|
||
|
|
int pb = m_fill & 0xFF;
|
||
|
|
|
||
|
|
int p = m_index;
|
||
|
|
float iaf = iaadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
int ia = (int) (iaf * xdiff + aleft);
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
int alpha = ia >> 16;
|
||
|
|
int mr0 = m_pixels[xstart];
|
||
|
|
int mg0 = mr0 & 0xFF00;
|
||
|
|
int mb0 = mr0 & 0xFF;
|
||
|
|
mr0 &= 0xFF0000;
|
||
|
|
|
||
|
|
mr0 = mr0 + (((pr - mr0) * alpha) >> 8);
|
||
|
|
mg0 = mg0 + (((pg - mg0) * alpha) >> 8);
|
||
|
|
mb0 = mb0 + (((pb - mb0) * alpha) >> 8);
|
||
|
|
m_pixels[xstart] = (mr0 & 0xFF0000) | (mg0 & 0xFF00) | (mb0 & 0xFF);
|
||
|
|
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
iz += izadd;
|
||
|
|
ia += iaadd;
|
||
|
|
}
|
||
|
|
ytop += SCREEN_WIDTH;
|
||
|
|
xleft += leftadd;
|
||
|
|
xrght += rghtadd;
|
||
|
|
zleft += zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* RGB gouraud
|
||
|
|
*/
|
||
|
|
private void drawsegment_gouraud
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
float irf = iradd;
|
||
|
|
float igf = igadd;
|
||
|
|
float ibf = ibadd;
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
int ir = (int) (irf * xdiff + rleft);
|
||
|
|
int ig = (int) (igf * xdiff + gleft);
|
||
|
|
int ib = (int) (ibf * xdiff + bleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
m_zbuffer[xstart] = iz;
|
||
|
|
m_pixels[xstart]=((ir & 0xFF0000) | ((ig >> 8) & 0xFF00) | (ib >> 16));
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
ir+=iradd;
|
||
|
|
ig+=igadd;
|
||
|
|
ib+=ibadd;
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
rleft+=rleftadd;
|
||
|
|
gleft+=gleftadd;
|
||
|
|
bleft+=bleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* RGB gouraud + interpolated alpha
|
||
|
|
*/
|
||
|
|
private void drawsegment_gouraud_alpha
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float irf = iradd;
|
||
|
|
float igf = igadd;
|
||
|
|
float ibf = ibadd;
|
||
|
|
float iaf = iaadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
|
||
|
|
int ir = (int) (irf * xdiff + rleft);
|
||
|
|
int ig = (int) (igf * xdiff + gleft);
|
||
|
|
int ib = (int) (ibf * xdiff + bleft);
|
||
|
|
int ia = (int) (iaf * xdiff + aleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
//
|
||
|
|
int red = (ir & 0xFF0000);
|
||
|
|
int grn = (ig >> 8) & 0xFF00;
|
||
|
|
int blu = (ib >> 16);
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
|
||
|
|
// blend alpha
|
||
|
|
int al = ia >> 16;
|
||
|
|
|
||
|
|
//
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al) >> 8)) & 0xFF0000) | ((bg + (((grn - bg) * al) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al) >> 8)) & 0xFF);
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
ir+=iradd;
|
||
|
|
ig+=igadd;
|
||
|
|
ib+=ibadd;
|
||
|
|
ia+=iaadd;
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
rleft+=rleftadd;
|
||
|
|
gleft+=gleftadd;
|
||
|
|
bleft+=bleftadd;
|
||
|
|
aleft+=aleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 8-bit plain texture
|
||
|
|
*/
|
||
|
|
|
||
|
|
//THIS IS MESSED UP, NEED TO GRAB ORIGINAL VERSION!!!
|
||
|
|
private void drawsegment_texture8
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
|
||
|
|
int red = m_fill & 0xFF0000;
|
||
|
|
int grn = m_fill & 0xFF00;
|
||
|
|
int blu = m_fill & 0xFF;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
// try-catch just in case pixel offset it out of range
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
int al0;
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = iu & 0xFFFF;
|
||
|
|
al0 = m_texture[ofs] & 0xFF;
|
||
|
|
int al1 = m_texture[ofs + 1] & 0xFF;
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int al2 = m_texture[ofs] & 0xFF;
|
||
|
|
int al3 = m_texture[ofs + 1] & 0xFF;
|
||
|
|
al0 = al0 + (((al1-al0) * iui) >> 16);
|
||
|
|
al2 = al2 + (((al3-al2) * iui) >> 16);
|
||
|
|
al0 = al0 + (((al2-al0) * (iv & 0xFFFF)) >> 16);
|
||
|
|
} else {
|
||
|
|
al0 = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)] & 0xFF;
|
||
|
|
}
|
||
|
|
|
||
|
|
int br = m_pixels[xstart];
|
||
|
|
int bg = (br & 0xFF00);
|
||
|
|
int bb = (br & 0xFF);
|
||
|
|
br = (br & 0xFF0000);
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al0) >> 8)) & 0xFF0000) | ((bg + (((grn - bg) * al0) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al0) >> 8)) & 0xFF);
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
}
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 8-bit texutre + alpha
|
||
|
|
*/
|
||
|
|
private void drawsegment_texture8_alpha
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
float iaf = iaadd;
|
||
|
|
|
||
|
|
int red = m_fill & 0xFF0000;
|
||
|
|
int grn = m_fill & 0xFF00;
|
||
|
|
int blu = m_fill & 0xFF;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
int ia = (int) (iaf * xdiff + aleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
// try-catch just in case pixel offset it out of range
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
int al0;
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = iu & 0xFFFF;
|
||
|
|
al0 = m_texture[ofs] & 0xFF;
|
||
|
|
int al1 = m_texture[ofs + 1] & 0xFF;
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int al2 = m_texture[ofs] & 0xFF;
|
||
|
|
int al3 = m_texture[ofs + 1] & 0xFF;
|
||
|
|
al0 = al0 + (((al1-al0) * iui) >> 16);
|
||
|
|
al2 = al2 + (((al3-al2) * iui) >> 16);
|
||
|
|
al0 = al0 + (((al2-al0) * (iv & 0xFFFF)) >> 16);
|
||
|
|
} else {
|
||
|
|
al0 = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)] & 0xFF;
|
||
|
|
}
|
||
|
|
al0 = (al0 * (ia >> 16)) >> 8;
|
||
|
|
|
||
|
|
int br = m_pixels[xstart];
|
||
|
|
int bg = (br & 0xFF00);
|
||
|
|
int bb = (br & 0xFF);
|
||
|
|
br = (br & 0xFF0000);
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al0) >> 8)) & 0xFF0000) | ((bg + (((grn - bg) * al0) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al0) >> 8)) & 0xFF);
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
}
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
iz+=izadd;
|
||
|
|
ia+=iaadd;
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
aleft+=aleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Plain 24-bit texture
|
||
|
|
*/
|
||
|
|
private void drawsegment_texture24
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
|
||
|
|
int ypixel = ytop/SCREEN_WIDTH;//ACCTEX
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;//If we're past this index, we can't shift down a row w/o throwing an exception
|
||
|
|
// int exCount = 0;//counter for exceptions caught
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES]; //bring this local since it will be accessed often
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
|
||
|
|
//Interpolation length of 16 tends to look good except at a small angle; 8 looks okay then, except for the
|
||
|
|
//above issue. When viewing close to flat, as high as 32 is often acceptable. Could add dynamic interpolation
|
||
|
|
//settings based on triangle angle - currently we just pick a value and leave it (by default I have the
|
||
|
|
//power set at 3, so every 8 pixels a true coordinate is calculated, which seems a decent compromise).
|
||
|
|
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion gave us garbage, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
while (ytop < ybottom) {//scanline loop
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0){ xstart = 0; }
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH){ xend = SCREEN_WIDTH; }
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
if (accurateMode){
|
||
|
|
//off by one (half, I guess) hack, w/o it the first rows are outside the texture - maybe a mistake somewhere?
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;//OPT - some of this could be brought out of the y-loop since
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;//xpixel and ypixel just increment by the same numbers each iteration.
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;//Probably not a big bottleneck, though.
|
||
|
|
}
|
||
|
|
|
||
|
|
//Figure out whether triangle is going further into the screen or not as we move along scanline
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
|
||
|
|
//Set up linear interpolation between calculated texture points
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
//float fdeltaU = 0; float fdeltaV = 0;//vars for floating point interpolating version of algorithm
|
||
|
|
//float fiu = 0; float fiv = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
|
||
|
|
//Bugfix (done): it's a Really Bad Thing to interpolate along a scanline when the triangle goes deeper into the screen,
|
||
|
|
//because if the angle is severe enough the last control point for interpolation may cross the vanishing
|
||
|
|
//point. This leads to some pretty nasty artifacts, and ideally we should scan from right to left if the
|
||
|
|
//triangle is better served that way, or (what we do now) precompute the offset that we'll need so that we end up
|
||
|
|
//with a control point exactly at the furthest edge of the triangle.
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
//IMPORTANT!!! Results are horrid without this hack!
|
||
|
|
//If polygon goes into the screen along scan line, we want to match the control point to the furthest point drawn
|
||
|
|
//since the control points are less meaningful the closer you are to the vanishing point.
|
||
|
|
//We'll do this by making the first control point lie before the start of the scanline (safe since it's closer to us)
|
||
|
|
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength; //"off by one" hack...probably means there's a small bug somewhere
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
|
||
|
|
//Take step to control point to the left of start pixel
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
|
||
|
|
//Now step to right control point
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
|
||
|
|
//Get deltas for interpolation
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
//Otherwise the left edge is further, and we pin the first control point to it
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {//pixel loop - keep trim, can execute thousands of times per frame
|
||
|
|
//boolean drawBlack = false; //used to display control points
|
||
|
|
if(accurateMode){
|
||
|
|
/* //Non-interpolating algorithm - slowest version, calculates exact coordinate for each pixel,
|
||
|
|
//and casts from float->int
|
||
|
|
float oneoverc = 65536.0f/c; //a bit faster to pre-divide for next two steps
|
||
|
|
iu = (int)(a*oneoverc);
|
||
|
|
iv = (int)(b*oneoverc);
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
*/
|
||
|
|
|
||
|
|
//Float while calculating, int while interpolating
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
//drawBlack = true;
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv; //ints are used for interpolation, not actual computation
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{ //race through using linear interpolation if we're not at a control point
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
|
||
|
|
/* //Floating point interpolating version - slower than int thanks to casts during interpolation steps
|
||
|
|
if (interpCounter == 0) {
|
||
|
|
interpCounter = linearInterpLength;
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu;
|
||
|
|
oldfv = fv;
|
||
|
|
fu = (a*oneoverc);
|
||
|
|
fv = (b*oneoverc);
|
||
|
|
//oldu = u; oldv = v;
|
||
|
|
fiu = oldfu;
|
||
|
|
fiv = oldfv;
|
||
|
|
fdeltaU = (fu-oldfu)/linearInterpLength;
|
||
|
|
fdeltaV = (fv-oldfv)/linearInterpLength;
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
fiu += fdeltaU;
|
||
|
|
fiv += fdeltaV;
|
||
|
|
}
|
||
|
|
interpCounter--;
|
||
|
|
iu = (int)(fiu); iv = (int)(fiv);*/
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
// try-catch just in case pixel offset is out of range
|
||
|
|
try{
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
m_zbuffer[xstart] = iz;
|
||
|
|
if (m_bilinear) {
|
||
|
|
//We could (should?) add bounds checking on iu and iv here (keep in mind the 16 bit shift!).
|
||
|
|
//This would also be the place to add looping texture mode (bounds check == clamped).
|
||
|
|
//For looping/clamped textures, we'd also need to change PGraphics.textureVertex() to remove
|
||
|
|
//the texture range check there (it constrains normalized texture coordinates from 0->1).
|
||
|
|
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = (iu & 0xFFFF) >> 9;
|
||
|
|
int ivi = (iv & 0xFFFF) >> 9;
|
||
|
|
|
||
|
|
//if(ofs < 0) { ofs += TEX_WIDTH; }
|
||
|
|
//if(ofs > m_texture.length-2) {ofs -= TEX_WIDTH; }
|
||
|
|
|
||
|
|
// get texture pixels
|
||
|
|
int pix0 = m_texture[ofs];
|
||
|
|
int pix1 = m_texture[ofs + 1];
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH; //quick hack to thwart exceptions
|
||
|
|
int pix2 = m_texture[ofs];
|
||
|
|
int pix3 = m_texture[ofs + 1];
|
||
|
|
|
||
|
|
// red
|
||
|
|
int red0 = (pix0 & 0xFF0000);
|
||
|
|
int red2 = (pix2 & 0xFF0000);
|
||
|
|
int up = red0 + ((((pix1 & 0xFF0000) - red0) * iui) >> 7);
|
||
|
|
int dn = red2 + ((((pix3 & 0xFF0000) - red2) * iui) >> 7);
|
||
|
|
int red = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// grn
|
||
|
|
red0 = (pix0 & 0xFF00);
|
||
|
|
red2 = (pix2 & 0xFF00);
|
||
|
|
up = red0 + ((((pix1 & 0xFF00) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF00) - red2) * iui) >> 7);
|
||
|
|
int grn = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// blu
|
||
|
|
red0 = (pix0 & 0xFF);
|
||
|
|
red2 = (pix2 & 0xFF);
|
||
|
|
up = red0 + ((((pix1 & 0xFF) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF) - red2) * iui) >> 7);
|
||
|
|
int blu = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
m_pixels[xstart] = (red & 0xFF0000) | (grn & 0xFF00) | (blu & 0xFF);
|
||
|
|
//if (drawBlack){ m_pixels[xstart] = 0; }
|
||
|
|
|
||
|
|
} else{
|
||
|
|
m_pixels[xstart] = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)];
|
||
|
|
}
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
} catch (Exception e) {/*exCount++;*/}
|
||
|
|
iz+=izadd;
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
}
|
||
|
|
// if (exCount>0) System.out.println(exCount+" exceptions in this segment");
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Alpha 24-bit texture
|
||
|
|
*/
|
||
|
|
private void drawsegment_texture24_alpha
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
float iaf = iaadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
int ia = (int) (iaf * xdiff + aleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
// get alpha
|
||
|
|
int al = ia >> 16;
|
||
|
|
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = (iu & 0xFFFF) >> 9;
|
||
|
|
int ivi = (iv & 0xFFFF) >> 9;
|
||
|
|
|
||
|
|
// get texture pixels
|
||
|
|
int pix0 = m_texture[ofs];
|
||
|
|
int pix1 = m_texture[ofs + 1];
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int pix2 = m_texture[ofs];
|
||
|
|
int pix3 = m_texture[ofs + 1];
|
||
|
|
|
||
|
|
// red
|
||
|
|
int red0 = (pix0 & 0xFF0000);
|
||
|
|
int red2 = (pix2 & 0xFF0000);
|
||
|
|
int up = red0 + ((((pix1 & 0xFF0000) - red0) * iui) >> 7);
|
||
|
|
int dn = red2 + ((((pix3 & 0xFF0000) - red2) * iui) >> 7);
|
||
|
|
int red = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// grn
|
||
|
|
red0 = (pix0 & 0xFF00);
|
||
|
|
red2 = (pix2 & 0xFF00);
|
||
|
|
up = red0 + ((((pix1 & 0xFF00) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF00) - red2) * iui) >> 7);
|
||
|
|
int grn = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// blu
|
||
|
|
red0 = (pix0 & 0xFF);
|
||
|
|
red2 = (pix2 & 0xFF);
|
||
|
|
up = red0 + ((((pix1 & 0xFF) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF) - red2) * iui) >> 7);
|
||
|
|
int blu = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al) >> 8)) & 0xFF0000) |( (bg + (((grn - bg) * al) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al) >> 8)) & 0xFF);
|
||
|
|
} else {
|
||
|
|
int red = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)];
|
||
|
|
int grn = red & 0xFF00;
|
||
|
|
int blu = red & 0xFF;
|
||
|
|
red&=0xFF0000;
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al) >> 8)) & 0xFF0000) |((bg + (((grn - bg) * al) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al) >> 8)) & 0xFF);
|
||
|
|
}
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {}
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
ia+=iaadd;
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
aleft+=aleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Plain 32-bit texutre
|
||
|
|
*/
|
||
|
|
private void drawsegment_texture32
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// try-catch just in case pixel offset it out of range
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = (iu & 0xFFFF) >> 9;
|
||
|
|
int ivi = (iv & 0xFFFF) >> 9;
|
||
|
|
|
||
|
|
// get texture pixels
|
||
|
|
int pix0 = m_texture[ofs];
|
||
|
|
int pix1 = m_texture[ofs + 1];
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int pix2 = m_texture[ofs];
|
||
|
|
int pix3 = m_texture[ofs + 1];
|
||
|
|
|
||
|
|
// red
|
||
|
|
int red0 = (pix0 & 0xFF0000);
|
||
|
|
int red2 = (pix2 & 0xFF0000);
|
||
|
|
int up = red0 + ((((pix1 & 0xFF0000) - red0) * iui) >> 7);
|
||
|
|
int dn = red2 + ((((pix3 & 0xFF0000) - red2) * iui) >> 7);
|
||
|
|
int red = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// grn
|
||
|
|
red0 = (pix0 & 0xFF00);
|
||
|
|
red2 = (pix2 & 0xFF00);
|
||
|
|
up = red0 + ((((pix1 & 0xFF00) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF00) - red2) * iui) >> 7);
|
||
|
|
int grn = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// blu
|
||
|
|
red0 = (pix0 & 0xFF);
|
||
|
|
red2 = (pix2 & 0xFF);
|
||
|
|
up = red0 + ((((pix1 & 0xFF) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF) - red2) * iui) >> 7);
|
||
|
|
int blu = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// alpha
|
||
|
|
pix0>>>=24;
|
||
|
|
pix2>>>=24;
|
||
|
|
up = pix0 + ((((pix1 >>> 24) - pix0) * iui) >> 7);
|
||
|
|
dn = pix2 + ((((pix3 >>> 24) - pix2) * iui) >> 7);
|
||
|
|
int al = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al) >> 8)) & 0xFF0000) |((bg + (((grn - bg) * al) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al) >> 8)) & 0xFF);
|
||
|
|
} else {
|
||
|
|
int red = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)];
|
||
|
|
int al = red >>> 24;
|
||
|
|
int grn = red & 0xFF00;
|
||
|
|
int blu = red & 0xFF;
|
||
|
|
red&=0xFF0000;
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al) >> 8)) & 0xFF0000) |((bg + (((grn - bg) * al) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al) >> 8)) & 0xFF);
|
||
|
|
}
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
}
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
aleft+=aleftadd;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Alpha 32-bit texutre
|
||
|
|
*/
|
||
|
|
private void drawsegment_texture32_alpha
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
float iaf = iaadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
int ia = (int) (iaf * xdiff + aleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// try-catch just in case pixel offset it out of range
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
// get alpha
|
||
|
|
int al = ia >> 16;
|
||
|
|
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = (iu & 0xFFFF) >> 9;
|
||
|
|
int ivi = (iv & 0xFFFF) >> 9;
|
||
|
|
|
||
|
|
// get texture pixels
|
||
|
|
int pix0 = m_texture[ofs];
|
||
|
|
int pix1 = m_texture[ofs + 1];
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int pix2 = m_texture[ofs];
|
||
|
|
int pix3 = m_texture[ofs + 1];
|
||
|
|
|
||
|
|
// red
|
||
|
|
int red0 = (pix0 & 0xFF0000);
|
||
|
|
int red2 = (pix2 & 0xFF0000);
|
||
|
|
int up = red0 + ((((pix1 & 0xFF0000) - red0) * iui) >> 7);
|
||
|
|
int dn = red2 + ((((pix3 & 0xFF0000) - red2) * iui) >> 7);
|
||
|
|
int red = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// grn
|
||
|
|
red0 = (pix0 & 0xFF00);
|
||
|
|
red2 = (pix2 & 0xFF00);
|
||
|
|
up = red0 + ((((pix1 & 0xFF00) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF00) - red2) * iui) >> 7);
|
||
|
|
int grn = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// blu
|
||
|
|
red0 = (pix0 & 0xFF);
|
||
|
|
red2 = (pix2 & 0xFF);
|
||
|
|
up = red0 + ((((pix1 & 0xFF) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF) - red2) * iui) >> 7);
|
||
|
|
int blu = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// alpha
|
||
|
|
pix0>>>=24;
|
||
|
|
pix2>>>=24;
|
||
|
|
up = pix0 + ((((pix1 >>> 24) - pix0) * iui) >> 7);
|
||
|
|
dn = pix2 + ((((pix3 >>> 24) - pix2) * iui) >> 7);
|
||
|
|
al = al * (up + (((dn-up) * ivi) >> 7)) >> 8;
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al) >> 8)) & 0xFF0000) |((bg + (((grn - bg) * al) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al) >> 8)) & 0xFF);
|
||
|
|
} else {
|
||
|
|
int red = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)];
|
||
|
|
al = al * (red >>> 24) >> 8;
|
||
|
|
int grn = red & 0xFF00;
|
||
|
|
int blu = red & 0xFF;
|
||
|
|
red&=0xFF0000;
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al) >> 8)) & 0xFF0000) |((bg + (((grn - bg) * al) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al) >> 8)) & 0xFF);
|
||
|
|
}
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
}
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
ia+=iaadd;
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
aleft+=aleftadd;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gouraud blended with 8-bit alpha texture
|
||
|
|
*/
|
||
|
|
private void drawsegment_gouraud_texture8
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
float irf = iradd;
|
||
|
|
float igf = igadd;
|
||
|
|
float ibf = ibadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
int ir = (int) (irf * xdiff + rleft);
|
||
|
|
int ig = (int) (igf * xdiff + gleft);
|
||
|
|
int ib = (int) (ibf * xdiff + bleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
int al0;
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = iu & 0xFFFF;
|
||
|
|
al0 = m_texture[ofs] & 0xFF;
|
||
|
|
int al1 = m_texture[ofs + 1] & 0xFF;
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int al2 = m_texture[ofs] & 0xFF;
|
||
|
|
int al3 = m_texture[ofs + 1] & 0xFF;
|
||
|
|
al0 = al0 + (((al1-al0) * iui) >> 16);
|
||
|
|
al2 = al2 + (((al3-al2) * iui) >> 16);
|
||
|
|
al0 = al0 + (((al2-al0) * (iv & 0xFFFF)) >> 16);
|
||
|
|
} else {
|
||
|
|
al0 = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)] & 0xFF;
|
||
|
|
}
|
||
|
|
|
||
|
|
// get RGB colors
|
||
|
|
int red = ir & 0xFF0000;
|
||
|
|
int grn = (ig >> 8) & 0xFF00;
|
||
|
|
int blu = (ib >> 16);
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al0) >> 8)) & 0xFF0000) |((bg + (((grn - bg) * al0) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al0) >> 8)) & 0xFF);
|
||
|
|
|
||
|
|
// write stencil
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
ir+=iradd;
|
||
|
|
ig+=igadd;
|
||
|
|
ib+=ibadd;
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
rleft+=rleftadd;
|
||
|
|
gleft+=gleftadd;
|
||
|
|
bleft+=bleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Texture multiplied with gouraud
|
||
|
|
*/
|
||
|
|
private void drawsegment_gouraud_texture8_alpha
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
float irf = iradd;
|
||
|
|
float igf = igadd;
|
||
|
|
float ibf = ibadd;
|
||
|
|
float iaf = iaadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
int ir = (int) (irf * xdiff + rleft);
|
||
|
|
int ig = (int) (igf * xdiff + gleft);
|
||
|
|
int ib = (int) (ibf * xdiff + bleft);
|
||
|
|
int ia = (int) (iaf * xdiff + aleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
int al0;
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = iu & 0xFFFF;
|
||
|
|
al0 = m_texture[ofs] & 0xFF;
|
||
|
|
int al1 = m_texture[ofs + 1] & 0xFF;
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int al2 = m_texture[ofs] & 0xFF;
|
||
|
|
int al3 = m_texture[ofs + 1] & 0xFF;
|
||
|
|
al0 = al0 + (((al1-al0) * iui) >> 16);
|
||
|
|
al2 = al2 + (((al3-al2) * iui) >> 16);
|
||
|
|
al0 = al0 + (((al2-al0) * (iv & 0xFFFF)) >> 16);
|
||
|
|
} else {
|
||
|
|
al0 = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)] & 0xFF;
|
||
|
|
}
|
||
|
|
al0 = (al0 * (ia >> 16)) >> 8;
|
||
|
|
|
||
|
|
// get RGB colors
|
||
|
|
int red = ir & 0xFF0000;
|
||
|
|
int grn = (ig >> 8) & 0xFF00;
|
||
|
|
int blu = (ib >> 16);
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al0) >> 8)) & 0xFF0000) |((bg + (((grn - bg) * al0) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al0) >> 8)) & 0xFF);
|
||
|
|
|
||
|
|
// write stencil
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
ir+=iradd;
|
||
|
|
ig+=igadd;
|
||
|
|
ib+=ibadd;
|
||
|
|
ia+=iaadd;
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
rleft+=rleftadd;
|
||
|
|
gleft+=gleftadd;
|
||
|
|
bleft+=bleftadd;
|
||
|
|
aleft+=aleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Texture multiplied with gouraud
|
||
|
|
*/
|
||
|
|
private void drawsegment_gouraud_texture24
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
float irf = iradd;
|
||
|
|
float igf = igadd;
|
||
|
|
float ibf = ibadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
int ir = (int) (irf * xdiff + rleft);
|
||
|
|
int ig = (int) (igf * xdiff + gleft);
|
||
|
|
int ib = (int) (ibf * xdiff + bleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
int red;
|
||
|
|
int grn;
|
||
|
|
int blu;
|
||
|
|
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = (iu & 0xFFFF) >> 9;
|
||
|
|
int ivi = (iv & 0xFFFF) >> 9;
|
||
|
|
|
||
|
|
// get texture pixels
|
||
|
|
int pix0 = m_texture[ofs];
|
||
|
|
int pix1 = m_texture[ofs + 1];
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int pix2 = m_texture[ofs];
|
||
|
|
int pix3 = m_texture[ofs + 1];
|
||
|
|
|
||
|
|
// red
|
||
|
|
int red0 = (pix0 & 0xFF0000);
|
||
|
|
int red2 = (pix2 & 0xFF0000);
|
||
|
|
int up = red0 + ((((pix1 & 0xFF0000) - red0) * iui) >> 7);
|
||
|
|
int dn = red2 + ((((pix3 & 0xFF0000) - red2) * iui) >> 7);
|
||
|
|
red = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// grn
|
||
|
|
red0 = (pix0 & 0xFF00);
|
||
|
|
red2 = (pix2 & 0xFF00);
|
||
|
|
up = red0 + ((((pix1 & 0xFF00) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF00) - red2) * iui) >> 7);
|
||
|
|
grn = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// blu
|
||
|
|
red0 = (pix0 & 0xFF);
|
||
|
|
red2 = (pix2 & 0xFF);
|
||
|
|
up = red0 + ((((pix1 & 0xFF) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF) - red2) * iui) >> 7);
|
||
|
|
blu = up + (((dn-up) * ivi) >> 7);
|
||
|
|
} else {
|
||
|
|
// get texture pixel color
|
||
|
|
blu = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)];
|
||
|
|
red = (blu & 0xFF0000);
|
||
|
|
grn = (blu & 0xFF00);
|
||
|
|
blu = blu & 0xFF;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
int r = (ir >> 16);
|
||
|
|
int g = (ig >> 16);
|
||
|
|
int bb2 = (ib >> 16); //oops, namespace collision with accurate texture vector b...sorry [ewjordan]
|
||
|
|
|
||
|
|
//
|
||
|
|
m_pixels[xstart] = ( ((red * r) & 0xFF000000) | ((grn * g) & 0xFF0000) | (blu * bb2) ) >> 8;
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
ir+=iradd;
|
||
|
|
ig+=igadd;
|
||
|
|
ib+=ibadd;
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
rleft+=rleftadd;
|
||
|
|
gleft+=gleftadd;
|
||
|
|
bleft+=bleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gouraud*texture blended with interpolating alpha
|
||
|
|
*/
|
||
|
|
private void drawsegment_gouraud_texture24_alpha
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
float irf = iradd;
|
||
|
|
float igf = igadd;
|
||
|
|
float ibf = ibadd;
|
||
|
|
float iaf = iaadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
int ir = (int) (irf * xdiff + rleft);
|
||
|
|
int ig = (int) (igf * xdiff + gleft);
|
||
|
|
int ib = (int) (ibf * xdiff + bleft);
|
||
|
|
int ia = (int) (iaf * xdiff + aleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( ;xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// get texture pixel color
|
||
|
|
try
|
||
|
|
{
|
||
|
|
//if (iz < m_zbuffer[xstart]) {
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) { // [fry 041114]
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
// blend
|
||
|
|
int al = ia >> 16;
|
||
|
|
|
||
|
|
int red;
|
||
|
|
int grn;
|
||
|
|
int blu;
|
||
|
|
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = (iu & 0xFFFF) >> 9;
|
||
|
|
int ivi = (iv & 0xFFFF) >> 9;
|
||
|
|
|
||
|
|
// get texture pixels
|
||
|
|
int pix0 = m_texture[ofs];
|
||
|
|
int pix1 = m_texture[ofs + 1];
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int pix2 = m_texture[ofs];
|
||
|
|
int pix3 = m_texture[ofs + 1];
|
||
|
|
|
||
|
|
// red
|
||
|
|
int red0 = (pix0 & 0xFF0000);
|
||
|
|
int red2 = (pix2 & 0xFF0000);
|
||
|
|
int up = red0 + ((((pix1 & 0xFF0000) - red0) * iui) >> 7);
|
||
|
|
int dn = red2 + ((((pix3 & 0xFF0000) - red2) * iui) >> 7);
|
||
|
|
red = (up + (((dn-up) * ivi) >> 7)) >> 16;
|
||
|
|
|
||
|
|
// grn
|
||
|
|
red0 = (pix0 & 0xFF00);
|
||
|
|
red2 = (pix2 & 0xFF00);
|
||
|
|
up = red0 + ((((pix1 & 0xFF00) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF00) - red2) * iui) >> 7);
|
||
|
|
grn = (up + (((dn-up) * ivi) >> 7)) >> 8;
|
||
|
|
|
||
|
|
// blu
|
||
|
|
red0 = (pix0 & 0xFF);
|
||
|
|
red2 = (pix2 & 0xFF);
|
||
|
|
up = red0 + ((((pix1 & 0xFF) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF) - red2) * iui) >> 7);
|
||
|
|
blu = up + (((dn-up) * ivi) >> 7);
|
||
|
|
} else {
|
||
|
|
blu = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)];
|
||
|
|
red = (blu & 0xFF0000) >> 16; // 0 - 255
|
||
|
|
grn = (blu & 0xFF00) >> 8; // 0 - 255
|
||
|
|
blu = (blu & 0xFF); // 0 - 255
|
||
|
|
}
|
||
|
|
|
||
|
|
// multiply with gouraud color
|
||
|
|
red = (red * ir) >>> 8; // 0x00FF????
|
||
|
|
grn = (grn * ig) >>> 16; // 0x0000FF??
|
||
|
|
blu = (blu * ib) >>> 24; // 0x000000FF
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
|
||
|
|
//
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al) >> 8)) & 0xFF0000) |((bg + (((grn - bg) * al) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al) >> 8)) & 0xFF);
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
ir+=iradd;
|
||
|
|
ig+=igadd;
|
||
|
|
ib+=ibadd;
|
||
|
|
ia+=iaadd;
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
rleft+=rleftadd;
|
||
|
|
gleft+=gleftadd;
|
||
|
|
bleft+=bleftadd;
|
||
|
|
aleft+=aleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gouraud*texture blended with interpolating alpha
|
||
|
|
*/
|
||
|
|
private void drawsegment_gouraud_texture32
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
//int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
float irf = iradd;
|
||
|
|
float igf = igadd;
|
||
|
|
float ibf = ibadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
int ir = (int) (irf * xdiff + rleft);
|
||
|
|
int ig = (int) (igf * xdiff + gleft);
|
||
|
|
int ib = (int) (ibf * xdiff + bleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
for ( ; xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
try
|
||
|
|
{
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) {
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
int red;
|
||
|
|
int grn;
|
||
|
|
int blu;
|
||
|
|
int al;
|
||
|
|
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = (iu & 0xFFFF) >> 9;
|
||
|
|
int ivi = (iv & 0xFFFF) >> 9;
|
||
|
|
|
||
|
|
// get texture pixels
|
||
|
|
int pix0 = m_texture[ofs];
|
||
|
|
int pix1 = m_texture[ofs + 1];
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int pix2 = m_texture[ofs];
|
||
|
|
int pix3 = m_texture[ofs + 1];
|
||
|
|
|
||
|
|
// red
|
||
|
|
int red0 = (pix0 & 0xFF0000);
|
||
|
|
int red2 = (pix2 & 0xFF0000);
|
||
|
|
int up = red0 + ((((pix1 & 0xFF0000) - red0) * iui) >> 7);
|
||
|
|
int dn = red2 + ((((pix3 & 0xFF0000) - red2) * iui) >> 7);
|
||
|
|
red = (up + (((dn-up) * ivi) >> 7)) >> 16;
|
||
|
|
|
||
|
|
// grn
|
||
|
|
red0 = (pix0 & 0xFF00);
|
||
|
|
red2 = (pix2 & 0xFF00);
|
||
|
|
up = red0 + ((((pix1 & 0xFF00) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF00) - red2) * iui) >> 7);
|
||
|
|
grn = (up + (((dn-up) * ivi) >> 7)) >> 8;
|
||
|
|
|
||
|
|
// blu
|
||
|
|
red0 = (pix0 & 0xFF);
|
||
|
|
red2 = (pix2 & 0xFF);
|
||
|
|
up = red0 + ((((pix1 & 0xFF) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF) - red2) * iui) >> 7);
|
||
|
|
blu = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// alpha
|
||
|
|
pix0>>>=24;
|
||
|
|
pix2>>>=24;
|
||
|
|
up = pix0 + ((((pix1 >>> 24) - pix0) * iui) >> 7);
|
||
|
|
dn = pix2 + ((((pix3 >>> 24) - pix2) * iui) >> 7);
|
||
|
|
al = up + (((dn-up) * ivi) >> 7);
|
||
|
|
} else {
|
||
|
|
// get texture pixel color
|
||
|
|
blu = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)];
|
||
|
|
al = (blu >>> 24);
|
||
|
|
red = (blu & 0xFF0000) >> 16;
|
||
|
|
grn = (blu & 0xFF00) >> 8;
|
||
|
|
blu = blu & 0xFF;
|
||
|
|
}
|
||
|
|
|
||
|
|
// multiply with gouraud color
|
||
|
|
red = (red * ir) >>> 8; // 0x00FF????
|
||
|
|
grn = (grn * ig) >>> 16; // 0x0000FF??
|
||
|
|
blu = (blu * ib) >>> 24; // 0x000000FF
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
|
||
|
|
//
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al) >> 8)) & 0xFF0000) |((bg + (((grn - bg) * al) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al) >> 8)) & 0xFF);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
ir+=iradd;
|
||
|
|
ig+=igadd;
|
||
|
|
ib+=ibadd;
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
rleft+=rleftadd;
|
||
|
|
gleft+=gleftadd;
|
||
|
|
bleft+=bleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Gouraud*texture blended with interpolating alpha
|
||
|
|
*/
|
||
|
|
private void drawsegment_gouraud_texture32_alpha
|
||
|
|
(
|
||
|
|
float leftadd,
|
||
|
|
float rghtadd,
|
||
|
|
int ytop,
|
||
|
|
int ybottom
|
||
|
|
) {
|
||
|
|
//Accurate texture mode added - comments stripped from dupe code, see drawsegment_texture24() for details
|
||
|
|
int ypixel = ytop;
|
||
|
|
int lastRowStart = m_texture.length - TEX_WIDTH - 2;
|
||
|
|
boolean accurateMode = parent.hints[ENABLE_ACCURATE_TEXTURES];
|
||
|
|
float screenx = 0; float screeny = 0; float screenz = 0;
|
||
|
|
float a = 0; float b = 0; float c = 0;
|
||
|
|
int linearInterpPower = TEX_INTERP_POWER;
|
||
|
|
int linearInterpLength = 1 << linearInterpPower;
|
||
|
|
if (accurateMode){
|
||
|
|
if(precomputeAccurateTexturing()){ //see if the precomputation goes well, if so finish the setup
|
||
|
|
newax *= linearInterpLength;
|
||
|
|
newbx *= linearInterpLength;
|
||
|
|
newcx *= linearInterpLength;
|
||
|
|
screenz = nearPlaneDepth;
|
||
|
|
firstSegment = false;
|
||
|
|
} else{
|
||
|
|
accurateMode = false; //if the matrix inversion screwed up, revert to normal rendering (something is degenerate)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ytop*=SCREEN_WIDTH;
|
||
|
|
ybottom*=SCREEN_WIDTH;
|
||
|
|
int p = m_index;
|
||
|
|
|
||
|
|
float iuf = iuadd;
|
||
|
|
float ivf = ivadd;
|
||
|
|
float irf = iradd;
|
||
|
|
float igf = igadd;
|
||
|
|
float ibf = ibadd;
|
||
|
|
float iaf = iaadd;
|
||
|
|
|
||
|
|
while (ytop < ybottom) {
|
||
|
|
int xstart = (int) (xleft + PIXEL_CENTER);
|
||
|
|
if (xstart < 0)
|
||
|
|
xstart = 0;
|
||
|
|
|
||
|
|
int xpixel = xstart;//accurate mode
|
||
|
|
|
||
|
|
int xend = (int) (xrght + PIXEL_CENTER);
|
||
|
|
if (xend > SCREEN_WIDTH)
|
||
|
|
xend = SCREEN_WIDTH;
|
||
|
|
float xdiff = (xstart + PIXEL_CENTER) - xleft;
|
||
|
|
|
||
|
|
int iu = (int) (iuf * xdiff + uleft);
|
||
|
|
int iv = (int) (ivf * xdiff + vleft);
|
||
|
|
int ir = (int) (irf * xdiff + rleft);
|
||
|
|
int ig = (int) (igf * xdiff + gleft);
|
||
|
|
int ib = (int) (ibf * xdiff + bleft);
|
||
|
|
int ia = (int) (iaf * xdiff + aleft);
|
||
|
|
float iz = izadd * xdiff + zleft;
|
||
|
|
|
||
|
|
xstart+=ytop;
|
||
|
|
xend+=ytop;
|
||
|
|
if (accurateMode){
|
||
|
|
screenx = xmult*(xpixel+.5f-(SCREEN_WIDTH/2.0f));
|
||
|
|
screeny = ymult*(ypixel+.5f-(SCREEN_HEIGHT/2.0f));
|
||
|
|
a = screenx*ax+screeny*ay+screenz*az;
|
||
|
|
b = screenx*bx+screeny*by+screenz*bz;
|
||
|
|
c = screenx*cx+screeny*cy+screenz*cz;
|
||
|
|
}
|
||
|
|
boolean goingIn = ( (newcx > 0) == (c > 0) )?false:true;
|
||
|
|
int interpCounter = 0;
|
||
|
|
int deltaU = 0; int deltaV = 0;
|
||
|
|
float fu = 0; float fv = 0;
|
||
|
|
float oldfu = 0; float oldfv = 0;
|
||
|
|
|
||
|
|
if (accurateMode&&goingIn){
|
||
|
|
int rightOffset = (xend-xstart-1)%linearInterpLength;
|
||
|
|
int leftOffset = linearInterpLength-rightOffset;
|
||
|
|
float rightOffset2 = rightOffset / ((float)linearInterpLength);
|
||
|
|
float leftOffset2 = leftOffset / ((float)linearInterpLength);
|
||
|
|
interpCounter = leftOffset;
|
||
|
|
float ao = a-leftOffset2*newax;
|
||
|
|
float bo = b-leftOffset2*newbx;
|
||
|
|
float co = c-leftOffset2*newcx;
|
||
|
|
float oneoverc = 65536.0f/co;
|
||
|
|
oldfu = (ao*oneoverc); oldfv = (bo*oneoverc);
|
||
|
|
a += rightOffset2*newax;
|
||
|
|
b += rightOffset2*newbx;
|
||
|
|
c += rightOffset2*newcx;
|
||
|
|
oneoverc = 65536.0f/c;
|
||
|
|
fu = a*oneoverc; fv = b*oneoverc;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
iu = ( (int)oldfu )+(leftOffset-1)*deltaU; iv = ( (int)oldfv )+(leftOffset-1)*deltaV; //another "off-by-one" hack
|
||
|
|
} else{
|
||
|
|
float preoneoverc = 65536.0f/c;
|
||
|
|
fu = (a*preoneoverc);
|
||
|
|
fv = (b*preoneoverc);
|
||
|
|
}
|
||
|
|
|
||
|
|
for ( ;xstart < xend; xstart++ ) {
|
||
|
|
if(accurateMode){
|
||
|
|
if (interpCounter == linearInterpLength) interpCounter = 0;
|
||
|
|
if (interpCounter == 0){
|
||
|
|
a += newax;
|
||
|
|
b += newbx;
|
||
|
|
c += newcx;
|
||
|
|
float oneoverc = 65536.0f/c;
|
||
|
|
oldfu = fu; oldfv = fv;
|
||
|
|
fu = (a*oneoverc); fv = (b*oneoverc);
|
||
|
|
iu = (int)oldfu; iv = (int)oldfv;
|
||
|
|
deltaU = ((int)(fu - oldfu)) >> linearInterpPower;
|
||
|
|
deltaV = ((int)(fv - oldfv)) >> linearInterpPower;
|
||
|
|
} else{
|
||
|
|
iu += deltaU;
|
||
|
|
iv += deltaV;
|
||
|
|
}
|
||
|
|
interpCounter++;
|
||
|
|
}
|
||
|
|
|
||
|
|
// get texture pixel color
|
||
|
|
try
|
||
|
|
{
|
||
|
|
//if (iz < m_zbuffer[xstart]) {
|
||
|
|
if (noDepthTest || (iz <= m_zbuffer[xstart])) { // [fry 041114]
|
||
|
|
//m_zbuffer[xstart] = iz;
|
||
|
|
|
||
|
|
// blend
|
||
|
|
int al = ia >> 16;
|
||
|
|
|
||
|
|
int red;
|
||
|
|
int grn;
|
||
|
|
int blu;
|
||
|
|
|
||
|
|
if (m_bilinear) {
|
||
|
|
int ofs = (iv >> 16) * TEX_WIDTH + (iu >> 16);
|
||
|
|
int iui = (iu & 0xFFFF) >> 9;
|
||
|
|
int ivi = (iv & 0xFFFF) >> 9;
|
||
|
|
|
||
|
|
// get texture pixels
|
||
|
|
int pix0 = m_texture[ofs];
|
||
|
|
int pix1 = m_texture[ofs + 1];
|
||
|
|
if (ofs < lastRowStart) ofs+=TEX_WIDTH;
|
||
|
|
int pix2 = m_texture[ofs];
|
||
|
|
int pix3 = m_texture[ofs + 1];
|
||
|
|
|
||
|
|
// red
|
||
|
|
int red0 = (pix0 & 0xFF0000);
|
||
|
|
int red2 = (pix2 & 0xFF0000);
|
||
|
|
int up = red0 + ((((pix1 & 0xFF0000) - red0) * iui) >> 7);
|
||
|
|
int dn = red2 + ((((pix3 & 0xFF0000) - red2) * iui) >> 7);
|
||
|
|
red = (up + (((dn-up) * ivi) >> 7)) >> 16;
|
||
|
|
|
||
|
|
// grn
|
||
|
|
red0 = (pix0 & 0xFF00);
|
||
|
|
red2 = (pix2 & 0xFF00);
|
||
|
|
up = red0 + ((((pix1 & 0xFF00) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF00) - red2) * iui) >> 7);
|
||
|
|
grn = (up + (((dn-up) * ivi) >> 7)) >> 8;
|
||
|
|
|
||
|
|
// blu
|
||
|
|
red0 = (pix0 & 0xFF);
|
||
|
|
red2 = (pix2 & 0xFF);
|
||
|
|
up = red0 + ((((pix1 & 0xFF) - red0) * iui) >> 7);
|
||
|
|
dn = red2 + ((((pix3 & 0xFF) - red2) * iui) >> 7);
|
||
|
|
blu = up + (((dn-up) * ivi) >> 7);
|
||
|
|
|
||
|
|
// alpha
|
||
|
|
pix0>>>=24;
|
||
|
|
pix2>>>=24;
|
||
|
|
up = pix0 + ((((pix1 >>> 24) - pix0) * iui) >> 7);
|
||
|
|
dn = pix2 + ((((pix3 >>> 24) - pix2) * iui) >> 7);
|
||
|
|
al = al * (up + (((dn-up) * ivi) >> 7)) >> 8;
|
||
|
|
} else {
|
||
|
|
blu = m_texture[(iv >> 16) * TEX_WIDTH + (iu >> 16)];
|
||
|
|
al = al * (blu >>> 24) >> 8;
|
||
|
|
red = (blu & 0xFF0000) >> 16; // 0 - 255
|
||
|
|
grn = (blu & 0xFF00) >> 8; // 0 - 255
|
||
|
|
blu = (blu & 0xFF); // 0 - 255
|
||
|
|
}
|
||
|
|
|
||
|
|
// multiply with gouraud color
|
||
|
|
red = (red * ir) >>> 8; // 0x00FF????
|
||
|
|
grn = (grn * ig) >>> 16; // 0x0000FF??
|
||
|
|
blu = (blu * ib) >>> 24; // 0x000000FF
|
||
|
|
|
||
|
|
// get buffer pixels
|
||
|
|
int bb = m_pixels[xstart];
|
||
|
|
int br = (bb & 0xFF0000); // 0x00FF0000
|
||
|
|
int bg = (bb & 0xFF00); // 0x0000FF00
|
||
|
|
bb = (bb & 0xFF); // 0x000000FF
|
||
|
|
|
||
|
|
//
|
||
|
|
m_pixels[xstart] = ((br + (((red - br) * al) >> 8)) & 0xFF0000) |((bg + (((grn - bg) * al) >> 8)) & 0xFF00) | ((bb + (((blu - bb) * al) >> 8)) & 0xFF);
|
||
|
|
m_stencil[xstart] = p;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (Exception e) {
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
xpixel++;//accurate mode
|
||
|
|
if (!accurateMode){
|
||
|
|
iu+=iuadd;
|
||
|
|
iv+=ivadd;
|
||
|
|
}
|
||
|
|
ir+=iradd;
|
||
|
|
ig+=igadd;
|
||
|
|
ib+=ibadd;
|
||
|
|
ia+=iaadd;
|
||
|
|
iz+=izadd;
|
||
|
|
}
|
||
|
|
ypixel++;//accurate mode
|
||
|
|
ytop+=SCREEN_WIDTH;
|
||
|
|
xleft+=leftadd;
|
||
|
|
xrght+=rghtadd;
|
||
|
|
uleft+=uleftadd;
|
||
|
|
vleft+=vleftadd;
|
||
|
|
rleft+=rleftadd;
|
||
|
|
gleft+=gleftadd;
|
||
|
|
bleft+=bleftadd;
|
||
|
|
aleft+=aleftadd;
|
||
|
|
zleft+=zleftadd;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|