1032 lines
35 KiB
Java
1032 lines
35 KiB
Java
import java.io.DataInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
|
|
public class GameModel {
|
|
|
|
private static int sine9[];
|
|
private static int sine11[];
|
|
private static int base64Alphabet[];
|
|
public int numVertices;
|
|
public int projectVertexX[];
|
|
public int projectVertexY[];
|
|
public int projectVertexZ[];
|
|
public int vertexViewX[];
|
|
public int vertexViewY[];
|
|
public int vertexIntensity[];
|
|
public byte vertexAmbience[];
|
|
public int numFaces;
|
|
public int faceNumVertices[];
|
|
public int faceVertices[][];
|
|
public int faceFillFront[];
|
|
public int faceFillBack[];
|
|
public int normalMagnitude[];
|
|
public int normalScale[];
|
|
public int faceIntensity[];
|
|
public int faceNormalX[];
|
|
public int faceNormalY[];
|
|
public int faceNormalZ[];
|
|
public int depth;
|
|
public int transformState;
|
|
public boolean visible;
|
|
public int x1;
|
|
public int x2;
|
|
public int y1;
|
|
public int y2;
|
|
public int z1;
|
|
public int z2;
|
|
public boolean textureTranslucent;
|
|
public boolean transparent;
|
|
public int key;
|
|
public int faceTag[];
|
|
public byte isLocalPlayer[];
|
|
public boolean isolated;
|
|
public boolean unlit;
|
|
public boolean unpickable;
|
|
public boolean projected;
|
|
public int maxVerts;
|
|
public int vertexX[];
|
|
public int vertexY[];
|
|
public int vertexZ[];
|
|
public int vertexTransformedX[];
|
|
public int vertexTransformedY[];
|
|
public int vertexTransformedZ[];
|
|
protected int lightDiffuse;
|
|
protected int lightAmbience;
|
|
private boolean autocommit;
|
|
private int magic;
|
|
private int maxFaces;
|
|
private int faceTransStateThing[][];
|
|
private int faceBoundLeft[];
|
|
private int faceBoundRight[];
|
|
private int faceBoundBottom[];
|
|
private int faceBoundTop[];
|
|
private int faceBoundNear[];
|
|
private int faceBoundFar[];
|
|
private int baseX;
|
|
private int baseY;
|
|
private int baseZ;
|
|
private int orientationYaw;
|
|
private int orientationPitch;
|
|
private int orientationRoll;
|
|
private int scaleFx;
|
|
private int scaleFy;
|
|
private int scaleFz;
|
|
private int shearXy;
|
|
private int shearXz;
|
|
private int shearYx;
|
|
private int shearYz;
|
|
private int shearZx;
|
|
private int shearZy;
|
|
private int transformKind;
|
|
private int diameter;
|
|
private int lightDirectionX;
|
|
private int lightDirectionY;
|
|
private int lightDirectionZ;
|
|
private int lightDirectionMagnitude;
|
|
private int dataPtr;
|
|
|
|
static {
|
|
sine9 = new int[512];
|
|
sine11 = new int[2048];
|
|
|
|
base64Alphabet = new int[256];
|
|
for (int i = 0; i < 256; i++) {
|
|
sine9[i] = (int) (Math.sin((double) i * 0.02454369D) * 32768D);
|
|
sine9[i + 256] = (int) (Math.cos((double) i * 0.02454369D) * 32768D);
|
|
}
|
|
|
|
for (int j = 0; j < 1024; j++) {
|
|
sine11[j] = (int) (Math.sin((double) j * 0.00613592315D) * 32768D);
|
|
sine11[j + 1024] = (int) (Math.cos((double) j * 0.00613592315D) * 32768D);
|
|
}
|
|
|
|
for (int j1 = 0; j1 < 10; j1++)
|
|
base64Alphabet[48 + j1] = j1;
|
|
|
|
for (int k1 = 0; k1 < 26; k1++)
|
|
base64Alphabet[65 + k1] = k1 + 10;
|
|
|
|
for (int l1 = 0; l1 < 26; l1++)
|
|
base64Alphabet[97 + l1] = l1 + 36;
|
|
|
|
base64Alphabet[163] = 62;
|
|
base64Alphabet[36] = 63;
|
|
}
|
|
|
|
public GameModel(int numVertices, int numFaces) {
|
|
transformState = 1;
|
|
visible = true;
|
|
textureTranslucent = false;
|
|
transparent = false;
|
|
key = -1;
|
|
autocommit = false;
|
|
isolated = false;
|
|
unlit = false;
|
|
unpickable = false;
|
|
projected = false;
|
|
magic = World.colourTransparent;
|
|
diameter = World.colourTransparent;
|
|
lightDirectionX = 180;
|
|
lightDirectionY = 155;
|
|
lightDirectionZ = 95;
|
|
lightDirectionMagnitude = 256;
|
|
lightDiffuse = 512;
|
|
lightAmbience = 32;
|
|
allocate(numVertices, numFaces);
|
|
faceTransStateThing = new int[numFaces][1];
|
|
for (int v = 0; v < numFaces; v++)
|
|
faceTransStateThing[v][0] = v;
|
|
|
|
}
|
|
|
|
public GameModel(int numVertices, int numFaces, boolean autocommit, boolean isolated, boolean unlit, boolean unpickable, boolean projected) {
|
|
transformState = 1;
|
|
visible = true;
|
|
textureTranslucent = false;
|
|
transparent = false;
|
|
key = -1;
|
|
magic = World.colourTransparent;
|
|
diameter = World.colourTransparent;
|
|
lightDirectionX = 180;
|
|
lightDirectionY = 155;
|
|
lightDirectionZ = 95;
|
|
lightDirectionMagnitude = 256;
|
|
lightDiffuse = 512;
|
|
lightAmbience = 32;
|
|
this.autocommit = autocommit;
|
|
this.isolated = isolated;
|
|
this.unlit = unlit;
|
|
this.unpickable = unpickable;
|
|
this.projected = projected;
|
|
allocate(numVertices, numFaces);
|
|
}
|
|
|
|
public GameModel(byte data[], int offset, boolean unused) {
|
|
transformState = 1;
|
|
visible = true;
|
|
textureTranslucent = false;
|
|
transparent = false;
|
|
key = -1;
|
|
autocommit = false;
|
|
isolated = false;
|
|
unlit = false;
|
|
unpickable = false;
|
|
projected = false;
|
|
magic = World.colourTransparent;
|
|
diameter = World.colourTransparent;
|
|
lightDirectionX = 180;
|
|
lightDirectionY = 155;
|
|
lightDirectionZ = 95;
|
|
lightDirectionMagnitude = 256;
|
|
lightDiffuse = 512;
|
|
lightAmbience = 32;
|
|
int j = Utility.getUnsignedShort(data, offset);
|
|
offset += 2;
|
|
int k = Utility.getUnsignedShort(data, offset);
|
|
offset += 2;
|
|
allocate(j, k);
|
|
faceTransStateThing = new int[k][1];
|
|
for (int l = 0; l < j; l++) {
|
|
vertexX[l] = Utility.getSignedShort(data, offset);
|
|
offset += 2;
|
|
}
|
|
|
|
for (int i1 = 0; i1 < j; i1++) {
|
|
vertexY[i1] = Utility.getSignedShort(data, offset);
|
|
offset += 2;
|
|
}
|
|
|
|
for (int j1 = 0; j1 < j; j1++) {
|
|
vertexZ[j1] = Utility.getSignedShort(data, offset);
|
|
offset += 2;
|
|
}
|
|
|
|
numVertices = j;
|
|
for (int k1 = 0; k1 < k; k1++)
|
|
faceNumVertices[k1] = data[offset++] & 0xff;
|
|
|
|
for (int l1 = 0; l1 < k; l1++) {
|
|
faceFillFront[l1] = Utility.getSignedShort(data, offset);
|
|
offset += 2;
|
|
if (faceFillFront[l1] == 32767)
|
|
faceFillFront[l1] = magic;
|
|
}
|
|
|
|
for (int i2 = 0; i2 < k; i2++) {
|
|
faceFillBack[i2] = Utility.getSignedShort(data, offset);
|
|
offset += 2;
|
|
if (faceFillBack[i2] == 32767)
|
|
faceFillBack[i2] = magic;
|
|
}
|
|
|
|
for (int j2 = 0; j2 < k; j2++) {
|
|
int k2 = data[offset++] & 0xff;
|
|
if (k2 == 0)
|
|
faceIntensity[j2] = 0;
|
|
else
|
|
faceIntensity[j2] = magic;
|
|
}
|
|
|
|
for (int l2 = 0; l2 < k; l2++) {
|
|
faceVertices[l2] = new int[faceNumVertices[l2]];
|
|
for (int i3 = 0; i3 < faceNumVertices[l2]; i3++)
|
|
if (j < 256) {
|
|
faceVertices[l2][i3] = data[offset++] & 0xff;
|
|
} else {
|
|
faceVertices[l2][i3] = Utility.getUnsignedShort(data, offset);
|
|
offset += 2;
|
|
}
|
|
|
|
}
|
|
|
|
numFaces = k;
|
|
transformState = 1;
|
|
}
|
|
|
|
public GameModel(String name) {
|
|
transformState = 1;
|
|
visible = true;
|
|
textureTranslucent = false;
|
|
transparent = false;
|
|
key = -1;
|
|
autocommit = false;
|
|
isolated = false;
|
|
unlit = false;
|
|
unpickable = false;
|
|
projected = false;
|
|
magic = World.colourTransparent;
|
|
diameter = World.colourTransparent;
|
|
lightDirectionX = 180;
|
|
lightDirectionY = 155;
|
|
lightDirectionZ = 95;
|
|
lightDirectionMagnitude = 256;
|
|
lightDiffuse = 512;
|
|
lightAmbience = 32;
|
|
byte data[];
|
|
try {
|
|
InputStream inputstream = Utility.openFile(name);
|
|
DataInputStream datainputstream = new DataInputStream(inputstream);
|
|
data = new byte[3];
|
|
dataPtr = 0;
|
|
for (int i = 0; i < 3; i += datainputstream.read(data, i, 3 - i)) ;
|
|
int sz = readBase64(data);
|
|
data = new byte[sz];
|
|
dataPtr = 0;
|
|
for (int j = 0; j < sz; j += datainputstream.read(data, j, sz - j)) ;
|
|
datainputstream.close();
|
|
} catch (IOException Ex) {
|
|
numVertices = 0;
|
|
numFaces = 0;
|
|
return;
|
|
}
|
|
int nV = readBase64(data);
|
|
int nF = readBase64(data);
|
|
allocate(nV, nF);
|
|
faceTransStateThing = new int[nF][];
|
|
for (int j3 = 0; j3 < nV; j3++) {
|
|
int x = readBase64(data);
|
|
int y = readBase64(data);
|
|
int z = readBase64(data);
|
|
vertexAt(x, y, z);
|
|
}
|
|
|
|
for (int k3 = 0; k3 < nF; k3++) {
|
|
int n = readBase64(data);
|
|
int front = readBase64(data);
|
|
int back = readBase64(data);
|
|
int l2 = readBase64(data);
|
|
lightDiffuse = readBase64(data);
|
|
lightAmbience = readBase64(data);
|
|
int gouraud = readBase64(data);
|
|
int vs[] = new int[n];
|
|
for (int i = 0; i < n; i++)
|
|
vs[i] = readBase64(data);
|
|
|
|
int ai1[] = new int[l2];
|
|
for (int i4 = 0; i4 < l2; i4++)
|
|
ai1[i4] = readBase64(data);
|
|
|
|
int j4 = createFace(n, vs, front, back);
|
|
faceTransStateThing[k3] = ai1;
|
|
if (gouraud == 0)
|
|
faceIntensity[j4] = 0;
|
|
else
|
|
faceIntensity[j4] = magic;
|
|
}
|
|
|
|
transformState = 1;
|
|
}
|
|
|
|
public GameModel(GameModel pieces[], int count, boolean autocommit, boolean isolated, boolean unlit, boolean unpickable) {
|
|
transformState = 1;
|
|
visible = true;
|
|
textureTranslucent = false;
|
|
transparent = false;
|
|
key = -1;
|
|
projected = false;
|
|
magic = World.colourTransparent;
|
|
diameter = World.colourTransparent;
|
|
lightDirectionX = 180;
|
|
lightDirectionY = 155;
|
|
lightDirectionZ = 95;
|
|
lightDirectionMagnitude = 256;
|
|
lightDiffuse = 512;
|
|
lightAmbience = 32;
|
|
this.autocommit = autocommit;
|
|
this.isolated = isolated;
|
|
this.unlit = unlit;
|
|
this.unpickable = unpickable;
|
|
merge(pieces, count, false);
|
|
}
|
|
|
|
public GameModel(GameModel pieces[], int count) {
|
|
transformState = 1;
|
|
visible = true;
|
|
textureTranslucent = false;
|
|
transparent = false;
|
|
key = -1;
|
|
autocommit = false;
|
|
isolated = false;
|
|
unlit = false;
|
|
unpickable = false;
|
|
projected = false;
|
|
magic = World.colourTransparent;
|
|
diameter = World.colourTransparent;
|
|
lightDirectionX = 180;
|
|
lightDirectionY = 155;
|
|
lightDirectionZ = 95;
|
|
lightDirectionMagnitude = 256;
|
|
lightDiffuse = 512;
|
|
lightAmbience = 32;
|
|
merge(pieces, count, true);
|
|
}
|
|
|
|
private void allocate(int numV, int numF) {
|
|
vertexX = new int[numV];
|
|
vertexY = new int[numV];
|
|
vertexZ = new int[numV];
|
|
vertexIntensity = new int[numV];
|
|
vertexAmbience = new byte[numV];
|
|
faceNumVertices = new int[numF];
|
|
faceVertices = new int[numF][];
|
|
faceFillFront = new int[numF];
|
|
faceFillBack = new int[numF];
|
|
faceIntensity = new int[numF];
|
|
normalScale = new int[numF];
|
|
normalMagnitude = new int[numF];
|
|
if (!projected) {
|
|
projectVertexX = new int[numV];
|
|
projectVertexY = new int[numV];
|
|
projectVertexZ = new int[numV];
|
|
vertexViewX = new int[numV];
|
|
vertexViewY = new int[numV];
|
|
}
|
|
if (!unpickable) {
|
|
isLocalPlayer = new byte[numF];
|
|
faceTag = new int[numF];
|
|
}
|
|
if (autocommit) {
|
|
vertexTransformedX = vertexX;
|
|
vertexTransformedY = vertexY;
|
|
vertexTransformedZ = vertexZ;
|
|
} else {
|
|
vertexTransformedX = new int[numV];
|
|
vertexTransformedY = new int[numV];
|
|
vertexTransformedZ = new int[numV];
|
|
}
|
|
if (!unlit || !isolated) {
|
|
faceNormalX = new int[numF];
|
|
faceNormalY = new int[numF];
|
|
faceNormalZ = new int[numF];
|
|
}
|
|
if (!isolated) {
|
|
faceBoundLeft = new int[numF];
|
|
faceBoundRight = new int[numF];
|
|
faceBoundBottom = new int[numF];
|
|
faceBoundTop = new int[numF];
|
|
faceBoundNear = new int[numF];
|
|
faceBoundFar = new int[numF];
|
|
}
|
|
numFaces = 0;
|
|
numVertices = 0;
|
|
maxVerts = numV;
|
|
maxFaces = numF;
|
|
baseX = baseY = baseZ = 0;
|
|
orientationYaw = orientationPitch = orientationRoll = 0;
|
|
scaleFx = scaleFy = scaleFz = 256;
|
|
shearXy = shearXz = shearYx = shearYz = shearZx = shearZy = 256;
|
|
transformKind = 0;
|
|
}
|
|
|
|
public void projectionPrepare() {
|
|
projectVertexX = new int[numVertices];
|
|
projectVertexY = new int[numVertices];
|
|
projectVertexZ = new int[numVertices];
|
|
vertexViewX = new int[numVertices];
|
|
vertexViewY = new int[numVertices];
|
|
}
|
|
|
|
public void clear() {
|
|
numFaces = 0;
|
|
numVertices = 0;
|
|
}
|
|
|
|
public void reduce(int df, int dz) {
|
|
numFaces -= df;
|
|
if (numFaces < 0)
|
|
numFaces = 0;
|
|
numVertices -= dz;
|
|
if (numVertices < 0)
|
|
numVertices = 0;
|
|
}
|
|
|
|
public void merge(GameModel pieces[], int count, boolean transState) {
|
|
int numF = 0;
|
|
int numV = 0;
|
|
for (int i = 0; i < count; i++) {
|
|
numF += pieces[i].numFaces;
|
|
numV += pieces[i].numVertices;
|
|
}
|
|
|
|
allocate(numV, numF);
|
|
if (transState)
|
|
faceTransStateThing = new int[numF][];
|
|
for (int i = 0; i < count; i++) {
|
|
GameModel source = pieces[i];
|
|
source.commit();
|
|
lightAmbience = source.lightAmbience;
|
|
lightDiffuse = source.lightDiffuse;
|
|
lightDirectionX = source.lightDirectionX;
|
|
lightDirectionY = source.lightDirectionY;
|
|
lightDirectionZ = source.lightDirectionZ;
|
|
lightDirectionMagnitude = source.lightDirectionMagnitude;
|
|
for (int srcF = 0; srcF < source.numFaces; srcF++) {
|
|
int dstVs[] = new int[source.faceNumVertices[srcF]];
|
|
int srcVs[] = source.faceVertices[srcF];
|
|
for (int v = 0; v < source.faceNumVertices[srcF]; v++)
|
|
dstVs[v] = vertexAt(source.vertexX[srcVs[v]], source.vertexY[srcVs[v]], source.vertexZ[srcVs[v]]);
|
|
|
|
int dstF = createFace(source.faceNumVertices[srcF], dstVs, source.faceFillFront[srcF], source.faceFillBack[srcF]);
|
|
faceIntensity[dstF] = source.faceIntensity[srcF];
|
|
normalScale[dstF] = source.normalScale[srcF];
|
|
normalMagnitude[dstF] = source.normalMagnitude[srcF];
|
|
if (transState)
|
|
if (count > 1) {
|
|
faceTransStateThing[dstF] = new int[source.faceTransStateThing[srcF].length + 1];
|
|
faceTransStateThing[dstF][0] = i;
|
|
for (int i2 = 0; i2 < source.faceTransStateThing[srcF].length; i2++)
|
|
faceTransStateThing[dstF][i2 + 1] = source.faceTransStateThing[srcF][i2];
|
|
|
|
} else {
|
|
faceTransStateThing[dstF] = new int[source.faceTransStateThing[srcF].length];
|
|
for (int j2 = 0; j2 < source.faceTransStateThing[srcF].length; j2++)
|
|
faceTransStateThing[dstF][j2] = source.faceTransStateThing[srcF][j2];
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
transformState = 1;
|
|
}
|
|
|
|
public int vertexAt(int x, int y, int z) {
|
|
for (int l = 0; l < numVertices; l++)
|
|
if (vertexX[l] == x && vertexY[l] == y && vertexZ[l] == z)
|
|
return l;
|
|
|
|
if (numVertices >= maxVerts) {
|
|
return -1;
|
|
} else {
|
|
vertexX[numVertices] = x;
|
|
vertexY[numVertices] = y;
|
|
vertexZ[numVertices] = z;
|
|
return numVertices++;
|
|
}
|
|
}
|
|
|
|
public int createVertex(int i, int j, int k) {
|
|
if (numVertices >= maxVerts) {
|
|
return -1;
|
|
} else {
|
|
vertexX[numVertices] = i;
|
|
vertexY[numVertices] = j;
|
|
vertexZ[numVertices] = k;
|
|
return numVertices++;
|
|
}
|
|
}
|
|
|
|
public int createFace(int n, int vs[], int front, int back) {
|
|
if (numFaces >= maxFaces) {
|
|
return -1;
|
|
} else {
|
|
faceNumVertices[numFaces] = n;
|
|
faceVertices[numFaces] = vs;
|
|
faceFillFront[numFaces] = front;
|
|
faceFillBack[numFaces] = back;
|
|
transformState = 1;
|
|
return numFaces++;
|
|
}
|
|
}
|
|
|
|
public GameModel[] split(int unused1, int unused2, int pieceDx, int pieceDz, int rows, int count, int pieceMaxVertices, boolean pickable) {
|
|
commit();
|
|
int pieceNV[] = new int[count];
|
|
int pieceNF[] = new int[count];
|
|
for (int i = 0; i < count; i++) {
|
|
pieceNV[i] = 0;
|
|
pieceNF[i] = 0;
|
|
}
|
|
|
|
for (int f = 0; f < numFaces; f++) {
|
|
int sumX = 0;
|
|
int sumZ = 0;
|
|
int n = faceNumVertices[f];
|
|
int vs[] = faceVertices[f];
|
|
for (int i = 0; i < n; i++) {
|
|
sumX += vertexX[vs[i]];
|
|
sumZ += vertexZ[vs[i]];
|
|
}
|
|
|
|
int p = sumX / (n * pieceDx) + (sumZ / (n * pieceDz)) * rows;
|
|
pieceNV[p] += n;
|
|
pieceNF[p]++;
|
|
}
|
|
|
|
GameModel pieces[] = new GameModel[count];
|
|
for (int i = 0; i < count; i++) {
|
|
if (pieceNV[i] > pieceMaxVertices)
|
|
pieceNV[i] = pieceMaxVertices;
|
|
pieces[i] = new GameModel(pieceNV[i], pieceNF[i], true, true, true, pickable, true);
|
|
pieces[i].lightDiffuse = lightDiffuse;
|
|
pieces[i].lightAmbience = lightAmbience;
|
|
}
|
|
|
|
for (int f = 0; f < numFaces; f++) {
|
|
int sumX = 0;
|
|
int sumZ = 0;
|
|
int n = faceNumVertices[f];
|
|
int vs[] = faceVertices[f];
|
|
for (int i = 0; i < n; i++) {
|
|
sumX += vertexX[vs[i]];
|
|
sumZ += vertexZ[vs[i]];
|
|
}
|
|
|
|
int p = sumX / (n * pieceDx) + (sumZ / (n * pieceDz)) * rows;
|
|
copyLighting(pieces[p], vs, n, f);
|
|
}
|
|
|
|
for (int p = 0; p < count; p++)
|
|
pieces[p].projectionPrepare();
|
|
|
|
return pieces;
|
|
}
|
|
|
|
public void copyLighting(GameModel model, int srcVs[], int nV, int inF) {
|
|
int dstVs[] = new int[nV];
|
|
for (int inV = 0; inV < nV; inV++) {
|
|
int outV = dstVs[inV] = model.vertexAt(vertexX[srcVs[inV]], vertexY[srcVs[inV]], vertexZ[srcVs[inV]]);
|
|
model.vertexIntensity[outV] = vertexIntensity[srcVs[inV]];
|
|
model.vertexAmbience[outV] = vertexAmbience[srcVs[inV]];
|
|
}
|
|
|
|
int outF = model.createFace(nV, dstVs, faceFillFront[inF], faceFillBack[inF]);
|
|
if (!model.unpickable && !unpickable)
|
|
model.faceTag[outF] = faceTag[inF];
|
|
model.faceIntensity[outF] = faceIntensity[inF];
|
|
model.normalScale[outF] = normalScale[inF];
|
|
model.normalMagnitude[outF] = normalMagnitude[inF];
|
|
}
|
|
|
|
public void setLight(boolean gouraud, int ambient, int diffuse, int x, int y, int z) {
|
|
lightAmbience = 256 - ambient * 4;
|
|
lightDiffuse = (64 - diffuse) * 16 + 128;
|
|
if (unlit)
|
|
return;
|
|
for (int i = 0; i < numFaces; i++)
|
|
if (gouraud)
|
|
faceIntensity[i] = magic;
|
|
else
|
|
faceIntensity[i] = 0;
|
|
|
|
lightDirectionX = x;
|
|
lightDirectionY = y;
|
|
lightDirectionZ = z;
|
|
lightDirectionMagnitude = (int) Math.sqrt(x * x + y * y + z * z);
|
|
light();
|
|
}
|
|
|
|
public void setLight(int ambience, int diffuse, int x, int y, int z) {
|
|
lightAmbience = 256 - ambience * 4;
|
|
lightDiffuse = (64 - diffuse) * 16 + 128;
|
|
if (!unlit) {
|
|
lightDirectionX = x;
|
|
lightDirectionY = y;
|
|
lightDirectionZ = z;
|
|
lightDirectionMagnitude = (int) Math.sqrt(x * x + y * y + z * z);
|
|
light();
|
|
}
|
|
}
|
|
|
|
public void setLight(int x, int y, int z) {
|
|
if (!unlit) {
|
|
lightDirectionX = x;
|
|
lightDirectionY = y;
|
|
lightDirectionZ = z;
|
|
lightDirectionMagnitude = (int) Math.sqrt(x * x + y * y + z * z);
|
|
light();
|
|
}
|
|
}
|
|
|
|
public void setVertexAmbience(int v, int ambience) {
|
|
vertexAmbience[v] = (byte) ambience;
|
|
}
|
|
|
|
public void rotate(int yaw, int pitch, int roll) {
|
|
orientationYaw = orientationYaw + yaw & 0xff;
|
|
orientationPitch = orientationPitch + pitch & 0xff;
|
|
orientationRoll = orientationRoll + roll & 0xff;
|
|
determineTransformKind();
|
|
transformState = 1;
|
|
}
|
|
|
|
public void orient(int yaw, int pitch, int roll) {
|
|
orientationYaw = yaw & 0xff;
|
|
orientationPitch = pitch & 0xff;
|
|
orientationRoll = roll & 0xff;
|
|
determineTransformKind();
|
|
transformState = 1;
|
|
}
|
|
|
|
public void translate(int x, int y, int z) {
|
|
baseX += x;
|
|
baseY += y;
|
|
baseZ += z;
|
|
determineTransformKind();
|
|
transformState = 1;
|
|
}
|
|
|
|
public void place(int x, int y, int z) {
|
|
baseX = x;
|
|
baseY = y;
|
|
baseZ = z;
|
|
determineTransformKind();
|
|
transformState = 1;
|
|
}
|
|
|
|
private void determineTransformKind() {
|
|
if (shearXy != 256 || shearXz != 256 || shearYx != 256 || shearYz != 256 || shearZx != 256 || shearZy != 256) {
|
|
transformKind = 4;
|
|
} else if (scaleFx != 256 || scaleFy != 256 || scaleFz != 256) {
|
|
transformKind = 3;
|
|
} else if (orientationYaw != 0 || orientationPitch != 0 || orientationRoll != 0) {
|
|
transformKind = 2;
|
|
} else if (baseX != 0 || baseY != 0 || baseZ != 0) {
|
|
transformKind = 1;
|
|
} else {
|
|
transformKind = 0;
|
|
}
|
|
}
|
|
|
|
private void applyTranslate(int dx, int dy, int dz) {
|
|
for (int v = 0; v < numVertices; v++) {
|
|
vertexTransformedX[v] += dx;
|
|
vertexTransformedY[v] += dy;
|
|
vertexTransformedZ[v] += dz;
|
|
}
|
|
|
|
}
|
|
|
|
private void applyRotation(int yaw, int roll, int pitch) {
|
|
for (int v = 0; v < numVertices; v++) {
|
|
if (pitch != 0) {
|
|
int sin = sine9[pitch];
|
|
int cos = sine9[pitch + 256];
|
|
int x = vertexTransformedY[v] * sin + vertexTransformedX[v] * cos >> 15;
|
|
vertexTransformedY[v] = vertexTransformedY[v] * cos - vertexTransformedX[v] * sin >> 15;
|
|
vertexTransformedX[v] = x;
|
|
}
|
|
if (yaw != 0) {
|
|
int sin = sine9[yaw];
|
|
int cos = sine9[yaw + 256];
|
|
int y = vertexTransformedY[v] * cos - vertexTransformedZ[v] * sin >> 15;
|
|
vertexTransformedZ[v] = vertexTransformedY[v] * sin + vertexTransformedZ[v] * cos >> 15;
|
|
vertexTransformedY[v] = y;
|
|
}
|
|
if (roll != 0) {
|
|
int sin = sine9[roll];
|
|
int cos = sine9[roll + 256];
|
|
int x = vertexTransformedZ[v] * sin + vertexTransformedX[v] * cos >> 15;
|
|
vertexTransformedZ[v] = vertexTransformedZ[v] * cos - vertexTransformedX[v] * sin >> 15;
|
|
vertexTransformedX[v] = x;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
private void applyShear(int xy, int xz, int yx, int yz, int zx, int zy) {
|
|
for (int idx = 0; idx < numVertices; idx++) {
|
|
if (xy != 0)
|
|
vertexTransformedX[idx] += vertexTransformedY[idx] * xy >> 8;
|
|
if (xz != 0)
|
|
vertexTransformedZ[idx] += vertexTransformedY[idx] * xz >> 8;
|
|
if (yx != 0)
|
|
vertexTransformedX[idx] += vertexTransformedZ[idx] * yx >> 8;
|
|
if (yz != 0)
|
|
vertexTransformedY[idx] += vertexTransformedZ[idx] * yz >> 8;
|
|
if (zx != 0)
|
|
vertexTransformedZ[idx] += vertexTransformedX[idx] * zx >> 8;
|
|
if (zy != 0)
|
|
vertexTransformedY[idx] += vertexTransformedX[idx] * zy >> 8;
|
|
}
|
|
|
|
}
|
|
|
|
private void applyScale(int fx, int fy, int fz) {
|
|
for (int v = 0; v < numVertices; v++) {
|
|
vertexTransformedX[v] = vertexTransformedX[v] * fx >> 8;
|
|
vertexTransformedY[v] = vertexTransformedY[v] * fy >> 8;
|
|
vertexTransformedZ[v] = vertexTransformedZ[v] * fz >> 8;
|
|
}
|
|
|
|
}
|
|
|
|
private void computeBounds() {
|
|
x1 = y1 = z1 = 0xf423f;
|
|
diameter = x2 = y2 = z2 = 0xfff0bdc1;
|
|
for (int face = 0; face < numFaces; face++) {
|
|
int vs[] = faceVertices[face];
|
|
int v = vs[0];
|
|
int n = faceNumVertices[face];
|
|
int x1;
|
|
int x2 = x1 = vertexTransformedX[v];
|
|
int y1;
|
|
int y2 = y1 = vertexTransformedY[v];
|
|
int z1;
|
|
int z2 = z1 = vertexTransformedZ[v];
|
|
for (int i = 0; i < n; i++) {
|
|
v = vs[i];
|
|
if (vertexTransformedX[v] < x1)
|
|
x1 = vertexTransformedX[v];
|
|
else if (vertexTransformedX[v] > x2)
|
|
x2 = vertexTransformedX[v];
|
|
if (vertexTransformedY[v] < y1)
|
|
y1 = vertexTransformedY[v];
|
|
else if (vertexTransformedY[v] > y2)
|
|
y2 = vertexTransformedY[v];
|
|
if (vertexTransformedZ[v] < z1)
|
|
z1 = vertexTransformedZ[v];
|
|
else if (vertexTransformedZ[v] > z2)
|
|
z2 = vertexTransformedZ[v];
|
|
}
|
|
|
|
if (!isolated) {
|
|
faceBoundLeft[face] = x1;
|
|
faceBoundRight[face] = x2;
|
|
faceBoundBottom[face] = y1;
|
|
faceBoundTop[face] = y2;
|
|
faceBoundNear[face] = z1;
|
|
faceBoundFar[face] = z2;
|
|
}
|
|
if (x2 - x1 > diameter)
|
|
diameter = x2 - x1;
|
|
if (y2 - y1 > diameter)
|
|
diameter = y2 - y1;
|
|
if (z2 - z1 > diameter)
|
|
diameter = z2 - z1;
|
|
if (x1 < this.x1)
|
|
this.x1 = x1;
|
|
if (x2 > this.x2)
|
|
this.x2 = x2;
|
|
if (y1 < this.y1)
|
|
this.y1 = y1;
|
|
if (y2 > this.y2)
|
|
this.y2 = y2;
|
|
if (z1 < this.z1)
|
|
this.z1 = z1;
|
|
if (z2 > this.z2)
|
|
this.z2 = z2;
|
|
}
|
|
|
|
}
|
|
|
|
public void light() {
|
|
if (unlit)
|
|
return;
|
|
int divisor = lightDiffuse * lightDirectionMagnitude >> 8;
|
|
for (int face = 0; face < numFaces; face++)
|
|
if (faceIntensity[face] != magic)
|
|
faceIntensity[face] = (faceNormalX[face] * lightDirectionX + faceNormalY[face] * lightDirectionY + faceNormalZ[face] * lightDirectionZ) / divisor;
|
|
|
|
int normalX[] = new int[numVertices];
|
|
int normalY[] = new int[numVertices];
|
|
int normalZ[] = new int[numVertices];
|
|
int normalMagnitude[] = new int[numVertices];
|
|
for (int k = 0; k < numVertices; k++) {
|
|
normalX[k] = 0;
|
|
normalY[k] = 0;
|
|
normalZ[k] = 0;
|
|
normalMagnitude[k] = 0;
|
|
}
|
|
|
|
for (int face = 0; face < numFaces; face++)
|
|
if (faceIntensity[face] == magic) {
|
|
for (int v = 0; v < faceNumVertices[face]; v++) {
|
|
int k1 = faceVertices[face][v];
|
|
normalX[k1] += faceNormalX[face];
|
|
normalY[k1] += faceNormalY[face];
|
|
normalZ[k1] += faceNormalZ[face];
|
|
normalMagnitude[k1]++;
|
|
}
|
|
|
|
}
|
|
|
|
for (int v = 0; v < numVertices; v++)
|
|
if (normalMagnitude[v] > 0)
|
|
vertexIntensity[v] = (normalX[v] * lightDirectionX + normalY[v] * lightDirectionY + normalZ[v] * lightDirectionZ) / (divisor * normalMagnitude[v]);
|
|
|
|
}
|
|
|
|
public void relight() {
|
|
if (unlit && isolated)
|
|
return;
|
|
for (int face = 0; face < numFaces; face++) {
|
|
int verts[] = faceVertices[face];
|
|
int aX = vertexTransformedX[verts[0]];
|
|
int aY = vertexTransformedY[verts[0]];
|
|
int aZ = vertexTransformedZ[verts[0]];
|
|
int bX = vertexTransformedX[verts[1]] - aX;
|
|
int bY = vertexTransformedY[verts[1]] - aY;
|
|
int bZ = vertexTransformedZ[verts[1]] - aZ;
|
|
int cX = vertexTransformedX[verts[2]] - aX;
|
|
int cY = vertexTransformedY[verts[2]] - aY;
|
|
int cZ = vertexTransformedZ[verts[2]] - aZ;
|
|
int normX = bY * cZ - cY * bZ;
|
|
int normY = bZ * cX - cZ * bX;
|
|
int normZ;
|
|
for (normZ = bX * cY - cX * bY; normX > 8192 || normY > 8192 || normZ > 8192 || normX < -8192 || normY < -8192 || normZ < -8192; normZ >>= 1) {
|
|
normX >>= 1;
|
|
normY >>= 1;
|
|
}
|
|
|
|
int normMag = (int) (256D * Math.sqrt(normX * normX + normY * normY + normZ * normZ));
|
|
if (normMag <= 0)
|
|
normMag = 1;
|
|
faceNormalX[face] = (normX * 0x10000) / normMag;
|
|
faceNormalY[face] = (normY * 0x10000) / normMag;
|
|
faceNormalZ[face] = (normZ * 65535) / normMag;
|
|
normalScale[face] = -1;
|
|
}
|
|
|
|
light();
|
|
}
|
|
|
|
public void apply() {
|
|
if (transformState == 2) {
|
|
transformState = 0;
|
|
for (int v = 0; v < numVertices; v++) {
|
|
vertexTransformedX[v] = vertexX[v];
|
|
vertexTransformedY[v] = vertexY[v];
|
|
vertexTransformedZ[v] = vertexZ[v];
|
|
}
|
|
|
|
x1 = y1 = z1 = 0xff676981;
|
|
diameter = x2 = y2 = z2 = 0x98967f;
|
|
return;
|
|
}
|
|
if (transformState == 1) {
|
|
transformState = 0;
|
|
for (int v = 0; v < numVertices; v++) {
|
|
vertexTransformedX[v] = vertexX[v];
|
|
vertexTransformedY[v] = vertexY[v];
|
|
vertexTransformedZ[v] = vertexZ[v];
|
|
}
|
|
|
|
if (transformKind >= 2)
|
|
applyRotation(orientationYaw, orientationPitch, orientationRoll);
|
|
if (transformKind >= 3)
|
|
applyScale(scaleFx, scaleFy, scaleFz);
|
|
if (transformKind >= 4)
|
|
applyShear(shearXy, shearXz, shearYx, shearYz, shearZx, shearZy);
|
|
if (transformKind >= 1)
|
|
applyTranslate(baseX, baseY, baseZ);
|
|
computeBounds();
|
|
relight();
|
|
}
|
|
}
|
|
|
|
public void project(int cameraX, int cameraY, int cameraZ, int cameraPitch, int cameraRoll, int cameraYaw, int viewDist, int clipNear) {
|
|
apply();
|
|
if (z1 > Scene.frustumNearZ || z2 < Scene.furstumFarZ || x1 > Scene.frustumMinX || x2 < Scene.frustumMaxX || y1 > Scene.furstumMinY || y2 < Scene.furstumMaxY) {
|
|
visible = false;
|
|
return;
|
|
}
|
|
visible = true;
|
|
int yawSin = 0;
|
|
int yawCos = 0;
|
|
int pitchSin = 0;
|
|
int pitchCos = 0;
|
|
int rollSin = 0;
|
|
int rollCos = 0;
|
|
if (cameraYaw != 0) {
|
|
yawSin = sine11[cameraYaw];
|
|
yawCos = sine11[cameraYaw + 1024];
|
|
}
|
|
if (cameraRoll != 0) {
|
|
rollSin = sine11[cameraRoll];
|
|
rollCos = sine11[cameraRoll + 1024];
|
|
}
|
|
if (cameraPitch != 0) {
|
|
pitchSin = sine11[cameraPitch];
|
|
pitchCos = sine11[cameraPitch + 1024];
|
|
}
|
|
for (int v = 0; v < numVertices; v++) {
|
|
int x = vertexTransformedX[v] - cameraX;
|
|
int y = vertexTransformedY[v] - cameraY;
|
|
int z = vertexTransformedZ[v] - cameraZ;
|
|
if (cameraYaw != 0) {
|
|
int X = y * yawSin + x * yawCos >> 15;
|
|
y = y * yawCos - x * yawSin >> 15;
|
|
x = X;
|
|
}
|
|
if (cameraRoll != 0) {
|
|
int X = z * rollSin + x * rollCos >> 15;
|
|
z = z * rollCos - x * rollSin >> 15;
|
|
x = X;
|
|
}
|
|
if (cameraPitch != 0) {
|
|
int Y = y * pitchCos - z * pitchSin >> 15;
|
|
z = y * pitchSin + z * pitchCos >> 15;
|
|
y = Y;
|
|
}
|
|
if (z >= clipNear)
|
|
vertexViewX[v] = (x << viewDist) / z;
|
|
else
|
|
vertexViewX[v] = x << viewDist;
|
|
if (z >= clipNear)
|
|
vertexViewY[v] = (y << viewDist) / z;
|
|
else
|
|
vertexViewY[v] = y << viewDist;
|
|
projectVertexX[v] = x;
|
|
projectVertexY[v] = y;
|
|
projectVertexZ[v] = z;
|
|
}
|
|
|
|
}
|
|
|
|
public void commit() {
|
|
apply();
|
|
for (int i = 0; i < numVertices; i++) {
|
|
vertexX[i] = vertexTransformedX[i];
|
|
vertexY[i] = vertexTransformedY[i];
|
|
vertexZ[i] = vertexTransformedZ[i];
|
|
}
|
|
|
|
baseX = baseY = baseZ = 0;
|
|
orientationYaw = orientationPitch = orientationRoll = 0;
|
|
scaleFx = scaleFy = scaleFz = 256;
|
|
shearXy = shearXz = shearYx = shearYz = shearZx = shearZy = 256;
|
|
transformKind = 0;
|
|
}
|
|
|
|
public GameModel copy() {
|
|
GameModel pieces[] = new GameModel[1];
|
|
pieces[0] = this;
|
|
GameModel gameModel = new GameModel(pieces, 1);
|
|
gameModel.depth = depth;
|
|
gameModel.transparent = transparent;
|
|
return gameModel;
|
|
}
|
|
|
|
public GameModel copy(boolean autocommit, boolean isolated, boolean unlit, boolean pickable) {
|
|
GameModel pieces[] = new GameModel[1];
|
|
pieces[0] = this;
|
|
GameModel gameModel = new GameModel(pieces, 1, autocommit, isolated, unlit, pickable);
|
|
gameModel.depth = depth;
|
|
return gameModel;
|
|
}
|
|
|
|
public void copyPosition(GameModel model) {
|
|
orientationYaw = model.orientationYaw;
|
|
orientationPitch = model.orientationPitch;
|
|
orientationRoll = model.orientationRoll;
|
|
baseX = model.baseX;
|
|
baseY = model.baseY;
|
|
baseZ = model.baseZ;
|
|
determineTransformKind();
|
|
transformState = 1;
|
|
}
|
|
|
|
public int readBase64(byte buff[]) {
|
|
for (; buff[dataPtr] == 10 || buff[dataPtr] == 13; dataPtr++) ;
|
|
int hi = base64Alphabet[buff[dataPtr++] & 0xff];
|
|
int mid = base64Alphabet[buff[dataPtr++] & 0xff];
|
|
int lo = base64Alphabet[buff[dataPtr++] & 0xff];
|
|
int val = (hi * 4096 + mid * 64 + lo) - 0x20000;
|
|
if (val == 0x1e240)
|
|
val = magic;
|
|
return val;
|
|
}
|
|
}
|