[c][cpp] Fix formatting

spine-c/spine-c/src/spine/AnimationState.c

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

spine-c/spine-c/src/spine/SkeletonClipping.c

@@ -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);

spine-cpp/spine-cpp-lite/spine-cpp-lite.cpp

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

spine-cpp/spine-cpp/src/spine/SkeletonBinary.cpp

@@ -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;
 	}
 

spine-cpp/spine-cpp/src/spine/SkeletonClipping.cpp

@@ -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;
-        }
-
-
-        if (outputStart == output->size()) {
+		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()) {
 			// All edges outside.
 			originalOutput->clear();
 			return true;