class="kw">package com.hypixel.hytale.builtin.hytalegenerator.bounds;

class="kw">import com.hypixel.hytale.builtin.hytalegenerator.engine.performanceinstruments.MemInstrument;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.math.Calculator;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3dc;
class="kw">import org.joml.Vector3i;

class="kw">public class Bounds3d class="kw">implements MemInstrument {
   @Nonnull
   class="kw">public class="kw">static class="kw">final Bounds3d ZERO = new Bounds3d();
   @Nonnull
   class="kw">public class="kw">static class="kw">final Bounds3d ALL = new Bounds3d(Vector3dUtil.MIN, Vector3dUtil.MAX);
   @Nonnull
   class="kw">public class="kw">final Vector3d min;
   @Nonnull
   class="kw">public class="kw">final Vector3d max;

   class="kw">public Bounds3d() {
      this(Vector3dUtil.ZERO, Vector3dUtil.ZERO);
   }

   class="kw">public Bounds3d(@Nonnull Bounds3d var1) {
      this.min = new Vector3d(var1.min);
      this.max = new Vector3d(var1.max);
   }

   class="kw">public Bounds3d(@Nonnull Vector3dc var1, @Nonnull Vector3dc var2) {
      this.min = new Vector3d(var1);
      this.max = new Vector3d(var2);
      this.correct();
   }

   class="kw">public boolean contains(int var1, int var2, int var3) {
      class="kw">return var1 >= this.min.x && var2 >= this.min.y && var3 >= this.min.z && var1 < this.max.x && var2 < this.max.y && var3 < this.max.z;
   }

   class="kw">public boolean contains(double var1, double var3, double var5) {
      class="kw">return var1 >= this.min.x && var3 >= this.min.y && var5 >= this.min.z && var1 < this.max.x && var3 < this.max.y && var5 < this.max.z;
   }

   class="kw">public boolean contains(@Nonnull Vector3i var1) {
      class="kw">return var1.x >= this.min.x && var1.y >= this.min.y && var1.z >= this.min.z && var1.x < this.max.x && var1.y < this.max.y && var1.z < this.max.z;
   }

   class="kw">public boolean contains(@Nonnull Vector3dc var1) {
      class="kw">return var1.x() >= this.min.x
         && var1.y() >= this.min.y
         && var1.z() >= this.min.z
         && var1.x() < this.max.x
         && var1.y() < this.max.y
         && var1.z() < this.max.z;
   }

   class="kw">public boolean contains(@Nonnull Bounds3d var1) {
      class="kw">return var1.min.x >= this.min.x
         && var1.min.y >= this.min.y
         && var1.min.z >= this.min.z
         && var1.max.x <= this.max.x
         && var1.max.y <= this.max.y
         && var1.max.z <= this.max.z;
   }

   class="kw">public boolean intersects(@Nonnull Bounds3d var1) {
      class="kw">return this.min.x < var1.max.x
         && this.min.y < var1.max.y
         && this.min.z < var1.max.z
         && this.max.x > var1.min.x
         && this.max.y > var1.min.y
         && this.max.z > var1.min.z;
   }

   class="kw">public boolean isZeroVolume() {
      class="kw">return this.min.x >= this.max.x || this.min.y >= this.max.y || this.min.z >= this.max.z;
   }

   @Nonnull
   class="kw">public Vector3d getSize() {
      class="kw">return new Vector3d(this.max).sub(this.min);
   }

   class="kw">public double maxRangeOrthogonal() {
      class="kw">return Calculator.max(Math.abs(this.min.x), Math.abs(this.min.y), Math.abs(this.min.z), Math.abs(this.max.x), Math.abs(this.max.y), Math.abs(this.max.z));
   }

