class="kw">package com.hypixel.hytale.math.hitdetection;

class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.shape.Quad4d;
class="kw">import com.hypixel.hytale.math.shape.Triangle4d;
class="kw">import com.hypixel.hytale.math.vector.Vector4dUtil;
class="kw">import java.util.Arrays;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Matrix4d;
class="kw">import org.joml.Vector4d;

class="kw">public class HitDetectionExecutor {
   class="kw">public class="kw">static class="kw">final HytaleLogger log = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static class="kw">final Vector4d[] VERTEX_POINTS = new Vector4d[]{
      new Vector4d(0.0, 1.0, 1.0, 1.0),
      new Vector4d(0.0, 1.0, 0.0, 1.0),
      new Vector4d(1.0, 1.0, 1.0, 1.0),
      new Vector4d(1.0, 1.0, 0.0, 1.0),
      new Vector4d(0.0, 0.0, 1.0, 1.0),
      new Vector4d(0.0, 0.0, 0.0, 1.0),
      new Vector4d(1.0, 0.0, 1.0, 1.0),
      new Vector4d(1.0, 0.0, 0.0, 1.0)
   };
   class="kw">public class="kw">static class="kw">final Quad4d[] CUBE_QUADS = new Quad4d[]{
      new Quad4d(VERTEX_POINTS, 0, 1, 3, 2),
      new Quad4d(VERTEX_POINTS, 0, 4, 5, 1),
      new Quad4d(VERTEX_POINTS, 4, 5, 7, 6),
      new Quad4d(VERTEX_POINTS, 2, 3, 7, 6),
      new Quad4d(VERTEX_POINTS, 1, 3, 7, 5),
      new Quad4d(VERTEX_POINTS, 0, 2, 6, 4)
   };
   @Nonnull
   class="kw">private class="kw">final Matrix4d pvmMatrix = new Matrix4d();
   @Nonnull
   class="kw">private class="kw">final Matrix4d invPvMatrix = new Matrix4d();
   @Nonnull
   class="kw">private class="kw">final Vector4d origin = new Vector4d().zero();
   @Nonnull
   class="kw">private class="kw">final HitDetectionBuffer buffer = new HitDetectionBuffer();
   class="kw">private MatrixProvider projectionProvider;
   class="kw">private MatrixProvider viewProvider;
   class="kw">private LineOfSightProvider losProvider = LineOfSightProvider.DEFAULT_TRUE;
   class="kw">private int maxRayTests = 10;

   class="kw">public HitDetectionExecutor() {
   }

   class="kw">public Vector4d getHitLocation() {
      class="kw">return this.buffer.hitPosition;
   }

   @Nonnull
   class="kw">public HitDetectionExecutor setProjectionProvider(MatrixProvider var1) {
      this.projectionProvider = var1;
      class="kw">return this;
   }

   @Nonnull
   class="kw">public HitDetectionExecutor setViewProvider(MatrixProvider var1) {
      this.viewProvider = var1;
      class="kw">return this;
   }

   @Nonnull
   class="kw">public HitDetectionExecutor setLineOfSightProvider(LineOfSightProvider var1) {
      this.losProvider = var1;
      class="kw">return this;
   }

   @Nonnull
   class="kw">public HitDetectionExecutor setMaxRayTests(int var1) {
      this.maxRayTests = var1;
      class="kw">return this;
   }

   @Nonnull
   class="kw">public HitDetectionExecutor setOrigin(double var1, double var3, double var5) {
      this.origin.set(var1, var3, var5, 1.0);
      class="kw">return this;
   }

   class="kw">private void setupMatrices(@Nonnull Matrix4d var1) {
      Matrix4d var2 = this.projectionProvider.getMatrix();
      Matrix4d var3 = this.viewProvider.getMatrix();
      this.pvmMatrix.set(var2).mul(var3);
      this.invPvMatrix.set(this.pvmMatrix).invert();
      this.pvmMatrix.mul(var1);
   }

   class="kw">public boolean test(@Nonnull Vector4d var1, @Nonnull Matrix4d var2) {
      this.setupMatrices(var2);
      class="kw">return this.testPoint(var1);
   }

   class="kw">public boolean test(@Nonnull Quad4d[] var1, @Nonnull Matrix4d var2) {
      try {
         this.setupMatrices(var2);
         class="kw">return this.testModel(var1);
      } catch (Throwable var4) {
         ((HytaleLogger.Api)log.at(Level.SEVERE).withCause(var4)).log("Error occured during Hit Detection execution. Dumping parameters!");
         log.at(Level.SEVERE).log("this = %s", this);
         log.at(Level.SEVERE).log("model = %s", Arrays.toString(var1));
         log.at(Level.SEVERE).log("modelMatrix = %s", var2);
         log.at(Level.SEVERE).log("thread = %s", Thread.currentThread().getName());
         throw var4;
      }
   }

