static int Resize(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 2);
         Spine.ExposedList <Spine.Animation> obj = (Spine.ExposedList <Spine.Animation>)ToLua.CheckObject <Spine.ExposedList <Spine.Animation> >(L, 1);
         int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
         Spine.ExposedList <Spine.Animation> o = obj.Resize(arg0);
         ToLua.PushObject(L, o);
         return(1);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
Exemple #2
0
        public ExposedList <int> Triangulate(ExposedList <float> verticesArray)
        {
            float[]           items       = verticesArray.Items;
            int               num         = verticesArray.Count >> 1;
            ExposedList <int> exposedList = indicesArray;

            exposedList.Clear();
            int[] items2 = exposedList.Resize(num).Items;
            for (int i = 0; i < num; i++)
            {
                items2[i] = i;
            }
            ExposedList <bool> exposedList2 = isConcaveArray;

            bool[] items3 = exposedList2.Resize(num).Items;
            int    j      = 0;

            for (int num2 = num; j < num2; j++)
            {
                items3[j] = IsConcave(j, num, items, items2);
            }
            ExposedList <int> exposedList3 = triangles;

            exposedList3.Clear();
            exposedList3.EnsureCapacity(Math.Max(0, num - 2) << 2);
            while (num > 3)
            {
                int num3 = num - 1;
                int num4 = 0;
                int num5 = 1;
                while (true)
                {
                    if (!items3[num4])
                    {
                        int   num6  = items2[num3] << 1;
                        int   num7  = items2[num4] << 1;
                        int   num8  = items2[num5] << 1;
                        float num9  = items[num6];
                        float num10 = items[num6 + 1];
                        float num11 = items[num7];
                        float num12 = items[num7 + 1];
                        float num13 = items[num8];
                        float num14 = items[num8 + 1];
                        for (int num15 = (num5 + 1) % num; num15 != num3; num15 = (num15 + 1) % num)
                        {
                            if (!items3[num15])
                            {
                                continue;
                            }
                            int   num16 = items2[num15] << 1;
                            float p3x   = items[num16];
                            float p3y   = items[num16 + 1];
                            if (!PositiveArea(num13, num14, num9, num10, p3x, p3y) || !PositiveArea(num9, num10, num11, num12, p3x, p3y) || !PositiveArea(num11, num12, num13, num14, p3x, p3y))
                            {
                                continue;
                            }
                            goto IL_0194;
                        }
                        break;
                    }
                    goto IL_0194;
IL_0194:
                    if (num5 == 0)
                    {
                        while (items3[num4])
                        {
                            num4--;
                            if (num4 <= 0)
                            {
                                break;
                            }
                        }
                        break;
                    }
                    num3 = num4;
                    num4 = num5;
                    num5 = (num5 + 1) % num;
                }
                exposedList3.Add(items2[(num + num4 - 1) % num]);
                exposedList3.Add(items2[num4]);
                exposedList3.Add(items2[(num4 + 1) % num]);
                exposedList.RemoveAt(num4);
                exposedList2.RemoveAt(num4);
                num--;
                int num17 = (num + num4 - 1) % num;
                int num18 = (num4 != num) ? num4 : 0;
                items3[num17] = IsConcave(num17, num, items, items2);
                items3[num18] = IsConcave(num18, num, items, items2);
            }
            if (num == 3)
            {
                exposedList3.Add(items2[2]);
                exposedList3.Add(items2[0]);
                exposedList3.Add(items2[1]);
            }
            return(exposedList3);
        }
        public void ClipTriangles(float[] vertices, int verticesLength, int[] triangles, int trianglesLength, float[] uvs)
        {
            ExposedList <float> clipOutput       = this.clipOutput;
            ExposedList <float> clippedVertices  = this.clippedVertices;
            ExposedList <int>   clippedTriangles = this.clippedTriangles;

            ExposedList <float>[] items = this.clippingPolygons.Items;
            int count = this.clippingPolygons.Count;
            int num2  = 0;

            clippedVertices.Clear(true);
            this.clippedUVs.Clear(true);
            clippedTriangles.Clear(true);
            for (int i = 0; i < trianglesLength; i += 3)
            {
                int   index = triangles[i] << 1;
                float num5  = vertices[index];
                float num6  = vertices[index + 1];
                float num7  = uvs[index];
                float num8  = uvs[index + 1];
                index = triangles[i + 1] << 1;
                float num9  = vertices[index];
                float num10 = vertices[index + 1];
                float num11 = uvs[index];
                float num12 = uvs[index + 1];
                index = triangles[i + 2] << 1;
                float num13 = vertices[index];
                float num14 = vertices[index + 1];
                float num15 = uvs[index];
                float num16 = uvs[index + 1];
                for (int j = 0; j < count; j++)
                {
                    int num18 = clippedVertices.Count;
                    if (this.Clip(num5, num6, num9, num10, num13, num14, items[j], clipOutput))
                    {
                        int num19 = clipOutput.Count;
                        if (num19 != 0)
                        {
                            float   num20     = num10 - num14;
                            float   num21     = num13 - num9;
                            float   num22     = num5 - num13;
                            float   num23     = num14 - num6;
                            float   num24     = 1f / ((num20 * num22) + (num21 * (num6 - num14)));
                            int     num25     = num19 >> 1;
                            float[] numArray  = clipOutput.Items;
                            float[] numArray2 = clippedVertices.Resize(num18 + (num25 * 2)).Items;
                            float[] numArray3 = this.clippedUVs.Resize(num18 + (num25 * 2)).Items;
                            for (int k = 0; k < num19; k += 2)
                            {
                                float num27 = numArray[k];
                                float num28 = numArray[k + 1];
                                numArray2[num18]     = num27;
                                numArray2[num18 + 1] = num28;
                                float num29 = num27 - num13;
                                float num30 = num28 - num14;
                                float num31 = ((num20 * num29) + (num21 * num30)) * num24;
                                float num32 = ((num23 * num29) + (num22 * num30)) * num24;
                                float num33 = (1f - num31) - num32;
                                numArray3[num18]     = ((num7 * num31) + (num11 * num32)) + (num15 * num33);
                                numArray3[num18 + 1] = ((num8 * num31) + (num12 * num32)) + (num16 * num33);
                                num18 += 2;
                            }
                            num18 = clippedTriangles.Count;
                            int[] numArray4 = clippedTriangles.Resize(num18 + (3 * (num25 - 2))).Items;
                            num25--;
                            for (int m = 1; m < num25; m++)
                            {
                                numArray4[num18]     = num2;
                                numArray4[num18 + 1] = num2 + m;
                                numArray4[num18 + 2] = (num2 + m) + 1;
                                num18 += 3;
                            }
                            num2 += num25 + 1;
                        }
                    }
                    else
                    {
                        float[] numArray5 = clippedVertices.Resize(num18 + 6).Items;
                        float[] numArray6 = this.clippedUVs.Resize(num18 + 6).Items;
                        numArray5[num18]     = num5;
                        numArray5[num18 + 1] = num6;
                        numArray5[num18 + 2] = num9;
                        numArray5[num18 + 3] = num10;
                        numArray5[num18 + 4] = num13;
                        numArray5[num18 + 5] = num14;
                        numArray6[num18]     = num7;
                        numArray6[num18 + 1] = num8;
                        numArray6[num18 + 2] = num11;
                        numArray6[num18 + 3] = num12;
                        numArray6[num18 + 4] = num15;
                        numArray6[num18 + 5] = num16;
                        num18 = clippedTriangles.Count;
                        int[] numArray7 = clippedTriangles.Resize(num18 + 3).Items;
                        numArray7[num18]     = num2;
                        numArray7[num18 + 1] = num2 + 1;
                        numArray7[num18 + 2] = num2 + 2;
                        num2 += 3;
                        break;
                    }
                }
            }
        }
        internal bool Clip(float x1, float y1, float x2, float y2, float x3, float y3, ExposedList <float> clippingArea, ExposedList <float> output)
        {
            ExposedList <float> list = output;
            bool flag = false;
            ExposedList <float> scratch = null;

            if ((clippingArea.Count % 4) >= 2)
            {
                scratch = output;
                output  = this.scratch;
            }
            else
            {
                scratch = this.scratch;
            }
            scratch.Clear(true);
            scratch.Add(x1);
            scratch.Add(y1);
            scratch.Add(x2);
            scratch.Add(y2);
            scratch.Add(x3);
            scratch.Add(y3);
            scratch.Add(x1);
            scratch.Add(y1);
            output.Clear(true);
            float[] items = clippingArea.Items;
            int     num   = clippingArea.Count - 4;
            int     index = 0;

            while (true)
            {
                float   num3      = items[index];
                float   num4      = items[index + 1];
                float   num5      = items[index + 2];
                float   num6      = items[index + 3];
                float   num7      = num3 - num5;
                float   num8      = num4 - num6;
                float[] numArray2 = scratch.Items;
                int     num9      = scratch.Count - 2;
                int     count     = output.Count;
                for (int i = 0; i < num9; i += 2)
                {
                    float num12 = numArray2[i];
                    float num13 = numArray2[i + 1];
                    float item  = numArray2[i + 2];
                    float num15 = numArray2[i + 3];
                    bool  flag2 = ((num7 * (num15 - num6)) - (num8 * (item - num5))) > 0f;
                    if (((num7 * (num13 - num6)) - (num8 * (num12 - num5))) > 0f)
                    {
                        if (flag2)
                        {
                            output.Add(item);
                            output.Add(num15);
                            continue;
                        }
                        float num16 = num15 - num13;
                        float num17 = item - num12;
                        float num18 = ((num17 * (num4 - num13)) - (num16 * (num3 - num12))) / ((num16 * (num5 - num3)) - (num17 * (num6 - num4)));
                        output.Add(num3 + ((num5 - num3) * num18));
                        output.Add(num4 + ((num6 - num4) * num18));
                    }
                    else if (flag2)
                    {
                        float num19 = num15 - num13;
                        float num20 = item - num12;
                        float num21 = ((num20 * (num4 - num13)) - (num19 * (num3 - num12))) / ((num19 * (num5 - num3)) - (num20 * (num6 - num4)));
                        output.Add(num3 + ((num5 - num3) * num21));
                        output.Add(num4 + ((num6 - num4) * num21));
                        output.Add(item);
                        output.Add(num15);
                    }
                    flag = true;
                }
                if (count == output.Count)
                {
                    list.Clear(true);
                    return(true);
                }
                output.Add(output.Items[0]);
                output.Add(output.Items[1]);
                if (index == num)
                {
                    break;
                }
                ExposedList <float> list3 = output;
                output = scratch;
                output.Clear(true);
                scratch = list3;
                index  += 2;
            }
            if (list != output)
            {
                list.Clear(true);
                int num22 = 0;
                int num23 = output.Count - 2;
                while (num22 < num23)
                {
                    list.Add(output.Items[num22]);
                    num22++;
                }
                return(flag);
            }
            list.Resize(list.Count - 2);
            return(flag);
        }
