mirror of https://github.com/axmolengine/axmol.git
314 lines
12 KiB
C
314 lines
12 KiB
C
|
/******************************************************************************
|
||
|
|
* Spine Runtimes Software License v2.5
|
||
|
|
*
|
||
|
|
* Copyright (c) 2013-2016, Esoteric Software
|
||
|
|
* All rights reserved.
|
||
|
|
*
|
||
|
|
* You are granted a perpetual, non-exclusive, non-sublicensable, and
|
||
|
|
* non-transferable license to use, install, execute, and perform the Spine
|
||
|
|
* Runtimes software and derivative works solely for personal or internal
|
||
|
|
* use. Without the written permission of Esoteric Software (see Section 2 of
|
||
|
|
* the Spine Software License Agreement), you may not (a) modify, translate,
|
||
|
|
* adapt, or develop new applications using the Spine Runtimes or otherwise
|
||
|
|
* create derivative works or improvements of the Spine Runtimes or (b) remove,
|
||
|
|
* delete, alter, or obscure any trademarks or any copyright, trademark, patent,
|
||
|
|
* or other intellectual property or proprietary rights notices on or in the
|
||
|
|
* Software, including any copy thereof. Redistributions in binary or source
|
||
|
|
* form must include this license and terms.
|
||
|
|
*
|
||
|
|
* THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "AS IS" AND ANY EXPRESS OR
|
||
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
||
|
|
* EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS INTERRUPTION, OR LOSS OF
|
||
|
|
* USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
|
||
|
|
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
||
|
|
*****************************************************************************/
|
||
|
|
|
||
|
|
#include <spine/SkeletonClipping.h>
|
||
|
|
#include <spine/extension.h>
|
||
|
|
|
||
|
|
spSkeletonClipping* spSkeletonClipping_create() {
|
||
|
|
spSkeletonClipping* clipping = CALLOC(spSkeletonClipping, 1);
|
||
|
|
|
||
|
|
clipping->triangulator = spTriangulator_create();
|
||
|
|
clipping->clippingPolygon = spFloatArray_create(128);
|
||
|
|
clipping->clipOutput = spFloatArray_create(128);
|
||
|
|
clipping->clippedVertices = spFloatArray_create(128);
|
||
|
|
clipping->clippedUVs = spFloatArray_create(128);
|
||
|
|
clipping->clippedTriangles = spUnsignedShortArray_create(128);
|
||
|
|
clipping->scratch = spFloatArray_create(128);
|
||
|
|
|
||
|
|
return clipping;
|
||
|
|
}
|
||
|
|
|
||
|
|
void spSkeletonClipping_dispose(spSkeletonClipping* self) {
|
||
|
|
spTriangulator_dispose(self->triangulator);
|
||
|
|
spFloatArray_dispose(self->clippingPolygon);
|
||
|
|
spFloatArray_dispose(self->clipOutput);
|
||
|
|
spFloatArray_dispose(self->clippedVertices);
|
||
|
|
spFloatArray_dispose(self->clippedUVs);
|
||
|
|
spUnsignedShortArray_dispose(self->clippedTriangles);
|
||
|
|
spFloatArray_dispose(self->scratch);
|
||
|
|
FREE(self);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void _makeClockwise (spFloatArray* polygon) {
|
||
|
|
int i, n, lastX;
|
||
|
|
float* vertices = polygon->items;
|
||
|
|
int verticeslength = polygon->size;
|
||
|
|
|
||
|
|
float area = vertices[verticeslength - 2] * vertices[1] - vertices[0] * vertices[verticeslength - 1], p1x, p1y, p2x, p2y;
|
||
|
|
for (i = 0, n = verticeslength - 3; i < n; i += 2) {
|
||
|
|
p1x = vertices[i];
|
||
|
|
p1y = vertices[i + 1];
|
||
|
|
p2x = vertices[i + 2];
|
||
|
|
p2y = vertices[i + 3];
|
||
|
|
area += p1x * p2y - p2x * p1y;
|
||
|
|
}
|
||
|
|
if (area < 0) return;
|
||
|
|
|
||
|
|
for (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;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
int spSkeletonClipping_clipStart(spSkeletonClipping* self, spSlot* slot, spClippingAttachment* clip) {
|
||
|
|
int i, n;
|
||
|
|
float* vertices;
|
||
|
|
if (self->clipAttachment) return 0;
|
||
|
|
self->clipAttachment = clip;
|
||
|
|
|
||
|
|
n = clip->super.worldVerticesLength;
|
||
|
|
vertices = spFloatArray_setSize(self->clippingPolygon, n)->items;
|
||
|
|
spVertexAttachment_computeWorldVertices(SUPER(clip), slot, 0, n, vertices, 0, 2);
|
||
|
|
_makeClockwise(self->clippingPolygon);
|
||
|
|
self->clippingPolygons = spTriangulator_decompose(self->triangulator, self->clippingPolygon, spTriangulator_triangulate(self->triangulator, self->clippingPolygon));
|
||
|
|
for (i = 0, n = self->clippingPolygons->size; i < n; i++) {
|
||
|
|
spFloatArray* polygon = self->clippingPolygons->items[i];
|
||
|
|
_makeClockwise(polygon);
|
||
|
|
spFloatArray_add(polygon, polygon->items[0]);
|
||
|
|
spFloatArray_add(polygon, polygon->items[1]);
|
||
|
|
}
|
||
|
|
return self->clippingPolygons->size;
|
||
|
|
}
|
||
|
|
|
||
|
|
void spSkeletonClipping_clipEnd(spSkeletonClipping* self, spSlot* slot) {
|
||
|
|
if (self->clipAttachment != 0 && self->clipAttachment->endSlot == slot->data) spSkeletonClipping_clipEnd2(self);
|
||
|
|
}
|
||
|
|
|
||
|
|
void spSkeletonClipping_clipEnd2(spSkeletonClipping* self) {
|
||
|
|
if (!self->clipAttachment) return;
|
||
|
|
self->clipAttachment = 0;
|
||
|
|
self->clippingPolygons = 0;
|
||
|
|
spFloatArray_clear(self->clippedVertices);
|
||
|
|
spFloatArray_clear(self->clippedUVs);
|
||
|
|
spUnsignedShortArray_clear(self->clippedTriangles);
|
||
|
|
spFloatArray_clear(self->clippingPolygon);
|
||
|
|
}
|
||
|
|
|
||
|
|
int /*boolean*/ spSkeletonClipping_isClipping(spSkeletonClipping* self) {
|
||
|
|
return self->clipAttachment != 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int /*boolean*/ _clip(spSkeletonClipping* self, float x1, float y1, float x2, float y2, float x3, float y3, spFloatArray* clippingArea, spFloatArray* output) {
|
||
|
|
int i;
|
||
|
|
spFloatArray* originalOutput = output;
|
||
|
|
int clipped = 0;
|
||
|
|
float* clippingVertices;
|
||
|
|
int clippingVerticesLast;
|
||
|
|
|
||
|
|
spFloatArray* input = 0;
|
||
|
|
if (clippingArea->size % 4 >= 2) {
|
||
|
|
input = output;
|
||
|
|
output = self->scratch;
|
||
|
|
} else
|
||
|
|
input = self->scratch;
|
||
|
|
|
||
|
|
spFloatArray_clear(input);
|
||
|
|
spFloatArray_add(input, x1);
|
||
|
|
spFloatArray_add(input, y1);
|
||
|
|
spFloatArray_add(input, x2);
|
||
|
|
spFloatArray_add(input, y2);
|
||
|
|
spFloatArray_add(input, x3);
|
||
|
|
spFloatArray_add(input, y3);
|
||
|
|
spFloatArray_add(input, x1);
|
||
|
|
spFloatArray_add(input, y1);
|
||
|
|
spFloatArray_clear(output);
|
||
|
|
|
||
|
|
clippingVertices = clippingArea->items;
|
||
|
|
clippingVerticesLast = clippingArea->size - 4;
|
||
|
|
for (i = 0;; i += 2) {
|
||
|
|
int ii;
|
||
|
|
spFloatArray* temp;
|
||
|
|
float edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1];
|
||
|
|
float edgeX2 = clippingVertices[i + 2], edgeY2 = clippingVertices[i + 3];
|
||
|
|
float deltaX = edgeX - edgeX2, deltaY = edgeY - edgeY2;
|
||
|
|
|
||
|
|
float* inputVertices = input->items;
|
||
|
|
int inputVerticesLength = input->size - 2, outputStart = output->size;
|
||
|
|
for (ii = 0; ii < inputVerticesLength; ii += 2) {
|
||
|
|
float inputX = inputVertices[ii], inputY = inputVertices[ii + 1];
|
||
|
|
float inputX2 = inputVertices[ii + 2], inputY2 = inputVertices[ii + 3];
|
||
|
|
int side2 = deltaX * (inputY2 - edgeY2) - deltaY * (inputX2 - edgeX2) > 0;
|
||
|
|
if (deltaX * (inputY - edgeY2) - deltaY * (inputX - edgeX2) > 0) {
|
||
|
|
float c0, c2;
|
||
|
|
float ua;
|
||
|
|
if (side2) {
|
||
|
|
spFloatArray_add(output, inputX2);
|
||
|
|
spFloatArray_add(output, inputY2);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
c0 = inputY2 - inputY, c2 = inputX2 - inputX;
|
||
|
|
ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / (c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY));
|
||
|
|
spFloatArray_add(output, edgeX + (edgeX2 - edgeX) * ua);
|
||
|
|
spFloatArray_add(output, edgeY + (edgeY2 - edgeY) * ua);
|
||
|
|
} else if (side2) {
|
||
|
|
float c0 = inputY2 - inputY, c2 = inputX2 - inputX;
|
||
|
|
float ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / (c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY));
|
||
|
|
spFloatArray_add(output, edgeX + (edgeX2 - edgeX) * ua);
|
||
|
|
spFloatArray_add(output, edgeY + (edgeY2 - edgeY) * ua);
|
||
|
|
spFloatArray_add(output, inputX2);
|
||
|
|
spFloatArray_add(output, inputY2);
|
||
|
|
}
|
||
|
|
clipped = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (outputStart == output->size) {
|
||
|
|
spFloatArray_clear(originalOutput);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
spFloatArray_add(output, output->items[0]);
|
||
|
|
spFloatArray_add(output, output->items[1]);
|
||
|
|
|
||
|
|
if (i == clippingVerticesLast) break;
|
||
|
|
temp = output;
|
||
|
|
output = input;
|
||
|
|
spFloatArray_clear(output);
|
||
|
|
input = temp;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (originalOutput != output) {
|
||
|
|
spFloatArray_clear(originalOutput);
|
||
|
|
spFloatArray_addAllValues(originalOutput, output->items, 0, output->size - 2);
|
||
|
|
} else
|
||
|
|
spFloatArray_setSize(originalOutput, originalOutput->size - 2);
|
||
|
|
|
||
|
|
return clipped;
|
||
|
|
}
|
||
|
|
|
||
|
|
void spSkeletonClipping_clipTriangles(spSkeletonClipping* self, float* vertices, int verticesLength, unsigned short* triangles, int trianglesLength, float* uvs, int stride) {
|
||
|
|
int i;
|
||
|
|
spFloatArray* clipOutput = self->clipOutput;
|
||
|
|
spFloatArray* clippedVertices = self->clippedVertices;
|
||
|
|
spFloatArray* clippedUVs = self->clippedUVs;
|
||
|
|
spUnsignedShortArray* clippedTriangles = self->clippedTriangles;
|
||
|
|
spFloatArray** polygons = self->clippingPolygons->items;
|
||
|
|
int polygonsCount = self->clippingPolygons->size;
|
||
|
|
|
||
|
|
short index = 0;
|
||
|
|
spFloatArray_clear(clippedVertices);
|
||
|
|
spFloatArray_clear(clippedUVs);
|
||
|
|
spUnsignedShortArray_clear(clippedTriangles);
|
||
|
|
i = 0;
|
||
|
|
outer:
|
||
|
|
for (; i < trianglesLength; i += 3) {
|
||
|
|
int p;
|
||
|
|
int vertexOffset = triangles[i] * stride;
|
||
|
|
float x2, y2, u2, v2, x3, y3, u3, v3;
|
||
|
|
float x1 = vertices[vertexOffset], y1 = vertices[vertexOffset + 1];
|
||
|
|
float u1 = uvs[vertexOffset], v1 = uvs[vertexOffset + 1];
|
||
|
|
|
||
|
|
vertexOffset = triangles[i + 1] * stride;
|
||
|
|
x2 = vertices[vertexOffset]; y2 = vertices[vertexOffset + 1];
|
||
|
|
u2 = uvs[vertexOffset]; v2 = uvs[vertexOffset + 1];
|
||
|
|
|
||
|
|
vertexOffset = triangles[i + 2] * stride;
|
||
|
|
x3 = vertices[vertexOffset]; y3 = vertices[vertexOffset + 1];
|
||
|
|
u3 = uvs[vertexOffset]; v3 = uvs[vertexOffset + 1];
|
||
|
|
|
||
|
|
for (p = 0; p < polygonsCount; p++) {
|
||
|
|
int s = clippedVertices->size;
|
||
|
|
if (_clip(self, x1, y1, x2, y2, x3, y3, polygons[p], clipOutput)) {
|
||
|
|
int ii;
|
||
|
|
float d0, d1, d2, d4, d;
|
||
|
|
unsigned short* clippedTrianglesItems;
|
||
|
|
int clipOutputCount;
|
||
|
|
float* clipOutputItems;
|
||
|
|
float* clippedVerticesItems;
|
||
|
|
float* clippedUVsItems;
|
||
|
|
|
||
|
|
int clipOutputLength = clipOutput->size;
|
||
|
|
if (clipOutputLength == 0) continue;
|
||
|
|
d0 = y2 - y3; d1 = x3 - x2; d2 = x1 - x3; d4 = y3 - y1;
|
||
|
|
d = 1 / (d0 * d2 + d1 * (y1 - y3));
|
||
|
|
|
||
|
|
clipOutputCount = clipOutputLength >> 1;
|
||
|
|
clipOutputItems = clipOutput->items;
|
||
|
|
clippedVerticesItems = spFloatArray_setSize(clippedVertices, s + (clipOutputCount << 1))->items;
|
||
|
|
clippedUVsItems = spFloatArray_setSize(clippedUVs, s + (clipOutputCount << 1))->items;
|
||
|
|
for (ii = 0; ii < clipOutputLength; ii += 2) {
|
||
|
|
float c0, c1, a, b, c;
|
||
|
|
float x = clipOutputItems[ii], y = clipOutputItems[ii + 1];
|
||
|
|
clippedVerticesItems[s] = x;
|
||
|
|
clippedVerticesItems[s + 1] = y;
|
||
|
|
c0 = x - x3; c1 = y - y3;
|
||
|
|
a = (d0 * c0 + d1 * c1) * d;
|
||
|
|
b = (d4 * c0 + d2 * c1) * d;
|
||
|
|
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->size;
|
||
|
|
clippedTrianglesItems = spUnsignedShortArray_setSize(clippedTriangles, s + 3 * (clipOutputCount - 2))->items;
|
||
|
|
clipOutputCount--;
|
||
|
|
for (ii = 1; ii < clipOutputCount; ii++) {
|
||
|
|
clippedTrianglesItems[s] = index;
|
||
|
|
clippedTrianglesItems[s + 1] = (unsigned short)(index + ii);
|
||
|
|
clippedTrianglesItems[s + 2] = (unsigned short)(index + ii + 1);
|
||
|
|
s += 3;
|
||
|
|
}
|
||
|
|
index += clipOutputCount + 1;
|
||
|
|
|
||
|
|
} else {
|
||
|
|
unsigned short* clippedTrianglesItems;
|
||
|
|
float* clippedVerticesItems = spFloatArray_setSize(clippedVertices, s + (3 << 1))->items;
|
||
|
|
float* clippedUVsItems = spFloatArray_setSize(clippedUVs, s + (3 << 1))->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->size;
|
||
|
|
clippedTrianglesItems = spUnsignedShortArray_setSize(clippedTriangles, s + 3)->items;
|
||
|
|
clippedTrianglesItems[s] = index;
|
||
|
|
clippedTrianglesItems[s + 1] = (unsigned short)(index + 1);
|
||
|
|
clippedTrianglesItems[s + 2] = (unsigned short)(index + 2);
|
||
|
|
index += 3;
|
||
|
|
i += 3;
|
||
|
|
goto outer;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|