   class="kw">private boolean testPoint(@Nonnull Vector4d var1) {
      this.pvmMatrix.transform(var1, this.buffer.transformedPoint);
      if (!Vector4dUtil.isInsideFrustum(this.buffer.transformedPoint)) {
         class="kw">return false;
      }

      Vector4d var2 = this.buffer.transformedPoint;
      this.invPvMatrix.transform(var2);
      Vector4dUtil.perspectiveTransform(var2);
      class="kw">return this.losProvider.test(this.origin.x, this.origin.y, this.origin.z, var2.x, var2.y, var2.z);
   }

   class="kw">private boolean testModel(@Nonnull Quad4d[] var1) {
      int var2 = 0;
      double var3 = Double.POSITIVE_INFINITY;

      for (Quad4d var8 : var1) {
         if (var2++ == this.maxRayTests) {
            class="kw">return false;
         }

         var8.multiply(this.pvmMatrix, this.buffer.transformedQuad);
         if (this.insideFrustum()) {
            Vector4d var9 = this.buffer.tempHitPosition;
            if (this.buffer.containsFully) {
               this.buffer.transformedQuad.getRandom(this.buffer.random, var9);
            } else {
               this.buffer.visibleTriangle.getRandom(this.buffer.random, var9);
            }

            this.invPvMatrix.transform(var9);
            Vector4dUtil.perspectiveTransform(var9);
            double var10 = this.origin.x - var9.x;
            double var12 = this.origin.y - var9.y;
            double var14 = this.origin.z - var9.z;
            double var16 = var10 * var10 + var12 * var12 + var14 * var14;
            if (!(var16 >= var3) && this.losProvider.test(this.origin.x, this.origin.y, this.origin.z, var9.x, var9.y, var9.z)) {
               var3 = var16;
               this.buffer.hitPosition.set(var9);
            }
         }
      }

      class="kw">return var3 != Double.POSITIVE_INFINITY;
   }

   class="kw">protected boolean insideFrustum() {
      Quad4d var1 = this.buffer.transformedQuad;
      if (var1.isFullyInsideFrustum()) {
         this.buffer.containsFully = true;
         class="kw">return true;
      }

      this.buffer.containsFully = false;
      Vector4dBufferList var2 = this.buffer.vertexList1;
      Vector4dBufferList var3 = this.buffer.vertexList2;
      var2.clear();
      var3.clear();
      var2.next().set(var1.getA());
      var2.next().set(var1.getB());
      var2.next().set(var1.getC());
      var2.next().set(var1.getD());
      if (this.clipPolygonAxis(0) && this.clipPolygonAxis(1) && this.clipPolygonAxis(2)) {
         Vector4d var4 = var2.get(0);
         int var5 = 1;
         if (var5 < var2.size() - 1) {
            Triangle4d var6 = this.buffer.visibleTriangle;
            var6.assign(var4, var2.get(var5), var2.get(var5 + 1));
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   class="kw">private boolean clipPolygonAxis(int var1) {
      clipPolygonComponent(this.buffer.vertexList1, var1, 1.0, this.buffer.vertexList2);
      this.buffer.vertexList1.clear();
      if (this.buffer.vertexList2.isEmpty()) {
         class="kw">return false;
      }

      clipPolygonComponent(this.buffer.vertexList2, var1, -1.0, this.buffer.vertexList1);
      this.buffer.vertexList2.clear();
      class="kw">return !this.buffer.vertexList1.isEmpty();
   }

   class="kw">private class="kw">static void clipPolygonComponent(@Nonnull Vector4dBufferList var0, int var1, double var2, @Nonnull Vector4dBufferList var4) {
      Vector4d var5 = var0.get(var0.size() - 1);
      double var6 = var5.get(var1) * var2;
      boolean var8 = var6 <= var5.w;

      for (int var9 = 0; var9 < var0.size(); var9++) {
         Vector4d var10 = var0.get(var9);
         double var11 = var10.get(var1) * var2;
         boolean var13 = var11 <= var10.w;
         if (var13 ^ var8) {
            double var14 = (var5.w - var6) / (var5.w - var6 - (var10.w - var11));
            var5.lerp(var10, var14, var4.next());
         }

         if (var13) {
            var4.next().set(var10);
         }

         var5 = var10;
         var6 = var11;
         var8 = var13;
      }
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "HitDetectionExecutor{pvmMatrix="
         + this.pvmMatrix
         + ", invPvMatrix="
         + this.invPvMatrix
         + ", origin="
         + this.origin
         + ", buffer="
         + this.buffer
         + ", projectionProvider="
         + this.projectionProvider
         + ", viewProvider="
         + this.viewProvider
         + ", losProvider="
         + this.losProvider
         + ", maxRayTests="
         + this.maxRayTests
         + "}";
   }
}