Exemple #5
0
        public void ClipTriangles(float[] vertices, int verticesLength, int[] triangles, int trianglesLength, float[] uvs)
        {
            ExposedList <float> clipOutput = this.clipOutput, clippedVertices = this.clippedVertices;
            var clippedTriangles = this.clippedTriangles;
            var polygons      = clippingPolygons.Items;
            int polygonsCount = clippingPolygons.Count;

            int index = 0;

            clippedVertices.Clear();
            clippedUVs.Clear();
            clippedTriangles.Clear();
            //outer: // libgdx
            for (int i = 0; i < trianglesLength; i += 3)
            {
                int   vertexOffset = triangles[i] << 1;
                float x1 = vertices[vertexOffset], y1 = vertices[vertexOffset + 1];
                float u1 = uvs[vertexOffset], v1 = uvs[vertexOffset + 1];

                vertexOffset = triangles[i + 1] << 1;
                float x2 = vertices[vertexOffset], y2 = vertices[vertexOffset + 1];
                float u2 = uvs[vertexOffset], v2 = uvs[vertexOffset + 1];

                vertexOffset = triangles[i + 2] << 1;
                float x3 = vertices[vertexOffset], y3 = vertices[vertexOffset + 1];
                float u3 = uvs[vertexOffset], v3 = uvs[vertexOffset + 1];

                for (int p = 0; p < polygonsCount; p++)
                {
                    int s = clippedVertices.Count;
                    if (Clip(x1, y1, x2, y2, x3, y3, polygons[p], clipOutput))
                    {
                        int clipOutputLength = clipOutput.Count;
                        if (clipOutputLength == 0)
                        {
                            continue;
                        }
                        float d0 = y2 - y3, d1 = x3 - x2, d2 = x1 - x3, d4 = y3 - y1;
                        float d = 1 / (d0 * d2 + d1 * (y1 - y3));

                        int     clipOutputCount      = clipOutputLength >> 1;
                        float[] clipOutputItems      = clipOutput.Items;
                        float[] clippedVerticesItems = clippedVertices.Resize(s + clipOutputCount * 2).Items;
                        float[] clippedUVsItems      = clippedUVs.Resize(s + clipOutputCount * 2).Items;
                        for (int ii = 0; ii < clipOutputLength; ii += 2)
                        {
                            float x = clipOutputItems[ii], y = clipOutputItems[ii + 1];
                            clippedVerticesItems[s]     = x;
                            clippedVerticesItems[s + 1] = y;
                            float c0 = x - x3, c1 = y - y3;
                            float a = (d0 * c0 + d1 * c1) * d;
                            float b = (d4 * c0 + d2 * c1) * d;
                            float c = 1 - a - b;
                            clippedUVsItems[s]     = u1 * a + u2 * b + u3 * c;
                            clippedUVsItems[s + 1] = v1 * a + v2 * b + v3 * c;
                            s += 2;
                        }

                        s = clippedTriangles.Count;
                        int[] clippedTrianglesItems = clippedTriangles.Resize(s + 3 * (clipOutputCount - 2)).Items;
                        clipOutputCount--;
                        for (int ii = 1; ii < clipOutputCount; ii++)
                        {
                            clippedTrianglesItems[s]     = index;
                            clippedTrianglesItems[s + 1] = index + ii;
                            clippedTrianglesItems[s + 2] = index + ii + 1;
                            s += 3;
                        }
                        index += clipOutputCount + 1;
                    }
                    else
                    {
                        float[] clippedVerticesItems = clippedVertices.Resize(s + 3 * 2).Items;
                        float[] clippedUVsItems      = clippedUVs.Resize(s + 3 * 2).Items;
                        clippedVerticesItems[s]     = x1;
                        clippedVerticesItems[s + 1] = y1;
                        clippedVerticesItems[s + 2] = x2;
                        clippedVerticesItems[s + 3] = y2;
                        clippedVerticesItems[s + 4] = x3;
                        clippedVerticesItems[s + 5] = y3;

                        clippedUVsItems[s]     = u1;
                        clippedUVsItems[s + 1] = v1;
                        clippedUVsItems[s + 2] = u2;
                        clippedUVsItems[s + 3] = v2;
                        clippedUVsItems[s + 4] = u3;
                        clippedUVsItems[s + 5] = v3;

                        s = clippedTriangles.Count;
                        int[] clippedTrianglesItems = clippedTriangles.Resize(s + 3).Items;
                        clippedTrianglesItems[s]     = index;
                        clippedTrianglesItems[s + 1] = index + 1;
                        clippedTrianglesItems[s + 2] = index + 2;
                        index += 3;
                        break;                         //continue outer;
                    }
                }
            }
        }
