import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.Polygon;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

class Triangle implements Comparable<Triangle> {

public Color color;

Point[] points = new Point[3];

Pixel[] pixels;

public Triangle(Point p1, Point p2, Point p3, ArrayList<Pixel> data) {

pixels = new Pixel[data.size()];

points[0] = new Point(p1.GetExX(), p1.GetExY(), p1.GetExZ());

points[1] = new Point(p2.GetExX(), p2.GetExY(), p2.GetExZ());

points[2] = new Point(p3.GetExX(), p3.GetExY(), p3.GetExZ());

for (int i = 0; i < data.size(); i++)

pixels[i] = Pixel.Copy(data.get(i));

}

public Triangle(Point p1, Point p2, Point p3, Color c) {

pixels = null;

points[0] = new Point(p1.GetExX(), p1.GetExY(), p1.GetExZ());

points[1] = new Point(p2.GetExX(), p2.GetExY(), p2.GetExZ());

points[2] = new Point(p3.GetExX(), p3.GetExY(), p3.GetExZ());

color = c;

}

public Triangle(Triangle triangle) {

for (int i = 0; i < 3; i++) {

this.points[i] = new Point(triangle.points[i].GetExX(), triangle.points[i].GetExY(),

triangle.points[i].GetExZ());

}

if (triangle.pixels != null) {

for (int i = 0; i < triangle.pixels.length; i++) {

this.pixels[i] = Pixel.Copy(triangle.pixels[i]);

}

} else {

color = triangle.color;

pixels = null;

}

}

public void Print_Info() {

for (Point p : points) {

System.out.println(p.GetExX() + " " + p.GetExY() + " " + p.GetExZ());

}

}

public boolean Should_Be_Drawn() {

Point p = Util.GetNormalVector(points[0], points[1], points[2]);

double dotproduct = Util.GetDotProduct(p, World.camera.GetDirection());

boolean draw = dotproduct < 0 ? true : false;

return draw;

}

public void RotateCounterClockwiseAboutYAxis(Point p, float degrees) {

for (Point p1 : points)

p1.RotateCounterClockwiseAboutYAxis(p, degrees);

if (pixels != null)

for (Pixel p2 : pixels)

p2.RotateCounterClockwiseAboutYAxis(p, degrees);

}

public void RotateClockwiseAboutYAxis(Point p, float degrees) {

for (Point p1 : points)

p1.RotateClockwiseAboutYAxis(p, degrees);

if (pixels != null)

for (Pixel p2 : pixels)

p2.RotateClockwiseAboutYAxis(p, degrees);

}

public void RotateCounterClockwiseAboutXAxis(Point p, float degrees) {

for (Point p1 : points)

p1.RotateCounterClockwiseAboutXAxis(p, degrees);

if (pixels != null)

for (Pixel p2 : pixels)

p2.RotateCounterClockwiseAboutXAxis(p, degrees);

}

public void RotateClockwiseAboutXAxis(Point p, float degrees) {

for (Point p1 : points)

p1.RotateClockwiseAboutXAxis(p, degrees);

if (pixels != null)

for (Pixel p2 : pixels)

p2.RotateClockwiseAboutXAxis(p, degrees);

}

public void RotateCounterClockwiseAboutZAxis(Point p, float degrees) {

for (Point p1 : points)

p1.RotateCounterClockwiseAboutZAxis(p, degrees);

if (pixels != null)

for (Pixel p2 : pixels)

p2.RotateCounterClockwiseAboutZAxis(p, degrees);

}

public void RotateClockwiseAboutZAxis(Point p, float degrees) {

for (Point p1 : points)

p1.RotateClockwiseAboutZAxis(p, degrees);

if (pixels != null)

for (Pixel p2 : pixels)

p2.RotateClockwiseAboutZAxis(p, degrees);

}

public void Resize(float scaleFactor) {

for (Point p : points) {

p.SetX(p.GetExX() * scaleFactor);

p.SetY(p.GetExY() * scaleFactor);

p.SetZ(p.GetExZ() * scaleFactor);

}

}

public Point GetCenter() {

double x = (points[0].GetExX() + points[1].GetExX() + points[2].GetExX()) / 3.0;

double y = (points[0].GetExY() + points[1].GetExY() + points[2].GetExY()) / 3.0;

double z = (points[0].GetExZ() + points[1].GetExZ() + points[2].GetExZ()) / 3.0;

return new Point(x, y, z);

}

public void Render(BufferedImage image) {

if (Should_Be_Drawn()) {

if (pixels != null) {

for (int i = 0; i < pixels.length; i++) {

Point p = World.camera.LookAt(pixels[i]);

if (p != null) {

if (p.GetX() > -640 && p.GetX() < 640 && p.GetY() > -500 && p.GetY() < 500) {

if (World.distancefromscreen[(int) Math.round(p.GetExX())

+ 640][(int) Math.round(p.GetExY()) + 500] > p.GetExZ()) {

image.setRGB((int) Math.round(p.GetExX()) + 640, (int) Math.round(p.GetExY()) + 500,

pixels[i].GetColor());

World.distancefromscreen[(int) Math.round(p.GetExX())

+ 640][(int) Math.round(p.GetExY()) + 500] = p.GetExZ();

}

}

}

}

} else {

Graphics2D g = image.createGraphics();

g.setColor(color);

int[] x = new int[3];

int[] y = new int[3];

Triangle t = World.camera.LookAt(this);

if (t != null && t.GetCenter().GetExZ() >= World.camera.GetLocation().GetExZ()) {

for (int i = 0; i < 3; i++) {

x[i] = t.points[i].GetX() + 640;

y[i] = t.points[i].GetY() + 500;

}

Polygon poly = new Polygon(x, y, 3);

g.fillPolygon(poly);

}

}

}

}

public void Draw_Mesh(BufferedImage buf) {

if (Should_Be_Drawn()) {

Graphics2D g = buf.createGraphics();

g.setColor(color);

Triangle t = World.camera.LookAt(this);

if (t != null) {

g.drawLine(t.points[0].GetX() + 640, t.points[0].GetY() + 500, t.points[1].GetX() + 640,

t.points[1].GetY() + 500);

g.drawLine(t.points[1].GetX() + 640, t.points[1].GetY() + 500, t.points[2].GetX() + 640,

t.points[2].GetY() + 500);

g.drawLine(t.points[0].GetX() + 640, t.points[0].GetY() + 500, t.points[2].GetX() + 640,

t.points[2].GetY() + 500);

}

}

}

public int GreatestX() {

int gx = -10000;

for (Point p : points)

if (p.GetExX() > gx)

gx = p.GetX();

return gx;

}

public int LeastX() {

int lx = 10000;

for (Point p : points)

if (p.GetExX() < lx)

lx = p.GetX();

return lx;

}

public int GreatestY() {

int gy = -10000;

for (Point p : points)

if (p.GetExY() > gy)

gy = p.GetY();

return gy;

}

public int LeastY() {

int ly = 10000;

for (Point p : points)

if (p.GetExY() < ly)

ly = p.GetY();

return ly;

}

@Override

public int compareTo(Triangle t) {

if (this.GetCenter().GetExZ() <= t.GetCenter().GetExZ()) {

return 1;

} else if (this.GetCenter().GetExZ() > t.GetCenter().GetExZ()) {

return -1;

} else {

return 0;

}

}

}