float[] ComputeWorldPositions (PathAttachment path, int spacesCount, bool tangents, bool percentPosition, bool percentSpacing) { Slot target = this.target; float position = this.position; float[] spaces = this.spaces.Items, output = this.positions.Resize(spacesCount * 3 + 2).Items, world; bool closed = path.Closed; int verticesLength = path.WorldVerticesLength, curveCount = verticesLength / 6, prevCurve = NONE; float pathLength; if (!path.ConstantSpeed) { float[] lengths = path.Lengths; curveCount -= closed ? 1 : 2; pathLength = lengths[curveCount]; if (percentPosition) position *= pathLength; if (percentSpacing) { for (int i = 0; i < spacesCount; i++) spaces[i] *= pathLength; } world = this.world.Resize(8).Items; for (int i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) { float space = spaces[i]; position += space; float p = position; if (closed) { p %= pathLength; if (p < 0) p += pathLength; curve = 0; } else if (p < 0) { if (prevCurve != BEFORE) { prevCurve = BEFORE; path.ComputeWorldVertices(target, 2, 4, world, 0); } AddBeforePosition(p, world, 0, output, o); continue; } else if (p > pathLength) { if (prevCurve != AFTER) { prevCurve = AFTER; path.ComputeWorldVertices(target, verticesLength - 6, 4, world, 0); } AddAfterPosition(p - pathLength, world, 0, output, o); continue; } // Determine curve containing position. for (;; curve++) { float length = lengths[curve]; if (p > length) continue; if (curve == 0) p /= length; else { float prev = lengths[curve - 1]; p = (p - prev) / (length - prev); } break; } if (curve != prevCurve) { prevCurve = curve; if (closed && curve == curveCount) { path.ComputeWorldVertices(target, verticesLength - 4, 4, world, 0); path.ComputeWorldVertices(target, 0, 4, world, 4); } else path.ComputeWorldVertices(target, curve * 6 + 2, 8, world, 0); } AddCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], output, o, tangents || (i > 0 && space == 0)); } return output; } // World vertices. if (closed) { verticesLength += 2; world = this.world.Resize(verticesLength).Items; path.ComputeWorldVertices(target, 2, verticesLength - 4, world, 0); path.ComputeWorldVertices(target, 0, 2, world, verticesLength - 4); world[verticesLength - 2] = world[0]; world[verticesLength - 1] = world[1]; } else { curveCount--; verticesLength -= 4; world = this.world.Resize(verticesLength).Items; path.ComputeWorldVertices(target, 2, verticesLength, world, 0); } // Curve lengths. float[] curves = this.curves.Resize(curveCount).Items; pathLength = 0; float x1 = world[0], y1 = world[1], cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0; float tmpx, tmpy, dddfx, dddfy, ddfx, ddfy, dfx, dfy; for (int i = 0, w = 2; i < curveCount; i++, w += 6) { cx1 = world[w]; cy1 = world[w + 1]; cx2 = world[w + 2]; cy2 = world[w + 3]; x2 = world[w + 4]; y2 = world[w + 5]; tmpx = (x1 - cx1 * 2 + cx2) * 0.1875f; tmpy = (y1 - cy1 * 2 + cy2) * 0.1875f; dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375f; dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375f; ddfx = tmpx * 2 + dddfx; ddfy = tmpy * 2 + dddfy; dfx = (cx1 - x1) * 0.75f + tmpx + dddfx * 0.16666667f; dfy = (cy1 - y1) * 0.75f + tmpy + dddfy * 0.16666667f; pathLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); dfx += ddfx; dfy += ddfy; ddfx += dddfx; ddfy += dddfy; pathLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); dfx += ddfx; dfy += ddfy; pathLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); dfx += ddfx + dddfx; dfy += ddfy + dddfy; pathLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); curves[i] = pathLength; x1 = x2; y1 = y2; } if (percentPosition) position *= pathLength; if (percentSpacing) { for (int i = 0; i < spacesCount; i++) spaces[i] *= pathLength; } float[] segments = this.segments; float curveLength = 0; for (int i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) { float space = spaces[i]; position += space; float p = position; if (closed) { p %= pathLength; if (p < 0) p += pathLength; curve = 0; } else if (p < 0) { AddBeforePosition(p, world, 0, output, o); continue; } else if (p > pathLength) { AddAfterPosition(p - pathLength, world, verticesLength - 4, output, o); continue; } // Determine curve containing position. for (;; curve++) { float length = curves[curve]; if (p > length) continue; if (curve == 0) p /= length; else { float prev = curves[curve - 1]; p = (p - prev) / (length - prev); } break; } // Curve segment lengths. if (curve != prevCurve) { prevCurve = curve; int ii = curve * 6; x1 = world[ii]; y1 = world[ii + 1]; cx1 = world[ii + 2]; cy1 = world[ii + 3]; cx2 = world[ii + 4]; cy2 = world[ii + 5]; x2 = world[ii + 6]; y2 = world[ii + 7]; tmpx = (x1 - cx1 * 2 + cx2) * 0.03f; tmpy = (y1 - cy1 * 2 + cy2) * 0.03f; dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006f; dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006f; ddfx = tmpx * 2 + dddfx; ddfy = tmpy * 2 + dddfy; dfx = (cx1 - x1) * 0.3f + tmpx + dddfx * 0.16666667f; dfy = (cy1 - y1) * 0.3f + tmpy + dddfy * 0.16666667f; curveLength = (float)Math.Sqrt(dfx * dfx + dfy * dfy); segments[0] = curveLength; for (ii = 1; ii < 8; ii++) { dfx += ddfx; dfy += ddfy; ddfx += dddfx; ddfy += dddfy; curveLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); segments[ii] = curveLength; } dfx += ddfx; dfy += ddfy; curveLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); segments[8] = curveLength; dfx += ddfx + dddfx; dfy += ddfy + dddfy; curveLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); segments[9] = curveLength; segment = 0; } // Weight by segment length. p *= curveLength; for (;; segment++) { float length = segments[segment]; if (p > length) continue; if (segment == 0) p /= length; else { float prev = segments[segment - 1]; p = segment + (p - prev) / (length - prev); } break; } AddCurvePosition(p * 0.1f, x1, y1, cx1, cy1, cx2, cy2, x2, y2, output, o, tangents || (i > 0 && space == 0)); } return output; }
float[] ComputeWorldPositions(PathAttachment path, int spacesCount, bool tangents, bool percentPosition, bool percentSpacing) { Slot target = this.target; float position = this.position; float[] spacesItems = this.spaces.Items, output = this.positions.Resize(spacesCount * 3 + 2).Items, world; bool closed = path.Closed; int verticesLength = path.WorldVerticesLength, curveCount = verticesLength / 6, prevCurve = NONE; float pathLength = 0; if (!path.ConstantSpeed) { float[] lengths = path.Lengths; curveCount -= closed ? 1 : 2; pathLength = lengths[curveCount]; if (percentPosition) { position *= pathLength; } if (percentSpacing) { for (int i = 1; i < spacesCount; i++) { spacesItems[i] *= pathLength; } } world = this.world.Resize(8).Items; for (int i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) { float space = spacesItems[i]; position += space; float p = position; if (closed) { p %= pathLength; if (p < 0) { p += pathLength; } curve = 0; } else if (p < 0) { if (prevCurve != BEFORE) { prevCurve = BEFORE; path.ComputeWorldVertices(target, 2, 4, world, 0, 2); } AddBeforePosition(p, world, 0, output, o); continue; } else if (p > pathLength) { if (prevCurve != AFTER) { prevCurve = AFTER; path.ComputeWorldVertices(target, verticesLength - 6, 4, world, 0, 2); } AddAfterPosition(p - pathLength, world, 0, output, o); continue; } // Determine curve containing position. for (;; curve++) { float length = lengths[curve]; if (p > length) { continue; } if (curve == 0) { p /= length; } else { float prev = lengths[curve - 1]; p = (p - prev) / (length - prev); } break; } if (curve != prevCurve) { prevCurve = curve; if (closed && curve == curveCount) { path.ComputeWorldVertices(target, verticesLength - 4, 4, world, 0, 2); path.ComputeWorldVertices(target, 0, 4, world, 4, 2); } else { path.ComputeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2); } } AddCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], output, o, tangents || (i > 0 && space < PathConstraint.Epsilon)); } return(output); } // World vertices. if (closed) { verticesLength += 2; world = this.world.Resize(verticesLength).Items; path.ComputeWorldVertices(target, 2, verticesLength - 4, world, 0, 2); path.ComputeWorldVertices(target, 0, 2, world, verticesLength - 4, 2); world[verticesLength - 2] = world[0]; world[verticesLength - 1] = world[1]; } else { curveCount--; verticesLength -= 4; world = this.world.Resize(verticesLength).Items; path.ComputeWorldVertices(target, 2, verticesLength, world, 0, 2); } // Curve lengths. float[] curves = this.curves.Resize(curveCount).Items; pathLength = 0; float x1 = world[0], y1 = world[1], cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0; float tmpx, tmpy, dddfx, dddfy, ddfx, ddfy, dfx, dfy; for (int i = 0, w = 2; i < curveCount; i++, w += 6) { cx1 = world[w]; cy1 = world[w + 1]; cx2 = world[w + 2]; cy2 = world[w + 3]; x2 = world[w + 4]; y2 = world[w + 5]; tmpx = (x1 - cx1 * 2 + cx2) * 0.1875f; tmpy = (y1 - cy1 * 2 + cy2) * 0.1875f; dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375f; dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375f; ddfx = tmpx * 2 + dddfx; ddfy = tmpy * 2 + dddfy; dfx = (cx1 - x1) * 0.75f + tmpx + dddfx * 0.16666667f; dfy = (cy1 - y1) * 0.75f + tmpy + dddfy * 0.16666667f; pathLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); dfx += ddfx; dfy += ddfy; ddfx += dddfx; ddfy += dddfy; pathLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); dfx += ddfx; dfy += ddfy; pathLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); dfx += ddfx + dddfx; dfy += ddfy + dddfy; pathLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); curves[i] = pathLength; x1 = x2; y1 = y2; } if (percentPosition) { position *= pathLength; } else { position *= pathLength / path.lengths[curveCount - 1]; } if (percentSpacing) { for (int i = 1; i < spacesCount; i++) { spacesItems[i] *= pathLength; } } float[] segments = this.segments; float curveLength = 0; for (int i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) { float space = spacesItems[i]; position += space; float p = position; if (closed) { p %= pathLength; if (p < 0) { p += pathLength; } curve = 0; } else if (p < 0) { AddBeforePosition(p, world, 0, output, o); continue; } else if (p > pathLength) { AddAfterPosition(p - pathLength, world, verticesLength - 4, output, o); continue; } // Determine curve containing position. for (;; curve++) { float length = curves[curve]; if (p > length) { continue; } if (curve == 0) { p /= length; } else { float prev = curves[curve - 1]; p = (p - prev) / (length - prev); } break; } // Curve segment lengths. if (curve != prevCurve) { prevCurve = curve; int ii = curve * 6; x1 = world[ii]; y1 = world[ii + 1]; cx1 = world[ii + 2]; cy1 = world[ii + 3]; cx2 = world[ii + 4]; cy2 = world[ii + 5]; x2 = world[ii + 6]; y2 = world[ii + 7]; tmpx = (x1 - cx1 * 2 + cx2) * 0.03f; tmpy = (y1 - cy1 * 2 + cy2) * 0.03f; dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006f; dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006f; ddfx = tmpx * 2 + dddfx; ddfy = tmpy * 2 + dddfy; dfx = (cx1 - x1) * 0.3f + tmpx + dddfx * 0.16666667f; dfy = (cy1 - y1) * 0.3f + tmpy + dddfy * 0.16666667f; curveLength = (float)Math.Sqrt(dfx * dfx + dfy * dfy); segments[0] = curveLength; for (ii = 1; ii < 8; ii++) { dfx += ddfx; dfy += ddfy; ddfx += dddfx; ddfy += dddfy; curveLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); segments[ii] = curveLength; } dfx += ddfx; dfy += ddfy; curveLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); segments[8] = curveLength; dfx += ddfx + dddfx; dfy += ddfy + dddfy; curveLength += (float)Math.Sqrt(dfx * dfx + dfy * dfy); segments[9] = curveLength; segment = 0; } // Weight by segment length. p *= curveLength; for (;; segment++) { float length = segments[segment]; if (p > length) { continue; } if (segment == 0) { p /= length; } else { float prev = segments[segment - 1]; p = segment + (p - prev) / (length - prev); } break; } AddCurvePosition(p * 0.1f, x1, y1, cx1, cy1, cx2, cy2, x2, y2, output, o, tangents || (i > 0 && space < PathConstraint.Epsilon)); } return(output); }
private float[] ComputeWorldPositions(PathAttachment path, int spacesCount, bool tangents, bool percentPosition, bool percentSpacing) { float[] numArray3; float num5; float num22; float num23; float num24; float num25; float num26; float num27; float num28; float num29; Slot target = this.target; float position = this.position; float[] items = this.spaces.Items; float[] output = this.positions.Resize((spacesCount * 3) + 2).Items; bool closed = path.Closed; int worldVerticesLength = path.WorldVerticesLength; int index = worldVerticesLength / 6; int num4 = -1; if (!path.ConstantSpeed) { float[] lengths = path.Lengths; index -= !closed ? 2 : 1; num5 = lengths[index]; if (percentPosition) { position *= num5; } if (percentSpacing) { for (int j = 0; j < spacesCount; j++) { items[j] *= num5; } } numArray3 = this.world.Resize(8).Items; int num7 = 0; int num8 = 0; int num9 = 0; while (num7 < spacesCount) { float num12; float num10 = items[num7]; position += num10; float p = position; if (closed) { p = p % num5; if (p < 0f) { p += num5; } num9 = 0; } else { if (p < 0f) { if (num4 != -2) { num4 = -2; path.ComputeWorldVertices(target, 2, 4, numArray3, 0, 2); } AddBeforePosition(p, numArray3, 0, output, num8); goto Label_0263; } if (p > num5) { if (num4 != -3) { num4 = -3; path.ComputeWorldVertices(target, worldVerticesLength - 6, 4, numArray3, 0, 2); } AddAfterPosition(p - num5, numArray3, 0, output, num8); goto Label_0263; } } Label_017D: num12 = lengths[num9]; if (p <= num12) { if (num9 == 0) { p /= num12; } else { float num13 = lengths[num9 - 1]; p = (p - num13) / (num12 - num13); } } else { num9++; goto Label_017D; } if (num9 != num4) { num4 = num9; if (closed && (num9 == index)) { path.ComputeWorldVertices(target, worldVerticesLength - 4, 4, numArray3, 0, 2); path.ComputeWorldVertices(target, 0, 4, numArray3, 4, 2); } else { path.ComputeWorldVertices(target, (num9 * 6) + 2, 8, numArray3, 0, 2); } } AddCurvePosition(p, numArray3[0], numArray3[1], numArray3[2], numArray3[3], numArray3[4], numArray3[5], numArray3[6], numArray3[7], output, num8, tangents || ((num7 > 0) && (num10 < 1E-05f))); Label_0263: num7++; num8 += 3; } return(output); } if (closed) { worldVerticesLength += 2; numArray3 = this.world.Resize(worldVerticesLength).Items; path.ComputeWorldVertices(target, 2, worldVerticesLength - 4, numArray3, 0, 2); path.ComputeWorldVertices(target, 0, 2, numArray3, worldVerticesLength - 4, 2); numArray3[worldVerticesLength - 2] = numArray3[0]; numArray3[worldVerticesLength - 1] = numArray3[1]; } else { index--; worldVerticesLength -= 4; numArray3 = this.world.Resize(worldVerticesLength).Items; path.ComputeWorldVertices(target, 2, worldVerticesLength, numArray3, 0, 2); } float[] numArray5 = this.curves.Resize(index).Items; num5 = 0f; float num14 = numArray3[0]; float num15 = numArray3[1]; float num16 = 0f; float num17 = 0f; float num18 = 0f; float num19 = 0f; float num20 = 0f; float num21 = 0f; int num30 = 0; for (int i = 2; num30 < index; i += 6) { num16 = numArray3[i]; num17 = numArray3[i + 1]; num18 = numArray3[i + 2]; num19 = numArray3[i + 3]; num20 = numArray3[i + 4]; num21 = numArray3[i + 5]; num22 = ((num14 - (num16 * 2f)) + num18) * 0.1875f; num23 = ((num15 - (num17 * 2f)) + num19) * 0.1875f; num24 = ((((num16 - num18) * 3f) - num14) + num20) * 0.09375f; num25 = ((((num17 - num19) * 3f) - num15) + num21) * 0.09375f; num26 = (num22 * 2f) + num24; num27 = (num23 * 2f) + num25; num28 = (((num16 - num14) * 0.75f) + num22) + (num24 * 0.1666667f); num29 = (((num17 - num15) * 0.75f) + num23) + (num25 * 0.1666667f); num5 += (float)Math.Sqrt((double)((num28 * num28) + (num29 * num29))); num28 += num26; num29 += num27; num26 += num24; num27 += num25; num5 += (float)Math.Sqrt((double)((num28 * num28) + (num29 * num29))); num28 += num26; num29 += num27; num5 += (float)Math.Sqrt((double)((num28 * num28) + (num29 * num29))); num28 += num26 + num24; num29 += num27 + num25; num5 += (float)Math.Sqrt((double)((num28 * num28) + (num29 * num29))); numArray5[num30] = num5; num14 = num20; num15 = num21; num30++; } if (percentPosition) { position *= num5; } if (percentSpacing) { for (int j = 0; j < spacesCount; j++) { items[j] *= num5; } } float[] segments = this.segments; float num33 = 0f; int num34 = 0; int o = 0; int num36 = 0; int num37 = 0; while (num34 < spacesCount) { float num40; float num38 = items[num34]; position += num38; float p = position; if (closed) { p = p % num5; if (p < 0f) { p += num5; } num36 = 0; } else { if (p < 0f) { AddBeforePosition(p, numArray3, 0, output, o); goto Label_0883; } if (p > num5) { AddAfterPosition(p - num5, numArray3, worldVerticesLength - 4, output, o); goto Label_0883; } } Label_05CD: num40 = numArray5[num36]; if (p <= num40) { if (num36 == 0) { p /= num40; } else { float num41 = numArray5[num36 - 1]; p = (p - num41) / (num40 - num41); } } else { num36++; goto Label_05CD; } if (num36 != num4) { num4 = num36; int num42 = num36 * 6; num14 = numArray3[num42]; num15 = numArray3[num42 + 1]; num16 = numArray3[num42 + 2]; num17 = numArray3[num42 + 3]; num18 = numArray3[num42 + 4]; num19 = numArray3[num42 + 5]; num20 = numArray3[num42 + 6]; num21 = numArray3[num42 + 7]; num22 = ((num14 - (num16 * 2f)) + num18) * 0.03f; num23 = ((num15 - (num17 * 2f)) + num19) * 0.03f; num24 = ((((num16 - num18) * 3f) - num14) + num20) * 0.006f; num25 = ((((num17 - num19) * 3f) - num15) + num21) * 0.006f; num26 = (num22 * 2f) + num24; num27 = (num23 * 2f) + num25; num28 = (((num16 - num14) * 0.3f) + num22) + (num24 * 0.1666667f); num29 = (((num17 - num15) * 0.3f) + num23) + (num25 * 0.1666667f); num33 = (float)Math.Sqrt((double)((num28 * num28) + (num29 * num29))); segments[0] = num33; for (num42 = 1; num42 < 8; num42++) { num28 += num26; num29 += num27; num26 += num24; num27 += num25; num33 += (float)Math.Sqrt((double)((num28 * num28) + (num29 * num29))); segments[num42] = num33; } num28 += num26; num29 += num27; num33 += (float)Math.Sqrt((double)((num28 * num28) + (num29 * num29))); segments[8] = num33; num28 += num26 + num24; num29 += num27 + num25; num33 += (float)Math.Sqrt((double)((num28 * num28) + (num29 * num29))); segments[9] = num33; num37 = 0; } p *= num33; while (true) { float num43 = segments[num37]; if (p <= num43) { if (num37 == 0) { p /= num43; } else { float num44 = segments[num37 - 1]; p = num37 + ((p - num44) / (num43 - num44)); } break; } num37++; } AddCurvePosition(p * 0.1f, num14, num15, num16, num17, num18, num19, num20, num21, output, o, tangents || ((num34 > 0) && (num38 < 1E-05f))); Label_0883: num34++; o += 3; } return(output); }
private float[] ComputeWorldPositions(PathAttachment path, int spacesCount, bool tangents, bool percentPosition, bool percentSpacing) { Slot slot = this.target; float num = this.position; float[] items = this.spaces.Items; float[] items2 = this.positions.Resize(spacesCount * 3 + 2).Items; bool closed = path.Closed; int num2 = path.WorldVerticesLength; int num3 = num2 / 6; int num4 = -1; float num5; float[] items3; if (!path.ConstantSpeed) { float[] array = path.Lengths; num3 -= ((!closed) ? 2 : 1); num5 = array[num3]; if (percentPosition) { num *= num5; } if (percentSpacing) { for (int i = 0; i < spacesCount; i++) { items[i] *= num5; } } items3 = this.world.Resize(8).Items; int j = 0; int num6 = 0; int num7 = 0; while (j < spacesCount) { float num8 = items[j]; num += num8; float num9 = num; if (closed) { num9 %= num5; if (num9 < 0f) { num9 += num5; } num7 = 0; goto IL_178; } if (num9 < 0f) { if (num4 != -2) { num4 = -2; path.ComputeWorldVertices(slot, 2, 4, items3, 0); } this.AddBeforePosition(num9, items3, 0, items2, num6); } else { if (num9 <= num5) { goto IL_178; } if (num4 != -3) { num4 = -3; path.ComputeWorldVertices(slot, num2 - 6, 4, items3, 0); } this.AddAfterPosition(num9 - num5, items3, 0, items2, num6); } IL_261: j++; num6 += 3; continue; IL_178: float num10; for (;;) { num10 = array[num7]; if (num9 <= num10) { break; } num7++; } if (num7 == 0) { num9 /= num10; } else { float num11 = array[num7 - 1]; num9 = (num9 - num11) / (num10 - num11); } if (num7 != num4) { num4 = num7; if (closed && num7 == num3) { path.ComputeWorldVertices(slot, num2 - 4, 4, items3, 0); path.ComputeWorldVertices(slot, 0, 4, items3, 4); } else { path.ComputeWorldVertices(slot, num7 * 6 + 2, 8, items3, 0); } } this.AddCurvePosition(num9, items3[0], items3[1], items3[2], items3[3], items3[4], items3[5], items3[6], items3[7], items2, num6, tangents || (j > 0 && num8 == 0f)); goto IL_261; } return(items2); } if (closed) { num2 += 2; items3 = this.world.Resize(num2).Items; path.ComputeWorldVertices(slot, 2, num2 - 4, items3, 0); path.ComputeWorldVertices(slot, 0, 2, items3, num2 - 4); items3[num2 - 2] = items3[0]; items3[num2 - 1] = items3[1]; } else { num3--; num2 -= 4; items3 = this.world.Resize(num2).Items; path.ComputeWorldVertices(slot, 2, num2, items3, 0); } float[] items4 = this.curves.Resize(num3).Items; num5 = 0f; float num12 = items3[0]; float num13 = items3[1]; float num14 = 0f; float num15 = 0f; float num16 = 0f; float num17 = 0f; float num18 = 0f; float num19 = 0f; int k = 0; int num20 = 2; while (k < num3) { num14 = items3[num20]; num15 = items3[num20 + 1]; num16 = items3[num20 + 2]; num17 = items3[num20 + 3]; num18 = items3[num20 + 4]; num19 = items3[num20 + 5]; float num21 = (num12 - num14 * 2f + num16) * 0.1875f; float num22 = (num13 - num15 * 2f + num17) * 0.1875f; float num23 = ((num14 - num16) * 3f - num12 + num18) * 0.09375f; float num24 = ((num15 - num17) * 3f - num13 + num19) * 0.09375f; float num25 = num21 * 2f + num23; float num26 = num22 * 2f + num24; float num27 = (num14 - num12) * 0.75f + num21 + num23 * 0.166666672f; float num28 = (num15 - num13) * 0.75f + num22 + num24 * 0.166666672f; num5 += (float)Math.Sqrt((double)(num27 * num27 + num28 * num28)); num27 += num25; num28 += num26; num25 += num23; num26 += num24; num5 += (float)Math.Sqrt((double)(num27 * num27 + num28 * num28)); num27 += num25; num28 += num26; num5 += (float)Math.Sqrt((double)(num27 * num27 + num28 * num28)); num27 += num25 + num23; num28 += num26 + num24; num5 += (float)Math.Sqrt((double)(num27 * num27 + num28 * num28)); items4[k] = num5; num12 = num18; num13 = num19; k++; num20 += 6; } if (percentPosition) { num *= num5; } if (percentSpacing) { for (int l = 0; l < spacesCount; l++) { items[l] *= num5; } } float[] array2 = this.segments; float num29 = 0f; int m = 0; int num30 = 0; int num31 = 0; int num32 = 0; while (m < spacesCount) { float num33 = items[m]; num += num33; float num34 = num; if (closed) { num34 %= num5; if (num34 < 0f) { num34 += num5; } num31 = 0; goto IL_5C5; } if (num34 < 0f) { this.AddBeforePosition(num34, items3, 0, items2, num30); } else { if (num34 <= num5) { goto IL_5C5; } this.AddAfterPosition(num34 - num5, items3, num2 - 4, items2, num30); } IL_881: m++; num30 += 3; continue; IL_5C5: float num35; for (;;) { num35 = items4[num31]; if (num34 <= num35) { break; } num31++; } if (num31 == 0) { num34 /= num35; } else { float num36 = items4[num31 - 1]; num34 = (num34 - num36) / (num35 - num36); } if (num31 != num4) { num4 = num31; int n = num31 * 6; num12 = items3[n]; num13 = items3[n + 1]; num14 = items3[n + 2]; num15 = items3[n + 3]; num16 = items3[n + 4]; num17 = items3[n + 5]; num18 = items3[n + 6]; num19 = items3[n + 7]; float num21 = (num12 - num14 * 2f + num16) * 0.03f; float num22 = (num13 - num15 * 2f + num17) * 0.03f; float num23 = ((num14 - num16) * 3f - num12 + num18) * 0.006f; float num24 = ((num15 - num17) * 3f - num13 + num19) * 0.006f; float num25 = num21 * 2f + num23; float num26 = num22 * 2f + num24; float num27 = (num14 - num12) * 0.3f + num21 + num23 * 0.166666672f; float num28 = (num15 - num13) * 0.3f + num22 + num24 * 0.166666672f; num29 = (float)Math.Sqrt((double)(num27 * num27 + num28 * num28)); array2[0] = num29; for (n = 1; n < 8; n++) { num27 += num25; num28 += num26; num25 += num23; num26 += num24; num29 += (float)Math.Sqrt((double)(num27 * num27 + num28 * num28)); array2[n] = num29; } num27 += num25; num28 += num26; num29 += (float)Math.Sqrt((double)(num27 * num27 + num28 * num28)); array2[8] = num29; num27 += num25 + num23; num28 += num26 + num24; num29 += (float)Math.Sqrt((double)(num27 * num27 + num28 * num28)); array2[9] = num29; num32 = 0; } num34 *= num29; float num37; for (;;) { num37 = array2[num32]; if (num34 <= num37) { break; } num32++; } if (num32 == 0) { num34 /= num37; } else { float num38 = array2[num32 - 1]; num34 = (float)num32 + (num34 - num38) / (num37 - num38); } this.AddCurvePosition(num34 * 0.1f, num12, num13, num14, num15, num16, num17, num18, num19, items2, num30, tangents || (m > 0 && num33 == 0f)); goto IL_881; } return(items2); }
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); }
public static void DrawPath (Slot s, PathAttachment p, Transform t, bool includeName) { int worldVerticesLength = p.WorldVerticesLength; if (pathVertexBuffer == null || pathVertexBuffer.Length < worldVerticesLength) pathVertexBuffer = new float[worldVerticesLength]; float[] pv = pathVertexBuffer; p.ComputeWorldVertices(s, pv); var ocolor = Handles.color; Handles.color = SpineHandles.PathColor; Matrix4x4 m = t.localToWorldMatrix; const int step = 6; int n = worldVerticesLength - step; Vector3 p0, p1, p2, p3; for (int i = 2; i < n; i += step) { p0 = m.MultiplyPoint(new Vector3(pv[i], pv[i+1])); p1 = m.MultiplyPoint(new Vector3(pv[i+2], pv[i+3])); p2 = m.MultiplyPoint(new Vector3(pv[i+4], pv[i+5])); p3 = m.MultiplyPoint(new Vector3(pv[i+6], pv[i+7])); DrawCubicBezier(p0, p1, p2, p3); } n += step; if (p.Closed) { p0 = m.MultiplyPoint(new Vector3(pv[n - 4], pv[n - 3])); p1 = m.MultiplyPoint(new Vector3(pv[n - 2], pv[n - 1])); p2 = m.MultiplyPoint(new Vector3(pv[0], pv[1])); p3 = m.MultiplyPoint(new Vector3(pv[2], pv[3])); DrawCubicBezier(p0, p1, p2, p3); } const float endCapSize = 0.05f; Vector3 firstPoint = m.MultiplyPoint(new Vector3(pv[2], pv[3])); Handles.DotCap(0, firstPoint, Quaternion.identity, endCapSize * HandleUtility.GetHandleSize(firstPoint)); // if (!p.Closed) Handles.DotCap(0, m.MultiplyPoint(new Vector3(pv[n - 4], pv[n - 3])), q, endCapSize); if (includeName) Handles.Label(firstPoint + new Vector3(0,0.1f), p.Name, PathNameStyle); Handles.color = ocolor; }