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

[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) {
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) {

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);
clippingVerticesLast = clippingArea->size - 4;
clippingVertices = clippingArea->items;
clippingVertices = clippingArea->items;
for (int i = 0;; i += 2) {
spFloatArray *temp;
float edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1];
float ex = edgeX - clippingVertices[i + 2], ey = edgeY - clippingVertices[i + 3];
int outputStart = output->size;
int outputStart = output->size;
float *inputVertices = input->items;
for (int ii = 0, nn = input->size - 2; ii < nn;) {
float inputX = inputVertices[ii], inputY = inputVertices[ii + 1];
ii += 2;
float inputX2 = inputVertices[ii], inputY2 = inputVertices[ii + 1];
float s2 = ey * (edgeX - inputX2) > ex * (edgeY - inputY2);
float s1 = ey * (edgeX - inputX) - ex * (edgeY - inputY);
if (s1 > 0) {
if (s2) { // v1 inside, v2 inside
spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2);
continue;
}
// v1 inside, v2 outside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) {
spFloatArray_add(output, inputX + ix * t);
spFloatArray_add(output, inputY + iy * t);
} else {
spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2);
}
} else if (s2) { // v1 outside, v2 inside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) {
spFloatArray_add(output, inputX + ix * t);
spFloatArray_add(output, inputY + iy * t);
spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2);
} else {
spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2);
continue;
}
}
clipped = -1;
}
for (int ii = 0, nn = input->size - 2; ii < nn;) {
float inputX = inputVertices[ii], inputY = inputVertices[ii + 1];
ii += 2;
float inputX2 = inputVertices[ii], inputY2 = inputVertices[ii + 1];
float s2 = ey * (edgeX - inputX2) > ex * (edgeY - inputY2);
float s1 = ey * (edgeX - inputX) - ex * (edgeY - inputY);
if (s1 > 0) {
if (s2) {// v1 inside, v2 inside
spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2);
continue;
}
// v1 inside, v2 outside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) {
spFloatArray_add(output, inputX + ix * t);
spFloatArray_add(output, inputY + iy * t);
} else {
spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2);
}
} else if (s2) {// v1 outside, v2 inside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) {
spFloatArray_add(output, inputX + ix * t);
spFloatArray_add(output, inputY + iy * t);
spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2);
} else {
spFloatArray_add(output, inputX2);
spFloatArray_add(output, inputY2);
continue;
}
}
clipped = -1;
}
if (outputStart == output->size) {
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 *uvs;
int32_t *colors;
int32_t *darkColors;
int32_t *darkColors;
int32_t numVertices;
uint16_t *indices;
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->uvs = allocator.allocate<float>(numVertices << 1);
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->indices = allocator.allocate<uint16_t>(numIndices);
cmd->numIndices = numIndices;
@ -699,7 +699,7 @@ static _spine_render_command *batch_sub_commands(BlockAllocator &allocator, Vect
float *positions = batched->positions;
float *uvs = batched->uvs;
int32_t *colors = batched->colors;
int32_t *darkColors = batched->darkColors;
int32_t *darkColors = batched->darkColors;
uint16_t *indices = batched->indices;
int indicesOffset = 0;
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(uvs, cmd->uvs, sizeof(float) * 2 * 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++)
indices[ii] = cmd->indices[ii] + indicesOffset;
indicesOffset += cmd->numVertices;
positions += 2 * cmd->numVertices;
uvs += 2 * cmd->numVertices;
colors += cmd->numVertices;
darkColors += cmd->numVertices;
darkColors += cmd->numVertices;
indices += cmd->numIndices;
}
return batched;
@ -734,15 +734,15 @@ static _spine_render_command *batch_commands(BlockAllocator &allocator, Vector<_
while (i <= (int) commands.size()) {
_spine_render_command *cmd = i < (int) commands.size() ? commands[i] : nullptr;
if (cmd && cmd->numVertices == 0 && cmd->numIndices == 0) {
i++;
continue;
}
if (cmd && cmd->numVertices == 0 && cmd->numIndices == 0) {
i++;
continue;
}
if (cmd != nullptr && cmd->atlasPage == first->atlasPage &&
cmd->blendMode == first->blendMode &&
cmd->colors[0] == first->colors[0] &&
cmd->darkColors[0] == first->darkColors[0] &&
cmd->darkColors[0] == first->darkColors[0] &&
numIndices + cmd->numIndices < 0xffff) {
numVertices += cmd->numVertices;
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 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 darkColor = 0xff000000;
if (slot.hasDarkColor()) {
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);
}
uint32_t darkColor = 0xff000000;
if (slot.hasDarkColor()) {
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);
}
if (clipper.isClipping()) {
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->uvs, uvs->buffer(), (verticesCount << 1) * sizeof(float));
for (int ii = 0; ii < verticesCount; ii++) {
cmd->colors[ii] = color;
cmd->darkColors[ii] = darkColor;
}
cmd->colors[ii] = color;
cmd->darkColors[ii] = darkColor;
}
memcpy(cmd->indices, indices->buffer(), indices->size() * sizeof(uint16_t));
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) {
if (!command) return nullptr;
return ((_spine_render_command *) command)->darkColors;
if (!command) return nullptr;
return ((_spine_render_command *) command)->darkColors;
}
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) {
if (entry == nullptr) return false;
TrackEntry *_entry = (TrackEntry *) entry;
return _entry->wasApplied();
if (entry == nullptr) return false;
TrackEntry *_entry = (TrackEntry *) entry;
return _entry->wasApplied();
}
spine_bool spine_track_entry_is_next_ready(spine_track_entry entry) {
if (entry == nullptr) return false;
TrackEntry *_entry = (TrackEntry *) entry;
return _entry->isNextReady();
if (entry == nullptr) return false;
TrackEntry *_entry = (TrackEntry *) entry;
return _entry->isNextReady();
}
// 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) {
if (skeleton == nullptr) return;
Skeleton *_skeleton = (Skeleton *) skeleton;
_skeleton->setScaleX(scaleX);
_skeleton->setScaleY(scaleY);
if (skeleton == nullptr) return;
Skeleton *_skeleton = (Skeleton *) skeleton;
_skeleton->setScaleX(scaleX);
_skeleton->setScaleY(scaleY);
}
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];
snprintf(errorMsg, 255, "Skeleton version %s does not match runtime version %s", skeletonData->_version.buffer(), SPINE_VERSION_STRING);
setError(errorMsg, "");
delete input;
delete skeletonData;
delete input;
delete skeletonData;
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();
size_t clippingVerticesLast = clippingArea->size() - 4;
Vector<float> &clippingVertices = *clippingArea;
Vector<float> &clippingVertices = *clippingArea;
for (size_t i = 0;; i += 2) {
float edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1];
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;
for (size_t ii = 0, nn = input->size() - 2; ii < nn;) {
float inputX = inputVertices[ii], inputY = inputVertices[ii + 1];
ii += 2;
float inputX2 = inputVertices[ii], inputY2 = inputVertices[ii + 1];
float s2 = ey * (edgeX - inputX2) > ex * (edgeY - inputY2);
float s1 = ey * (edgeX - inputX) - ex * (edgeY - inputY);
if (s1 > 0) {
if (s2) { // v1 inside, v2 inside
output->add(inputX2);
output->add(inputY2);
continue;
}
// v1 inside, v2 outside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) {
output->add(inputX + ix * t);
output->add(inputY + iy * t);
} else {
output->add(inputX2);
output->add(inputY2);
}
} else if (s2) { // v1 outside, v2 inside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) {
output->add(inputX + ix * t);
output->add(inputY + iy * t);
output->add(inputX2);
output->add(inputY2);
} else {
output->add(inputX2);
output->add(inputY2);
continue;
}
}
clipped = true;
}
for (size_t ii = 0, nn = input->size() - 2; ii < nn;) {
float inputX = inputVertices[ii], inputY = inputVertices[ii + 1];
ii += 2;
float inputX2 = inputVertices[ii], inputY2 = inputVertices[ii + 1];
float s2 = ey * (edgeX - inputX2) > ex * (edgeY - inputY2);
float s1 = ey * (edgeX - inputX) - ex * (edgeY - inputY);
if (s1 > 0) {
if (s2) {// v1 inside, v2 inside
output->add(inputX2);
output->add(inputY2);
continue;
}
// v1 inside, v2 outside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) {
output->add(inputX + ix * t);
output->add(inputY + iy * t);
} else {
output->add(inputX2);
output->add(inputY2);
}
} else if (s2) {// v1 outside, v2 inside
float ix = inputX2 - inputX, iy = inputY2 - inputY, t = s1 / (ix * ey - iy * ex);
if (t >= 0 && t <= 1) {
output->add(inputX + ix * t);
output->add(inputY + iy * t);
output->add(inputX2);
output->add(inputY2);
} else {
output->add(inputX2);
output->add(inputY2);
continue;
}
}
clipped = true;
}
if (outputStart == output->size()) {
if (outputStart == output->size()) {
// All edges outside.
originalOutput->clear();
return true;