Refactoring to remove unneeded complexity.

[sixth-3d.git] / src / main / java / eu / svjatoslav / sixth / e3d / renderer / raster / shapes / basic / texturedpolygon / TexturedPolygon.java

diff --git a/src/main/java/eu/svjatoslav/sixth/e3d/renderer/raster/shapes/basic/texturedpolygon/TexturedPolygon.java b/src/main/java/eu/svjatoslav/sixth/e3d/renderer/raster/shapes/basic/texturedpolygon/TexturedPolygon.java
index 889acda..85760f5 100644 (file)
--- a/src/main/java/eu/svjatoslav/sixth/e3d/renderer/raster/shapes/basic/texturedpolygon/TexturedPolygon.java
+++ b/src/main/java/eu/svjatoslav/sixth/e3d/renderer/raster/shapes/basic/texturedpolygon/TexturedPolygon.java
@@ -1,60 +1,55 @@
 /*
- * Sixth 3D engine. Author: Svjatoslav Agejenko. 
+ * Sixth 3D engine. Author: Svjatoslav Agejenko.
  * This project is released under Creative Commons Zero (CC0) license.
  */
 package eu.svjatoslav.sixth.e3d.renderer.raster.shapes.basic.texturedpolygon;
 
 import eu.svjatoslav.sixth.e3d.geometry.Point2D;
-import eu.svjatoslav.sixth.e3d.geometry.Point3D;
 import eu.svjatoslav.sixth.e3d.gui.RenderingContext;
+import eu.svjatoslav.sixth.e3d.math.Vertex;
 import eu.svjatoslav.sixth.e3d.renderer.raster.shapes.AbstractCoordinateShape;
-import eu.svjatoslav.sixth.e3d.renderer.raster.slicer.PolygonCoordinate;
 import eu.svjatoslav.sixth.e3d.renderer.raster.texture.Texture;
 import eu.svjatoslav.sixth.e3d.renderer.raster.texture.TextureBitmap;
 
 import java.awt.*;
 
 import static eu.svjatoslav.sixth.e3d.geometry.Polygon.pointWithinPolygon;
+import static java.util.Arrays.sort;
+
+/**
+ * Textured polygon.
+ * <p>
+ *
+ * <pre>
+ * This is how perspective-correct texture rendering is implemented:
+ * If polygon is sufficiently small, it is rendered without perspective correction.
+ * Otherwise, it is sliced into smaller polygons.
+ * </pre>
+ */
 
 public class TexturedPolygon extends AbstractCoordinateShape {
 
     public final Texture texture;
-    final PolygonBorderInterpolator[] is = new PolygonBorderInterpolator[]{
-            new PolygonBorderInterpolator(), new PolygonBorderInterpolator(),
-            new PolygonBorderInterpolator()};
+
     /**
-     * Polygon texture coordinates.
+     * If <code>true</code> then polygon borders will be drawn.
+     * It is used for debugging purposes.
      */
-    public Point2D texturePoint1, texturePoint2, texturePoint3;
-    private boolean showBorders = false;
+    public boolean showBorders = false;
+
     private double totalTextureDistance = -1;
 
-    public TexturedPolygon(final Point3D p1, final Point3D p2,
-                           final Point3D p3, final Point2D tp1, final Point2D tp2,
-                           final Point2D tp3, final Texture texture) {
+    public TexturedPolygon(Vertex p1, Vertex p2, Vertex p3, final Texture texture) {
 
         super(p1, p2, p3);
-
-        texturePoint1 = tp1;
-        texturePoint2 = tp2;
-        texturePoint3 = tp3;
-
         this.texture = texture;
     }
 
-    public TexturedPolygon(final PolygonCoordinate pc1,
-                           final PolygonCoordinate pc2, final PolygonCoordinate pc3,
-                           final Texture texture) {
-
-        this(pc1.space, pc2.space, pc3.space, pc1.texture, pc2.texture,
-                pc3.texture, texture);
-    }
-
     private void computeTotalTextureDistance() {
         // compute total texture distance
-        totalTextureDistance = texturePoint1.getDistanceTo(texturePoint2);
-        totalTextureDistance += texturePoint1.getDistanceTo(texturePoint3);
-        totalTextureDistance += texturePoint2.getDistanceTo(texturePoint3);
+        totalTextureDistance = coordinates[0].textureCoordinate.getDistanceTo(coordinates[1].textureCoordinate);
+        totalTextureDistance += coordinates[0].textureCoordinate.getDistanceTo(coordinates[2].textureCoordinate);
+        totalTextureDistance += coordinates[1].textureCoordinate.getDistanceTo(coordinates[2].textureCoordinate);
     }
 
     private void drawHorizontalLine(final PolygonBorderInterpolator line1,
@@ -140,7 +135,7 @@ public class TexturedPolygon extends AbstractCoordinateShape {
                 if (pointWithinPolygon(
                         renderBuffer.getMouseEvent().coordinate, projectedPoint1,
                         projectedPoint2, projectedPoint3))
-                    renderBuffer.setObjectUnderMouse(mouseInteractionController);
+                    renderBuffer.setCurrentObjectUnderMouseCursor(mouseInteractionController);
 
         // Show polygon boundaries (for debugging)
         if (showBorders)
@@ -171,8 +166,7 @@ public class TexturedPolygon extends AbstractCoordinateShape {
             yBottom = renderBuffer.height - 1;
 
         // paint
-        double totalVisibleDistance = projectedPoint1
-                .getDistanceTo(projectedPoint2);
+        double totalVisibleDistance = projectedPoint1.getDistanceTo(projectedPoint2);
         totalVisibleDistance += projectedPoint1.getDistanceTo(projectedPoint3);
         totalVisibleDistance += projectedPoint2.getDistanceTo(projectedPoint3);
 
@@ -182,14 +176,21 @@ public class TexturedPolygon extends AbstractCoordinateShape {
 
         final TextureBitmap zoomedBitmap = texture.getZoomedBitmap(scaleFactor);
 
-        is[0].setPoints(projectedPoint1, projectedPoint2, texturePoint1,
-                texturePoint2);
-        is[1].setPoints(projectedPoint1, projectedPoint3, texturePoint1,
-                texturePoint3);
-        is[2].setPoints(projectedPoint2, projectedPoint3, texturePoint2,
-                texturePoint3);
-
-        java.util.Arrays.sort(is);
+        final PolygonBorderInterpolator[] is = new PolygonBorderInterpolator[]{
+                new PolygonBorderInterpolator(), new PolygonBorderInterpolator(),
+                new PolygonBorderInterpolator()};
+
+        is[0].setPoints(projectedPoint1, projectedPoint2,
+                coordinates[0].textureCoordinate,
+                coordinates[1].textureCoordinate);
+        is[1].setPoints(projectedPoint1, projectedPoint3,
+                coordinates[0].textureCoordinate,
+                coordinates[2].textureCoordinate);
+        is[2].setPoints(projectedPoint2, projectedPoint3,
+                coordinates[1].textureCoordinate,
+                coordinates[2].textureCoordinate);
+
+        sort(is);
 
         for (int y = yTop; y < yBottom; y++)
             if (is[0].containsY(y)) {