public static TexturedPolygon newTexturedPolygon(Texture texture, Vector... vectors) {
TexturedPolygon texturedPolygon = TexturedPolygonImpl.newInstance(texture, vectors);
if (vectors.length >= 2) {
if (texture instanceof ShadedTexture) {
ShadedTexture shadedTexture = ShadedTexture.class.cast(texture);
List<PointLight> pointLights = new ArrayList<>();
Vector normal = texturedPolygon.getNormal();
Vector location = null;
double x = normal.getX();
double y = normal.getY() + 500.0D;
double z = normal.getZ();
double distanceFalloff = 2500.0D;
Color intensity = Color.white();
location = Vector.newInstance(x, y, z);
PointLight pointLight = PointLight.newInstance();
pointLight.setLocation(location);
pointLight.setIntensity(intensity);
pointLight.setDistanceFalloff(distanceFalloff);
pointLights.add(pointLight);
Color ambientLightIntensity = Color.valueOf(0xFF333333);
ShadedSurfaceTexture.createShadedSurfaceTexture(
texturedPolygon,
shadedTexture,
pointLights,
new ArrayList<Polygon>(),
ambientLightIntensity);
} else {
Vector origin = vectors[0];
Vector v = vectors[1].copy();
Vector normal = texturedPolygon.getNormal();
v.subtract(origin);
Vector u = Vector.toCrossProduct(normal, v);
BoundingBox boundingBox = texturedPolygon.getTextureBounds();
boundingBox.setOrigin(origin);
boundingBox.setU(u);
boundingBox.setV(v);
}
}
return texturedPolygon;
}
@Override
public final void clip(double z) {
boolean isCompletelyHidden = true;
int vectorCount = vectors.size();
for (int i = 0; i < vectorCount; i++) {
int next = (i + 1) % vectorCount;
Vector vector1 = vectors.get(i);
Vector vector2 = vectors.get(next);
Vector vector3 = null;
if (vector1.getZ() < z) {
isCompletelyHidden = false;
}
if (vector1.getZ() > vector2.getZ()) {
vector3 = vector1;
vector1 = vector2;
vector2 = vector3;
}
if (vector1.getZ() < z && vector2.getZ() > z) {
double scale = (z - vector1.getZ()) / (vector2.getZ() - vector1.getZ());
vectors.add(
next,
Vector.newInstance(
vector1.getX() + scale * (vector2.getX() - vector1.getX()),
vector1.getY() + scale * (vector2.getY() - vector1.getY()),
z));
vectorCount++;
}
}
if (isCompletelyHidden) {
return;
}
for (int i = vectorCount - 1; i >= 0; i--) {
if (vectors.get(i).getZ() > z) {
vectors.remove(i);
}
}
}
private double doGetIntersectionForTriangle(Ray ray, Vector a, Vector b, Vector c) {
Vector direction = ray.getDirection();
Vector edge1 = Vector.copyAndSubtract(b, a);
Vector edge2 = Vector.copyAndSubtract(c, a);
Vector p = Vector.toCrossProduct(direction, edge2);
double determinant = edge1.getDotProduct(p);
if (determinant == 0.0D) {
return -1.0D;
}
double inverseDeterminant = 1.0D / determinant;
Vector origin = Vector.newInstance(ray.getOrigin());
Vector vector = Vector.copyAndSubtract(origin, a);
double u = vector.getDotProduct(p) * inverseDeterminant;
if (u < 0.0D || u > 1.0D) {
return -1.0D;
}
Vector q = Vector.toCrossProduct(vector, edge1);
double v = direction.getDotProduct(q) * inverseDeterminant;
if (v < 0.0D || u + v > 1.0D) {
return -1.0D;
}
double t = edge2.getDotProduct(q) * inverseDeterminant;
if (t > EPSILON) {
return t;
} else {
return -1.0D;
}
}
@Override
public final BoundingBox getBounds() {
BoundingBox boundingBox = BoundingBox.newInstance();
double minimum = Double.MAX_VALUE;
Vector u = Vector.newInstance(0.0D, 0.0D, 0.0D);
Vector v;
Vector d = Vector.newInstance(0.0D, 0.0D, 0.0D);
int size = vectors.size();
for (int i = 0; i < size; i++) {
Vector vector1 = vectors.get((i + 1) % size);
Vector vector2 = vectors.get(i);
u.set(vector1);
u.subtract(vector2);
u.normalize();
v = Vector.toCrossProduct(getNormal(), u);
v.normalize();
double uMaximum = 0.0D;
double uMinimum = 0.0D;
double vMaximum = 0.0D;
double vMinimum = 0.0D;
for (int j = 0; j < size; j++) {
if (i != j) {
Vector vector3 = vectors.get(j);
d.set(vector3);
d.subtract(vector2);
double uLength = d.getDotProduct(u);
double vLength = d.getDotProduct(v);
uMaximum = Math.max(uLength, uMaximum);
uMinimum = Math.min(uLength, uMinimum);
vMaximum = Math.max(vLength, vMaximum);
vMinimum = Math.min(vLength, vMinimum);
}
}
double current = (uMaximum - uMinimum) * (vMaximum - vMinimum);
if (current < minimum) {
minimum = current;
Vector origin = boundingBox.getOrigin();
origin.set(vector2);
d.set(u);
d.multiply(uMinimum);
origin.add(d);
d.set(v);
d.multiply(vMinimum);
origin.add(d);
boundingBox.getU().set(u);
boundingBox.getV().set(v);
boundingBox.setHeight(vMaximum - vMinimum);
boundingBox.setWidth(uMaximum - uMinimum);
}
}
return boundingBox;
}