Exemple #6
0
        private float[] ComputeWorldPositions(PathAttachment path, int spacesCount, bool tangents, bool percentPosition, bool percentSpacing)
        {
            Slot  slot = target;
            float num  = position;

            float[] items  = spaces.Items;
            float[] items2 = positions.Resize(spacesCount * 3 + 2).Items;
            bool    closed = path.Closed;
            int     worldVerticesLength = path.WorldVerticesLength;
            int     num2 = worldVerticesLength / 6;
            int     num3 = -1;

            float[] items3;
            float   num4;

            if (!path.ConstantSpeed)
            {
                float[] array = path.Lengths;
                num2 -= (closed ? 1 : 2);
                num4  = array[num2];
                if (percentPosition)
                {
                    num *= num4;
                }
                if (percentSpacing)
                {
                    for (int i = 0; i < spacesCount; i++)
                    {
                        items[i] *= num4;
                    }
                }
                items3 = world.Resize(8).Items;
                int j    = 0;
                int k    = 0;
                int num5 = 0;
                for (; j < spacesCount; j++, k += 3)
                {
                    float num6 = items[j];
                    num += num6;
                    float num7 = num;
                    if (closed)
                    {
                        num7 %= num4;
                        if (num7 < 0f)
                        {
                            num7 += num4;
                        }
                        num5 = 0;
                    }
                    else
                    {
                        if (num7 < 0f)
                        {
                            if (num3 != -2)
                            {
                                num3 = -2;
                                path.ComputeWorldVertices(slot, 2, 4, items3, 0);
                            }
                            AddBeforePosition(num7, items3, 0, items2, k);
                            continue;
                        }
                        if (num7 > num4)
                        {
                            if (num3 != -3)
                            {
                                num3 = -3;
                                path.ComputeWorldVertices(slot, worldVerticesLength - 6, 4, items3, 0);
                            }
                            AddAfterPosition(num7 - num4, items3, 0, items2, k);
                            continue;
                        }
                    }
                    float num8;
                    while (true)
                    {
                        num8 = array[num5];
                        if (!(num7 > num8))
                        {
                            break;
                        }
                        num5++;
                    }
                    if (num5 == 0)
                    {
                        num7 /= num8;
                    }
                    else
                    {
                        float num9 = array[num5 - 1];
                        num7 = (num7 - num9) / (num8 - num9);
                    }
                    if (num5 != num3)
                    {
                        num3 = num5;
                        if (closed && num5 == num2)
                        {
                            path.ComputeWorldVertices(slot, worldVerticesLength - 4, 4, items3, 0);
                            path.ComputeWorldVertices(slot, 0, 4, items3, 4);
                        }
                        else
                        {
                            path.ComputeWorldVertices(slot, num5 * 6 + 2, 8, items3, 0);
                        }
                    }
                    AddCurvePosition(num7, items3[0], items3[1], items3[2], items3[3], items3[4], items3[5], items3[6], items3[7], items2, k, tangents || (j > 0 && num6 == 0f));
                }
                return(items2);
            }
            if (closed)
            {
                worldVerticesLength += 2;
                items3 = world.Resize(worldVerticesLength).Items;
                path.ComputeWorldVertices(slot, 2, worldVerticesLength - 4, items3, 0);
                path.ComputeWorldVertices(slot, 0, 2, items3, worldVerticesLength - 4);
                items3[worldVerticesLength - 2] = items3[0];
                items3[worldVerticesLength - 1] = items3[1];
            }
            else
            {
                num2--;
                worldVerticesLength -= 4;
                items3 = world.Resize(worldVerticesLength).Items;
                path.ComputeWorldVertices(slot, 2, worldVerticesLength, items3, 0);
            }
            float[] items4 = curves.Resize(num2).Items;
            num4 = 0f;
            float num10 = items3[0];
            float num11 = items3[1];
            float num12 = 0f;
            float num13 = 0f;
            float num14 = 0f;
            float num15 = 0f;
            float num16 = 0f;
            float num17 = 0f;
            int   num18 = 0;
            int   num19 = 2;

            while (num18 < num2)
            {
                num12 = items3[num19];
                num13 = items3[num19 + 1];
                num14 = items3[num19 + 2];
                num15 = items3[num19 + 3];
                num16 = items3[num19 + 4];
                num17 = items3[num19 + 5];
                float num20 = (num10 - num12 * 2f + num14) * 0.1875f;
                float num21 = (num11 - num13 * 2f + num15) * 0.1875f;
                float num22 = ((num12 - num14) * 3f - num10 + num16) * (3f / 32f);
                float num23 = ((num13 - num15) * 3f - num11 + num17) * (3f / 32f);
                float num24 = num20 * 2f + num22;
                float num25 = num21 * 2f + num23;
                float num26 = (num12 - num10) * 0.75f + num20 + num22 * (355f / (678f * (float)Math.PI));
                float num27 = (num13 - num11) * 0.75f + num21 + num23 * (355f / (678f * (float)Math.PI));
                num4  += (float)Math.Sqrt(num26 * num26 + num27 * num27);
                num26 += num24;
                num27 += num25;
                num24 += num22;
                num25 += num23;
                num4  += (float)Math.Sqrt(num26 * num26 + num27 * num27);
                num26 += num24;
                num27 += num25;
                num4  += (float)Math.Sqrt(num26 * num26 + num27 * num27);
                num26 += num24 + num22;
                num27 += num25 + num23;
                num4   = (items4[num18] = num4 + (float)Math.Sqrt(num26 * num26 + num27 * num27));
                num10  = num16;
                num11  = num17;
                num18++;
                num19 += 6;
            }
            if (percentPosition)
            {
                num *= num4;
            }
            if (percentSpacing)
            {
                for (int l = 0; l < spacesCount; l++)
                {
                    items[l] *= num4;
                }
            }
            float[] array2 = segments;
            float   num28  = 0f;
            int     m      = 0;
            int     n      = 0;
            int     num29  = 0;
            int     num30  = 0;

            for (; m < spacesCount; m++, n += 3)
            {
                float num31 = items[m];
                num += num31;
                float num32 = num;
                if (closed)
                {
                    num32 %= num4;
                    if (num32 < 0f)
                    {
                        num32 += num4;
                    }
                    num29 = 0;
                }
                else
                {
                    if (num32 < 0f)
                    {
                        AddBeforePosition(num32, items3, 0, items2, n);
                        continue;
                    }
                    if (num32 > num4)
                    {
                        AddAfterPosition(num32 - num4, items3, worldVerticesLength - 4, items2, n);
                        continue;
                    }
                }
                float num33;
                while (true)
                {
                    num33 = items4[num29];
                    if (!(num32 > num33))
                    {
                        break;
                    }
                    num29++;
                }
                if (num29 == 0)
                {
                    num32 /= num33;
                }
                else
                {
                    float num34 = items4[num29 - 1];
                    num32 = (num32 - num34) / (num33 - num34);
                }
                if (num29 != num3)
                {
                    num3 = num29;
                    int num35 = num29 * 6;
                    num10 = items3[num35];
                    num11 = items3[num35 + 1];
                    num12 = items3[num35 + 2];
                    num13 = items3[num35 + 3];
                    num14 = items3[num35 + 4];
                    num15 = items3[num35 + 5];
                    num16 = items3[num35 + 6];
                    num17 = items3[num35 + 7];
                    float num20 = (num10 - num12 * 2f + num14) * 0.03f;
                    float num21 = (num11 - num13 * 2f + num15) * 0.03f;
                    float num22 = ((num12 - num14) * 3f - num10 + num16) * 0.006f;
                    float num23 = ((num13 - num15) * 3f - num11 + num17) * 0.006f;
                    float num24 = num20 * 2f + num22;
                    float num25 = num21 * 2f + num23;
                    float num26 = (num12 - num10) * 0.3f + num20 + num22 * (355f / (678f * (float)Math.PI));
                    float num27 = (num13 - num11) * 0.3f + num21 + num23 * (355f / (678f * (float)Math.PI));
                    num28 = (array2[0] = (float)Math.Sqrt(num26 * num26 + num27 * num27));
                    for (num35 = 1; num35 < 8; num35++)
                    {
                        num26 += num24;
                        num27 += num25;
                        num24 += num22;
                        num25 += num23;
                        num28  = (array2[num35] = num28 + (float)Math.Sqrt(num26 * num26 + num27 * num27));
                    }
                    num26 += num24;
                    num27 += num25;
                    num28  = (array2[8] = num28 + (float)Math.Sqrt(num26 * num26 + num27 * num27));
                    num26 += num24 + num22;
                    num27 += num25 + num23;
                    num28  = (array2[9] = num28 + (float)Math.Sqrt(num26 * num26 + num27 * num27));
                    num30  = 0;
                }
                num32 *= num28;
                float num36;
                while (true)
                {
                    num36 = array2[num30];
                    if (!(num32 > num36))
                    {
                        break;
                    }
                    num30++;
                }
                if (num30 == 0)
                {
                    num32 /= num36;
                }
                else
                {
                    float num37 = array2[num30 - 1];
                    num32 = (float)num30 + (num32 - num37) / (num36 - num37);
                }
                AddCurvePosition(num32 * 0.1f, num10, num11, num12, num13, num14, num15, num16, num17, items2, n, tangents || (m > 0 && num31 == 0f));
            }
            return(items2);
        }