   @Nonnull
   class="kw">public Bounds3d assign(@Nonnull Bounds3d var1) {
      this.min.set(var1.min);
      this.max.set(var1.max);
      this.correct();
      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d assign(@Nonnull Bounds3i var1) {
      this.min.set(var1.min);
      this.max.set(var1.max);
      this.correct();
      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d assign(@Nonnull Vector3d var1, @Nonnull Vector3d var2) {
      this.min.set(var1);
      this.max.set(var2);
      this.correct();
      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d offset(@Nonnull Vector3dc var1) {
      this.min.add(var1);
      this.max.add(var1);
      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d offsetOpposite(@Nonnull Vector3d var1) {
      this.min.sub(var1);
      this.max.sub(var1);
      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d intersect(@Nonnull Bounds3d var1) {
      if (!this.intersects(var1)) {
         this.min.zero();
         this.max.zero();
      }

      this.min.set(Math.max(this.min.x, var1.min.x), Math.max(this.min.y, var1.min.y), Math.max(this.min.z, var1.min.z));
      this.max.set(Math.min(this.max.x, var1.max.x), Math.min(this.max.y, var1.max.y), Math.min(this.max.z, var1.max.z));
      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d encompass(@Nonnull Bounds3d var1) {
      if (var1.isZeroVolume()) {
         class="kw">return this;
      } else if (this.isZeroVolume()) {
         this.min.set(var1.min);
         this.max.set(var1.max);
         class="kw">return this;
      } else {
         this.min.set(Math.min(this.min.x, var1.min.x), Math.min(this.min.y, var1.min.y), Math.min(this.min.z, var1.min.z));
         this.max.set(Math.max(this.max.x, var1.max.x), Math.max(this.max.y, var1.max.y), Math.max(this.max.z, var1.max.z));
         class="kw">return this;
      }
   }

   @Nonnull
   class="kw">public Bounds3d encompass(@Nonnull Vector3d var1) {
      this.min.set(Math.min(this.min.x, var1.x), Math.min(this.min.y, var1.y), Math.min(this.min.z, var1.z));
      this.max.set(Math.max(this.max.x, var1.x), Math.max(this.max.y, var1.y), Math.max(this.max.z, var1.z));
      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d stack(@Nonnull Bounds3d var1) {
      if (!this.isZeroVolume() && !var1.isZeroVolume()) {
         Vector3d var2 = new Vector3d(this.max);
         Bounds3d var3 = var1.clone();
         var3.offset(this.min);
         this.encompass(var3);
         var3 = var1.clone();
         var3.offset(var2);
         this.encompass(var3);
         class="kw">return this;
      } else {
         class="kw">return this;
      }
   }

   @Nonnull
   class="kw">public Bounds3d stackOrAssign(@Nonnull Bounds3d var1) {
      if (this.isZeroVolume()) {
         this.assign(var1);
      } else {
         this.stack(var1);
      }

      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d expand(double var1) {
      this.correct();
      this.min.add(-var1, -var1, -var1);
      this.max.add(var1, var1, var1);
      if (var1 < 0.0) {
         this.correct();
      }

      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d flipOnOriginPoint() {
      if (this.isZeroVolume()) {
         class="kw">return this;
      }

      Vector3d var1 = new Vector3d(this.min);
      this.min.set(this.max);
      this.min.mul(-1.0);
      this.max.set(var1);
      this.max.mul(-1.0);
      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d flipOnOriginVoxel() {
      if (this.isZeroVolume()) {
         class="kw">return this;
      }

      Vector3d var1 = new Vector3d(this.min);
      this.min.set(Vector3dUtil.ALL_ONES);
      this.min.sub(this.max);
      this.max.set(Vector3dUtil.ALL_ONES);
      this.max.sub(var1);
      class="kw">return this;
   }

   class="kw">public Bounds3d applyRotation(@Nonnull RotationTuple var1, @Nonnull Vector3d var2) {
      if (this.isZeroVolume()) {
         class="kw">return this;
      }

      this.min.sub(var2);
      var1.applyRotationTo(this.min);
      this.min.add(var2);
      this.max.sub(var2);
      var1.applyRotationTo(this.max);
      this.max.add(var2);
      this.correct();
      class="kw">return this;
   }

   class="kw">public Bounds3d undoRotation(@Nonnull RotationTuple var1, @Nonnull Vector3d var2) {
      if (this.isZeroVolume()) {
         class="kw">return this;
      }

      this.min.sub(var2);
      var1.undoRotationTo(this.min);
      this.min.add(var2);
      this.max.sub(var2);
      var1.undoRotationTo(this.max);
      this.max.add(var2);
      this.correct();
      class="kw">return this;
   }

   @Nonnull
   class="kw">public Bounds3d clone() {
      class="kw">return new Bounds3d(new Vector3d(this.min), new Vector3d(this.max));
   }

   class="kw">public boolean isCorrect() {
      class="kw">return this.min.x <= this.max.x && this.min.y <= this.max.y && this.min.z <= this.max.z;
   }

   class="kw">public void correct() {
      Vector3d var1 = new Vector3d(this.min);
      this.min.set(Math.min(this.max.x, this.min.x), Math.min(this.max.y, this.min.y), Math.min(this.max.z, this.min.z));
      this.max.set(Math.max(var1.x, this.max.x), Math.max(var1.y, this.max.y), Math.max(var1.z, this.max.z));
   }

   @Nonnull
   @Override
   class="kw">public MemInstrument.Report getMemoryUsage() {
      long var1 = 40L;
      class="kw">return new MemInstrument.Report(40L);
   }
}