// Decompiled with JetBrains decompiler
// Type: Eden.AutoMorpher.VertexMoverUtil
// Assembly: EdenAutoMorpherScript, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: D39968B3-E151-4276-BDB4-E82752BBAFF0
// Assembly location: D:\dev\AutoMorpher\Assets\@Eden_Tools\Eden_AutoMorpher\Script\EdenAutoMorpherScript.dll

using UnityEngine;

namespace Eden.AutoMorpher
{
    public class VertexMoverUtil
    {
        public Vector3[] MoveVertices(
          ClothInstance cloth,
          Vector3 targetPoint,
          bool centerIsLeftLeg,
          bool centerIsRightLeg,
          float maxRadius,
          float param,
          Vector3 vertexMovement)
        {
            Vector3[] verts = cloth != null && cloth.worldVertices != null ? cloth.worldVertices : throw new AutoMorpherException("Cloth or World Vertices are Missing", "[MoveVertices] MoveVertices\n - cloth is null or cloth.worldVertices is null");
            int length = verts.Length;
            bool[] isInboundVerts;
            float[] euclideanDistances = this.ComputeEuclideanDistances(verts, targetPoint, maxRadius, out isInboundVerts);
            if (euclideanDistances == null)
                return (Vector3[])null;
            float[] kernelWeights = this.ComputeKernelWeights(euclideanDistances, isInboundVerts, maxRadius, WeightKernel.Gaussian, param);
            Vector3[] vector3Array = new Vector3[length];
            bool[] isLeftLegVertex = cloth.isLeftLegVertex;
            bool[] isRightLegVertex = cloth.isRightLegVertex;
            for (int index = 0; index < length; ++index)
            {
                if (!isInboundVerts[index])
                    vector3Array[index] = Vector3.zero;
                else if (centerIsLeftLeg && this.IsRightLegVertex(isRightLegVertex, index))
                    vector3Array[index] = Vector3.zero;
                else if (centerIsRightLeg && this.IsLeftLegVertex(isLeftLegVertex, index))
                {
                    vector3Array[index] = Vector3.zero;
                }
                else
                {
                    float num = kernelWeights[index];
                    vector3Array[index] = Vector3.op_Multiply(vertexMovement, num);
                }
            }
            return vector3Array;
        }

        public Vector3[] MoveVertices(
          ClothInstance cloth,
          int targetVertexIdx,
          bool centerIsLeftLeg,
          bool centerIsRightLeg,
          float maxRadius,
          float param,
          Vector3 vertexMovement)
        {
            Vector3[] verts = cloth != null && cloth.worldVertices != null ? cloth.worldVertices : throw new AutoMorpherException("Cloth or World Vertices are Missing", "[MoveVertices] MoveVertices\n - cloth is null or cloth.worldVertices is null");
            int length = verts.Length;
            bool[] isInboundVerts;
            float[] euclideanDistances = this.ComputeEuclideanDistances(verts, targetVertexIdx, maxRadius, out isInboundVerts);
            if (euclideanDistances == null)
                return (Vector3[])null;
            float[] kernelWeights = this.ComputeKernelWeights(euclideanDistances, isInboundVerts, maxRadius, WeightKernel.Gaussian, param);
            Vector3[] vector3Array = new Vector3[length];
            bool[] isLeftLegVertex = cloth.isLeftLegVertex;
            bool[] isRightLegVertex = cloth.isRightLegVertex;
            for (int index = 0; index < length; ++index)
            {
                if (!isInboundVerts[index])
                    vector3Array[index] = Vector3.zero;
                else if (centerIsLeftLeg && this.IsRightLegVertex(isRightLegVertex, index))
                    vector3Array[index] = Vector3.zero;
                else if (centerIsRightLeg && this.IsLeftLegVertex(isLeftLegVertex, index))
                {
                    vector3Array[index] = Vector3.zero;
                }
                else
                {
                    float num = kernelWeights[index];
                    vector3Array[index] = Vector3.op_Multiply(vertexMovement, num);
                }
            }
            return vector3Array;
        }

        private float[] ComputeEuclideanDistances(
          Vector3[] verts,
          int targetVertIdx,
          float maxRadius,
          out bool[] isInboundVerts)
        {
            return this.ComputeEuclideanDistances(verts, verts[targetVertIdx], maxRadius, out isInboundVerts);
        }

        private float[] ComputeEuclideanDistances(
          Vector3[] verts,
          Vector3 targetVert,
          float maxRadius,
          out bool[] isInboundVerts)
        {
            int length = verts.Length;
            float[] numArray = new float[length];
            isInboundVerts = new bool[length];
            bool flag = false;
            for (int index = 0; index < length; ++index)
            {
                numArray[index] = Vector3.Distance(verts[index], targetVert);
                isInboundVerts[index] = (double)numArray[index] <= (double)maxRadius;
                flag |= isInboundVerts[index];
            }
            return !flag ? (float[])null : numArray;
        }

        private float ComputeGaussianWeight(float distance, float alpah)
        {
            return Mathf.Exp((float)(-((double)distance * (double)distance) / (2.0 * (double)alpah * (double)alpah)));
        }

        private float ComputeLaplacianWeight(float distance, float beta)
        {
            return Mathf.Exp((float)-((double)distance / (double)beta));
        }

        private float[] ComputeKernelWeights(
          float[] dist,
          bool[] isInboundVerts,
          float maxRadius,
          WeightKernel kernel,
          float param)
        {
            int length = dist.Length;
            float[] kernelWeights = new float[length];
            float num1 = Mathf.Max(1E-08f, param);
            for (int index = 0; index < length; ++index)
            {
                if (!isInboundVerts[index])
                {
                    kernelWeights[index] = 0.0f;
                }
                else
                {
                    switch (kernel)
                    {
                        case WeightKernel.Gaussian:
                            kernelWeights[index] = this.ComputeGaussianWeight(dist[index], num1);
                            break;
                        case WeightKernel.Laplacian:
                            kernelWeights[index] = this.ComputeLaplacianWeight(dist[index], num1);
                            break;
                        default:
                            kernelWeights[index] = 0.0f;
                            break;
                    }
                    float num2 = (float)(1.0 - (double)dist[index] / (double)maxRadius);
                    kernelWeights[index] *= num2 * num2;
                }
            }
            return kernelWeights;
        }

        private bool IsLeftLegVertex(bool[] leftMask, int index)
        {
            return leftMask != null && index >= 0 && index < leftMask.Length && leftMask[index];
        }

        private bool IsRightLegVertex(bool[] rightMask, int index)
        {
            return rightMask != null && index >= 0 && index < rightMask.Length && rightMask[index];
        }
    }
}