Exemple #7
0
        public void Update()
        {
            PathAttachment pathAttachment = target.Attachment as PathAttachment;

            if (pathAttachment == null)
            {
                return;
            }
            float num   = rotateMix;
            float num2  = translateMix;
            bool  flag  = num2 > 0f;
            bool  flag2 = num > 0f;

            if (!flag && !flag2)
            {
                return;
            }
            PathConstraintData pathConstraintData = data;
            SpacingMode        spacingMode        = pathConstraintData.spacingMode;
            bool       flag3      = spacingMode == SpacingMode.Length;
            RotateMode rotateMode = pathConstraintData.rotateMode;
            bool       flag4      = rotateMode == RotateMode.Tangent;
            bool       flag5      = rotateMode == RotateMode.ChainScale;
            int        count      = bones.Count;
            int        num3       = (!flag4) ? (count + 1) : count;

            Bone[] items = bones.Items;
            ExposedList <float> exposedList  = spaces.Resize(num3);
            ExposedList <float> exposedList2 = null;
            float num4 = spacing;

            if (flag5 || flag3)
            {
                if (flag5)
                {
                    exposedList2 = lengths.Resize(count);
                }
                int num5 = 0;
                int num6 = num3 - 1;
                while (num5 < num6)
                {
                    Bone  bone = items[num5];
                    float num7 = bone.data.length;
                    if (num7 == 0f)
                    {
                        num7 = 1E-09f;
                    }
                    float num8  = num7 * bone.a;
                    float num9  = num7 * bone.c;
                    float num10 = (float)Math.Sqrt(num8 * num8 + num9 * num9);
                    if (flag5)
                    {
                        exposedList2.Items[num5] = num7;
                    }
                    exposedList.Items[++num5] = ((!flag3) ? num4 : Math.Max(0f, num7 + num4)) * num10 / num7;
                }
            }
            else
            {
                for (int i = 1; i < num3; i++)
                {
                    exposedList.Items[i] = num4;
                }
            }
            float[] array = ComputeWorldPositions(pathAttachment, num3, flag4, pathConstraintData.positionMode == PositionMode.Percent, spacingMode == SpacingMode.Percent);
            float   num11 = array[0];
            float   num12 = array[1];
            float   num13 = pathConstraintData.offsetRotation;
            bool    flag6;

            if (num13 == 0f)
            {
                flag6 = (rotateMode == RotateMode.Chain);
            }
            else
            {
                flag6 = false;
                Bone bone2 = target.bone;
                num13 *= ((!(bone2.a * bone2.d - bone2.b * bone2.c > 0f)) ? (-(float)Math.PI / 180f) : ((float)Math.PI / 180f));
            }
            int num14 = 0;
            int num15 = 3;

            while (num14 < count)
            {
                Bone bone3 = items[num14];
                bone3.worldX += (num11 - bone3.worldX) * num2;
                bone3.worldY += (num12 - bone3.worldY) * num2;
                float num16 = array[num15];
                float num17 = array[num15 + 1];
                float num18 = num16 - num11;
                float num19 = num17 - num12;
                if (flag5)
                {
                    float num20 = exposedList2.Items[num14];
                    if (num20 != 0f)
                    {
                        float num21 = ((float)Math.Sqrt(num18 * num18 + num19 * num19) / num20 - 1f) * num + 1f;
                        bone3.a *= num21;
                        bone3.c *= num21;
                    }
                }
                num11 = num16;
                num12 = num17;
                if (flag2)
                {
                    float a     = bone3.a;
                    float b     = bone3.b;
                    float c     = bone3.c;
                    float d     = bone3.d;
                    float num22 = flag4 ? array[num15 - 1] : ((exposedList.Items[num14 + 1] != 0f) ? MathUtils.Atan2(num19, num18) : array[num15 + 2]);
                    num22 -= MathUtils.Atan2(c, a);
                    float num23;
                    float num24;
                    if (flag6)
                    {
                        num23 = MathUtils.Cos(num22);
                        num24 = MathUtils.Sin(num22);
                        float length = bone3.data.length;
                        num11 += (length * (num23 * a - num24 * c) - num18) * num;
                        num12 += (length * (num24 * a + num23 * c) - num19) * num;
                    }
                    else
                    {
                        num22 += num13;
                    }
                    if (num22 > (float)Math.PI)
                    {
                        num22 -= (float)Math.PI * 2f;
                    }
                    else if (num22 < -(float)Math.PI)
                    {
                        num22 += (float)Math.PI * 2f;
                    }
                    num22  *= num;
                    num23   = MathUtils.Cos(num22);
                    num24   = MathUtils.Sin(num22);
                    bone3.a = num23 * a - num24 * c;
                    bone3.b = num23 * b - num24 * d;
                    bone3.c = num24 * a + num23 * c;
                    bone3.d = num24 * b + num23 * d;
                }
                bone3.appliedValid = false;
                num14++;
                num15 += 3;
            }
        }