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

class="kw">import com.hypixel.hytale.builtin.hytalegenerator.ReusableList;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.math.Calculator;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.pipe.Control;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.positionproviders.PositionProvider;
class="kw">import it.unimi.dsi.fastutil.doubles.Double2DoubleFunction;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3dc;

class="kw">public class PositionsHorizontalPinchDensity class="kw">extends Density {
   @Nonnull
   class="kw">private Density input;
   @Nonnull
   class="kw">private class="kw">final PositionProvider positions;
   @Nonnull
   class="kw">private class="kw">final Double2DoubleFunction pinchCurve;
   @Nonnull
   class="kw">private class="kw">final PositionsHorizontalPinchDensity.Cache cache;
   class="kw">private class="kw">final double maxDistance;
   class="kw">private class="kw">final boolean distanceNormalized;
   class="kw">private class="kw">final double positionsMinY;
   class="kw">private class="kw">final double positionsMaxY;
   @Nonnull
   class="kw">private class="kw">final Vector3d rWarpVector;
   @Nonnull
   class="kw">private class="kw">final Vector3d rSamplePoint;
   @Nonnull
   class="kw">private class="kw">final Vector3d rMin;
   @Nonnull
   class="kw">private class="kw">final Vector3d rMax;
   @Nonnull
   class="kw">private class="kw">final Vector3d rPosition;
   @Nonnull
   class="kw">private class="kw">final Vector3d rConsumerResult;
   @Nonnull
   class="kw">private class="kw">final ReusableList<Vector3d> rWarpVectors;
   @Nonnull
   class="kw">private class="kw">final ReusableList<Double> rNormalizedDistances;
   @Nonnull
   class="kw">private class="kw">final ReusableList<Double> rWeights;
   @Nonnull
   class="kw">private class="kw">final PositionProvider.Context rPositionsContext;
   @Nonnull
   class="kw">private class="kw">final Density.Context rChildContext;

   class="kw">public PositionsHorizontalPinchDensity(
      @Nonnull Density var1, @Nonnull PositionProvider var2, @Nonnull Double2DoubleFunction var3, double var4, boolean var6, double var7, double var9
   ) {
      assert var4 >= 0.0;
      if (var7 > var9) {
         var7 = var9;
      }

      this.input = var1;
      this.positions = var2;
      this.pinchCurve = var3;
      this.maxDistance = var4;
      this.distanceNormalized = var6;
      this.positionsMinY = var7;
      this.positionsMaxY = var9;
      this.cache = new PositionsHorizontalPinchDensity.Cache();
      this.rWarpVector = new Vector3d();
      this.rSamplePoint = new Vector3d();
      this.rMin = new Vector3d();
      this.rMax = new Vector3d();
      this.rPosition = new Vector3d();
      this.rConsumerResult = new Vector3d();
      this.rWarpVectors = new ReusableList<>();
      this.rNormalizedDistances = new ReusableList<>();
      this.rWeights = new ReusableList<>();
      this.rPositionsContext = new PositionProvider.Context();
      this.rChildContext = new Density.Context();
   }

   @Override
   class="kw">public double process(@Nonnull Density.Context var1) {
      if (this.input == null) {
         class="kw">return 0.0;
      }

      if (this.positions == null) {
         class="kw">return this.input.process(var1);
      }

      if (this.cache.x == var1.position.x && this.cache.z == var1.position.z && this.cache.hasValue) {
         this.rWarpVector.set(this.cache.warpVector);
      } else {
         this.calculateWarpVector(var1, this.rWarpVector);
         this.cache.warpVector = this.rWarpVector;
         this.cache.x = var1.position.x;
         this.cache.z = var1.position.z;
         this.cache.hasValue = true;
      }

      this.rPosition.set(this.rWarpVector.x + var1.position.x, this.rWarpVector.y + var1.position.y, this.rWarpVector.z + var1.position.z);
      this.rChildContext.assign(var1);
      this.rChildContext.position = this.rPosition;
      double var2 = this.input.process(this.rChildContext);
      this.rChildContext.clearReferences();
      class="kw">return var2;
   }

   @Override
   class="kw">public void setInputs(@Nonnull Density[] var1) {
      if (var1.length == 0) {
         this.input = new ConstantValueDensity(0.0);
      }

      this.input = var1[0];
   }

   class="kw">private void consumer(@Nonnull Vector3d var1, @Nonnull Control var2) {
      double var3 = Calculator.distance(var1.x, var1.z, this.rSamplePoint.x, this.rSamplePoint.z);
      if (!(var3 > this.maxDistance)) {
         double var5 = var3 / this.maxDistance;
         this.rConsumerResult.set(var1).sub(this.rSamplePoint);
         this.rConsumerResult.y = 0.0;
         double var9;
         if (this.distanceNormalized) {
            var9 = this.pinchCurve.applyAsDouble(var5);
            var9 *= this.maxDistance;
         } else {
            var9 = this.pinchCurve.applyAsDouble(var3);
         }

         if (!(Math.abs(this.rConsumerResult.length()) < 1.0E-9)) {
            this.rConsumerResult.normalize(var9);
         }

         if (this.rWarpVectors.isAtHardCapacity()) {
            this.rWarpVectors.expandAndSet(new Vector3d(this.rConsumerResult));
         } else {
            this.rWarpVectors.expandAndGet().set(this.rConsumerResult);
         }

         this.rNormalizedDistances.expandAndSet(var5);
      }
   }

   class="kw">public void calculateWarpVector(@Nonnull Density.Context var1, @Nonnull Vector3d var2) {
      this.rMin.set(var1.position.x - this.maxDistance, this.positionsMinY, var1.position.z - this.maxDistance);
      this.rMax.set(var1.position.x + this.maxDistance, this.positionsMaxY, var1.position.z + this.maxDistance);
      this.rSamplePoint.set(var1.position);
      this.rWarpVectors.clear();
      this.rNormalizedDistances.clear();
      this.rPositionsContext.bounds.min.set(this.rMin);
      this.rPositionsContext.bounds.max.set(this.rMax);
      this.rPositionsContext.pipe = this::consumer;
      this.positions.generate(this.rPositionsContext);
      var2.set(0.0, 0.0, 0.0);
      if (this.rWarpVectors.getSoftSize() != 0) {
         if (this.rWarpVectors.getSoftSize() == 1) {
            var2.set((Vector3dc)this.rWarpVectors.get(0));
         } else {
            int var3 = this.rWarpVectors.getSoftSize();
            this.rWeights.clear();
            double var4 = 0.0;

            for (int var6 = 0; var6 < var3; var6++) {
               double var7 = this.rNormalizedDistances.get(var6);
               double var9 = 1.0 - var7;
               this.rWeights.expandAndSet(var9);
               var4 += var9;
            }

            for (int var11 = 0; var11 < var3; var11++) {
               double var12 = this.rWeights.get(var11) / var4;
               Vector3d var13 = this.rWarpVectors.get(var11);
               var13.mul(var12);
               var2.add(var13);
            }
         }
      }
   }

   class="kw">private class="kw">static class Cache {
      double x;
      double z;
      Vector3d warpVector;
      boolean hasValue;

      class="kw">private Cache() {
      }
   }
}