[formatters] C/C++ formatting

formatters/.clang-format

@@ -8,11 +8,11 @@ AlignOperands: DontAlign
 AllowAllArgumentsOnNextLine: true
 AllowAllConstructorInitializersOnNextLine: false
 AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: Always
+AllowShortBlocksOnASingleLine: Never
 AllowShortCaseLabelsOnASingleLine: false
 AllowShortEnumsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: All
-AllowShortIfStatementsOnASingleLine: Always
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: WithoutElse
 AllowShortLambdasOnASingleLine: All
 AllowShortLoopsOnASingleLine: true
 AlwaysBreakAfterReturnType: None
@@ -39,13 +39,13 @@ BreakBeforeTernaryOperators: true
 BreakAfterJavaFieldAnnotations: false
 PenaltyBreakBeforeFirstCallParameter: 200
 PenaltyBreakAssignment: 1000
-PenaltyBreakFirstLessLess: 120
+PenaltyBreakFirstLessLess: 150
 PenaltyExcessCharacter: 1000000
 PenaltyBreakString: 1000
 PenaltyReturnTypeOnItsOwnLine: 1000000
 BreakConstructorInitializers: BeforeColon
 BreakInheritanceList: BeforeColon
-ColumnLimit: 120
+ColumnLimit: 150
 CompactNamespaces: false
 ContinuationIndentWidth: 4
 DerivePointerAlignment: false

spine-c/include/spine-c.h

@@ -166,4 +166,4 @@
 #include "../src/generated/update.h"
 #include "../src/generated/vertex_attachment.h"
 
-#endif // SPINE_C_H
+#endif// SPINE_C_H

spine-c/src/base.h

@@ -56,12 +56,12 @@
 #endif
 #endif
 
-#define SPINE_OPAQUE_TYPE(name)     \
-    typedef struct name##_wrapper { \
-        char _dummy;                \
-    } name##_wrapper;               \
-    typedef name##_wrapper *name;
+#define SPINE_OPAQUE_TYPE(name)                                                                                                                      \
+	typedef struct name##_wrapper {                                                                                                                  \
+		char _dummy;                                                                                                                                 \
+	} name##_wrapper;                                                                                                                                \
+	typedef name##_wrapper *name;
 
 typedef long long spine_property_id;
 
-#endif // SPINE_C_BASE_H
+#endif// SPINE_C_BASE_H

spine-c/src/extensions.cpp

@@ -41,60 +41,60 @@ using namespace spine;
 
 // Internal structures
 struct _spine_atlas {
-    void *atlas;
-    const char **imagePaths;
-    int32_t numImagePaths;
-    const char *error;
+	void *atlas;
+	const char **imagePaths;
+	int32_t numImagePaths;
+	const char *error;
 };
 
 struct _spine_skeleton_data_result {
-    spine_skeleton_data skeletonData;
-    const char *error;
+	spine_skeleton_data skeletonData;
+	const char *error;
 };
 
 struct _spine_bounds {
-    float x, y, width, height;
+	float x, y, width, height;
 };
 
 struct _spine_vector {
-    float x, y;
+	float x, y;
 };
 
 struct _spine_skeleton_drawable : public SpineObject {
-    spine_skeleton skeleton;
-    spine_animation_state animationState;
-    spine_animation_state_data animationStateData;
-    spine_animation_state_events animationStateEvents;
-    SkeletonRenderer *renderer;
+	spine_skeleton skeleton;
+	spine_animation_state animationState;
+	spine_animation_state_data animationStateData;
+	spine_animation_state_events animationStateEvents;
+	SkeletonRenderer *renderer;
 };
 
 struct _spine_skin_entry {
-    int32_t slotIndex;
-    const char *name;
-    spine_attachment attachment;
+	int32_t slotIndex;
+	const char *name;
+	spine_attachment attachment;
 };
 
 struct _spine_skin_entries {
-    int32_t numEntries;
-    _spine_skin_entry *entries;
+	int32_t numEntries;
+	_spine_skin_entry *entries;
 };
 
 // Animation state event tracking
 struct AnimationStateEvent {
-    EventType type;
-    TrackEntry *entry;
-    Event *event;
-    AnimationStateEvent(EventType type, TrackEntry *entry, Event *event) : type(type), entry(entry), event(event){};
+	EventType type;
+	TrackEntry *entry;
+	Event *event;
+	AnimationStateEvent(EventType type, TrackEntry *entry, Event *event) : type(type), entry(entry), event(event) {};
 };
 
 class EventListener : public AnimationStateListenerObject, public SpineObject {
 public:
-    Array<AnimationStateEvent> events;
+	Array<AnimationStateEvent> events;
 
-    void callback(AnimationState *state, EventType type, TrackEntry *entry, Event *event) override {
-        events.add(AnimationStateEvent(type, entry, event));
-        SP_UNUSED(state);
-    }
+	void callback(AnimationState *state, EventType type, TrackEntry *entry, Event *event) override {
+		events.add(AnimationStateEvent(type, entry, event));
+		SP_UNUSED(state);
+	}
 };
 
 // Static variables
@@ -103,385 +103,385 @@ static SpineExtension *defaultExtension = nullptr;
 static DebugExtension *debugExtension = nullptr;
 
 static void initExtensions() {
-    if (defaultExtension == nullptr) {
-        defaultExtension = new DefaultSpineExtension();
-        debugExtension = new DebugExtension(defaultExtension);
-    }
+	if (defaultExtension == nullptr) {
+		defaultExtension = new DefaultSpineExtension();
+		debugExtension = new DebugExtension(defaultExtension);
+	}
 }
 
 namespace spine {
-    SpineExtension *getDefaultExtension() {
-        initExtensions();
-        return defaultExtension;
-    }
+	SpineExtension *getDefaultExtension() {
+		initExtensions();
+		return defaultExtension;
+	}
 }
 
 // Version functions
 int32_t spine_major_version() {
-    return SPINE_MAJOR_VERSION;
+	return SPINE_MAJOR_VERSION;
 }
 
 int32_t spine_minor_version() {
-    return SPINE_MINOR_VERSION;
+	return SPINE_MINOR_VERSION;
 }
 
 void spine_enable_debug_extension(bool enable) {
-    initExtensions();
-    SpineExtension::setInstance(enable ? debugExtension : defaultExtension);
+	initExtensions();
+	SpineExtension::setInstance(enable ? debugExtension : defaultExtension);
 }
 
 void spine_report_leaks() {
-    initExtensions();
-    debugExtension->reportLeaks();
-    fflush(stdout);
+	initExtensions();
+	debugExtension->reportLeaks();
+	fflush(stdout);
 }
 
 // Bounds functions
 float spine_bounds_get_x(spine_bounds bounds) {
-    if (!bounds) return 0;
-    return ((_spine_bounds *) bounds)->x;
+	if (!bounds) return 0;
+	return ((_spine_bounds *) bounds)->x;
 }
 
 float spine_bounds_get_y(spine_bounds bounds) {
-    if (!bounds) return 0;
-    return ((_spine_bounds *) bounds)->y;
+	if (!bounds) return 0;
+	return ((_spine_bounds *) bounds)->y;
 }
 
 float spine_bounds_get_width(spine_bounds bounds) {
-    if (!bounds) return 0;
-    return ((_spine_bounds *) bounds)->width;
+	if (!bounds) return 0;
+	return ((_spine_bounds *) bounds)->width;
 }
 
 float spine_bounds_get_height(spine_bounds bounds) {
-    if (!bounds) return 0;
-    return ((_spine_bounds *) bounds)->height;
+	if (!bounds) return 0;
+	return ((_spine_bounds *) bounds)->height;
 }
 
 // Vector functions
 float spine_vector_get_x(spine_vector vector) {
-    if (!vector) return 0;
-    return ((_spine_vector *) vector)->x;
+	if (!vector) return 0;
+	return ((_spine_vector *) vector)->x;
 }
 
 float spine_vector_get_y(spine_vector vector) {
-    if (!vector) return 0;
-    return ((_spine_vector *) vector)->y;
+	if (!vector) return 0;
+	return ((_spine_vector *) vector)->y;
 }
 
 // Atlas functions
 class LiteTextureLoad : public TextureLoader {
-    void load(AtlasPage &page, const String &path) {
-        page.texture = (void *) (intptr_t) page.index;
-    }
+	void load(AtlasPage &page, const String &path) {
+		page.texture = (void *) (intptr_t) page.index;
+	}
 
-    void unload(void *texture) {
-    }
+	void unload(void *texture) {
+	}
 };
 static LiteTextureLoad liteLoader;
 
 spine_atlas spine_atlas_load(const char *atlasData) {
-    if (!atlasData) return nullptr;
-    int32_t length = (int32_t) strlen(atlasData);
-    auto atlas = new (__FILE__, __LINE__) Atlas(atlasData, length, "", &liteLoader, true);
-    _spine_atlas *result = SpineExtension::calloc<_spine_atlas>(1, __FILE__, __LINE__);
-    result->atlas = atlas;
-    result->numImagePaths = (int32_t) atlas->getPages().size();
-    result->imagePaths = SpineExtension::calloc<const char *>(result->numImagePaths, __FILE__, __LINE__);
-    for (int i = 0; i < result->numImagePaths; i++) {
-        result->imagePaths[i] = atlas->getPages()[i]->texturePath.buffer();
-    }
-    return (spine_atlas) result;
+	if (!atlasData) return nullptr;
+	int32_t length = (int32_t) strlen(atlasData);
+	auto atlas = new (__FILE__, __LINE__) Atlas(atlasData, length, "", &liteLoader, true);
+	_spine_atlas *result = SpineExtension::calloc<_spine_atlas>(1, __FILE__, __LINE__);
+	result->atlas = atlas;
+	result->numImagePaths = (int32_t) atlas->getPages().size();
+	result->imagePaths = SpineExtension::calloc<const char *>(result->numImagePaths, __FILE__, __LINE__);
+	for (int i = 0; i < result->numImagePaths; i++) {
+		result->imagePaths[i] = atlas->getPages()[i]->texturePath.buffer();
+	}
+	return (spine_atlas) result;
 }
 
 class CallbackTextureLoad : public TextureLoader {
-    spine_texture_loader_load_func loadCb;
-    spine_texture_loader_unload_func unloadCb;
+	spine_texture_loader_load_func loadCb;
+	spine_texture_loader_unload_func unloadCb;
 
 public:
-    CallbackTextureLoad() : loadCb(nullptr), unloadCb(nullptr) {}
+	CallbackTextureLoad() : loadCb(nullptr), unloadCb(nullptr) {
+	}
 
-    void setCallbacks(spine_texture_loader_load_func load, spine_texture_loader_unload_func unload) {
-        loadCb = load;
-        unloadCb = unload;
-    }
+	void setCallbacks(spine_texture_loader_load_func load, spine_texture_loader_unload_func unload) {
+		loadCb = load;
+		unloadCb = unload;
+	}
 
-    void load(AtlasPage &page, const String &path) {
-        page.texture = this->loadCb(path.buffer());
-    }
+	void load(AtlasPage &page, const String &path) {
+		page.texture = this->loadCb(path.buffer());
+	}
 
-    void unload(void *texture) {
-        this->unloadCb(texture);
-    }
+	void unload(void *texture) {
+		this->unloadCb(texture);
+	}
 };
 static CallbackTextureLoad callbackLoader;
 
-spine_atlas spine_atlas_load_callback(const char *atlasData, const char *atlasDir,
-                                     spine_texture_loader_load_func load,
-                                     spine_texture_loader_unload_func unload) {
-    if (!atlasData) return nullptr;
-    int32_t length = (int32_t) strlen(atlasData);
-    callbackLoader.setCallbacks(load, unload);
-    auto atlas = new (__FILE__, __LINE__) Atlas(atlasData, length, (const char *) atlasDir, &callbackLoader, true);
-    _spine_atlas *result = SpineExtension::calloc<_spine_atlas>(1, __FILE__, __LINE__);
-    result->atlas = atlas;
-    result->numImagePaths = (int32_t) atlas->getPages().size();
-    result->imagePaths = SpineExtension::calloc<const char *>(result->numImagePaths, __FILE__, __LINE__);
-    for (int i = 0; i < result->numImagePaths; i++) {
-        result->imagePaths[i] = atlas->getPages()[i]->texturePath.buffer();
-    }
-    return (spine_atlas) result;
+spine_atlas spine_atlas_load_callback(const char *atlasData, const char *atlasDir, spine_texture_loader_load_func load,
+									  spine_texture_loader_unload_func unload) {
+	if (!atlasData) return nullptr;
+	int32_t length = (int32_t) strlen(atlasData);
+	callbackLoader.setCallbacks(load, unload);
+	auto atlas = new (__FILE__, __LINE__) Atlas(atlasData, length, (const char *) atlasDir, &callbackLoader, true);
+	_spine_atlas *result = SpineExtension::calloc<_spine_atlas>(1, __FILE__, __LINE__);
+	result->atlas = atlas;
+	result->numImagePaths = (int32_t) atlas->getPages().size();
+	result->imagePaths = SpineExtension::calloc<const char *>(result->numImagePaths, __FILE__, __LINE__);
+	for (int i = 0; i < result->numImagePaths; i++) {
+		result->imagePaths[i] = atlas->getPages()[i]->texturePath.buffer();
+	}
+	return (spine_atlas) result;
 }
 
 int32_t spine_atlas_get_num_image_paths(spine_atlas atlas) {
-    if (!atlas) return 0;
-    return ((_spine_atlas *) atlas)->numImagePaths;
+	if (!atlas) return 0;
+	return ((_spine_atlas *) atlas)->numImagePaths;
 }
 
 const char *spine_atlas_get_image_path(spine_atlas atlas, int32_t index) {
-    if (!atlas) return nullptr;
-    _spine_atlas *_atlas = (_spine_atlas *) atlas;
-    if (index < 0 || index >= _atlas->numImagePaths) return nullptr;
-    return _atlas->imagePaths[index];
+	if (!atlas) return nullptr;
+	_spine_atlas *_atlas = (_spine_atlas *) atlas;
+	if (index < 0 || index >= _atlas->numImagePaths) return nullptr;
+	return _atlas->imagePaths[index];
 }
 
 bool spine_atlas_is_pma(spine_atlas atlas) {
-    if (!atlas) return false;
-    Atlas *_atlas = (Atlas *) ((_spine_atlas *) atlas)->atlas;
-    for (size_t i = 0; i < _atlas->getPages().size(); i++) {
-        AtlasPage *page = _atlas->getPages()[i];
-        if (page->pma) return true;
-    }
-    return false;
+	if (!atlas) return false;
+	Atlas *_atlas = (Atlas *) ((_spine_atlas *) atlas)->atlas;
+	for (size_t i = 0; i < _atlas->getPages().size(); i++) {
+		AtlasPage *page = _atlas->getPages()[i];
+		if (page->pma) return true;
+	}
+	return false;
 }
 
 const char *spine_atlas_get_error(spine_atlas atlas) {
-    if (!atlas) return nullptr;
-    return ((_spine_atlas *) atlas)->error;
+	if (!atlas) return nullptr;
+	return ((_spine_atlas *) atlas)->error;
 }
 
 void spine_atlas_dispose(spine_atlas atlas) {
-    if (!atlas) return;
-    _spine_atlas *_atlas = (_spine_atlas *) atlas;
-    if (_atlas->atlas) {
-        delete (Atlas *) _atlas->atlas;
-    }
-    if (_atlas->imagePaths) {
-        SpineExtension::free(_atlas->imagePaths, __FILE__, __LINE__);
-    }
-    if (_atlas->error) {
-        SpineExtension::free(_atlas->error, __FILE__, __LINE__);
-    }
-    SpineExtension::free(_atlas, __FILE__, __LINE__);
+	if (!atlas) return;
+	_spine_atlas *_atlas = (_spine_atlas *) atlas;
+	if (_atlas->atlas) {
+		delete (Atlas *) _atlas->atlas;
+	}
+	if (_atlas->imagePaths) {
+		SpineExtension::free(_atlas->imagePaths, __FILE__, __LINE__);
+	}
+	if (_atlas->error) {
+		SpineExtension::free(_atlas->error, __FILE__, __LINE__);
+	}
+	SpineExtension::free(_atlas, __FILE__, __LINE__);
 }
 
 // Skeleton data loading
 spine_skeleton_data_result spine_skeleton_data_load_json(spine_atlas atlas, const char *skeletonData, const char *path) {
-    if (!atlas || !skeletonData) return nullptr;
-    _spine_skeleton_data_result *result = SpineExtension::calloc<_spine_skeleton_data_result>(1, __FILE__, __LINE__);
-    SkeletonJson json((Atlas *) ((_spine_atlas *) atlas)->atlas);
-    json.setScale(1);
+	if (!atlas || !skeletonData) return nullptr;
+	_spine_skeleton_data_result *result = SpineExtension::calloc<_spine_skeleton_data_result>(1, __FILE__, __LINE__);
+	SkeletonJson json((Atlas *) ((_spine_atlas *) atlas)->atlas);
+	json.setScale(1);
 
-    SkeletonData *data = json.readSkeletonData(skeletonData);
-    if (!data) {
-        result->error = (const char *) strdup("Failed to load skeleton data");
-        return (spine_skeleton_data_result) result;
-    }
+	SkeletonData *data = json.readSkeletonData(skeletonData);
+	if (!data) {
+		result->error = (const char *) strdup("Failed to load skeleton data");
+		return (spine_skeleton_data_result) result;
+	}
 
-    // Set name from path if provided
-    if (path != nullptr && data != nullptr) {
-        String pathStr(path);
+	// Set name from path if provided
+	if (path != nullptr && data != nullptr) {
+		String pathStr(path);
 
-        // Extract filename without extension from path
-        int lastSlash = pathStr.lastIndexOf('/');
-        int lastBackslash = pathStr.lastIndexOf('\\');
-        int start = 0;
+		// Extract filename without extension from path
+		int lastSlash = pathStr.lastIndexOf('/');
+		int lastBackslash = pathStr.lastIndexOf('\\');
+		int start = 0;
 
-        if (lastSlash != -1) start = lastSlash + 1;
-        if (lastBackslash != -1 && lastBackslash > start) start = lastBackslash + 1;
+		if (lastSlash != -1) start = lastSlash + 1;
+		if (lastBackslash != -1 && lastBackslash > start) start = lastBackslash + 1;
 
-        int lastDot = pathStr.lastIndexOf('.');
-        if (lastDot != -1 && lastDot > start) {
-            data->setName(pathStr.substring(start, lastDot - start));
-        } else {
-            data->setName(pathStr.substring(start));
-        }
-    }
+		int lastDot = pathStr.lastIndexOf('.');
+		if (lastDot != -1 && lastDot > start) {
+			data->setName(pathStr.substring(start, lastDot - start));
+		} else {
+			data->setName(pathStr.substring(start));
+		}
+	}
 
-    result->skeletonData = (spine_skeleton_data) data;
-    return (spine_skeleton_data_result) result;
+	result->skeletonData = (spine_skeleton_data) data;
+	return (spine_skeleton_data_result) result;
 }
 
 spine_skeleton_data_result spine_skeleton_data_load_binary(spine_atlas atlas, const uint8_t *skeletonData, int32_t length, const char *path) {
-    if (!atlas || !skeletonData) return nullptr;
-    _spine_skeleton_data_result *result = SpineExtension::calloc<_spine_skeleton_data_result>(1, __FILE__, __LINE__);
-    SkeletonBinary binary((Atlas *) ((_spine_atlas *) atlas)->atlas);
-    binary.setScale(1);
+	if (!atlas || !skeletonData) return nullptr;
+	_spine_skeleton_data_result *result = SpineExtension::calloc<_spine_skeleton_data_result>(1, __FILE__, __LINE__);
+	SkeletonBinary binary((Atlas *) ((_spine_atlas *) atlas)->atlas);
+	binary.setScale(1);
 
-    SkeletonData *data = binary.readSkeletonData((const unsigned char *) skeletonData, length);
-    if (!data) {
-        result->error = (const char *) strdup("Failed to load skeleton data");
-        return (spine_skeleton_data_result) result;
-    }
+	SkeletonData *data = binary.readSkeletonData((const unsigned char *) skeletonData, length);
+	if (!data) {
+		result->error = (const char *) strdup("Failed to load skeleton data");
+		return (spine_skeleton_data_result) result;
+	}
 
-    // Set name from path if provided
-    if (path != nullptr && data != nullptr) {
-        String pathStr(path);
+	// Set name from path if provided
+	if (path != nullptr && data != nullptr) {
+		String pathStr(path);
 
-        // Extract filename without extension from path
-        int lastSlash = pathStr.lastIndexOf('/');
-        int lastBackslash = pathStr.lastIndexOf('\\');
-        int start = 0;
+		// Extract filename without extension from path
+		int lastSlash = pathStr.lastIndexOf('/');
+		int lastBackslash = pathStr.lastIndexOf('\\');
+		int start = 0;
 
-        if (lastSlash != -1) start = lastSlash + 1;
-        if (lastBackslash != -1 && lastBackslash > start) start = lastBackslash + 1;
+		if (lastSlash != -1) start = lastSlash + 1;
+		if (lastBackslash != -1 && lastBackslash > start) start = lastBackslash + 1;
 
-        int lastDot = pathStr.lastIndexOf('.');
-        if (lastDot != -1 && lastDot > start) {
-            data->setName(pathStr.substring(start, lastDot - start));
-        } else {
-            data->setName(pathStr.substring(start));
-        }
-    }
+		int lastDot = pathStr.lastIndexOf('.');
+		if (lastDot != -1 && lastDot > start) {
+			data->setName(pathStr.substring(start, lastDot - start));
+		} else {
+			data->setName(pathStr.substring(start));
+		}
+	}
 
-    result->skeletonData = (spine_skeleton_data) data;
-    return (spine_skeleton_data_result) result;
+	result->skeletonData = (spine_skeleton_data) data;
+	return (spine_skeleton_data_result) result;
 }
 
 const char *spine_skeleton_data_result_get_error(spine_skeleton_data_result result) {
-    if (!result) return nullptr;
-    return ((_spine_skeleton_data_result *) result)->error;
+	if (!result) return nullptr;
+	return ((_spine_skeleton_data_result *) result)->error;
 }
 
 spine_skeleton_data spine_skeleton_data_result_get_data(spine_skeleton_data_result result) {
-    if (!result) return nullptr;
-    return ((_spine_skeleton_data_result *) result)->skeletonData;
+	if (!result) return nullptr;
+	return ((_spine_skeleton_data_result *) result)->skeletonData;
 }
 
 void spine_skeleton_data_result_dispose(spine_skeleton_data_result result) {
-    if (!result) return;
-    _spine_skeleton_data_result *_result = (_spine_skeleton_data_result *) result;
-    if (_result->error) {
-        SpineExtension::free(_result->error, __FILE__, __LINE__);
-    }
-    SpineExtension::free(_result, __FILE__, __LINE__);
+	if (!result) return;
+	_spine_skeleton_data_result *_result = (_spine_skeleton_data_result *) result;
+	if (_result->error) {
+		SpineExtension::free(_result->error, __FILE__, __LINE__);
+	}
+	SpineExtension::free(_result, __FILE__, __LINE__);
 }
 
 // Skeleton drawable
 spine_skeleton_drawable spine_skeleton_drawable_create(spine_skeleton_data skeletonData) {
-    if (!skeletonData) return nullptr;
-    _spine_skeleton_drawable *drawable = new (__FILE__, __LINE__) _spine_skeleton_drawable();
+	if (!skeletonData) return nullptr;
+	_spine_skeleton_drawable *drawable = new (__FILE__, __LINE__) _spine_skeleton_drawable();
 
-    Skeleton *skeleton = new (__FILE__, __LINE__) Skeleton(*((SkeletonData *) skeletonData));
-    AnimationStateData *stateData = new (__FILE__, __LINE__) AnimationStateData((SkeletonData *) skeletonData);
-    AnimationState *state = new (__FILE__, __LINE__) AnimationState(stateData);
-    EventListener *listener = new (__FILE__, __LINE__) EventListener();
-    state->setListener(listener);
+	Skeleton *skeleton = new (__FILE__, __LINE__) Skeleton(*((SkeletonData *) skeletonData));
+	AnimationStateData *stateData = new (__FILE__, __LINE__) AnimationStateData((SkeletonData *) skeletonData);
+	AnimationState *state = new (__FILE__, __LINE__) AnimationState(stateData);
+	EventListener *listener = new (__FILE__, __LINE__) EventListener();
+	state->setListener(listener);
 
-    drawable->skeleton = (spine_skeleton) skeleton;
-    drawable->animationStateData = (spine_animation_state_data) stateData;
-    drawable->animationState = (spine_animation_state) state;
-    drawable->animationStateEvents = (spine_animation_state_events) listener;
-    drawable->renderer = new (__FILE__, __LINE__) SkeletonRenderer();
+	drawable->skeleton = (spine_skeleton) skeleton;
+	drawable->animationStateData = (spine_animation_state_data) stateData;
+	drawable->animationState = (spine_animation_state) state;
+	drawable->animationStateEvents = (spine_animation_state_events) listener;
+	drawable->renderer = new (__FILE__, __LINE__) SkeletonRenderer();
 
-    return (spine_skeleton_drawable) drawable;
+	return (spine_skeleton_drawable) drawable;
 }
 
 spine_render_command spine_skeleton_drawable_render(spine_skeleton_drawable drawable) {
-    if (!drawable) return nullptr;
-    _spine_skeleton_drawable *_drawable = (_spine_skeleton_drawable *) drawable;
-    Skeleton *skeleton = (Skeleton *) _drawable->skeleton;
-    SkeletonRenderer *renderer = _drawable->renderer;
+	if (!drawable) return nullptr;
+	_spine_skeleton_drawable *_drawable = (_spine_skeleton_drawable *) drawable;
+	Skeleton *skeleton = (Skeleton *) _drawable->skeleton;
+	SkeletonRenderer *renderer = _drawable->renderer;
 
-    RenderCommand *commands = renderer->render(*skeleton);
-    return (spine_render_command) commands;
+	RenderCommand *commands = renderer->render(*skeleton);
+	return (spine_render_command) commands;
 }
 
 void spine_skeleton_drawable_dispose(spine_skeleton_drawable drawable) {
-    if (!drawable) return;
-    _spine_skeleton_drawable *_drawable = (_spine_skeleton_drawable *) drawable;
-
-    if (_drawable->renderer) {
-        delete _drawable->renderer;
-    }
-    if (_drawable->animationState) {
-        delete (AnimationState *) _drawable->animationState;
-    }
-    if (_drawable->animationStateData) {
-        delete (AnimationStateData *) _drawable->animationStateData;
-    }
-    if (_drawable->skeleton) {
-        delete (Skeleton *) _drawable->skeleton;
-    }
-    if (_drawable->animationStateEvents) {
-        delete (EventListener *) _drawable->animationStateEvents;
-    }
-
-    delete _drawable;
+	if (!drawable) return;
+	_spine_skeleton_drawable *_drawable = (_spine_skeleton_drawable *) drawable;
+
+	if (_drawable->renderer) {
+		delete _drawable->renderer;
+	}
+	if (_drawable->animationState) {
+		delete (AnimationState *) _drawable->animationState;
+	}
+	if (_drawable->animationStateData) {
+		delete (AnimationStateData *) _drawable->animationStateData;
+	}
+	if (_drawable->skeleton) {
+		delete (Skeleton *) _drawable->skeleton;
+	}
+	if (_drawable->animationStateEvents) {
+		delete (EventListener *) _drawable->animationStateEvents;
+	}
+
+	delete _drawable;
 }
 
 spine_skeleton spine_skeleton_drawable_get_skeleton(spine_skeleton_drawable drawable) {
-    if (!drawable) return nullptr;
-    return ((_spine_skeleton_drawable *) drawable)->skeleton;
+	if (!drawable) return nullptr;
+	return ((_spine_skeleton_drawable *) drawable)->skeleton;
 }
 
 spine_animation_state spine_skeleton_drawable_get_animation_state(spine_skeleton_drawable drawable) {
-    if (!drawable) return nullptr;
-    return ((_spine_skeleton_drawable *) drawable)->animationState;
+	if (!drawable) return nullptr;
+	return ((_spine_skeleton_drawable *) drawable)->animationState;
 }
 
 spine_animation_state_data spine_skeleton_drawable_get_animation_state_data(spine_skeleton_drawable drawable) {
-    if (!drawable) return nullptr;
-    return ((_spine_skeleton_drawable *) drawable)->animationStateData;
+	if (!drawable) return nullptr;
+	return ((_spine_skeleton_drawable *) drawable)->animationStateData;
 }
 
 spine_animation_state_events spine_skeleton_drawable_get_animation_state_events(spine_skeleton_drawable drawable) {
-    if (!drawable) return nullptr;
-    return ((_spine_skeleton_drawable *) drawable)->animationStateEvents;
+	if (!drawable) return nullptr;
+	return ((_spine_skeleton_drawable *) drawable)->animationStateEvents;
 }
 
 // Skin entries
 spine_skin_entries spine_skin_entries_create() {
-    _spine_skin_entries *entries = SpineExtension::calloc<_spine_skin_entries>(1, __FILE__, __LINE__);
-    return (spine_skin_entries) entries;
+	_spine_skin_entries *entries = SpineExtension::calloc<_spine_skin_entries>(1, __FILE__, __LINE__);
+	return (spine_skin_entries) entries;
 }
 
 void spine_skin_entries_dispose(spine_skin_entries entries) {
-    if (!entries) return;
-    _spine_skin_entries *_entries = (_spine_skin_entries *) entries;
-    if (_entries->entries) {
-        for (int i = 0; i < _entries->numEntries; i++) {
-            if (_entries->entries[i].name) {
-                SpineExtension::free(_entries->entries[i].name, __FILE__, __LINE__);
-            }
-        }
-        SpineExtension::free(_entries->entries, __FILE__, __LINE__);
-    }
-    SpineExtension::free(_entries, __FILE__, __LINE__);
+	if (!entries) return;
+	_spine_skin_entries *_entries = (_spine_skin_entries *) entries;
+	if (_entries->entries) {
+		for (int i = 0; i < _entries->numEntries; i++) {
+			if (_entries->entries[i].name) {
+				SpineExtension::free(_entries->entries[i].name, __FILE__, __LINE__);
+			}
+		}
+		SpineExtension::free(_entries->entries, __FILE__, __LINE__);
+	}
+	SpineExtension::free(_entries, __FILE__, __LINE__);
 }
 
 int32_t spine_skin_entries_get_num_entries(spine_skin_entries entries) {
-    if (!entries) return 0;
-    return ((_spine_skin_entries *) entries)->numEntries;
+	if (!entries) return 0;
+	return ((_spine_skin_entries *) entries)->numEntries;
 }
 
 spine_skin_entry spine_skin_entries_get_entry(spine_skin_entries entries, int32_t index) {
-    if (!entries) return nullptr;
-    _spine_skin_entries *_entries = (_spine_skin_entries *) entries;
-    if (index < 0 || index >= _entries->numEntries) return nullptr;
-    return (spine_skin_entry) &_entries->entries[index];
+	if (!entries) return nullptr;
+	_spine_skin_entries *_entries = (_spine_skin_entries *) entries;
+	if (index < 0 || index >= _entries->numEntries) return nullptr;
+	return (spine_skin_entry) &_entries->entries[index];
 }
 
 int32_t spine_skin_entry_get_slot_index(spine_skin_entry entry) {
-    if (!entry) return 0;
-    return ((_spine_skin_entry *) entry)->slotIndex;
+	if (!entry) return 0;
+	return ((_spine_skin_entry *) entry)->slotIndex;
 }
 
 const char *spine_skin_entry_get_name(spine_skin_entry entry) {
-    if (!entry) return nullptr;
-    return ((_spine_skin_entry *) entry)->name;
+	if (!entry) return nullptr;
+	return ((_spine_skin_entry *) entry)->name;
 }
 
 spine_attachment spine_skin_entry_get_attachment(spine_skin_entry entry) {
-    if (!entry) return nullptr;
-    return ((_spine_skin_entry *) entry)->attachment;
+	if (!entry) return nullptr;
+	return ((_spine_skin_entry *) entry)->attachment;
 }

spine-c/src/extensions.h

@@ -47,11 +47,11 @@ SPINE_OPAQUE_TYPE(spine_skin_entries)
 SPINE_OPAQUE_TYPE(spine_texture_loader)
 
 // Additional types
-typedef void* spine_void;
-typedef void (*spine_dispose_renderer_object)(void*);
+typedef void *spine_void;
+typedef void (*spine_dispose_renderer_object)(void *);
 
 // Texture loader callbacks
-typedef void* (*spine_texture_loader_load_func)(const char *path);
+typedef void *(*spine_texture_loader_load_func)(const char *path);
 typedef void (*spine_texture_loader_unload_func)(void *texture);
 
 // Version functions
@@ -72,9 +72,8 @@ SPINE_C_API float spine_vector_get_y(spine_vector vector);
 
 // Atlas functions
 SPINE_C_API spine_atlas spine_atlas_load(const char *atlasData);
-SPINE_C_API spine_atlas spine_atlas_load_callback(const char *atlasData, const char *atlasDir,
-                                                     spine_texture_loader_load_func load,
-                                                     spine_texture_loader_unload_func unload);
+SPINE_C_API spine_atlas spine_atlas_load_callback(const char *atlasData, const char *atlasDir, spine_texture_loader_load_func load,
+												  spine_texture_loader_unload_func unload);
 SPINE_C_API int32_t spine_atlas_get_num_image_paths(spine_atlas atlas);
 SPINE_C_API const char *spine_atlas_get_image_path(spine_atlas atlas, int32_t index);
 SPINE_C_API bool spine_atlas_is_pma(spine_atlas atlas);
@@ -83,7 +82,8 @@ SPINE_C_API void spine_atlas_dispose(spine_atlas atlas);
 
 // Skeleton data functions
 SPINE_C_API spine_skeleton_data_result spine_skeleton_data_load_json(spine_atlas atlas, const char *skeletonData, const char *path);
-SPINE_C_API spine_skeleton_data_result spine_skeleton_data_load_binary(spine_atlas atlas, const uint8_t *skeletonData, int32_t length, const char *path);
+SPINE_C_API spine_skeleton_data_result spine_skeleton_data_load_binary(spine_atlas atlas, const uint8_t *skeletonData, int32_t length,
+																	   const char *path);
 SPINE_C_API const char *spine_skeleton_data_result_get_error(spine_skeleton_data_result result);
 SPINE_C_API spine_skeleton_data spine_skeleton_data_result_get_data(spine_skeleton_data_result result);
 SPINE_C_API void spine_skeleton_data_result_dispose(spine_skeleton_data_result result);
@@ -112,4 +112,4 @@ SPINE_C_API spine_attachment spine_skin_entry_get_attachment(spine_skin_entry en
 }
 #endif
 
-#endif // SPINE_C_EXTENSIONS_H
+#endif// SPINE_C_EXTENSIONS_H

spine-c/src/generated/alpha_timeline.cpp

@@ -4,93 +4,119 @@
 using namespace spine;
 
 spine_alpha_timeline spine_alpha_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex) {
-    return (spine_alpha_timeline) new (__FILE__, __LINE__) AlphaTimeline(frameCount, bezierCount, slotIndex);
+	return (spine_alpha_timeline) new (__FILE__, __LINE__) AlphaTimeline(frameCount, bezierCount, slotIndex);
 }
 
 void spine_alpha_timeline_dispose(spine_alpha_timeline self) {
-    delete (AlphaTimeline*)self;
+	delete (AlphaTimeline *) self;
 }
 
 spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self) {
-    return (spine_rtti)&((AlphaTimeline*)self)->getRTTI();
+	AlphaTimeline *_self = (AlphaTimeline *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((AlphaTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	AlphaTimeline *_self = (AlphaTimeline *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 void spine_alpha_timeline_set_frame(spine_alpha_timeline self, size_t frame, float time, float value) {
-    ((CurveTimeline1*)(AlphaTimeline*)self)->setFrame(frame, time, value);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	_self->setFrame(frame, time, value);
 }
 
 float spine_alpha_timeline_get_curve_value(spine_alpha_timeline self, float time) {
-    return ((CurveTimeline1*)(AlphaTimeline*)self)->getCurveValue(time);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return _self->getCurveValue(time);
 }
 
 float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
-    return ((CurveTimeline1*)(AlphaTimeline*)self)->getRelativeValue(time, alpha, (MixBlend)blend, current, setup);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
-float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
-    return ((CurveTimeline1*)(AlphaTimeline*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup);
+float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
+												float setup) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
-float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) {
-    return ((CurveTimeline1*)(AlphaTimeline*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup, value);
+float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup,
+												float value) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
-float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-    return ((CurveTimeline1*)(AlphaTimeline*)self)->getScaleValue(time, alpha, (MixBlend)blend, (MixDirection)direction, current, setup);
+float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+										   float current, float setup) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_alpha_timeline_set_linear(spine_alpha_timeline self, size_t frame) {
-    ((CurveTimeline1*)(AlphaTimeline*)self)->setLinear(frame);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	_self->setLinear(frame);
 }
 
 void spine_alpha_timeline_set_stepped(spine_alpha_timeline self, size_t frame) {
-    ((CurveTimeline1*)(AlphaTimeline*)self)->setStepped(frame);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	_self->setStepped(frame);
 }
 
-void spine_alpha_timeline_set_bezier(spine_alpha_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
-    ((CurveTimeline1*)(AlphaTimeline*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+void spine_alpha_timeline_set_bezier(spine_alpha_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
+									 float cy1, float cx2, float cy2, float time2, float value2) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_alpha_timeline_get_bezier_value(spine_alpha_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-    return ((CurveTimeline1*)(AlphaTimeline*)self)->getBezierValue(time, frame, valueOffset, i);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_alpha_timeline_get_curves(spine_alpha_timeline self) {
-    return (spine_array_float)&((CurveTimeline1*)(AlphaTimeline*)self)->getCurves();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_alpha_timeline_get_frame_entries(spine_alpha_timeline self) {
-    return ((CurveTimeline1*)(AlphaTimeline*)self)->getFrameEntries();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return _self->getFrameEntries();
 }
 
 size_t spine_alpha_timeline_get_frame_count(spine_alpha_timeline self) {
-    return ((CurveTimeline1*)(AlphaTimeline*)self)->getFrameCount();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_float spine_alpha_timeline_get_frames(spine_alpha_timeline self) {
-    return (spine_array_float)&((CurveTimeline1*)(AlphaTimeline*)self)->getFrames();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_alpha_timeline_get_duration(spine_alpha_timeline self) {
-    return ((CurveTimeline1*)(AlphaTimeline*)self)->getDuration();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_alpha_timeline_get_property_ids(spine_alpha_timeline self) {
-    return (spine_array_property_id)&((CurveTimeline1*)(AlphaTimeline*)self)->getPropertyIds();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 int spine_alpha_timeline_get_slot_index(spine_alpha_timeline self) {
-    return ((SlotTimeline*)(AlphaTimeline*)self)->getSlotIndex();
+	SlotTimeline *_self = (SlotTimeline *) (AlphaTimeline *) self;
+	return _self->getSlotIndex();
 }
 
 void spine_alpha_timeline_set_slot_index(spine_alpha_timeline self, int inValue) {
-    ((SlotTimeline*)(AlphaTimeline*)self)->setSlotIndex(inValue);
+	SlotTimeline *_self = (SlotTimeline *) (AlphaTimeline *) self;
+	_self->setSlotIndex(inValue);
 }
 
 spine_rtti spine_alpha_timeline_rtti(void) {
-    return (spine_rtti)&AlphaTimeline::rtti;
+	return (spine_rtti) &AlphaTimeline::rtti;
 }

spine-c/src/generated/alpha_timeline.h

@@ -13,16 +13,22 @@ SPINE_C_API spine_alpha_timeline spine_alpha_timeline_create(size_t frameCount,
 SPINE_C_API void spine_alpha_timeline_dispose(spine_alpha_timeline self);
 
 SPINE_C_API spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self);
-SPINE_C_API void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
 SPINE_C_API void spine_alpha_timeline_set_frame(spine_alpha_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_alpha_timeline_get_curve_value(spine_alpha_timeline self, float time);
-SPINE_C_API float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup);
-SPINE_C_API float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup);
-SPINE_C_API float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value);
-SPINE_C_API float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup);
+SPINE_C_API float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
+														  float setup);
+SPINE_C_API float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
+															float setup);
+SPINE_C_API float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
+															float setup, float value);
+SPINE_C_API float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend,
+													   spine_mix_direction direction, float current, float setup);
 SPINE_C_API void spine_alpha_timeline_set_linear(spine_alpha_timeline self, size_t frame);
 SPINE_C_API void spine_alpha_timeline_set_stepped(spine_alpha_timeline self, size_t frame);
-SPINE_C_API void spine_alpha_timeline_set_bezier(spine_alpha_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
+SPINE_C_API void spine_alpha_timeline_set_bezier(spine_alpha_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
+												 float cx1, float cy1, float cx2, float cy2, float time2, float value2);
 SPINE_C_API float spine_alpha_timeline_get_bezier_value(spine_alpha_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
 SPINE_C_API spine_array_float spine_alpha_timeline_get_curves(spine_alpha_timeline self);
 SPINE_C_API size_t spine_alpha_timeline_get_frame_entries(spine_alpha_timeline self);

spine-c/src/generated/animation.cpp

@@ -3,50 +3,60 @@
 
 using namespace spine;
 
-spine_animation spine_animation_create(const char * name, spine_array_timeline timelines, float duration) {
-    return (spine_animation) new (__FILE__, __LINE__) Animation(String(name), *((Array<Timeline *>*)timelines), duration);
+spine_animation spine_animation_create(const char *name, spine_array_timeline timelines, float duration) {
+	return (spine_animation) new (__FILE__, __LINE__) Animation(String(name), *((Array<Timeline *> *) timelines), duration);
 }
 
 void spine_animation_dispose(spine_animation self) {
-    delete (Animation*)self;
+	delete (Animation *) self;
 }
 
 spine_array_timeline spine_animation_get_timelines(spine_animation self) {
-    return (spine_array_timeline)&((Animation*)self)->getTimelines();
+	Animation *_self = (Animation *) self;
+	return (spine_array_timeline) &_self->getTimelines();
 }
 
 void spine_animation_set_timelines(spine_animation self, spine_array_timeline timelines) {
-    ((Animation*)self)->setTimelines(*((Array<Timeline *>*)timelines));
+	Animation *_self = (Animation *) self;
+	_self->setTimelines(*((Array<Timeline *> *) timelines));
 }
 
 bool spine_animation_has_timeline(spine_animation self, spine_array_property_id ids) {
-    return ((Animation*)self)->hasTimeline(*((Array<PropertyId>*)ids));
+	Animation *_self = (Animation *) self;
+	return _self->hasTimeline(*((Array<PropertyId> *) ids));
 }
 
 float spine_animation_get_duration(spine_animation self) {
-    return ((Animation*)self)->getDuration();
+	Animation *_self = (Animation *) self;
+	return _self->getDuration();
 }
 
 void spine_animation_set_duration(spine_animation self, float inValue) {
-    ((Animation*)self)->setDuration(inValue);
+	Animation *_self = (Animation *) self;
+	_self->setDuration(inValue);
 }
 
-void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((Animation*)self)->apply(*((Skeleton*)skeleton), lastTime, time, loop, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, spine_array_event pEvents,
+						   float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	Animation *_self = (Animation *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, loop, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
-const char * spine_animation_get_name(spine_animation self) {
-    return ((Animation*)self)->getName().buffer();
+const char *spine_animation_get_name(spine_animation self) {
+	Animation *_self = (Animation *) self;
+	return _self->getName().buffer();
 }
 
 spine_array_int spine_animation_get_bones(spine_animation self) {
-    return (spine_array_int)&((Animation*)self)->getBones();
+	Animation *_self = (Animation *) self;
+	return (spine_array_int) &_self->getBones();
 }
 
 int spine_animation_search_1(spine_array_float values, float target) {
-    return Animation::search(*((Array<float>*)values), target);
+	return Animation::search(*((Array<float> *) values), target);
 }
 
 int spine_animation_search_2(spine_array_float values, float target, int step) {
-    return Animation::search(*((Array<float>*)values), target, step);
+	return Animation::search(*((Array<float> *) values), target, step);
 }

spine-c/src/generated/animation.h

@@ -8,7 +8,7 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_animation spine_animation_create(const char * name, spine_array_timeline timelines, float duration);
+SPINE_C_API spine_animation spine_animation_create(const char *name, spine_array_timeline timelines, float duration);
 
 SPINE_C_API void spine_animation_dispose(spine_animation self);
 
@@ -17,8 +17,10 @@ SPINE_C_API void spine_animation_set_timelines(spine_animation self, spine_array
 SPINE_C_API bool spine_animation_has_timeline(spine_animation self, spine_array_property_id ids);
 SPINE_C_API float spine_animation_get_duration(spine_animation self);
 SPINE_C_API void spine_animation_set_duration(spine_animation self, float inValue);
-SPINE_C_API void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
-SPINE_C_API const char * spine_animation_get_name(spine_animation self);
+SPINE_C_API void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop,
+									   spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+									   bool appliedPose);
+SPINE_C_API const char *spine_animation_get_name(spine_animation self);
 SPINE_C_API spine_array_int spine_animation_get_bones(spine_animation self);
 SPINE_C_API int spine_animation_search_1(spine_array_float values, float target);
 SPINE_C_API int spine_animation_search_2(spine_array_float values, float target, int step);

spine-c/src/generated/animation_state.cpp

@@ -4,97 +4,121 @@
 using namespace spine;
 
 spine_animation_state spine_animation_state_create(spine_animation_state_data data) {
-    return (spine_animation_state) new (__FILE__, __LINE__) AnimationState((AnimationStateData *)data);
+	return (spine_animation_state) new (__FILE__, __LINE__) AnimationState((AnimationStateData *) data);
 }
 
 void spine_animation_state_dispose(spine_animation_state self) {
-    delete (AnimationState*)self;
+	delete (AnimationState *) self;
 }
 
 void spine_animation_state_update(spine_animation_state self, float delta) {
-    ((AnimationState*)self)->update(delta);
+	AnimationState *_self = (AnimationState *) self;
+	_self->update(delta);
 }
 
 bool spine_animation_state_apply(spine_animation_state self, spine_skeleton skeleton) {
-    return ((AnimationState*)self)->apply(*((Skeleton*)skeleton));
+	AnimationState *_self = (AnimationState *) self;
+	return _self->apply(*((Skeleton *) skeleton));
 }
 
 void spine_animation_state_clear_tracks(spine_animation_state self) {
-    ((AnimationState*)self)->clearTracks();
+	AnimationState *_self = (AnimationState *) self;
+	_self->clearTracks();
 }
 
 void spine_animation_state_clear_track(spine_animation_state self, size_t trackIndex) {
-    ((AnimationState*)self)->clearTrack(trackIndex);
+	AnimationState *_self = (AnimationState *) self;
+	_self->clearTrack(trackIndex);
 }
 
-spine_track_entry spine_animation_state_set_animation_1(spine_animation_state self, size_t trackIndex, const char * animationName, bool loop) {
-    return (spine_track_entry)((AnimationState*)self)->setAnimation(trackIndex, String(animationName), loop);
+spine_track_entry spine_animation_state_set_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName, bool loop) {
+	AnimationState *_self = (AnimationState *) self;
+	return (spine_track_entry) _self->setAnimation(trackIndex, String(animationName), loop);
 }
 
 spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop) {
-    return (spine_track_entry)((AnimationState*)self)->setAnimation(trackIndex, (Animation *)animation, loop);
+	AnimationState *_self = (AnimationState *) self;
+	return (spine_track_entry) _self->setAnimation(trackIndex, (Animation *) animation, loop);
 }
 
-spine_track_entry spine_animation_state_add_animation_1(spine_animation_state self, size_t trackIndex, const char * animationName, bool loop, float delay) {
-    return (spine_track_entry)((AnimationState*)self)->addAnimation(trackIndex, String(animationName), loop, delay);
+spine_track_entry spine_animation_state_add_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName, bool loop,
+														float delay) {
+	AnimationState *_self = (AnimationState *) self;
+	return (spine_track_entry) _self->addAnimation(trackIndex, String(animationName), loop, delay);
 }
 
-spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop, float delay) {
-    return (spine_track_entry)((AnimationState*)self)->addAnimation(trackIndex, (Animation *)animation, loop, delay);
+spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop,
+														float delay) {
+	AnimationState *_self = (AnimationState *) self;
+	return (spine_track_entry) _self->addAnimation(trackIndex, (Animation *) animation, loop, delay);
 }
 
 spine_track_entry spine_animation_state_set_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration) {
-    return (spine_track_entry)((AnimationState*)self)->setEmptyAnimation(trackIndex, mixDuration);
+	AnimationState *_self = (AnimationState *) self;
+	return (spine_track_entry) _self->setEmptyAnimation(trackIndex, mixDuration);
 }
 
 spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration, float delay) {
-    return (spine_track_entry)((AnimationState*)self)->addEmptyAnimation(trackIndex, mixDuration, delay);
+	AnimationState *_self = (AnimationState *) self;
+	return (spine_track_entry) _self->addEmptyAnimation(trackIndex, mixDuration, delay);
 }
 
 void spine_animation_state_set_empty_animations(spine_animation_state self, float mixDuration) {
-    ((AnimationState*)self)->setEmptyAnimations(mixDuration);
+	AnimationState *_self = (AnimationState *) self;
+	_self->setEmptyAnimations(mixDuration);
 }
 
 spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex) {
-    return (spine_track_entry)((AnimationState*)self)->getCurrent(trackIndex);
+	AnimationState *_self = (AnimationState *) self;
+	return (spine_track_entry) _self->getCurrent(trackIndex);
 }
 
 spine_animation_state_data spine_animation_state_get_data(spine_animation_state self) {
-    return (spine_animation_state_data)&((AnimationState*)self)->getData();
+	AnimationState *_self = (AnimationState *) self;
+	return (spine_animation_state_data) &_self->getData();
 }
 
 spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self) {
-    return (spine_array_track_entry)&((AnimationState*)self)->getTracks();
+	AnimationState *_self = (AnimationState *) self;
+	return (spine_array_track_entry) &_self->getTracks();
 }
 
 float spine_animation_state_get_time_scale(spine_animation_state self) {
-    return ((AnimationState*)self)->getTimeScale();
+	AnimationState *_self = (AnimationState *) self;
+	return _self->getTimeScale();
 }
 
 void spine_animation_state_set_time_scale(spine_animation_state self, float inValue) {
-    ((AnimationState*)self)->setTimeScale(inValue);
+	AnimationState *_self = (AnimationState *) self;
+	_self->setTimeScale(inValue);
 }
 
 void spine_animation_state_disable_queue(spine_animation_state self) {
-    ((AnimationState*)self)->disableQueue();
+	AnimationState *_self = (AnimationState *) self;
+	_self->disableQueue();
 }
 
 void spine_animation_state_enable_queue(spine_animation_state self) {
-    ((AnimationState*)self)->enableQueue();
+	AnimationState *_self = (AnimationState *) self;
+	_self->enableQueue();
 }
 
 void spine_animation_state_set_manual_track_entry_disposal(spine_animation_state self, bool inValue) {
-    ((AnimationState*)self)->setManualTrackEntryDisposal(inValue);
+	AnimationState *_self = (AnimationState *) self;
+	_self->setManualTrackEntryDisposal(inValue);
 }
 
 bool spine_animation_state_get_manual_track_entry_disposal(spine_animation_state self) {
-    return ((AnimationState*)self)->getManualTrackEntryDisposal();
+	AnimationState *_self = (AnimationState *) self;
+	return _self->getManualTrackEntryDisposal();
 }
 
 void spine_animation_state_dispose_track_entry(spine_animation_state self, spine_track_entry entry) {
-    ((AnimationState*)self)->disposeTrackEntry((TrackEntry *)entry);
+	AnimationState *_self = (AnimationState *) self;
+	_self->disposeTrackEntry((TrackEntry *) entry);
 }
 
-void * spine_animation_state_get_renderer_object(spine_animation_state self) {
-    return ((HasRendererObject*)(AnimationState*)self)->getRendererObject();
+void *spine_animation_state_get_renderer_object(spine_animation_state self) {
+	HasRendererObject *_self = (HasRendererObject *) (AnimationState *) self;
+	return _self->getRendererObject();
 }

spine-c/src/generated/animation_state.h

@@ -16,12 +16,17 @@ SPINE_C_API void spine_animation_state_update(spine_animation_state self, float
 SPINE_C_API bool spine_animation_state_apply(spine_animation_state self, spine_skeleton skeleton);
 SPINE_C_API void spine_animation_state_clear_tracks(spine_animation_state self);
 SPINE_C_API void spine_animation_state_clear_track(spine_animation_state self, size_t trackIndex);
-SPINE_C_API spine_track_entry spine_animation_state_set_animation_1(spine_animation_state self, size_t trackIndex, const char * animationName, bool loop);
-SPINE_C_API spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop);
-SPINE_C_API spine_track_entry spine_animation_state_add_animation_1(spine_animation_state self, size_t trackIndex, const char * animationName, bool loop, float delay);
-SPINE_C_API spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop, float delay);
+SPINE_C_API spine_track_entry spine_animation_state_set_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName,
+																	bool loop);
+SPINE_C_API spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation,
+																	bool loop);
+SPINE_C_API spine_track_entry spine_animation_state_add_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName,
+																	bool loop, float delay);
+SPINE_C_API spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation,
+																	bool loop, float delay);
 SPINE_C_API spine_track_entry spine_animation_state_set_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration);
-SPINE_C_API spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration, float delay);
+SPINE_C_API spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration,
+																		float delay);
 SPINE_C_API void spine_animation_state_set_empty_animations(spine_animation_state self, float mixDuration);
 SPINE_C_API spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex);
 SPINE_C_API spine_animation_state_data spine_animation_state_get_data(spine_animation_state self);
@@ -33,7 +38,7 @@ SPINE_C_API void spine_animation_state_enable_queue(spine_animation_state self);
 SPINE_C_API void spine_animation_state_set_manual_track_entry_disposal(spine_animation_state self, bool inValue);
 SPINE_C_API bool spine_animation_state_get_manual_track_entry_disposal(spine_animation_state self);
 SPINE_C_API void spine_animation_state_dispose_track_entry(spine_animation_state self, spine_track_entry entry);
-SPINE_C_API void * spine_animation_state_get_renderer_object(spine_animation_state self);
+SPINE_C_API void *spine_animation_state_get_renderer_object(spine_animation_state self);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/animation_state_data.cpp

@@ -4,37 +4,44 @@
 using namespace spine;
 
 spine_animation_state_data spine_animation_state_data_create(spine_skeleton_data skeletonData) {
-    return (spine_animation_state_data) new (__FILE__, __LINE__) AnimationStateData((SkeletonData *)skeletonData);
+	return (spine_animation_state_data) new (__FILE__, __LINE__) AnimationStateData((SkeletonData *) skeletonData);
 }
 
 void spine_animation_state_data_dispose(spine_animation_state_data self) {
-    delete (AnimationStateData*)self;
+	delete (AnimationStateData *) self;
 }
 
 spine_skeleton_data spine_animation_state_data_get_skeleton_data(spine_animation_state_data self) {
-    return (spine_skeleton_data)((AnimationStateData*)self)->getSkeletonData();
+	AnimationStateData *_self = (AnimationStateData *) self;
+	return (spine_skeleton_data) _self->getSkeletonData();
 }
 
 float spine_animation_state_data_get_default_mix(spine_animation_state_data self) {
-    return ((AnimationStateData*)self)->getDefaultMix();
+	AnimationStateData *_self = (AnimationStateData *) self;
+	return _self->getDefaultMix();
 }
 
 void spine_animation_state_data_set_default_mix(spine_animation_state_data self, float inValue) {
-    ((AnimationStateData*)self)->setDefaultMix(inValue);
+	AnimationStateData *_self = (AnimationStateData *) self;
+	_self->setDefaultMix(inValue);
 }
 
-void spine_animation_state_data_set_mix_1(spine_animation_state_data self, const char * fromName, const char * toName, float duration) {
-    ((AnimationStateData*)self)->setMix(String(fromName), String(toName), duration);
+void spine_animation_state_data_set_mix_1(spine_animation_state_data self, const char *fromName, const char *toName, float duration) {
+	AnimationStateData *_self = (AnimationStateData *) self;
+	_self->setMix(String(fromName), String(toName), duration);
 }
 
 void spine_animation_state_data_set_mix_2(spine_animation_state_data self, spine_animation from, spine_animation to, float duration) {
-    ((AnimationStateData*)self)->setMix((Animation *)from, (Animation *)to, duration);
+	AnimationStateData *_self = (AnimationStateData *) self;
+	_self->setMix((Animation *) from, (Animation *) to, duration);
 }
 
 float spine_animation_state_data_get_mix(spine_animation_state_data self, spine_animation from, spine_animation to) {
-    return ((AnimationStateData*)self)->getMix((Animation *)from, (Animation *)to);
+	AnimationStateData *_self = (AnimationStateData *) self;
+	return _self->getMix((Animation *) from, (Animation *) to);
 }
 
 void spine_animation_state_data_clear(spine_animation_state_data self) {
-    ((AnimationStateData*)self)->clear();
+	AnimationStateData *_self = (AnimationStateData *) self;
+	_self->clear();
 }

spine-c/src/generated/animation_state_data.h

@@ -15,7 +15,7 @@ SPINE_C_API void spine_animation_state_data_dispose(spine_animation_state_data s
 SPINE_C_API spine_skeleton_data spine_animation_state_data_get_skeleton_data(spine_animation_state_data self);
 SPINE_C_API float spine_animation_state_data_get_default_mix(spine_animation_state_data self);
 SPINE_C_API void spine_animation_state_data_set_default_mix(spine_animation_state_data self, float inValue);
-SPINE_C_API void spine_animation_state_data_set_mix_1(spine_animation_state_data self, const char * fromName, const char * toName, float duration);
+SPINE_C_API void spine_animation_state_data_set_mix_1(spine_animation_state_data self, const char *fromName, const char *toName, float duration);
 SPINE_C_API void spine_animation_state_data_set_mix_2(spine_animation_state_data self, spine_animation from, spine_animation to, float duration);
 SPINE_C_API float spine_animation_state_data_get_mix(spine_animation_state_data self, spine_animation from, spine_animation to);
 SPINE_C_API void spine_animation_state_data_clear(spine_animation_state_data self);

spine-c/src/generated/arrays.cpp

@@ -33,1567 +33,1894 @@
 using namespace spine;
 
 spine_array_float spine_array_float_create(void) {
-    return (spine_array_float) new (__FILE__, __LINE__) Array<float>();
+	return (spine_array_float) new (__FILE__, __LINE__) Array<float>();
 }
 
 spine_array_float spine_array_float_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_float) new (__FILE__, __LINE__) Array<float>(initialCapacity);
+	return (spine_array_float) new (__FILE__, __LINE__) Array<float>(initialCapacity);
 }
 void spine_array_float_dispose(spine_array_float array) {
-    delete (Array<float>*)array;
+	delete (Array<float> *) array;
 }
 void spine_array_float_clear(spine_array_float array) {
-    ((Array<float>*)array)->clear();
+	Array<float> *_array = (Array<float> *) array;
+	_array->clear();
 }
 
 size_t spine_array_float_get_capacity(spine_array_float array) {
-    return ((Array<float>*)array)->getCapacity();
+	Array<float> *_array = (Array<float> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_float_size(spine_array_float array) {
-    return ((Array<float>*)array)->size();
+	Array<float> *_array = (Array<float> *) array;
+	return _array->size();
 }
 
 spine_array_float spine_array_float_set_size(spine_array_float array, size_t newSize, float defaultValue) {
-    return (spine_array_float)&((Array<float>*)array)->setSize(newSize, defaultValue);
+	Array<float> *_array = (Array<float> *) array;
+	return (spine_array_float) &_array->setSize(newSize, defaultValue);
 }
 
 void spine_array_float_ensure_capacity(spine_array_float array, size_t newCapacity) {
-    ((Array<float>*)array)->ensureCapacity(newCapacity);
+	Array<float> *_array = (Array<float> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_float_add(spine_array_float array, float inValue) {
-    ((Array<float>*)array)->add(inValue);
+	Array<float> *_array = (Array<float> *) array;
+	_array->add(inValue);
 }
 
 void spine_array_float_add_all(spine_array_float array, spine_array_float inValue) {
-    ((Array<float>*)array)->addAll(*((const Array<float>*)inValue));
+	Array<float> *_array = (Array<float> *) array;
+	_array->addAll(*((const Array<float> *) inValue));
 }
 
 void spine_array_float_clear_and_add_all(spine_array_float array, spine_array_float inValue) {
-    ((Array<float>*)array)->clearAndAddAll(*((const Array<float>*)inValue));
+	Array<float> *_array = (Array<float> *) array;
+	_array->clearAndAddAll(*((const Array<float> *) inValue));
 }
 
 void spine_array_float_remove_at(spine_array_float array, size_t inIndex) {
-    ((Array<float>*)array)->removeAt(inIndex);
+	Array<float> *_array = (Array<float> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_float_contains(spine_array_float array, float inValue) {
-    return ((Array<float>*)array)->contains(inValue);
+	Array<float> *_array = (Array<float> *) array;
+	return _array->contains(inValue);
 }
 
 int spine_array_float_index_of(spine_array_float array, float inValue) {
-    return ((Array<float>*)array)->indexOf(inValue);
+	Array<float> *_array = (Array<float> *) array;
+	return _array->indexOf(inValue);
 }
 
-float * spine_array_float_buffer(spine_array_float array) {
-    return ((Array<float>*)array)->buffer();
+float *spine_array_float_buffer(spine_array_float array) {
+	Array<float> *_array = (Array<float> *) array;
+	return _array->buffer();
 }
 
 spine_array_int spine_array_int_create(void) {
-    return (spine_array_int) new (__FILE__, __LINE__) Array<int>();
+	return (spine_array_int) new (__FILE__, __LINE__) Array<int>();
 }
 
 spine_array_int spine_array_int_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_int) new (__FILE__, __LINE__) Array<int>(initialCapacity);
+	return (spine_array_int) new (__FILE__, __LINE__) Array<int>(initialCapacity);
 }
 void spine_array_int_dispose(spine_array_int array) {
-    delete (Array<int>*)array;
+	delete (Array<int> *) array;
 }
 void spine_array_int_clear(spine_array_int array) {
-    ((Array<int>*)array)->clear();
+	Array<int> *_array = (Array<int> *) array;
+	_array->clear();
 }
 
 size_t spine_array_int_get_capacity(spine_array_int array) {
-    return ((Array<int>*)array)->getCapacity();
+	Array<int> *_array = (Array<int> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_int_size(spine_array_int array) {
-    return ((Array<int>*)array)->size();
+	Array<int> *_array = (Array<int> *) array;
+	return _array->size();
 }
 
 spine_array_int spine_array_int_set_size(spine_array_int array, size_t newSize, int defaultValue) {
-    return (spine_array_int)&((Array<int>*)array)->setSize(newSize, defaultValue);
+	Array<int> *_array = (Array<int> *) array;
+	return (spine_array_int) &_array->setSize(newSize, defaultValue);
 }
 
 void spine_array_int_ensure_capacity(spine_array_int array, size_t newCapacity) {
-    ((Array<int>*)array)->ensureCapacity(newCapacity);
+	Array<int> *_array = (Array<int> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_int_add(spine_array_int array, int inValue) {
-    ((Array<int>*)array)->add(inValue);
+	Array<int> *_array = (Array<int> *) array;
+	_array->add(inValue);
 }
 
 void spine_array_int_add_all(spine_array_int array, spine_array_int inValue) {
-    ((Array<int>*)array)->addAll(*((const Array<int>*)inValue));
+	Array<int> *_array = (Array<int> *) array;
+	_array->addAll(*((const Array<int> *) inValue));
 }
 
 void spine_array_int_clear_and_add_all(spine_array_int array, spine_array_int inValue) {
-    ((Array<int>*)array)->clearAndAddAll(*((const Array<int>*)inValue));
+	Array<int> *_array = (Array<int> *) array;
+	_array->clearAndAddAll(*((const Array<int> *) inValue));
 }
 
 void spine_array_int_remove_at(spine_array_int array, size_t inIndex) {
-    ((Array<int>*)array)->removeAt(inIndex);
+	Array<int> *_array = (Array<int> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_int_contains(spine_array_int array, int inValue) {
-    return ((Array<int>*)array)->contains(inValue);
+	Array<int> *_array = (Array<int> *) array;
+	return _array->contains(inValue);
 }
 
 int spine_array_int_index_of(spine_array_int array, int inValue) {
-    return ((Array<int>*)array)->indexOf(inValue);
+	Array<int> *_array = (Array<int> *) array;
+	return _array->indexOf(inValue);
 }
 
-int * spine_array_int_buffer(spine_array_int array) {
-    return ((Array<int>*)array)->buffer();
+int *spine_array_int_buffer(spine_array_int array) {
+	Array<int> *_array = (Array<int> *) array;
+	return _array->buffer();
 }
 
 spine_array_unsigned_short spine_array_unsigned_short_create(void) {
-    return (spine_array_unsigned_short) new (__FILE__, __LINE__) Array<unsigned short>();
+	return (spine_array_unsigned_short) new (__FILE__, __LINE__) Array<unsigned short>();
 }
 
 spine_array_unsigned_short spine_array_unsigned_short_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_unsigned_short) new (__FILE__, __LINE__) Array<unsigned short>(initialCapacity);
+	return (spine_array_unsigned_short) new (__FILE__, __LINE__) Array<unsigned short>(initialCapacity);
 }
 void spine_array_unsigned_short_dispose(spine_array_unsigned_short array) {
-    delete (Array<unsigned short>*)array;
+	delete (Array<unsigned short> *) array;
 }
 void spine_array_unsigned_short_clear(spine_array_unsigned_short array) {
-    ((Array<unsigned short>*)array)->clear();
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	_array->clear();
 }
 
 size_t spine_array_unsigned_short_get_capacity(spine_array_unsigned_short array) {
-    return ((Array<unsigned short>*)array)->getCapacity();
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_unsigned_short_size(spine_array_unsigned_short array) {
-    return ((Array<unsigned short>*)array)->size();
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	return _array->size();
 }
 
 spine_array_unsigned_short spine_array_unsigned_short_set_size(spine_array_unsigned_short array, size_t newSize, unsigned short defaultValue) {
-    return (spine_array_unsigned_short)&((Array<unsigned short>*)array)->setSize(newSize, defaultValue);
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	return (spine_array_unsigned_short) &_array->setSize(newSize, defaultValue);
 }
 
 void spine_array_unsigned_short_ensure_capacity(spine_array_unsigned_short array, size_t newCapacity) {
-    ((Array<unsigned short>*)array)->ensureCapacity(newCapacity);
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_unsigned_short_add(spine_array_unsigned_short array, unsigned short inValue) {
-    ((Array<unsigned short>*)array)->add(inValue);
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	_array->add(inValue);
 }
 
 void spine_array_unsigned_short_add_all(spine_array_unsigned_short array, spine_array_unsigned_short inValue) {
-    ((Array<unsigned short>*)array)->addAll(*((const Array<unsigned short>*)inValue));
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	_array->addAll(*((const Array<unsigned short> *) inValue));
 }
 
 void spine_array_unsigned_short_clear_and_add_all(spine_array_unsigned_short array, spine_array_unsigned_short inValue) {
-    ((Array<unsigned short>*)array)->clearAndAddAll(*((const Array<unsigned short>*)inValue));
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	_array->clearAndAddAll(*((const Array<unsigned short> *) inValue));
 }
 
 void spine_array_unsigned_short_remove_at(spine_array_unsigned_short array, size_t inIndex) {
-    ((Array<unsigned short>*)array)->removeAt(inIndex);
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_unsigned_short_contains(spine_array_unsigned_short array, unsigned short inValue) {
-    return ((Array<unsigned short>*)array)->contains(inValue);
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	return _array->contains(inValue);
 }
 
 int spine_array_unsigned_short_index_of(spine_array_unsigned_short array, unsigned short inValue) {
-    return ((Array<unsigned short>*)array)->indexOf(inValue);
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	return _array->indexOf(inValue);
 }
 
-unsigned short * spine_array_unsigned_short_buffer(spine_array_unsigned_short array) {
-    return ((Array<unsigned short>*)array)->buffer();
+unsigned short *spine_array_unsigned_short_buffer(spine_array_unsigned_short array) {
+	Array<unsigned short> *_array = (Array<unsigned short> *) array;
+	return _array->buffer();
 }
 
 spine_array_property_id spine_array_property_id_create(void) {
-    return (spine_array_property_id) new (__FILE__, __LINE__) Array<PropertyId>();
+	return (spine_array_property_id) new (__FILE__, __LINE__) Array<PropertyId>();
 }
 
 spine_array_property_id spine_array_property_id_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_property_id) new (__FILE__, __LINE__) Array<PropertyId>(initialCapacity);
+	return (spine_array_property_id) new (__FILE__, __LINE__) Array<PropertyId>(initialCapacity);
 }
 void spine_array_property_id_dispose(spine_array_property_id array) {
-    delete (Array<PropertyId>*)array;
+	delete (Array<PropertyId> *) array;
 }
 void spine_array_property_id_clear(spine_array_property_id array) {
-    ((Array<PropertyId>*)array)->clear();
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	_array->clear();
 }
 
 size_t spine_array_property_id_get_capacity(spine_array_property_id array) {
-    return ((Array<PropertyId>*)array)->getCapacity();
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_property_id_size(spine_array_property_id array) {
-    return ((Array<PropertyId>*)array)->size();
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	return _array->size();
 }
 
 spine_array_property_id spine_array_property_id_set_size(spine_array_property_id array, size_t newSize, int64_t defaultValue) {
-    return (spine_array_property_id)&((Array<PropertyId>*)array)->setSize(newSize, *((const PropertyId*)defaultValue));
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	return (spine_array_property_id) &_array->setSize(newSize, *((const PropertyId *) defaultValue));
 }
 
 void spine_array_property_id_ensure_capacity(spine_array_property_id array, size_t newCapacity) {
-    ((Array<PropertyId>*)array)->ensureCapacity(newCapacity);
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_property_id_add(spine_array_property_id array, int64_t inValue) {
-    ((Array<PropertyId>*)array)->add(*((const PropertyId*)inValue));
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	_array->add(*((const PropertyId *) inValue));
 }
 
 void spine_array_property_id_add_all(spine_array_property_id array, spine_array_property_id inValue) {
-    ((Array<PropertyId>*)array)->addAll(*((const Array<PropertyId>*)inValue));
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	_array->addAll(*((const Array<PropertyId> *) inValue));
 }
 
 void spine_array_property_id_clear_and_add_all(spine_array_property_id array, spine_array_property_id inValue) {
-    ((Array<PropertyId>*)array)->clearAndAddAll(*((const Array<PropertyId>*)inValue));
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	_array->clearAndAddAll(*((const Array<PropertyId> *) inValue));
 }
 
 void spine_array_property_id_remove_at(spine_array_property_id array, size_t inIndex) {
-    ((Array<PropertyId>*)array)->removeAt(inIndex);
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_property_id_contains(spine_array_property_id array, int64_t inValue) {
-    return ((Array<PropertyId>*)array)->contains(*((const PropertyId*)inValue));
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	return _array->contains(*((const PropertyId *) inValue));
 }
 
 int spine_array_property_id_index_of(spine_array_property_id array, int64_t inValue) {
-    return ((Array<PropertyId>*)array)->indexOf(*((const PropertyId*)inValue));
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	return _array->indexOf(*((const PropertyId *) inValue));
 }
 
 spine_property_id spine_array_property_id_buffer(spine_array_property_id array) {
-    return (spine_property_id)((Array<PropertyId>*)array)->buffer();
+	Array<PropertyId> *_array = (Array<PropertyId> *) array;
+	return (spine_property_id) _array->buffer();
 }
 
 spine_array_animation spine_array_animation_create(void) {
-    return (spine_array_animation) new (__FILE__, __LINE__) Array<Animation *>();
+	return (spine_array_animation) new (__FILE__, __LINE__) Array<Animation *>();
 }
 
 spine_array_animation spine_array_animation_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_animation) new (__FILE__, __LINE__) Array<Animation *>(initialCapacity);
+	return (spine_array_animation) new (__FILE__, __LINE__) Array<Animation *>(initialCapacity);
 }
 void spine_array_animation_dispose(spine_array_animation array) {
-    delete (Array<Animation *>*)array;
+	delete (Array<Animation *> *) array;
 }
 void spine_array_animation_clear(spine_array_animation array) {
-    ((Array<Animation *>*)array)->clear();
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_animation_get_capacity(spine_array_animation array) {
-    return ((Array<Animation *>*)array)->getCapacity();
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_animation_size(spine_array_animation array) {
-    return ((Array<Animation *>*)array)->size();
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	return _array->size();
 }
 
 spine_array_animation spine_array_animation_set_size(spine_array_animation array, size_t newSize, spine_animation defaultValue) {
-    return (spine_array_animation)&((Array<Animation *>*)array)->setSize(newSize, (Animation *)defaultValue);
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	return (spine_array_animation) &_array->setSize(newSize, (Animation *) defaultValue);
 }
 
 void spine_array_animation_ensure_capacity(spine_array_animation array, size_t newCapacity) {
-    ((Array<Animation *>*)array)->ensureCapacity(newCapacity);
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_animation_add(spine_array_animation array, spine_animation inValue) {
-    ((Array<Animation *>*)array)->add((Animation *)inValue);
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	_array->add((Animation *) inValue);
 }
 
 void spine_array_animation_add_all(spine_array_animation array, spine_array_animation inValue) {
-    ((Array<Animation *>*)array)->addAll(*((const Array<Animation *>*)inValue));
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	_array->addAll(*((const Array<Animation *> *) inValue));
 }
 
 void spine_array_animation_clear_and_add_all(spine_array_animation array, spine_array_animation inValue) {
-    ((Array<Animation *>*)array)->clearAndAddAll(*((const Array<Animation *>*)inValue));
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	_array->clearAndAddAll(*((const Array<Animation *> *) inValue));
 }
 
 void spine_array_animation_remove_at(spine_array_animation array, size_t inIndex) {
-    ((Array<Animation *>*)array)->removeAt(inIndex);
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_animation_contains(spine_array_animation array, spine_animation inValue) {
-    return ((Array<Animation *>*)array)->contains((Animation *)inValue);
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	return _array->contains((Animation *) inValue);
 }
 
 int spine_array_animation_index_of(spine_array_animation array, spine_animation inValue) {
-    return ((Array<Animation *>*)array)->indexOf((Animation *)inValue);
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	return _array->indexOf((Animation *) inValue);
 }
 
-spine_animation * spine_array_animation_buffer(spine_array_animation array) {
-    return (spine_animation *)((Array<Animation *>*)array)->buffer();
+spine_animation *spine_array_animation_buffer(spine_array_animation array) {
+	Array<Animation *> *_array = (Array<Animation *> *) array;
+	return (spine_animation *) _array->buffer();
 }
 
 spine_array_atlas_page spine_array_atlas_page_create(void) {
-    return (spine_array_atlas_page) new (__FILE__, __LINE__) Array<AtlasPage *>();
+	return (spine_array_atlas_page) new (__FILE__, __LINE__) Array<AtlasPage *>();
 }
 
 spine_array_atlas_page spine_array_atlas_page_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_atlas_page) new (__FILE__, __LINE__) Array<AtlasPage *>(initialCapacity);
+	return (spine_array_atlas_page) new (__FILE__, __LINE__) Array<AtlasPage *>(initialCapacity);
 }
 void spine_array_atlas_page_dispose(spine_array_atlas_page array) {
-    delete (Array<AtlasPage *>*)array;
+	delete (Array<AtlasPage *> *) array;
 }
 void spine_array_atlas_page_clear(spine_array_atlas_page array) {
-    ((Array<AtlasPage *>*)array)->clear();
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_atlas_page_get_capacity(spine_array_atlas_page array) {
-    return ((Array<AtlasPage *>*)array)->getCapacity();
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_atlas_page_size(spine_array_atlas_page array) {
-    return ((Array<AtlasPage *>*)array)->size();
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	return _array->size();
 }
 
 spine_array_atlas_page spine_array_atlas_page_set_size(spine_array_atlas_page array, size_t newSize, spine_atlas_page defaultValue) {
-    return (spine_array_atlas_page)&((Array<AtlasPage *>*)array)->setSize(newSize, (AtlasPage *)defaultValue);
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	return (spine_array_atlas_page) &_array->setSize(newSize, (AtlasPage *) defaultValue);
 }
 
 void spine_array_atlas_page_ensure_capacity(spine_array_atlas_page array, size_t newCapacity) {
-    ((Array<AtlasPage *>*)array)->ensureCapacity(newCapacity);
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_atlas_page_add(spine_array_atlas_page array, spine_atlas_page inValue) {
-    ((Array<AtlasPage *>*)array)->add((AtlasPage *)inValue);
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	_array->add((AtlasPage *) inValue);
 }
 
 void spine_array_atlas_page_add_all(spine_array_atlas_page array, spine_array_atlas_page inValue) {
-    ((Array<AtlasPage *>*)array)->addAll(*((const Array<AtlasPage *>*)inValue));
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	_array->addAll(*((const Array<AtlasPage *> *) inValue));
 }
 
 void spine_array_atlas_page_clear_and_add_all(spine_array_atlas_page array, spine_array_atlas_page inValue) {
-    ((Array<AtlasPage *>*)array)->clearAndAddAll(*((const Array<AtlasPage *>*)inValue));
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	_array->clearAndAddAll(*((const Array<AtlasPage *> *) inValue));
 }
 
 void spine_array_atlas_page_remove_at(spine_array_atlas_page array, size_t inIndex) {
-    ((Array<AtlasPage *>*)array)->removeAt(inIndex);
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_atlas_page_contains(spine_array_atlas_page array, spine_atlas_page inValue) {
-    return ((Array<AtlasPage *>*)array)->contains((AtlasPage *)inValue);
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	return _array->contains((AtlasPage *) inValue);
 }
 
 int spine_array_atlas_page_index_of(spine_array_atlas_page array, spine_atlas_page inValue) {
-    return ((Array<AtlasPage *>*)array)->indexOf((AtlasPage *)inValue);
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	return _array->indexOf((AtlasPage *) inValue);
 }
 
-spine_atlas_page * spine_array_atlas_page_buffer(spine_array_atlas_page array) {
-    return (spine_atlas_page *)((Array<AtlasPage *>*)array)->buffer();
+spine_atlas_page *spine_array_atlas_page_buffer(spine_array_atlas_page array) {
+	Array<AtlasPage *> *_array = (Array<AtlasPage *> *) array;
+	return (spine_atlas_page *) _array->buffer();
 }
 
 spine_array_atlas_region spine_array_atlas_region_create(void) {
-    return (spine_array_atlas_region) new (__FILE__, __LINE__) Array<AtlasRegion *>();
+	return (spine_array_atlas_region) new (__FILE__, __LINE__) Array<AtlasRegion *>();
 }
 
 spine_array_atlas_region spine_array_atlas_region_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_atlas_region) new (__FILE__, __LINE__) Array<AtlasRegion *>(initialCapacity);
+	return (spine_array_atlas_region) new (__FILE__, __LINE__) Array<AtlasRegion *>(initialCapacity);
 }
 void spine_array_atlas_region_dispose(spine_array_atlas_region array) {
-    delete (Array<AtlasRegion *>*)array;
+	delete (Array<AtlasRegion *> *) array;
 }
 void spine_array_atlas_region_clear(spine_array_atlas_region array) {
-    ((Array<AtlasRegion *>*)array)->clear();
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_atlas_region_get_capacity(spine_array_atlas_region array) {
-    return ((Array<AtlasRegion *>*)array)->getCapacity();
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_atlas_region_size(spine_array_atlas_region array) {
-    return ((Array<AtlasRegion *>*)array)->size();
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	return _array->size();
 }
 
 spine_array_atlas_region spine_array_atlas_region_set_size(spine_array_atlas_region array, size_t newSize, spine_atlas_region defaultValue) {
-    return (spine_array_atlas_region)&((Array<AtlasRegion *>*)array)->setSize(newSize, (AtlasRegion *)defaultValue);
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	return (spine_array_atlas_region) &_array->setSize(newSize, (AtlasRegion *) defaultValue);
 }
 
 void spine_array_atlas_region_ensure_capacity(spine_array_atlas_region array, size_t newCapacity) {
-    ((Array<AtlasRegion *>*)array)->ensureCapacity(newCapacity);
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_atlas_region_add(spine_array_atlas_region array, spine_atlas_region inValue) {
-    ((Array<AtlasRegion *>*)array)->add((AtlasRegion *)inValue);
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	_array->add((AtlasRegion *) inValue);
 }
 
 void spine_array_atlas_region_add_all(spine_array_atlas_region array, spine_array_atlas_region inValue) {
-    ((Array<AtlasRegion *>*)array)->addAll(*((const Array<AtlasRegion *>*)inValue));
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	_array->addAll(*((const Array<AtlasRegion *> *) inValue));
 }
 
 void spine_array_atlas_region_clear_and_add_all(spine_array_atlas_region array, spine_array_atlas_region inValue) {
-    ((Array<AtlasRegion *>*)array)->clearAndAddAll(*((const Array<AtlasRegion *>*)inValue));
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	_array->clearAndAddAll(*((const Array<AtlasRegion *> *) inValue));
 }
 
 void spine_array_atlas_region_remove_at(spine_array_atlas_region array, size_t inIndex) {
-    ((Array<AtlasRegion *>*)array)->removeAt(inIndex);
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_atlas_region_contains(spine_array_atlas_region array, spine_atlas_region inValue) {
-    return ((Array<AtlasRegion *>*)array)->contains((AtlasRegion *)inValue);
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	return _array->contains((AtlasRegion *) inValue);
 }
 
 int spine_array_atlas_region_index_of(spine_array_atlas_region array, spine_atlas_region inValue) {
-    return ((Array<AtlasRegion *>*)array)->indexOf((AtlasRegion *)inValue);
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	return _array->indexOf((AtlasRegion *) inValue);
 }
 
-spine_atlas_region * spine_array_atlas_region_buffer(spine_array_atlas_region array) {
-    return (spine_atlas_region *)((Array<AtlasRegion *>*)array)->buffer();
+spine_atlas_region *spine_array_atlas_region_buffer(spine_array_atlas_region array) {
+	Array<AtlasRegion *> *_array = (Array<AtlasRegion *> *) array;
+	return (spine_atlas_region *) _array->buffer();
 }
 
 spine_array_attachment spine_array_attachment_create(void) {
-    return (spine_array_attachment) new (__FILE__, __LINE__) Array<Attachment *>();
+	return (spine_array_attachment) new (__FILE__, __LINE__) Array<Attachment *>();
 }
 
 spine_array_attachment spine_array_attachment_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_attachment) new (__FILE__, __LINE__) Array<Attachment *>(initialCapacity);
+	return (spine_array_attachment) new (__FILE__, __LINE__) Array<Attachment *>(initialCapacity);
 }
 void spine_array_attachment_dispose(spine_array_attachment array) {
-    delete (Array<Attachment *>*)array;
+	delete (Array<Attachment *> *) array;
 }
 void spine_array_attachment_clear(spine_array_attachment array) {
-    ((Array<Attachment *>*)array)->clear();
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_attachment_get_capacity(spine_array_attachment array) {
-    return ((Array<Attachment *>*)array)->getCapacity();
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_attachment_size(spine_array_attachment array) {
-    return ((Array<Attachment *>*)array)->size();
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	return _array->size();
 }
 
 spine_array_attachment spine_array_attachment_set_size(spine_array_attachment array, size_t newSize, spine_attachment defaultValue) {
-    return (spine_array_attachment)&((Array<Attachment *>*)array)->setSize(newSize, (Attachment *)defaultValue);
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	return (spine_array_attachment) &_array->setSize(newSize, (Attachment *) defaultValue);
 }
 
 void spine_array_attachment_ensure_capacity(spine_array_attachment array, size_t newCapacity) {
-    ((Array<Attachment *>*)array)->ensureCapacity(newCapacity);
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_attachment_add(spine_array_attachment array, spine_attachment inValue) {
-    ((Array<Attachment *>*)array)->add((Attachment *)inValue);
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	_array->add((Attachment *) inValue);
 }
 
 void spine_array_attachment_add_all(spine_array_attachment array, spine_array_attachment inValue) {
-    ((Array<Attachment *>*)array)->addAll(*((const Array<Attachment *>*)inValue));
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	_array->addAll(*((const Array<Attachment *> *) inValue));
 }
 
 void spine_array_attachment_clear_and_add_all(spine_array_attachment array, spine_array_attachment inValue) {
-    ((Array<Attachment *>*)array)->clearAndAddAll(*((const Array<Attachment *>*)inValue));
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	_array->clearAndAddAll(*((const Array<Attachment *> *) inValue));
 }
 
 void spine_array_attachment_remove_at(spine_array_attachment array, size_t inIndex) {
-    ((Array<Attachment *>*)array)->removeAt(inIndex);
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_attachment_contains(spine_array_attachment array, spine_attachment inValue) {
-    return ((Array<Attachment *>*)array)->contains((Attachment *)inValue);
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	return _array->contains((Attachment *) inValue);
 }
 
 int spine_array_attachment_index_of(spine_array_attachment array, spine_attachment inValue) {
-    return ((Array<Attachment *>*)array)->indexOf((Attachment *)inValue);
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	return _array->indexOf((Attachment *) inValue);
 }
 
-spine_attachment * spine_array_attachment_buffer(spine_array_attachment array) {
-    return (spine_attachment *)((Array<Attachment *>*)array)->buffer();
+spine_attachment *spine_array_attachment_buffer(spine_array_attachment array) {
+	Array<Attachment *> *_array = (Array<Attachment *> *) array;
+	return (spine_attachment *) _array->buffer();
 }
 
 spine_array_bone spine_array_bone_create(void) {
-    return (spine_array_bone) new (__FILE__, __LINE__) Array<Bone *>();
+	return (spine_array_bone) new (__FILE__, __LINE__) Array<Bone *>();
 }
 
 spine_array_bone spine_array_bone_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_bone) new (__FILE__, __LINE__) Array<Bone *>(initialCapacity);
+	return (spine_array_bone) new (__FILE__, __LINE__) Array<Bone *>(initialCapacity);
 }
 void spine_array_bone_dispose(spine_array_bone array) {
-    delete (Array<Bone *>*)array;
+	delete (Array<Bone *> *) array;
 }
 void spine_array_bone_clear(spine_array_bone array) {
-    ((Array<Bone *>*)array)->clear();
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_bone_get_capacity(spine_array_bone array) {
-    return ((Array<Bone *>*)array)->getCapacity();
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_bone_size(spine_array_bone array) {
-    return ((Array<Bone *>*)array)->size();
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	return _array->size();
 }
 
 spine_array_bone spine_array_bone_set_size(spine_array_bone array, size_t newSize, spine_bone defaultValue) {
-    return (spine_array_bone)&((Array<Bone *>*)array)->setSize(newSize, (Bone *)defaultValue);
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	return (spine_array_bone) &_array->setSize(newSize, (Bone *) defaultValue);
 }
 
 void spine_array_bone_ensure_capacity(spine_array_bone array, size_t newCapacity) {
-    ((Array<Bone *>*)array)->ensureCapacity(newCapacity);
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_bone_add(spine_array_bone array, spine_bone inValue) {
-    ((Array<Bone *>*)array)->add((Bone *)inValue);
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	_array->add((Bone *) inValue);
 }
 
 void spine_array_bone_add_all(spine_array_bone array, spine_array_bone inValue) {
-    ((Array<Bone *>*)array)->addAll(*((const Array<Bone *>*)inValue));
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	_array->addAll(*((const Array<Bone *> *) inValue));
 }
 
 void spine_array_bone_clear_and_add_all(spine_array_bone array, spine_array_bone inValue) {
-    ((Array<Bone *>*)array)->clearAndAddAll(*((const Array<Bone *>*)inValue));
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	_array->clearAndAddAll(*((const Array<Bone *> *) inValue));
 }
 
 void spine_array_bone_remove_at(spine_array_bone array, size_t inIndex) {
-    ((Array<Bone *>*)array)->removeAt(inIndex);
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_bone_contains(spine_array_bone array, spine_bone inValue) {
-    return ((Array<Bone *>*)array)->contains((Bone *)inValue);
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	return _array->contains((Bone *) inValue);
 }
 
 int spine_array_bone_index_of(spine_array_bone array, spine_bone inValue) {
-    return ((Array<Bone *>*)array)->indexOf((Bone *)inValue);
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	return _array->indexOf((Bone *) inValue);
 }
 
-spine_bone * spine_array_bone_buffer(spine_array_bone array) {
-    return (spine_bone *)((Array<Bone *>*)array)->buffer();
+spine_bone *spine_array_bone_buffer(spine_array_bone array) {
+	Array<Bone *> *_array = (Array<Bone *> *) array;
+	return (spine_bone *) _array->buffer();
 }
 
 spine_array_bone_data spine_array_bone_data_create(void) {
-    return (spine_array_bone_data) new (__FILE__, __LINE__) Array<BoneData *>();
+	return (spine_array_bone_data) new (__FILE__, __LINE__) Array<BoneData *>();
 }
 
 spine_array_bone_data spine_array_bone_data_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_bone_data) new (__FILE__, __LINE__) Array<BoneData *>(initialCapacity);
+	return (spine_array_bone_data) new (__FILE__, __LINE__) Array<BoneData *>(initialCapacity);
 }
 void spine_array_bone_data_dispose(spine_array_bone_data array) {
-    delete (Array<BoneData *>*)array;
+	delete (Array<BoneData *> *) array;
 }
 void spine_array_bone_data_clear(spine_array_bone_data array) {
-    ((Array<BoneData *>*)array)->clear();
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_bone_data_get_capacity(spine_array_bone_data array) {
-    return ((Array<BoneData *>*)array)->getCapacity();
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_bone_data_size(spine_array_bone_data array) {
-    return ((Array<BoneData *>*)array)->size();
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	return _array->size();
 }
 
 spine_array_bone_data spine_array_bone_data_set_size(spine_array_bone_data array, size_t newSize, spine_bone_data defaultValue) {
-    return (spine_array_bone_data)&((Array<BoneData *>*)array)->setSize(newSize, (BoneData *)defaultValue);
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	return (spine_array_bone_data) &_array->setSize(newSize, (BoneData *) defaultValue);
 }
 
 void spine_array_bone_data_ensure_capacity(spine_array_bone_data array, size_t newCapacity) {
-    ((Array<BoneData *>*)array)->ensureCapacity(newCapacity);
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_bone_data_add(spine_array_bone_data array, spine_bone_data inValue) {
-    ((Array<BoneData *>*)array)->add((BoneData *)inValue);
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	_array->add((BoneData *) inValue);
 }
 
 void spine_array_bone_data_add_all(spine_array_bone_data array, spine_array_bone_data inValue) {
-    ((Array<BoneData *>*)array)->addAll(*((const Array<BoneData *>*)inValue));
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	_array->addAll(*((const Array<BoneData *> *) inValue));
 }
 
 void spine_array_bone_data_clear_and_add_all(spine_array_bone_data array, spine_array_bone_data inValue) {
-    ((Array<BoneData *>*)array)->clearAndAddAll(*((const Array<BoneData *>*)inValue));
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	_array->clearAndAddAll(*((const Array<BoneData *> *) inValue));
 }
 
 void spine_array_bone_data_remove_at(spine_array_bone_data array, size_t inIndex) {
-    ((Array<BoneData *>*)array)->removeAt(inIndex);
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_bone_data_contains(spine_array_bone_data array, spine_bone_data inValue) {
-    return ((Array<BoneData *>*)array)->contains((BoneData *)inValue);
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	return _array->contains((BoneData *) inValue);
 }
 
 int spine_array_bone_data_index_of(spine_array_bone_data array, spine_bone_data inValue) {
-    return ((Array<BoneData *>*)array)->indexOf((BoneData *)inValue);
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	return _array->indexOf((BoneData *) inValue);
 }
 
-spine_bone_data * spine_array_bone_data_buffer(spine_array_bone_data array) {
-    return (spine_bone_data *)((Array<BoneData *>*)array)->buffer();
+spine_bone_data *spine_array_bone_data_buffer(spine_array_bone_data array) {
+	Array<BoneData *> *_array = (Array<BoneData *> *) array;
+	return (spine_bone_data *) _array->buffer();
 }
 
 spine_array_bone_pose spine_array_bone_pose_create(void) {
-    return (spine_array_bone_pose) new (__FILE__, __LINE__) Array<BonePose *>();
+	return (spine_array_bone_pose) new (__FILE__, __LINE__) Array<BonePose *>();
 }
 
 spine_array_bone_pose spine_array_bone_pose_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_bone_pose) new (__FILE__, __LINE__) Array<BonePose *>(initialCapacity);
+	return (spine_array_bone_pose) new (__FILE__, __LINE__) Array<BonePose *>(initialCapacity);
 }
 void spine_array_bone_pose_dispose(spine_array_bone_pose array) {
-    delete (Array<BonePose *>*)array;
+	delete (Array<BonePose *> *) array;
 }
 void spine_array_bone_pose_clear(spine_array_bone_pose array) {
-    ((Array<BonePose *>*)array)->clear();
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_bone_pose_get_capacity(spine_array_bone_pose array) {
-    return ((Array<BonePose *>*)array)->getCapacity();
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_bone_pose_size(spine_array_bone_pose array) {
-    return ((Array<BonePose *>*)array)->size();
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	return _array->size();
 }
 
 spine_array_bone_pose spine_array_bone_pose_set_size(spine_array_bone_pose array, size_t newSize, spine_bone_pose defaultValue) {
-    return (spine_array_bone_pose)&((Array<BonePose *>*)array)->setSize(newSize, (BonePose *)defaultValue);
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	return (spine_array_bone_pose) &_array->setSize(newSize, (BonePose *) defaultValue);
 }
 
 void spine_array_bone_pose_ensure_capacity(spine_array_bone_pose array, size_t newCapacity) {
-    ((Array<BonePose *>*)array)->ensureCapacity(newCapacity);
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_bone_pose_add(spine_array_bone_pose array, spine_bone_pose inValue) {
-    ((Array<BonePose *>*)array)->add((BonePose *)inValue);
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	_array->add((BonePose *) inValue);
 }
 
 void spine_array_bone_pose_add_all(spine_array_bone_pose array, spine_array_bone_pose inValue) {
-    ((Array<BonePose *>*)array)->addAll(*((const Array<BonePose *>*)inValue));
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	_array->addAll(*((const Array<BonePose *> *) inValue));
 }
 
 void spine_array_bone_pose_clear_and_add_all(spine_array_bone_pose array, spine_array_bone_pose inValue) {
-    ((Array<BonePose *>*)array)->clearAndAddAll(*((const Array<BonePose *>*)inValue));
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	_array->clearAndAddAll(*((const Array<BonePose *> *) inValue));
 }
 
 void spine_array_bone_pose_remove_at(spine_array_bone_pose array, size_t inIndex) {
-    ((Array<BonePose *>*)array)->removeAt(inIndex);
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_bone_pose_contains(spine_array_bone_pose array, spine_bone_pose inValue) {
-    return ((Array<BonePose *>*)array)->contains((BonePose *)inValue);
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	return _array->contains((BonePose *) inValue);
 }
 
 int spine_array_bone_pose_index_of(spine_array_bone_pose array, spine_bone_pose inValue) {
-    return ((Array<BonePose *>*)array)->indexOf((BonePose *)inValue);
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	return _array->indexOf((BonePose *) inValue);
 }
 
-spine_bone_pose * spine_array_bone_pose_buffer(spine_array_bone_pose array) {
-    return (spine_bone_pose *)((Array<BonePose *>*)array)->buffer();
+spine_bone_pose *spine_array_bone_pose_buffer(spine_array_bone_pose array) {
+	Array<BonePose *> *_array = (Array<BonePose *> *) array;
+	return (spine_bone_pose *) _array->buffer();
 }
 
 spine_array_bounding_box_attachment spine_array_bounding_box_attachment_create(void) {
-    return (spine_array_bounding_box_attachment) new (__FILE__, __LINE__) Array<BoundingBoxAttachment *>();
+	return (spine_array_bounding_box_attachment) new (__FILE__, __LINE__) Array<BoundingBoxAttachment *>();
 }
 
 spine_array_bounding_box_attachment spine_array_bounding_box_attachment_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_bounding_box_attachment) new (__FILE__, __LINE__) Array<BoundingBoxAttachment *>(initialCapacity);
+	return (spine_array_bounding_box_attachment) new (__FILE__, __LINE__) Array<BoundingBoxAttachment *>(initialCapacity);
 }
 void spine_array_bounding_box_attachment_dispose(spine_array_bounding_box_attachment array) {
-    delete (Array<BoundingBoxAttachment *>*)array;
+	delete (Array<BoundingBoxAttachment *> *) array;
 }
 void spine_array_bounding_box_attachment_clear(spine_array_bounding_box_attachment array) {
-    ((Array<BoundingBoxAttachment *>*)array)->clear();
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_bounding_box_attachment_get_capacity(spine_array_bounding_box_attachment array) {
-    return ((Array<BoundingBoxAttachment *>*)array)->getCapacity();
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_bounding_box_attachment_size(spine_array_bounding_box_attachment array) {
-    return ((Array<BoundingBoxAttachment *>*)array)->size();
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	return _array->size();
 }
 
-spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(spine_array_bounding_box_attachment array, size_t newSize, spine_bounding_box_attachment defaultValue) {
-    return (spine_array_bounding_box_attachment)&((Array<BoundingBoxAttachment *>*)array)->setSize(newSize, (BoundingBoxAttachment *)defaultValue);
+spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(spine_array_bounding_box_attachment array, size_t newSize,
+																				 spine_bounding_box_attachment defaultValue) {
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	return (spine_array_bounding_box_attachment) &_array->setSize(newSize, (BoundingBoxAttachment *) defaultValue);
 }
 
 void spine_array_bounding_box_attachment_ensure_capacity(spine_array_bounding_box_attachment array, size_t newCapacity) {
-    ((Array<BoundingBoxAttachment *>*)array)->ensureCapacity(newCapacity);
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_bounding_box_attachment_add(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue) {
-    ((Array<BoundingBoxAttachment *>*)array)->add((BoundingBoxAttachment *)inValue);
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	_array->add((BoundingBoxAttachment *) inValue);
 }
 
 void spine_array_bounding_box_attachment_add_all(spine_array_bounding_box_attachment array, spine_array_bounding_box_attachment inValue) {
-    ((Array<BoundingBoxAttachment *>*)array)->addAll(*((const Array<BoundingBoxAttachment *>*)inValue));
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	_array->addAll(*((const Array<BoundingBoxAttachment *> *) inValue));
 }
 
 void spine_array_bounding_box_attachment_clear_and_add_all(spine_array_bounding_box_attachment array, spine_array_bounding_box_attachment inValue) {
-    ((Array<BoundingBoxAttachment *>*)array)->clearAndAddAll(*((const Array<BoundingBoxAttachment *>*)inValue));
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	_array->clearAndAddAll(*((const Array<BoundingBoxAttachment *> *) inValue));
 }
 
 void spine_array_bounding_box_attachment_remove_at(spine_array_bounding_box_attachment array, size_t inIndex) {
-    ((Array<BoundingBoxAttachment *>*)array)->removeAt(inIndex);
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_bounding_box_attachment_contains(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue) {
-    return ((Array<BoundingBoxAttachment *>*)array)->contains((BoundingBoxAttachment *)inValue);
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	return _array->contains((BoundingBoxAttachment *) inValue);
 }
 
 int spine_array_bounding_box_attachment_index_of(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue) {
-    return ((Array<BoundingBoxAttachment *>*)array)->indexOf((BoundingBoxAttachment *)inValue);
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	return _array->indexOf((BoundingBoxAttachment *) inValue);
 }
 
-spine_bounding_box_attachment * spine_array_bounding_box_attachment_buffer(spine_array_bounding_box_attachment array) {
-    return (spine_bounding_box_attachment *)((Array<BoundingBoxAttachment *>*)array)->buffer();
+spine_bounding_box_attachment *spine_array_bounding_box_attachment_buffer(spine_array_bounding_box_attachment array) {
+	Array<BoundingBoxAttachment *> *_array = (Array<BoundingBoxAttachment *> *) array;
+	return (spine_bounding_box_attachment *) _array->buffer();
 }
 
 spine_array_constraint spine_array_constraint_create(void) {
-    return (spine_array_constraint) new (__FILE__, __LINE__) Array<Constraint *>();
+	return (spine_array_constraint) new (__FILE__, __LINE__) Array<Constraint *>();
 }
 
 spine_array_constraint spine_array_constraint_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_constraint) new (__FILE__, __LINE__) Array<Constraint *>(initialCapacity);
+	return (spine_array_constraint) new (__FILE__, __LINE__) Array<Constraint *>(initialCapacity);
 }
 void spine_array_constraint_dispose(spine_array_constraint array) {
-    delete (Array<Constraint *>*)array;
+	delete (Array<Constraint *> *) array;
 }
 void spine_array_constraint_clear(spine_array_constraint array) {
-    ((Array<Constraint *>*)array)->clear();
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_constraint_get_capacity(spine_array_constraint array) {
-    return ((Array<Constraint *>*)array)->getCapacity();
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_constraint_size(spine_array_constraint array) {
-    return ((Array<Constraint *>*)array)->size();
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	return _array->size();
 }
 
 spine_array_constraint spine_array_constraint_set_size(spine_array_constraint array, size_t newSize, spine_constraint defaultValue) {
-    return (spine_array_constraint)&((Array<Constraint *>*)array)->setSize(newSize, (Constraint *)defaultValue);
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	return (spine_array_constraint) &_array->setSize(newSize, (Constraint *) defaultValue);
 }
 
 void spine_array_constraint_ensure_capacity(spine_array_constraint array, size_t newCapacity) {
-    ((Array<Constraint *>*)array)->ensureCapacity(newCapacity);
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_constraint_add(spine_array_constraint array, spine_constraint inValue) {
-    ((Array<Constraint *>*)array)->add((Constraint *)inValue);
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	_array->add((Constraint *) inValue);
 }
 
 void spine_array_constraint_add_all(spine_array_constraint array, spine_array_constraint inValue) {
-    ((Array<Constraint *>*)array)->addAll(*((const Array<Constraint *>*)inValue));
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	_array->addAll(*((const Array<Constraint *> *) inValue));
 }
 
 void spine_array_constraint_clear_and_add_all(spine_array_constraint array, spine_array_constraint inValue) {
-    ((Array<Constraint *>*)array)->clearAndAddAll(*((const Array<Constraint *>*)inValue));
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	_array->clearAndAddAll(*((const Array<Constraint *> *) inValue));
 }
 
 void spine_array_constraint_remove_at(spine_array_constraint array, size_t inIndex) {
-    ((Array<Constraint *>*)array)->removeAt(inIndex);
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_constraint_contains(spine_array_constraint array, spine_constraint inValue) {
-    return ((Array<Constraint *>*)array)->contains((Constraint *)inValue);
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	return _array->contains((Constraint *) inValue);
 }
 
 int spine_array_constraint_index_of(spine_array_constraint array, spine_constraint inValue) {
-    return ((Array<Constraint *>*)array)->indexOf((Constraint *)inValue);
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	return _array->indexOf((Constraint *) inValue);
 }
 
-spine_constraint * spine_array_constraint_buffer(spine_array_constraint array) {
-    return (spine_constraint *)((Array<Constraint *>*)array)->buffer();
+spine_constraint *spine_array_constraint_buffer(spine_array_constraint array) {
+	Array<Constraint *> *_array = (Array<Constraint *> *) array;
+	return (spine_constraint *) _array->buffer();
 }
 
 spine_array_constraint_data spine_array_constraint_data_create(void) {
-    return (spine_array_constraint_data) new (__FILE__, __LINE__) Array<ConstraintData *>();
+	return (spine_array_constraint_data) new (__FILE__, __LINE__) Array<ConstraintData *>();
 }
 
 spine_array_constraint_data spine_array_constraint_data_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_constraint_data) new (__FILE__, __LINE__) Array<ConstraintData *>(initialCapacity);
+	return (spine_array_constraint_data) new (__FILE__, __LINE__) Array<ConstraintData *>(initialCapacity);
 }
 void spine_array_constraint_data_dispose(spine_array_constraint_data array) {
-    delete (Array<ConstraintData *>*)array;
+	delete (Array<ConstraintData *> *) array;
 }
 void spine_array_constraint_data_clear(spine_array_constraint_data array) {
-    ((Array<ConstraintData *>*)array)->clear();
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_constraint_data_get_capacity(spine_array_constraint_data array) {
-    return ((Array<ConstraintData *>*)array)->getCapacity();
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_constraint_data_size(spine_array_constraint_data array) {
-    return ((Array<ConstraintData *>*)array)->size();
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	return _array->size();
 }
 
-spine_array_constraint_data spine_array_constraint_data_set_size(spine_array_constraint_data array, size_t newSize, spine_constraint_data defaultValue) {
-    return (spine_array_constraint_data)&((Array<ConstraintData *>*)array)->setSize(newSize, (ConstraintData *)defaultValue);
+spine_array_constraint_data spine_array_constraint_data_set_size(spine_array_constraint_data array, size_t newSize,
+																 spine_constraint_data defaultValue) {
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	return (spine_array_constraint_data) &_array->setSize(newSize, (ConstraintData *) defaultValue);
 }
 
 void spine_array_constraint_data_ensure_capacity(spine_array_constraint_data array, size_t newCapacity) {
-    ((Array<ConstraintData *>*)array)->ensureCapacity(newCapacity);
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_constraint_data_add(spine_array_constraint_data array, spine_constraint_data inValue) {
-    ((Array<ConstraintData *>*)array)->add((ConstraintData *)inValue);
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	_array->add((ConstraintData *) inValue);
 }
 
 void spine_array_constraint_data_add_all(spine_array_constraint_data array, spine_array_constraint_data inValue) {
-    ((Array<ConstraintData *>*)array)->addAll(*((const Array<ConstraintData *>*)inValue));
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	_array->addAll(*((const Array<ConstraintData *> *) inValue));
 }
 
 void spine_array_constraint_data_clear_and_add_all(spine_array_constraint_data array, spine_array_constraint_data inValue) {
-    ((Array<ConstraintData *>*)array)->clearAndAddAll(*((const Array<ConstraintData *>*)inValue));
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	_array->clearAndAddAll(*((const Array<ConstraintData *> *) inValue));
 }
 
 void spine_array_constraint_data_remove_at(spine_array_constraint_data array, size_t inIndex) {
-    ((Array<ConstraintData *>*)array)->removeAt(inIndex);
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_constraint_data_contains(spine_array_constraint_data array, spine_constraint_data inValue) {
-    return ((Array<ConstraintData *>*)array)->contains((ConstraintData *)inValue);
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	return _array->contains((ConstraintData *) inValue);
 }
 
 int spine_array_constraint_data_index_of(spine_array_constraint_data array, spine_constraint_data inValue) {
-    return ((Array<ConstraintData *>*)array)->indexOf((ConstraintData *)inValue);
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	return _array->indexOf((ConstraintData *) inValue);
 }
 
-spine_constraint_data * spine_array_constraint_data_buffer(spine_array_constraint_data array) {
-    return (spine_constraint_data *)((Array<ConstraintData *>*)array)->buffer();
+spine_constraint_data *spine_array_constraint_data_buffer(spine_array_constraint_data array) {
+	Array<ConstraintData *> *_array = (Array<ConstraintData *> *) array;
+	return (spine_constraint_data *) _array->buffer();
 }
 
 spine_array_event spine_array_event_create(void) {
-    return (spine_array_event) new (__FILE__, __LINE__) Array<Event *>();
+	return (spine_array_event) new (__FILE__, __LINE__) Array<Event *>();
 }
 
 spine_array_event spine_array_event_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_event) new (__FILE__, __LINE__) Array<Event *>(initialCapacity);
+	return (spine_array_event) new (__FILE__, __LINE__) Array<Event *>(initialCapacity);
 }
 void spine_array_event_dispose(spine_array_event array) {
-    delete (Array<Event *>*)array;
+	delete (Array<Event *> *) array;
 }
 void spine_array_event_clear(spine_array_event array) {
-    ((Array<Event *>*)array)->clear();
+	Array<Event *> *_array = (Array<Event *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_event_get_capacity(spine_array_event array) {
-    return ((Array<Event *>*)array)->getCapacity();
+	Array<Event *> *_array = (Array<Event *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_event_size(spine_array_event array) {
-    return ((Array<Event *>*)array)->size();
+	Array<Event *> *_array = (Array<Event *> *) array;
+	return _array->size();
 }
 
 spine_array_event spine_array_event_set_size(spine_array_event array, size_t newSize, spine_event defaultValue) {
-    return (spine_array_event)&((Array<Event *>*)array)->setSize(newSize, (Event *)defaultValue);
+	Array<Event *> *_array = (Array<Event *> *) array;
+	return (spine_array_event) &_array->setSize(newSize, (Event *) defaultValue);
 }
 
 void spine_array_event_ensure_capacity(spine_array_event array, size_t newCapacity) {
-    ((Array<Event *>*)array)->ensureCapacity(newCapacity);
+	Array<Event *> *_array = (Array<Event *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_event_add(spine_array_event array, spine_event inValue) {
-    ((Array<Event *>*)array)->add((Event *)inValue);
+	Array<Event *> *_array = (Array<Event *> *) array;
+	_array->add((Event *) inValue);
 }
 
 void spine_array_event_add_all(spine_array_event array, spine_array_event inValue) {
-    ((Array<Event *>*)array)->addAll(*((const Array<Event *>*)inValue));
+	Array<Event *> *_array = (Array<Event *> *) array;
+	_array->addAll(*((const Array<Event *> *) inValue));
 }
 
 void spine_array_event_clear_and_add_all(spine_array_event array, spine_array_event inValue) {
-    ((Array<Event *>*)array)->clearAndAddAll(*((const Array<Event *>*)inValue));
+	Array<Event *> *_array = (Array<Event *> *) array;
+	_array->clearAndAddAll(*((const Array<Event *> *) inValue));
 }
 
 void spine_array_event_remove_at(spine_array_event array, size_t inIndex) {
-    ((Array<Event *>*)array)->removeAt(inIndex);
+	Array<Event *> *_array = (Array<Event *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_event_contains(spine_array_event array, spine_event inValue) {
-    return ((Array<Event *>*)array)->contains((Event *)inValue);
+	Array<Event *> *_array = (Array<Event *> *) array;
+	return _array->contains((Event *) inValue);
 }
 
 int spine_array_event_index_of(spine_array_event array, spine_event inValue) {
-    return ((Array<Event *>*)array)->indexOf((Event *)inValue);
+	Array<Event *> *_array = (Array<Event *> *) array;
+	return _array->indexOf((Event *) inValue);
 }
 
-spine_event * spine_array_event_buffer(spine_array_event array) {
-    return (spine_event *)((Array<Event *>*)array)->buffer();
+spine_event *spine_array_event_buffer(spine_array_event array) {
+	Array<Event *> *_array = (Array<Event *> *) array;
+	return (spine_event *) _array->buffer();
 }
 
 spine_array_event_data spine_array_event_data_create(void) {
-    return (spine_array_event_data) new (__FILE__, __LINE__) Array<EventData *>();
+	return (spine_array_event_data) new (__FILE__, __LINE__) Array<EventData *>();
 }
 
 spine_array_event_data spine_array_event_data_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_event_data) new (__FILE__, __LINE__) Array<EventData *>(initialCapacity);
+	return (spine_array_event_data) new (__FILE__, __LINE__) Array<EventData *>(initialCapacity);
 }
 void spine_array_event_data_dispose(spine_array_event_data array) {
-    delete (Array<EventData *>*)array;
+	delete (Array<EventData *> *) array;
 }
 void spine_array_event_data_clear(spine_array_event_data array) {
-    ((Array<EventData *>*)array)->clear();
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_event_data_get_capacity(spine_array_event_data array) {
-    return ((Array<EventData *>*)array)->getCapacity();
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_event_data_size(spine_array_event_data array) {
-    return ((Array<EventData *>*)array)->size();
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	return _array->size();
 }
 
 spine_array_event_data spine_array_event_data_set_size(spine_array_event_data array, size_t newSize, spine_event_data defaultValue) {
-    return (spine_array_event_data)&((Array<EventData *>*)array)->setSize(newSize, (EventData *)defaultValue);
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	return (spine_array_event_data) &_array->setSize(newSize, (EventData *) defaultValue);
 }
 
 void spine_array_event_data_ensure_capacity(spine_array_event_data array, size_t newCapacity) {
-    ((Array<EventData *>*)array)->ensureCapacity(newCapacity);
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_event_data_add(spine_array_event_data array, spine_event_data inValue) {
-    ((Array<EventData *>*)array)->add((EventData *)inValue);
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	_array->add((EventData *) inValue);
 }
 
 void spine_array_event_data_add_all(spine_array_event_data array, spine_array_event_data inValue) {
-    ((Array<EventData *>*)array)->addAll(*((const Array<EventData *>*)inValue));
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	_array->addAll(*((const Array<EventData *> *) inValue));
 }
 
 void spine_array_event_data_clear_and_add_all(spine_array_event_data array, spine_array_event_data inValue) {
-    ((Array<EventData *>*)array)->clearAndAddAll(*((const Array<EventData *>*)inValue));
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	_array->clearAndAddAll(*((const Array<EventData *> *) inValue));
 }
 
 void spine_array_event_data_remove_at(spine_array_event_data array, size_t inIndex) {
-    ((Array<EventData *>*)array)->removeAt(inIndex);
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_event_data_contains(spine_array_event_data array, spine_event_data inValue) {
-    return ((Array<EventData *>*)array)->contains((EventData *)inValue);
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	return _array->contains((EventData *) inValue);
 }
 
 int spine_array_event_data_index_of(spine_array_event_data array, spine_event_data inValue) {
-    return ((Array<EventData *>*)array)->indexOf((EventData *)inValue);
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	return _array->indexOf((EventData *) inValue);
 }
 
-spine_event_data * spine_array_event_data_buffer(spine_array_event_data array) {
-    return (spine_event_data *)((Array<EventData *>*)array)->buffer();
+spine_event_data *spine_array_event_data_buffer(spine_array_event_data array) {
+	Array<EventData *> *_array = (Array<EventData *> *) array;
+	return (spine_event_data *) _array->buffer();
 }
 
 spine_array_from_property spine_array_from_property_create(void) {
-    return (spine_array_from_property) new (__FILE__, __LINE__) Array<FromProperty *>();
+	return (spine_array_from_property) new (__FILE__, __LINE__) Array<FromProperty *>();
 }
 
 spine_array_from_property spine_array_from_property_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_from_property) new (__FILE__, __LINE__) Array<FromProperty *>(initialCapacity);
+	return (spine_array_from_property) new (__FILE__, __LINE__) Array<FromProperty *>(initialCapacity);
 }
 void spine_array_from_property_dispose(spine_array_from_property array) {
-    delete (Array<FromProperty *>*)array;
+	delete (Array<FromProperty *> *) array;
 }
 void spine_array_from_property_clear(spine_array_from_property array) {
-    ((Array<FromProperty *>*)array)->clear();
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_from_property_get_capacity(spine_array_from_property array) {
-    return ((Array<FromProperty *>*)array)->getCapacity();
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_from_property_size(spine_array_from_property array) {
-    return ((Array<FromProperty *>*)array)->size();
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	return _array->size();
 }
 
 spine_array_from_property spine_array_from_property_set_size(spine_array_from_property array, size_t newSize, spine_from_property defaultValue) {
-    return (spine_array_from_property)&((Array<FromProperty *>*)array)->setSize(newSize, (FromProperty *)defaultValue);
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	return (spine_array_from_property) &_array->setSize(newSize, (FromProperty *) defaultValue);
 }
 
 void spine_array_from_property_ensure_capacity(spine_array_from_property array, size_t newCapacity) {
-    ((Array<FromProperty *>*)array)->ensureCapacity(newCapacity);
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_from_property_add(spine_array_from_property array, spine_from_property inValue) {
-    ((Array<FromProperty *>*)array)->add((FromProperty *)inValue);
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	_array->add((FromProperty *) inValue);
 }
 
 void spine_array_from_property_add_all(spine_array_from_property array, spine_array_from_property inValue) {
-    ((Array<FromProperty *>*)array)->addAll(*((const Array<FromProperty *>*)inValue));
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	_array->addAll(*((const Array<FromProperty *> *) inValue));
 }
 
 void spine_array_from_property_clear_and_add_all(spine_array_from_property array, spine_array_from_property inValue) {
-    ((Array<FromProperty *>*)array)->clearAndAddAll(*((const Array<FromProperty *>*)inValue));
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	_array->clearAndAddAll(*((const Array<FromProperty *> *) inValue));
 }
 
 void spine_array_from_property_remove_at(spine_array_from_property array, size_t inIndex) {
-    ((Array<FromProperty *>*)array)->removeAt(inIndex);
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_from_property_contains(spine_array_from_property array, spine_from_property inValue) {
-    return ((Array<FromProperty *>*)array)->contains((FromProperty *)inValue);
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	return _array->contains((FromProperty *) inValue);
 }
 
 int spine_array_from_property_index_of(spine_array_from_property array, spine_from_property inValue) {
-    return ((Array<FromProperty *>*)array)->indexOf((FromProperty *)inValue);
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	return _array->indexOf((FromProperty *) inValue);
 }
 
-spine_from_property * spine_array_from_property_buffer(spine_array_from_property array) {
-    return (spine_from_property *)((Array<FromProperty *>*)array)->buffer();
+spine_from_property *spine_array_from_property_buffer(spine_array_from_property array) {
+	Array<FromProperty *> *_array = (Array<FromProperty *> *) array;
+	return (spine_from_property *) _array->buffer();
 }
 
 spine_array_physics_constraint spine_array_physics_constraint_create(void) {
-    return (spine_array_physics_constraint) new (__FILE__, __LINE__) Array<PhysicsConstraint *>();
+	return (spine_array_physics_constraint) new (__FILE__, __LINE__) Array<PhysicsConstraint *>();
 }
 
 spine_array_physics_constraint spine_array_physics_constraint_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_physics_constraint) new (__FILE__, __LINE__) Array<PhysicsConstraint *>(initialCapacity);
+	return (spine_array_physics_constraint) new (__FILE__, __LINE__) Array<PhysicsConstraint *>(initialCapacity);
 }
 void spine_array_physics_constraint_dispose(spine_array_physics_constraint array) {
-    delete (Array<PhysicsConstraint *>*)array;
+	delete (Array<PhysicsConstraint *> *) array;
 }
 void spine_array_physics_constraint_clear(spine_array_physics_constraint array) {
-    ((Array<PhysicsConstraint *>*)array)->clear();
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_physics_constraint_get_capacity(spine_array_physics_constraint array) {
-    return ((Array<PhysicsConstraint *>*)array)->getCapacity();
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_physics_constraint_size(spine_array_physics_constraint array) {
-    return ((Array<PhysicsConstraint *>*)array)->size();
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	return _array->size();
 }
 
-spine_array_physics_constraint spine_array_physics_constraint_set_size(spine_array_physics_constraint array, size_t newSize, spine_physics_constraint defaultValue) {
-    return (spine_array_physics_constraint)&((Array<PhysicsConstraint *>*)array)->setSize(newSize, (PhysicsConstraint *)defaultValue);
+spine_array_physics_constraint spine_array_physics_constraint_set_size(spine_array_physics_constraint array, size_t newSize,
+																	   spine_physics_constraint defaultValue) {
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	return (spine_array_physics_constraint) &_array->setSize(newSize, (PhysicsConstraint *) defaultValue);
 }
 
 void spine_array_physics_constraint_ensure_capacity(spine_array_physics_constraint array, size_t newCapacity) {
-    ((Array<PhysicsConstraint *>*)array)->ensureCapacity(newCapacity);
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_physics_constraint_add(spine_array_physics_constraint array, spine_physics_constraint inValue) {
-    ((Array<PhysicsConstraint *>*)array)->add((PhysicsConstraint *)inValue);
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	_array->add((PhysicsConstraint *) inValue);
 }
 
 void spine_array_physics_constraint_add_all(spine_array_physics_constraint array, spine_array_physics_constraint inValue) {
-    ((Array<PhysicsConstraint *>*)array)->addAll(*((const Array<PhysicsConstraint *>*)inValue));
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	_array->addAll(*((const Array<PhysicsConstraint *> *) inValue));
 }
 
 void spine_array_physics_constraint_clear_and_add_all(spine_array_physics_constraint array, spine_array_physics_constraint inValue) {
-    ((Array<PhysicsConstraint *>*)array)->clearAndAddAll(*((const Array<PhysicsConstraint *>*)inValue));
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	_array->clearAndAddAll(*((const Array<PhysicsConstraint *> *) inValue));
 }
 
 void spine_array_physics_constraint_remove_at(spine_array_physics_constraint array, size_t inIndex) {
-    ((Array<PhysicsConstraint *>*)array)->removeAt(inIndex);
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_physics_constraint_contains(spine_array_physics_constraint array, spine_physics_constraint inValue) {
-    return ((Array<PhysicsConstraint *>*)array)->contains((PhysicsConstraint *)inValue);
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	return _array->contains((PhysicsConstraint *) inValue);
 }
 
 int spine_array_physics_constraint_index_of(spine_array_physics_constraint array, spine_physics_constraint inValue) {
-    return ((Array<PhysicsConstraint *>*)array)->indexOf((PhysicsConstraint *)inValue);
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	return _array->indexOf((PhysicsConstraint *) inValue);
 }
 
-spine_physics_constraint * spine_array_physics_constraint_buffer(spine_array_physics_constraint array) {
-    return (spine_physics_constraint *)((Array<PhysicsConstraint *>*)array)->buffer();
+spine_physics_constraint *spine_array_physics_constraint_buffer(spine_array_physics_constraint array) {
+	Array<PhysicsConstraint *> *_array = (Array<PhysicsConstraint *> *) array;
+	return (spine_physics_constraint *) _array->buffer();
 }
 
 spine_array_polygon spine_array_polygon_create(void) {
-    return (spine_array_polygon) new (__FILE__, __LINE__) Array<Polygon *>();
+	return (spine_array_polygon) new (__FILE__, __LINE__) Array<Polygon *>();
 }
 
 spine_array_polygon spine_array_polygon_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_polygon) new (__FILE__, __LINE__) Array<Polygon *>(initialCapacity);
+	return (spine_array_polygon) new (__FILE__, __LINE__) Array<Polygon *>(initialCapacity);
 }
 void spine_array_polygon_dispose(spine_array_polygon array) {
-    delete (Array<Polygon *>*)array;
+	delete (Array<Polygon *> *) array;
 }
 void spine_array_polygon_clear(spine_array_polygon array) {
-    ((Array<Polygon *>*)array)->clear();
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_polygon_get_capacity(spine_array_polygon array) {
-    return ((Array<Polygon *>*)array)->getCapacity();
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_polygon_size(spine_array_polygon array) {
-    return ((Array<Polygon *>*)array)->size();
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	return _array->size();
 }
 
 spine_array_polygon spine_array_polygon_set_size(spine_array_polygon array, size_t newSize, spine_polygon defaultValue) {
-    return (spine_array_polygon)&((Array<Polygon *>*)array)->setSize(newSize, (Polygon *)defaultValue);
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	return (spine_array_polygon) &_array->setSize(newSize, (Polygon *) defaultValue);
 }
 
 void spine_array_polygon_ensure_capacity(spine_array_polygon array, size_t newCapacity) {
-    ((Array<Polygon *>*)array)->ensureCapacity(newCapacity);
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_polygon_add(spine_array_polygon array, spine_polygon inValue) {
-    ((Array<Polygon *>*)array)->add((Polygon *)inValue);
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	_array->add((Polygon *) inValue);
 }
 
 void spine_array_polygon_add_all(spine_array_polygon array, spine_array_polygon inValue) {
-    ((Array<Polygon *>*)array)->addAll(*((const Array<Polygon *>*)inValue));
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	_array->addAll(*((const Array<Polygon *> *) inValue));
 }
 
 void spine_array_polygon_clear_and_add_all(spine_array_polygon array, spine_array_polygon inValue) {
-    ((Array<Polygon *>*)array)->clearAndAddAll(*((const Array<Polygon *>*)inValue));
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	_array->clearAndAddAll(*((const Array<Polygon *> *) inValue));
 }
 
 void spine_array_polygon_remove_at(spine_array_polygon array, size_t inIndex) {
-    ((Array<Polygon *>*)array)->removeAt(inIndex);
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_polygon_contains(spine_array_polygon array, spine_polygon inValue) {
-    return ((Array<Polygon *>*)array)->contains((Polygon *)inValue);
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	return _array->contains((Polygon *) inValue);
 }
 
 int spine_array_polygon_index_of(spine_array_polygon array, spine_polygon inValue) {
-    return ((Array<Polygon *>*)array)->indexOf((Polygon *)inValue);
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	return _array->indexOf((Polygon *) inValue);
 }
 
-spine_polygon * spine_array_polygon_buffer(spine_array_polygon array) {
-    return (spine_polygon *)((Array<Polygon *>*)array)->buffer();
+spine_polygon *spine_array_polygon_buffer(spine_array_polygon array) {
+	Array<Polygon *> *_array = (Array<Polygon *> *) array;
+	return (spine_polygon *) _array->buffer();
 }
 
 spine_array_skin spine_array_skin_create(void) {
-    return (spine_array_skin) new (__FILE__, __LINE__) Array<Skin *>();
+	return (spine_array_skin) new (__FILE__, __LINE__) Array<Skin *>();
 }
 
 spine_array_skin spine_array_skin_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_skin) new (__FILE__, __LINE__) Array<Skin *>(initialCapacity);
+	return (spine_array_skin) new (__FILE__, __LINE__) Array<Skin *>(initialCapacity);
 }
 void spine_array_skin_dispose(spine_array_skin array) {
-    delete (Array<Skin *>*)array;
+	delete (Array<Skin *> *) array;
 }
 void spine_array_skin_clear(spine_array_skin array) {
-    ((Array<Skin *>*)array)->clear();
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_skin_get_capacity(spine_array_skin array) {
-    return ((Array<Skin *>*)array)->getCapacity();
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_skin_size(spine_array_skin array) {
-    return ((Array<Skin *>*)array)->size();
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	return _array->size();
 }
 
 spine_array_skin spine_array_skin_set_size(spine_array_skin array, size_t newSize, spine_skin defaultValue) {
-    return (spine_array_skin)&((Array<Skin *>*)array)->setSize(newSize, (Skin *)defaultValue);
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	return (spine_array_skin) &_array->setSize(newSize, (Skin *) defaultValue);
 }
 
 void spine_array_skin_ensure_capacity(spine_array_skin array, size_t newCapacity) {
-    ((Array<Skin *>*)array)->ensureCapacity(newCapacity);
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_skin_add(spine_array_skin array, spine_skin inValue) {
-    ((Array<Skin *>*)array)->add((Skin *)inValue);
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	_array->add((Skin *) inValue);
 }
 
 void spine_array_skin_add_all(spine_array_skin array, spine_array_skin inValue) {
-    ((Array<Skin *>*)array)->addAll(*((const Array<Skin *>*)inValue));
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	_array->addAll(*((const Array<Skin *> *) inValue));
 }
 
 void spine_array_skin_clear_and_add_all(spine_array_skin array, spine_array_skin inValue) {
-    ((Array<Skin *>*)array)->clearAndAddAll(*((const Array<Skin *>*)inValue));
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	_array->clearAndAddAll(*((const Array<Skin *> *) inValue));
 }
 
 void spine_array_skin_remove_at(spine_array_skin array, size_t inIndex) {
-    ((Array<Skin *>*)array)->removeAt(inIndex);
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_skin_contains(spine_array_skin array, spine_skin inValue) {
-    return ((Array<Skin *>*)array)->contains((Skin *)inValue);
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	return _array->contains((Skin *) inValue);
 }
 
 int spine_array_skin_index_of(spine_array_skin array, spine_skin inValue) {
-    return ((Array<Skin *>*)array)->indexOf((Skin *)inValue);
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	return _array->indexOf((Skin *) inValue);
 }
 
-spine_skin * spine_array_skin_buffer(spine_array_skin array) {
-    return (spine_skin *)((Array<Skin *>*)array)->buffer();
+spine_skin *spine_array_skin_buffer(spine_array_skin array) {
+	Array<Skin *> *_array = (Array<Skin *> *) array;
+	return (spine_skin *) _array->buffer();
 }
 
 spine_array_slot spine_array_slot_create(void) {
-    return (spine_array_slot) new (__FILE__, __LINE__) Array<Slot *>();
+	return (spine_array_slot) new (__FILE__, __LINE__) Array<Slot *>();
 }
 
 spine_array_slot spine_array_slot_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_slot) new (__FILE__, __LINE__) Array<Slot *>(initialCapacity);
+	return (spine_array_slot) new (__FILE__, __LINE__) Array<Slot *>(initialCapacity);
 }
 void spine_array_slot_dispose(spine_array_slot array) {
-    delete (Array<Slot *>*)array;
+	delete (Array<Slot *> *) array;
 }
 void spine_array_slot_clear(spine_array_slot array) {
-    ((Array<Slot *>*)array)->clear();
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_slot_get_capacity(spine_array_slot array) {
-    return ((Array<Slot *>*)array)->getCapacity();
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_slot_size(spine_array_slot array) {
-    return ((Array<Slot *>*)array)->size();
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	return _array->size();
 }
 
 spine_array_slot spine_array_slot_set_size(spine_array_slot array, size_t newSize, spine_slot defaultValue) {
-    return (spine_array_slot)&((Array<Slot *>*)array)->setSize(newSize, (Slot *)defaultValue);
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	return (spine_array_slot) &_array->setSize(newSize, (Slot *) defaultValue);
 }
 
 void spine_array_slot_ensure_capacity(spine_array_slot array, size_t newCapacity) {
-    ((Array<Slot *>*)array)->ensureCapacity(newCapacity);
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_slot_add(spine_array_slot array, spine_slot inValue) {
-    ((Array<Slot *>*)array)->add((Slot *)inValue);
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	_array->add((Slot *) inValue);
 }
 
 void spine_array_slot_add_all(spine_array_slot array, spine_array_slot inValue) {
-    ((Array<Slot *>*)array)->addAll(*((const Array<Slot *>*)inValue));
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	_array->addAll(*((const Array<Slot *> *) inValue));
 }
 
 void spine_array_slot_clear_and_add_all(spine_array_slot array, spine_array_slot inValue) {
-    ((Array<Slot *>*)array)->clearAndAddAll(*((const Array<Slot *>*)inValue));
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	_array->clearAndAddAll(*((const Array<Slot *> *) inValue));
 }
 
 void spine_array_slot_remove_at(spine_array_slot array, size_t inIndex) {
-    ((Array<Slot *>*)array)->removeAt(inIndex);
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_slot_contains(spine_array_slot array, spine_slot inValue) {
-    return ((Array<Slot *>*)array)->contains((Slot *)inValue);
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	return _array->contains((Slot *) inValue);
 }
 
 int spine_array_slot_index_of(spine_array_slot array, spine_slot inValue) {
-    return ((Array<Slot *>*)array)->indexOf((Slot *)inValue);
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	return _array->indexOf((Slot *) inValue);
 }
 
-spine_slot * spine_array_slot_buffer(spine_array_slot array) {
-    return (spine_slot *)((Array<Slot *>*)array)->buffer();
+spine_slot *spine_array_slot_buffer(spine_array_slot array) {
+	Array<Slot *> *_array = (Array<Slot *> *) array;
+	return (spine_slot *) _array->buffer();
 }
 
 spine_array_slot_data spine_array_slot_data_create(void) {
-    return (spine_array_slot_data) new (__FILE__, __LINE__) Array<SlotData *>();
+	return (spine_array_slot_data) new (__FILE__, __LINE__) Array<SlotData *>();
 }
 
 spine_array_slot_data spine_array_slot_data_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_slot_data) new (__FILE__, __LINE__) Array<SlotData *>(initialCapacity);
+	return (spine_array_slot_data) new (__FILE__, __LINE__) Array<SlotData *>(initialCapacity);
 }
 void spine_array_slot_data_dispose(spine_array_slot_data array) {
-    delete (Array<SlotData *>*)array;
+	delete (Array<SlotData *> *) array;
 }
 void spine_array_slot_data_clear(spine_array_slot_data array) {
-    ((Array<SlotData *>*)array)->clear();
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_slot_data_get_capacity(spine_array_slot_data array) {
-    return ((Array<SlotData *>*)array)->getCapacity();
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_slot_data_size(spine_array_slot_data array) {
-    return ((Array<SlotData *>*)array)->size();
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	return _array->size();
 }
 
 spine_array_slot_data spine_array_slot_data_set_size(spine_array_slot_data array, size_t newSize, spine_slot_data defaultValue) {
-    return (spine_array_slot_data)&((Array<SlotData *>*)array)->setSize(newSize, (SlotData *)defaultValue);
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	return (spine_array_slot_data) &_array->setSize(newSize, (SlotData *) defaultValue);
 }
 
 void spine_array_slot_data_ensure_capacity(spine_array_slot_data array, size_t newCapacity) {
-    ((Array<SlotData *>*)array)->ensureCapacity(newCapacity);
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_slot_data_add(spine_array_slot_data array, spine_slot_data inValue) {
-    ((Array<SlotData *>*)array)->add((SlotData *)inValue);
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	_array->add((SlotData *) inValue);
 }
 
 void spine_array_slot_data_add_all(spine_array_slot_data array, spine_array_slot_data inValue) {
-    ((Array<SlotData *>*)array)->addAll(*((const Array<SlotData *>*)inValue));
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	_array->addAll(*((const Array<SlotData *> *) inValue));
 }
 
 void spine_array_slot_data_clear_and_add_all(spine_array_slot_data array, spine_array_slot_data inValue) {
-    ((Array<SlotData *>*)array)->clearAndAddAll(*((const Array<SlotData *>*)inValue));
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	_array->clearAndAddAll(*((const Array<SlotData *> *) inValue));
 }
 
 void spine_array_slot_data_remove_at(spine_array_slot_data array, size_t inIndex) {
-    ((Array<SlotData *>*)array)->removeAt(inIndex);
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_slot_data_contains(spine_array_slot_data array, spine_slot_data inValue) {
-    return ((Array<SlotData *>*)array)->contains((SlotData *)inValue);
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	return _array->contains((SlotData *) inValue);
 }
 
 int spine_array_slot_data_index_of(spine_array_slot_data array, spine_slot_data inValue) {
-    return ((Array<SlotData *>*)array)->indexOf((SlotData *)inValue);
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	return _array->indexOf((SlotData *) inValue);
 }
 
-spine_slot_data * spine_array_slot_data_buffer(spine_array_slot_data array) {
-    return (spine_slot_data *)((Array<SlotData *>*)array)->buffer();
+spine_slot_data *spine_array_slot_data_buffer(spine_array_slot_data array) {
+	Array<SlotData *> *_array = (Array<SlotData *> *) array;
+	return (spine_slot_data *) _array->buffer();
 }
 
 spine_array_texture_region spine_array_texture_region_create(void) {
-    return (spine_array_texture_region) new (__FILE__, __LINE__) Array<TextureRegion *>();
+	return (spine_array_texture_region) new (__FILE__, __LINE__) Array<TextureRegion *>();
 }
 
 spine_array_texture_region spine_array_texture_region_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_texture_region) new (__FILE__, __LINE__) Array<TextureRegion *>(initialCapacity);
+	return (spine_array_texture_region) new (__FILE__, __LINE__) Array<TextureRegion *>(initialCapacity);
 }
 void spine_array_texture_region_dispose(spine_array_texture_region array) {
-    delete (Array<TextureRegion *>*)array;
+	delete (Array<TextureRegion *> *) array;
 }
 void spine_array_texture_region_clear(spine_array_texture_region array) {
-    ((Array<TextureRegion *>*)array)->clear();
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_texture_region_get_capacity(spine_array_texture_region array) {
-    return ((Array<TextureRegion *>*)array)->getCapacity();
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_texture_region_size(spine_array_texture_region array) {
-    return ((Array<TextureRegion *>*)array)->size();
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	return _array->size();
 }
 
 spine_array_texture_region spine_array_texture_region_set_size(spine_array_texture_region array, size_t newSize, spine_texture_region defaultValue) {
-    return (spine_array_texture_region)&((Array<TextureRegion *>*)array)->setSize(newSize, (TextureRegion *)defaultValue);
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	return (spine_array_texture_region) &_array->setSize(newSize, (TextureRegion *) defaultValue);
 }
 
 void spine_array_texture_region_ensure_capacity(spine_array_texture_region array, size_t newCapacity) {
-    ((Array<TextureRegion *>*)array)->ensureCapacity(newCapacity);
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_texture_region_add(spine_array_texture_region array, spine_texture_region inValue) {
-    ((Array<TextureRegion *>*)array)->add((TextureRegion *)inValue);
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	_array->add((TextureRegion *) inValue);
 }
 
 void spine_array_texture_region_add_all(spine_array_texture_region array, spine_array_texture_region inValue) {
-    ((Array<TextureRegion *>*)array)->addAll(*((const Array<TextureRegion *>*)inValue));
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	_array->addAll(*((const Array<TextureRegion *> *) inValue));
 }
 
 void spine_array_texture_region_clear_and_add_all(spine_array_texture_region array, spine_array_texture_region inValue) {
-    ((Array<TextureRegion *>*)array)->clearAndAddAll(*((const Array<TextureRegion *>*)inValue));
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	_array->clearAndAddAll(*((const Array<TextureRegion *> *) inValue));
 }
 
 void spine_array_texture_region_remove_at(spine_array_texture_region array, size_t inIndex) {
-    ((Array<TextureRegion *>*)array)->removeAt(inIndex);
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_texture_region_contains(spine_array_texture_region array, spine_texture_region inValue) {
-    return ((Array<TextureRegion *>*)array)->contains((TextureRegion *)inValue);
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	return _array->contains((TextureRegion *) inValue);
 }
 
 int spine_array_texture_region_index_of(spine_array_texture_region array, spine_texture_region inValue) {
-    return ((Array<TextureRegion *>*)array)->indexOf((TextureRegion *)inValue);
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	return _array->indexOf((TextureRegion *) inValue);
 }
 
-spine_texture_region * spine_array_texture_region_buffer(spine_array_texture_region array) {
-    return (spine_texture_region *)((Array<TextureRegion *>*)array)->buffer();
+spine_texture_region *spine_array_texture_region_buffer(spine_array_texture_region array) {
+	Array<TextureRegion *> *_array = (Array<TextureRegion *> *) array;
+	return (spine_texture_region *) _array->buffer();
 }
 
 spine_array_timeline spine_array_timeline_create(void) {
-    return (spine_array_timeline) new (__FILE__, __LINE__) Array<Timeline *>();
+	return (spine_array_timeline) new (__FILE__, __LINE__) Array<Timeline *>();
 }
 
 spine_array_timeline spine_array_timeline_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_timeline) new (__FILE__, __LINE__) Array<Timeline *>(initialCapacity);
+	return (spine_array_timeline) new (__FILE__, __LINE__) Array<Timeline *>(initialCapacity);
 }
 void spine_array_timeline_dispose(spine_array_timeline array) {
-    delete (Array<Timeline *>*)array;
+	delete (Array<Timeline *> *) array;
 }
 void spine_array_timeline_clear(spine_array_timeline array) {
-    ((Array<Timeline *>*)array)->clear();
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_timeline_get_capacity(spine_array_timeline array) {
-    return ((Array<Timeline *>*)array)->getCapacity();
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_timeline_size(spine_array_timeline array) {
-    return ((Array<Timeline *>*)array)->size();
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	return _array->size();
 }
 
 spine_array_timeline spine_array_timeline_set_size(spine_array_timeline array, size_t newSize, spine_timeline defaultValue) {
-    return (spine_array_timeline)&((Array<Timeline *>*)array)->setSize(newSize, (Timeline *)defaultValue);
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	return (spine_array_timeline) &_array->setSize(newSize, (Timeline *) defaultValue);
 }
 
 void spine_array_timeline_ensure_capacity(spine_array_timeline array, size_t newCapacity) {
-    ((Array<Timeline *>*)array)->ensureCapacity(newCapacity);
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_timeline_add(spine_array_timeline array, spine_timeline inValue) {
-    ((Array<Timeline *>*)array)->add((Timeline *)inValue);
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	_array->add((Timeline *) inValue);
 }
 
 void spine_array_timeline_add_all(spine_array_timeline array, spine_array_timeline inValue) {
-    ((Array<Timeline *>*)array)->addAll(*((const Array<Timeline *>*)inValue));
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	_array->addAll(*((const Array<Timeline *> *) inValue));
 }
 
 void spine_array_timeline_clear_and_add_all(spine_array_timeline array, spine_array_timeline inValue) {
-    ((Array<Timeline *>*)array)->clearAndAddAll(*((const Array<Timeline *>*)inValue));
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	_array->clearAndAddAll(*((const Array<Timeline *> *) inValue));
 }
 
 void spine_array_timeline_remove_at(spine_array_timeline array, size_t inIndex) {
-    ((Array<Timeline *>*)array)->removeAt(inIndex);
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_timeline_contains(spine_array_timeline array, spine_timeline inValue) {
-    return ((Array<Timeline *>*)array)->contains((Timeline *)inValue);
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	return _array->contains((Timeline *) inValue);
 }
 
 int spine_array_timeline_index_of(spine_array_timeline array, spine_timeline inValue) {
-    return ((Array<Timeline *>*)array)->indexOf((Timeline *)inValue);
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	return _array->indexOf((Timeline *) inValue);
 }
 
-spine_timeline * spine_array_timeline_buffer(spine_array_timeline array) {
-    return (spine_timeline *)((Array<Timeline *>*)array)->buffer();
+spine_timeline *spine_array_timeline_buffer(spine_array_timeline array) {
+	Array<Timeline *> *_array = (Array<Timeline *> *) array;
+	return (spine_timeline *) _array->buffer();
 }
 
 spine_array_to_property spine_array_to_property_create(void) {
-    return (spine_array_to_property) new (__FILE__, __LINE__) Array<ToProperty *>();
+	return (spine_array_to_property) new (__FILE__, __LINE__) Array<ToProperty *>();
 }
 
 spine_array_to_property spine_array_to_property_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_to_property) new (__FILE__, __LINE__) Array<ToProperty *>(initialCapacity);
+	return (spine_array_to_property) new (__FILE__, __LINE__) Array<ToProperty *>(initialCapacity);
 }
 void spine_array_to_property_dispose(spine_array_to_property array) {
-    delete (Array<ToProperty *>*)array;
+	delete (Array<ToProperty *> *) array;
 }
 void spine_array_to_property_clear(spine_array_to_property array) {
-    ((Array<ToProperty *>*)array)->clear();
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_to_property_get_capacity(spine_array_to_property array) {
-    return ((Array<ToProperty *>*)array)->getCapacity();
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_to_property_size(spine_array_to_property array) {
-    return ((Array<ToProperty *>*)array)->size();
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	return _array->size();
 }
 
 spine_array_to_property spine_array_to_property_set_size(spine_array_to_property array, size_t newSize, spine_to_property defaultValue) {
-    return (spine_array_to_property)&((Array<ToProperty *>*)array)->setSize(newSize, (ToProperty *)defaultValue);
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	return (spine_array_to_property) &_array->setSize(newSize, (ToProperty *) defaultValue);
 }
 
 void spine_array_to_property_ensure_capacity(spine_array_to_property array, size_t newCapacity) {
-    ((Array<ToProperty *>*)array)->ensureCapacity(newCapacity);
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_to_property_add(spine_array_to_property array, spine_to_property inValue) {
-    ((Array<ToProperty *>*)array)->add((ToProperty *)inValue);
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	_array->add((ToProperty *) inValue);
 }
 
 void spine_array_to_property_add_all(spine_array_to_property array, spine_array_to_property inValue) {
-    ((Array<ToProperty *>*)array)->addAll(*((const Array<ToProperty *>*)inValue));
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	_array->addAll(*((const Array<ToProperty *> *) inValue));
 }
 
 void spine_array_to_property_clear_and_add_all(spine_array_to_property array, spine_array_to_property inValue) {
-    ((Array<ToProperty *>*)array)->clearAndAddAll(*((const Array<ToProperty *>*)inValue));
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	_array->clearAndAddAll(*((const Array<ToProperty *> *) inValue));
 }
 
 void spine_array_to_property_remove_at(spine_array_to_property array, size_t inIndex) {
-    ((Array<ToProperty *>*)array)->removeAt(inIndex);
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_to_property_contains(spine_array_to_property array, spine_to_property inValue) {
-    return ((Array<ToProperty *>*)array)->contains((ToProperty *)inValue);
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	return _array->contains((ToProperty *) inValue);
 }
 
 int spine_array_to_property_index_of(spine_array_to_property array, spine_to_property inValue) {
-    return ((Array<ToProperty *>*)array)->indexOf((ToProperty *)inValue);
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	return _array->indexOf((ToProperty *) inValue);
 }
 
-spine_to_property * spine_array_to_property_buffer(spine_array_to_property array) {
-    return (spine_to_property *)((Array<ToProperty *>*)array)->buffer();
+spine_to_property *spine_array_to_property_buffer(spine_array_to_property array) {
+	Array<ToProperty *> *_array = (Array<ToProperty *> *) array;
+	return (spine_to_property *) _array->buffer();
 }
 
 spine_array_track_entry spine_array_track_entry_create(void) {
-    return (spine_array_track_entry) new (__FILE__, __LINE__) Array<TrackEntry *>();
+	return (spine_array_track_entry) new (__FILE__, __LINE__) Array<TrackEntry *>();
 }
 
 spine_array_track_entry spine_array_track_entry_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_track_entry) new (__FILE__, __LINE__) Array<TrackEntry *>(initialCapacity);
+	return (spine_array_track_entry) new (__FILE__, __LINE__) Array<TrackEntry *>(initialCapacity);
 }
 void spine_array_track_entry_dispose(spine_array_track_entry array) {
-    delete (Array<TrackEntry *>*)array;
+	delete (Array<TrackEntry *> *) array;
 }
 void spine_array_track_entry_clear(spine_array_track_entry array) {
-    ((Array<TrackEntry *>*)array)->clear();
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_track_entry_get_capacity(spine_array_track_entry array) {
-    return ((Array<TrackEntry *>*)array)->getCapacity();
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_track_entry_size(spine_array_track_entry array) {
-    return ((Array<TrackEntry *>*)array)->size();
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	return _array->size();
 }
 
 spine_array_track_entry spine_array_track_entry_set_size(spine_array_track_entry array, size_t newSize, spine_track_entry defaultValue) {
-    return (spine_array_track_entry)&((Array<TrackEntry *>*)array)->setSize(newSize, (TrackEntry *)defaultValue);
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	return (spine_array_track_entry) &_array->setSize(newSize, (TrackEntry *) defaultValue);
 }
 
 void spine_array_track_entry_ensure_capacity(spine_array_track_entry array, size_t newCapacity) {
-    ((Array<TrackEntry *>*)array)->ensureCapacity(newCapacity);
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_track_entry_add(spine_array_track_entry array, spine_track_entry inValue) {
-    ((Array<TrackEntry *>*)array)->add((TrackEntry *)inValue);
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	_array->add((TrackEntry *) inValue);
 }
 
 void spine_array_track_entry_add_all(spine_array_track_entry array, spine_array_track_entry inValue) {
-    ((Array<TrackEntry *>*)array)->addAll(*((const Array<TrackEntry *>*)inValue));
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	_array->addAll(*((const Array<TrackEntry *> *) inValue));
 }
 
 void spine_array_track_entry_clear_and_add_all(spine_array_track_entry array, spine_array_track_entry inValue) {
-    ((Array<TrackEntry *>*)array)->clearAndAddAll(*((const Array<TrackEntry *>*)inValue));
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	_array->clearAndAddAll(*((const Array<TrackEntry *> *) inValue));
 }
 
 void spine_array_track_entry_remove_at(spine_array_track_entry array, size_t inIndex) {
-    ((Array<TrackEntry *>*)array)->removeAt(inIndex);
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_track_entry_contains(spine_array_track_entry array, spine_track_entry inValue) {
-    return ((Array<TrackEntry *>*)array)->contains((TrackEntry *)inValue);
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	return _array->contains((TrackEntry *) inValue);
 }
 
 int spine_array_track_entry_index_of(spine_array_track_entry array, spine_track_entry inValue) {
-    return ((Array<TrackEntry *>*)array)->indexOf((TrackEntry *)inValue);
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	return _array->indexOf((TrackEntry *) inValue);
 }
 
-spine_track_entry * spine_array_track_entry_buffer(spine_array_track_entry array) {
-    return (spine_track_entry *)((Array<TrackEntry *>*)array)->buffer();
+spine_track_entry *spine_array_track_entry_buffer(spine_array_track_entry array) {
+	Array<TrackEntry *> *_array = (Array<TrackEntry *> *) array;
+	return (spine_track_entry *) _array->buffer();
 }
 
 spine_array_update spine_array_update_create(void) {
-    return (spine_array_update) new (__FILE__, __LINE__) Array<Update *>();
+	return (spine_array_update) new (__FILE__, __LINE__) Array<Update *>();
 }
 
 spine_array_update spine_array_update_create_with_capacity(size_t initialCapacity) {
-    return (spine_array_update) new (__FILE__, __LINE__) Array<Update *>(initialCapacity);
+	return (spine_array_update) new (__FILE__, __LINE__) Array<Update *>(initialCapacity);
 }
 void spine_array_update_dispose(spine_array_update array) {
-    delete (Array<Update *>*)array;
+	delete (Array<Update *> *) array;
 }
 void spine_array_update_clear(spine_array_update array) {
-    ((Array<Update *>*)array)->clear();
+	Array<Update *> *_array = (Array<Update *> *) array;
+	_array->clear();
 }
 
 size_t spine_array_update_get_capacity(spine_array_update array) {
-    return ((Array<Update *>*)array)->getCapacity();
+	Array<Update *> *_array = (Array<Update *> *) array;
+	return _array->getCapacity();
 }
 
 size_t spine_array_update_size(spine_array_update array) {
-    return ((Array<Update *>*)array)->size();
+	Array<Update *> *_array = (Array<Update *> *) array;
+	return _array->size();
 }
 
 spine_array_update spine_array_update_set_size(spine_array_update array, size_t newSize, spine_update defaultValue) {
-    return (spine_array_update)&((Array<Update *>*)array)->setSize(newSize, (Update *)defaultValue);
+	Array<Update *> *_array = (Array<Update *> *) array;
+	return (spine_array_update) &_array->setSize(newSize, (Update *) defaultValue);
 }
 
 void spine_array_update_ensure_capacity(spine_array_update array, size_t newCapacity) {
-    ((Array<Update *>*)array)->ensureCapacity(newCapacity);
+	Array<Update *> *_array = (Array<Update *> *) array;
+	_array->ensureCapacity(newCapacity);
 }
 
 void spine_array_update_add(spine_array_update array, spine_update inValue) {
-    ((Array<Update *>*)array)->add((Update *)inValue);
+	Array<Update *> *_array = (Array<Update *> *) array;
+	_array->add((Update *) inValue);
 }
 
 void spine_array_update_add_all(spine_array_update array, spine_array_update inValue) {
-    ((Array<Update *>*)array)->addAll(*((const Array<Update *>*)inValue));
+	Array<Update *> *_array = (Array<Update *> *) array;
+	_array->addAll(*((const Array<Update *> *) inValue));
 }
 
 void spine_array_update_clear_and_add_all(spine_array_update array, spine_array_update inValue) {
-    ((Array<Update *>*)array)->clearAndAddAll(*((const Array<Update *>*)inValue));
+	Array<Update *> *_array = (Array<Update *> *) array;
+	_array->clearAndAddAll(*((const Array<Update *> *) inValue));
 }
 
 void spine_array_update_remove_at(spine_array_update array, size_t inIndex) {
-    ((Array<Update *>*)array)->removeAt(inIndex);
+	Array<Update *> *_array = (Array<Update *> *) array;
+	_array->removeAt(inIndex);
 }
 
 bool spine_array_update_contains(spine_array_update array, spine_update inValue) {
-    return ((Array<Update *>*)array)->contains((Update *)inValue);
+	Array<Update *> *_array = (Array<Update *> *) array;
+	return _array->contains((Update *) inValue);
 }
 
 int spine_array_update_index_of(spine_array_update array, spine_update inValue) {
-    return ((Array<Update *>*)array)->indexOf((Update *)inValue);
+	Array<Update *> *_array = (Array<Update *> *) array;
+	return _array->indexOf((Update *) inValue);
 }
 
-spine_update * spine_array_update_buffer(spine_array_update array) {
-    return (spine_update *)((Array<Update *>*)array)->buffer();
+spine_update *spine_array_update_buffer(spine_array_update array) {
+	Array<Update *> *_array = (Array<Update *> *) array;
+	return (spine_update *) _array->buffer();
 }

spine-c/src/generated/arrays.h

@@ -91,7 +91,7 @@ SPINE_C_API bool spine_array_float_contains(spine_array_float array, float inVal
 
 SPINE_C_API int spine_array_float_index_of(spine_array_float array, float inValue);
 
-SPINE_C_API float * spine_array_float_buffer(spine_array_float array);
+SPINE_C_API float *spine_array_float_buffer(spine_array_float array);
 
 SPINE_C_API spine_array_int spine_array_int_create(void);
 
@@ -119,7 +119,7 @@ SPINE_C_API bool spine_array_int_contains(spine_array_int array, int inValue);
 
 SPINE_C_API int spine_array_int_index_of(spine_array_int array, int inValue);
 
-SPINE_C_API int * spine_array_int_buffer(spine_array_int array);
+SPINE_C_API int *spine_array_int_buffer(spine_array_int array);
 
 SPINE_C_API spine_array_unsigned_short spine_array_unsigned_short_create(void);
 
@@ -131,7 +131,8 @@ SPINE_C_API size_t spine_array_unsigned_short_get_capacity(spine_array_unsigned_
 
 SPINE_C_API size_t spine_array_unsigned_short_size(spine_array_unsigned_short array);
 
-SPINE_C_API spine_array_unsigned_short spine_array_unsigned_short_set_size(spine_array_unsigned_short array, size_t newSize, unsigned short defaultValue);
+SPINE_C_API spine_array_unsigned_short spine_array_unsigned_short_set_size(spine_array_unsigned_short array, size_t newSize,
+																		   unsigned short defaultValue);
 
 SPINE_C_API void spine_array_unsigned_short_ensure_capacity(spine_array_unsigned_short array, size_t newCapacity);
 
@@ -147,7 +148,7 @@ SPINE_C_API bool spine_array_unsigned_short_contains(spine_array_unsigned_short
 
 SPINE_C_API int spine_array_unsigned_short_index_of(spine_array_unsigned_short array, unsigned short inValue);
 
-SPINE_C_API unsigned short * spine_array_unsigned_short_buffer(spine_array_unsigned_short array);
+SPINE_C_API unsigned short *spine_array_unsigned_short_buffer(spine_array_unsigned_short array);
 
 SPINE_C_API spine_array_property_id spine_array_property_id_create(void);
 
@@ -203,7 +204,7 @@ SPINE_C_API bool spine_array_animation_contains(spine_array_animation array, spi
 
 SPINE_C_API int spine_array_animation_index_of(spine_array_animation array, spine_animation inValue);
 
-SPINE_C_API spine_animation * spine_array_animation_buffer(spine_array_animation array);
+SPINE_C_API spine_animation *spine_array_animation_buffer(spine_array_animation array);
 
 SPINE_C_API spine_array_atlas_page spine_array_atlas_page_create(void);
 
@@ -231,7 +232,7 @@ SPINE_C_API bool spine_array_atlas_page_contains(spine_array_atlas_page array, s
 
 SPINE_C_API int spine_array_atlas_page_index_of(spine_array_atlas_page array, spine_atlas_page inValue);
 
-SPINE_C_API spine_atlas_page * spine_array_atlas_page_buffer(spine_array_atlas_page array);
+SPINE_C_API spine_atlas_page *spine_array_atlas_page_buffer(spine_array_atlas_page array);
 
 SPINE_C_API spine_array_atlas_region spine_array_atlas_region_create(void);
 
@@ -243,7 +244,8 @@ SPINE_C_API size_t spine_array_atlas_region_get_capacity(spine_array_atlas_regio
 
 SPINE_C_API size_t spine_array_atlas_region_size(spine_array_atlas_region array);
 
-SPINE_C_API spine_array_atlas_region spine_array_atlas_region_set_size(spine_array_atlas_region array, size_t newSize, spine_atlas_region defaultValue);
+SPINE_C_API spine_array_atlas_region spine_array_atlas_region_set_size(spine_array_atlas_region array, size_t newSize,
+																	   spine_atlas_region defaultValue);
 
 SPINE_C_API void spine_array_atlas_region_ensure_capacity(spine_array_atlas_region array, size_t newCapacity);
 
@@ -259,7 +261,7 @@ SPINE_C_API bool spine_array_atlas_region_contains(spine_array_atlas_region arra
 
 SPINE_C_API int spine_array_atlas_region_index_of(spine_array_atlas_region array, spine_atlas_region inValue);
 
-SPINE_C_API spine_atlas_region * spine_array_atlas_region_buffer(spine_array_atlas_region array);
+SPINE_C_API spine_atlas_region *spine_array_atlas_region_buffer(spine_array_atlas_region array);
 
 SPINE_C_API spine_array_attachment spine_array_attachment_create(void);
 
@@ -287,7 +289,7 @@ SPINE_C_API bool spine_array_attachment_contains(spine_array_attachment array, s
 
 SPINE_C_API int spine_array_attachment_index_of(spine_array_attachment array, spine_attachment inValue);
 
-SPINE_C_API spine_attachment * spine_array_attachment_buffer(spine_array_attachment array);
+SPINE_C_API spine_attachment *spine_array_attachment_buffer(spine_array_attachment array);
 
 SPINE_C_API spine_array_bone spine_array_bone_create(void);
 
@@ -315,7 +317,7 @@ SPINE_C_API bool spine_array_bone_contains(spine_array_bone array, spine_bone in
 
 SPINE_C_API int spine_array_bone_index_of(spine_array_bone array, spine_bone inValue);
 
-SPINE_C_API spine_bone * spine_array_bone_buffer(spine_array_bone array);
+SPINE_C_API spine_bone *spine_array_bone_buffer(spine_array_bone array);
 
 SPINE_C_API spine_array_bone_data spine_array_bone_data_create(void);
 
@@ -343,7 +345,7 @@ SPINE_C_API bool spine_array_bone_data_contains(spine_array_bone_data array, spi
 
 SPINE_C_API int spine_array_bone_data_index_of(spine_array_bone_data array, spine_bone_data inValue);
 
-SPINE_C_API spine_bone_data * spine_array_bone_data_buffer(spine_array_bone_data array);
+SPINE_C_API spine_bone_data *spine_array_bone_data_buffer(spine_array_bone_data array);
 
 SPINE_C_API spine_array_bone_pose spine_array_bone_pose_create(void);
 
@@ -371,7 +373,7 @@ SPINE_C_API bool spine_array_bone_pose_contains(spine_array_bone_pose array, spi
 
 SPINE_C_API int spine_array_bone_pose_index_of(spine_array_bone_pose array, spine_bone_pose inValue);
 
-SPINE_C_API spine_bone_pose * spine_array_bone_pose_buffer(spine_array_bone_pose array);
+SPINE_C_API spine_bone_pose *spine_array_bone_pose_buffer(spine_array_bone_pose array);
 
 SPINE_C_API spine_array_bounding_box_attachment spine_array_bounding_box_attachment_create(void);
 
@@ -383,7 +385,9 @@ SPINE_C_API size_t spine_array_bounding_box_attachment_get_capacity(spine_array_
 
 SPINE_C_API size_t spine_array_bounding_box_attachment_size(spine_array_bounding_box_attachment array);
 
-SPINE_C_API spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(spine_array_bounding_box_attachment array, size_t newSize, spine_bounding_box_attachment defaultValue);
+SPINE_C_API spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(spine_array_bounding_box_attachment array,
+																							 size_t newSize,
+																							 spine_bounding_box_attachment defaultValue);
 
 SPINE_C_API void spine_array_bounding_box_attachment_ensure_capacity(spine_array_bounding_box_attachment array, size_t newCapacity);
 
@@ -391,7 +395,8 @@ SPINE_C_API void spine_array_bounding_box_attachment_add(spine_array_bounding_bo
 
 SPINE_C_API void spine_array_bounding_box_attachment_add_all(spine_array_bounding_box_attachment array, spine_array_bounding_box_attachment inValue);
 
-SPINE_C_API void spine_array_bounding_box_attachment_clear_and_add_all(spine_array_bounding_box_attachment array, spine_array_bounding_box_attachment inValue);
+SPINE_C_API void spine_array_bounding_box_attachment_clear_and_add_all(spine_array_bounding_box_attachment array,
+																	   spine_array_bounding_box_attachment inValue);
 
 SPINE_C_API void spine_array_bounding_box_attachment_remove_at(spine_array_bounding_box_attachment array, size_t inIndex);
 
@@ -399,7 +404,7 @@ SPINE_C_API bool spine_array_bounding_box_attachment_contains(spine_array_boundi
 
 SPINE_C_API int spine_array_bounding_box_attachment_index_of(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue);
 
-SPINE_C_API spine_bounding_box_attachment * spine_array_bounding_box_attachment_buffer(spine_array_bounding_box_attachment array);
+SPINE_C_API spine_bounding_box_attachment *spine_array_bounding_box_attachment_buffer(spine_array_bounding_box_attachment array);
 
 SPINE_C_API spine_array_constraint spine_array_constraint_create(void);
 
@@ -427,7 +432,7 @@ SPINE_C_API bool spine_array_constraint_contains(spine_array_constraint array, s
 
 SPINE_C_API int spine_array_constraint_index_of(spine_array_constraint array, spine_constraint inValue);
 
-SPINE_C_API spine_constraint * spine_array_constraint_buffer(spine_array_constraint array);
+SPINE_C_API spine_constraint *spine_array_constraint_buffer(spine_array_constraint array);
 
 SPINE_C_API spine_array_constraint_data spine_array_constraint_data_create(void);
 
@@ -439,7 +444,8 @@ SPINE_C_API size_t spine_array_constraint_data_get_capacity(spine_array_constrai
 
 SPINE_C_API size_t spine_array_constraint_data_size(spine_array_constraint_data array);
 
-SPINE_C_API spine_array_constraint_data spine_array_constraint_data_set_size(spine_array_constraint_data array, size_t newSize, spine_constraint_data defaultValue);
+SPINE_C_API spine_array_constraint_data spine_array_constraint_data_set_size(spine_array_constraint_data array, size_t newSize,
+																			 spine_constraint_data defaultValue);
 
 SPINE_C_API void spine_array_constraint_data_ensure_capacity(spine_array_constraint_data array, size_t newCapacity);
 
@@ -455,7 +461,7 @@ SPINE_C_API bool spine_array_constraint_data_contains(spine_array_constraint_dat
 
 SPINE_C_API int spine_array_constraint_data_index_of(spine_array_constraint_data array, spine_constraint_data inValue);
 
-SPINE_C_API spine_constraint_data * spine_array_constraint_data_buffer(spine_array_constraint_data array);
+SPINE_C_API spine_constraint_data *spine_array_constraint_data_buffer(spine_array_constraint_data array);
 
 SPINE_C_API spine_array_event spine_array_event_create(void);
 
@@ -483,7 +489,7 @@ SPINE_C_API bool spine_array_event_contains(spine_array_event array, spine_event
 
 SPINE_C_API int spine_array_event_index_of(spine_array_event array, spine_event inValue);
 
-SPINE_C_API spine_event * spine_array_event_buffer(spine_array_event array);
+SPINE_C_API spine_event *spine_array_event_buffer(spine_array_event array);
 
 SPINE_C_API spine_array_event_data spine_array_event_data_create(void);
 
@@ -511,7 +517,7 @@ SPINE_C_API bool spine_array_event_data_contains(spine_array_event_data array, s
 
 SPINE_C_API int spine_array_event_data_index_of(spine_array_event_data array, spine_event_data inValue);
 
-SPINE_C_API spine_event_data * spine_array_event_data_buffer(spine_array_event_data array);
+SPINE_C_API spine_event_data *spine_array_event_data_buffer(spine_array_event_data array);
 
 SPINE_C_API spine_array_from_property spine_array_from_property_create(void);
 
@@ -523,7 +529,8 @@ SPINE_C_API size_t spine_array_from_property_get_capacity(spine_array_from_prope
 
 SPINE_C_API size_t spine_array_from_property_size(spine_array_from_property array);
 
-SPINE_C_API spine_array_from_property spine_array_from_property_set_size(spine_array_from_property array, size_t newSize, spine_from_property defaultValue);
+SPINE_C_API spine_array_from_property spine_array_from_property_set_size(spine_array_from_property array, size_t newSize,
+																		 spine_from_property defaultValue);
 
 SPINE_C_API void spine_array_from_property_ensure_capacity(spine_array_from_property array, size_t newCapacity);
 
@@ -539,7 +546,7 @@ SPINE_C_API bool spine_array_from_property_contains(spine_array_from_property ar
 
 SPINE_C_API int spine_array_from_property_index_of(spine_array_from_property array, spine_from_property inValue);
 
-SPINE_C_API spine_from_property * spine_array_from_property_buffer(spine_array_from_property array);
+SPINE_C_API spine_from_property *spine_array_from_property_buffer(spine_array_from_property array);
 
 SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_create(void);
 
@@ -551,7 +558,8 @@ SPINE_C_API size_t spine_array_physics_constraint_get_capacity(spine_array_physi
 
 SPINE_C_API size_t spine_array_physics_constraint_size(spine_array_physics_constraint array);
 
-SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_set_size(spine_array_physics_constraint array, size_t newSize, spine_physics_constraint defaultValue);
+SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_set_size(spine_array_physics_constraint array, size_t newSize,
+																				   spine_physics_constraint defaultValue);
 
 SPINE_C_API void spine_array_physics_constraint_ensure_capacity(spine_array_physics_constraint array, size_t newCapacity);
 
@@ -567,7 +575,7 @@ SPINE_C_API bool spine_array_physics_constraint_contains(spine_array_physics_con
 
 SPINE_C_API int spine_array_physics_constraint_index_of(spine_array_physics_constraint array, spine_physics_constraint inValue);
 
-SPINE_C_API spine_physics_constraint * spine_array_physics_constraint_buffer(spine_array_physics_constraint array);
+SPINE_C_API spine_physics_constraint *spine_array_physics_constraint_buffer(spine_array_physics_constraint array);
 
 SPINE_C_API spine_array_polygon spine_array_polygon_create(void);
 
@@ -595,7 +603,7 @@ SPINE_C_API bool spine_array_polygon_contains(spine_array_polygon array, spine_p
 
 SPINE_C_API int spine_array_polygon_index_of(spine_array_polygon array, spine_polygon inValue);
 
-SPINE_C_API spine_polygon * spine_array_polygon_buffer(spine_array_polygon array);
+SPINE_C_API spine_polygon *spine_array_polygon_buffer(spine_array_polygon array);
 
 SPINE_C_API spine_array_skin spine_array_skin_create(void);
 
@@ -623,7 +631,7 @@ SPINE_C_API bool spine_array_skin_contains(spine_array_skin array, spine_skin in
 
 SPINE_C_API int spine_array_skin_index_of(spine_array_skin array, spine_skin inValue);
 
-SPINE_C_API spine_skin * spine_array_skin_buffer(spine_array_skin array);
+SPINE_C_API spine_skin *spine_array_skin_buffer(spine_array_skin array);
 
 SPINE_C_API spine_array_slot spine_array_slot_create(void);
 
@@ -651,7 +659,7 @@ SPINE_C_API bool spine_array_slot_contains(spine_array_slot array, spine_slot in
 
 SPINE_C_API int spine_array_slot_index_of(spine_array_slot array, spine_slot inValue);
 
-SPINE_C_API spine_slot * spine_array_slot_buffer(spine_array_slot array);
+SPINE_C_API spine_slot *spine_array_slot_buffer(spine_array_slot array);
 
 SPINE_C_API spine_array_slot_data spine_array_slot_data_create(void);
 
@@ -679,7 +687,7 @@ SPINE_C_API bool spine_array_slot_data_contains(spine_array_slot_data array, spi
 
 SPINE_C_API int spine_array_slot_data_index_of(spine_array_slot_data array, spine_slot_data inValue);
 
-SPINE_C_API spine_slot_data * spine_array_slot_data_buffer(spine_array_slot_data array);
+SPINE_C_API spine_slot_data *spine_array_slot_data_buffer(spine_array_slot_data array);
 
 SPINE_C_API spine_array_texture_region spine_array_texture_region_create(void);
 
@@ -691,7 +699,8 @@ SPINE_C_API size_t spine_array_texture_region_get_capacity(spine_array_texture_r
 
 SPINE_C_API size_t spine_array_texture_region_size(spine_array_texture_region array);
 
-SPINE_C_API spine_array_texture_region spine_array_texture_region_set_size(spine_array_texture_region array, size_t newSize, spine_texture_region defaultValue);
+SPINE_C_API spine_array_texture_region spine_array_texture_region_set_size(spine_array_texture_region array, size_t newSize,
+																		   spine_texture_region defaultValue);
 
 SPINE_C_API void spine_array_texture_region_ensure_capacity(spine_array_texture_region array, size_t newCapacity);
 
@@ -707,7 +716,7 @@ SPINE_C_API bool spine_array_texture_region_contains(spine_array_texture_region
 
 SPINE_C_API int spine_array_texture_region_index_of(spine_array_texture_region array, spine_texture_region inValue);
 
-SPINE_C_API spine_texture_region * spine_array_texture_region_buffer(spine_array_texture_region array);
+SPINE_C_API spine_texture_region *spine_array_texture_region_buffer(spine_array_texture_region array);
 
 SPINE_C_API spine_array_timeline spine_array_timeline_create(void);
 
@@ -735,7 +744,7 @@ SPINE_C_API bool spine_array_timeline_contains(spine_array_timeline array, spine
 
 SPINE_C_API int spine_array_timeline_index_of(spine_array_timeline array, spine_timeline inValue);
 
-SPINE_C_API spine_timeline * spine_array_timeline_buffer(spine_array_timeline array);
+SPINE_C_API spine_timeline *spine_array_timeline_buffer(spine_array_timeline array);
 
 SPINE_C_API spine_array_to_property spine_array_to_property_create(void);
 
@@ -763,7 +772,7 @@ SPINE_C_API bool spine_array_to_property_contains(spine_array_to_property array,
 
 SPINE_C_API int spine_array_to_property_index_of(spine_array_to_property array, spine_to_property inValue);
 
-SPINE_C_API spine_to_property * spine_array_to_property_buffer(spine_array_to_property array);
+SPINE_C_API spine_to_property *spine_array_to_property_buffer(spine_array_to_property array);
 
 SPINE_C_API spine_array_track_entry spine_array_track_entry_create(void);
 
@@ -791,7 +800,7 @@ SPINE_C_API bool spine_array_track_entry_contains(spine_array_track_entry array,
 
 SPINE_C_API int spine_array_track_entry_index_of(spine_array_track_entry array, spine_track_entry inValue);
 
-SPINE_C_API spine_track_entry * spine_array_track_entry_buffer(spine_array_track_entry array);
+SPINE_C_API spine_track_entry *spine_array_track_entry_buffer(spine_array_track_entry array);
 
 SPINE_C_API spine_array_update spine_array_update_create(void);
 
@@ -819,7 +828,7 @@ SPINE_C_API bool spine_array_update_contains(spine_array_update array, spine_upd
 
 SPINE_C_API int spine_array_update_index_of(spine_array_update array, spine_update inValue);
 
-SPINE_C_API spine_update * spine_array_update_buffer(spine_array_update array);
+SPINE_C_API spine_update *spine_array_update_buffer(spine_array_update array);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/atlas.cpp

@@ -4,21 +4,25 @@
 using namespace spine;
 
 void spine_atlas_dispose(spine_atlas self) {
-    delete (Atlas*)self;
+	delete (Atlas *) self;
 }
 
 void spine_atlas_flip_v(spine_atlas self) {
-    ((Atlas*)self)->flipV();
+	Atlas *_self = (Atlas *) self;
+	_self->flipV();
 }
 
-spine_atlas_region spine_atlas_find_region(spine_atlas self, const char * name) {
-    return (spine_atlas_region)((Atlas*)self)->findRegion(String(name));
+spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name) {
+	Atlas *_self = (Atlas *) self;
+	return (spine_atlas_region) _self->findRegion(String(name));
 }
 
 spine_array_atlas_page spine_atlas_get_pages(spine_atlas self) {
-    return (spine_array_atlas_page)&((Atlas*)self)->getPages();
+	Atlas *_self = (Atlas *) self;
+	return (spine_array_atlas_page) &_self->getPages();
 }
 
 spine_array_atlas_region spine_atlas_get_regions(spine_atlas self) {
-    return (spine_array_atlas_region)&((Atlas*)self)->getRegions();
+	Atlas *_self = (Atlas *) self;
+	return (spine_array_atlas_region) &_self->getRegions();
 }

spine-c/src/generated/atlas.h

@@ -11,7 +11,7 @@ extern "C" {
 SPINE_C_API void spine_atlas_dispose(spine_atlas self);
 
 SPINE_C_API void spine_atlas_flip_v(spine_atlas self);
-SPINE_C_API spine_atlas_region spine_atlas_find_region(spine_atlas self, const char * name);
+SPINE_C_API spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name);
 SPINE_C_API spine_array_atlas_page spine_atlas_get_pages(spine_atlas self);
 SPINE_C_API spine_array_atlas_region spine_atlas_get_regions(spine_atlas self);
 

spine-c/src/generated/atlas_attachment_loader.cpp

@@ -4,37 +4,48 @@
 using namespace spine;
 
 spine_atlas_attachment_loader spine_atlas_attachment_loader_create(spine_atlas atlas) {
-    return (spine_atlas_attachment_loader) new (__FILE__, __LINE__) AtlasAttachmentLoader((Atlas *)atlas);
+	return (spine_atlas_attachment_loader) new (__FILE__, __LINE__) AtlasAttachmentLoader((Atlas *) atlas);
 }
 
 void spine_atlas_attachment_loader_dispose(spine_atlas_attachment_loader self) {
-    delete (AtlasAttachmentLoader*)self;
+	delete (AtlasAttachmentLoader *) self;
 }
 
-spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence) {
-    return (spine_region_attachment)((AtlasAttachmentLoader*)self)->newRegionAttachment(*((Skin*)skin), String(name), String(path), (Sequence *)sequence);
+spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name,
+																			const char *path, spine_sequence sequence) {
+	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
+	return (spine_region_attachment) _self->newRegionAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
 }
 
-spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence) {
-    return (spine_mesh_attachment)((AtlasAttachmentLoader*)self)->newMeshAttachment(*((Skin*)skin), String(name), String(path), (Sequence *)sequence);
+spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name,
+																		const char *path, spine_sequence sequence) {
+	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
+	return (spine_mesh_attachment) _self->newMeshAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
 }
 
-spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name) {
-    return (spine_bounding_box_attachment)((AtlasAttachmentLoader*)self)->newBoundingBoxAttachment(*((Skin*)skin), String(name));
+spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																						const char *name) {
+	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
+	return (spine_bounding_box_attachment) _self->newBoundingBoxAttachment(*((Skin *) skin), String(name));
 }
 
-spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name) {
-    return (spine_path_attachment)((AtlasAttachmentLoader*)self)->newPathAttachment(*((Skin*)skin), String(name));
+spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name) {
+	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
+	return (spine_path_attachment) _self->newPathAttachment(*((Skin *) skin), String(name));
 }
 
-spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name) {
-    return (spine_point_attachment)((AtlasAttachmentLoader*)self)->newPointAttachment(*((Skin*)skin), String(name));
+spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char *name) {
+	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
+	return (spine_point_attachment) _self->newPointAttachment(*((Skin *) skin), String(name));
 }
 
-spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name) {
-    return (spine_clipping_attachment)((AtlasAttachmentLoader*)self)->newClippingAttachment(*((Skin*)skin), String(name));
+spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																				const char *name) {
+	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
+	return (spine_clipping_attachment) _self->newClippingAttachment(*((Skin *) skin), String(name));
 }
 
-spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char * name) {
-    return (spine_atlas_region)((AtlasAttachmentLoader*)self)->findRegion(String(name));
+spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char *name) {
+	AtlasAttachmentLoader *_self = (AtlasAttachmentLoader *) self;
+	return (spine_atlas_region) _self->findRegion(String(name));
 }

spine-c/src/generated/atlas_attachment_loader.h

@@ -12,13 +12,19 @@ SPINE_C_API spine_atlas_attachment_loader spine_atlas_attachment_loader_create(s
 
 SPINE_C_API void spine_atlas_attachment_loader_dispose(spine_atlas_attachment_loader self);
 
-SPINE_C_API spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence);
-SPINE_C_API spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence);
-SPINE_C_API spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name);
-SPINE_C_API spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name);
-SPINE_C_API spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name);
-SPINE_C_API spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin, const char * name);
-SPINE_C_API spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char * name);
+SPINE_C_API spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																						const char *name, const char *path, spine_sequence sequence);
+SPINE_C_API spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																					const char *name, const char *path, spine_sequence sequence);
+SPINE_C_API spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self,
+																									spine_skin skin, const char *name);
+SPINE_C_API spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																					const char *name);
+SPINE_C_API spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																					  const char *name);
+SPINE_C_API spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin,
+																							const char *name);
+SPINE_C_API spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char *name);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/atlas_page.cpp

@@ -3,106 +3,130 @@
 
 using namespace spine;
 
-spine_atlas_page spine_atlas_page_create(const char * inName) {
-    return (spine_atlas_page) new (__FILE__, __LINE__) AtlasPage(String(inName));
+spine_atlas_page spine_atlas_page_create(const char *inName) {
+	return (spine_atlas_page) new (__FILE__, __LINE__) AtlasPage(String(inName));
 }
 
 void spine_atlas_page_dispose(spine_atlas_page self) {
-    delete (AtlasPage*)self;
+	delete (AtlasPage *) self;
 }
 
-const char * spine_atlas_page_get_name(spine_atlas_page self) {
-    return ((AtlasPage*)self)->name.buffer();
+const char *spine_atlas_page_get_name(spine_atlas_page self) {
+	AtlasPage *_self = (AtlasPage *) self;
+	return _self->name.buffer();
 }
 
-void spine_atlas_page_set_name(spine_atlas_page self, const char * value) {
-    ((AtlasPage*)self)->name = String(value);
+void spine_atlas_page_set_name(spine_atlas_page self, const char *value) {
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->name = String(value);
 }
 
-const char * spine_atlas_page_get_texture_path(spine_atlas_page self) {
-    return ((AtlasPage*)self)->texturePath.buffer();
+const char *spine_atlas_page_get_texture_path(spine_atlas_page self) {
+	AtlasPage *_self = (AtlasPage *) self;
+	return _self->texturePath.buffer();
 }
 
-void spine_atlas_page_set_texture_path(spine_atlas_page self, const char * value) {
-    ((AtlasPage*)self)->texturePath = String(value);
+void spine_atlas_page_set_texture_path(spine_atlas_page self, const char *value) {
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->texturePath = String(value);
 }
 
 spine_format spine_atlas_page_get_format(spine_atlas_page self) {
-    return (spine_format)((AtlasPage*)self)->format;
+	AtlasPage *_self = (AtlasPage *) self;
+	return (spine_format) _self->format;
 }
 
 void spine_atlas_page_set_format(spine_atlas_page self, spine_format value) {
-    ((AtlasPage*)self)->format = (Format)value;
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->format = (Format) value;
 }
 
 spine_texture_filter spine_atlas_page_get_min_filter(spine_atlas_page self) {
-    return (spine_texture_filter)((AtlasPage*)self)->minFilter;
+	AtlasPage *_self = (AtlasPage *) self;
+	return (spine_texture_filter) _self->minFilter;
 }
 
 void spine_atlas_page_set_min_filter(spine_atlas_page self, spine_texture_filter value) {
-    ((AtlasPage*)self)->minFilter = (TextureFilter)value;
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->minFilter = (TextureFilter) value;
 }
 
 spine_texture_filter spine_atlas_page_get_mag_filter(spine_atlas_page self) {
-    return (spine_texture_filter)((AtlasPage*)self)->magFilter;
+	AtlasPage *_self = (AtlasPage *) self;
+	return (spine_texture_filter) _self->magFilter;
 }
 
 void spine_atlas_page_set_mag_filter(spine_atlas_page self, spine_texture_filter value) {
-    ((AtlasPage*)self)->magFilter = (TextureFilter)value;
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->magFilter = (TextureFilter) value;
 }
 
 spine_texture_wrap spine_atlas_page_get_u_wrap(spine_atlas_page self) {
-    return (spine_texture_wrap)((AtlasPage*)self)->uWrap;
+	AtlasPage *_self = (AtlasPage *) self;
+	return (spine_texture_wrap) _self->uWrap;
 }
 
 void spine_atlas_page_set_u_wrap(spine_atlas_page self, spine_texture_wrap value) {
-    ((AtlasPage*)self)->uWrap = (TextureWrap)value;
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->uWrap = (TextureWrap) value;
 }
 
 spine_texture_wrap spine_atlas_page_get_v_wrap(spine_atlas_page self) {
-    return (spine_texture_wrap)((AtlasPage*)self)->vWrap;
+	AtlasPage *_self = (AtlasPage *) self;
+	return (spine_texture_wrap) _self->vWrap;
 }
 
 void spine_atlas_page_set_v_wrap(spine_atlas_page self, spine_texture_wrap value) {
-    ((AtlasPage*)self)->vWrap = (TextureWrap)value;
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->vWrap = (TextureWrap) value;
 }
 
 int spine_atlas_page_get_width(spine_atlas_page self) {
-    return ((AtlasPage*)self)->width;
+	AtlasPage *_self = (AtlasPage *) self;
+	return _self->width;
 }
 
 void spine_atlas_page_set_width(spine_atlas_page self, int value) {
-    ((AtlasPage*)self)->width = value;
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->width = value;
 }
 
 int spine_atlas_page_get_height(spine_atlas_page self) {
-    return ((AtlasPage*)self)->height;
+	AtlasPage *_self = (AtlasPage *) self;
+	return _self->height;
 }
 
 void spine_atlas_page_set_height(spine_atlas_page self, int value) {
-    ((AtlasPage*)self)->height = value;
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->height = value;
 }
 
 bool spine_atlas_page_get_pma(spine_atlas_page self) {
-    return ((AtlasPage*)self)->pma;
+	AtlasPage *_self = (AtlasPage *) self;
+	return _self->pma;
 }
 
 void spine_atlas_page_set_pma(spine_atlas_page self, bool value) {
-    ((AtlasPage*)self)->pma = value;
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->pma = value;
 }
 
 int spine_atlas_page_get_index(spine_atlas_page self) {
-    return ((AtlasPage*)self)->index;
+	AtlasPage *_self = (AtlasPage *) self;
+	return _self->index;
 }
 
 void spine_atlas_page_set_index(spine_atlas_page self, int value) {
-    ((AtlasPage*)self)->index = value;
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->index = value;
 }
 
-void * spine_atlas_page_get_texture(spine_atlas_page self) {
-    return ((AtlasPage*)self)->texture;
+void *spine_atlas_page_get_texture(spine_atlas_page self) {
+	AtlasPage *_self = (AtlasPage *) self;
+	return _self->texture;
 }
 
-void spine_atlas_page_set_texture(spine_atlas_page self, void * value) {
-    ((AtlasPage*)self)->texture = (void*)value;
+void spine_atlas_page_set_texture(spine_atlas_page self, void *value) {
+	AtlasPage *_self = (AtlasPage *) self;
+	_self->texture = (void *) value;
 }

spine-c/src/generated/atlas_page.h

@@ -8,14 +8,14 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_atlas_page spine_atlas_page_create(const char * inName);
+SPINE_C_API spine_atlas_page spine_atlas_page_create(const char *inName);
 
 SPINE_C_API void spine_atlas_page_dispose(spine_atlas_page self);
 
-SPINE_C_API const char * spine_atlas_page_get_name(spine_atlas_page self);
-SPINE_C_API void spine_atlas_page_set_name(spine_atlas_page self, const char * value);
-SPINE_C_API const char * spine_atlas_page_get_texture_path(spine_atlas_page self);
-SPINE_C_API void spine_atlas_page_set_texture_path(spine_atlas_page self, const char * value);
+SPINE_C_API const char *spine_atlas_page_get_name(spine_atlas_page self);
+SPINE_C_API void spine_atlas_page_set_name(spine_atlas_page self, const char *value);
+SPINE_C_API const char *spine_atlas_page_get_texture_path(spine_atlas_page self);
+SPINE_C_API void spine_atlas_page_set_texture_path(spine_atlas_page self, const char *value);
 SPINE_C_API spine_format spine_atlas_page_get_format(spine_atlas_page self);
 SPINE_C_API void spine_atlas_page_set_format(spine_atlas_page self, spine_format value);
 SPINE_C_API spine_texture_filter spine_atlas_page_get_min_filter(spine_atlas_page self);
@@ -34,8 +34,8 @@ SPINE_C_API bool spine_atlas_page_get_pma(spine_atlas_page self);
 SPINE_C_API void spine_atlas_page_set_pma(spine_atlas_page self, bool value);
 SPINE_C_API int spine_atlas_page_get_index(spine_atlas_page self);
 SPINE_C_API void spine_atlas_page_set_index(spine_atlas_page self, int value);
-SPINE_C_API void * spine_atlas_page_get_texture(spine_atlas_page self);
-SPINE_C_API void spine_atlas_page_set_texture(spine_atlas_page self, void * value);
+SPINE_C_API void *spine_atlas_page_get_texture(spine_atlas_page self);
+SPINE_C_API void spine_atlas_page_set_texture(spine_atlas_page self, void *value);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/atlas_region.cpp

@@ -4,189 +4,233 @@
 using namespace spine;
 
 spine_atlas_region spine_atlas_region_create(void) {
-    return (spine_atlas_region) new (__FILE__, __LINE__) AtlasRegion();
+	return (spine_atlas_region) new (__FILE__, __LINE__) AtlasRegion();
 }
 
 void spine_atlas_region_dispose(spine_atlas_region self) {
-    delete (AtlasRegion*)self;
+	delete (AtlasRegion *) self;
 }
 
 spine_rtti spine_atlas_region_get_rtti(spine_atlas_region self) {
-    return (spine_rtti)&((AtlasRegion*)self)->getRTTI();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self) {
-    return (spine_atlas_page)((AtlasRegion*)self)->getPage();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return (spine_atlas_page) _self->getPage();
 }
 
 int spine_atlas_region_get_index(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getIndex();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getIndex();
 }
 
 int spine_atlas_region_get_x(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getX();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getX();
 }
 
 int spine_atlas_region_get_y(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getY();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getY();
 }
 
 float spine_atlas_region_get_offset_x(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getOffsetX();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getOffsetX();
 }
 
 float spine_atlas_region_get_offset_y(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getOffsetY();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getOffsetY();
 }
 
 int spine_atlas_region_get_packed_width(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getPackedWidth();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getPackedWidth();
 }
 
 int spine_atlas_region_get_packed_height(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getPackedHeight();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getPackedHeight();
 }
 
 int spine_atlas_region_get_original_width(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getOriginalWidth();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getOriginalWidth();
 }
 
 int spine_atlas_region_get_original_height(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getOriginalHeight();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getOriginalHeight();
 }
 
 bool spine_atlas_region_get_rotate(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getRotate();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getRotate();
 }
 
 int spine_atlas_region_get_degrees(spine_atlas_region self) {
-    return ((AtlasRegion*)self)->getDegrees();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return _self->getDegrees();
 }
 
 spine_array_int spine_atlas_region_get_splits(spine_atlas_region self) {
-    return (spine_array_int)&((AtlasRegion*)self)->getSplits();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return (spine_array_int) &_self->getSplits();
 }
 
 spine_array_int spine_atlas_region_get_pads(spine_atlas_region self) {
-    return (spine_array_int)&((AtlasRegion*)self)->getPads();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return (spine_array_int) &_self->getPads();
 }
 
 spine_array_float spine_atlas_region_get_values(spine_atlas_region self) {
-    return (spine_array_float)&((AtlasRegion*)self)->getValues();
+	AtlasRegion *_self = (AtlasRegion *) self;
+	return (spine_array_float) &_self->getValues();
 }
 
 void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value) {
-    ((AtlasRegion*)self)->setPage((AtlasPage *)value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setPage((AtlasPage *) value);
 }
 
-void spine_atlas_region_set_name(spine_atlas_region self, const char * value) {
-    ((AtlasRegion*)self)->setName(String(value));
+void spine_atlas_region_set_name(spine_atlas_region self, const char *value) {
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setName(String(value));
 }
 
 void spine_atlas_region_set_index(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->setIndex(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setIndex(value);
 }
 
 void spine_atlas_region_set_x(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->setX(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setX(value);
 }
 
 void spine_atlas_region_set_y(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->setY(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setY(value);
 }
 
 void spine_atlas_region_set_offset_x(spine_atlas_region self, float value) {
-    ((AtlasRegion*)self)->setOffsetX(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setOffsetX(value);
 }
 
 void spine_atlas_region_set_offset_y(spine_atlas_region self, float value) {
-    ((AtlasRegion*)self)->setOffsetY(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setOffsetY(value);
 }
 
 void spine_atlas_region_set_packed_width(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->setPackedWidth(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setPackedWidth(value);
 }
 
 void spine_atlas_region_set_packed_height(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->setPackedHeight(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setPackedHeight(value);
 }
 
 void spine_atlas_region_set_original_width(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->setOriginalWidth(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setOriginalWidth(value);
 }
 
 void spine_atlas_region_set_original_height(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->setOriginalHeight(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setOriginalHeight(value);
 }
 
 void spine_atlas_region_set_rotate(spine_atlas_region self, bool value) {
-    ((AtlasRegion*)self)->setRotate(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setRotate(value);
 }
 
 void spine_atlas_region_set_degrees(spine_atlas_region self, int value) {
-    ((AtlasRegion*)self)->setDegrees(value);
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setDegrees(value);
 }
 
 void spine_atlas_region_set_splits(spine_atlas_region self, spine_array_int value) {
-    ((AtlasRegion*)self)->setSplits(*((const Array<int>*)value));
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setSplits(*((const Array<int> *) value));
 }
 
 void spine_atlas_region_set_pads(spine_atlas_region self, spine_array_int value) {
-    ((AtlasRegion*)self)->setPads(*((const Array<int>*)value));
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setPads(*((const Array<int> *) value));
 }
 
 void spine_atlas_region_set_values(spine_atlas_region self, spine_array_float value) {
-    ((AtlasRegion*)self)->setValues(*((const Array<float>*)value));
+	AtlasRegion *_self = (AtlasRegion *) self;
+	_self->setValues(*((const Array<float> *) value));
 }
 
 float spine_atlas_region_get_u(spine_atlas_region self) {
-    return ((TextureRegion*)(AtlasRegion*)self)->getU();
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	return _self->getU();
 }
 
 void spine_atlas_region_set_u(spine_atlas_region self, float value) {
-    ((TextureRegion*)(AtlasRegion*)self)->setU(value);
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	_self->setU(value);
 }
 
 float spine_atlas_region_get_v(spine_atlas_region self) {
-    return ((TextureRegion*)(AtlasRegion*)self)->getV();
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	return _self->getV();
 }
 
 void spine_atlas_region_set_v(spine_atlas_region self, float value) {
-    ((TextureRegion*)(AtlasRegion*)self)->setV(value);
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	_self->setV(value);
 }
 
 float spine_atlas_region_get_u2(spine_atlas_region self) {
-    return ((TextureRegion*)(AtlasRegion*)self)->getU2();
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	return _self->getU2();
 }
 
 void spine_atlas_region_set_u2(spine_atlas_region self, float value) {
-    ((TextureRegion*)(AtlasRegion*)self)->setU2(value);
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	_self->setU2(value);
 }
 
 float spine_atlas_region_get_v2(spine_atlas_region self) {
-    return ((TextureRegion*)(AtlasRegion*)self)->getV2();
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	return _self->getV2();
 }
 
 void spine_atlas_region_set_v2(spine_atlas_region self, float value) {
-    ((TextureRegion*)(AtlasRegion*)self)->setV2(value);
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	_self->setV2(value);
 }
 
 int spine_atlas_region_get_region_width(spine_atlas_region self) {
-    return ((TextureRegion*)(AtlasRegion*)self)->getRegionWidth();
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	return _self->getRegionWidth();
 }
 
 void spine_atlas_region_set_region_width(spine_atlas_region self, int value) {
-    ((TextureRegion*)(AtlasRegion*)self)->setRegionWidth(value);
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	_self->setRegionWidth(value);
 }
 
 int spine_atlas_region_get_region_height(spine_atlas_region self) {
-    return ((TextureRegion*)(AtlasRegion*)self)->getRegionHeight();
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	return _self->getRegionHeight();
 }
 
 void spine_atlas_region_set_region_height(spine_atlas_region self, int value) {
-    ((TextureRegion*)(AtlasRegion*)self)->setRegionHeight(value);
+	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	_self->setRegionHeight(value);
 }
 
 spine_rtti spine_atlas_region_rtti(void) {
-    return (spine_rtti)&AtlasRegion::rtti;
+	return (spine_rtti) &AtlasRegion::rtti;
 }

spine-c/src/generated/atlas_region.h

@@ -29,7 +29,7 @@ SPINE_C_API spine_array_int spine_atlas_region_get_splits(spine_atlas_region sel
 SPINE_C_API spine_array_int spine_atlas_region_get_pads(spine_atlas_region self);
 SPINE_C_API spine_array_float spine_atlas_region_get_values(spine_atlas_region self);
 SPINE_C_API void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value);
-SPINE_C_API void spine_atlas_region_set_name(spine_atlas_region self, const char * value);
+SPINE_C_API void spine_atlas_region_set_name(spine_atlas_region self, const char *value);
 SPINE_C_API void spine_atlas_region_set_index(spine_atlas_region self, int value);
 SPINE_C_API void spine_atlas_region_set_x(spine_atlas_region self, int value);
 SPINE_C_API void spine_atlas_region_set_y(spine_atlas_region self, int value);

spine-c/src/generated/attachment.cpp

@@ -4,33 +4,39 @@
 using namespace spine;
 
 void spine_attachment_dispose(spine_attachment self) {
-    delete (Attachment*)self;
+	delete (Attachment *) self;
 }
 
 spine_rtti spine_attachment_get_rtti(spine_attachment self) {
-    return (spine_rtti)&((Attachment*)self)->getRTTI();
+	Attachment *_self = (Attachment *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-const char * spine_attachment_get_name(spine_attachment self) {
-    return ((Attachment*)self)->getName().buffer();
+const char *spine_attachment_get_name(spine_attachment self) {
+	Attachment *_self = (Attachment *) self;
+	return _self->getName().buffer();
 }
 
 spine_attachment spine_attachment_copy(spine_attachment self) {
-    return (spine_attachment)((Attachment*)self)->copy();
+	Attachment *_self = (Attachment *) self;
+	return (spine_attachment) _self->copy();
 }
 
 int spine_attachment_get_ref_count(spine_attachment self) {
-    return ((Attachment*)self)->getRefCount();
+	Attachment *_self = (Attachment *) self;
+	return _self->getRefCount();
 }
 
 void spine_attachment_reference(spine_attachment self) {
-    ((Attachment*)self)->reference();
+	Attachment *_self = (Attachment *) self;
+	_self->reference();
 }
 
 void spine_attachment_dereference(spine_attachment self) {
-    ((Attachment*)self)->dereference();
+	Attachment *_self = (Attachment *) self;
+	_self->dereference();
 }
 
 spine_rtti spine_attachment_rtti(void) {
-    return (spine_rtti)&Attachment::rtti;
+	return (spine_rtti) &Attachment::rtti;
 }

spine-c/src/generated/attachment.h

@@ -11,7 +11,7 @@ extern "C" {
 SPINE_C_API void spine_attachment_dispose(spine_attachment self);
 
 SPINE_C_API spine_rtti spine_attachment_get_rtti(spine_attachment self);
-SPINE_C_API const char * spine_attachment_get_name(spine_attachment self);
+SPINE_C_API const char *spine_attachment_get_name(spine_attachment self);
 SPINE_C_API spine_attachment spine_attachment_copy(spine_attachment self);
 SPINE_C_API int spine_attachment_get_ref_count(spine_attachment self);
 SPINE_C_API void spine_attachment_reference(spine_attachment self);

spine-c/src/generated/attachment_loader.cpp

@@ -4,29 +4,37 @@
 using namespace spine;
 
 void spine_attachment_loader_dispose(spine_attachment_loader self) {
-    delete (AttachmentLoader*)self;
+	delete (AttachmentLoader *) self;
 }
 
-spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence) {
-    return (spine_region_attachment)((AttachmentLoader*)self)->newRegionAttachment(*((Skin*)skin), String(name), String(path), (Sequence *)sequence);
+spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
+																	  const char *path, spine_sequence sequence) {
+	AttachmentLoader *_self = (AttachmentLoader *) self;
+	return (spine_region_attachment) _self->newRegionAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
 }
 
-spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence) {
-    return (spine_mesh_attachment)((AttachmentLoader*)self)->newMeshAttachment(*((Skin*)skin), String(name), String(path), (Sequence *)sequence);
+spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char *name, const char *path,
+																  spine_sequence sequence) {
+	AttachmentLoader *_self = (AttachmentLoader *) self;
+	return (spine_mesh_attachment) _self->newMeshAttachment(*((Skin *) skin), String(name), String(path), (Sequence *) sequence);
 }
 
-spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin, const char * name) {
-    return (spine_bounding_box_attachment)((AttachmentLoader*)self)->newBoundingBoxAttachment(*((Skin*)skin), String(name));
+spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
+	AttachmentLoader *_self = (AttachmentLoader *) self;
+	return (spine_bounding_box_attachment) _self->newBoundingBoxAttachment(*((Skin *) skin), String(name));
 }
 
-spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char * name) {
-    return (spine_path_attachment)((AttachmentLoader*)self)->newPathAttachment(*((Skin*)skin), String(name));
+spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
+	AttachmentLoader *_self = (AttachmentLoader *) self;
+	return (spine_path_attachment) _self->newPathAttachment(*((Skin *) skin), String(name));
 }
 
-spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char * name) {
-    return (spine_point_attachment)((AttachmentLoader*)self)->newPointAttachment(*((Skin*)skin), String(name));
+spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
+	AttachmentLoader *_self = (AttachmentLoader *) self;
+	return (spine_point_attachment) _self->newPointAttachment(*((Skin *) skin), String(name));
 }
 
-spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin, const char * name) {
-    return (spine_clipping_attachment)((AttachmentLoader*)self)->newClippingAttachment(*((Skin*)skin), String(name));
+spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin, const char *name) {
+	AttachmentLoader *_self = (AttachmentLoader *) self;
+	return (spine_clipping_attachment) _self->newClippingAttachment(*((Skin *) skin), String(name));
 }

spine-c/src/generated/attachment_loader.h

@@ -10,12 +10,16 @@ extern "C" {
 
 SPINE_C_API void spine_attachment_loader_dispose(spine_attachment_loader self);
 
-SPINE_C_API spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence);
-SPINE_C_API spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char * name, const char * path, spine_sequence sequence);
-SPINE_C_API spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin, const char * name);
-SPINE_C_API spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char * name);
-SPINE_C_API spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char * name);
-SPINE_C_API spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin, const char * name);
+SPINE_C_API spine_region_attachment spine_attachment_loader_new_region_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
+																				  const char *path, spine_sequence sequence);
+SPINE_C_API spine_mesh_attachment spine_attachment_loader_new_mesh_attachment(spine_attachment_loader self, spine_skin skin, const char *name,
+																			  const char *path, spine_sequence sequence);
+SPINE_C_API spine_bounding_box_attachment spine_attachment_loader_new_bounding_box_attachment(spine_attachment_loader self, spine_skin skin,
+																							  const char *name);
+SPINE_C_API spine_path_attachment spine_attachment_loader_new_path_attachment(spine_attachment_loader self, spine_skin skin, const char *name);
+SPINE_C_API spine_point_attachment spine_attachment_loader_new_point_attachment(spine_attachment_loader self, spine_skin skin, const char *name);
+SPINE_C_API spine_clipping_attachment spine_attachment_loader_new_clipping_attachment(spine_attachment_loader self, spine_skin skin,
+																					  const char *name);
 
 #ifdef __cplusplus
 }

spine-c/src/generated/attachment_timeline.cpp

@@ -4,53 +4,65 @@
 using namespace spine;
 
 spine_attachment_timeline spine_attachment_timeline_create(size_t frameCount, int slotIndex) {
-    return (spine_attachment_timeline) new (__FILE__, __LINE__) AttachmentTimeline(frameCount, slotIndex);
+	return (spine_attachment_timeline) new (__FILE__, __LINE__) AttachmentTimeline(frameCount, slotIndex);
 }
 
 void spine_attachment_timeline_dispose(spine_attachment_timeline self) {
-    delete (AttachmentTimeline*)self;
+	delete (AttachmentTimeline *) self;
 }
 
 spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline self) {
-    return (spine_rtti)&((AttachmentTimeline*)self)->getRTTI();
+	AttachmentTimeline *_self = (AttachmentTimeline *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((AttachmentTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+									 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	AttachmentTimeline *_self = (AttachmentTimeline *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
-void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char * attachmentName) {
-    ((AttachmentTimeline*)self)->setFrame(frame, time, String(attachmentName));
+void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char *attachmentName) {
+	AttachmentTimeline *_self = (AttachmentTimeline *) self;
+	_self->setFrame(frame, time, String(attachmentName));
 }
 
 size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline self) {
-    return ((Timeline*)(AttachmentTimeline*)self)->getFrameEntries();
+	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
+	return _self->getFrameEntries();
 }
 
 size_t spine_attachment_timeline_get_frame_count(spine_attachment_timeline self) {
-    return ((Timeline*)(AttachmentTimeline*)self)->getFrameCount();
+	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_float spine_attachment_timeline_get_frames(spine_attachment_timeline self) {
-    return (spine_array_float)&((Timeline*)(AttachmentTimeline*)self)->getFrames();
+	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_attachment_timeline_get_duration(spine_attachment_timeline self) {
-    return ((Timeline*)(AttachmentTimeline*)self)->getDuration();
+	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_attachment_timeline_get_property_ids(spine_attachment_timeline self) {
-    return (spine_array_property_id)&((Timeline*)(AttachmentTimeline*)self)->getPropertyIds();
+	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 int spine_attachment_timeline_get_slot_index(spine_attachment_timeline self) {
-    return ((SlotTimeline*)(AttachmentTimeline*)self)->getSlotIndex();
+	SlotTimeline *_self = (SlotTimeline *) (AttachmentTimeline *) self;
+	return _self->getSlotIndex();
 }
 
 void spine_attachment_timeline_set_slot_index(spine_attachment_timeline self, int inValue) {
-    ((SlotTimeline*)(AttachmentTimeline*)self)->setSlotIndex(inValue);
+	SlotTimeline *_self = (SlotTimeline *) (AttachmentTimeline *) self;
+	_self->setSlotIndex(inValue);
 }
 
 spine_rtti spine_attachment_timeline_rtti(void) {
-    return (spine_rtti)&AttachmentTimeline::rtti;
+	return (spine_rtti) &AttachmentTimeline::rtti;
 }

spine-c/src/generated/attachment_timeline.h

@@ -13,8 +13,10 @@ SPINE_C_API spine_attachment_timeline spine_attachment_timeline_create(size_t fr
 SPINE_C_API void spine_attachment_timeline_dispose(spine_attachment_timeline self);
 
 SPINE_C_API spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline self);
-SPINE_C_API void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
-SPINE_C_API void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char * attachmentName);
+SPINE_C_API void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time,
+												 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+												 bool appliedPose);
+SPINE_C_API void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char *attachmentName);
 SPINE_C_API size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline self);
 SPINE_C_API size_t spine_attachment_timeline_get_frame_count(spine_attachment_timeline self);
 SPINE_C_API spine_array_float spine_attachment_timeline_get_frames(spine_attachment_timeline self);

spine-c/src/generated/attachment_type.h

@@ -6,13 +6,13 @@ extern "C" {
 #endif
 
 typedef enum spine_attachment_type {
-    SPINE_ATTACHMENT_TYPE_REGION,
-    SPINE_ATTACHMENT_TYPE_BOUNDINGBOX,
-    SPINE_ATTACHMENT_TYPE_MESH,
-    SPINE_ATTACHMENT_TYPE_LINKEDMESH,
-    SPINE_ATTACHMENT_TYPE_PATH,
-    SPINE_ATTACHMENT_TYPE_POINT,
-    SPINE_ATTACHMENT_TYPE_CLIPPING
+	SPINE_ATTACHMENT_TYPE_REGION,
+	SPINE_ATTACHMENT_TYPE_BOUNDINGBOX,
+	SPINE_ATTACHMENT_TYPE_MESH,
+	SPINE_ATTACHMENT_TYPE_LINKEDMESH,
+	SPINE_ATTACHMENT_TYPE_PATH,
+	SPINE_ATTACHMENT_TYPE_POINT,
+	SPINE_ATTACHMENT_TYPE_CLIPPING
 } spine_attachment_type;
 
 #ifdef __cplusplus

spine-c/src/generated/blend_mode.h

@@ -6,10 +6,10 @@ extern "C" {
 #endif
 
 typedef enum spine_blend_mode {
-    SPINE_BLEND_MODE_NORMAL = 0,
-    SPINE_BLEND_MODE_ADDITIVE,
-    SPINE_BLEND_MODE_MULTIPLY,
-    SPINE_BLEND_MODE_SCREEN
+	SPINE_BLEND_MODE_NORMAL = 0,
+	SPINE_BLEND_MODE_ADDITIVE,
+	SPINE_BLEND_MODE_MULTIPLY,
+	SPINE_BLEND_MODE_SCREEN
 } spine_blend_mode;
 
 #ifdef __cplusplus

spine-c/src/generated/bone.cpp

@@ -4,73 +4,85 @@
 using namespace spine;
 
 spine_bone spine_bone_create(spine_bone_data data, spine_bone parent) {
-    return (spine_bone) new (__FILE__, __LINE__) Bone(*((BoneData*)data), (Bone *)parent);
+	return (spine_bone) new (__FILE__, __LINE__) Bone(*((BoneData *) data), (Bone *) parent);
 }
 
 spine_bone spine_bone_create2(spine_bone bone, spine_bone parent) {
-    return (spine_bone) new (__FILE__, __LINE__) Bone(*((Bone*)bone), (Bone *)parent);
+	return (spine_bone) new (__FILE__, __LINE__) Bone(*((Bone *) bone), (Bone *) parent);
 }
 
 void spine_bone_dispose(spine_bone self) {
-    delete (Bone*)self;
+	delete (Bone *) self;
 }
 
 spine_rtti spine_bone_get_rtti(spine_bone self) {
-    return (spine_rtti)&((Bone*)self)->getRTTI();
+	Bone *_self = (Bone *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 spine_bone spine_bone_get_parent(spine_bone self) {
-    return (spine_bone)((Bone*)self)->getParent();
+	Bone *_self = (Bone *) self;
+	return (spine_bone) _self->getParent();
 }
 
 spine_array_bone spine_bone_get_children(spine_bone self) {
-    return (spine_array_bone)&((Bone*)self)->getChildren();
+	Bone *_self = (Bone *) self;
+	return (spine_array_bone) &_self->getChildren();
 }
 
 bool spine_bone_is_y_down(void) {
-    return Bone::isYDown();
+	return Bone::isYDown();
 }
 
 void spine_bone_set_y_down(bool value) {
-    Bone::setYDown(value);
+	Bone::setYDown(value);
 }
 
 void spine_bone_update(spine_bone self, spine_skeleton skeleton, spine_physics physics) {
-    ((Bone*)self)->update(*((Skeleton*)skeleton), (Physics)physics);
+	Bone *_self = (Bone *) self;
+	_self->update(*((Skeleton *) skeleton), (Physics) physics);
 }
 
 spine_bone_data spine_bone_get_data(spine_bone self) {
-    return (spine_bone_data)&((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->getData();
+	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	return (spine_bone_data) &_self->getData();
 }
 
 spine_bone_local spine_bone_get_pose(spine_bone self) {
-    return (spine_bone_local)&((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->getPose();
+	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	return (spine_bone_local) &_self->getPose();
 }
 
 spine_bone_pose spine_bone_get_applied_pose(spine_bone self) {
-    return (spine_bone_pose)&((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->getAppliedPose();
+	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	return (spine_bone_pose) &_self->getAppliedPose();
 }
 
 void spine_bone_reset_constrained(spine_bone self) {
-    ((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->resetConstrained();
+	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	_self->resetConstrained();
 }
 
 void spine_bone_constrained(spine_bone self) {
-    ((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->constrained();
+	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	_self->constrained();
 }
 
 bool spine_bone_is_pose_equal_to_applied(spine_bone self) {
-    return ((PosedGeneric<BoneData, BoneLocal, BonePose>*)(Bone*)self)->isPoseEqualToApplied();
+	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	return _self->isPoseEqualToApplied();
 }
 
 bool spine_bone_is_active(spine_bone self) {
-    return ((PosedActive*)(Bone*)self)->isActive();
+	PosedActive *_self = (PosedActive *) (Bone *) self;
+	return _self->isActive();
 }
 
 void spine_bone_set_active(spine_bone self, bool active) {
-    ((PosedActive*)(Bone*)self)->setActive(active);
+	PosedActive *_self = (PosedActive *) (Bone *) self;
+	_self->setActive(active);
 }
 
 spine_rtti spine_bone_rtti(void) {
-    return (spine_rtti)&Bone::rtti;
+	return (spine_rtti) &Bone::rtti;
 }

spine-c/src/generated/bone_data.cpp

@@ -3,62 +3,75 @@
 
 using namespace spine;
 
-spine_bone_data spine_bone_data_create(int index, const char * name, spine_bone_data parent) {
-    return (spine_bone_data) new (__FILE__, __LINE__) BoneData(index, String(name), (BoneData *)parent);
+spine_bone_data spine_bone_data_create(int index, const char *name, spine_bone_data parent) {
+	return (spine_bone_data) new (__FILE__, __LINE__) BoneData(index, String(name), (BoneData *) parent);
 }
 
 void spine_bone_data_dispose(spine_bone_data self) {
-    delete (BoneData*)self;
+	delete (BoneData *) self;
 }
 
 int spine_bone_data_get_index(spine_bone_data self) {
-    return ((BoneData*)self)->getIndex();
+	BoneData *_self = (BoneData *) self;
+	return _self->getIndex();
 }
 
 spine_bone_data spine_bone_data_get_parent(spine_bone_data self) {
-    return (spine_bone_data)((BoneData*)self)->getParent();
+	BoneData *_self = (BoneData *) self;
+	return (spine_bone_data) _self->getParent();
 }
 
 float spine_bone_data_get_length(spine_bone_data self) {
-    return ((BoneData*)self)->getLength();
+	BoneData *_self = (BoneData *) self;
+	return _self->getLength();
 }
 
 void spine_bone_data_set_length(spine_bone_data self, float inValue) {
-    ((BoneData*)self)->setLength(inValue);
+	BoneData *_self = (BoneData *) self;
+	_self->setLength(inValue);
 }
 
 spine_color spine_bone_data_get_color(spine_bone_data self) {
-    return (spine_color)&((BoneData*)self)->getColor();
+	BoneData *_self = (BoneData *) self;
+	return (spine_color) &_self->getColor();
 }
 
-const char * spine_bone_data_get_icon(spine_bone_data self) {
-    return ((BoneData*)self)->getIcon().buffer();
+const char *spine_bone_data_get_icon(spine_bone_data self) {
+	BoneData *_self = (BoneData *) self;
+	return _self->getIcon().buffer();
 }
 
-void spine_bone_data_set_icon(spine_bone_data self, const char * icon) {
-    ((BoneData*)self)->setIcon(String(icon));
+void spine_bone_data_set_icon(spine_bone_data self, const char *icon) {
+	BoneData *_self = (BoneData *) self;
+	_self->setIcon(String(icon));
 }
 
 bool spine_bone_data_get_visible(spine_bone_data self) {
-    return ((BoneData*)self)->getVisible();
+	BoneData *_self = (BoneData *) self;
+	return _self->getVisible();
 }
 
 void spine_bone_data_set_visible(spine_bone_data self, bool inValue) {
-    ((BoneData*)self)->setVisible(inValue);
+	BoneData *_self = (BoneData *) self;
+	_self->setVisible(inValue);
 }
 
 spine_bone_local spine_bone_data_get_setup_pose(spine_bone_data self) {
-    return (spine_bone_local)&((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->getSetupPose();
+	PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
+	return (spine_bone_local) &_self->getSetupPose();
 }
 
-const char * spine_bone_data_get_name(spine_bone_data self) {
-    return ((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->getName().buffer();
+const char *spine_bone_data_get_name(spine_bone_data self) {
+	PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
+	return _self->getName().buffer();
 }
 
 bool spine_bone_data_get_skin_required(spine_bone_data self) {
-    return ((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->getSkinRequired();
+	PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
+	return _self->getSkinRequired();
 }
 
 void spine_bone_data_set_skin_required(spine_bone_data self, bool skinRequired) {
-    ((PosedDataGeneric<BoneLocal>*)(BoneData*)self)->setSkinRequired(skinRequired);
+	PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
+	_self->setSkinRequired(skinRequired);
 }

spine-c/src/generated/bone_data.h

@@ -8,7 +8,7 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_bone_data spine_bone_data_create(int index, const char * name, spine_bone_data parent);
+SPINE_C_API spine_bone_data spine_bone_data_create(int index, const char *name, spine_bone_data parent);
 
 SPINE_C_API void spine_bone_data_dispose(spine_bone_data self);
 
@@ -17,12 +17,12 @@ SPINE_C_API spine_bone_data spine_bone_data_get_parent(spine_bone_data self);
 SPINE_C_API float spine_bone_data_get_length(spine_bone_data self);
 SPINE_C_API void spine_bone_data_set_length(spine_bone_data self, float inValue);
 SPINE_C_API spine_color spine_bone_data_get_color(spine_bone_data self);
-SPINE_C_API const char * spine_bone_data_get_icon(spine_bone_data self);
-SPINE_C_API void spine_bone_data_set_icon(spine_bone_data self, const char * icon);
+SPINE_C_API const char *spine_bone_data_get_icon(spine_bone_data self);
+SPINE_C_API void spine_bone_data_set_icon(spine_bone_data self, const char *icon);
 SPINE_C_API bool spine_bone_data_get_visible(spine_bone_data self);
 SPINE_C_API void spine_bone_data_set_visible(spine_bone_data self, bool inValue);
 SPINE_C_API spine_bone_local spine_bone_data_get_setup_pose(spine_bone_data self);
-SPINE_C_API const char * spine_bone_data_get_name(spine_bone_data self);
+SPINE_C_API const char *spine_bone_data_get_name(spine_bone_data self);
 SPINE_C_API bool spine_bone_data_get_skin_required(spine_bone_data self);
 SPINE_C_API void spine_bone_data_set_skin_required(spine_bone_data self, bool skinRequired);
 

spine-c/src/generated/bone_local.cpp

@@ -4,89 +4,109 @@
 using namespace spine;
 
 spine_bone_local spine_bone_local_create(void) {
-    return (spine_bone_local) new (__FILE__, __LINE__) BoneLocal();
+	return (spine_bone_local) new (__FILE__, __LINE__) BoneLocal();
 }
 
 void spine_bone_local_dispose(spine_bone_local self) {
-    delete (BoneLocal*)self;
+	delete (BoneLocal *) self;
 }
 
 void spine_bone_local_set(spine_bone_local self, spine_bone_local pose) {
-    ((BoneLocal*)self)->set(*((BoneLocal*)pose));
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->set(*((BoneLocal *) pose));
 }
 
 float spine_bone_local_get_x(spine_bone_local self) {
-    return ((BoneLocal*)self)->getX();
+	BoneLocal *_self = (BoneLocal *) self;
+	return _self->getX();
 }
 
 void spine_bone_local_set_x(spine_bone_local self, float x) {
-    ((BoneLocal*)self)->setX(x);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setX(x);
 }
 
 float spine_bone_local_get_y(spine_bone_local self) {
-    return ((BoneLocal*)self)->getY();
+	BoneLocal *_self = (BoneLocal *) self;
+	return _self->getY();
 }
 
 void spine_bone_local_set_y(spine_bone_local self, float y) {
-    ((BoneLocal*)self)->setY(y);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setY(y);
 }
 
 void spine_bone_local_set_position(spine_bone_local self, float x, float y) {
-    ((BoneLocal*)self)->setPosition(x, y);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setPosition(x, y);
 }
 
 float spine_bone_local_get_rotation(spine_bone_local self) {
-    return ((BoneLocal*)self)->getRotation();
+	BoneLocal *_self = (BoneLocal *) self;
+	return _self->getRotation();
 }
 
 void spine_bone_local_set_rotation(spine_bone_local self, float rotation) {
-    ((BoneLocal*)self)->setRotation(rotation);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setRotation(rotation);
 }
 
 float spine_bone_local_get_scale_x(spine_bone_local self) {
-    return ((BoneLocal*)self)->getScaleX();
+	BoneLocal *_self = (BoneLocal *) self;
+	return _self->getScaleX();
 }
 
 void spine_bone_local_set_scale_x(spine_bone_local self, float scaleX) {
-    ((BoneLocal*)self)->setScaleX(scaleX);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setScaleX(scaleX);
 }
 
 float spine_bone_local_get_scale_y(spine_bone_local self) {
-    return ((BoneLocal*)self)->getScaleY();
+	BoneLocal *_self = (BoneLocal *) self;
+	return _self->getScaleY();
 }
 
 void spine_bone_local_set_scale_y(spine_bone_local self, float scaleY) {
-    ((BoneLocal*)self)->setScaleY(scaleY);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setScaleY(scaleY);
 }
 
 void spine_bone_local_set_scale_1(spine_bone_local self, float scaleX, float scaleY) {
-    ((BoneLocal*)self)->setScale(scaleX, scaleY);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setScale(scaleX, scaleY);
 }
 
 void spine_bone_local_set_scale_2(spine_bone_local self, float scale) {
-    ((BoneLocal*)self)->setScale(scale);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setScale(scale);
 }
 
 float spine_bone_local_get_shear_x(spine_bone_local self) {
-    return ((BoneLocal*)self)->getShearX();
+	BoneLocal *_self = (BoneLocal *) self;
+	return _self->getShearX();
 }
 
 void spine_bone_local_set_shear_x(spine_bone_local self, float shearX) {
-    ((BoneLocal*)self)->setShearX(shearX);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setShearX(shearX);
 }
 
 float spine_bone_local_get_shear_y(spine_bone_local self) {
-    return ((BoneLocal*)self)->getShearY();
+	BoneLocal *_self = (BoneLocal *) self;
+	return _self->getShearY();
 }
 
 void spine_bone_local_set_shear_y(spine_bone_local self, float shearY) {
-    ((BoneLocal*)self)->setShearY(shearY);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setShearY(shearY);
 }
 
 spine_inherit spine_bone_local_get_inherit(spine_bone_local self) {
-    return (spine_inherit)((BoneLocal*)self)->getInherit();
+	BoneLocal *_self = (BoneLocal *) self;
+	return (spine_inherit) _self->getInherit();
 }
 
 void spine_bone_local_set_inherit(spine_bone_local self, spine_inherit inherit) {
-    ((BoneLocal*)self)->setInherit((Inherit)inherit);
+	BoneLocal *_self = (BoneLocal *) self;
+	_self->setInherit((Inherit) inherit);
 }

spine-c/src/generated/bone_pose.cpp

@@ -4,217 +4,268 @@
 using namespace spine;
 
 spine_bone_pose spine_bone_pose_create(void) {
-    return (spine_bone_pose) new (__FILE__, __LINE__) BonePose();
+	return (spine_bone_pose) new (__FILE__, __LINE__) BonePose();
 }
 
 void spine_bone_pose_dispose(spine_bone_pose self) {
-    delete (BonePose*)self;
+	delete (BonePose *) self;
 }
 
 void spine_bone_pose_update(spine_bone_pose self, spine_skeleton skeleton, spine_physics physics) {
-    ((BonePose*)self)->update(*((Skeleton*)skeleton), (Physics)physics);
+	BonePose *_self = (BonePose *) self;
+	_self->update(*((Skeleton *) skeleton), (Physics) physics);
 }
 
 void spine_bone_pose_update_world_transform(spine_bone_pose self, spine_skeleton skeleton) {
-    ((BonePose*)self)->updateWorldTransform(*((Skeleton*)skeleton));
+	BonePose *_self = (BonePose *) self;
+	_self->updateWorldTransform(*((Skeleton *) skeleton));
 }
 
 void spine_bone_pose_update_local_transform(spine_bone_pose self, spine_skeleton skeleton) {
-    ((BonePose*)self)->updateLocalTransform(*((Skeleton*)skeleton));
+	BonePose *_self = (BonePose *) self;
+	_self->updateLocalTransform(*((Skeleton *) skeleton));
 }
 
 void spine_bone_pose_validate_local_transform(spine_bone_pose self, spine_skeleton skeleton) {
-    ((BonePose*)self)->validateLocalTransform(*((Skeleton*)skeleton));
+	BonePose *_self = (BonePose *) self;
+	_self->validateLocalTransform(*((Skeleton *) skeleton));
 }
 
 void spine_bone_pose_modify_local(spine_bone_pose self, spine_skeleton skeleton) {
-    ((BonePose*)self)->modifyLocal(*((Skeleton*)skeleton));
+	BonePose *_self = (BonePose *) self;
+	_self->modifyLocal(*((Skeleton *) skeleton));
 }
 
 void spine_bone_pose_modify_world(spine_bone_pose self, int update) {
-    ((BonePose*)self)->modifyWorld(update);
+	BonePose *_self = (BonePose *) self;
+	_self->modifyWorld(update);
 }
 
 void spine_bone_pose_reset_world(spine_bone_pose self, int update) {
-    ((BonePose*)self)->resetWorld(update);
+	BonePose *_self = (BonePose *) self;
+	_self->resetWorld(update);
 }
 
 float spine_bone_pose_get_a(spine_bone_pose self) {
-    return ((BonePose*)self)->getA();
+	BonePose *_self = (BonePose *) self;
+	return _self->getA();
 }
 
 void spine_bone_pose_set_a(spine_bone_pose self, float a) {
-    ((BonePose*)self)->setA(a);
+	BonePose *_self = (BonePose *) self;
+	_self->setA(a);
 }
 
 float spine_bone_pose_get_b(spine_bone_pose self) {
-    return ((BonePose*)self)->getB();
+	BonePose *_self = (BonePose *) self;
+	return _self->getB();
 }
 
 void spine_bone_pose_set_b(spine_bone_pose self, float b) {
-    ((BonePose*)self)->setB(b);
+	BonePose *_self = (BonePose *) self;
+	_self->setB(b);
 }
 
 float spine_bone_pose_get_c(spine_bone_pose self) {
-    return ((BonePose*)self)->getC();
+	BonePose *_self = (BonePose *) self;
+	return _self->getC();
 }
 
 void spine_bone_pose_set_c(spine_bone_pose self, float c) {
-    ((BonePose*)self)->setC(c);
+	BonePose *_self = (BonePose *) self;
+	_self->setC(c);
 }
 
 float spine_bone_pose_get_d(spine_bone_pose self) {
-    return ((BonePose*)self)->getD();
+	BonePose *_self = (BonePose *) self;
+	return _self->getD();
 }
 
 void spine_bone_pose_set_d(spine_bone_pose self, float d) {
-    ((BonePose*)self)->setD(d);
+	BonePose *_self = (BonePose *) self;
+	_self->setD(d);
 }
 
 float spine_bone_pose_get_world_x(spine_bone_pose self) {
-    return ((BonePose*)self)->getWorldX();
+	BonePose *_self = (BonePose *) self;
+	return _self->getWorldX();
 }
 
 void spine_bone_pose_set_world_x(spine_bone_pose self, float worldX) {
-    ((BonePose*)self)->setWorldX(worldX);
+	BonePose *_self = (BonePose *) self;
+	_self->setWorldX(worldX);
 }
 
 float spine_bone_pose_get_world_y(spine_bone_pose self) {
-    return ((BonePose*)self)->getWorldY();
+	BonePose *_self = (BonePose *) self;
+	return _self->getWorldY();
 }
 
 void spine_bone_pose_set_world_y(spine_bone_pose self, float worldY) {
-    ((BonePose*)self)->setWorldY(worldY);
+	BonePose *_self = (BonePose *) self;
+	_self->setWorldY(worldY);
 }
 
 float spine_bone_pose_get_world_rotation_x(spine_bone_pose self) {
-    return ((BonePose*)self)->getWorldRotationX();
+	BonePose *_self = (BonePose *) self;
+	return _self->getWorldRotationX();
 }
 
 float spine_bone_pose_get_world_rotation_y(spine_bone_pose self) {
-    return ((BonePose*)self)->getWorldRotationY();
+	BonePose *_self = (BonePose *) self;
+	return _self->getWorldRotationY();
 }
 
 float spine_bone_pose_get_world_scale_x(spine_bone_pose self) {
-    return ((BonePose*)self)->getWorldScaleX();
+	BonePose *_self = (BonePose *) self;
+	return _self->getWorldScaleX();
 }
 
 float spine_bone_pose_get_world_scale_y(spine_bone_pose self) {
-    return ((BonePose*)self)->getWorldScaleY();
+	BonePose *_self = (BonePose *) self;
+	return _self->getWorldScaleY();
 }
 
-void spine_bone_pose_world_to_local(spine_bone_pose self, float worldX, float worldY, float * outLocalX, float * outLocalY) {
-    ((BonePose*)self)->worldToLocal(worldX, worldY, *outLocalX, *outLocalY);
+void spine_bone_pose_world_to_local(spine_bone_pose self, float worldX, float worldY, float *outLocalX, float *outLocalY) {
+	BonePose *_self = (BonePose *) self;
+	_self->worldToLocal(worldX, worldY, *outLocalX, *outLocalY);
 }
 
-void spine_bone_pose_local_to_world(spine_bone_pose self, float localX, float localY, float * outWorldX, float * outWorldY) {
-    ((BonePose*)self)->localToWorld(localX, localY, *outWorldX, *outWorldY);
+void spine_bone_pose_local_to_world(spine_bone_pose self, float localX, float localY, float *outWorldX, float *outWorldY) {
+	BonePose *_self = (BonePose *) self;
+	_self->localToWorld(localX, localY, *outWorldX, *outWorldY);
 }
 
-void spine_bone_pose_world_to_parent(spine_bone_pose self, float worldX, float worldY, float * outParentX, float * outParentY) {
-    ((BonePose*)self)->worldToParent(worldX, worldY, *outParentX, *outParentY);
+void spine_bone_pose_world_to_parent(spine_bone_pose self, float worldX, float worldY, float *outParentX, float *outParentY) {
+	BonePose *_self = (BonePose *) self;
+	_self->worldToParent(worldX, worldY, *outParentX, *outParentY);
 }
 
-void spine_bone_pose_parent_to_world(spine_bone_pose self, float parentX, float parentY, float * outWorldX, float * outWorldY) {
-    ((BonePose*)self)->parentToWorld(parentX, parentY, *outWorldX, *outWorldY);
+void spine_bone_pose_parent_to_world(spine_bone_pose self, float parentX, float parentY, float *outWorldX, float *outWorldY) {
+	BonePose *_self = (BonePose *) self;
+	_self->parentToWorld(parentX, parentY, *outWorldX, *outWorldY);
 }
 
 float spine_bone_pose_world_to_local_rotation(spine_bone_pose self, float worldRotation) {
-    return ((BonePose*)self)->worldToLocalRotation(worldRotation);
+	BonePose *_self = (BonePose *) self;
+	return _self->worldToLocalRotation(worldRotation);
 }
 
 float spine_bone_pose_local_to_world_rotation(spine_bone_pose self, float localRotation) {
-    return ((BonePose*)self)->localToWorldRotation(localRotation);
+	BonePose *_self = (BonePose *) self;
+	return _self->localToWorldRotation(localRotation);
 }
 
 void spine_bone_pose_rotate_world(spine_bone_pose self, float degrees) {
-    ((BonePose*)self)->rotateWorld(degrees);
+	BonePose *_self = (BonePose *) self;
+	_self->rotateWorld(degrees);
 }
 
 void spine_bone_pose_set(spine_bone_pose self, spine_bone_local pose) {
-    ((BoneLocal*)(BonePose*)self)->set(*((BoneLocal*)pose));
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->set(*((BoneLocal *) pose));
 }
 
 float spine_bone_pose_get_x(spine_bone_pose self) {
-    return ((BoneLocal*)(BonePose*)self)->getX();
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	return _self->getX();
 }
 
 void spine_bone_pose_set_x(spine_bone_pose self, float x) {
-    ((BoneLocal*)(BonePose*)self)->setX(x);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setX(x);
 }
 
 float spine_bone_pose_get_y(spine_bone_pose self) {
-    return ((BoneLocal*)(BonePose*)self)->getY();
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	return _self->getY();
 }
 
 void spine_bone_pose_set_y(spine_bone_pose self, float y) {
-    ((BoneLocal*)(BonePose*)self)->setY(y);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setY(y);
 }
 
 void spine_bone_pose_set_position(spine_bone_pose self, float x, float y) {
-    ((BoneLocal*)(BonePose*)self)->setPosition(x, y);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setPosition(x, y);
 }
 
 float spine_bone_pose_get_rotation(spine_bone_pose self) {
-    return ((BoneLocal*)(BonePose*)self)->getRotation();
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	return _self->getRotation();
 }
 
 void spine_bone_pose_set_rotation(spine_bone_pose self, float rotation) {
-    ((BoneLocal*)(BonePose*)self)->setRotation(rotation);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setRotation(rotation);
 }
 
 float spine_bone_pose_get_scale_x(spine_bone_pose self) {
-    return ((BoneLocal*)(BonePose*)self)->getScaleX();
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	return _self->getScaleX();
 }
 
 void spine_bone_pose_set_scale_x(spine_bone_pose self, float scaleX) {
-    ((BoneLocal*)(BonePose*)self)->setScaleX(scaleX);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setScaleX(scaleX);
 }
 
 float spine_bone_pose_get_scale_y(spine_bone_pose self) {
-    return ((BoneLocal*)(BonePose*)self)->getScaleY();
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	return _self->getScaleY();
 }
 
 void spine_bone_pose_set_scale_y(spine_bone_pose self, float scaleY) {
-    ((BoneLocal*)(BonePose*)self)->setScaleY(scaleY);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setScaleY(scaleY);
 }
 
 void spine_bone_pose_set_scale_1(spine_bone_pose self, float scaleX, float scaleY) {
-    ((BoneLocal*)(BonePose*)self)->setScale(scaleX, scaleY);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setScale(scaleX, scaleY);
 }
 
 void spine_bone_pose_set_scale_2(spine_bone_pose self, float scale) {
-    ((BoneLocal*)(BonePose*)self)->setScale(scale);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setScale(scale);
 }
 
 float spine_bone_pose_get_shear_x(spine_bone_pose self) {
-    return ((BoneLocal*)(BonePose*)self)->getShearX();
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	return _self->getShearX();
 }
 
 void spine_bone_pose_set_shear_x(spine_bone_pose self, float shearX) {
-    ((BoneLocal*)(BonePose*)self)->setShearX(shearX);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setShearX(shearX);
 }
 
 float spine_bone_pose_get_shear_y(spine_bone_pose self) {
-    return ((BoneLocal*)(BonePose*)self)->getShearY();
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	return _self->getShearY();
 }
 
 void spine_bone_pose_set_shear_y(spine_bone_pose self, float shearY) {
-    ((BoneLocal*)(BonePose*)self)->setShearY(shearY);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setShearY(shearY);
 }
 
 spine_inherit spine_bone_pose_get_inherit(spine_bone_pose self) {
-    return (spine_inherit)((BoneLocal*)(BonePose*)self)->getInherit();
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	return (spine_inherit) _self->getInherit();
 }
 
 void spine_bone_pose_set_inherit(spine_bone_pose self, spine_inherit inherit) {
-    ((BoneLocal*)(BonePose*)self)->setInherit((Inherit)inherit);
+	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	_self->setInherit((Inherit) inherit);
 }
 
 spine_rtti spine_bone_pose_get_rtti(spine_bone_pose self) {
-    return (spine_rtti)&((Update*)(BonePose*)self)->getRTTI();
+	Update *_self = (Update *) (BonePose *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 spine_rtti spine_bone_pose_rtti(void) {
-    return (spine_rtti)&BonePose::rtti;
+	return (spine_rtti) &BonePose::rtti;
 }

spine-c/src/generated/bone_pose.h

@@ -35,10 +35,10 @@ SPINE_C_API float spine_bone_pose_get_world_rotation_x(spine_bone_pose self);
 SPINE_C_API float spine_bone_pose_get_world_rotation_y(spine_bone_pose self);
 SPINE_C_API float spine_bone_pose_get_world_scale_x(spine_bone_pose self);
 SPINE_C_API float spine_bone_pose_get_world_scale_y(spine_bone_pose self);
-SPINE_C_API void spine_bone_pose_world_to_local(spine_bone_pose self, float worldX, float worldY, float * outLocalX, float * outLocalY);
-SPINE_C_API void spine_bone_pose_local_to_world(spine_bone_pose self, float localX, float localY, float * outWorldX, float * outWorldY);
-SPINE_C_API void spine_bone_pose_world_to_parent(spine_bone_pose self, float worldX, float worldY, float * outParentX, float * outParentY);
-SPINE_C_API void spine_bone_pose_parent_to_world(spine_bone_pose self, float parentX, float parentY, float * outWorldX, float * outWorldY);
+SPINE_C_API void spine_bone_pose_world_to_local(spine_bone_pose self, float worldX, float worldY, float *outLocalX, float *outLocalY);
+SPINE_C_API void spine_bone_pose_local_to_world(spine_bone_pose self, float localX, float localY, float *outWorldX, float *outWorldY);
+SPINE_C_API void spine_bone_pose_world_to_parent(spine_bone_pose self, float worldX, float worldY, float *outParentX, float *outParentY);
+SPINE_C_API void spine_bone_pose_parent_to_world(spine_bone_pose self, float parentX, float parentY, float *outWorldX, float *outWorldY);
 SPINE_C_API float spine_bone_pose_world_to_local_rotation(spine_bone_pose self, float worldRotation);
 SPINE_C_API float spine_bone_pose_local_to_world_rotation(spine_bone_pose self, float localRotation);
 SPINE_C_API void spine_bone_pose_rotate_world(spine_bone_pose self, float degrees);

spine-c/src/generated/bone_timeline.cpp

@@ -4,21 +4,24 @@
 using namespace spine;
 
 void spine_bone_timeline_dispose(spine_bone_timeline self) {
-    delete (BoneTimeline*)self;
+	delete (BoneTimeline *) self;
 }
 
 spine_rtti spine_bone_timeline_get_rtti(spine_bone_timeline self) {
-    return (spine_rtti)&((BoneTimeline*)self)->getRTTI();
+	BoneTimeline *_self = (BoneTimeline *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 int spine_bone_timeline_get_bone_index(spine_bone_timeline self) {
-    return ((BoneTimeline*)self)->getBoneIndex();
+	BoneTimeline *_self = (BoneTimeline *) self;
+	return _self->getBoneIndex();
 }
 
 void spine_bone_timeline_set_bone_index(spine_bone_timeline self, int inValue) {
-    ((BoneTimeline*)self)->setBoneIndex(inValue);
+	BoneTimeline *_self = (BoneTimeline *) self;
+	_self->setBoneIndex(inValue);
 }
 
 spine_rtti spine_bone_timeline_rtti(void) {
-    return (spine_rtti)&BoneTimeline::rtti;
+	return (spine_rtti) &BoneTimeline::rtti;
 }

spine-c/src/generated/bone_timeline1.cpp

@@ -4,89 +4,115 @@
 using namespace spine;
 
 void spine_bone_timeline1_dispose(spine_bone_timeline1 self) {
-    delete (BoneTimeline1*)self;
+	delete (BoneTimeline1 *) self;
 }
 
 spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self) {
-    return (spine_rtti)&((BoneTimeline1*)self)->getRTTI();
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((BoneTimeline1*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 void spine_bone_timeline1_set_frame(spine_bone_timeline1 self, size_t frame, float time, float value) {
-    ((CurveTimeline1*)(BoneTimeline1*)self)->setFrame(frame, time, value);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	_self->setFrame(frame, time, value);
 }
 
 float spine_bone_timeline1_get_curve_value(spine_bone_timeline1 self, float time) {
-    return ((CurveTimeline1*)(BoneTimeline1*)self)->getCurveValue(time);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return _self->getCurveValue(time);
 }
 
 float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
-    return ((CurveTimeline1*)(BoneTimeline1*)self)->getRelativeValue(time, alpha, (MixBlend)blend, current, setup);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
-float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
-    return ((CurveTimeline1*)(BoneTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup);
+float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+												float setup) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
-float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) {
-    return ((CurveTimeline1*)(BoneTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup, value);
+float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup,
+												float value) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
-float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-    return ((CurveTimeline1*)(BoneTimeline1*)self)->getScaleValue(time, alpha, (MixBlend)blend, (MixDirection)direction, current, setup);
+float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+										   float current, float setup) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_bone_timeline1_set_linear(spine_bone_timeline1 self, size_t frame) {
-    ((CurveTimeline1*)(BoneTimeline1*)self)->setLinear(frame);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	_self->setLinear(frame);
 }
 
 void spine_bone_timeline1_set_stepped(spine_bone_timeline1 self, size_t frame) {
-    ((CurveTimeline1*)(BoneTimeline1*)self)->setStepped(frame);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	_self->setStepped(frame);
 }
 
-void spine_bone_timeline1_set_bezier(spine_bone_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
-    ((CurveTimeline1*)(BoneTimeline1*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+void spine_bone_timeline1_set_bezier(spine_bone_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
+									 float cy1, float cx2, float cy2, float time2, float value2) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_bone_timeline1_get_bezier_value(spine_bone_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i) {
-    return ((CurveTimeline1*)(BoneTimeline1*)self)->getBezierValue(time, frame, valueOffset, i);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_bone_timeline1_get_curves(spine_bone_timeline1 self) {
-    return (spine_array_float)&((CurveTimeline1*)(BoneTimeline1*)self)->getCurves();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_bone_timeline1_get_frame_entries(spine_bone_timeline1 self) {
-    return ((CurveTimeline1*)(BoneTimeline1*)self)->getFrameEntries();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return _self->getFrameEntries();
 }
 
 size_t spine_bone_timeline1_get_frame_count(spine_bone_timeline1 self) {
-    return ((CurveTimeline1*)(BoneTimeline1*)self)->getFrameCount();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_float spine_bone_timeline1_get_frames(spine_bone_timeline1 self) {
-    return (spine_array_float)&((CurveTimeline1*)(BoneTimeline1*)self)->getFrames();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_bone_timeline1_get_duration(spine_bone_timeline1 self) {
-    return ((CurveTimeline1*)(BoneTimeline1*)self)->getDuration();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_bone_timeline1_get_property_ids(spine_bone_timeline1 self) {
-    return (spine_array_property_id)&((CurveTimeline1*)(BoneTimeline1*)self)->getPropertyIds();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 int spine_bone_timeline1_get_bone_index(spine_bone_timeline1 self) {
-    return ((BoneTimeline*)(BoneTimeline1*)self)->getBoneIndex();
+	BoneTimeline *_self = (BoneTimeline *) (BoneTimeline1 *) self;
+	return _self->getBoneIndex();
 }
 
 void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 self, int inValue) {
-    ((BoneTimeline*)(BoneTimeline1*)self)->setBoneIndex(inValue);
+	BoneTimeline *_self = (BoneTimeline *) (BoneTimeline1 *) self;
+	_self->setBoneIndex(inValue);
 }
 
 spine_rtti spine_bone_timeline1_rtti(void) {
-    return (spine_rtti)&BoneTimeline1::rtti;
+	return (spine_rtti) &BoneTimeline1::rtti;
 }

spine-c/src/generated/bone_timeline1.h

@@ -11,16 +11,22 @@ extern "C" {
 SPINE_C_API void spine_bone_timeline1_dispose(spine_bone_timeline1 self);
 
 SPINE_C_API spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self);
-SPINE_C_API void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
 SPINE_C_API void spine_bone_timeline1_set_frame(spine_bone_timeline1 self, size_t frame, float time, float value);
 SPINE_C_API float spine_bone_timeline1_get_curve_value(spine_bone_timeline1 self, float time);
-SPINE_C_API float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
-SPINE_C_API float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
-SPINE_C_API float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value);
-SPINE_C_API float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup);
+SPINE_C_API float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+														  float setup);
+SPINE_C_API float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+															float setup);
+SPINE_C_API float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+															float setup, float value);
+SPINE_C_API float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend,
+													   spine_mix_direction direction, float current, float setup);
 SPINE_C_API void spine_bone_timeline1_set_linear(spine_bone_timeline1 self, size_t frame);
 SPINE_C_API void spine_bone_timeline1_set_stepped(spine_bone_timeline1 self, size_t frame);
-SPINE_C_API void spine_bone_timeline1_set_bezier(spine_bone_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
+SPINE_C_API void spine_bone_timeline1_set_bezier(spine_bone_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1,
+												 float cx1, float cy1, float cx2, float cy2, float time2, float value2);
 SPINE_C_API float spine_bone_timeline1_get_bezier_value(spine_bone_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i);
 SPINE_C_API spine_array_float spine_bone_timeline1_get_curves(spine_bone_timeline1 self);
 SPINE_C_API size_t spine_bone_timeline1_get_frame_entries(spine_bone_timeline1 self);

spine-c/src/generated/bone_timeline2.cpp

@@ -4,73 +4,92 @@
 using namespace spine;
 
 void spine_bone_timeline2_dispose(spine_bone_timeline2 self) {
-    delete (BoneTimeline2*)self;
+	delete (BoneTimeline2 *) self;
 }
 
 spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self) {
-    return (spine_rtti)&((BoneTimeline2*)self)->getRTTI();
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((BoneTimeline2*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 void spine_bone_timeline2_set_frame(spine_bone_timeline2 self, size_t frame, float time, float value1, float value2) {
-    ((CurveTimeline2*)(BoneTimeline2*)self)->setFrame(frame, time, value1, value2);
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	_self->setFrame(frame, time, value1, value2);
 }
 
 float spine_bone_timeline2_get_curve_value(spine_bone_timeline2 self, float time) {
-    return ((CurveTimeline2*)(BoneTimeline2*)self)->getCurveValue(time);
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	return _self->getCurveValue(time);
 }
 
 void spine_bone_timeline2_set_linear(spine_bone_timeline2 self, size_t frame) {
-    ((CurveTimeline2*)(BoneTimeline2*)self)->setLinear(frame);
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	_self->setLinear(frame);
 }
 
 void spine_bone_timeline2_set_stepped(spine_bone_timeline2 self, size_t frame) {
-    ((CurveTimeline2*)(BoneTimeline2*)self)->setStepped(frame);
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	_self->setStepped(frame);
 }
 
-void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
-    ((CurveTimeline2*)(BoneTimeline2*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
+									 float cy1, float cx2, float cy2, float time2, float value2) {
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_bone_timeline2_get_bezier_value(spine_bone_timeline2 self, float time, size_t frame, size_t valueOffset, size_t i) {
-    return ((CurveTimeline2*)(BoneTimeline2*)self)->getBezierValue(time, frame, valueOffset, i);
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_bone_timeline2_get_curves(spine_bone_timeline2 self) {
-    return (spine_array_float)&((CurveTimeline2*)(BoneTimeline2*)self)->getCurves();
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_bone_timeline2_get_frame_entries(spine_bone_timeline2 self) {
-    return ((CurveTimeline2*)(BoneTimeline2*)self)->getFrameEntries();
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	return _self->getFrameEntries();
 }
 
 size_t spine_bone_timeline2_get_frame_count(spine_bone_timeline2 self) {
-    return ((CurveTimeline2*)(BoneTimeline2*)self)->getFrameCount();
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_float spine_bone_timeline2_get_frames(spine_bone_timeline2 self) {
-    return (spine_array_float)&((CurveTimeline2*)(BoneTimeline2*)self)->getFrames();
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_bone_timeline2_get_duration(spine_bone_timeline2 self) {
-    return ((CurveTimeline2*)(BoneTimeline2*)self)->getDuration();
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_bone_timeline2_get_property_ids(spine_bone_timeline2 self) {
-    return (spine_array_property_id)&((CurveTimeline2*)(BoneTimeline2*)self)->getPropertyIds();
+	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 int spine_bone_timeline2_get_bone_index(spine_bone_timeline2 self) {
-    return ((BoneTimeline*)(BoneTimeline2*)self)->getBoneIndex();
+	BoneTimeline *_self = (BoneTimeline *) (BoneTimeline2 *) self;
+	return _self->getBoneIndex();
 }
 
 void spine_bone_timeline2_set_bone_index(spine_bone_timeline2 self, int inValue) {
-    ((BoneTimeline*)(BoneTimeline2*)self)->setBoneIndex(inValue);
+	BoneTimeline *_self = (BoneTimeline *) (BoneTimeline2 *) self;
+	_self->setBoneIndex(inValue);
 }
 
 spine_rtti spine_bone_timeline2_rtti(void) {
-    return (spine_rtti)&BoneTimeline2::rtti;
+	return (spine_rtti) &BoneTimeline2::rtti;
 }

spine-c/src/generated/bone_timeline2.h

@@ -11,12 +11,14 @@ extern "C" {
 SPINE_C_API void spine_bone_timeline2_dispose(spine_bone_timeline2 self);
 
 SPINE_C_API spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self);
-SPINE_C_API void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
 SPINE_C_API void spine_bone_timeline2_set_frame(spine_bone_timeline2 self, size_t frame, float time, float value1, float value2);
 SPINE_C_API float spine_bone_timeline2_get_curve_value(spine_bone_timeline2 self, float time);
 SPINE_C_API void spine_bone_timeline2_set_linear(spine_bone_timeline2 self, size_t frame);
 SPINE_C_API void spine_bone_timeline2_set_stepped(spine_bone_timeline2 self, size_t frame);
-SPINE_C_API void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
+SPINE_C_API void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1,
+												 float cx1, float cy1, float cx2, float cy2, float time2, float value2);
 SPINE_C_API float spine_bone_timeline2_get_bezier_value(spine_bone_timeline2 self, float time, size_t frame, size_t valueOffset, size_t i);
 SPINE_C_API spine_array_float spine_bone_timeline2_get_curves(spine_bone_timeline2 self);
 SPINE_C_API size_t spine_bone_timeline2_get_frame_entries(spine_bone_timeline2 self);

spine-c/src/generated/bounding_box_attachment.cpp

@@ -3,90 +3,112 @@
 
 using namespace spine;
 
-spine_bounding_box_attachment spine_bounding_box_attachment_create(const char * name) {
-    return (spine_bounding_box_attachment) new (__FILE__, __LINE__) BoundingBoxAttachment(String(name));
+spine_bounding_box_attachment spine_bounding_box_attachment_create(const char *name) {
+	return (spine_bounding_box_attachment) new (__FILE__, __LINE__) BoundingBoxAttachment(String(name));
 }
 
 void spine_bounding_box_attachment_dispose(spine_bounding_box_attachment self) {
-    delete (BoundingBoxAttachment*)self;
+	delete (BoundingBoxAttachment *) self;
 }
 
 spine_rtti spine_bounding_box_attachment_get_rtti(spine_bounding_box_attachment self) {
-    return (spine_rtti)&((BoundingBoxAttachment*)self)->getRTTI();
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment self) {
-    return (spine_color)&((BoundingBoxAttachment*)self)->getColor();
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
+	return (spine_color) &_self->getColor();
 }
 
 spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachment self) {
-    return (spine_attachment)((BoundingBoxAttachment*)self)->copy();
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
+	return (spine_attachment) _self->copy();
 }
 
-void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, float * worldVertices, size_t offset, size_t stride) {
-    ((VertexAttachment*)(BoundingBoxAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, worldVertices, offset, stride);
+void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
+															size_t start, size_t count, float *worldVertices, size_t offset, size_t stride) {
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
 }
 
-void spine_bounding_box_attachment_compute_world_vertices_2(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, spine_array_float worldVertices, size_t offset, size_t stride) {
-    ((VertexAttachment*)(BoundingBoxAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, *((Array<float>*)worldVertices), offset, stride);
+void spine_bounding_box_attachment_compute_world_vertices_2(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
+															size_t start, size_t count, spine_array_float worldVertices, size_t offset,
+															size_t stride) {
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, *((Array<float> *) worldVertices), offset, stride);
 }
 
 int spine_bounding_box_attachment_get_id(spine_bounding_box_attachment self) {
-    return ((VertexAttachment*)(BoundingBoxAttachment*)self)->getId();
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	return _self->getId();
 }
 
 spine_array_int spine_bounding_box_attachment_get_bones(spine_bounding_box_attachment self) {
-    return (spine_array_int)&((VertexAttachment*)(BoundingBoxAttachment*)self)->getBones();
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	return (spine_array_int) &_self->getBones();
 }
 
 void spine_bounding_box_attachment_set_bones(spine_bounding_box_attachment self, spine_array_int bones) {
-    ((VertexAttachment*)(BoundingBoxAttachment*)self)->setBones(*((Array<int>*)bones));
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	_self->setBones(*((Array<int> *) bones));
 }
 
 spine_array_float spine_bounding_box_attachment_get_vertices(spine_bounding_box_attachment self) {
-    return (spine_array_float)&((VertexAttachment*)(BoundingBoxAttachment*)self)->getVertices();
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	return (spine_array_float) &_self->getVertices();
 }
 
 void spine_bounding_box_attachment_set_vertices(spine_bounding_box_attachment self, spine_array_float vertices) {
-    ((VertexAttachment*)(BoundingBoxAttachment*)self)->setVertices(*((Array<float>*)vertices));
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	_self->setVertices(*((Array<float> *) vertices));
 }
 
 size_t spine_bounding_box_attachment_get_world_vertices_length(spine_bounding_box_attachment self) {
-    return ((VertexAttachment*)(BoundingBoxAttachment*)self)->getWorldVerticesLength();
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	return _self->getWorldVerticesLength();
 }
 
 void spine_bounding_box_attachment_set_world_vertices_length(spine_bounding_box_attachment self, size_t inValue) {
-    ((VertexAttachment*)(BoundingBoxAttachment*)self)->setWorldVerticesLength(inValue);
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	_self->setWorldVerticesLength(inValue);
 }
 
 spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self) {
-    return (spine_attachment)((VertexAttachment*)(BoundingBoxAttachment*)self)->getTimelineAttachment();
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	return (spine_attachment) _self->getTimelineAttachment();
 }
 
 void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, spine_attachment attachment) {
-    ((VertexAttachment*)(BoundingBoxAttachment*)self)->setTimelineAttachment((Attachment *)attachment);
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	_self->setTimelineAttachment((Attachment *) attachment);
 }
 
 void spine_bounding_box_attachment_copy_to(spine_bounding_box_attachment self, spine_vertex_attachment other) {
-    ((VertexAttachment*)(BoundingBoxAttachment*)self)->copyTo((VertexAttachment *)other);
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	_self->copyTo((VertexAttachment *) other);
 }
 
-const char * spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self) {
-    return ((VertexAttachment*)(BoundingBoxAttachment*)self)->getName().buffer();
+const char *spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self) {
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	return _self->getName().buffer();
 }
 
 int spine_bounding_box_attachment_get_ref_count(spine_bounding_box_attachment self) {
-    return ((VertexAttachment*)(BoundingBoxAttachment*)self)->getRefCount();
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	return _self->getRefCount();
 }
 
 void spine_bounding_box_attachment_reference(spine_bounding_box_attachment self) {
-    ((VertexAttachment*)(BoundingBoxAttachment*)self)->reference();
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	_self->reference();
 }
 
 void spine_bounding_box_attachment_dereference(spine_bounding_box_attachment self) {
-    ((VertexAttachment*)(BoundingBoxAttachment*)self)->dereference();
+	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	_self->dereference();
 }
 
 spine_rtti spine_bounding_box_attachment_rtti(void) {
-    return (spine_rtti)&BoundingBoxAttachment::rtti;
+	return (spine_rtti) &BoundingBoxAttachment::rtti;
 }

spine-c/src/generated/bounding_box_attachment.h

@@ -8,15 +8,19 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_bounding_box_attachment spine_bounding_box_attachment_create(const char * name);
+SPINE_C_API spine_bounding_box_attachment spine_bounding_box_attachment_create(const char *name);
 
 SPINE_C_API void spine_bounding_box_attachment_dispose(spine_bounding_box_attachment self);
 
 SPINE_C_API spine_rtti spine_bounding_box_attachment_get_rtti(spine_bounding_box_attachment self);
 SPINE_C_API spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment self);
 SPINE_C_API spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachment self);
-SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, float * worldVertices, size_t offset, size_t stride);
-SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_2(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, spine_array_float worldVertices, size_t offset, size_t stride);
+SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
+																		size_t start, size_t count, float *worldVertices, size_t offset,
+																		size_t stride);
+SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_2(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
+																		size_t start, size_t count, spine_array_float worldVertices, size_t offset,
+																		size_t stride);
 SPINE_C_API int spine_bounding_box_attachment_get_id(spine_bounding_box_attachment self);
 SPINE_C_API spine_array_int spine_bounding_box_attachment_get_bones(spine_bounding_box_attachment self);
 SPINE_C_API void spine_bounding_box_attachment_set_bones(spine_bounding_box_attachment self, spine_array_int bones);
@@ -27,7 +31,7 @@ SPINE_C_API void spine_bounding_box_attachment_set_world_vertices_length(spine_b
 SPINE_C_API spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self);
 SPINE_C_API void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, spine_attachment attachment);
 SPINE_C_API void spine_bounding_box_attachment_copy_to(spine_bounding_box_attachment self, spine_vertex_attachment other);
-SPINE_C_API const char * spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self);
+SPINE_C_API const char *spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self);
 SPINE_C_API int spine_bounding_box_attachment_get_ref_count(spine_bounding_box_attachment self);
 SPINE_C_API void spine_bounding_box_attachment_reference(spine_bounding_box_attachment self);
 SPINE_C_API void spine_bounding_box_attachment_dereference(spine_bounding_box_attachment self);

spine-c/src/generated/clipping_attachment.cpp

@@ -3,98 +3,121 @@
 
 using namespace spine;
 
-spine_clipping_attachment spine_clipping_attachment_create(const char * name) {
-    return (spine_clipping_attachment) new (__FILE__, __LINE__) ClippingAttachment(String(name));
+spine_clipping_attachment spine_clipping_attachment_create(const char *name) {
+	return (spine_clipping_attachment) new (__FILE__, __LINE__) ClippingAttachment(String(name));
 }
 
 void spine_clipping_attachment_dispose(spine_clipping_attachment self) {
-    delete (ClippingAttachment*)self;
+	delete (ClippingAttachment *) self;
 }
 
 spine_rtti spine_clipping_attachment_get_rtti(spine_clipping_attachment self) {
-    return (spine_rtti)&((ClippingAttachment*)self)->getRTTI();
+	ClippingAttachment *_self = (ClippingAttachment *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self) {
-    return (spine_slot_data)((ClippingAttachment*)self)->getEndSlot();
+	ClippingAttachment *_self = (ClippingAttachment *) self;
+	return (spine_slot_data) _self->getEndSlot();
 }
 
 void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, spine_slot_data inValue) {
-    ((ClippingAttachment*)self)->setEndSlot((SlotData *)inValue);
+	ClippingAttachment *_self = (ClippingAttachment *) self;
+	_self->setEndSlot((SlotData *) inValue);
 }
 
 spine_color spine_clipping_attachment_get_color(spine_clipping_attachment self) {
-    return (spine_color)&((ClippingAttachment*)self)->getColor();
+	ClippingAttachment *_self = (ClippingAttachment *) self;
+	return (spine_color) &_self->getColor();
 }
 
 spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment self) {
-    return (spine_attachment)((ClippingAttachment*)self)->copy();
+	ClippingAttachment *_self = (ClippingAttachment *) self;
+	return (spine_attachment) _self->copy();
 }
 
-void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, float * worldVertices, size_t offset, size_t stride) {
-    ((VertexAttachment*)(ClippingAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, worldVertices, offset, stride);
+void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
+														size_t count, float *worldVertices, size_t offset, size_t stride) {
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
 }
 
-void spine_clipping_attachment_compute_world_vertices_2(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, spine_array_float worldVertices, size_t offset, size_t stride) {
-    ((VertexAttachment*)(ClippingAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, *((Array<float>*)worldVertices), offset, stride);
+void spine_clipping_attachment_compute_world_vertices_2(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
+														size_t count, spine_array_float worldVertices, size_t offset, size_t stride) {
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, *((Array<float> *) worldVertices), offset, stride);
 }
 
 int spine_clipping_attachment_get_id(spine_clipping_attachment self) {
-    return ((VertexAttachment*)(ClippingAttachment*)self)->getId();
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	return _self->getId();
 }
 
 spine_array_int spine_clipping_attachment_get_bones(spine_clipping_attachment self) {
-    return (spine_array_int)&((VertexAttachment*)(ClippingAttachment*)self)->getBones();
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	return (spine_array_int) &_self->getBones();
 }
 
 void spine_clipping_attachment_set_bones(spine_clipping_attachment self, spine_array_int bones) {
-    ((VertexAttachment*)(ClippingAttachment*)self)->setBones(*((Array<int>*)bones));
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	_self->setBones(*((Array<int> *) bones));
 }
 
 spine_array_float spine_clipping_attachment_get_vertices(spine_clipping_attachment self) {
-    return (spine_array_float)&((VertexAttachment*)(ClippingAttachment*)self)->getVertices();
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	return (spine_array_float) &_self->getVertices();
 }
 
 void spine_clipping_attachment_set_vertices(spine_clipping_attachment self, spine_array_float vertices) {
-    ((VertexAttachment*)(ClippingAttachment*)self)->setVertices(*((Array<float>*)vertices));
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	_self->setVertices(*((Array<float> *) vertices));
 }
 
 size_t spine_clipping_attachment_get_world_vertices_length(spine_clipping_attachment self) {
-    return ((VertexAttachment*)(ClippingAttachment*)self)->getWorldVerticesLength();
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	return _self->getWorldVerticesLength();
 }
 
 void spine_clipping_attachment_set_world_vertices_length(spine_clipping_attachment self, size_t inValue) {
-    ((VertexAttachment*)(ClippingAttachment*)self)->setWorldVerticesLength(inValue);
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	_self->setWorldVerticesLength(inValue);
 }
 
 spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self) {
-    return (spine_attachment)((VertexAttachment*)(ClippingAttachment*)self)->getTimelineAttachment();
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	return (spine_attachment) _self->getTimelineAttachment();
 }
 
 void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, spine_attachment attachment) {
-    ((VertexAttachment*)(ClippingAttachment*)self)->setTimelineAttachment((Attachment *)attachment);
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	_self->setTimelineAttachment((Attachment *) attachment);
 }
 
 void spine_clipping_attachment_copy_to(spine_clipping_attachment self, spine_vertex_attachment other) {
-    ((VertexAttachment*)(ClippingAttachment*)self)->copyTo((VertexAttachment *)other);
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	_self->copyTo((VertexAttachment *) other);
 }
 
-const char * spine_clipping_attachment_get_name(spine_clipping_attachment self) {
-    return ((VertexAttachment*)(ClippingAttachment*)self)->getName().buffer();
+const char *spine_clipping_attachment_get_name(spine_clipping_attachment self) {
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	return _self->getName().buffer();
 }
 
 int spine_clipping_attachment_get_ref_count(spine_clipping_attachment self) {
-    return ((VertexAttachment*)(ClippingAttachment*)self)->getRefCount();
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	return _self->getRefCount();
 }
 
 void spine_clipping_attachment_reference(spine_clipping_attachment self) {
-    ((VertexAttachment*)(ClippingAttachment*)self)->reference();
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	_self->reference();
 }
 
 void spine_clipping_attachment_dereference(spine_clipping_attachment self) {
-    ((VertexAttachment*)(ClippingAttachment*)self)->dereference();
+	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	_self->dereference();
 }
 
 spine_rtti spine_clipping_attachment_rtti(void) {
-    return (spine_rtti)&ClippingAttachment::rtti;
+	return (spine_rtti) &ClippingAttachment::rtti;
 }

spine-c/src/generated/clipping_attachment.h

@@ -8,7 +8,7 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_clipping_attachment spine_clipping_attachment_create(const char * name);
+SPINE_C_API spine_clipping_attachment spine_clipping_attachment_create(const char *name);
 
 SPINE_C_API void spine_clipping_attachment_dispose(spine_clipping_attachment self);
 
@@ -17,8 +17,11 @@ SPINE_C_API spine_slot_data spine_clipping_attachment_get_end_slot(spine_clippin
 SPINE_C_API void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, spine_slot_data inValue);
 SPINE_C_API spine_color spine_clipping_attachment_get_color(spine_clipping_attachment self);
 SPINE_C_API spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment self);
-SPINE_C_API void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, float * worldVertices, size_t offset, size_t stride);
-SPINE_C_API void spine_clipping_attachment_compute_world_vertices_2(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, spine_array_float worldVertices, size_t offset, size_t stride);
+SPINE_C_API void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot,
+																	size_t start, size_t count, float *worldVertices, size_t offset, size_t stride);
+SPINE_C_API void spine_clipping_attachment_compute_world_vertices_2(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot,
+																	size_t start, size_t count, spine_array_float worldVertices, size_t offset,
+																	size_t stride);
 SPINE_C_API int spine_clipping_attachment_get_id(spine_clipping_attachment self);
 SPINE_C_API spine_array_int spine_clipping_attachment_get_bones(spine_clipping_attachment self);
 SPINE_C_API void spine_clipping_attachment_set_bones(spine_clipping_attachment self, spine_array_int bones);
@@ -29,7 +32,7 @@ SPINE_C_API void spine_clipping_attachment_set_world_vertices_length(spine_clipp
 SPINE_C_API spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self);
 SPINE_C_API void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, spine_attachment attachment);
 SPINE_C_API void spine_clipping_attachment_copy_to(spine_clipping_attachment self, spine_vertex_attachment other);
-SPINE_C_API const char * spine_clipping_attachment_get_name(spine_clipping_attachment self);
+SPINE_C_API const char *spine_clipping_attachment_get_name(spine_clipping_attachment self);
 SPINE_C_API int spine_clipping_attachment_get_ref_count(spine_clipping_attachment self);
 SPINE_C_API void spine_clipping_attachment_reference(spine_clipping_attachment self);
 SPINE_C_API void spine_clipping_attachment_dereference(spine_clipping_attachment self);

spine-c/src/generated/color.cpp

@@ -4,85 +4,100 @@
 using namespace spine;
 
 spine_color spine_color_create(void) {
-    return (spine_color) new (__FILE__, __LINE__) Color();
+	return (spine_color) new (__FILE__, __LINE__) Color();
 }
 
 spine_color spine_color_create2(float r, float g, float b, float a) {
-    return (spine_color) new (__FILE__, __LINE__) Color(r, g, b, a);
+	return (spine_color) new (__FILE__, __LINE__) Color(r, g, b, a);
 }
 
 void spine_color_dispose(spine_color self) {
-    delete (Color*)self;
+	delete (Color *) self;
 }
 
 spine_color spine_color_set_1(spine_color self, float _r, float _g, float _b, float _a) {
-    return (spine_color)&((Color*)self)->set(_r, _g, _b, _a);
+	Color *_self = (Color *) self;
+	return (spine_color) &_self->set(_r, _g, _b, _a);
 }
 
 spine_color spine_color_set_2(spine_color self, float _r, float _g, float _b) {
-    return (spine_color)&((Color*)self)->set(_r, _g, _b);
+	Color *_self = (Color *) self;
+	return (spine_color) &_self->set(_r, _g, _b);
 }
 
 spine_color spine_color_set_3(spine_color self, spine_color other) {
-    return (spine_color)&((Color*)self)->set(*((const Color*)other));
+	Color *_self = (Color *) self;
+	return (spine_color) &_self->set(*((const Color *) other));
 }
 
 spine_color spine_color_add_1(spine_color self, float _r, float _g, float _b, float _a) {
-    return (spine_color)&((Color*)self)->add(_r, _g, _b, _a);
+	Color *_self = (Color *) self;
+	return (spine_color) &_self->add(_r, _g, _b, _a);
 }
 
 spine_color spine_color_add_2(spine_color self, float _r, float _g, float _b) {
-    return (spine_color)&((Color*)self)->add(_r, _g, _b);
+	Color *_self = (Color *) self;
+	return (spine_color) &_self->add(_r, _g, _b);
 }
 
 spine_color spine_color_add_3(spine_color self, spine_color other) {
-    return (spine_color)&((Color*)self)->add(*((const Color*)other));
+	Color *_self = (Color *) self;
+	return (spine_color) &_self->add(*((const Color *) other));
 }
 
 spine_color spine_color_clamp(spine_color self) {
-    return (spine_color)&((Color*)self)->clamp();
+	Color *_self = (Color *) self;
+	return (spine_color) &_self->clamp();
 }
 
-float spine_color_parse_hex(const char * value, size_t index) {
-    return Color::parseHex(value, index);
+float spine_color_parse_hex(const char *value, size_t index) {
+	return Color::parseHex(value, index);
 }
 
 void spine_color_rgba8888_to_color(spine_color color, int value) {
-    Color::rgba8888ToColor(*((Color*)color), value);
+	Color::rgba8888ToColor(*((Color *) color), value);
 }
 
 void spine_color_rgb888_to_color(spine_color color, int value) {
-    Color::rgb888ToColor(*((Color*)color), value);
+	Color::rgb888ToColor(*((Color *) color), value);
 }
 
 float spine_color_get_r(spine_color self) {
-    return ((Color*)self)->r;
+	Color *_self = (Color *) self;
+	return _self->r;
 }
 
 void spine_color_set_r(spine_color self, float value) {
-    ((Color*)self)->r = value;
+	Color *_self = (Color *) self;
+	_self->r = value;
 }
 
 float spine_color_get_g(spine_color self) {
-    return ((Color*)self)->g;
+	Color *_self = (Color *) self;
+	return _self->g;
 }
 
 void spine_color_set_g(spine_color self, float value) {
-    ((Color*)self)->g = value;
+	Color *_self = (Color *) self;
+	_self->g = value;
 }
 
 float spine_color_get_b(spine_color self) {
-    return ((Color*)self)->b;
+	Color *_self = (Color *) self;
+	return _self->b;
 }
 
 void spine_color_set_b(spine_color self, float value) {
-    ((Color*)self)->b = value;
+	Color *_self = (Color *) self;
+	_self->b = value;
 }
 
 float spine_color_get_a(spine_color self) {
-    return ((Color*)self)->a;
+	Color *_self = (Color *) self;
+	return _self->a;
 }
 
 void spine_color_set_a(spine_color self, float value) {
-    ((Color*)self)->a = value;
+	Color *_self = (Color *) self;
+	_self->a = value;
 }

spine-c/src/generated/color.h

@@ -20,7 +20,7 @@ SPINE_C_API spine_color spine_color_add_1(spine_color self, float _r, float _g,
 SPINE_C_API spine_color spine_color_add_2(spine_color self, float _r, float _g, float _b);
 SPINE_C_API spine_color spine_color_add_3(spine_color self, spine_color other);
 SPINE_C_API spine_color spine_color_clamp(spine_color self);
-SPINE_C_API float spine_color_parse_hex(const char * value, size_t index);
+SPINE_C_API float spine_color_parse_hex(const char *value, size_t index);
 SPINE_C_API void spine_color_rgba8888_to_color(spine_color color, int value);
 SPINE_C_API void spine_color_rgb888_to_color(spine_color color, int value);
 SPINE_C_API float spine_color_get_r(spine_color self);

spine-c/src/generated/constraint.cpp

@@ -4,29 +4,34 @@
 using namespace spine;
 
 void spine_constraint_dispose(spine_constraint self) {
-    delete (Constraint*)self;
+	delete (Constraint *) self;
 }
 
 spine_rtti spine_constraint_get_rtti(spine_constraint self) {
-    return (spine_rtti)&((Constraint*)self)->getRTTI();
+	Constraint *_self = (Constraint *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 spine_constraint_data spine_constraint_get_data(spine_constraint self) {
-    return (spine_constraint_data)&((Constraint*)self)->getData();
+	Constraint *_self = (Constraint *) self;
+	return (spine_constraint_data) &_self->getData();
 }
 
 void spine_constraint_sort(spine_constraint self, spine_skeleton skeleton) {
-    ((Constraint*)self)->sort(*((Skeleton*)skeleton));
+	Constraint *_self = (Constraint *) self;
+	_self->sort(*((Skeleton *) skeleton));
 }
 
 bool spine_constraint_is_source_active(spine_constraint self) {
-    return ((Constraint*)self)->isSourceActive();
+	Constraint *_self = (Constraint *) self;
+	return _self->isSourceActive();
 }
 
 void spine_constraint_update(spine_constraint self, spine_skeleton skeleton, spine_physics physics) {
-    ((Constraint*)self)->update(*((Skeleton*)skeleton), (Physics)physics);
+	Constraint *_self = (Constraint *) self;
+	_self->update(*((Skeleton *) skeleton), (Physics) physics);
 }
 
 spine_rtti spine_constraint_rtti(void) {
-    return (spine_rtti)&Constraint::rtti;
+	return (spine_rtti) &Constraint::rtti;
 }

spine-c/src/generated/constraint_data.cpp

@@ -4,25 +4,29 @@
 using namespace spine;
 
 void spine_constraint_data_dispose(spine_constraint_data self) {
-    delete (ConstraintData*)self;
+	delete (ConstraintData *) self;
 }
 
 spine_rtti spine_constraint_data_get_rtti(spine_constraint_data self) {
-    return (spine_rtti)&((ConstraintData*)self)->getRTTI();
+	ConstraintData *_self = (ConstraintData *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 spine_constraint spine_constraint_data_create_method(spine_constraint_data self, spine_skeleton skeleton) {
-    return (spine_constraint)((ConstraintData*)self)->create(*((Skeleton*)skeleton));
+	ConstraintData *_self = (ConstraintData *) self;
+	return (spine_constraint) _self->create(*((Skeleton *) skeleton));
 }
 
-const char * spine_constraint_data_get_name(spine_constraint_data self) {
-    return ((ConstraintData*)self)->getName().buffer();
+const char *spine_constraint_data_get_name(spine_constraint_data self) {
+	ConstraintData *_self = (ConstraintData *) self;
+	return _self->getName().buffer();
 }
 
 bool spine_constraint_data_get_skin_required(spine_constraint_data self) {
-    return ((ConstraintData*)self)->getSkinRequired();
+	ConstraintData *_self = (ConstraintData *) self;
+	return _self->getSkinRequired();
 }
 
 spine_rtti spine_constraint_data_rtti(void) {
-    return (spine_rtti)&ConstraintData::rtti;
+	return (spine_rtti) &ConstraintData::rtti;
 }

spine-c/src/generated/constraint_data.h

@@ -12,7 +12,7 @@ SPINE_C_API void spine_constraint_data_dispose(spine_constraint_data self);
 
 SPINE_C_API spine_rtti spine_constraint_data_get_rtti(spine_constraint_data self);
 SPINE_C_API spine_constraint spine_constraint_data_create_method(spine_constraint_data self, spine_skeleton skeleton);
-SPINE_C_API const char * spine_constraint_data_get_name(spine_constraint_data self);
+SPINE_C_API const char *spine_constraint_data_get_name(spine_constraint_data self);
 SPINE_C_API bool spine_constraint_data_get_skin_required(spine_constraint_data self);
 SPINE_C_API spine_rtti spine_constraint_data_rtti(void);
 

spine-c/src/generated/constraint_timeline.cpp

@@ -4,21 +4,24 @@
 using namespace spine;
 
 void spine_constraint_timeline_dispose(spine_constraint_timeline self) {
-    delete (ConstraintTimeline*)self;
+	delete (ConstraintTimeline *) self;
 }
 
 spine_rtti spine_constraint_timeline_get_rtti(spine_constraint_timeline self) {
-    return (spine_rtti)&((ConstraintTimeline*)self)->getRTTI();
+	ConstraintTimeline *_self = (ConstraintTimeline *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 int spine_constraint_timeline_get_constraint_index(spine_constraint_timeline self) {
-    return ((ConstraintTimeline*)self)->getConstraintIndex();
+	ConstraintTimeline *_self = (ConstraintTimeline *) self;
+	return _self->getConstraintIndex();
 }
 
 void spine_constraint_timeline_set_constraint_index(spine_constraint_timeline self, int inValue) {
-    ((ConstraintTimeline*)self)->setConstraintIndex(inValue);
+	ConstraintTimeline *_self = (ConstraintTimeline *) self;
+	_self->setConstraintIndex(inValue);
 }
 
 spine_rtti spine_constraint_timeline_rtti(void) {
-    return (spine_rtti)&ConstraintTimeline::rtti;
+	return (spine_rtti) &ConstraintTimeline::rtti;
 }

spine-c/src/generated/constraint_timeline1.cpp

@@ -4,89 +4,116 @@
 using namespace spine;
 
 void spine_constraint_timeline1_dispose(spine_constraint_timeline1 self) {
-    delete (ConstraintTimeline1*)self;
+	delete (ConstraintTimeline1 *) self;
 }
 
 spine_rtti spine_constraint_timeline1_get_rtti(spine_constraint_timeline1 self) {
-    return (spine_rtti)&((ConstraintTimeline1*)self)->getRTTI();
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_constraint_timeline1_set_frame(spine_constraint_timeline1 self, size_t frame, float time, float value) {
-    ((CurveTimeline1*)(ConstraintTimeline1*)self)->setFrame(frame, time, value);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	_self->setFrame(frame, time, value);
 }
 
 float spine_constraint_timeline1_get_curve_value(spine_constraint_timeline1 self, float time) {
-    return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getCurveValue(time);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return _self->getCurveValue(time);
 }
 
-float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
-    return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getRelativeValue(time, alpha, (MixBlend)blend, current, setup);
+float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+													float setup) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
-float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
-    return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup);
+float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+													  float setup) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
-float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) {
-    return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup, value);
+float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+													  float setup, float value) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
-float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-    return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getScaleValue(time, alpha, (MixBlend)blend, (MixDirection)direction, current, setup);
+float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
+												 spine_mix_direction direction, float current, float setup) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_constraint_timeline1_set_linear(spine_constraint_timeline1 self, size_t frame) {
-    ((CurveTimeline1*)(ConstraintTimeline1*)self)->setLinear(frame);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	_self->setLinear(frame);
 }
 
 void spine_constraint_timeline1_set_stepped(spine_constraint_timeline1 self, size_t frame) {
-    ((CurveTimeline1*)(ConstraintTimeline1*)self)->setStepped(frame);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	_self->setStepped(frame);
 }
 
-void spine_constraint_timeline1_set_bezier(spine_constraint_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
-    ((CurveTimeline1*)(ConstraintTimeline1*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+void spine_constraint_timeline1_set_bezier(spine_constraint_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1,
+										   float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_constraint_timeline1_get_bezier_value(spine_constraint_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i) {
-    return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getBezierValue(time, frame, valueOffset, i);
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timeline1 self) {
-    return (spine_array_float)&((CurveTimeline1*)(ConstraintTimeline1*)self)->getCurves();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return (spine_array_float) &_self->getCurves();
 }
 
-void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((CurveTimeline1*)(ConstraintTimeline1*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+									  float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 size_t spine_constraint_timeline1_get_frame_entries(spine_constraint_timeline1 self) {
-    return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getFrameEntries();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return _self->getFrameEntries();
 }
 
 size_t spine_constraint_timeline1_get_frame_count(spine_constraint_timeline1 self) {
-    return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getFrameCount();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_float spine_constraint_timeline1_get_frames(spine_constraint_timeline1 self) {
-    return (spine_array_float)&((CurveTimeline1*)(ConstraintTimeline1*)self)->getFrames();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_constraint_timeline1_get_duration(spine_constraint_timeline1 self) {
-    return ((CurveTimeline1*)(ConstraintTimeline1*)self)->getDuration();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_constraint_timeline1_get_property_ids(spine_constraint_timeline1 self) {
-    return (spine_array_property_id)&((CurveTimeline1*)(ConstraintTimeline1*)self)->getPropertyIds();
+	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 int spine_constraint_timeline1_get_constraint_index(spine_constraint_timeline1 self) {
-    return ((ConstraintTimeline*)(ConstraintTimeline1*)self)->getConstraintIndex();
+	ConstraintTimeline *_self = (ConstraintTimeline *) (ConstraintTimeline1 *) self;
+	return _self->getConstraintIndex();
 }
 
 void spine_constraint_timeline1_set_constraint_index(spine_constraint_timeline1 self, int inValue) {
-    ((ConstraintTimeline*)(ConstraintTimeline1*)self)->setConstraintIndex(inValue);
+	ConstraintTimeline *_self = (ConstraintTimeline *) (ConstraintTimeline1 *) self;
+	_self->setConstraintIndex(inValue);
 }
 
 spine_rtti spine_constraint_timeline1_rtti(void) {
-    return (spine_rtti)&ConstraintTimeline1::rtti;
+	return (spine_rtti) &ConstraintTimeline1::rtti;
 }

spine-c/src/generated/constraint_timeline1.h

@@ -13,16 +13,24 @@ SPINE_C_API void spine_constraint_timeline1_dispose(spine_constraint_timeline1 s
 SPINE_C_API spine_rtti spine_constraint_timeline1_get_rtti(spine_constraint_timeline1 self);
 SPINE_C_API void spine_constraint_timeline1_set_frame(spine_constraint_timeline1 self, size_t frame, float time, float value);
 SPINE_C_API float spine_constraint_timeline1_get_curve_value(spine_constraint_timeline1 self, float time);
-SPINE_C_API float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
-SPINE_C_API float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
-SPINE_C_API float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value);
-SPINE_C_API float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup);
+SPINE_C_API float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
+																float current, float setup);
+SPINE_C_API float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
+																  float current, float setup);
+SPINE_C_API float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
+																  float current, float setup, float value);
+SPINE_C_API float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
+															 spine_mix_direction direction, float current, float setup);
 SPINE_C_API void spine_constraint_timeline1_set_linear(spine_constraint_timeline1 self, size_t frame);
 SPINE_C_API void spine_constraint_timeline1_set_stepped(spine_constraint_timeline1 self, size_t frame);
-SPINE_C_API void spine_constraint_timeline1_set_bezier(spine_constraint_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
-SPINE_C_API float spine_constraint_timeline1_get_bezier_value(spine_constraint_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i);
+SPINE_C_API void spine_constraint_timeline1_set_bezier(spine_constraint_timeline1 self, size_t bezier, size_t frame, float value, float time1,
+													   float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
+SPINE_C_API float spine_constraint_timeline1_get_bezier_value(spine_constraint_timeline1 self, float time, size_t frame, size_t valueOffset,
+															  size_t i);
 SPINE_C_API spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timeline1 self);
-SPINE_C_API void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
+												  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+												  bool appliedPose);
 SPINE_C_API size_t spine_constraint_timeline1_get_frame_entries(spine_constraint_timeline1 self);
 SPINE_C_API size_t spine_constraint_timeline1_get_frame_count(spine_constraint_timeline1 self);
 SPINE_C_API spine_array_float spine_constraint_timeline1_get_frames(spine_constraint_timeline1 self);

spine-c/src/generated/curve_timeline.cpp

@@ -4,57 +4,72 @@
 using namespace spine;
 
 void spine_curve_timeline_dispose(spine_curve_timeline self) {
-    delete (CurveTimeline*)self;
+	delete (CurveTimeline *) self;
 }
 
 spine_rtti spine_curve_timeline_get_rtti(spine_curve_timeline self) {
-    return (spine_rtti)&((CurveTimeline*)self)->getRTTI();
+	CurveTimeline *_self = (CurveTimeline *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_curve_timeline_set_linear(spine_curve_timeline self, size_t frame) {
-    ((CurveTimeline*)self)->setLinear(frame);
+	CurveTimeline *_self = (CurveTimeline *) self;
+	_self->setLinear(frame);
 }
 
 void spine_curve_timeline_set_stepped(spine_curve_timeline self, size_t frame) {
-    ((CurveTimeline*)self)->setStepped(frame);
+	CurveTimeline *_self = (CurveTimeline *) self;
+	_self->setStepped(frame);
 }
 
-void spine_curve_timeline_set_bezier(spine_curve_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
-    ((CurveTimeline*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+void spine_curve_timeline_set_bezier(spine_curve_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
+									 float cy1, float cx2, float cy2, float time2, float value2) {
+	CurveTimeline *_self = (CurveTimeline *) self;
+	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_curve_timeline_get_bezier_value(spine_curve_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-    return ((CurveTimeline*)self)->getBezierValue(time, frame, valueOffset, i);
+	CurveTimeline *_self = (CurveTimeline *) self;
+	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self) {
-    return (spine_array_float)&((CurveTimeline*)self)->getCurves();
+	CurveTimeline *_self = (CurveTimeline *) self;
+	return (spine_array_float) &_self->getCurves();
 }
 
-void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((Timeline*)(CurveTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline self) {
-    return ((Timeline*)(CurveTimeline*)self)->getFrameEntries();
+	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	return _self->getFrameEntries();
 }
 
 size_t spine_curve_timeline_get_frame_count(spine_curve_timeline self) {
-    return ((Timeline*)(CurveTimeline*)self)->getFrameCount();
+	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_float spine_curve_timeline_get_frames(spine_curve_timeline self) {
-    return (spine_array_float)&((Timeline*)(CurveTimeline*)self)->getFrames();
+	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_curve_timeline_get_duration(spine_curve_timeline self) {
-    return ((Timeline*)(CurveTimeline*)self)->getDuration();
+	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_curve_timeline_get_property_ids(spine_curve_timeline self) {
-    return (spine_array_property_id)&((Timeline*)(CurveTimeline*)self)->getPropertyIds();
+	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 spine_rtti spine_curve_timeline_rtti(void) {
-    return (spine_rtti)&CurveTimeline::rtti;
+	return (spine_rtti) &CurveTimeline::rtti;
 }

spine-c/src/generated/curve_timeline.h

@@ -13,10 +13,12 @@ SPINE_C_API void spine_curve_timeline_dispose(spine_curve_timeline self);
 SPINE_C_API spine_rtti spine_curve_timeline_get_rtti(spine_curve_timeline self);
 SPINE_C_API void spine_curve_timeline_set_linear(spine_curve_timeline self, size_t frame);
 SPINE_C_API void spine_curve_timeline_set_stepped(spine_curve_timeline self, size_t frame);
-SPINE_C_API void spine_curve_timeline_set_bezier(spine_curve_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
+SPINE_C_API void spine_curve_timeline_set_bezier(spine_curve_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
+												 float cx1, float cy1, float cx2, float cy2, float time2, float value2);
 SPINE_C_API float spine_curve_timeline_get_bezier_value(spine_curve_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
 SPINE_C_API spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self);
-SPINE_C_API void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
 SPINE_C_API size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline self);
 SPINE_C_API size_t spine_curve_timeline_get_frame_count(spine_curve_timeline self);
 SPINE_C_API spine_array_float spine_curve_timeline_get_frames(spine_curve_timeline self);

spine-c/src/generated/curve_timeline1.cpp

@@ -4,81 +4,106 @@
 using namespace spine;
 
 void spine_curve_timeline1_dispose(spine_curve_timeline1 self) {
-    delete (CurveTimeline1*)self;
+	delete (CurveTimeline1 *) self;
 }
 
 spine_rtti spine_curve_timeline1_get_rtti(spine_curve_timeline1 self) {
-    return (spine_rtti)&((CurveTimeline1*)self)->getRTTI();
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_curve_timeline1_set_frame(spine_curve_timeline1 self, size_t frame, float time, float value) {
-    ((CurveTimeline1*)self)->setFrame(frame, time, value);
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
+	_self->setFrame(frame, time, value);
 }
 
 float spine_curve_timeline1_get_curve_value(spine_curve_timeline1 self, float time) {
-    return ((CurveTimeline1*)self)->getCurveValue(time);
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
+	return _self->getCurveValue(time);
 }
 
-float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
-    return ((CurveTimeline1*)self)->getRelativeValue(time, alpha, (MixBlend)blend, current, setup);
+float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+											   float setup) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
+	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
-float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
-    return ((CurveTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup);
+float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+												 float setup) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
+	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
-float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value) {
-    return ((CurveTimeline1*)self)->getAbsoluteValue(time, alpha, (MixBlend)blend, current, setup, value);
+float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+												 float setup, float value) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
+	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
-float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-    return ((CurveTimeline1*)self)->getScaleValue(time, alpha, (MixBlend)blend, (MixDirection)direction, current, setup);
+float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											float current, float setup) {
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
+	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_curve_timeline1_set_linear(spine_curve_timeline1 self, size_t frame) {
-    ((CurveTimeline*)(CurveTimeline1*)self)->setLinear(frame);
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	_self->setLinear(frame);
 }
 
 void spine_curve_timeline1_set_stepped(spine_curve_timeline1 self, size_t frame) {
-    ((CurveTimeline*)(CurveTimeline1*)self)->setStepped(frame);
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	_self->setStepped(frame);
 }
 
-void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
-    ((CurveTimeline*)(CurveTimeline1*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
+									  float cy1, float cx2, float cy2, float time2, float value2) {
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_curve_timeline1_get_bezier_value(spine_curve_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i) {
-    return ((CurveTimeline*)(CurveTimeline1*)self)->getBezierValue(time, frame, valueOffset, i);
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self) {
-    return (spine_array_float)&((CurveTimeline*)(CurveTimeline1*)self)->getCurves();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	return (spine_array_float) &_self->getCurves();
 }
 
-void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((CurveTimeline*)(CurveTimeline1*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+								 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 self) {
-    return ((CurveTimeline*)(CurveTimeline1*)self)->getFrameEntries();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	return _self->getFrameEntries();
 }
 
 size_t spine_curve_timeline1_get_frame_count(spine_curve_timeline1 self) {
-    return ((CurveTimeline*)(CurveTimeline1*)self)->getFrameCount();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_float spine_curve_timeline1_get_frames(spine_curve_timeline1 self) {
-    return (spine_array_float)&((CurveTimeline*)(CurveTimeline1*)self)->getFrames();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_curve_timeline1_get_duration(spine_curve_timeline1 self) {
-    return ((CurveTimeline*)(CurveTimeline1*)self)->getDuration();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_curve_timeline1_get_property_ids(spine_curve_timeline1 self) {
-    return (spine_array_property_id)&((CurveTimeline*)(CurveTimeline1*)self)->getPropertyIds();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 spine_rtti spine_curve_timeline1_rtti(void) {
-    return (spine_rtti)&CurveTimeline1::rtti;
+	return (spine_rtti) &CurveTimeline1::rtti;
 }

spine-c/src/generated/curve_timeline1.h

@@ -13,16 +13,23 @@ SPINE_C_API void spine_curve_timeline1_dispose(spine_curve_timeline1 self);
 SPINE_C_API spine_rtti spine_curve_timeline1_get_rtti(spine_curve_timeline1 self);
 SPINE_C_API void spine_curve_timeline1_set_frame(spine_curve_timeline1 self, size_t frame, float time, float value);
 SPINE_C_API float spine_curve_timeline1_get_curve_value(spine_curve_timeline1 self, float time);
-SPINE_C_API float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
-SPINE_C_API float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup);
-SPINE_C_API float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup, float value);
-SPINE_C_API float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, float current, float setup);
+SPINE_C_API float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
+														   float setup);
+SPINE_C_API float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend,
+															 float current, float setup);
+SPINE_C_API float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend,
+															 float current, float setup, float value);
+SPINE_C_API float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend,
+														spine_mix_direction direction, float current, float setup);
 SPINE_C_API void spine_curve_timeline1_set_linear(spine_curve_timeline1 self, size_t frame);
 SPINE_C_API void spine_curve_timeline1_set_stepped(spine_curve_timeline1 self, size_t frame);
-SPINE_C_API void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
+SPINE_C_API void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1,
+												  float cx1, float cy1, float cx2, float cy2, float time2, float value2);
 SPINE_C_API float spine_curve_timeline1_get_bezier_value(spine_curve_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i);
 SPINE_C_API spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self);
-SPINE_C_API void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
+											 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											 bool appliedPose);
 SPINE_C_API size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 self);
 SPINE_C_API size_t spine_curve_timeline1_get_frame_count(spine_curve_timeline1 self);
 SPINE_C_API spine_array_float spine_curve_timeline1_get_frames(spine_curve_timeline1 self);

spine-c/src/generated/curve_timeline2.cpp

@@ -4,65 +4,82 @@
 using namespace spine;
 
 void spine_curve_timeline2_dispose(spine_curve_timeline2 self) {
-    delete (CurveTimeline2*)self;
+	delete (CurveTimeline2 *) self;
 }
 
 spine_rtti spine_curve_timeline2_get_rtti(spine_curve_timeline2 self) {
-    return (spine_rtti)&((CurveTimeline2*)self)->getRTTI();
+	CurveTimeline2 *_self = (CurveTimeline2 *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_curve_timeline2_set_frame(spine_curve_timeline2 self, size_t frame, float time, float value1, float value2) {
-    ((CurveTimeline2*)self)->setFrame(frame, time, value1, value2);
+	CurveTimeline2 *_self = (CurveTimeline2 *) self;
+	_self->setFrame(frame, time, value1, value2);
 }
 
 float spine_curve_timeline2_get_curve_value(spine_curve_timeline2 self, float time) {
-    return ((CurveTimeline2*)self)->getCurveValue(time);
+	CurveTimeline2 *_self = (CurveTimeline2 *) self;
+	return _self->getCurveValue(time);
 }
 
 void spine_curve_timeline2_set_linear(spine_curve_timeline2 self, size_t frame) {
-    ((CurveTimeline*)(CurveTimeline2*)self)->setLinear(frame);
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	_self->setLinear(frame);
 }
 
 void spine_curve_timeline2_set_stepped(spine_curve_timeline2 self, size_t frame) {
-    ((CurveTimeline*)(CurveTimeline2*)self)->setStepped(frame);
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	_self->setStepped(frame);
 }
 
-void spine_curve_timeline2_set_bezier(spine_curve_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
-    ((CurveTimeline*)(CurveTimeline2*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+void spine_curve_timeline2_set_bezier(spine_curve_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
+									  float cy1, float cx2, float cy2, float time2, float value2) {
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_curve_timeline2_get_bezier_value(spine_curve_timeline2 self, float time, size_t frame, size_t valueOffset, size_t i) {
-    return ((CurveTimeline*)(CurveTimeline2*)self)->getBezierValue(time, frame, valueOffset, i);
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_curve_timeline2_get_curves(spine_curve_timeline2 self) {
-    return (spine_array_float)&((CurveTimeline*)(CurveTimeline2*)self)->getCurves();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	return (spine_array_float) &_self->getCurves();
 }
 
-void spine_curve_timeline2_apply(spine_curve_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((CurveTimeline*)(CurveTimeline2*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_curve_timeline2_apply(spine_curve_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+								 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 size_t spine_curve_timeline2_get_frame_entries(spine_curve_timeline2 self) {
-    return ((CurveTimeline*)(CurveTimeline2*)self)->getFrameEntries();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	return _self->getFrameEntries();
 }
 
 size_t spine_curve_timeline2_get_frame_count(spine_curve_timeline2 self) {
-    return ((CurveTimeline*)(CurveTimeline2*)self)->getFrameCount();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_float spine_curve_timeline2_get_frames(spine_curve_timeline2 self) {
-    return (spine_array_float)&((CurveTimeline*)(CurveTimeline2*)self)->getFrames();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_curve_timeline2_get_duration(spine_curve_timeline2 self) {
-    return ((CurveTimeline*)(CurveTimeline2*)self)->getDuration();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_curve_timeline2_get_property_ids(spine_curve_timeline2 self) {
-    return (spine_array_property_id)&((CurveTimeline*)(CurveTimeline2*)self)->getPropertyIds();
+	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline2 *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 spine_rtti spine_curve_timeline2_rtti(void) {
-    return (spine_rtti)&CurveTimeline2::rtti;
+	return (spine_rtti) &CurveTimeline2::rtti;
 }

spine-c/src/generated/curve_timeline2.h

@@ -15,10 +15,13 @@ SPINE_C_API void spine_curve_timeline2_set_frame(spine_curve_timeline2 self, siz
 SPINE_C_API float spine_curve_timeline2_get_curve_value(spine_curve_timeline2 self, float time);
 SPINE_C_API void spine_curve_timeline2_set_linear(spine_curve_timeline2 self, size_t frame);
 SPINE_C_API void spine_curve_timeline2_set_stepped(spine_curve_timeline2 self, size_t frame);
-SPINE_C_API void spine_curve_timeline2_set_bezier(spine_curve_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
+SPINE_C_API void spine_curve_timeline2_set_bezier(spine_curve_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1,
+												  float cx1, float cy1, float cx2, float cy2, float time2, float value2);
 SPINE_C_API float spine_curve_timeline2_get_bezier_value(spine_curve_timeline2 self, float time, size_t frame, size_t valueOffset, size_t i);
 SPINE_C_API spine_array_float spine_curve_timeline2_get_curves(spine_curve_timeline2 self);
-SPINE_C_API void spine_curve_timeline2_apply(spine_curve_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_curve_timeline2_apply(spine_curve_timeline2 self, spine_skeleton skeleton, float lastTime, float time,
+											 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											 bool appliedPose);
 SPINE_C_API size_t spine_curve_timeline2_get_frame_entries(spine_curve_timeline2 self);
 SPINE_C_API size_t spine_curve_timeline2_get_frame_count(spine_curve_timeline2 self);
 SPINE_C_API spine_array_float spine_curve_timeline2_get_frames(spine_curve_timeline2 self);

spine-c/src/generated/deform_timeline.cpp

@@ -4,85 +4,106 @@
 using namespace spine;
 
 spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex, spine_vertex_attachment attachment) {
-    return (spine_deform_timeline) new (__FILE__, __LINE__) DeformTimeline(frameCount, bezierCount, slotIndex, (VertexAttachment *)attachment);
+	return (spine_deform_timeline) new (__FILE__, __LINE__) DeformTimeline(frameCount, bezierCount, slotIndex, (VertexAttachment *) attachment);
 }
 
 void spine_deform_timeline_dispose(spine_deform_timeline self) {
-    delete (DeformTimeline*)self;
+	delete (DeformTimeline *) self;
 }
 
 spine_rtti spine_deform_timeline_get_rtti(spine_deform_timeline self) {
-    return (spine_rtti)&((DeformTimeline*)self)->getRTTI();
+	DeformTimeline *_self = (DeformTimeline *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_deform_timeline_set_frame(spine_deform_timeline self, int frameIndex, float time, spine_array_float vertices) {
-    ((DeformTimeline*)self)->setFrame(frameIndex, time, *((Array<float>*)vertices));
+	DeformTimeline *_self = (DeformTimeline *) self;
+	_self->setFrame(frameIndex, time, *((Array<float> *) vertices));
 }
 
 spine_vertex_attachment spine_deform_timeline_get_attachment(spine_deform_timeline self) {
-    return (spine_vertex_attachment)((DeformTimeline*)self)->getAttachment();
+	DeformTimeline *_self = (DeformTimeline *) self;
+	return (spine_vertex_attachment) _self->getAttachment();
 }
 
 void spine_deform_timeline_set_attachment(spine_deform_timeline self, spine_vertex_attachment inValue) {
-    ((DeformTimeline*)self)->setAttachment((VertexAttachment *)inValue);
+	DeformTimeline *_self = (DeformTimeline *) self;
+	_self->setAttachment((VertexAttachment *) inValue);
 }
 
-void spine_deform_timeline_set_bezier(spine_deform_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
-    ((DeformTimeline*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+void spine_deform_timeline_set_bezier(spine_deform_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
+									  float cy1, float cx2, float cy2, float time2, float value2) {
+	DeformTimeline *_self = (DeformTimeline *) self;
+	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_deform_timeline_get_curve_percent(spine_deform_timeline self, float time, int frame) {
-    return ((DeformTimeline*)self)->getCurvePercent(time, frame);
+	DeformTimeline *_self = (DeformTimeline *) self;
+	return _self->getCurvePercent(time, frame);
 }
 
 size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self) {
-    return ((DeformTimeline*)self)->getFrameCount();
+	DeformTimeline *_self = (DeformTimeline *) self;
+	return _self->getFrameCount();
 }
 
-void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((SlotCurveTimeline*)(DeformTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+								 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 void spine_deform_timeline_set_linear(spine_deform_timeline self, size_t frame) {
-    ((SlotCurveTimeline*)(DeformTimeline*)self)->setLinear(frame);
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	_self->setLinear(frame);
 }
 
 void spine_deform_timeline_set_stepped(spine_deform_timeline self, size_t frame) {
-    ((SlotCurveTimeline*)(DeformTimeline*)self)->setStepped(frame);
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	_self->setStepped(frame);
 }
 
 float spine_deform_timeline_get_bezier_value(spine_deform_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-    return ((SlotCurveTimeline*)(DeformTimeline*)self)->getBezierValue(time, frame, valueOffset, i);
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_deform_timeline_get_curves(spine_deform_timeline self) {
-    return (spine_array_float)&((SlotCurveTimeline*)(DeformTimeline*)self)->getCurves();
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_deform_timeline_get_frame_entries(spine_deform_timeline self) {
-    return ((SlotCurveTimeline*)(DeformTimeline*)self)->getFrameEntries();
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	return _self->getFrameEntries();
 }
 
 spine_array_float spine_deform_timeline_get_frames(spine_deform_timeline self) {
-    return (spine_array_float)&((SlotCurveTimeline*)(DeformTimeline*)self)->getFrames();
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_deform_timeline_get_duration(spine_deform_timeline self) {
-    return ((SlotCurveTimeline*)(DeformTimeline*)self)->getDuration();
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_deform_timeline_get_property_ids(spine_deform_timeline self) {
-    return (spine_array_property_id)&((SlotCurveTimeline*)(DeformTimeline*)self)->getPropertyIds();
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 int spine_deform_timeline_get_slot_index(spine_deform_timeline self) {
-    return ((SlotCurveTimeline*)(DeformTimeline*)self)->getSlotIndex();
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	return _self->getSlotIndex();
 }
 
 void spine_deform_timeline_set_slot_index(spine_deform_timeline self, int inValue) {
-    ((SlotCurveTimeline*)(DeformTimeline*)self)->setSlotIndex(inValue);
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	_self->setSlotIndex(inValue);
 }
 
 spine_rtti spine_deform_timeline_rtti(void) {
-    return (spine_rtti)&DeformTimeline::rtti;
+	return (spine_rtti) &DeformTimeline::rtti;
 }

spine-c/src/generated/deform_timeline.h

@@ -8,7 +8,8 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex, spine_vertex_attachment attachment);
+SPINE_C_API spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex,
+															   spine_vertex_attachment attachment);
 
 SPINE_C_API void spine_deform_timeline_dispose(spine_deform_timeline self);
 
@@ -16,10 +17,13 @@ SPINE_C_API spine_rtti spine_deform_timeline_get_rtti(spine_deform_timeline self
 SPINE_C_API void spine_deform_timeline_set_frame(spine_deform_timeline self, int frameIndex, float time, spine_array_float vertices);
 SPINE_C_API spine_vertex_attachment spine_deform_timeline_get_attachment(spine_deform_timeline self);
 SPINE_C_API void spine_deform_timeline_set_attachment(spine_deform_timeline self, spine_vertex_attachment inValue);
-SPINE_C_API void spine_deform_timeline_set_bezier(spine_deform_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
+SPINE_C_API void spine_deform_timeline_set_bezier(spine_deform_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
+												  float cx1, float cy1, float cx2, float cy2, float time2, float value2);
 SPINE_C_API float spine_deform_timeline_get_curve_percent(spine_deform_timeline self, float time, int frame);
 SPINE_C_API size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self);
-SPINE_C_API void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time,
+											 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											 bool appliedPose);
 SPINE_C_API void spine_deform_timeline_set_linear(spine_deform_timeline self, size_t frame);
 SPINE_C_API void spine_deform_timeline_set_stepped(spine_deform_timeline self, size_t frame);
 SPINE_C_API float spine_deform_timeline_get_bezier_value(spine_deform_timeline self, float time, size_t frame, size_t valueOffset, size_t i);

spine-c/src/generated/draw_order_timeline.cpp

@@ -4,45 +4,55 @@
 using namespace spine;
 
 spine_draw_order_timeline spine_draw_order_timeline_create(size_t frameCount) {
-    return (spine_draw_order_timeline) new (__FILE__, __LINE__) DrawOrderTimeline(frameCount);
+	return (spine_draw_order_timeline) new (__FILE__, __LINE__) DrawOrderTimeline(frameCount);
 }
 
 void spine_draw_order_timeline_dispose(spine_draw_order_timeline self) {
-    delete (DrawOrderTimeline*)self;
+	delete (DrawOrderTimeline *) self;
 }
 
 spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline self) {
-    return (spine_rtti)&((DrawOrderTimeline*)self)->getRTTI();
+	DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((DrawOrderTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+									 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline self) {
-    return ((DrawOrderTimeline*)self)->getFrameCount();
+	DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
+	return _self->getFrameCount();
 }
 
 void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, spine_array_int drawOrder) {
-    ((DrawOrderTimeline*)self)->setFrame(frame, time, (Array<int> *)drawOrder);
+	DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
+	_self->setFrame(frame, time, (Array<int> *) drawOrder);
 }
 
 size_t spine_draw_order_timeline_get_frame_entries(spine_draw_order_timeline self) {
-    return ((Timeline*)(DrawOrderTimeline*)self)->getFrameEntries();
+	Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
+	return _self->getFrameEntries();
 }
 
 spine_array_float spine_draw_order_timeline_get_frames(spine_draw_order_timeline self) {
-    return (spine_array_float)&((Timeline*)(DrawOrderTimeline*)self)->getFrames();
+	Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_draw_order_timeline_get_duration(spine_draw_order_timeline self) {
-    return ((Timeline*)(DrawOrderTimeline*)self)->getDuration();
+	Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_draw_order_timeline_get_property_ids(spine_draw_order_timeline self) {
-    return (spine_array_property_id)&((Timeline*)(DrawOrderTimeline*)self)->getPropertyIds();
+	Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 spine_rtti spine_draw_order_timeline_rtti(void) {
-    return (spine_rtti)&DrawOrderTimeline::rtti;
+	return (spine_rtti) &DrawOrderTimeline::rtti;
 }

spine-c/src/generated/draw_order_timeline.h

@@ -13,7 +13,9 @@ SPINE_C_API spine_draw_order_timeline spine_draw_order_timeline_create(size_t fr
 SPINE_C_API void spine_draw_order_timeline_dispose(spine_draw_order_timeline self);
 
 SPINE_C_API spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline self);
-SPINE_C_API void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time,
+												 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+												 bool appliedPose);
 SPINE_C_API size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline self);
 SPINE_C_API void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, spine_array_int drawOrder);
 SPINE_C_API size_t spine_draw_order_timeline_get_frame_entries(spine_draw_order_timeline self);

spine-c/src/generated/event.cpp

@@ -4,57 +4,69 @@
 using namespace spine;
 
 spine_event spine_event_create(float time, spine_event_data data) {
-    return (spine_event) new (__FILE__, __LINE__) Event(time, *((const EventData*)data));
+	return (spine_event) new (__FILE__, __LINE__) Event(time, *((const EventData *) data));
 }
 
 void spine_event_dispose(spine_event self) {
-    delete (Event*)self;
+	delete (Event *) self;
 }
 
 spine_event_data spine_event_get_data(spine_event self) {
-    return (spine_event_data)&((Event*)self)->getData();
+	Event *_self = (Event *) self;
+	return (spine_event_data) &_self->getData();
 }
 
 float spine_event_get_time(spine_event self) {
-    return ((Event*)self)->getTime();
+	Event *_self = (Event *) self;
+	return _self->getTime();
 }
 
 int spine_event_get_int(spine_event self) {
-    return ((Event*)self)->getInt();
+	Event *_self = (Event *) self;
+	return _self->getInt();
 }
 
 void spine_event_set_int(spine_event self, int inValue) {
-    ((Event*)self)->setInt(inValue);
+	Event *_self = (Event *) self;
+	_self->setInt(inValue);
 }
 
 float spine_event_get_float(spine_event self) {
-    return ((Event*)self)->getFloat();
+	Event *_self = (Event *) self;
+	return _self->getFloat();
 }
 
 void spine_event_set_float(spine_event self, float inValue) {
-    ((Event*)self)->setFloat(inValue);
+	Event *_self = (Event *) self;
+	_self->setFloat(inValue);
 }
 
-const char * spine_event_get_string(spine_event self) {
-    return ((Event*)self)->getString().buffer();
+const char *spine_event_get_string(spine_event self) {
+	Event *_self = (Event *) self;
+	return _self->getString().buffer();
 }
 
-void spine_event_set_string(spine_event self, const char * inValue) {
-    ((Event*)self)->setString(String(inValue));
+void spine_event_set_string(spine_event self, const char *inValue) {
+	Event *_self = (Event *) self;
+	_self->setString(String(inValue));
 }
 
 float spine_event_get_volume(spine_event self) {
-    return ((Event*)self)->getVolume();
+	Event *_self = (Event *) self;
+	return _self->getVolume();
 }
 
 void spine_event_set_volume(spine_event self, float inValue) {
-    ((Event*)self)->setVolume(inValue);
+	Event *_self = (Event *) self;
+	_self->setVolume(inValue);
 }
 
 float spine_event_get_balance(spine_event self) {
-    return ((Event*)self)->getBalance();
+	Event *_self = (Event *) self;
+	return _self->getBalance();
 }
 
 void spine_event_set_balance(spine_event self, float inValue) {
-    ((Event*)self)->setBalance(inValue);
+	Event *_self = (Event *) self;
+	_self->setBalance(inValue);
 }

spine-c/src/generated/event.h

@@ -18,8 +18,8 @@ SPINE_C_API int spine_event_get_int(spine_event self);
 SPINE_C_API void spine_event_set_int(spine_event self, int inValue);
 SPINE_C_API float spine_event_get_float(spine_event self);
 SPINE_C_API void spine_event_set_float(spine_event self, float inValue);
-SPINE_C_API const char * spine_event_get_string(spine_event self);
-SPINE_C_API void spine_event_set_string(spine_event self, const char * inValue);
+SPINE_C_API const char *spine_event_get_string(spine_event self);
+SPINE_C_API void spine_event_set_string(spine_event self, const char *inValue);
 SPINE_C_API float spine_event_get_volume(spine_event self);
 SPINE_C_API void spine_event_set_volume(spine_event self, float inValue);
 SPINE_C_API float spine_event_get_balance(spine_event self);

spine-c/src/generated/event_data.cpp

@@ -3,62 +3,75 @@
 
 using namespace spine;
 
-spine_event_data spine_event_data_create(const char * name) {
-    return (spine_event_data) new (__FILE__, __LINE__) EventData(String(name));
+spine_event_data spine_event_data_create(const char *name) {
+	return (spine_event_data) new (__FILE__, __LINE__) EventData(String(name));
 }
 
 void spine_event_data_dispose(spine_event_data self) {
-    delete (EventData*)self;
+	delete (EventData *) self;
 }
 
-const char * spine_event_data_get_name(spine_event_data self) {
-    return ((EventData*)self)->getName().buffer();
+const char *spine_event_data_get_name(spine_event_data self) {
+	EventData *_self = (EventData *) self;
+	return _self->getName().buffer();
 }
 
 int spine_event_data_get_int(spine_event_data self) {
-    return ((EventData*)self)->getInt();
+	EventData *_self = (EventData *) self;
+	return _self->getInt();
 }
 
 void spine_event_data_set_int(spine_event_data self, int inValue) {
-    ((EventData*)self)->setInt(inValue);
+	EventData *_self = (EventData *) self;
+	_self->setInt(inValue);
 }
 
 float spine_event_data_get_float(spine_event_data self) {
-    return ((EventData*)self)->getFloat();
+	EventData *_self = (EventData *) self;
+	return _self->getFloat();
 }
 
 void spine_event_data_set_float(spine_event_data self, float inValue) {
-    ((EventData*)self)->setFloat(inValue);
+	EventData *_self = (EventData *) self;
+	_self->setFloat(inValue);
 }
 
-const char * spine_event_data_get_string(spine_event_data self) {
-    return ((EventData*)self)->getString().buffer();
+const char *spine_event_data_get_string(spine_event_data self) {
+	EventData *_self = (EventData *) self;
+	return _self->getString().buffer();
 }
 
-void spine_event_data_set_string(spine_event_data self, const char * inValue) {
-    ((EventData*)self)->setString(String(inValue));
+void spine_event_data_set_string(spine_event_data self, const char *inValue) {
+	EventData *_self = (EventData *) self;
+	_self->setString(String(inValue));
 }
 
-const char * spine_event_data_get_audio_path(spine_event_data self) {
-    return ((EventData*)self)->getAudioPath().buffer();
+const char *spine_event_data_get_audio_path(spine_event_data self) {
+	EventData *_self = (EventData *) self;
+	return _self->getAudioPath().buffer();
 }
 
-void spine_event_data_set_audio_path(spine_event_data self, const char * inValue) {
-    ((EventData*)self)->setAudioPath(String(inValue));
+void spine_event_data_set_audio_path(spine_event_data self, const char *inValue) {
+	EventData *_self = (EventData *) self;
+	_self->setAudioPath(String(inValue));
 }
 
 float spine_event_data_get_volume(spine_event_data self) {
-    return ((EventData*)self)->getVolume();
+	EventData *_self = (EventData *) self;
+	return _self->getVolume();
 }
 
 void spine_event_data_set_volume(spine_event_data self, float inValue) {
-    ((EventData*)self)->setVolume(inValue);
+	EventData *_self = (EventData *) self;
+	_self->setVolume(inValue);
 }
 
 float spine_event_data_get_balance(spine_event_data self) {
-    return ((EventData*)self)->getBalance();
+	EventData *_self = (EventData *) self;
+	return _self->getBalance();
 }
 
 void spine_event_data_set_balance(spine_event_data self, float inValue) {
-    ((EventData*)self)->setBalance(inValue);
+	EventData *_self = (EventData *) self;
+	_self->setBalance(inValue);
 }

spine-c/src/generated/event_data.h

@@ -8,19 +8,19 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_event_data spine_event_data_create(const char * name);
+SPINE_C_API spine_event_data spine_event_data_create(const char *name);
 
 SPINE_C_API void spine_event_data_dispose(spine_event_data self);
 
-SPINE_C_API const char * spine_event_data_get_name(spine_event_data self);
+SPINE_C_API const char *spine_event_data_get_name(spine_event_data self);
 SPINE_C_API int spine_event_data_get_int(spine_event_data self);
 SPINE_C_API void spine_event_data_set_int(spine_event_data self, int inValue);
 SPINE_C_API float spine_event_data_get_float(spine_event_data self);
 SPINE_C_API void spine_event_data_set_float(spine_event_data self, float inValue);
-SPINE_C_API const char * spine_event_data_get_string(spine_event_data self);
-SPINE_C_API void spine_event_data_set_string(spine_event_data self, const char * inValue);
-SPINE_C_API const char * spine_event_data_get_audio_path(spine_event_data self);
-SPINE_C_API void spine_event_data_set_audio_path(spine_event_data self, const char * inValue);
+SPINE_C_API const char *spine_event_data_get_string(spine_event_data self);
+SPINE_C_API void spine_event_data_set_string(spine_event_data self, const char *inValue);
+SPINE_C_API const char *spine_event_data_get_audio_path(spine_event_data self);
+SPINE_C_API void spine_event_data_set_audio_path(spine_event_data self, const char *inValue);
 SPINE_C_API float spine_event_data_get_volume(spine_event_data self);
 SPINE_C_API void spine_event_data_set_volume(spine_event_data self, float inValue);
 SPINE_C_API float spine_event_data_get_balance(spine_event_data self);

spine-c/src/generated/event_queue_entry.cpp

@@ -4,33 +4,39 @@
 using namespace spine;
 
 spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, spine_track_entry trackEntry, spine_event event) {
-    return (spine_event_queue_entry) new (__FILE__, __LINE__) EventQueueEntry((EventType)eventType, (TrackEntry *)trackEntry, (Event *)event);
+	return (spine_event_queue_entry) new (__FILE__, __LINE__) EventQueueEntry((EventType) eventType, (TrackEntry *) trackEntry, (Event *) event);
 }
 
 void spine_event_queue_entry_dispose(spine_event_queue_entry self) {
-    delete (EventQueueEntry*)self;
+	delete (EventQueueEntry *) self;
 }
 
 spine_event_type spine_event_queue_entry_get__type(spine_event_queue_entry self) {
-    return (spine_event_type)((EventQueueEntry*)self)->_type;
+	EventQueueEntry *_self = (EventQueueEntry *) self;
+	return (spine_event_type) _self->_type;
 }
 
 void spine_event_queue_entry_set__type(spine_event_queue_entry self, spine_event_type value) {
-    ((EventQueueEntry*)self)->_type = (EventType)value;
+	EventQueueEntry *_self = (EventQueueEntry *) self;
+	_self->_type = (EventType) value;
 }
 
 spine_track_entry spine_event_queue_entry_get__entry(spine_event_queue_entry self) {
-    return (spine_track_entry)((EventQueueEntry*)self)->_entry;
+	EventQueueEntry *_self = (EventQueueEntry *) self;
+	return (spine_track_entry) _self->_entry;
 }
 
 void spine_event_queue_entry_set__entry(spine_event_queue_entry self, spine_track_entry value) {
-    ((EventQueueEntry*)self)->_entry = (TrackEntry*)value;
+	EventQueueEntry *_self = (EventQueueEntry *) self;
+	_self->_entry = (TrackEntry *) value;
 }
 
 spine_event spine_event_queue_entry_get__event(spine_event_queue_entry self) {
-    return (spine_event)((EventQueueEntry*)self)->_event;
+	EventQueueEntry *_self = (EventQueueEntry *) self;
+	return (spine_event) _self->_event;
 }
 
 void spine_event_queue_entry_set__event(spine_event_queue_entry self, spine_event value) {
-    ((EventQueueEntry*)self)->_event = (Event*)value;
+	EventQueueEntry *_self = (EventQueueEntry *) self;
+	_self->_event = (Event *) value;
 }

spine-c/src/generated/event_timeline.cpp

@@ -4,49 +4,60 @@
 using namespace spine;
 
 spine_event_timeline spine_event_timeline_create(size_t frameCount) {
-    return (spine_event_timeline) new (__FILE__, __LINE__) EventTimeline(frameCount);
+	return (spine_event_timeline) new (__FILE__, __LINE__) EventTimeline(frameCount);
 }
 
 void spine_event_timeline_dispose(spine_event_timeline self) {
-    delete (EventTimeline*)self;
+	delete (EventTimeline *) self;
 }
 
 spine_rtti spine_event_timeline_get_rtti(spine_event_timeline self) {
-    return (spine_rtti)&((EventTimeline*)self)->getRTTI();
+	EventTimeline *_self = (EventTimeline *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((EventTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	EventTimeline *_self = (EventTimeline *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 size_t spine_event_timeline_get_frame_count(spine_event_timeline self) {
-    return ((EventTimeline*)self)->getFrameCount();
+	EventTimeline *_self = (EventTimeline *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_event spine_event_timeline_get_events(spine_event_timeline self) {
-    return (spine_array_event)&((EventTimeline*)self)->getEvents();
+	EventTimeline *_self = (EventTimeline *) self;
+	return (spine_array_event) &_self->getEvents();
 }
 
 void spine_event_timeline_set_frame(spine_event_timeline self, size_t frame, spine_event event) {
-    ((EventTimeline*)self)->setFrame(frame, (Event *)event);
+	EventTimeline *_self = (EventTimeline *) self;
+	_self->setFrame(frame, (Event *) event);
 }
 
 size_t spine_event_timeline_get_frame_entries(spine_event_timeline self) {
-    return ((Timeline*)(EventTimeline*)self)->getFrameEntries();
+	Timeline *_self = (Timeline *) (EventTimeline *) self;
+	return _self->getFrameEntries();
 }
 
 spine_array_float spine_event_timeline_get_frames(spine_event_timeline self) {
-    return (spine_array_float)&((Timeline*)(EventTimeline*)self)->getFrames();
+	Timeline *_self = (Timeline *) (EventTimeline *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_event_timeline_get_duration(spine_event_timeline self) {
-    return ((Timeline*)(EventTimeline*)self)->getDuration();
+	Timeline *_self = (Timeline *) (EventTimeline *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_event_timeline_get_property_ids(spine_event_timeline self) {
-    return (spine_array_property_id)&((Timeline*)(EventTimeline*)self)->getPropertyIds();
+	Timeline *_self = (Timeline *) (EventTimeline *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 spine_rtti spine_event_timeline_rtti(void) {
-    return (spine_rtti)&EventTimeline::rtti;
+	return (spine_rtti) &EventTimeline::rtti;
 }

spine-c/src/generated/event_timeline.h

@@ -13,7 +13,8 @@ SPINE_C_API spine_event_timeline spine_event_timeline_create(size_t frameCount);
 SPINE_C_API void spine_event_timeline_dispose(spine_event_timeline self);
 
 SPINE_C_API spine_rtti spine_event_timeline_get_rtti(spine_event_timeline self);
-SPINE_C_API void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
 SPINE_C_API size_t spine_event_timeline_get_frame_count(spine_event_timeline self);
 SPINE_C_API spine_array_event spine_event_timeline_get_events(spine_event_timeline self);
 SPINE_C_API void spine_event_timeline_set_frame(spine_event_timeline self, size_t frame, spine_event event);

spine-c/src/generated/event_type.h

@@ -6,12 +6,12 @@ extern "C" {
 #endif
 
 typedef enum spine_event_type {
-    SPINE_EVENT_TYPE_START = 0,
-    SPINE_EVENT_TYPE_INTERRUPT,
-    SPINE_EVENT_TYPE_END,
-    SPINE_EVENT_TYPE_DISPOSE,
-    SPINE_EVENT_TYPE_COMPLETE,
-    SPINE_EVENT_TYPE_EVENT
+	SPINE_EVENT_TYPE_START = 0,
+	SPINE_EVENT_TYPE_INTERRUPT,
+	SPINE_EVENT_TYPE_END,
+	SPINE_EVENT_TYPE_DISPOSE,
+	SPINE_EVENT_TYPE_COMPLETE,
+	SPINE_EVENT_TYPE_EVENT
 } spine_event_type;
 
 #ifdef __cplusplus

spine-c/src/generated/format.h

@@ -6,13 +6,13 @@ extern "C" {
 #endif
 
 typedef enum spine_format {
-    SPINE_FORMAT_ALPHA,
-    SPINE_FORMAT_INTENSITY,
-    SPINE_FORMAT_LUMINANCE_ALPHA,
-    SPINE_FORMAT_RGB565,
-    SPINE_FORMAT_RGBA4444,
-    SPINE_FORMAT_RGB888,
-    SPINE_FORMAT_RGBA8888
+	SPINE_FORMAT_ALPHA,
+	SPINE_FORMAT_INTENSITY,
+	SPINE_FORMAT_LUMINANCE_ALPHA,
+	SPINE_FORMAT_RGB565,
+	SPINE_FORMAT_RGBA4444,
+	SPINE_FORMAT_RGB888,
+	SPINE_FORMAT_RGBA8888
 } spine_format;
 
 #ifdef __cplusplus

spine-c/src/generated/from_property.cpp

@@ -4,33 +4,39 @@
 using namespace spine;
 
 void spine_from_property_dispose(spine_from_property self) {
-    delete (FromProperty*)self;
+	delete (FromProperty *) self;
 }
 
 spine_rtti spine_from_property_get_rtti(spine_from_property self) {
-    return (spine_rtti)&((FromProperty*)self)->getRTTI();
+	FromProperty *_self = (FromProperty *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
-    return ((FromProperty*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
+float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+	FromProperty *_self = (FromProperty *) self;
+	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }
 
 spine_rtti spine_from_property_rtti(void) {
-    return (spine_rtti)&FromProperty::rtti;
+	return (spine_rtti) &FromProperty::rtti;
 }
 
 float spine_from_property_get__offset(spine_from_property self) {
-    return ((FromProperty*)self)->_offset;
+	FromProperty *_self = (FromProperty *) self;
+	return _self->_offset;
 }
 
 void spine_from_property_set__offset(spine_from_property self, float value) {
-    ((FromProperty*)self)->_offset = value;
+	FromProperty *_self = (FromProperty *) self;
+	_self->_offset = value;
 }
 
 spine_array_to_property spine_from_property_get__to(spine_from_property self) {
-    return (spine_array_to_property)&((FromProperty*)self)->_to;
+	FromProperty *_self = (FromProperty *) self;
+	return (spine_array_to_property) &_self->_to;
 }
 
 void spine_from_property_set__to(spine_from_property self, spine_array_to_property value) {
-    ((FromProperty*)self)->_to = *((Array<ToProperty *>*)value);
+	FromProperty *_self = (FromProperty *) self;
+	_self->_to = *((Array<ToProperty *> *) value);
 }

spine-c/src/generated/from_property.h

@@ -11,7 +11,7 @@ extern "C" {
 SPINE_C_API void spine_from_property_dispose(spine_from_property self);
 
 SPINE_C_API spine_rtti spine_from_property_get_rtti(spine_from_property self);
-SPINE_C_API float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
 SPINE_C_API spine_rtti spine_from_property_rtti(void);
 SPINE_C_API float spine_from_property_get__offset(spine_from_property self);
 SPINE_C_API void spine_from_property_set__offset(spine_from_property self, float value);

spine-c/src/generated/from_rotate.cpp

@@ -4,21 +4,23 @@
 using namespace spine;
 
 spine_from_rotate spine_from_rotate_create(void) {
-    return (spine_from_rotate) new (__FILE__, __LINE__) FromRotate();
+	return (spine_from_rotate) new (__FILE__, __LINE__) FromRotate();
 }
 
 void spine_from_rotate_dispose(spine_from_rotate self) {
-    delete (FromRotate*)self;
+	delete (FromRotate *) self;
 }
 
 spine_rtti spine_from_rotate_get_rtti(spine_from_rotate self) {
-    return (spine_rtti)&((FromRotate*)self)->getRTTI();
+	FromRotate *_self = (FromRotate *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
-    return ((FromRotate*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
+float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+	FromRotate *_self = (FromRotate *) self;
+	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }
 
 spine_rtti spine_from_rotate_rtti(void) {
-    return (spine_rtti)&FromRotate::rtti;
+	return (spine_rtti) &FromRotate::rtti;
 }

spine-c/src/generated/from_rotate.h

@@ -13,7 +13,7 @@ SPINE_C_API spine_from_rotate spine_from_rotate_create(void);
 SPINE_C_API void spine_from_rotate_dispose(spine_from_rotate self);
 
 SPINE_C_API spine_rtti spine_from_rotate_get_rtti(spine_from_rotate self);
-SPINE_C_API float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
 SPINE_C_API spine_rtti spine_from_rotate_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/from_scale_x.cpp

@@ -4,21 +4,23 @@
 using namespace spine;
 
 spine_from_scale_x spine_from_scale_x_create(void) {
-    return (spine_from_scale_x) new (__FILE__, __LINE__) FromScaleX();
+	return (spine_from_scale_x) new (__FILE__, __LINE__) FromScaleX();
 }
 
 void spine_from_scale_x_dispose(spine_from_scale_x self) {
-    delete (FromScaleX*)self;
+	delete (FromScaleX *) self;
 }
 
 spine_rtti spine_from_scale_x_get_rtti(spine_from_scale_x self) {
-    return (spine_rtti)&((FromScaleX*)self)->getRTTI();
+	FromScaleX *_self = (FromScaleX *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
-    return ((FromScaleX*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
+float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+	FromScaleX *_self = (FromScaleX *) self;
+	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }
 
 spine_rtti spine_from_scale_x_rtti(void) {
-    return (spine_rtti)&FromScaleX::rtti;
+	return (spine_rtti) &FromScaleX::rtti;
 }

spine-c/src/generated/from_scale_x.h

@@ -13,7 +13,7 @@ SPINE_C_API spine_from_scale_x spine_from_scale_x_create(void);
 SPINE_C_API void spine_from_scale_x_dispose(spine_from_scale_x self);
 
 SPINE_C_API spine_rtti spine_from_scale_x_get_rtti(spine_from_scale_x self);
-SPINE_C_API float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
 SPINE_C_API spine_rtti spine_from_scale_x_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/from_scale_y.cpp

@@ -4,21 +4,23 @@
 using namespace spine;
 
 spine_from_scale_y spine_from_scale_y_create(void) {
-    return (spine_from_scale_y) new (__FILE__, __LINE__) FromScaleY();
+	return (spine_from_scale_y) new (__FILE__, __LINE__) FromScaleY();
 }
 
 void spine_from_scale_y_dispose(spine_from_scale_y self) {
-    delete (FromScaleY*)self;
+	delete (FromScaleY *) self;
 }
 
 spine_rtti spine_from_scale_y_get_rtti(spine_from_scale_y self) {
-    return (spine_rtti)&((FromScaleY*)self)->getRTTI();
+	FromScaleY *_self = (FromScaleY *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
-    return ((FromScaleY*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
+float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+	FromScaleY *_self = (FromScaleY *) self;
+	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }
 
 spine_rtti spine_from_scale_y_rtti(void) {
-    return (spine_rtti)&FromScaleY::rtti;
+	return (spine_rtti) &FromScaleY::rtti;
 }

spine-c/src/generated/from_scale_y.h

@@ -13,7 +13,7 @@ SPINE_C_API spine_from_scale_y spine_from_scale_y_create(void);
 SPINE_C_API void spine_from_scale_y_dispose(spine_from_scale_y self);
 
 SPINE_C_API spine_rtti spine_from_scale_y_get_rtti(spine_from_scale_y self);
-SPINE_C_API float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
 SPINE_C_API spine_rtti spine_from_scale_y_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/from_shear_y.cpp

@@ -4,21 +4,23 @@
 using namespace spine;
 
 spine_from_shear_y spine_from_shear_y_create(void) {
-    return (spine_from_shear_y) new (__FILE__, __LINE__) FromShearY();
+	return (spine_from_shear_y) new (__FILE__, __LINE__) FromShearY();
 }
 
 void spine_from_shear_y_dispose(spine_from_shear_y self) {
-    delete (FromShearY*)self;
+	delete (FromShearY *) self;
 }
 
 spine_rtti spine_from_shear_y_get_rtti(spine_from_shear_y self) {
-    return (spine_rtti)&((FromShearY*)self)->getRTTI();
+	FromShearY *_self = (FromShearY *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
-    return ((FromShearY*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
+float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+	FromShearY *_self = (FromShearY *) self;
+	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }
 
 spine_rtti spine_from_shear_y_rtti(void) {
-    return (spine_rtti)&FromShearY::rtti;
+	return (spine_rtti) &FromShearY::rtti;
 }

spine-c/src/generated/from_shear_y.h

@@ -13,7 +13,7 @@ SPINE_C_API spine_from_shear_y spine_from_shear_y_create(void);
 SPINE_C_API void spine_from_shear_y_dispose(spine_from_shear_y self);
 
 SPINE_C_API spine_rtti spine_from_shear_y_get_rtti(spine_from_shear_y self);
-SPINE_C_API float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
 SPINE_C_API spine_rtti spine_from_shear_y_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/from_x.cpp

@@ -4,21 +4,23 @@
 using namespace spine;
 
 spine_from_x spine_from_x_create(void) {
-    return (spine_from_x) new (__FILE__, __LINE__) FromX();
+	return (spine_from_x) new (__FILE__, __LINE__) FromX();
 }
 
 void spine_from_x_dispose(spine_from_x self) {
-    delete (FromX*)self;
+	delete (FromX *) self;
 }
 
 spine_rtti spine_from_x_get_rtti(spine_from_x self) {
-    return (spine_rtti)&((FromX*)self)->getRTTI();
+	FromX *_self = (FromX *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
-    return ((FromX*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
+float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+	FromX *_self = (FromX *) self;
+	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }
 
 spine_rtti spine_from_x_rtti(void) {
-    return (spine_rtti)&FromX::rtti;
+	return (spine_rtti) &FromX::rtti;
 }

spine-c/src/generated/from_x.h

@@ -13,7 +13,7 @@ SPINE_C_API spine_from_x spine_from_x_create(void);
 SPINE_C_API void spine_from_x_dispose(spine_from_x self);
 
 SPINE_C_API spine_rtti spine_from_x_get_rtti(spine_from_x self);
-SPINE_C_API float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
 SPINE_C_API spine_rtti spine_from_x_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/from_y.cpp

@@ -4,21 +4,23 @@
 using namespace spine;
 
 spine_from_y spine_from_y_create(void) {
-    return (spine_from_y) new (__FILE__, __LINE__) FromY();
+	return (spine_from_y) new (__FILE__, __LINE__) FromY();
 }
 
 void spine_from_y_dispose(spine_from_y self) {
-    delete (FromY*)self;
+	delete (FromY *) self;
 }
 
 spine_rtti spine_from_y_get_rtti(spine_from_y self) {
-    return (spine_rtti)&((FromY*)self)->getRTTI();
+	FromY *_self = (FromY *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets) {
-    return ((FromY*)self)->value(*((Skeleton*)skeleton), *((BonePose*)source), local, offsets);
+float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
+	FromY *_self = (FromY *) self;
+	return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
 }
 
 spine_rtti spine_from_y_rtti(void) {
-    return (spine_rtti)&FromY::rtti;
+	return (spine_rtti) &FromY::rtti;
 }

spine-c/src/generated/from_y.h

@@ -13,7 +13,7 @@ SPINE_C_API spine_from_y spine_from_y_create(void);
 SPINE_C_API void spine_from_y_dispose(spine_from_y self);
 
 SPINE_C_API spine_rtti spine_from_y_get_rtti(spine_from_y self);
-SPINE_C_API float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float * offsets);
+SPINE_C_API float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
 SPINE_C_API spine_rtti spine_from_y_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/ik_constraint.cpp

@@ -4,85 +4,111 @@
 using namespace spine;
 
 spine_ik_constraint spine_ik_constraint_create(spine_ik_constraint_data data, spine_skeleton skeleton) {
-    return (spine_ik_constraint) new (__FILE__, __LINE__) IkConstraint(*((IkConstraintData*)data), *((Skeleton*)skeleton));
+	return (spine_ik_constraint) new (__FILE__, __LINE__) IkConstraint(*((IkConstraintData *) data), *((Skeleton *) skeleton));
 }
 
 void spine_ik_constraint_dispose(spine_ik_constraint self) {
-    delete (IkConstraint*)self;
+	delete (IkConstraint *) self;
 }
 
 spine_rtti spine_ik_constraint_get_rtti(spine_ik_constraint self) {
-    return (spine_rtti)&((IkConstraint*)self)->getRTTI();
+	IkConstraint *_self = (IkConstraint *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 spine_ik_constraint spine_ik_constraint_copy(spine_ik_constraint self, spine_skeleton skeleton) {
-    return (spine_ik_constraint)((IkConstraint*)self)->copy(*((Skeleton*)skeleton));
+	IkConstraint *_self = (IkConstraint *) self;
+	return (spine_ik_constraint) _self->copy(*((Skeleton *) skeleton));
 }
 
 void spine_ik_constraint_update(spine_ik_constraint self, spine_skeleton skeleton, spine_physics physics) {
-    ((IkConstraint*)self)->update(*((Skeleton*)skeleton), (Physics)physics);
+	IkConstraint *_self = (IkConstraint *) self;
+	_self->update(*((Skeleton *) skeleton), (Physics) physics);
 }
 
 void spine_ik_constraint_sort(spine_ik_constraint self, spine_skeleton skeleton) {
-    ((IkConstraint*)self)->sort(*((Skeleton*)skeleton));
+	IkConstraint *_self = (IkConstraint *) self;
+	_self->sort(*((Skeleton *) skeleton));
 }
 
 bool spine_ik_constraint_is_source_active(spine_ik_constraint self) {
-    return ((IkConstraint*)self)->isSourceActive();
+	IkConstraint *_self = (IkConstraint *) self;
+	return _self->isSourceActive();
 }
 
 spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self) {
-    return (spine_ik_constraint_data)&((IkConstraint*)self)->getData();
+	IkConstraint *_self = (IkConstraint *) self;
+	return (spine_ik_constraint_data) &_self->getData();
 }
 
 spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self) {
-    return (spine_array_bone_pose)&((IkConstraint*)self)->getBones();
+	IkConstraint *_self = (IkConstraint *) self;
+	return (spine_array_bone_pose) &_self->getBones();
 }
 
 spine_bone spine_ik_constraint_get_target(spine_ik_constraint self) {
-    return (spine_bone)((IkConstraint*)self)->getTarget();
+	IkConstraint *_self = (IkConstraint *) self;
+	return (spine_bone) _self->getTarget();
 }
 
 void spine_ik_constraint_set_target(spine_ik_constraint self, spine_bone inValue) {
-    ((IkConstraint*)self)->setTarget((Bone *)inValue);
+	IkConstraint *_self = (IkConstraint *) self;
+	_self->setTarget((Bone *) inValue);
 }
 
-void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone_pose bone, float targetX, float targetY, bool compress, bool stretch, bool uniform, float mix) {
-    IkConstraint::apply(*((Skeleton*)skeleton), *((BonePose*)bone), targetX, targetY, compress, stretch, uniform, mix);
+void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone_pose bone, float targetX, float targetY, bool compress, bool stretch,
+								 bool uniform, float mix) {
+	IkConstraint::apply(*((Skeleton *) skeleton), *((BonePose *) bone), targetX, targetY, compress, stretch, uniform, mix);
 }
 
-void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent, spine_bone_pose child, float targetX, float targetY, int bendDirection, bool stretch, bool uniform, float softness, float mix) {
-    IkConstraint::apply(*((Skeleton*)skeleton), *((BonePose*)parent), *((BonePose*)child), targetX, targetY, bendDirection, stretch, uniform, softness, mix);
+void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent, spine_bone_pose child, float targetX, float targetY,
+								 int bendDirection, bool stretch, bool uniform, float softness, float mix) {
+	IkConstraint::apply(*((Skeleton *) skeleton), *((BonePose *) parent), *((BonePose *) child), targetX, targetY, bendDirection, stretch, uniform,
+						softness, mix);
 }
 
 spine_ik_constraint_pose spine_ik_constraint_get_pose(spine_ik_constraint self) {
-    return (spine_ik_constraint_pose)&((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->getPose();
+	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
+		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
+	return (spine_ik_constraint_pose) &_self->getPose();
 }
 
 spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(spine_ik_constraint self) {
-    return (spine_ik_constraint_pose)&((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->getAppliedPose();
+	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
+		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
+	return (spine_ik_constraint_pose) &_self->getAppliedPose();
 }
 
 void spine_ik_constraint_reset_constrained(spine_ik_constraint self) {
-    ((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->resetConstrained();
+	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
+		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
+	_self->resetConstrained();
 }
 
 void spine_ik_constraint_constrained(spine_ik_constraint self) {
-    ((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->constrained();
+	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
+		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
+	_self->constrained();
 }
 
 bool spine_ik_constraint_is_pose_equal_to_applied(spine_ik_constraint self) {
-    return ((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->isPoseEqualToApplied();
+	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
+		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
+	return _self->isPoseEqualToApplied();
 }
 
 bool spine_ik_constraint_is_active(spine_ik_constraint self) {
-    return ((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->isActive();
+	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
+		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
+	return _self->isActive();
 }
 
 void spine_ik_constraint_set_active(spine_ik_constraint self, bool active) {
-    ((ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>*)(IkConstraint*)self)->setActive(active);
+	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
+		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraint *) self;
+	_self->setActive(active);
 }
 
 spine_rtti spine_ik_constraint_rtti(void) {
-    return (spine_rtti)&IkConstraint::rtti;
+	return (spine_rtti) &IkConstraint::rtti;
 }

spine-c/src/generated/ik_constraint.h

@@ -21,8 +21,10 @@ SPINE_C_API spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_const
 SPINE_C_API spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self);
 SPINE_C_API spine_bone spine_ik_constraint_get_target(spine_ik_constraint self);
 SPINE_C_API void spine_ik_constraint_set_target(spine_ik_constraint self, spine_bone inValue);
-SPINE_C_API void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone_pose bone, float targetX, float targetY, bool compress, bool stretch, bool uniform, float mix);
-SPINE_C_API void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent, spine_bone_pose child, float targetX, float targetY, int bendDirection, bool stretch, bool uniform, float softness, float mix);
+SPINE_C_API void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone_pose bone, float targetX, float targetY, bool compress, bool stretch,
+											 bool uniform, float mix);
+SPINE_C_API void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent, spine_bone_pose child, float targetX, float targetY,
+											 int bendDirection, bool stretch, bool uniform, float softness, float mix);
 SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_get_pose(spine_ik_constraint self);
 SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(spine_ik_constraint self);
 SPINE_C_API void spine_ik_constraint_reset_constrained(spine_ik_constraint self);

spine-c/src/generated/ik_constraint_data.cpp

@@ -3,58 +3,73 @@
 
 using namespace spine;
 
-spine_ik_constraint_data spine_ik_constraint_data_create(const char * name) {
-    return (spine_ik_constraint_data) new (__FILE__, __LINE__) IkConstraintData(String(name));
+spine_ik_constraint_data spine_ik_constraint_data_create(const char *name) {
+	return (spine_ik_constraint_data) new (__FILE__, __LINE__) IkConstraintData(String(name));
 }
 
 void spine_ik_constraint_data_dispose(spine_ik_constraint_data self) {
-    delete (IkConstraintData*)self;
+	delete (IkConstraintData *) self;
 }
 
 spine_rtti spine_ik_constraint_data_get_rtti(spine_ik_constraint_data self) {
-    return (spine_rtti)&((IkConstraintData*)self)->getRTTI();
+	IkConstraintData *_self = (IkConstraintData *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 spine_constraint spine_ik_constraint_data_create_method(spine_ik_constraint_data self, spine_skeleton skeleton) {
-    return (spine_constraint)((IkConstraintData*)self)->create(*((Skeleton*)skeleton));
+	IkConstraintData *_self = (IkConstraintData *) self;
+	return (spine_constraint) _self->create(*((Skeleton *) skeleton));
 }
 
 spine_array_bone_data spine_ik_constraint_data_get_bones(spine_ik_constraint_data self) {
-    return (spine_array_bone_data)&((IkConstraintData*)self)->getBones();
+	IkConstraintData *_self = (IkConstraintData *) self;
+	return (spine_array_bone_data) &_self->getBones();
 }
 
 spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data self) {
-    return (spine_bone_data)((IkConstraintData*)self)->getTarget();
+	IkConstraintData *_self = (IkConstraintData *) self;
+	return (spine_bone_data) _self->getTarget();
 }
 
 void spine_ik_constraint_data_set_target(spine_ik_constraint_data self, spine_bone_data inValue) {
-    ((IkConstraintData*)self)->setTarget((BoneData *)inValue);
+	IkConstraintData *_self = (IkConstraintData *) self;
+	_self->setTarget((BoneData *) inValue);
 }
 
 bool spine_ik_constraint_data_get_uniform(spine_ik_constraint_data self) {
-    return ((IkConstraintData*)self)->getUniform();
+	IkConstraintData *_self = (IkConstraintData *) self;
+	return _self->getUniform();
 }
 
 void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data self, bool uniform) {
-    ((IkConstraintData*)self)->setUniform(uniform);
+	IkConstraintData *_self = (IkConstraintData *) self;
+	_self->setUniform(uniform);
 }
 
-const char * spine_ik_constraint_data_get_name(spine_ik_constraint_data self) {
-    return ((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->getName().buffer();
+const char *spine_ik_constraint_data_get_name(spine_ik_constraint_data self) {
+	ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
+		self;
+	return _self->getName().buffer();
 }
 
 bool spine_ik_constraint_data_get_skin_required(spine_ik_constraint_data self) {
-    return ((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->getSkinRequired();
+	ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
+		self;
+	return _self->getSkinRequired();
 }
 
 spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data self) {
-    return (spine_ik_constraint_pose)&((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->getSetupPose();
+	ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
+		self;
+	return (spine_ik_constraint_pose) &_self->getSetupPose();
 }
 
 void spine_ik_constraint_data_set_skin_required(spine_ik_constraint_data self, bool skinRequired) {
-    ((ConstraintDataGeneric<IkConstraint, IkConstraintPose>*)(IkConstraintData*)self)->setSkinRequired(skinRequired);
+	ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
+		self;
+	_self->setSkinRequired(skinRequired);
 }
 
 spine_rtti spine_ik_constraint_data_rtti(void) {
-    return (spine_rtti)&IkConstraintData::rtti;
+	return (spine_rtti) &IkConstraintData::rtti;
 }

spine-c/src/generated/ik_constraint_data.h

@@ -8,7 +8,7 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_ik_constraint_data spine_ik_constraint_data_create(const char * name);
+SPINE_C_API spine_ik_constraint_data spine_ik_constraint_data_create(const char *name);
 
 SPINE_C_API void spine_ik_constraint_data_dispose(spine_ik_constraint_data self);
 
@@ -19,7 +19,7 @@ SPINE_C_API spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constra
 SPINE_C_API void spine_ik_constraint_data_set_target(spine_ik_constraint_data self, spine_bone_data inValue);
 SPINE_C_API bool spine_ik_constraint_data_get_uniform(spine_ik_constraint_data self);
 SPINE_C_API void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data self, bool uniform);
-SPINE_C_API const char * spine_ik_constraint_data_get_name(spine_ik_constraint_data self);
+SPINE_C_API const char *spine_ik_constraint_data_get_name(spine_ik_constraint_data self);
 SPINE_C_API bool spine_ik_constraint_data_get_skin_required(spine_ik_constraint_data self);
 SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data self);
 SPINE_C_API void spine_ik_constraint_data_set_skin_required(spine_ik_constraint_data self, bool skinRequired);

spine-c/src/generated/ik_constraint_pose.cpp

@@ -4,53 +4,64 @@
 using namespace spine;
 
 spine_ik_constraint_pose spine_ik_constraint_pose_create(void) {
-    return (spine_ik_constraint_pose) new (__FILE__, __LINE__) IkConstraintPose();
+	return (spine_ik_constraint_pose) new (__FILE__, __LINE__) IkConstraintPose();
 }
 
 void spine_ik_constraint_pose_dispose(spine_ik_constraint_pose self) {
-    delete (IkConstraintPose*)self;
+	delete (IkConstraintPose *) self;
 }
 
 void spine_ik_constraint_pose_set(spine_ik_constraint_pose self, spine_ik_constraint_pose pose) {
-    ((IkConstraintPose*)self)->set(*((IkConstraintPose*)pose));
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	_self->set(*((IkConstraintPose *) pose));
 }
 
 float spine_ik_constraint_pose_get_mix(spine_ik_constraint_pose self) {
-    return ((IkConstraintPose*)self)->getMix();
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	return _self->getMix();
 }
 
 void spine_ik_constraint_pose_set_mix(spine_ik_constraint_pose self, float mix) {
-    ((IkConstraintPose*)self)->setMix(mix);
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	_self->setMix(mix);
 }
 
 float spine_ik_constraint_pose_get_softness(spine_ik_constraint_pose self) {
-    return ((IkConstraintPose*)self)->getSoftness();
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	return _self->getSoftness();
 }
 
 void spine_ik_constraint_pose_set_softness(spine_ik_constraint_pose self, float softness) {
-    ((IkConstraintPose*)self)->setSoftness(softness);
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	_self->setSoftness(softness);
 }
 
 int spine_ik_constraint_pose_get_bend_direction(spine_ik_constraint_pose self) {
-    return ((IkConstraintPose*)self)->getBendDirection();
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	return _self->getBendDirection();
 }
 
 void spine_ik_constraint_pose_set_bend_direction(spine_ik_constraint_pose self, int bendDirection) {
-    ((IkConstraintPose*)self)->setBendDirection(bendDirection);
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	_self->setBendDirection(bendDirection);
 }
 
 bool spine_ik_constraint_pose_get_compress(spine_ik_constraint_pose self) {
-    return ((IkConstraintPose*)self)->getCompress();
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	return _self->getCompress();
 }
 
 void spine_ik_constraint_pose_set_compress(spine_ik_constraint_pose self, bool compress) {
-    ((IkConstraintPose*)self)->setCompress(compress);
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	_self->setCompress(compress);
 }
 
 bool spine_ik_constraint_pose_get_stretch(spine_ik_constraint_pose self) {
-    return ((IkConstraintPose*)self)->getStretch();
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	return _self->getStretch();
 }
 
 void spine_ik_constraint_pose_set_stretch(spine_ik_constraint_pose self, bool stretch) {
-    ((IkConstraintPose*)self)->setStretch(stretch);
+	IkConstraintPose *_self = (IkConstraintPose *) self;
+	_self->setStretch(stretch);
 }

spine-c/src/generated/ik_constraint_timeline.cpp

@@ -4,73 +4,93 @@
 using namespace spine;
 
 spine_ik_constraint_timeline spine_ik_constraint_timeline_create(size_t frameCount, size_t bezierCount, int constraintIndex) {
-    return (spine_ik_constraint_timeline) new (__FILE__, __LINE__) IkConstraintTimeline(frameCount, bezierCount, constraintIndex);
+	return (spine_ik_constraint_timeline) new (__FILE__, __LINE__) IkConstraintTimeline(frameCount, bezierCount, constraintIndex);
 }
 
 void spine_ik_constraint_timeline_dispose(spine_ik_constraint_timeline self) {
-    delete (IkConstraintTimeline*)self;
+	delete (IkConstraintTimeline *) self;
 }
 
 spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline self) {
-    return (spine_rtti)&((IkConstraintTimeline*)self)->getRTTI();
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((IkConstraintTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
+										spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+										bool appliedPose) {
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
-void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness, int bendDirection, bool compress, bool stretch) {
-    ((IkConstraintTimeline*)self)->setFrame(frame, time, mix, softness, bendDirection, compress, stretch);
+void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness, int bendDirection,
+											bool compress, bool stretch) {
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
+	_self->setFrame(frame, time, mix, softness, bendDirection, compress, stretch);
 }
 
 void spine_ik_constraint_timeline_set_linear(spine_ik_constraint_timeline self, size_t frame) {
-    ((CurveTimeline*)(IkConstraintTimeline*)self)->setLinear(frame);
+	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	_self->setLinear(frame);
 }
 
 void spine_ik_constraint_timeline_set_stepped(spine_ik_constraint_timeline self, size_t frame) {
-    ((CurveTimeline*)(IkConstraintTimeline*)self)->setStepped(frame);
+	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	_self->setStepped(frame);
 }
 
-void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
-    ((CurveTimeline*)(IkConstraintTimeline*)self)->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
+void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
+											 float cx1, float cy1, float cx2, float cy2, float time2, float value2) {
+	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_ik_constraint_timeline_get_bezier_value(spine_ik_constraint_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-    return ((CurveTimeline*)(IkConstraintTimeline*)self)->getBezierValue(time, frame, valueOffset, i);
+	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_ik_constraint_timeline_get_curves(spine_ik_constraint_timeline self) {
-    return (spine_array_float)&((CurveTimeline*)(IkConstraintTimeline*)self)->getCurves();
+	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_ik_constraint_timeline_get_frame_entries(spine_ik_constraint_timeline self) {
-    return ((CurveTimeline*)(IkConstraintTimeline*)self)->getFrameEntries();
+	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	return _self->getFrameEntries();
 }
 
 size_t spine_ik_constraint_timeline_get_frame_count(spine_ik_constraint_timeline self) {
-    return ((CurveTimeline*)(IkConstraintTimeline*)self)->getFrameCount();
+	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_float spine_ik_constraint_timeline_get_frames(spine_ik_constraint_timeline self) {
-    return (spine_array_float)&((CurveTimeline*)(IkConstraintTimeline*)self)->getFrames();
+	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_ik_constraint_timeline_get_duration(spine_ik_constraint_timeline self) {
-    return ((CurveTimeline*)(IkConstraintTimeline*)self)->getDuration();
+	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_ik_constraint_timeline_get_property_ids(spine_ik_constraint_timeline self) {
-    return (spine_array_property_id)&((CurveTimeline*)(IkConstraintTimeline*)self)->getPropertyIds();
+	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 int spine_ik_constraint_timeline_get_constraint_index(spine_ik_constraint_timeline self) {
-    return ((ConstraintTimeline*)(IkConstraintTimeline*)self)->getConstraintIndex();
+	ConstraintTimeline *_self = (ConstraintTimeline *) (IkConstraintTimeline *) self;
+	return _self->getConstraintIndex();
 }
 
 void spine_ik_constraint_timeline_set_constraint_index(spine_ik_constraint_timeline self, int inValue) {
-    ((ConstraintTimeline*)(IkConstraintTimeline*)self)->setConstraintIndex(inValue);
+	ConstraintTimeline *_self = (ConstraintTimeline *) (IkConstraintTimeline *) self;
+	_self->setConstraintIndex(inValue);
 }
 
 spine_rtti spine_ik_constraint_timeline_rtti(void) {
-    return (spine_rtti)&IkConstraintTimeline::rtti;
+	return (spine_rtti) &IkConstraintTimeline::rtti;
 }

spine-c/src/generated/ik_constraint_timeline.h

@@ -13,12 +13,17 @@ SPINE_C_API spine_ik_constraint_timeline spine_ik_constraint_timeline_create(siz
 SPINE_C_API void spine_ik_constraint_timeline_dispose(spine_ik_constraint_timeline self);
 
 SPINE_C_API spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline self);
-SPINE_C_API void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
-SPINE_C_API void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness, int bendDirection, bool compress, bool stretch);
+SPINE_C_API void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
+													spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+													bool appliedPose);
+SPINE_C_API void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness,
+														int bendDirection, bool compress, bool stretch);
 SPINE_C_API void spine_ik_constraint_timeline_set_linear(spine_ik_constraint_timeline self, size_t frame);
 SPINE_C_API void spine_ik_constraint_timeline_set_stepped(spine_ik_constraint_timeline self, size_t frame);
-SPINE_C_API void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
-SPINE_C_API float spine_ik_constraint_timeline_get_bezier_value(spine_ik_constraint_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
+SPINE_C_API void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline self, size_t bezier, size_t frame, float value, float time1,
+														 float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2);
+SPINE_C_API float spine_ik_constraint_timeline_get_bezier_value(spine_ik_constraint_timeline self, float time, size_t frame, size_t valueOffset,
+																size_t i);
 SPINE_C_API spine_array_float spine_ik_constraint_timeline_get_curves(spine_ik_constraint_timeline self);
 SPINE_C_API size_t spine_ik_constraint_timeline_get_frame_entries(spine_ik_constraint_timeline self);
 SPINE_C_API size_t spine_ik_constraint_timeline_get_frame_count(spine_ik_constraint_timeline self);

spine-c/src/generated/inherit.h

@@ -6,11 +6,11 @@ extern "C" {
 #endif
 
 typedef enum spine_inherit {
-    SPINE_INHERIT_NORMAL = 0,
-    SPINE_INHERIT_ONLY_TRANSLATION,
-    SPINE_INHERIT_NO_ROTATION_OR_REFLECTION,
-    SPINE_INHERIT_NO_SCALE,
-    SPINE_INHERIT_NO_SCALE_OR_REFLECTION
+	SPINE_INHERIT_NORMAL = 0,
+	SPINE_INHERIT_ONLY_TRANSLATION,
+	SPINE_INHERIT_NO_ROTATION_OR_REFLECTION,
+	SPINE_INHERIT_NO_SCALE,
+	SPINE_INHERIT_NO_SCALE_OR_REFLECTION
 } spine_inherit;
 
 #ifdef __cplusplus

spine-c/src/generated/inherit_timeline.cpp

@@ -4,53 +4,65 @@
 using namespace spine;
 
 spine_inherit_timeline spine_inherit_timeline_create(size_t frameCount, int boneIndex) {
-    return (spine_inherit_timeline) new (__FILE__, __LINE__) InheritTimeline(frameCount, boneIndex);
+	return (spine_inherit_timeline) new (__FILE__, __LINE__) InheritTimeline(frameCount, boneIndex);
 }
 
 void spine_inherit_timeline_dispose(spine_inherit_timeline self) {
-    delete (InheritTimeline*)self;
+	delete (InheritTimeline *) self;
 }
 
 spine_rtti spine_inherit_timeline_get_rtti(spine_inherit_timeline self) {
-    return (spine_rtti)&((InheritTimeline*)self)->getRTTI();
+	InheritTimeline *_self = (InheritTimeline *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_inherit_timeline_set_frame(spine_inherit_timeline self, int frame, float time, spine_inherit inherit) {
-    ((InheritTimeline*)self)->setFrame(frame, time, (Inherit)inherit);
+	InheritTimeline *_self = (InheritTimeline *) self;
+	_self->setFrame(frame, time, (Inherit) inherit);
 }
 
-void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-    ((InheritTimeline*)self)->apply(*((Skeleton*)skeleton), lastTime, time, (Array<Event *> *)pEvents, alpha, (MixBlend)blend, (MixDirection)direction, appliedPose);
+void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
+								  float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
+	InheritTimeline *_self = (InheritTimeline *) self;
+	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
+				 appliedPose);
 }
 
 size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline self) {
-    return ((Timeline*)(InheritTimeline*)self)->getFrameEntries();
+	Timeline *_self = (Timeline *) (InheritTimeline *) self;
+	return _self->getFrameEntries();
 }
 
 size_t spine_inherit_timeline_get_frame_count(spine_inherit_timeline self) {
-    return ((Timeline*)(InheritTimeline*)self)->getFrameCount();
+	Timeline *_self = (Timeline *) (InheritTimeline *) self;
+	return _self->getFrameCount();
 }
 
 spine_array_float spine_inherit_timeline_get_frames(spine_inherit_timeline self) {
-    return (spine_array_float)&((Timeline*)(InheritTimeline*)self)->getFrames();
+	Timeline *_self = (Timeline *) (InheritTimeline *) self;
+	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_inherit_timeline_get_duration(spine_inherit_timeline self) {
-    return ((Timeline*)(InheritTimeline*)self)->getDuration();
+	Timeline *_self = (Timeline *) (InheritTimeline *) self;
+	return _self->getDuration();
 }
 
 spine_array_property_id spine_inherit_timeline_get_property_ids(spine_inherit_timeline self) {
-    return (spine_array_property_id)&((Timeline*)(InheritTimeline*)self)->getPropertyIds();
+	Timeline *_self = (Timeline *) (InheritTimeline *) self;
+	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
 int spine_inherit_timeline_get_bone_index(spine_inherit_timeline self) {
-    return ((BoneTimeline*)(InheritTimeline*)self)->getBoneIndex();
+	BoneTimeline *_self = (BoneTimeline *) (InheritTimeline *) self;
+	return _self->getBoneIndex();
 }
 
 void spine_inherit_timeline_set_bone_index(spine_inherit_timeline self, int inValue) {
-    ((BoneTimeline*)(InheritTimeline*)self)->setBoneIndex(inValue);
+	BoneTimeline *_self = (BoneTimeline *) (InheritTimeline *) self;
+	_self->setBoneIndex(inValue);
 }
 
 spine_rtti spine_inherit_timeline_rtti(void) {
-    return (spine_rtti)&InheritTimeline::rtti;
+	return (spine_rtti) &InheritTimeline::rtti;
 }

spine-c/src/generated/inherit_timeline.h

@@ -14,7 +14,9 @@ SPINE_C_API void spine_inherit_timeline_dispose(spine_inherit_timeline self);
 
 SPINE_C_API spine_rtti spine_inherit_timeline_get_rtti(spine_inherit_timeline self);
 SPINE_C_API void spine_inherit_timeline_set_frame(spine_inherit_timeline self, int frame, float time, spine_inherit inherit);
-SPINE_C_API void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time,
+											  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
+											  bool appliedPose);
 SPINE_C_API size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline self);
 SPINE_C_API size_t spine_inherit_timeline_get_frame_count(spine_inherit_timeline self);
 SPINE_C_API spine_array_float spine_inherit_timeline_get_frames(spine_inherit_timeline self);

spine-c/src/generated/linked_mesh.cpp

@@ -3,14 +3,17 @@
 
 using namespace spine;
 
-spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char * parent, bool inheritTimelines) {
-    return (spine_linked_mesh) new (__FILE__, __LINE__) LinkedMesh((MeshAttachment *)mesh, skinIndex, slotIndex, String(parent), inheritTimelines);
+spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char *parent,
+										   bool inheritTimelines) {
+	return (spine_linked_mesh) new (__FILE__, __LINE__) LinkedMesh((MeshAttachment *) mesh, skinIndex, slotIndex, String(parent), inheritTimelines);
 }
 
-spine_linked_mesh spine_linked_mesh_create2(spine_mesh_attachment mesh, const char * skin, size_t slotIndex, const char * parent, bool inheritTimelines) {
-    return (spine_linked_mesh) new (__FILE__, __LINE__) LinkedMesh((MeshAttachment *)mesh, String(skin), slotIndex, String(parent), inheritTimelines);
+spine_linked_mesh spine_linked_mesh_create2(spine_mesh_attachment mesh, const char *skin, size_t slotIndex, const char *parent,
+											bool inheritTimelines) {
+	return (spine_linked_mesh) new (__FILE__, __LINE__)
+		LinkedMesh((MeshAttachment *) mesh, String(skin), slotIndex, String(parent), inheritTimelines);
 }
 
 void spine_linked_mesh_dispose(spine_linked_mesh self) {
-    delete (LinkedMesh*)self;
+	delete (LinkedMesh *) self;
 }

spine-c/src/generated/linked_mesh.h

@@ -8,8 +8,10 @@
 extern "C" {
 #endif
 
-SPINE_C_API spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char * parent, bool inheritTimelines);
-SPINE_C_API spine_linked_mesh spine_linked_mesh_create2(spine_mesh_attachment mesh, const char * skin, size_t slotIndex, const char * parent, bool inheritTimelines);
+SPINE_C_API spine_linked_mesh spine_linked_mesh_create(spine_mesh_attachment mesh, const int skinIndex, size_t slotIndex, const char *parent,
+													   bool inheritTimelines);
+SPINE_C_API spine_linked_mesh spine_linked_mesh_create2(spine_mesh_attachment mesh, const char *skin, size_t slotIndex, const char *parent,
+														bool inheritTimelines);
 
 SPINE_C_API void spine_linked_mesh_dispose(spine_linked_mesh self);
 

spine-c/src/generated/mesh_attachment.cpp

@@ -3,182 +3,226 @@
 
 using namespace spine;
 
-spine_mesh_attachment spine_mesh_attachment_create(const char * name) {
-    return (spine_mesh_attachment) new (__FILE__, __LINE__) MeshAttachment(String(name));
+spine_mesh_attachment spine_mesh_attachment_create(const char *name) {
+	return (spine_mesh_attachment) new (__FILE__, __LINE__) MeshAttachment(String(name));
 }
 
 void spine_mesh_attachment_dispose(spine_mesh_attachment self) {
-    delete (MeshAttachment*)self;
+	delete (MeshAttachment *) self;
 }
 
 spine_rtti spine_mesh_attachment_get_rtti(spine_mesh_attachment self) {
-    return (spine_rtti)&((MeshAttachment*)self)->getRTTI();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_rtti) &_self->getRTTI();
 }
 
-void spine_mesh_attachment_compute_world_vertices_1(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, float * worldVertices, size_t offset, size_t stride) {
-    ((MeshAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, worldVertices, offset, stride);
+void spine_mesh_attachment_compute_world_vertices_1(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count,
+													float *worldVertices, size_t offset, size_t stride) {
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
 }
 
-void spine_mesh_attachment_compute_world_vertices_2(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count, spine_array_float worldVertices, size_t offset, size_t stride) {
-    ((VertexAttachment*)(MeshAttachment*)self)->computeWorldVertices(*((Skeleton*)skeleton), *((Slot*)slot), start, count, *((Array<float>*)worldVertices), offset, stride);
+void spine_mesh_attachment_compute_world_vertices_2(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count,
+													spine_array_float worldVertices, size_t offset, size_t stride) {
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, *((Array<float> *) worldVertices), offset, stride);
 }
 
 void spine_mesh_attachment_update_region(spine_mesh_attachment self) {
-    ((MeshAttachment*)self)->updateRegion();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->updateRegion();
 }
 
 int spine_mesh_attachment_get_hull_length(spine_mesh_attachment self) {
-    return ((MeshAttachment*)self)->getHullLength();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return _self->getHullLength();
 }
 
 void spine_mesh_attachment_set_hull_length(spine_mesh_attachment self, int inValue) {
-    ((MeshAttachment*)self)->setHullLength(inValue);
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->setHullLength(inValue);
 }
 
 spine_array_float spine_mesh_attachment_get_region_u_vs(spine_mesh_attachment self) {
-    return (spine_array_float)&((MeshAttachment*)self)->getRegionUVs();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_array_float) &_self->getRegionUVs();
 }
 
 void spine_mesh_attachment_set_region_u_vs(spine_mesh_attachment self, spine_array_float inValue) {
-    ((MeshAttachment*)self)->setRegionUVs(*((Array<float>*)inValue));
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->setRegionUVs(*((Array<float> *) inValue));
 }
 
 spine_array_float spine_mesh_attachment_get_u_vs(spine_mesh_attachment self) {
-    return (spine_array_float)&((MeshAttachment*)self)->getUVs();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_array_float) &_self->getUVs();
 }
 
 spine_array_unsigned_short spine_mesh_attachment_get_triangles(spine_mesh_attachment self) {
-    return (spine_array_unsigned_short)&((MeshAttachment*)self)->getTriangles();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_array_unsigned_short) &_self->getTriangles();
 }
 
 void spine_mesh_attachment_set_triangles(spine_mesh_attachment self, spine_array_unsigned_short inValue) {
-    ((MeshAttachment*)self)->setTriangles(*((Array<unsigned short>*)inValue));
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->setTriangles(*((Array<unsigned short> *) inValue));
 }
 
 spine_color spine_mesh_attachment_get_color(spine_mesh_attachment self) {
-    return (spine_color)&((MeshAttachment*)self)->getColor();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_color) &_self->getColor();
 }
 
-const char * spine_mesh_attachment_get_path(spine_mesh_attachment self) {
-    return ((MeshAttachment*)self)->getPath().buffer();
+const char *spine_mesh_attachment_get_path(spine_mesh_attachment self) {
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return _self->getPath().buffer();
 }
 
-void spine_mesh_attachment_set_path(spine_mesh_attachment self, const char * inValue) {
-    ((MeshAttachment*)self)->setPath(String(inValue));
+void spine_mesh_attachment_set_path(spine_mesh_attachment self, const char *inValue) {
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->setPath(String(inValue));
 }
 
 spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment self) {
-    return (spine_texture_region)((MeshAttachment*)self)->getRegion();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_texture_region) _self->getRegion();
 }
 
 void spine_mesh_attachment_set_region(spine_mesh_attachment self, spine_texture_region region) {
-    ((MeshAttachment*)self)->setRegion((TextureRegion *)region);
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->setRegion((TextureRegion *) region);
 }
 
 spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment self) {
-    return (spine_sequence)((MeshAttachment*)self)->getSequence();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_sequence) _self->getSequence();
 }
 
 void spine_mesh_attachment_set_sequence(spine_mesh_attachment self, spine_sequence sequence) {
-    ((MeshAttachment*)self)->setSequence((Sequence *)sequence);
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->setSequence((Sequence *) sequence);
 }
 
 spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self) {
-    return (spine_mesh_attachment)((MeshAttachment*)self)->getParentMesh();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_mesh_attachment) _self->getParentMesh();
 }
 
 void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, spine_mesh_attachment inValue) {
-    ((MeshAttachment*)self)->setParentMesh((MeshAttachment *)inValue);
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->setParentMesh((MeshAttachment *) inValue);
 }
 
 spine_array_unsigned_short spine_mesh_attachment_get_edges(spine_mesh_attachment self) {
-    return (spine_array_unsigned_short)&((MeshAttachment*)self)->getEdges();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_array_unsigned_short) &_self->getEdges();
 }
 
 void spine_mesh_attachment_set_edges(spine_mesh_attachment self, spine_array_unsigned_short inValue) {
-    ((MeshAttachment*)self)->setEdges(*((Array<unsigned short>*)inValue));
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->setEdges(*((Array<unsigned short> *) inValue));
 }
 
 float spine_mesh_attachment_get_width(spine_mesh_attachment self) {
-    return ((MeshAttachment*)self)->getWidth();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return _self->getWidth();
 }
 
 void spine_mesh_attachment_set_width(spine_mesh_attachment self, float inValue) {
-    ((MeshAttachment*)self)->setWidth(inValue);
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->setWidth(inValue);
 }
 
 float spine_mesh_attachment_get_height(spine_mesh_attachment self) {
-    return ((MeshAttachment*)self)->getHeight();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return _self->getHeight();
 }
 
 void spine_mesh_attachment_set_height(spine_mesh_attachment self, float inValue) {
-    ((MeshAttachment*)self)->setHeight(inValue);
+	MeshAttachment *_self = (MeshAttachment *) self;
+	_self->setHeight(inValue);
 }
 
 spine_attachment spine_mesh_attachment_copy(spine_mesh_attachment self) {
-    return (spine_attachment)((MeshAttachment*)self)->copy();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_attachment) _self->copy();
 }
 
 spine_mesh_attachment spine_mesh_attachment_new_linked_mesh(spine_mesh_attachment self) {
-    return (spine_mesh_attachment)((MeshAttachment*)self)->newLinkedMesh();
+	MeshAttachment *_self = (MeshAttachment *) self;
+	return (spine_mesh_attachment) _self->newLinkedMesh();
 }
 
 int spine_mesh_attachment_get_id(spine_mesh_attachment self) {
-    return ((VertexAttachment*)(MeshAttachment*)self)->getId();
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	return _self->getId();
 }
 
 spine_array_int spine_mesh_attachment_get_bones(spine_mesh_attachment self) {
-    return (spine_array_int)&((VertexAttachment*)(MeshAttachment*)self)->getBones();
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	return (spine_array_int) &_self->getBones();
 }
 
 void spine_mesh_attachment_set_bones(spine_mesh_attachment self, spine_array_int bones) {
-    ((VertexAttachment*)(MeshAttachment*)self)->setBones(*((Array<int>*)bones));
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	_self->setBones(*((Array<int> *) bones));
 }
 
 spine_array_float spine_mesh_attachment_get_vertices(spine_mesh_attachment self) {
-    return (spine_array_float)&((VertexAttachment*)(MeshAttachment*)self)->getVertices();
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	return (spine_array_float) &_self->getVertices();
 }
 
 void spine_mesh_attachment_set_vertices(spine_mesh_attachment self, spine_array_float vertices) {
-    ((VertexAttachment*)(MeshAttachment*)self)->setVertices(*((Array<float>*)vertices));
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	_self->setVertices(*((Array<float> *) vertices));
 }
 
 size_t spine_mesh_attachment_get_world_vertices_length(spine_mesh_attachment self) {
-    return ((VertexAttachment*)(MeshAttachment*)self)->getWorldVerticesLength();
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	return _self->getWorldVerticesLength();
 }
 
 void spine_mesh_attachment_set_world_vertices_length(spine_mesh_attachment self, size_t inValue) {
-    ((VertexAttachment*)(MeshAttachment*)self)->setWorldVerticesLength(inValue);
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	_self->setWorldVerticesLength(inValue);
 }
 
 spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self) {
-    return (spine_attachment)((VertexAttachment*)(MeshAttachment*)self)->getTimelineAttachment();
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	return (spine_attachment) _self->getTimelineAttachment();
 }
 
 void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, spine_attachment attachment) {
-    ((VertexAttachment*)(MeshAttachment*)self)->setTimelineAttachment((Attachment *)attachment);
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	_self->setTimelineAttachment((Attachment *) attachment);
 }
 
 void spine_mesh_attachment_copy_to(spine_mesh_attachment self, spine_vertex_attachment other) {
-    ((VertexAttachment*)(MeshAttachment*)self)->copyTo((VertexAttachment *)other);
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	_self->copyTo((VertexAttachment *) other);
 }
 
-const char * spine_mesh_attachment_get_name(spine_mesh_attachment self) {
-    return ((VertexAttachment*)(MeshAttachment*)self)->getName().buffer();
+const char *spine_mesh_attachment_get_name(spine_mesh_attachment self) {
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	return _self->getName().buffer();
 }
 
 int spine_mesh_attachment_get_ref_count(spine_mesh_attachment self) {
-    return ((VertexAttachment*)(MeshAttachment*)self)->getRefCount();
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	return _self->getRefCount();
 }
 
 void spine_mesh_attachment_reference(spine_mesh_attachment self) {
-    ((VertexAttachment*)(MeshAttachment*)self)->reference();
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	_self->reference();
 }
 
 void spine_mesh_attachment_dereference(spine_mesh_attachment self) {
-    ((VertexAttachment*)(MeshAttachment*)self)->dereference();
+	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	_self->dereference();
 }
 
 spine_rtti spine_mesh_attachment_rtti(void) {
-    return (spine_rtti)&MeshAttachment::rtti;
+	return (spine_rtti) &MeshAttachment::rtti;
 }