public int copyPolygon(Polygon p) {
int newP = getFreePolygon();
Polygon np = polygons[newP];
np.length = p.length;
for (int i = 0; i < p.length; i++) {
np.vertices[i] = p.vertices[i];
np.setShader(p.getShader());
np.setCenterZ(p.getCenterZ());
}
return newP;
}
/**
* This helper method assumes that the polygon following the one at polPos is free.
*
* @param polPos the position of the polygon in thepolygons array
* @param index The index to compare --- e.g. Polyggn.SX
* @param sign +/-1 which side of the halfspace.
* @param k the location of the halfspace --- e.g. ClippingBox.x0
*/
private void clipToHalfspace(int polPos, Polygon polygons[], int index, int sign, double k) {
Polygon p = polygons[polPos];
if (p.length == 0) return;
// int vc = vertexCount;
int u = p.vertices[p.length - 1];
int v = p.vertices[0];
double tu = sign * vertexData[u + index] - k * vertexData[u + Polygon.SW];
// sign * vertexData[u + index] / vertexData[u+Polygon.SW] -k;
double tv = 0;
// HERE!!!!!
Polygon newP = polygons[polPos + 1];
newP.length = 0;
for (int i = 0; i < p.length; i++, u = v, tu = tv, v = p.vertices[i]) {
tv = sign * vertexData[v + index] - k * vertexData[v + Polygon.SW];
// sign * vertexData[v + index] / vertexData[v+Polygon.SW] - k;
if (tu <= 0. ^ tv <= 0.) { // edge crosses plane...
double t = tu / (tu - tv);
for (int j = 0; j < Polygon.VERTEX_LENGTH; j++) {
vertexData[vertexCount + j] =
vertexData[u + j] + t * (vertexData[v + j] - vertexData[u + j]);
}
newP.vertices[newP.length++] = vertexCount;
vertexCount += Polygon.VERTEX_LENGTH;
}
if (tv <= 0.) { // vertex v is in ...
// for(int j = 0;j<Polygon.VERTEX_LENGTH;j++) {
// vertexData[vc+j] = vertexData[v+j];
// }
newP.vertices[newP.length++] = v;
// vc+= Polygon.VERTEX_LENGTH;
}
}
// It is left to swap:
int vp[] = p.vertices;
p.vertices = newP.vertices;
p.length = newP.length;
newP.vertices = vp;
}
private final void compute(int verticesLength) {
// boolean isTransparent = shader.getVertexShader().getTransparency() != 0.;
if (polygonCount + 1 >= this.polygons.length) increasePolygonCapacity();
Polygon p = polygons[polygonCount++];
p.length = verticesLength;
// We store the current shader for later shading
p.setShader(shader);
for (int i = 0; i < verticesLength; i++) {
p.vertices[i] = vertexCount;
vertexCount += Polygon.VERTEX_LENGTH;
}
// sky box shaders need the matrix...
environment.setMatrix(matrix);
// ****
shader.shadePolygon(p, vertexData, environment);
int numClip = environment.getNumClippingPlanes();
if (numClip > 0) {
ClippingPlaneSoft[] cp = environment.getClippingPlanes();
// Intersector.dehomogenize(p,vertexData);
for (int k = 0; k < numClip; k++) {
double d = VecMat.dot(cp[k].getNormal(), cp[k].getPoint());
// System.out.println("d "+d);
int res = Intersector.clipToHalfspace(p, cp[k].getNormal(), -1, d, this);
if (res == -1) { // clipped out
p.setShader(null);
vertexCount -= p.length * Polygon.VERTEX_LENGTH;
polygonCount--;
return;
}
}
}
for (int i = 0; i < p.length; i++) {
perspective.perspective(vertexData, p.vertices[i]);
}
boolean clippedAway = clipPolygon();
if (!clippedAway) {
// if (p.length == 0)
// System.out.println("ZEROLENGTH!");
// TODO: check wether we sort before computing this.
// boolean isTransparent = (shader.getVertexShader().getTransparency() !=
// 0.)||shader.hasTexture()||shader.interpolateAlpha();
// shader might have changed after lighting:
boolean isTransparent = p.getShader().needsSorting();
//// isTransparent = false;
if (triangulate) {
PolygonShader ps = p.getShader();
if (polygonCount + 1 >= this.polygons.length) increasePolygonCapacity();
polygonCount--;
for (int i = 0, pl = p.length - 2; i < pl; i++) {
Polygon pi = polygons[polygonCount++];
pi.length = 3;
pi.vertices[0] = p.vertices[0];
pi.vertices[1] = p.vertices[i + 1];
pi.vertices[2] = p.vertices[i + 2];
pi.setShader(ps);
if (queueOpaque || isTransparent) {
if (sortOpaque || isTransparent) pi.computeCenterZ(vertexData);
// pi.computeMaxZ(vertexData);
// return;
} else {
renderer.renderPolygon(pi, vertexData, ps.isOutline());
pi.setShader(null);
// TODO:check wether this is save
// vertexCount -= p.length * Polygon.VERTEX_LENGTH;
polygonCount--;
}
}
return;
} else {
if (queueOpaque || isTransparent) {
if (sortOpaque || isTransparent) p.computeCenterZ(vertexData);
// p.computeMaxZ(vertexData);
return;
} else {
renderer.renderPolygon(p, vertexData, p.getShader().isOutline());
}
}
}
// if the polygon was clipped completely or if the polygon was opaque and therefore
// rendered already, we can free its resources:
p.setShader(null);
vertexCount -= p.length * Polygon.VERTEX_LENGTH;
polygonCount--;
}
