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

[c][cpp] Fix formatting

Browse Source
This commit is contained in:
Mario Zechner 2024-06-28 15:38:51 +02:00
parent a58346ff64
commit 35d76de559
5 changed files with 110 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
spine-c/spine-c/src/spine/AnimationState.c
View File

@ -1070,7 +1070,7 @@ int spTrackEntry_wasApplied(spTrackEntry *entry) {
} }
int spTrackEntry_isNextReady(spTrackEntry *entry) { int spTrackEntry_isNextReady(spTrackEntry *entry) {
return entry->next != NULL && entry->nextTrackLast - entry->next->delay >= 0; return entry->next != NULL && entry->nextTrackLast - entry->next->delay >= 0;
} }
void _spTrackEntry_computeHold(spTrackEntry *entry, spAnimationState *state) { void _spTrackEntry_computeHold(spTrackEntry *entry, spAnimationState *state) {

76
spine-c/spine-c/src/spine/SkeletonClipping.c
View File

@ -149,50 +149,50 @@ _clip(spSkeletonClipping *self, float x1, float y1, float x2, float y2, float x3
spFloatArray_clear(output); spFloatArray_clear(output);
clippingVerticesLast = clippingArea->size - 4; clippingVerticesLast = clippingArea->size - 4;
clippingVertices = clippingArea->items; clippingVertices = clippingArea->items;
for (int i = 0;; i += 2) { for (int i = 0;; i += 2) {
spFloatArray *temp; spFloatArray *temp;
float edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1]; float edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1];
float ex = edgeX - clippingVertices[i + 2], ey = edgeY - clippingVertices[i + 3]; float ex = edgeX - clippingVertices[i + 2], ey = edgeY - clippingVertices[i + 3];
int outputStart = output->size; int outputStart = output->size;
float *inputVertices = input->items; float *inputVertices = input->items;
for (int ii = 0, nn = input->size - 2; ii < nn;) { for (int ii = 0, nn = input->size - 2; ii < nn;) {
float inputX = inputVertices[ii], inputY = inputVertices[ii + 1]; float inputX = inputVertices[ii], inputY = inputVertices[ii + 1];
ii += 2; ii += 2;
float inputX2 = inputVertices[ii], inputY2 = inputVertices[ii + 1]; float inputX2 = inputVertices[ii], inputY2 = inputVertices[ii + 1];
float s2 = ey * (edgeX - inputX2) > ex * (edgeY - inputY2); float s2 = ey * (edgeX - inputX2) > ex * (edgeY - inputY2);
float s1 = ey * (edgeX - inputX) - ex * (edgeY - inputY); float s1 = ey * (edgeX - inputX) - ex * (edgeY - inputY);
if (s1 > 0) { if (s1 > 0) {
if (s2) { // v1 inside, v2 inside if (s2) {// v1 inside, v2 inside
spFloatArray_add(output, inputX2); spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2); spFloatArray_add(output, inputY2);
continue; continue;
} }
// v1 inside, v2 outside // v1 inside, v2 outside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex); float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) { if (t >= 0 && t <= 1) {
spFloatArray_add(output, inputX + ix * t); spFloatArray_add(output, inputX + ix * t);
spFloatArray_add(output, inputY + iy * t); spFloatArray_add(output, inputY + iy * t);
} else { } else {
spFloatArray_add(output, inputX2); spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2); spFloatArray_add(output, inputY2);
} }
} else if (s2) { // v1 outside, v2 inside } else if (s2) {// v1 outside, v2 inside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex); float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) { if (t >= 0 && t <= 1) {
spFloatArray_add(output, inputX + ix * t); spFloatArray_add(output, inputX + ix * t);
spFloatArray_add(output, inputY + iy * t); spFloatArray_add(output, inputY + iy * t);
spFloatArray_add(output, inputX2); spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2); spFloatArray_add(output, inputY2);
} else { } else {
spFloatArray_add(output, inputX2); spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2); spFloatArray_add(output, inputY2);
continue; continue;
} }
} }
clipped = -1; clipped = -1;
} }
if (outputStart == output->size) { if (outputStart == output->size) {
spFloatArray_clear(originalOutput); spFloatArray_clear(originalOutput);

60
spine-cpp/spine-cpp-lite/spine-cpp-lite.cpp
View File

@ -135,7 +135,7 @@ typedef struct _spine_render_command {
float *positions; float *positions;
float *uvs; float *uvs;
int32_t *colors; int32_t *colors;
int32_t *darkColors; int32_t *darkColors;
int32_t numVertices; int32_t numVertices;
uint16_t *indices; uint16_t *indices;
int32_t numIndices; int32_t numIndices;
@ -654,7 +654,7 @@ static _spine_render_command *spine_render_command_create(BlockAllocator &alloca
cmd->positions = allocator.allocate<float>(numVertices << 1); cmd->positions = allocator.allocate<float>(numVertices << 1);
cmd->uvs = allocator.allocate<float>(numVertices << 1); cmd->uvs = allocator.allocate<float>(numVertices << 1);
cmd->colors = allocator.allocate<int32_t>(numVertices); cmd->colors = allocator.allocate<int32_t>(numVertices);
cmd->darkColors = allocator.allocate<int32_t>(numVertices); cmd->darkColors = allocator.allocate<int32_t>(numVertices);
cmd->numVertices = numVertices; cmd->numVertices = numVertices;
cmd->indices = allocator.allocate<uint16_t>(numIndices); cmd->indices = allocator.allocate<uint16_t>(numIndices);
cmd->numIndices = numIndices; cmd->numIndices = numIndices;
@ -699,7 +699,7 @@ static _spine_render_command *batch_sub_commands(BlockAllocator &allocator, Vect
float *positions = batched->positions; float *positions = batched->positions;
float *uvs = batched->uvs; float *uvs = batched->uvs;
int32_t *colors = batched->colors; int32_t *colors = batched->colors;
int32_t *darkColors = batched->darkColors; int32_t *darkColors = batched->darkColors;
uint16_t *indices = batched->indices; uint16_t *indices = batched->indices;
int indicesOffset = 0; int indicesOffset = 0;
for (int i = first; i <= last; i++) { for (int i = first; i <= last; i++) {
@ -707,14 +707,14 @@ static _spine_render_command *batch_sub_commands(BlockAllocator &allocator, Vect
memcpy(positions, cmd->positions, sizeof(float) * 2 * cmd->numVertices); memcpy(positions, cmd->positions, sizeof(float) * 2 * cmd->numVertices);
memcpy(uvs, cmd->uvs, sizeof(float) * 2 * cmd->numVertices); memcpy(uvs, cmd->uvs, sizeof(float) * 2 * cmd->numVertices);
memcpy(colors, cmd->colors, sizeof(int32_t) * cmd->numVertices); memcpy(colors, cmd->colors, sizeof(int32_t) * cmd->numVertices);
memcpy(darkColors, cmd->darkColors, sizeof(int32_t) * cmd->numVertices); memcpy(darkColors, cmd->darkColors, sizeof(int32_t) * cmd->numVertices);
for (int ii = 0; ii < cmd->numIndices; ii++) for (int ii = 0; ii < cmd->numIndices; ii++)
indices[ii] = cmd->indices[ii] + indicesOffset; indices[ii] = cmd->indices[ii] + indicesOffset;
indicesOffset += cmd->numVertices; indicesOffset += cmd->numVertices;
positions += 2 * cmd->numVertices; positions += 2 * cmd->numVertices;
uvs += 2 * cmd->numVertices; uvs += 2 * cmd->numVertices;
colors += cmd->numVertices; colors += cmd->numVertices;
darkColors += cmd->numVertices; darkColors += cmd->numVertices;
indices += cmd->numIndices; indices += cmd->numIndices;
} }
return batched; return batched;
@ -734,15 +734,15 @@ static _spine_render_command *batch_commands(BlockAllocator &allocator, Vector<_
while (i <= (int) commands.size()) { while (i <= (int) commands.size()) {
_spine_render_command *cmd = i < (int) commands.size() ? commands[i] : nullptr; _spine_render_command *cmd = i < (int) commands.size() ? commands[i] : nullptr;
if (cmd && cmd->numVertices == 0 && cmd->numIndices == 0) { if (cmd && cmd->numVertices == 0 && cmd->numIndices == 0) {
i++; i++;
continue; continue;
} }
if (cmd != nullptr && cmd->atlasPage == first->atlasPage && if (cmd != nullptr && cmd->atlasPage == first->atlasPage &&
cmd->blendMode == first->blendMode && cmd->blendMode == first->blendMode &&
cmd->colors[0] == first->colors[0] && cmd->colors[0] == first->colors[0] &&
cmd->darkColors[0] == first->darkColors[0] && cmd->darkColors[0] == first->darkColors[0] &&
numIndices + cmd->numIndices < 0xffff) { numIndices + cmd->numIndices < 0xffff) {
numVertices += cmd->numVertices; numVertices += cmd->numVertices;
numIndices += cmd->numIndices; numIndices += cmd->numIndices;
@ -848,11 +848,11 @@ spine_render_command spine_skeleton_drawable_render(spine_skeleton_drawable draw
uint8_t b = static_cast<uint8_t>(skeleton->getColor().b * slot.getColor().b * attachmentColor->b * 255); uint8_t b = static_cast<uint8_t>(skeleton->getColor().b * slot.getColor().b * attachmentColor->b * 255);
uint8_t a = static_cast<uint8_t>(skeleton->getColor().a * slot.getColor().a * attachmentColor->a * 255); uint8_t a = static_cast<uint8_t>(skeleton->getColor().a * slot.getColor().a * attachmentColor->a * 255);
uint32_t color = (a << 24) | (r << 16) | (g << 8) | b; uint32_t color = (a << 24) | (r << 16) | (g << 8) | b;
uint32_t darkColor = 0xff000000; uint32_t darkColor = 0xff000000;
if (slot.hasDarkColor()) { if (slot.hasDarkColor()) {
Color &slotDarkColor = slot.getDarkColor(); Color &slotDarkColor = slot.getDarkColor();
darkColor = 0xff000000 | (static_cast<uint8_t>(slotDarkColor.r * 255) << 16)| (static_cast<uint8_t>(slotDarkColor.g * 255) << 8)| static_cast<uint8_t>(slotDarkColor.b * 255); darkColor = 0xff000000 | (static_cast<uint8_t>(slotDarkColor.r * 255) << 16) | (static_cast<uint8_t>(slotDarkColor.g * 255) << 8) | static_cast<uint8_t>(slotDarkColor.b * 255);
} }
if (clipper.isClipping()) { if (clipper.isClipping()) {
clipper.clipTriangles(*worldVertices, *indices, *uvs, 2); clipper.clipTriangles(*worldVertices, *indices, *uvs, 2);
@ -868,9 +868,9 @@ spine_render_command spine_skeleton_drawable_render(spine_skeleton_drawable draw
memcpy(cmd->positions, vertices->buffer(), (verticesCount << 1) * sizeof(float)); memcpy(cmd->positions, vertices->buffer(), (verticesCount << 1) * sizeof(float));
memcpy(cmd->uvs, uvs->buffer(), (verticesCount << 1) * sizeof(float)); memcpy(cmd->uvs, uvs->buffer(), (verticesCount << 1) * sizeof(float));
for (int ii = 0; ii < verticesCount; ii++) { for (int ii = 0; ii < verticesCount; ii++) {
cmd->colors[ii] = color; cmd->colors[ii] = color;
cmd->darkColors[ii] = darkColor; cmd->darkColors[ii] = darkColor;
} }
memcpy(cmd->indices, indices->buffer(), indices->size() * sizeof(uint16_t)); memcpy(cmd->indices, indices->buffer(), indices->size() * sizeof(uint16_t));
clipper.clipEnd(slot); clipper.clipEnd(slot);
} }
@ -916,8 +916,8 @@ int32_t *spine_render_command_get_colors(spine_render_command command) {
} }
int32_t *spine_render_command_get_dark_colors(spine_render_command command) { int32_t *spine_render_command_get_dark_colors(spine_render_command command) {
if (!command) return nullptr; if (!command) return nullptr;
return ((_spine_render_command *) command)->darkColors; return ((_spine_render_command *) command)->darkColors;
} }
int32_t spine_render_command_get_num_vertices(spine_render_command command) { int32_t spine_render_command_get_num_vertices(spine_render_command command) {
@ -1448,15 +1448,15 @@ float spine_track_entry_get_track_complete(spine_track_entry entry) {
} }
spine_bool spine_track_entry_was_applied(spine_track_entry entry) { spine_bool spine_track_entry_was_applied(spine_track_entry entry) {
if (entry == nullptr) return false; if (entry == nullptr) return false;
TrackEntry *_entry = (TrackEntry *) entry; TrackEntry *_entry = (TrackEntry *) entry;
return _entry->wasApplied(); return _entry->wasApplied();
} }
spine_bool spine_track_entry_is_next_ready(spine_track_entry entry) { spine_bool spine_track_entry_is_next_ready(spine_track_entry entry) {
if (entry == nullptr) return false; if (entry == nullptr) return false;
TrackEntry *_entry = (TrackEntry *) entry; TrackEntry *_entry = (TrackEntry *) entry;
return _entry->isNextReady(); return _entry->isNextReady();
} }
// Skeleton // Skeleton
@ -1723,10 +1723,10 @@ void spine_skeleton_set_y(spine_skeleton skeleton, float y) {
} }
void spine_skeleton_set_scale(spine_skeleton skeleton, float scaleX, float scaleY) { void spine_skeleton_set_scale(spine_skeleton skeleton, float scaleX, float scaleY) {
if (skeleton == nullptr) return; if (skeleton == nullptr) return;
Skeleton *_skeleton = (Skeleton *) skeleton; Skeleton *_skeleton = (Skeleton *) skeleton;
_skeleton->setScaleX(scaleX); _skeleton->setScaleX(scaleX);
_skeleton->setScaleY(scaleY); _skeleton->setScaleY(scaleY);
} }
float spine_skeleton_get_scale_x(spine_skeleton skeleton) { float spine_skeleton_get_scale_x(spine_skeleton skeleton) {

4
spine-cpp/spine-cpp/src/spine/SkeletonBinary.cpp
View File

@ -125,8 +125,8 @@ SkeletonData *SkeletonBinary::readSkeletonData(const unsigned char *binary, cons
char errorMsg[255]; char errorMsg[255];
snprintf(errorMsg, 255, "Skeleton version %s does not match runtime version %s", skeletonData->_version.buffer(), SPINE_VERSION_STRING); snprintf(errorMsg, 255, "Skeleton version %s does not match runtime version %s", skeletonData->_version.buffer(), SPINE_VERSION_STRING);
setError(errorMsg, ""); setError(errorMsg, "");
delete input; delete input;
delete skeletonData; delete skeletonData;
return NULL; return NULL;
} }

78
spine-cpp/spine-cpp/src/spine/SkeletonClipping.cpp
View File

@ -293,52 +293,52 @@ bool SkeletonClipping::clip(float x1, float y1, float x2, float y2, float x3, fl
output->clear(); output->clear();
size_t clippingVerticesLast = clippingArea->size() - 4; size_t clippingVerticesLast = clippingArea->size() - 4;
Vector<float> &clippingVertices = *clippingArea; Vector<float> &clippingVertices = *clippingArea;
for (size_t i = 0;; i += 2) { for (size_t i = 0;; i += 2) {
float edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1]; float edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1];
float ex = edgeX - clippingVertices[i + 2], ey = edgeY - clippingVertices[i + 3]; float ex = edgeX - clippingVertices[i + 2], ey = edgeY - clippingVertices[i + 3];
size_t outputStart = output->size(); size_t outputStart = output->size();
Vector<float> &inputVertices = *input; Vector<float> &inputVertices = *input;
for (size_t ii = 0, nn = input->size() - 2; ii < nn;) { for (size_t ii = 0, nn = input->size() - 2; ii < nn;) {
float inputX = inputVertices[ii], inputY = inputVertices[ii + 1]; float inputX = inputVertices[ii], inputY = inputVertices[ii + 1];
ii += 2; ii += 2;
float inputX2 = inputVertices[ii], inputY2 = inputVertices[ii + 1]; float inputX2 = inputVertices[ii], inputY2 = inputVertices[ii + 1];
float s2 = ey * (edgeX - inputX2) > ex * (edgeY - inputY2); float s2 = ey * (edgeX - inputX2) > ex * (edgeY - inputY2);
float s1 = ey * (edgeX - inputX) - ex * (edgeY - inputY); float s1 = ey * (edgeX - inputX) - ex * (edgeY - inputY);
if (s1 > 0) { if (s1 > 0) {
if (s2) { // v1 inside, v2 inside if (s2) {// v1 inside, v2 inside
output->add(inputX2); output->add(inputX2);
output->add(inputY2); output->add(inputY2);
continue; continue;
} }
// v1 inside, v2 outside // v1 inside, v2 outside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex); float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) { if (t >= 0 && t <= 1) {
output->add(inputX + ix * t); output->add(inputX + ix * t);
output->add(inputY + iy * t); output->add(inputY + iy * t);
} else { } else {
output->add(inputX2); output->add(inputX2);
output->add(inputY2); output->add(inputY2);
} }
} else if (s2) { // v1 outside, v2 inside } else if (s2) {// v1 outside, v2 inside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex); float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) { if (t >= 0 && t <= 1) {
output->add(inputX + ix * t); output->add(inputX + ix * t);
output->add(inputY + iy * t); output->add(inputY + iy * t);
output->add(inputX2); output->add(inputX2);
output->add(inputY2); output->add(inputY2);
} else { } else {
output->add(inputX2); output->add(inputX2);
output->add(inputY2); output->add(inputY2);
continue; continue;
} }
} }
clipped = true; clipped = true;
} }
if (outputStart == output->size()) { if (outputStart == output->size()) {
// All edges outside. // All edges outside.
originalOutput->clear(); originalOutput->clear();
return true; return true;