UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2025-12-20 17:26:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

[csharp] Fixed port of ConvexDecomposer, SkeletonClipping

Browse Source
This commit is contained in:
badlogic 2017-04-19 15:15:37 +02:00
parent 69711476fc
commit 4cd5ccc5b8
2 changed files with 249 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
spine-csharp/src/ConvexDecomposer.cs
View File

@ -42,9 +42,9 @@ namespace Spine {
private readonly Pool<ExposedList<float>> polygonPool = new Pool<ExposedList<float>>(); private readonly Pool<ExposedList<float>> polygonPool = new Pool<ExposedList<float>>();
private readonly Pool<ExposedList<short>> polygonIndicesPool = new Pool<ExposedList<short>>(); private readonly Pool<ExposedList<short>> polygonIndicesPool = new Pool<ExposedList<short>>();
public ExposedList<ExposedList<float>> Decompose(float[] input) { public ExposedList<ExposedList<float>> Decompose(ExposedList<float> input) {
var vertices = input; var vertices = input.Items;
int vertexCount = input.Length >> 1; int vertexCount = input.Count >> 1;
var indicesArray = this.indicesArray; var indicesArray = this.indicesArray;
indicesArray.Clear(); indicesArray.Clear();

495
spine-csharp/src/SkeletonClipping.cs
View File

@ -32,288 +32,285 @@ using System;
namespace Spine { namespace Spine {
public class SkeletonClipping { public class SkeletonClipping {
// private final ConvexDecomposer decomposer = new ConvexDecomposer(); private readonly ConvexDecomposer decomposer = new ConvexDecomposer();
// private final FloatArray clippingPolygon = new FloatArray(); private readonly ExposedList<float> clippingPolygon = new ExposedList<float>();
// private final FloatArray clipOutput = new FloatArray(128); private readonly ExposedList<float> clipOutput = new ExposedList<float>(128);
// private final FloatArray clippedVertices = new FloatArray(128); private readonly ExposedList<float> clippedVertices = new ExposedList<float>(128);
// private final ShortArray clippedTriangles = new ShortArray(128); private readonly ExposedList<short> clippedTriangles = new ExposedList<short>(128);
// private final FloatArray scratch = new FloatArray(); private readonly ExposedList<float> scratch = new ExposedList<float>();
// private ClippingAttachment clipAttachment; private ClippingAttachment clipAttachment;
// private Array<FloatArray> clippingPolygons; private ExposedList<ExposedList<float>> clippingPolygons;
// public void clipStart(Slot slot, ClippingAttachment clip) { public ExposedList<float> ClippedVertices { get { return clippedVertices; } }
// if (clipAttachment != null) return; public ExposedList<short> ClippedTriangles { get { return clippedTriangles; } }
// clipAttachment = clip;
// int n = clip.getWorldVerticesLength(); public void ClipStart(Slot slot, ClippingAttachment clip) {
// float[] vertices = clippingPolygon.setSize(n); if (clipAttachment != null) return;
// clip.computeWorldVertices(slot, 0, n, vertices, 0, 2); clipAttachment = clip;
// makeClockwise(clippingPolygon);
// clippingPolygons = decomposer.decompose(clippingPolygon);
// for (FloatArray polygon : clippingPolygons) {
// makeClockwise(polygon);
// polygon.add(polygon.items[0]);
// polygon.add(polygon.items[1]);
// }
// }
// public void clipEnd(Slot slot) { int n = clip.worldVerticesLength;
// if (clipAttachment != null && clipAttachment.getEndSlot() == slot.getData()) clipEnd(); float[] vertices = clippingPolygon.Resize(n).Items;
// } clip.ComputeWorldVertices(slot, 0, n, vertices, 0, 2);
MakeClockwise(clippingPolygon);
clippingPolygons = decomposer.Decompose(clippingPolygon);
foreach (var polygon in clippingPolygons) {
MakeClockwise(polygon);
polygon.Add(polygon.Items[0]);
polygon.Add(polygon.Items[1]);
}
}
// public void clipEnd() { public void ClipEnd(Slot slot) {
// if (clipAttachment == null) return; if (clipAttachment != null && clipAttachment.endSlot == slot.data) ClipEnd();
// clipAttachment = null; }
// clippingPolygons = null;
// clippedVertices.clear();
// clippedTriangles.clear();
// clippingPolygon.clear();
// }
// public boolean isClipping() { public void ClipEnd() {
// return clipAttachment != null; if (clipAttachment == null) return;
// } clipAttachment = null;
clippingPolygons = null;
clippedVertices.Clear();
clippedTriangles.Clear();
clippingPolygon.Clear();
}
// public void clipTriangles(float[] vertices, int verticesLength, short[] triangles, int trianglesLength, float[] uvs, public bool IsClipping() {
// float light, float dark, boolean twoColor) { return clipAttachment != null;
}
// FloatArray clipOutput = this.clipOutput, clippedVertices = this.clippedVertices; public void ClipTriangles(float[] vertices, int verticesLength, short[] triangles, int trianglesLength, float[] uvs,
// ShortArray clippedTriangles = this.clippedTriangles; float light, float dark, bool twoColor) {
// Object[] polygons = clippingPolygons.items;
// int polygonsCount = clippingPolygons.size;
// int vertexSize = twoColor ? 6 : 5;
// short index = 0; ExposedList<float> clipOutput = this.clipOutput, clippedVertices = this.clippedVertices;
// clippedVertices.clear(); var clippedTriangles = this.clippedTriangles;
// clippedTriangles.clear(); var polygons = clippingPolygons.Items;
// outer: int polygonsCount = clippingPolygons.Count;
// for (int i = 0; i < trianglesLength; i += 3) { int vertexSize = twoColor ? 6 : 5;
// 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; short index = 0;
// float x2 = vertices[vertexOffset], y2 = vertices[vertexOffset + 1]; clippedVertices.Clear();
// float u2 = uvs[vertexOffset], v2 = uvs[vertexOffset + 1]; clippedTriangles.Clear();
outer:
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 + 2] << 1; vertexOffset = triangles[i + 1] << 1;
// float x3 = vertices[vertexOffset], y3 = vertices[vertexOffset + 1]; float x2 = vertices[vertexOffset], y2 = vertices[vertexOffset + 1];
// float u3 = uvs[vertexOffset], v3 = uvs[vertexOffset + 1]; float u2 = uvs[vertexOffset], v2 = uvs[vertexOffset + 1];
// for (int p = 0; p < polygonsCount; p++) { vertexOffset = triangles[i + 2] << 1;
// int s = clippedVertices.size; float x3 = vertices[vertexOffset], y3 = vertices[vertexOffset + 1];
// if (clip(x1, y1, x2, y2, x3, y3, (FloatArray)polygons[p], clipOutput)) { float u3 = uvs[vertexOffset], v3 = uvs[vertexOffset + 1];
// int clipOutputLength = clipOutput.size;
// 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; for (int p = 0; p < polygonsCount; p++) {
// float[] clipOutputItems = clipOutput.items; int s = clippedVertices.Count;
// float[] clippedVerticesItems = clippedVertices.setSize(s + clipOutputCount * vertexSize); if (Clip(x1, y1, x2, y2, x3, y3, polygons[p], clipOutput)) {
// for (int ii = 0; ii < clipOutputLength; ii += 2) { int clipOutputLength = clipOutput.Count;
// float x = clipOutputItems[ii], y = clipOutputItems[ii + 1]; if (clipOutputLength == 0) continue;
// clippedVerticesItems[s] = x; float d0 = y2 - y3, d1 = x3 - x2, d2 = x1 - x3, d4 = y3 - y1;
// clippedVerticesItems[s + 1] = y; float d = 1 / (d0 * d2 + d1 * (y1 - y3));
// clippedVerticesItems[s + 2] = light;
// if (twoColor) {
// clippedVerticesItems[s + 3] = dark;
// s += 4;
// }
// else
// s += 3;
// 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;
// clippedVerticesItems[s] = u1 * a + u2 * b + u3 * c;
// clippedVerticesItems[s + 1] = v1 * a + v2 * b + v3 * c;
// s += 2;
// }
// s = clippedTriangles.size; int clipOutputCount = clipOutputLength >> 1;
// short[] clippedTrianglesItems = clippedTriangles.setSize(s + 3 * (clipOutputCount - 2)); float[] clipOutputItems = clipOutput.Items;
// clipOutputCount--; float[] clippedVerticesItems = clippedVertices.Resize(s + clipOutputCount * vertexSize).Items;
// for (int ii = 1; ii < clipOutputCount; ii++) { for (int ii = 0; ii < clipOutputLength; ii += 2) {
// clippedTrianglesItems[s] = index; float x = clipOutputItems[ii], y = clipOutputItems[ii + 1];
// clippedTrianglesItems[s + 1] = (short)(index + ii); clippedVerticesItems[s] = x;
// clippedTrianglesItems[s + 2] = (short)(index + ii + 1); clippedVerticesItems[s + 1] = y;
// s += 3; clippedVerticesItems[s + 2] = light;
// } if (twoColor) {
// index += clipOutputCount + 1; clippedVerticesItems[s + 3] = dark;
s += 4;
}
else
s += 3;
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;
clippedVerticesItems[s] = u1 * a + u2 * b + u3 * c;
clippedVerticesItems[s + 1] = v1 * a + v2 * b + v3 * c;
s += 2;
}
// } s = clippedTriangles.Count;
// else { short[] clippedTrianglesItems = clippedTriangles.Resize(s + 3 * (clipOutputCount - 2)).Items;
// float[] clippedVerticesItems = clippedVertices.setSize(s + 3 * vertexSize); clipOutputCount--;
// clippedVerticesItems[s] = x1; for (int ii = 1; ii < clipOutputCount; ii++) {
// clippedVerticesItems[s + 1] = y1; clippedTrianglesItems[s] = index;
// clippedVerticesItems[s + 2] = light; clippedTrianglesItems[s + 1] = (short)(index + ii);
// if (!twoColor) { clippedTrianglesItems[s + 2] = (short)(index + ii + 1);
// clippedVerticesItems[s + 3] = u1; s += 3;
// clippedVerticesItems[s + 4] = v1; }
index += (short)(clipOutputCount + 1);
// clippedVerticesItems[s + 5] = x2; }
// clippedVerticesItems[s + 6] = y2; else {
// clippedVerticesItems[s + 7] = light; float[] clippedVerticesItems = clippedVertices.Resize(s + 3 * vertexSize).Items;
// clippedVerticesItems[s + 8] = u2; clippedVerticesItems[s] = x1;
// clippedVerticesItems[s + 9] = v2; clippedVerticesItems[s + 1] = y1;
clippedVerticesItems[s + 2] = light;
if (!twoColor) {
clippedVerticesItems[s + 3] = u1;
clippedVerticesItems[s + 4] = v1;
// clippedVerticesItems[s + 10] = x3; clippedVerticesItems[s + 5] = x2;
// clippedVerticesItems[s + 11] = y3; clippedVerticesItems[s + 6] = y2;
// clippedVerticesItems[s + 12] = light; clippedVerticesItems[s + 7] = light;
// clippedVerticesItems[s + 13] = u3; clippedVerticesItems[s + 8] = u2;
// clippedVerticesItems[s + 14] = v3; clippedVerticesItems[s + 9] = v2;
// }
// else {
// clippedVerticesItems[s + 3] = dark;
// clippedVerticesItems[s + 4] = u1;
// clippedVerticesItems[s + 5] = v1;
// clippedVerticesItems[s + 6] = x2; clippedVerticesItems[s + 10] = x3;
// clippedVerticesItems[s + 7] = y2; clippedVerticesItems[s + 11] = y3;
// clippedVerticesItems[s + 8] = light; clippedVerticesItems[s + 12] = light;
// clippedVerticesItems[s + 9] = dark; clippedVerticesItems[s + 13] = u3;
// clippedVerticesItems[s + 10] = u2; clippedVerticesItems[s + 14] = v3;
// clippedVerticesItems[s + 11] = v2; }
else {
clippedVerticesItems[s + 3] = dark;
clippedVerticesItems[s + 4] = u1;
clippedVerticesItems[s + 5] = v1;
// clippedVerticesItems[s + 12] = x3; clippedVerticesItems[s + 6] = x2;
// clippedVerticesItems[s + 13] = y3; clippedVerticesItems[s + 7] = y2;
// clippedVerticesItems[s + 14] = light; clippedVerticesItems[s + 8] = light;
// clippedVerticesItems[s + 15] = dark; clippedVerticesItems[s + 9] = dark;
// clippedVerticesItems[s + 16] = u3; clippedVerticesItems[s + 10] = u2;
// clippedVerticesItems[s + 17] = v3; clippedVerticesItems[s + 11] = v2;
// }
// s = clippedTriangles.size; clippedVerticesItems[s + 12] = x3;
// short[] clippedTrianglesItems = clippedTriangles.setSize(s + 3); clippedVerticesItems[s + 13] = y3;
// clippedTrianglesItems[s] = index; clippedVerticesItems[s + 14] = light;
// clippedTrianglesItems[s + 1] = (short)(index + 1); clippedVerticesItems[s + 15] = dark;
// clippedTrianglesItems[s + 2] = (short)(index + 2); clippedVerticesItems[s + 16] = u3;
// index += 3; clippedVerticesItems[s + 17] = v3;
// continue outer; }
// }
// }
// }
// }
// /** Clips the input triangle against the convex, clockwise clipping area. If the triangle lies entirely within the clipping s = clippedTriangles.Count;
// * area, false is returned. The clipping area must duplicate the first vertex at the end of the vertices list. */ short[] clippedTrianglesItems = clippedTriangles.Resize(s + 3).Items;
// boolean clip(float x1, float y1, float x2, float y2, float x3, float y3, FloatArray clippingArea, FloatArray output) { clippedTrianglesItems[s] = index;
// FloatArray originalOutput = output; clippedTrianglesItems[s + 1] = (short)(index + 1);
// boolean clipped = false; clippedTrianglesItems[s + 2] = (short)(index + 2);
index += 3;
goto outer;
}
}
}
}
// // Avoid copy at the end. /** Clips the input triangle against the convex, clockwise clipping area. If the triangle lies entirely within the clipping
// FloatArray input = null; * area, false is returned. The clipping area must duplicate the first vertex at the end of the vertices list. */
// if (clippingArea.size % 4 >= 2) { internal bool Clip(float x1, float y1, float x2, float y2, float x3, float y3, ExposedList<float> clippingArea, ExposedList<float> output) {
// input = output; var originalOutput = output;
// output = scratch; var clipped = false;
// }
// else
// input = scratch;
// input.clear(); // Avoid copy at the end.
// input.add(x1); ExposedList<float> input = null;
// input.add(y1); if (clippingArea.Count % 4 >= 2) {
// input.add(x2); input = output;
// input.add(y2); output = scratch;
// input.add(x3); }
// input.add(y3); else
// input.add(x1); input = scratch;
// input.add(y1);
// output.clear();
// float[] clippingVertices = clippingArea.items; input.Clear();
// int clippingVerticesLast = clippingArea.size - 4; input.Add(x1);
// for (int i = 0; ; i += 2) { input.Add(y1);
// float edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1]; input.Add(x2);
// float edgeX2 = clippingVertices[i + 2], edgeY2 = clippingVertices[i + 3]; input.Add(y2);
// float deltaX = edgeX - edgeX2, deltaY = edgeY - edgeY2; input.Add(x3);
input.Add(y3);
input.Add(x1);
input.Add(y1);
output.Clear();
// float[] inputVertices = input.items; float[] clippingVertices = clippingArea.Items;
// int inputVerticesLength = input.size - 2, outputStart = output.size; int clippingVerticesLast = clippingArea.Count - 4;
// for (int ii = 0; ii < inputVerticesLength; ii += 2) { for (int i = 0; ; i += 2) {
// float inputX = inputVertices[ii], inputY = inputVertices[ii + 1]; float edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1];
// float inputX2 = inputVertices[ii + 2], inputY2 = inputVertices[ii + 3]; float edgeX2 = clippingVertices[i + 2], edgeY2 = clippingVertices[i + 3];
// boolean side2 = deltaX * (inputY2 - edgeY2) - deltaY * (inputX2 - edgeX2) > 0; float deltaX = edgeX - edgeX2, deltaY = edgeY - edgeY2;
// if (deltaX * (inputY - edgeY2) - deltaY * (inputX - edgeX2) > 0) {
// if (side2) { // v1 inside, v2 inside
// output.add(inputX2);
// output.add(inputY2);
// continue;
// }
// // v1 inside, v2 outside
// float c0 = inputY2 - inputY, c2 = inputX2 - inputX;
// float ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / (c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY));
// output.add(edgeX + (edgeX2 - edgeX) * ua);
// output.add(edgeY + (edgeY2 - edgeY) * ua);
// }
// else if (side2) { // v1 outside, v2 inside
// float c0 = inputY2 - inputY, c2 = inputX2 - inputX;
// float ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / (c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY));
// output.add(edgeX + (edgeX2 - edgeX) * ua);
// output.add(edgeY + (edgeY2 - edgeY) * ua);
// output.add(inputX2);
// output.add(inputY2);
// }
// clipped = true;
// }
// if (outputStart == output.size) { // All edges outside. float[] inputVertices = input.Items;
// originalOutput.clear(); int inputVerticesLength = input.Count - 2, outputStart = output.Count;
// return true; for (int ii = 0; ii < inputVerticesLength; ii += 2) {
// } float inputX = inputVertices[ii], inputY = inputVertices[ii + 1];
float inputX2 = inputVertices[ii + 2], inputY2 = inputVertices[ii + 3];
bool side2 = deltaX * (inputY2 - edgeY2) - deltaY * (inputX2 - edgeX2) > 0;
if (deltaX * (inputY - edgeY2) - deltaY * (inputX - edgeX2) > 0) {
if (side2) { // v1 inside, v2 inside
output.Add(inputX2);
output.Add(inputY2);
continue;
}
// v1 inside, v2 outside
float c0 = inputY2 - inputY, c2 = inputX2 - inputX;
float ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / (c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY));
output.Add(edgeX + (edgeX2 - edgeX) * ua);
output.Add(edgeY + (edgeY2 - edgeY) * ua);
}
else if (side2) { // v1 outside, v2 inside
float c0 = inputY2 - inputY, c2 = inputX2 - inputX;
float ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / (c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY));
output.Add(edgeX + (edgeX2 - edgeX) * ua);
output.Add(edgeY + (edgeY2 - edgeY) * ua);
output.Add(inputX2);
output.Add(inputY2);
}
clipped = true;
}
// output.add(output.items[0]); if (outputStart == output.Count) { // All edges outside.
// output.add(output.items[1]); originalOutput.Clear();
return true;
}
// if (i == clippingVerticesLast) break; output.Add(output.Items[0]);
// FloatArray temp = output; output.Add(output.Items[1]);
// output = input;
// output.clear();
// input = temp;
// }
// if (originalOutput != output) { if (i == clippingVerticesLast) break;
// originalOutput.clear(); var temp = output;
// originalOutput.addAll(output.items, 0, output.size - 2); output = input;
// } output.Clear();
// else input = temp;
// originalOutput.setSize(originalOutput.size - 2); }
// return clipped; if (originalOutput != output) {
// } originalOutput.Clear();
for (int i = 0, n = output.Count - 2; i < n; i++) {
originalOutput.Add(output.Items[i]);
}
}
else
originalOutput.Resize(originalOutput.Count - 2);
// public FloatArray getClippedVertices() { return clipped;
// return clippedVertices; }
// }
// public ShortArray getClippedTriangles() { static void MakeClockwise(ExposedList<float> polygon) {
// return clippedTriangles; float[] vertices = polygon.Items;
// } int verticeslength = polygon.Count;
// static void makeClockwise(FloatArray polygon) { float area = vertices[verticeslength - 2] * vertices[1] - vertices[0] * vertices[verticeslength - 1], p1x, p1y, p2x, p2y;
// float[] vertices = polygon.items; for (int i = 0, n = verticeslength - 3; i < n; i += 2) {
// int verticeslength = polygon.size; p1x = vertices[i];
p1y = vertices[i + 1];
p2x = vertices[i + 2];
p2y = vertices[i + 3];
area += p1x * p2y - p2x * p1y;
}
if (area < 0) return;
// float area = vertices[verticeslength - 2] * vertices[1] - vertices[0] * vertices[verticeslength - 1], p1x, p1y, p2x, p2y; for (int i = 0, lastX = verticeslength - 2, n = verticeslength >> 1; i < n; i += 2) {
// for (int i = 0, n = verticeslength - 3; i < n; i += 2) { float x = vertices[i], y = vertices[i + 1];
// p1x = vertices[i]; int other = lastX - i;
// p1y = vertices[i + 1]; vertices[i] = vertices[other];
// p2x = vertices[i + 2]; vertices[i + 1] = vertices[other + 1];
// p2y = vertices[i + 3]; vertices[other] = x;
// area += p1x * p2y - p2x * p1y; vertices[other + 1] = y;
// } }
// if (area < 0) return; }
// for (int i = 0, lastX = verticeslength - 2, n = verticeslength >> 1; i < n; i += 2) {
// float x = vertices[i], y = vertices[i + 1];
// int other = lastX - i;
// vertices[i] = vertices[other];
// vertices[i + 1] = vertices[other + 1];
// vertices[other] = x;
// vertices[other + 1] = y;
// }
// }
} }
} }