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.Vector3iUtil;
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.Vector3i;
class="kw">import org.joml.Vector3ic;

class="kw">public class Bounds3i class="kw">implements MemInstrument {
   @Nonnull
   class="kw">public class="kw">static class="kw">final Bounds3i ZERO = new Bounds3i();
   @Nonnull
   class="kw">public class="kw">final Vector3i min;
   @Nonnull
   class="kw">public class="kw">final Vector3i max;

   class="kw">public Bounds3i() {
      this(Vector3iUtil.ZERO, Vector3iUtil.ZERO);
   }

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

   class="kw">public Bounds3i(@Nonnull Vector3ic var1, @Nonnull Vector3ic var2) {
      this.min = new Vector3i(var1);
      this.max = new Vector3i(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 Vector3d 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 Bounds3i 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 Bounds3i 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 Vector3i getSize() {
      class="kw">return new Vector3i(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 Bounds3i assign(@Nonnull Bounds3i var1) {
      this.min.set(var1.min);
      this.max.set(var1.max);
      this.correct();
      class="kw">return this;
   }

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

   @Nonnull
   class="kw">public Bounds3i offset(int var1, int var2, int var3) {
      this.min.add(var1, var2, var3);
      this.max.add(var1, var2, var3);
      class="kw">return this;
   }

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

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

   @Nonnull
   class="kw">public Bounds3i intersect(@Nonnull Bounds3i var1) {
      if (!this.intersects(var1)) {
         this.min.set(Vector3iUtil.ZERO);
         this.max.set(Vector3iUtil.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 Bounds3i encompass(@Nonnull Bounds3i 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 Bounds3i encompass(@Nonnull Vector3ic 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() + 1), Math.max(this.max.y, var1.y() + 1), Math.max(this.max.z, var1.z() + 1));
      class="kw">return this;
   }

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

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

      class="kw">return this;
   }

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

      class="kw">return this;
   }

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

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

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

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

   class="kw">public Bounds3i applyRotationAroundVoxel(@Nonnull RotationTuple var1, @Nonnull Vector3ic var2) {
      if (this.isZeroVolume()) {
         class="kw">return this;
      }

      this.max.sub(Vector3iUtil.ALL_ONES);
      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();
      this.max.add(Vector3iUtil.ALL_ONES);
      class="kw">return this;
   }

   class="kw">public Bounds3i undoRotationAroundVoxel(@Nonnull RotationTuple var1, @Nonnull Vector3ic var2) {
      if (this.isZeroVolume()) {
         class="kw">return this;
      }

      this.max.sub(Vector3iUtil.ALL_ONES);
      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();
      this.max.add(Vector3iUtil.ALL_ONES);
      class="kw">return this;
   }

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

   @Nonnull
   class="kw">public Bounds3i clone() {
      class="kw">return new Bounds3i(new Vector3i(this.min), new Vector3i(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() {
      Vector3i var1 = new Vector3i(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 = 28L;
      class="kw">return new MemInstrument.Report(28L);
   }
}