[c] Code generator now generates cast functions, see updated spine-c docs on RTTI

spine-c/codegen/src/c-writer.ts

@@ -215,6 +215,9 @@ export class CWriter {
             '// Extension types & functions',
             '#include "../src/extensions.h"',
             '',
+            '// Cast functions for type conversions',
+            '#include "../src/generated/casts.h"',
+            '',
             '// Generated class types'
         ];
 
@@ -304,6 +307,117 @@ export class CWriter {
         fs.writeFileSync(sourcePath, arraySourceLines.join('\n'));
     }
 
+    async writeCasts(supertypes: Record<string, string[]>, subtypes: Record<string, string[]>, 
+                     cNameToCppName: Record<string, string>): Promise<void> {
+        console.log('\nGenerating casts.h/casts.cpp...');
+
+        // Generate header
+        const castHeaderLines: string[] = [];
+        
+        castHeaderLines.push(LICENSE_HEADER);
+        castHeaderLines.push('');
+        castHeaderLines.push('#ifndef SPINE_C_CASTS_H');
+        castHeaderLines.push('#define SPINE_C_CASTS_H');
+        castHeaderLines.push('');
+        castHeaderLines.push('#include "../base.h"');
+        castHeaderLines.push('#include "types.h"');
+        castHeaderLines.push('');
+        castHeaderLines.push('#ifdef __cplusplus');
+        castHeaderLines.push('extern "C" {');
+        castHeaderLines.push('#endif');
+        castHeaderLines.push('');
+        
+        // Generate upcast functions (derived to base)
+        castHeaderLines.push('// Upcast functions (derived to base) - always safe');
+        for (const [derivedType, supertypeList] of Object.entries(supertypes)) {
+            for (const baseType of supertypeList) {
+                const funcName = `${derivedType}_cast_to_${baseType.replace('spine_', '')}`;
+                castHeaderLines.push(`SPINE_C_API ${baseType} ${funcName}(${derivedType} obj);`);
+            }
+        }
+        
+        castHeaderLines.push('');
+        castHeaderLines.push('// Downcast functions (base to derived) - user must ensure correct type');
+        
+        // Generate downcast functions (base to derived)
+        for (const [baseType, subtypeList] of Object.entries(subtypes)) {
+            for (const derivedType of subtypeList) {
+                const funcName = `${baseType}_cast_to_${derivedType.replace('spine_', '')}`;
+                castHeaderLines.push(`SPINE_C_API ${derivedType} ${funcName}(${baseType} obj);`);
+            }
+        }
+        
+        castHeaderLines.push('');
+        castHeaderLines.push('#ifdef __cplusplus');
+        castHeaderLines.push('}');
+        castHeaderLines.push('#endif');
+        castHeaderLines.push('');
+        castHeaderLines.push('#endif /* SPINE_C_CASTS_H */');
+        castHeaderLines.push('');
+        
+        // Generate source
+        const castSourceLines: string[] = [];
+        
+        castSourceLines.push(LICENSE_HEADER);
+        castSourceLines.push('');
+        castSourceLines.push('#include "casts.h"');
+        castSourceLines.push('#include <spine/spine.h>');
+        castSourceLines.push('');
+        castSourceLines.push('using namespace spine;');
+        castSourceLines.push('');
+        
+        // Helper function to get C++ class name from C name
+        const toCppClassName = (cName: string): string => {
+            const cppName = cNameToCppName[cName];
+            if (!cppName) {
+                throw new Error(`Cannot find C++ class name for C type '${cName}'. Make sure the type is properly generated.`);
+            }
+            return cppName;
+        };
+        
+        // Generate upcast implementations
+        castSourceLines.push('// Upcast function implementations');
+        for (const [derivedType, supertypeList] of Object.entries(supertypes)) {
+            const derivedCppClass = toCppClassName(derivedType);
+            
+            for (const baseType of supertypeList) {
+                const baseCppClass = toCppClassName(baseType);
+                const funcName = `${derivedType}_cast_to_${baseType.replace('spine_', '')}`;
+                
+                castSourceLines.push(`${baseType} ${funcName}(${derivedType} obj) {`);
+                castSourceLines.push(`    ${derivedCppClass}* derived = (${derivedCppClass}*)obj;`);
+                castSourceLines.push(`    ${baseCppClass}* base = static_cast<${baseCppClass}*>(derived);`);
+                castSourceLines.push(`    return (${baseType})base;`);
+                castSourceLines.push(`}`);
+                castSourceLines.push('');
+            }
+        }
+        
+        // Generate downcast implementations
+        castSourceLines.push('// Downcast function implementations');
+        for (const [baseType, subtypeList] of Object.entries(subtypes)) {
+            const baseCppClass = toCppClassName(baseType);
+            
+            for (const derivedType of subtypeList) {
+                const derivedCppClass = toCppClassName(derivedType);
+                const funcName = `${baseType}_cast_to_${derivedType.replace('spine_', '')}`;
+                
+                castSourceLines.push(`${derivedType} ${funcName}(${baseType} obj) {`);
+                castSourceLines.push(`    ${baseCppClass}* base = (${baseCppClass}*)obj;`);
+                castSourceLines.push(`    ${derivedCppClass}* derived = static_cast<${derivedCppClass}*>(base);`);
+                castSourceLines.push(`    return (${derivedType})derived;`);
+                castSourceLines.push(`}`);
+                castSourceLines.push('');
+            }
+        }
+        
+        const headerPath = path.join(this.outputDir, 'casts.h');
+        const sourcePath = path.join(this.outputDir, 'casts.cpp');
+        
+        fs.writeFileSync(headerPath, castHeaderLines.join('\n'));
+        fs.writeFileSync(sourcePath, castSourceLines.join('\n'));
+    }
+
     /** Writes the types.h file, which includes all class forward declarations and enum types. */
     async writeTypesHeader(cClasses: CClassOrStruct[], cEnums: CEnum[]): Promise<void> {
         const headerPath = path.join(this.outputDir, 'types.h');
@@ -346,10 +460,19 @@ export class CWriter {
         fs.writeFileSync(headerPath, lines.join('\n'));
     }
 
-    async writeAll(cClasses: CClassOrStruct[], cEnums: CEnum[], cArrayTypes: CClassOrStruct[]): Promise<void> {
+    async writeAll(cClasses: CClassOrStruct[], cEnums: CEnum[], cArrayTypes: CClassOrStruct[], 
+                   supertypes: Record<string, string[]>, subtypes: Record<string, string[]>): Promise<void> {
         await this.writeTypesHeader(cClasses, cEnums);
         await this.writeMainHeader(cClasses);
         await this.writeArrays(cArrayTypes);
+        
+        // Build C name to C++ name mapping
+        const cNameToCppName: Record<string, string> = {};
+        for (const cClass of cClasses) {
+            cNameToCppName[cClass.name] = cClass.cppType.name;
+        }
+        
+        await this.writeCasts(supertypes, subtypes, cNameToCppName);
 
         // Write all class files
         for (const classType of cClasses) {

spine-c/codegen/src/index.ts

@@ -322,7 +322,7 @@ async function main() {
 
     // Write all files to disk
     const cWriter = new CWriter(path.join(__dirname, '../../src/generated'));
-    await cWriter.writeAll(cTypes, cEnums, cArrayTypes);
+    await cWriter.writeAll(cTypes, cEnums, cArrayTypes, supertypes, subtypes);
 
     // Format the generated code
     console.log('Formatting generated code...');

spine-c/docs-new.md

@@ -47,7 +47,10 @@ target_link_libraries(your_target spine-c)
 
 This will automatically fetch and build spine-c along with its dependency (spine-cpp).
 
-Include `spine-c.h` in your code, which provides the complete API. All code samples in this guide assume `#include <spine-c.h>`.
+Include spine-c headers in your code:
+```c
+#include <spine-c.h>
+```
 
 ## Manual Integration
 
@@ -58,9 +61,10 @@ If you prefer manual integration:
    - Add sources from `spine-cpp/src`, `spine-c/src`
 3. Add the include directories: `spine-cpp/include`, `spine-c/include`
 
-Include `spine-c.h` in your code, which provides the complete API. All code samples in this guide assume `#include <spine-c.h>`.
-
-See the [example integrations](#introduction) for complete implementations.
+Include spine-c headers in your code:
+```c
+#include <spine-c.h>
+```
 
 # Exporting Spine assets for spine-c
 ![](/img/spine-runtimes-guide/spine-ue4/export.png)
@@ -109,12 +113,16 @@ if (spine_atlas_result_get_error(result)) {
 spine_atlas atlas = spine_atlas_result_get_atlas(result);
 spine_atlas_result_dispose(result);
 
-// Now manually load textures for each page
+// Manual texture loading: spine_atlas_load sets page indices, not texture pointers
+// You need to load textures and set them on the regions for each page
 spine_array_atlas_page pages = spine_atlas_get_pages(atlas);
 int num_pages = spine_array_atlas_page_size(pages);
 
+// Load texture for each page
+void** page_textures = malloc(num_pages * sizeof(void*));
+spine_atlas_page* pages_buffer = spine_array_atlas_page_buffer(pages);
 for (int i = 0; i < num_pages; i++) {
-    spine_atlas_page page = spine_array_atlas_page_get(pages, i);
+    spine_atlas_page page = pages_buffer[i];
 
     // Get the texture filename from the atlas
     const char* texture_name = spine_atlas_page_get_texture_path(page);
@@ -124,13 +132,26 @@ for (int i = 0; i < num_pages; i++) {
     snprintf(full_path, sizeof(full_path), "%s/%s", atlas_dir, texture_name);
 
     // Load texture using your engine
-    void* texture = engine_load_texture(full_path);
-
-    // Store the texture in the page
-    spine_atlas_page_set_texture(page, texture);
-    spine_atlas_page_set_width(page, texture_width);
-    spine_atlas_page_set_height(page, texture_height);
+    page_textures[i] = engine_load_texture(full_path);
 }
+
+// Set renderer objects on all regions to point to their page's texture
+spine_array_atlas_region regions = spine_atlas_get_regions(atlas);
+int num_regions = spine_array_atlas_region_size(regions);
+spine_atlas_region* regions_buffer = spine_array_atlas_region_buffer(regions);
+
+for (int i = 0; i < num_regions; i++) {
+    spine_atlas_region region = regions_buffer[i];
+    spine_atlas_page page = spine_atlas_region_get_page(region);
+
+    // spine_atlas_load stores the page index in the page's texture field
+    int page_index = (int)(intptr_t)spine_atlas_page_get_texture(page);
+
+    // Set the actual texture as the region's renderer object
+    spine_atlas_region_set_renderer_object(region, page_textures[page_index]);
+}
+
+free(page_textures);
 ```
 
 ### Option 2: Provide texture loading callbacks
@@ -740,7 +761,7 @@ Iterate through commands and submit them to your graphics API:
 // Simplified graphics API for illustration
 void render_skeleton(spine_render_command first_command) {
     spine_render_command command = first_command;
-    
+
     while (command) {
         // Get command data
         float* positions = spine_render_command_get_positions(command);
@@ -749,19 +770,19 @@ void render_skeleton(spine_render_command first_command) {
         uint16_t* indices = spine_render_command_get_indices(command);
         int num_vertices = spine_render_command_get_num_vertices(command);
         int num_indices = spine_render_command_get_num_indices(command);
-        
+
         // Get texture and blend mode
         void* texture = spine_render_command_get_texture(command);
         spine_blend_mode blend_mode = spine_render_command_get_blend_mode(command);
-        
+
         // Set graphics state
         graphics_bind_texture(texture);
         graphics_set_blend_mode(blend_mode);
-        
+
         // Submit vertices and indices to GPU
         graphics_set_vertices(positions, uvs, colors, num_vertices);
         graphics_draw_indexed(indices, num_indices);
-        
+
         // Move to next command
         command = spine_render_command_get_next(command);
     }
@@ -797,7 +818,7 @@ void graphics_set_blend_mode(spine_blend_mode mode, bool premultiplied_alpha) {
 
 For complete rendering implementations, see:
 * [spine-sfml](/spine-sfml): SFML-based renderer
-* [spine-sdl](/spine-sdl): SDL-based renderer  
+* [spine-sdl](/spine-sdl): SDL-based renderer
 * [spine-glfw](/spine-glfw): OpenGL renderer with GLFW
 
 These examples show how to integrate spine-c rendering with different graphics APIs and frameworks.
@@ -816,4 +837,99 @@ Track entries (`spine_track_entry`) are valid from when an animation is queued (
 When creating objects, you pass references to other objects. The referencing object never disposes the referenced object:
 * Disposing `spine_skeleton` does not dispose `spine_skeleton_data` or `spine_atlas`. The skeleton data is likely shared by other skeleton instances.
 * Disposing `spine_skeleton_data` does not dispose `spine_atlas`. The atlas may be shared by multiple skeleton data instances.
-* Disposing `spine_skeleton_drawable` disposes its skeleton and animation state, but not the skeleton data.
+* Disposing `spine_skeleton_drawable` disposes its skeleton and animation state, but not the skeleton data.
+
+# Type information and casting
+
+spine-c uses opaque pointers to represent C++ objects. Some types have inheritance relationships that require explicit casting when converting between base and derived types.
+
+## RTTI (Runtime Type Information)
+
+Every polymorphic type in spine-c provides RTTI to identify its concrete type at runtime:
+
+```c
+spine_array_constraint constraints = spine_skeleton_get_constraints(skeleton);
+spine_constraint* buffer = spine_array_constraint_buffer(constraints);
+
+for (int i = 0; i < spine_array_constraint_size(constraints); i++) {
+    spine_constraint constraint = buffer[i];
+    spine_rtti rtti = spine_constraint_get_rtti(constraint);
+    
+    // Check the exact type
+    if (spine_rtti_is_exactly(rtti, spine_transform_constraint_rtti())) {
+        // This is exactly a TransformConstraint
+    }
+    
+    // Check if it's an instance of a type (includes derived types)
+    if (spine_rtti_is_instance_of(rtti, spine_constraint_rtti())) {
+        // This is a Constraint or derived from Constraint
+    }
+    
+    // Get the class name for debugging
+    const char* class_name = spine_rtti_get_class_name(rtti);
+    printf("Constraint type: %s\n", class_name);
+}
+```
+
+## Type casting
+
+Due to C++ multiple inheritance, pointer values change when casting between types. spine-c provides cast functions that handle these adjustments correctly.
+
+### Upcasting (derived to base)
+
+Upcasting is always safe and used when storing derived types in base-type containers:
+
+```c
+spine_transform_constraint tc = /* ... */;
+
+// Cast to base type for storage in array
+spine_constraint base = spine_transform_constraint_cast_to_constraint(tc);
+spine_array_constraint_add(constraints_array, base);
+```
+
+### Downcasting (base to derived)
+
+Downcasting requires knowing the actual type. Use RTTI to verify before casting:
+
+```c
+spine_constraint constraint = buffer[i];
+
+// Check type before downcasting
+spine_rtti rtti = spine_constraint_get_rtti(constraint);
+if (spine_rtti_is_exactly(rtti, spine_transform_constraint_rtti())) {
+    // Safe to downcast
+    spine_transform_constraint tc = spine_constraint_cast_to_transform_constraint(constraint);
+    spine_transform_constraint_data data = spine_transform_constraint_get_data(tc);
+    // Use the transform constraint...
+}
+```
+
+### Common type hierarchies
+
+Key inheritance relationships that require casting:
+
+* **Constraints**: `IkConstraint`, `PathConstraint`, `PhysicsConstraint`, `TransformConstraint` → `Constraint`
+* **Constraint data**: `IkConstraintData`, `PathConstraintData`, etc. → `ConstraintData`
+* **Attachments**: `RegionAttachment`, `MeshAttachment`, `BoundingBoxAttachment`, etc. → `Attachment`
+* **Timelines**: Many timeline types → `CurveTimeline` → `Timeline`
+
+Example with attachments:
+
+```c
+spine_slot slot = spine_skeleton_find_slot(skeleton, "weapon");
+spine_attachment attachment = spine_slot_get_attachment(slot);
+
+if (attachment) {
+    spine_rtti rtti = spine_attachment_get_rtti(attachment);
+    
+    if (spine_rtti_is_exactly(rtti, spine_region_attachment_rtti())) {
+        spine_region_attachment region = spine_attachment_cast_to_region_attachment(attachment);
+        // Work with region attachment...
+    } else if (spine_rtti_is_exactly(rtti, spine_mesh_attachment_rtti())) {
+        spine_mesh_attachment mesh = spine_attachment_cast_to_mesh_attachment(attachment);
+        // Work with mesh attachment...
+    }
+}
+```
+
+> **Note:** Never use C-style casts between spine-c types. Always use the provided cast functions to ensure correct pointer adjustment.

spine-c/include/spine-c.h

@@ -39,6 +39,9 @@
 // Extension types & functions
 #include "../src/extensions.h"
 
+// Cast functions for type conversions
+#include "../src/generated/casts.h"
+
 // Generated class types
 #include "../src/generated/alpha_timeline.h"
 #include "../src/generated/animation.h"

spine-c/src/generated/alpha_timeline.cpp

@@ -33,86 +33,86 @@ void spine_alpha_timeline_set_slot_index(spine_alpha_timeline self, int inValue)
 }
 
 void spine_alpha_timeline_set_frame(spine_alpha_timeline self, size_t frame, float time, float value) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (AlphaTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_alpha_timeline_get_curve_value(spine_alpha_timeline self, float time) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (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 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (AlphaTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_alpha_timeline_set_stepped(spine_alpha_timeline self, size_t frame) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (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 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (AlphaTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_alpha_timeline_get_curves(spine_alpha_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (AlphaTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_alpha_timeline_get_frame_entries(spine_alpha_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (AlphaTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_alpha_timeline_get_frame_count(spine_alpha_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (AlphaTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_alpha_timeline_get_frames(spine_alpha_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (AlphaTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_alpha_timeline_get_duration(spine_alpha_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (AlphaTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_alpha_timeline_get_property_ids(spine_alpha_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
+	AlphaTimeline *_self = (AlphaTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/animation_state.cpp

@@ -119,6 +119,6 @@ void spine_animation_state_dispose_track_entry(spine_animation_state self, /*@nu
 }
 
 /*@null*/ void *spine_animation_state_get_renderer_object(spine_animation_state self) {
-	HasRendererObject *_self = (HasRendererObject *) (AnimationState *) self;
+	AnimationState *_self = (AnimationState *) self;
 	return _self->getRendererObject();
 }

spine-c/src/generated/atlas_region.cpp

@@ -177,72 +177,72 @@ void spine_atlas_region_set_values(spine_atlas_region self, spine_array_float va
 }
 
 float spine_atlas_region_get_u(spine_atlas_region self) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	return _self->getU();
 }
 
 void spine_atlas_region_set_u(spine_atlas_region self, float value) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	_self->setU(value);
 }
 
 float spine_atlas_region_get_v(spine_atlas_region self) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	return _self->getV();
 }
 
 void spine_atlas_region_set_v(spine_atlas_region self, float value) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	_self->setV(value);
 }
 
 float spine_atlas_region_get_u2(spine_atlas_region self) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	return _self->getU2();
 }
 
 void spine_atlas_region_set_u2(spine_atlas_region self, float value) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	_self->setU2(value);
 }
 
 float spine_atlas_region_get_v2(spine_atlas_region self) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	return _self->getV2();
 }
 
 void spine_atlas_region_set_v2(spine_atlas_region self, float value) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	_self->setV2(value);
 }
 
 int spine_atlas_region_get_region_width(spine_atlas_region self) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	return _self->getRegionWidth();
 }
 
 void spine_atlas_region_set_region_width(spine_atlas_region self, int value) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	_self->setRegionWidth(value);
 }
 
 int spine_atlas_region_get_region_height(spine_atlas_region self) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	return _self->getRegionHeight();
 }
 
 void spine_atlas_region_set_region_height(spine_atlas_region self, int value) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	_self->setRegionHeight(value);
 }
 
 /*@null*/ void *spine_atlas_region_get_renderer_object(spine_atlas_region self) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	return _self->getRendererObject();
 }
 
 void spine_atlas_region_set_renderer_object(spine_atlas_region self, /*@null*/ void *value) {
-	TextureRegion *_self = (TextureRegion *) (AtlasRegion *) self;
+	AtlasRegion *_self = (AtlasRegion *) self;
 	_self->setRendererObject(value);
 }
 

spine-c/src/generated/attachment_timeline.cpp

@@ -39,27 +39,27 @@ void spine_attachment_timeline_set_slot_index(spine_attachment_timeline self, in
 }
 
 size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline self) {
-	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
+	AttachmentTimeline *_self = (AttachmentTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_attachment_timeline_get_frame_count(spine_attachment_timeline self) {
-	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
+	AttachmentTimeline *_self = (AttachmentTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_attachment_timeline_get_frames(spine_attachment_timeline self) {
-	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
+	AttachmentTimeline *_self = (AttachmentTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_attachment_timeline_get_duration(spine_attachment_timeline self) {
-	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
+	AttachmentTimeline *_self = (AttachmentTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_attachment_timeline_get_property_ids(spine_attachment_timeline self) {
-	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
+	AttachmentTimeline *_self = (AttachmentTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/bone.cpp

@@ -44,42 +44,42 @@ void spine_bone_update(spine_bone self, spine_skeleton skeleton, spine_physics p
 }
 
 spine_bone_data spine_bone_get_data(spine_bone self) {
-	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	Bone *_self = (Bone *) self;
 	return (spine_bone_data) &_self->getData();
 }
 
 spine_bone_local spine_bone_get_pose(spine_bone self) {
-	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	Bone *_self = (Bone *) self;
 	return (spine_bone_local) &_self->getPose();
 }
 
 spine_bone_pose spine_bone_get_applied_pose(spine_bone self) {
-	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	Bone *_self = (Bone *) self;
 	return (spine_bone_pose) &_self->getAppliedPose();
 }
 
 void spine_bone_reset_constrained(spine_bone self) {
-	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	Bone *_self = (Bone *) self;
 	_self->resetConstrained();
 }
 
 void spine_bone_constrained(spine_bone self) {
-	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	Bone *_self = (Bone *) self;
 	_self->constrained();
 }
 
 bool spine_bone_is_pose_equal_to_applied(spine_bone self) {
-	PosedGeneric<BoneData, BoneLocal, BonePose> *_self = (PosedGeneric<BoneData, BoneLocal, BonePose> *) (Bone *) self;
+	Bone *_self = (Bone *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_bone_is_active(spine_bone self) {
-	PosedActive *_self = (PosedActive *) (Bone *) self;
+	Bone *_self = (Bone *) self;
 	return _self->isActive();
 }
 
 void spine_bone_set_active(spine_bone self, bool active) {
-	PosedActive *_self = (PosedActive *) (Bone *) self;
+	Bone *_self = (Bone *) self;
 	_self->setActive(active);
 }
 

spine-c/src/generated/bone_data.cpp

@@ -57,21 +57,21 @@ void spine_bone_data_set_visible(spine_bone_data self, bool inValue) {
 }
 
 spine_bone_local spine_bone_data_get_setup_pose(spine_bone_data self) {
-	PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
+	BoneData *_self = (BoneData *) self;
 	return (spine_bone_local) &_self->getSetupPose();
 }
 
 const char *spine_bone_data_get_name(spine_bone_data self) {
-	PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
+	BoneData *_self = (BoneData *) self;
 	return _self->getName().buffer();
 }
 
 bool spine_bone_data_get_skin_required(spine_bone_data self) {
-	PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
+	BoneData *_self = (BoneData *) self;
 	return _self->getSkinRequired();
 }
 
 void spine_bone_data_set_skin_required(spine_bone_data self, bool skinRequired) {
-	PosedDataGeneric<BoneLocal> *_self = (PosedDataGeneric<BoneLocal> *) (BoneData *) self;
+	BoneData *_self = (BoneData *) self;
 	_self->setSkinRequired(skinRequired);
 }

spine-c/src/generated/bone_pose.cpp

@@ -167,102 +167,102 @@ void spine_bone_pose_rotate_world(spine_bone_pose self, float degrees) {
 }
 
 void spine_bone_pose_set(spine_bone_pose self, spine_bone_local pose) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->set(*((BoneLocal *) pose));
 }
 
 float spine_bone_pose_get_x(spine_bone_pose self) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	return _self->getX();
 }
 
 void spine_bone_pose_set_x(spine_bone_pose self, float x) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setX(x);
 }
 
 float spine_bone_pose_get_y(spine_bone_pose self) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	return _self->getY();
 }
 
 void spine_bone_pose_set_y(spine_bone_pose self, float y) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setY(y);
 }
 
 void spine_bone_pose_set_position(spine_bone_pose self, float x, float y) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setPosition(x, y);
 }
 
 float spine_bone_pose_get_rotation(spine_bone_pose self) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	return _self->getRotation();
 }
 
 void spine_bone_pose_set_rotation(spine_bone_pose self, float rotation) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setRotation(rotation);
 }
 
 float spine_bone_pose_get_scale_x(spine_bone_pose self) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	return _self->getScaleX();
 }
 
 void spine_bone_pose_set_scale_x(spine_bone_pose self, float scaleX) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setScaleX(scaleX);
 }
 
 float spine_bone_pose_get_scale_y(spine_bone_pose self) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	return _self->getScaleY();
 }
 
 void spine_bone_pose_set_scale_y(spine_bone_pose self, float scaleY) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setScaleY(scaleY);
 }
 
 void spine_bone_pose_set_scale_1(spine_bone_pose self, float scaleX, float scaleY) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setScale(scaleX, scaleY);
 }
 
 void spine_bone_pose_set_scale_2(spine_bone_pose self, float scale) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setScale(scale);
 }
 
 float spine_bone_pose_get_shear_x(spine_bone_pose self) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	return _self->getShearX();
 }
 
 void spine_bone_pose_set_shear_x(spine_bone_pose self, float shearX) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setShearX(shearX);
 }
 
 float spine_bone_pose_get_shear_y(spine_bone_pose self) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	return _self->getShearY();
 }
 
 void spine_bone_pose_set_shear_y(spine_bone_pose self, float shearY) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setShearY(shearY);
 }
 
 spine_inherit spine_bone_pose_get_inherit(spine_bone_pose self) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	return (spine_inherit) _self->getInherit();
 }
 
 void spine_bone_pose_set_inherit(spine_bone_pose self, spine_inherit inherit) {
-	BoneLocal *_self = (BoneLocal *) (BonePose *) self;
+	BonePose *_self = (BonePose *) self;
 	_self->setInherit((Inherit) inherit);
 }
 

spine-c/src/generated/bone_timeline1.cpp

@@ -29,86 +29,86 @@ void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 self, int inValue)
 }
 
 void spine_bone_timeline1_set_frame(spine_bone_timeline1 self, size_t frame, float time, float value) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_bone_timeline1_get_curve_value(spine_bone_timeline1 self, float time) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (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 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
 	_self->setLinear(frame);
 }
 
 void spine_bone_timeline1_set_stepped(spine_bone_timeline1 self, size_t frame) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (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 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_bone_timeline1_get_curves(spine_bone_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_bone_timeline1_get_frame_entries(spine_bone_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_bone_timeline1_get_frame_count(spine_bone_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_bone_timeline1_get_frames(spine_bone_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_bone_timeline1_get_duration(spine_bone_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_bone_timeline1_get_property_ids(spine_bone_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/bone_timeline2.cpp

@@ -34,53 +34,53 @@ void spine_bone_timeline2_set_frame(spine_bone_timeline2 self, size_t frame, flo
 }
 
 void spine_bone_timeline2_set_linear(spine_bone_timeline2 self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
 	_self->setLinear(frame);
 }
 
 void spine_bone_timeline2_set_stepped(spine_bone_timeline2 self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
+	BoneTimeline2 *_self = (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) {
-	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
+	BoneTimeline2 *_self = (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) {
-	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_bone_timeline2_get_curves(spine_bone_timeline2 self) {
-	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_bone_timeline2_get_frame_entries(spine_bone_timeline2 self) {
-	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_bone_timeline2_get_frame_count(spine_bone_timeline2 self) {
-	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_bone_timeline2_get_frames(spine_bone_timeline2 self) {
-	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_bone_timeline2_get_duration(spine_bone_timeline2 self) {
-	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_bone_timeline2_get_property_ids(spine_bone_timeline2 self) {
-	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/bounding_box_attachment.cpp

@@ -29,84 +29,84 @@ spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachmen
 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, /*@null*/ float *worldVertices, size_t offset,
 															size_t stride) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (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 *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (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) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	return _self->getId();
 }
 
 spine_array_int spine_bounding_box_attachment_get_bones(spine_bounding_box_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (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 *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	_self->setBones(*((Array<int> *) bones));
 }
 
 spine_array_float spine_bounding_box_attachment_get_vertices(spine_bounding_box_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (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 *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	_self->setVertices(*((Array<float> *) vertices));
 }
 
 size_t spine_bounding_box_attachment_get_world_vertices_length(spine_bounding_box_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	return _self->getWorldVerticesLength();
 }
 
 void spine_bounding_box_attachment_set_world_vertices_length(spine_bounding_box_attachment self, size_t inValue) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	_self->setWorldVerticesLength(inValue);
 }
 
 /*@null*/ spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	return (spine_attachment) _self->getTimelineAttachment();
 }
 
 void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, /*@null*/ spine_attachment attachment) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	_self->setTimelineAttachment((Attachment *) attachment);
 }
 
 void spine_bounding_box_attachment_copy_to(spine_bounding_box_attachment self, spine_vertex_attachment other) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	_self->copyTo(*((VertexAttachment *) other));
 }
 
 const char *spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	return _self->getName().buffer();
 }
 
 int spine_bounding_box_attachment_get_ref_count(spine_bounding_box_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	return _self->getRefCount();
 }
 
 void spine_bounding_box_attachment_reference(spine_bounding_box_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	_self->reference();
 }
 
 void spine_bounding_box_attachment_dereference(spine_bounding_box_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
+	BoundingBoxAttachment *_self = (BoundingBoxAttachment *) self;
 	_self->dereference();
 }
 

spine-c/src/generated/casts.h

@@ -0,0 +1,588 @@
+/******************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated April 5, 2025. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2025, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software
+ * or otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+
+#ifndef SPINE_C_CASTS_H
+#define SPINE_C_CASTS_H
+
+#include "../base.h"
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Upcast functions (derived to base) - always safe
+SPINE_C_API spine_curve_timeline1 spine_alpha_timeline_cast_to_curve_timeline1(spine_alpha_timeline obj);
+SPINE_C_API spine_curve_timeline spine_alpha_timeline_cast_to_curve_timeline(spine_alpha_timeline obj);
+SPINE_C_API spine_timeline spine_alpha_timeline_cast_to_timeline(spine_alpha_timeline obj);
+SPINE_C_API spine_slot_timeline spine_alpha_timeline_cast_to_slot_timeline(spine_alpha_timeline obj);
+SPINE_C_API spine_attachment_loader spine_atlas_attachment_loader_cast_to_attachment_loader(spine_atlas_attachment_loader obj);
+SPINE_C_API spine_texture_region spine_atlas_region_cast_to_texture_region(spine_atlas_region obj);
+SPINE_C_API spine_timeline spine_attachment_timeline_cast_to_timeline(spine_attachment_timeline obj);
+SPINE_C_API spine_slot_timeline spine_attachment_timeline_cast_to_slot_timeline(spine_attachment_timeline obj);
+SPINE_C_API spine_posed spine_bone_cast_to_posed(spine_bone obj);
+SPINE_C_API spine_posed_active spine_bone_cast_to_posed_active(spine_bone obj);
+SPINE_C_API spine_update spine_bone_cast_to_update(spine_bone obj);
+SPINE_C_API spine_posed_data spine_bone_data_cast_to_posed_data(spine_bone_data obj);
+SPINE_C_API spine_bone_local spine_bone_pose_cast_to_bone_local(spine_bone_pose obj);
+SPINE_C_API spine_update spine_bone_pose_cast_to_update(spine_bone_pose obj);
+SPINE_C_API spine_curve_timeline1 spine_bone_timeline1_cast_to_curve_timeline1(spine_bone_timeline1 obj);
+SPINE_C_API spine_curve_timeline spine_bone_timeline1_cast_to_curve_timeline(spine_bone_timeline1 obj);
+SPINE_C_API spine_timeline spine_bone_timeline1_cast_to_timeline(spine_bone_timeline1 obj);
+SPINE_C_API spine_bone_timeline spine_bone_timeline1_cast_to_bone_timeline(spine_bone_timeline1 obj);
+SPINE_C_API spine_curve_timeline spine_bone_timeline2_cast_to_curve_timeline(spine_bone_timeline2 obj);
+SPINE_C_API spine_timeline spine_bone_timeline2_cast_to_timeline(spine_bone_timeline2 obj);
+SPINE_C_API spine_bone_timeline spine_bone_timeline2_cast_to_bone_timeline(spine_bone_timeline2 obj);
+SPINE_C_API spine_vertex_attachment spine_bounding_box_attachment_cast_to_vertex_attachment(spine_bounding_box_attachment obj);
+SPINE_C_API spine_attachment spine_bounding_box_attachment_cast_to_attachment(spine_bounding_box_attachment obj);
+SPINE_C_API spine_vertex_attachment spine_clipping_attachment_cast_to_vertex_attachment(spine_clipping_attachment obj);
+SPINE_C_API spine_attachment spine_clipping_attachment_cast_to_attachment(spine_clipping_attachment obj);
+SPINE_C_API spine_update spine_constraint_cast_to_update(spine_constraint obj);
+SPINE_C_API spine_curve_timeline1 spine_constraint_timeline1_cast_to_curve_timeline1(spine_constraint_timeline1 obj);
+SPINE_C_API spine_curve_timeline spine_constraint_timeline1_cast_to_curve_timeline(spine_constraint_timeline1 obj);
+SPINE_C_API spine_timeline spine_constraint_timeline1_cast_to_timeline(spine_constraint_timeline1 obj);
+SPINE_C_API spine_constraint_timeline spine_constraint_timeline1_cast_to_constraint_timeline(spine_constraint_timeline1 obj);
+SPINE_C_API spine_timeline spine_curve_timeline_cast_to_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_curve_timeline spine_curve_timeline1_cast_to_curve_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_timeline spine_curve_timeline1_cast_to_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_slot_curve_timeline spine_deform_timeline_cast_to_slot_curve_timeline(spine_deform_timeline obj);
+SPINE_C_API spine_curve_timeline spine_deform_timeline_cast_to_curve_timeline(spine_deform_timeline obj);
+SPINE_C_API spine_timeline spine_deform_timeline_cast_to_timeline(spine_deform_timeline obj);
+SPINE_C_API spine_slot_timeline spine_deform_timeline_cast_to_slot_timeline(spine_deform_timeline obj);
+SPINE_C_API spine_timeline spine_draw_order_timeline_cast_to_timeline(spine_draw_order_timeline obj);
+SPINE_C_API spine_timeline spine_event_timeline_cast_to_timeline(spine_event_timeline obj);
+SPINE_C_API spine_from_property spine_from_rotate_cast_to_from_property(spine_from_rotate obj);
+SPINE_C_API spine_from_property spine_from_scale_x_cast_to_from_property(spine_from_scale_x obj);
+SPINE_C_API spine_from_property spine_from_scale_y_cast_to_from_property(spine_from_scale_y obj);
+SPINE_C_API spine_from_property spine_from_shear_y_cast_to_from_property(spine_from_shear_y obj);
+SPINE_C_API spine_from_property spine_from_x_cast_to_from_property(spine_from_x obj);
+SPINE_C_API spine_from_property spine_from_y_cast_to_from_property(spine_from_y obj);
+SPINE_C_API spine_ik_constraint_base spine_ik_constraint_cast_to_ik_constraint_base(spine_ik_constraint obj);
+SPINE_C_API spine_posed spine_ik_constraint_cast_to_posed(spine_ik_constraint obj);
+SPINE_C_API spine_posed_active spine_ik_constraint_cast_to_posed_active(spine_ik_constraint obj);
+SPINE_C_API spine_constraint spine_ik_constraint_cast_to_constraint(spine_ik_constraint obj);
+SPINE_C_API spine_update spine_ik_constraint_cast_to_update(spine_ik_constraint obj);
+SPINE_C_API spine_posed spine_ik_constraint_base_cast_to_posed(spine_ik_constraint_base obj);
+SPINE_C_API spine_posed_active spine_ik_constraint_base_cast_to_posed_active(spine_ik_constraint_base obj);
+SPINE_C_API spine_constraint spine_ik_constraint_base_cast_to_constraint(spine_ik_constraint_base obj);
+SPINE_C_API spine_update spine_ik_constraint_base_cast_to_update(spine_ik_constraint_base obj);
+SPINE_C_API spine_posed_data spine_ik_constraint_data_cast_to_posed_data(spine_ik_constraint_data obj);
+SPINE_C_API spine_constraint_data spine_ik_constraint_data_cast_to_constraint_data(spine_ik_constraint_data obj);
+SPINE_C_API spine_curve_timeline spine_ik_constraint_timeline_cast_to_curve_timeline(spine_ik_constraint_timeline obj);
+SPINE_C_API spine_timeline spine_ik_constraint_timeline_cast_to_timeline(spine_ik_constraint_timeline obj);
+SPINE_C_API spine_constraint_timeline spine_ik_constraint_timeline_cast_to_constraint_timeline(spine_ik_constraint_timeline obj);
+SPINE_C_API spine_timeline spine_inherit_timeline_cast_to_timeline(spine_inherit_timeline obj);
+SPINE_C_API spine_bone_timeline spine_inherit_timeline_cast_to_bone_timeline(spine_inherit_timeline obj);
+SPINE_C_API spine_vertex_attachment spine_mesh_attachment_cast_to_vertex_attachment(spine_mesh_attachment obj);
+SPINE_C_API spine_attachment spine_mesh_attachment_cast_to_attachment(spine_mesh_attachment obj);
+SPINE_C_API spine_vertex_attachment spine_path_attachment_cast_to_vertex_attachment(spine_path_attachment obj);
+SPINE_C_API spine_attachment spine_path_attachment_cast_to_attachment(spine_path_attachment obj);
+SPINE_C_API spine_path_constraint_base spine_path_constraint_cast_to_path_constraint_base(spine_path_constraint obj);
+SPINE_C_API spine_posed spine_path_constraint_cast_to_posed(spine_path_constraint obj);
+SPINE_C_API spine_posed_active spine_path_constraint_cast_to_posed_active(spine_path_constraint obj);
+SPINE_C_API spine_constraint spine_path_constraint_cast_to_constraint(spine_path_constraint obj);
+SPINE_C_API spine_update spine_path_constraint_cast_to_update(spine_path_constraint obj);
+SPINE_C_API spine_posed spine_path_constraint_base_cast_to_posed(spine_path_constraint_base obj);
+SPINE_C_API spine_posed_active spine_path_constraint_base_cast_to_posed_active(spine_path_constraint_base obj);
+SPINE_C_API spine_constraint spine_path_constraint_base_cast_to_constraint(spine_path_constraint_base obj);
+SPINE_C_API spine_update spine_path_constraint_base_cast_to_update(spine_path_constraint_base obj);
+SPINE_C_API spine_posed_data spine_path_constraint_data_cast_to_posed_data(spine_path_constraint_data obj);
+SPINE_C_API spine_constraint_data spine_path_constraint_data_cast_to_constraint_data(spine_path_constraint_data obj);
+SPINE_C_API spine_curve_timeline spine_path_constraint_mix_timeline_cast_to_curve_timeline(spine_path_constraint_mix_timeline obj);
+SPINE_C_API spine_timeline spine_path_constraint_mix_timeline_cast_to_timeline(spine_path_constraint_mix_timeline obj);
+SPINE_C_API spine_constraint_timeline spine_path_constraint_mix_timeline_cast_to_constraint_timeline(spine_path_constraint_mix_timeline obj);
+SPINE_C_API spine_constraint_timeline1
+spine_path_constraint_position_timeline_cast_to_constraint_timeline1(spine_path_constraint_position_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_path_constraint_position_timeline_cast_to_curve_timeline1(spine_path_constraint_position_timeline obj);
+SPINE_C_API spine_curve_timeline spine_path_constraint_position_timeline_cast_to_curve_timeline(spine_path_constraint_position_timeline obj);
+SPINE_C_API spine_timeline spine_path_constraint_position_timeline_cast_to_timeline(spine_path_constraint_position_timeline obj);
+SPINE_C_API spine_constraint_timeline
+spine_path_constraint_position_timeline_cast_to_constraint_timeline(spine_path_constraint_position_timeline obj);
+SPINE_C_API spine_constraint_timeline1
+spine_path_constraint_spacing_timeline_cast_to_constraint_timeline1(spine_path_constraint_spacing_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_path_constraint_spacing_timeline_cast_to_curve_timeline1(spine_path_constraint_spacing_timeline obj);
+SPINE_C_API spine_curve_timeline spine_path_constraint_spacing_timeline_cast_to_curve_timeline(spine_path_constraint_spacing_timeline obj);
+SPINE_C_API spine_timeline spine_path_constraint_spacing_timeline_cast_to_timeline(spine_path_constraint_spacing_timeline obj);
+SPINE_C_API spine_constraint_timeline spine_path_constraint_spacing_timeline_cast_to_constraint_timeline(spine_path_constraint_spacing_timeline obj);
+SPINE_C_API spine_physics_constraint_base spine_physics_constraint_cast_to_physics_constraint_base(spine_physics_constraint obj);
+SPINE_C_API spine_posed spine_physics_constraint_cast_to_posed(spine_physics_constraint obj);
+SPINE_C_API spine_posed_active spine_physics_constraint_cast_to_posed_active(spine_physics_constraint obj);
+SPINE_C_API spine_constraint spine_physics_constraint_cast_to_constraint(spine_physics_constraint obj);
+SPINE_C_API spine_update spine_physics_constraint_cast_to_update(spine_physics_constraint obj);
+SPINE_C_API spine_posed spine_physics_constraint_base_cast_to_posed(spine_physics_constraint_base obj);
+SPINE_C_API spine_posed_active spine_physics_constraint_base_cast_to_posed_active(spine_physics_constraint_base obj);
+SPINE_C_API spine_constraint spine_physics_constraint_base_cast_to_constraint(spine_physics_constraint_base obj);
+SPINE_C_API spine_update spine_physics_constraint_base_cast_to_update(spine_physics_constraint_base obj);
+SPINE_C_API spine_physics_constraint_timeline
+spine_physics_constraint_damping_timeline_cast_to_physics_constraint_timeline(spine_physics_constraint_damping_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_physics_constraint_damping_timeline_cast_to_curve_timeline1(spine_physics_constraint_damping_timeline obj);
+SPINE_C_API spine_curve_timeline spine_physics_constraint_damping_timeline_cast_to_curve_timeline(spine_physics_constraint_damping_timeline obj);
+SPINE_C_API spine_timeline spine_physics_constraint_damping_timeline_cast_to_timeline(spine_physics_constraint_damping_timeline obj);
+SPINE_C_API spine_constraint_timeline
+spine_physics_constraint_damping_timeline_cast_to_constraint_timeline(spine_physics_constraint_damping_timeline obj);
+SPINE_C_API spine_posed_data spine_physics_constraint_data_cast_to_posed_data(spine_physics_constraint_data obj);
+SPINE_C_API spine_constraint_data spine_physics_constraint_data_cast_to_constraint_data(spine_physics_constraint_data obj);
+SPINE_C_API spine_physics_constraint_timeline
+spine_physics_constraint_gravity_timeline_cast_to_physics_constraint_timeline(spine_physics_constraint_gravity_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_physics_constraint_gravity_timeline_cast_to_curve_timeline1(spine_physics_constraint_gravity_timeline obj);
+SPINE_C_API spine_curve_timeline spine_physics_constraint_gravity_timeline_cast_to_curve_timeline(spine_physics_constraint_gravity_timeline obj);
+SPINE_C_API spine_timeline spine_physics_constraint_gravity_timeline_cast_to_timeline(spine_physics_constraint_gravity_timeline obj);
+SPINE_C_API spine_constraint_timeline
+spine_physics_constraint_gravity_timeline_cast_to_constraint_timeline(spine_physics_constraint_gravity_timeline obj);
+SPINE_C_API spine_physics_constraint_timeline
+spine_physics_constraint_inertia_timeline_cast_to_physics_constraint_timeline(spine_physics_constraint_inertia_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_physics_constraint_inertia_timeline_cast_to_curve_timeline1(spine_physics_constraint_inertia_timeline obj);
+SPINE_C_API spine_curve_timeline spine_physics_constraint_inertia_timeline_cast_to_curve_timeline(spine_physics_constraint_inertia_timeline obj);
+SPINE_C_API spine_timeline spine_physics_constraint_inertia_timeline_cast_to_timeline(spine_physics_constraint_inertia_timeline obj);
+SPINE_C_API spine_constraint_timeline
+spine_physics_constraint_inertia_timeline_cast_to_constraint_timeline(spine_physics_constraint_inertia_timeline obj);
+SPINE_C_API spine_physics_constraint_timeline
+spine_physics_constraint_mass_timeline_cast_to_physics_constraint_timeline(spine_physics_constraint_mass_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_physics_constraint_mass_timeline_cast_to_curve_timeline1(spine_physics_constraint_mass_timeline obj);
+SPINE_C_API spine_curve_timeline spine_physics_constraint_mass_timeline_cast_to_curve_timeline(spine_physics_constraint_mass_timeline obj);
+SPINE_C_API spine_timeline spine_physics_constraint_mass_timeline_cast_to_timeline(spine_physics_constraint_mass_timeline obj);
+SPINE_C_API spine_constraint_timeline spine_physics_constraint_mass_timeline_cast_to_constraint_timeline(spine_physics_constraint_mass_timeline obj);
+SPINE_C_API spine_physics_constraint_timeline
+spine_physics_constraint_mix_timeline_cast_to_physics_constraint_timeline(spine_physics_constraint_mix_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_physics_constraint_mix_timeline_cast_to_curve_timeline1(spine_physics_constraint_mix_timeline obj);
+SPINE_C_API spine_curve_timeline spine_physics_constraint_mix_timeline_cast_to_curve_timeline(spine_physics_constraint_mix_timeline obj);
+SPINE_C_API spine_timeline spine_physics_constraint_mix_timeline_cast_to_timeline(spine_physics_constraint_mix_timeline obj);
+SPINE_C_API spine_constraint_timeline spine_physics_constraint_mix_timeline_cast_to_constraint_timeline(spine_physics_constraint_mix_timeline obj);
+SPINE_C_API spine_timeline spine_physics_constraint_reset_timeline_cast_to_timeline(spine_physics_constraint_reset_timeline obj);
+SPINE_C_API spine_constraint_timeline
+spine_physics_constraint_reset_timeline_cast_to_constraint_timeline(spine_physics_constraint_reset_timeline obj);
+SPINE_C_API spine_physics_constraint_timeline
+spine_physics_constraint_strength_timeline_cast_to_physics_constraint_timeline(spine_physics_constraint_strength_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_physics_constraint_strength_timeline_cast_to_curve_timeline1(spine_physics_constraint_strength_timeline obj);
+SPINE_C_API spine_curve_timeline spine_physics_constraint_strength_timeline_cast_to_curve_timeline(spine_physics_constraint_strength_timeline obj);
+SPINE_C_API spine_timeline spine_physics_constraint_strength_timeline_cast_to_timeline(spine_physics_constraint_strength_timeline obj);
+SPINE_C_API spine_constraint_timeline
+spine_physics_constraint_strength_timeline_cast_to_constraint_timeline(spine_physics_constraint_strength_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_physics_constraint_timeline_cast_to_curve_timeline1(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_curve_timeline spine_physics_constraint_timeline_cast_to_curve_timeline(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_timeline spine_physics_constraint_timeline_cast_to_timeline(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_constraint_timeline spine_physics_constraint_timeline_cast_to_constraint_timeline(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_timeline
+spine_physics_constraint_wind_timeline_cast_to_physics_constraint_timeline(spine_physics_constraint_wind_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_physics_constraint_wind_timeline_cast_to_curve_timeline1(spine_physics_constraint_wind_timeline obj);
+SPINE_C_API spine_curve_timeline spine_physics_constraint_wind_timeline_cast_to_curve_timeline(spine_physics_constraint_wind_timeline obj);
+SPINE_C_API spine_timeline spine_physics_constraint_wind_timeline_cast_to_timeline(spine_physics_constraint_wind_timeline obj);
+SPINE_C_API spine_constraint_timeline spine_physics_constraint_wind_timeline_cast_to_constraint_timeline(spine_physics_constraint_wind_timeline obj);
+SPINE_C_API spine_attachment spine_point_attachment_cast_to_attachment(spine_point_attachment obj);
+SPINE_C_API spine_attachment spine_region_attachment_cast_to_attachment(spine_region_attachment obj);
+SPINE_C_API spine_slot_curve_timeline spine_rgb2_timeline_cast_to_slot_curve_timeline(spine_rgb2_timeline obj);
+SPINE_C_API spine_curve_timeline spine_rgb2_timeline_cast_to_curve_timeline(spine_rgb2_timeline obj);
+SPINE_C_API spine_timeline spine_rgb2_timeline_cast_to_timeline(spine_rgb2_timeline obj);
+SPINE_C_API spine_slot_timeline spine_rgb2_timeline_cast_to_slot_timeline(spine_rgb2_timeline obj);
+SPINE_C_API spine_slot_curve_timeline spine_rgba2_timeline_cast_to_slot_curve_timeline(spine_rgba2_timeline obj);
+SPINE_C_API spine_curve_timeline spine_rgba2_timeline_cast_to_curve_timeline(spine_rgba2_timeline obj);
+SPINE_C_API spine_timeline spine_rgba2_timeline_cast_to_timeline(spine_rgba2_timeline obj);
+SPINE_C_API spine_slot_timeline spine_rgba2_timeline_cast_to_slot_timeline(spine_rgba2_timeline obj);
+SPINE_C_API spine_slot_curve_timeline spine_rgba_timeline_cast_to_slot_curve_timeline(spine_rgba_timeline obj);
+SPINE_C_API spine_curve_timeline spine_rgba_timeline_cast_to_curve_timeline(spine_rgba_timeline obj);
+SPINE_C_API spine_timeline spine_rgba_timeline_cast_to_timeline(spine_rgba_timeline obj);
+SPINE_C_API spine_slot_timeline spine_rgba_timeline_cast_to_slot_timeline(spine_rgba_timeline obj);
+SPINE_C_API spine_slot_curve_timeline spine_rgb_timeline_cast_to_slot_curve_timeline(spine_rgb_timeline obj);
+SPINE_C_API spine_curve_timeline spine_rgb_timeline_cast_to_curve_timeline(spine_rgb_timeline obj);
+SPINE_C_API spine_timeline spine_rgb_timeline_cast_to_timeline(spine_rgb_timeline obj);
+SPINE_C_API spine_slot_timeline spine_rgb_timeline_cast_to_slot_timeline(spine_rgb_timeline obj);
+SPINE_C_API spine_bone_timeline1 spine_rotate_timeline_cast_to_bone_timeline1(spine_rotate_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_rotate_timeline_cast_to_curve_timeline1(spine_rotate_timeline obj);
+SPINE_C_API spine_curve_timeline spine_rotate_timeline_cast_to_curve_timeline(spine_rotate_timeline obj);
+SPINE_C_API spine_timeline spine_rotate_timeline_cast_to_timeline(spine_rotate_timeline obj);
+SPINE_C_API spine_bone_timeline spine_rotate_timeline_cast_to_bone_timeline(spine_rotate_timeline obj);
+SPINE_C_API spine_bone_timeline2 spine_scale_timeline_cast_to_bone_timeline2(spine_scale_timeline obj);
+SPINE_C_API spine_curve_timeline spine_scale_timeline_cast_to_curve_timeline(spine_scale_timeline obj);
+SPINE_C_API spine_timeline spine_scale_timeline_cast_to_timeline(spine_scale_timeline obj);
+SPINE_C_API spine_bone_timeline spine_scale_timeline_cast_to_bone_timeline(spine_scale_timeline obj);
+SPINE_C_API spine_bone_timeline1 spine_scale_x_timeline_cast_to_bone_timeline1(spine_scale_x_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_scale_x_timeline_cast_to_curve_timeline1(spine_scale_x_timeline obj);
+SPINE_C_API spine_curve_timeline spine_scale_x_timeline_cast_to_curve_timeline(spine_scale_x_timeline obj);
+SPINE_C_API spine_timeline spine_scale_x_timeline_cast_to_timeline(spine_scale_x_timeline obj);
+SPINE_C_API spine_bone_timeline spine_scale_x_timeline_cast_to_bone_timeline(spine_scale_x_timeline obj);
+SPINE_C_API spine_bone_timeline1 spine_scale_y_timeline_cast_to_bone_timeline1(spine_scale_y_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_scale_y_timeline_cast_to_curve_timeline1(spine_scale_y_timeline obj);
+SPINE_C_API spine_curve_timeline spine_scale_y_timeline_cast_to_curve_timeline(spine_scale_y_timeline obj);
+SPINE_C_API spine_timeline spine_scale_y_timeline_cast_to_timeline(spine_scale_y_timeline obj);
+SPINE_C_API spine_bone_timeline spine_scale_y_timeline_cast_to_bone_timeline(spine_scale_y_timeline obj);
+SPINE_C_API spine_timeline spine_sequence_timeline_cast_to_timeline(spine_sequence_timeline obj);
+SPINE_C_API spine_slot_timeline spine_sequence_timeline_cast_to_slot_timeline(spine_sequence_timeline obj);
+SPINE_C_API spine_bone_timeline2 spine_shear_timeline_cast_to_bone_timeline2(spine_shear_timeline obj);
+SPINE_C_API spine_curve_timeline spine_shear_timeline_cast_to_curve_timeline(spine_shear_timeline obj);
+SPINE_C_API spine_timeline spine_shear_timeline_cast_to_timeline(spine_shear_timeline obj);
+SPINE_C_API spine_bone_timeline spine_shear_timeline_cast_to_bone_timeline(spine_shear_timeline obj);
+SPINE_C_API spine_bone_timeline1 spine_shear_x_timeline_cast_to_bone_timeline1(spine_shear_x_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_shear_x_timeline_cast_to_curve_timeline1(spine_shear_x_timeline obj);
+SPINE_C_API spine_curve_timeline spine_shear_x_timeline_cast_to_curve_timeline(spine_shear_x_timeline obj);
+SPINE_C_API spine_timeline spine_shear_x_timeline_cast_to_timeline(spine_shear_x_timeline obj);
+SPINE_C_API spine_bone_timeline spine_shear_x_timeline_cast_to_bone_timeline(spine_shear_x_timeline obj);
+SPINE_C_API spine_bone_timeline1 spine_shear_y_timeline_cast_to_bone_timeline1(spine_shear_y_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_shear_y_timeline_cast_to_curve_timeline1(spine_shear_y_timeline obj);
+SPINE_C_API spine_curve_timeline spine_shear_y_timeline_cast_to_curve_timeline(spine_shear_y_timeline obj);
+SPINE_C_API spine_timeline spine_shear_y_timeline_cast_to_timeline(spine_shear_y_timeline obj);
+SPINE_C_API spine_bone_timeline spine_shear_y_timeline_cast_to_bone_timeline(spine_shear_y_timeline obj);
+SPINE_C_API spine_slider_base spine_slider_cast_to_slider_base(spine_slider obj);
+SPINE_C_API spine_posed spine_slider_cast_to_posed(spine_slider obj);
+SPINE_C_API spine_posed_active spine_slider_cast_to_posed_active(spine_slider obj);
+SPINE_C_API spine_constraint spine_slider_cast_to_constraint(spine_slider obj);
+SPINE_C_API spine_update spine_slider_cast_to_update(spine_slider obj);
+SPINE_C_API spine_posed spine_slider_base_cast_to_posed(spine_slider_base obj);
+SPINE_C_API spine_posed_active spine_slider_base_cast_to_posed_active(spine_slider_base obj);
+SPINE_C_API spine_constraint spine_slider_base_cast_to_constraint(spine_slider_base obj);
+SPINE_C_API spine_update spine_slider_base_cast_to_update(spine_slider_base obj);
+SPINE_C_API spine_posed_data spine_slider_data_cast_to_posed_data(spine_slider_data obj);
+SPINE_C_API spine_constraint_data spine_slider_data_cast_to_constraint_data(spine_slider_data obj);
+SPINE_C_API spine_constraint_timeline1 spine_slider_mix_timeline_cast_to_constraint_timeline1(spine_slider_mix_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_slider_mix_timeline_cast_to_curve_timeline1(spine_slider_mix_timeline obj);
+SPINE_C_API spine_curve_timeline spine_slider_mix_timeline_cast_to_curve_timeline(spine_slider_mix_timeline obj);
+SPINE_C_API spine_timeline spine_slider_mix_timeline_cast_to_timeline(spine_slider_mix_timeline obj);
+SPINE_C_API spine_constraint_timeline spine_slider_mix_timeline_cast_to_constraint_timeline(spine_slider_mix_timeline obj);
+SPINE_C_API spine_constraint_timeline1 spine_slider_timeline_cast_to_constraint_timeline1(spine_slider_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_slider_timeline_cast_to_curve_timeline1(spine_slider_timeline obj);
+SPINE_C_API spine_curve_timeline spine_slider_timeline_cast_to_curve_timeline(spine_slider_timeline obj);
+SPINE_C_API spine_timeline spine_slider_timeline_cast_to_timeline(spine_slider_timeline obj);
+SPINE_C_API spine_constraint_timeline spine_slider_timeline_cast_to_constraint_timeline(spine_slider_timeline obj);
+SPINE_C_API spine_posed spine_slot_cast_to_posed(spine_slot obj);
+SPINE_C_API spine_curve_timeline spine_slot_curve_timeline_cast_to_curve_timeline(spine_slot_curve_timeline obj);
+SPINE_C_API spine_timeline spine_slot_curve_timeline_cast_to_timeline(spine_slot_curve_timeline obj);
+SPINE_C_API spine_slot_timeline spine_slot_curve_timeline_cast_to_slot_timeline(spine_slot_curve_timeline obj);
+SPINE_C_API spine_posed_data spine_slot_data_cast_to_posed_data(spine_slot_data obj);
+SPINE_C_API spine_to_property spine_to_rotate_cast_to_to_property(spine_to_rotate obj);
+SPINE_C_API spine_to_property spine_to_scale_x_cast_to_to_property(spine_to_scale_x obj);
+SPINE_C_API spine_to_property spine_to_scale_y_cast_to_to_property(spine_to_scale_y obj);
+SPINE_C_API spine_to_property spine_to_shear_y_cast_to_to_property(spine_to_shear_y obj);
+SPINE_C_API spine_to_property spine_to_x_cast_to_to_property(spine_to_x obj);
+SPINE_C_API spine_to_property spine_to_y_cast_to_to_property(spine_to_y obj);
+SPINE_C_API spine_transform_constraint_base spine_transform_constraint_cast_to_transform_constraint_base(spine_transform_constraint obj);
+SPINE_C_API spine_posed spine_transform_constraint_cast_to_posed(spine_transform_constraint obj);
+SPINE_C_API spine_posed_active spine_transform_constraint_cast_to_posed_active(spine_transform_constraint obj);
+SPINE_C_API spine_constraint spine_transform_constraint_cast_to_constraint(spine_transform_constraint obj);
+SPINE_C_API spine_update spine_transform_constraint_cast_to_update(spine_transform_constraint obj);
+SPINE_C_API spine_posed spine_transform_constraint_base_cast_to_posed(spine_transform_constraint_base obj);
+SPINE_C_API spine_posed_active spine_transform_constraint_base_cast_to_posed_active(spine_transform_constraint_base obj);
+SPINE_C_API spine_constraint spine_transform_constraint_base_cast_to_constraint(spine_transform_constraint_base obj);
+SPINE_C_API spine_update spine_transform_constraint_base_cast_to_update(spine_transform_constraint_base obj);
+SPINE_C_API spine_posed_data spine_transform_constraint_data_cast_to_posed_data(spine_transform_constraint_data obj);
+SPINE_C_API spine_constraint_data spine_transform_constraint_data_cast_to_constraint_data(spine_transform_constraint_data obj);
+SPINE_C_API spine_curve_timeline spine_transform_constraint_timeline_cast_to_curve_timeline(spine_transform_constraint_timeline obj);
+SPINE_C_API spine_timeline spine_transform_constraint_timeline_cast_to_timeline(spine_transform_constraint_timeline obj);
+SPINE_C_API spine_constraint_timeline spine_transform_constraint_timeline_cast_to_constraint_timeline(spine_transform_constraint_timeline obj);
+SPINE_C_API spine_bone_timeline2 spine_translate_timeline_cast_to_bone_timeline2(spine_translate_timeline obj);
+SPINE_C_API spine_curve_timeline spine_translate_timeline_cast_to_curve_timeline(spine_translate_timeline obj);
+SPINE_C_API spine_timeline spine_translate_timeline_cast_to_timeline(spine_translate_timeline obj);
+SPINE_C_API spine_bone_timeline spine_translate_timeline_cast_to_bone_timeline(spine_translate_timeline obj);
+SPINE_C_API spine_bone_timeline1 spine_translate_x_timeline_cast_to_bone_timeline1(spine_translate_x_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_translate_x_timeline_cast_to_curve_timeline1(spine_translate_x_timeline obj);
+SPINE_C_API spine_curve_timeline spine_translate_x_timeline_cast_to_curve_timeline(spine_translate_x_timeline obj);
+SPINE_C_API spine_timeline spine_translate_x_timeline_cast_to_timeline(spine_translate_x_timeline obj);
+SPINE_C_API spine_bone_timeline spine_translate_x_timeline_cast_to_bone_timeline(spine_translate_x_timeline obj);
+SPINE_C_API spine_bone_timeline1 spine_translate_y_timeline_cast_to_bone_timeline1(spine_translate_y_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_translate_y_timeline_cast_to_curve_timeline1(spine_translate_y_timeline obj);
+SPINE_C_API spine_curve_timeline spine_translate_y_timeline_cast_to_curve_timeline(spine_translate_y_timeline obj);
+SPINE_C_API spine_timeline spine_translate_y_timeline_cast_to_timeline(spine_translate_y_timeline obj);
+SPINE_C_API spine_bone_timeline spine_translate_y_timeline_cast_to_bone_timeline(spine_translate_y_timeline obj);
+SPINE_C_API spine_attachment spine_vertex_attachment_cast_to_attachment(spine_vertex_attachment obj);
+
+// Downcast functions (base to derived) - user must ensure correct type
+SPINE_C_API spine_alpha_timeline spine_curve_timeline1_cast_to_alpha_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_bone_timeline1 spine_curve_timeline1_cast_to_bone_timeline1(spine_curve_timeline1 obj);
+SPINE_C_API spine_constraint_timeline1 spine_curve_timeline1_cast_to_constraint_timeline1(spine_curve_timeline1 obj);
+SPINE_C_API spine_path_constraint_position_timeline spine_curve_timeline1_cast_to_path_constraint_position_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_path_constraint_spacing_timeline spine_curve_timeline1_cast_to_path_constraint_spacing_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_physics_constraint_damping_timeline spine_curve_timeline1_cast_to_physics_constraint_damping_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_physics_constraint_gravity_timeline spine_curve_timeline1_cast_to_physics_constraint_gravity_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_physics_constraint_inertia_timeline spine_curve_timeline1_cast_to_physics_constraint_inertia_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_physics_constraint_mass_timeline spine_curve_timeline1_cast_to_physics_constraint_mass_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_physics_constraint_mix_timeline spine_curve_timeline1_cast_to_physics_constraint_mix_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_physics_constraint_strength_timeline spine_curve_timeline1_cast_to_physics_constraint_strength_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_physics_constraint_timeline spine_curve_timeline1_cast_to_physics_constraint_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_physics_constraint_wind_timeline spine_curve_timeline1_cast_to_physics_constraint_wind_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_rotate_timeline spine_curve_timeline1_cast_to_rotate_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_scale_x_timeline spine_curve_timeline1_cast_to_scale_x_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_scale_y_timeline spine_curve_timeline1_cast_to_scale_y_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_shear_x_timeline spine_curve_timeline1_cast_to_shear_x_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_shear_y_timeline spine_curve_timeline1_cast_to_shear_y_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_slider_mix_timeline spine_curve_timeline1_cast_to_slider_mix_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_slider_timeline spine_curve_timeline1_cast_to_slider_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_translate_x_timeline spine_curve_timeline1_cast_to_translate_x_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_translate_y_timeline spine_curve_timeline1_cast_to_translate_y_timeline(spine_curve_timeline1 obj);
+SPINE_C_API spine_alpha_timeline spine_curve_timeline_cast_to_alpha_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_bone_timeline1 spine_curve_timeline_cast_to_bone_timeline1(spine_curve_timeline obj);
+SPINE_C_API spine_bone_timeline2 spine_curve_timeline_cast_to_bone_timeline2(spine_curve_timeline obj);
+SPINE_C_API spine_constraint_timeline1 spine_curve_timeline_cast_to_constraint_timeline1(spine_curve_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_curve_timeline_cast_to_curve_timeline1(spine_curve_timeline obj);
+SPINE_C_API spine_deform_timeline spine_curve_timeline_cast_to_deform_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_ik_constraint_timeline spine_curve_timeline_cast_to_ik_constraint_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_path_constraint_mix_timeline spine_curve_timeline_cast_to_path_constraint_mix_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_path_constraint_position_timeline spine_curve_timeline_cast_to_path_constraint_position_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_path_constraint_spacing_timeline spine_curve_timeline_cast_to_path_constraint_spacing_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_physics_constraint_damping_timeline spine_curve_timeline_cast_to_physics_constraint_damping_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_physics_constraint_gravity_timeline spine_curve_timeline_cast_to_physics_constraint_gravity_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_physics_constraint_inertia_timeline spine_curve_timeline_cast_to_physics_constraint_inertia_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_physics_constraint_mass_timeline spine_curve_timeline_cast_to_physics_constraint_mass_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_physics_constraint_mix_timeline spine_curve_timeline_cast_to_physics_constraint_mix_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_physics_constraint_strength_timeline spine_curve_timeline_cast_to_physics_constraint_strength_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_physics_constraint_timeline spine_curve_timeline_cast_to_physics_constraint_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_physics_constraint_wind_timeline spine_curve_timeline_cast_to_physics_constraint_wind_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_rgb2_timeline spine_curve_timeline_cast_to_rgb2_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_rgba2_timeline spine_curve_timeline_cast_to_rgba2_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_rgba_timeline spine_curve_timeline_cast_to_rgba_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_rgb_timeline spine_curve_timeline_cast_to_rgb_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_rotate_timeline spine_curve_timeline_cast_to_rotate_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_scale_timeline spine_curve_timeline_cast_to_scale_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_scale_x_timeline spine_curve_timeline_cast_to_scale_x_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_scale_y_timeline spine_curve_timeline_cast_to_scale_y_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_shear_timeline spine_curve_timeline_cast_to_shear_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_shear_x_timeline spine_curve_timeline_cast_to_shear_x_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_shear_y_timeline spine_curve_timeline_cast_to_shear_y_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_slider_mix_timeline spine_curve_timeline_cast_to_slider_mix_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_slider_timeline spine_curve_timeline_cast_to_slider_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_slot_curve_timeline spine_curve_timeline_cast_to_slot_curve_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_transform_constraint_timeline spine_curve_timeline_cast_to_transform_constraint_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_translate_timeline spine_curve_timeline_cast_to_translate_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_translate_x_timeline spine_curve_timeline_cast_to_translate_x_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_translate_y_timeline spine_curve_timeline_cast_to_translate_y_timeline(spine_curve_timeline obj);
+SPINE_C_API spine_alpha_timeline spine_timeline_cast_to_alpha_timeline(spine_timeline obj);
+SPINE_C_API spine_attachment_timeline spine_timeline_cast_to_attachment_timeline(spine_timeline obj);
+SPINE_C_API spine_bone_timeline1 spine_timeline_cast_to_bone_timeline1(spine_timeline obj);
+SPINE_C_API spine_bone_timeline2 spine_timeline_cast_to_bone_timeline2(spine_timeline obj);
+SPINE_C_API spine_constraint_timeline1 spine_timeline_cast_to_constraint_timeline1(spine_timeline obj);
+SPINE_C_API spine_curve_timeline spine_timeline_cast_to_curve_timeline(spine_timeline obj);
+SPINE_C_API spine_curve_timeline1 spine_timeline_cast_to_curve_timeline1(spine_timeline obj);
+SPINE_C_API spine_deform_timeline spine_timeline_cast_to_deform_timeline(spine_timeline obj);
+SPINE_C_API spine_draw_order_timeline spine_timeline_cast_to_draw_order_timeline(spine_timeline obj);
+SPINE_C_API spine_event_timeline spine_timeline_cast_to_event_timeline(spine_timeline obj);
+SPINE_C_API spine_ik_constraint_timeline spine_timeline_cast_to_ik_constraint_timeline(spine_timeline obj);
+SPINE_C_API spine_inherit_timeline spine_timeline_cast_to_inherit_timeline(spine_timeline obj);
+SPINE_C_API spine_path_constraint_mix_timeline spine_timeline_cast_to_path_constraint_mix_timeline(spine_timeline obj);
+SPINE_C_API spine_path_constraint_position_timeline spine_timeline_cast_to_path_constraint_position_timeline(spine_timeline obj);
+SPINE_C_API spine_path_constraint_spacing_timeline spine_timeline_cast_to_path_constraint_spacing_timeline(spine_timeline obj);
+SPINE_C_API spine_physics_constraint_damping_timeline spine_timeline_cast_to_physics_constraint_damping_timeline(spine_timeline obj);
+SPINE_C_API spine_physics_constraint_gravity_timeline spine_timeline_cast_to_physics_constraint_gravity_timeline(spine_timeline obj);
+SPINE_C_API spine_physics_constraint_inertia_timeline spine_timeline_cast_to_physics_constraint_inertia_timeline(spine_timeline obj);
+SPINE_C_API spine_physics_constraint_mass_timeline spine_timeline_cast_to_physics_constraint_mass_timeline(spine_timeline obj);
+SPINE_C_API spine_physics_constraint_mix_timeline spine_timeline_cast_to_physics_constraint_mix_timeline(spine_timeline obj);
+SPINE_C_API spine_physics_constraint_reset_timeline spine_timeline_cast_to_physics_constraint_reset_timeline(spine_timeline obj);
+SPINE_C_API spine_physics_constraint_strength_timeline spine_timeline_cast_to_physics_constraint_strength_timeline(spine_timeline obj);
+SPINE_C_API spine_physics_constraint_timeline spine_timeline_cast_to_physics_constraint_timeline(spine_timeline obj);
+SPINE_C_API spine_physics_constraint_wind_timeline spine_timeline_cast_to_physics_constraint_wind_timeline(spine_timeline obj);
+SPINE_C_API spine_rgb2_timeline spine_timeline_cast_to_rgb2_timeline(spine_timeline obj);
+SPINE_C_API spine_rgba2_timeline spine_timeline_cast_to_rgba2_timeline(spine_timeline obj);
+SPINE_C_API spine_rgba_timeline spine_timeline_cast_to_rgba_timeline(spine_timeline obj);
+SPINE_C_API spine_rgb_timeline spine_timeline_cast_to_rgb_timeline(spine_timeline obj);
+SPINE_C_API spine_rotate_timeline spine_timeline_cast_to_rotate_timeline(spine_timeline obj);
+SPINE_C_API spine_scale_timeline spine_timeline_cast_to_scale_timeline(spine_timeline obj);
+SPINE_C_API spine_scale_x_timeline spine_timeline_cast_to_scale_x_timeline(spine_timeline obj);
+SPINE_C_API spine_scale_y_timeline spine_timeline_cast_to_scale_y_timeline(spine_timeline obj);
+SPINE_C_API spine_sequence_timeline spine_timeline_cast_to_sequence_timeline(spine_timeline obj);
+SPINE_C_API spine_shear_timeline spine_timeline_cast_to_shear_timeline(spine_timeline obj);
+SPINE_C_API spine_shear_x_timeline spine_timeline_cast_to_shear_x_timeline(spine_timeline obj);
+SPINE_C_API spine_shear_y_timeline spine_timeline_cast_to_shear_y_timeline(spine_timeline obj);
+SPINE_C_API spine_slider_mix_timeline spine_timeline_cast_to_slider_mix_timeline(spine_timeline obj);
+SPINE_C_API spine_slider_timeline spine_timeline_cast_to_slider_timeline(spine_timeline obj);
+SPINE_C_API spine_slot_curve_timeline spine_timeline_cast_to_slot_curve_timeline(spine_timeline obj);
+SPINE_C_API spine_transform_constraint_timeline spine_timeline_cast_to_transform_constraint_timeline(spine_timeline obj);
+SPINE_C_API spine_translate_timeline spine_timeline_cast_to_translate_timeline(spine_timeline obj);
+SPINE_C_API spine_translate_x_timeline spine_timeline_cast_to_translate_x_timeline(spine_timeline obj);
+SPINE_C_API spine_translate_y_timeline spine_timeline_cast_to_translate_y_timeline(spine_timeline obj);
+SPINE_C_API spine_alpha_timeline spine_slot_timeline_cast_to_alpha_timeline(spine_slot_timeline obj);
+SPINE_C_API spine_attachment_timeline spine_slot_timeline_cast_to_attachment_timeline(spine_slot_timeline obj);
+SPINE_C_API spine_deform_timeline spine_slot_timeline_cast_to_deform_timeline(spine_slot_timeline obj);
+SPINE_C_API spine_rgb2_timeline spine_slot_timeline_cast_to_rgb2_timeline(spine_slot_timeline obj);
+SPINE_C_API spine_rgba2_timeline spine_slot_timeline_cast_to_rgba2_timeline(spine_slot_timeline obj);
+SPINE_C_API spine_rgba_timeline spine_slot_timeline_cast_to_rgba_timeline(spine_slot_timeline obj);
+SPINE_C_API spine_rgb_timeline spine_slot_timeline_cast_to_rgb_timeline(spine_slot_timeline obj);
+SPINE_C_API spine_sequence_timeline spine_slot_timeline_cast_to_sequence_timeline(spine_slot_timeline obj);
+SPINE_C_API spine_slot_curve_timeline spine_slot_timeline_cast_to_slot_curve_timeline(spine_slot_timeline obj);
+SPINE_C_API spine_atlas_attachment_loader spine_attachment_loader_cast_to_atlas_attachment_loader(spine_attachment_loader obj);
+SPINE_C_API spine_atlas_region spine_texture_region_cast_to_atlas_region(spine_texture_region obj);
+SPINE_C_API spine_bone spine_posed_cast_to_bone(spine_posed obj);
+SPINE_C_API spine_ik_constraint spine_posed_cast_to_ik_constraint(spine_posed obj);
+SPINE_C_API spine_ik_constraint_base spine_posed_cast_to_ik_constraint_base(spine_posed obj);
+SPINE_C_API spine_path_constraint spine_posed_cast_to_path_constraint(spine_posed obj);
+SPINE_C_API spine_path_constraint_base spine_posed_cast_to_path_constraint_base(spine_posed obj);
+SPINE_C_API spine_physics_constraint spine_posed_cast_to_physics_constraint(spine_posed obj);
+SPINE_C_API spine_physics_constraint_base spine_posed_cast_to_physics_constraint_base(spine_posed obj);
+SPINE_C_API spine_slider spine_posed_cast_to_slider(spine_posed obj);
+SPINE_C_API spine_slider_base spine_posed_cast_to_slider_base(spine_posed obj);
+SPINE_C_API spine_slot spine_posed_cast_to_slot(spine_posed obj);
+SPINE_C_API spine_transform_constraint spine_posed_cast_to_transform_constraint(spine_posed obj);
+SPINE_C_API spine_transform_constraint_base spine_posed_cast_to_transform_constraint_base(spine_posed obj);
+SPINE_C_API spine_bone spine_posed_active_cast_to_bone(spine_posed_active obj);
+SPINE_C_API spine_ik_constraint spine_posed_active_cast_to_ik_constraint(spine_posed_active obj);
+SPINE_C_API spine_ik_constraint_base spine_posed_active_cast_to_ik_constraint_base(spine_posed_active obj);
+SPINE_C_API spine_path_constraint spine_posed_active_cast_to_path_constraint(spine_posed_active obj);
+SPINE_C_API spine_path_constraint_base spine_posed_active_cast_to_path_constraint_base(spine_posed_active obj);
+SPINE_C_API spine_physics_constraint spine_posed_active_cast_to_physics_constraint(spine_posed_active obj);
+SPINE_C_API spine_physics_constraint_base spine_posed_active_cast_to_physics_constraint_base(spine_posed_active obj);
+SPINE_C_API spine_slider spine_posed_active_cast_to_slider(spine_posed_active obj);
+SPINE_C_API spine_slider_base spine_posed_active_cast_to_slider_base(spine_posed_active obj);
+SPINE_C_API spine_transform_constraint spine_posed_active_cast_to_transform_constraint(spine_posed_active obj);
+SPINE_C_API spine_transform_constraint_base spine_posed_active_cast_to_transform_constraint_base(spine_posed_active obj);
+SPINE_C_API spine_bone spine_update_cast_to_bone(spine_update obj);
+SPINE_C_API spine_bone_pose spine_update_cast_to_bone_pose(spine_update obj);
+SPINE_C_API spine_constraint spine_update_cast_to_constraint(spine_update obj);
+SPINE_C_API spine_ik_constraint spine_update_cast_to_ik_constraint(spine_update obj);
+SPINE_C_API spine_ik_constraint_base spine_update_cast_to_ik_constraint_base(spine_update obj);
+SPINE_C_API spine_path_constraint spine_update_cast_to_path_constraint(spine_update obj);
+SPINE_C_API spine_path_constraint_base spine_update_cast_to_path_constraint_base(spine_update obj);
+SPINE_C_API spine_physics_constraint spine_update_cast_to_physics_constraint(spine_update obj);
+SPINE_C_API spine_physics_constraint_base spine_update_cast_to_physics_constraint_base(spine_update obj);
+SPINE_C_API spine_slider spine_update_cast_to_slider(spine_update obj);
+SPINE_C_API spine_slider_base spine_update_cast_to_slider_base(spine_update obj);
+SPINE_C_API spine_transform_constraint spine_update_cast_to_transform_constraint(spine_update obj);
+SPINE_C_API spine_transform_constraint_base spine_update_cast_to_transform_constraint_base(spine_update obj);
+SPINE_C_API spine_bone_data spine_posed_data_cast_to_bone_data(spine_posed_data obj);
+SPINE_C_API spine_ik_constraint_data spine_posed_data_cast_to_ik_constraint_data(spine_posed_data obj);
+SPINE_C_API spine_path_constraint_data spine_posed_data_cast_to_path_constraint_data(spine_posed_data obj);
+SPINE_C_API spine_physics_constraint_data spine_posed_data_cast_to_physics_constraint_data(spine_posed_data obj);
+SPINE_C_API spine_slider_data spine_posed_data_cast_to_slider_data(spine_posed_data obj);
+SPINE_C_API spine_slot_data spine_posed_data_cast_to_slot_data(spine_posed_data obj);
+SPINE_C_API spine_transform_constraint_data spine_posed_data_cast_to_transform_constraint_data(spine_posed_data obj);
+SPINE_C_API spine_bone_pose spine_bone_local_cast_to_bone_pose(spine_bone_local obj);
+SPINE_C_API spine_bone_timeline1 spine_bone_timeline_cast_to_bone_timeline1(spine_bone_timeline obj);
+SPINE_C_API spine_bone_timeline2 spine_bone_timeline_cast_to_bone_timeline2(spine_bone_timeline obj);
+SPINE_C_API spine_inherit_timeline spine_bone_timeline_cast_to_inherit_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_rotate_timeline spine_bone_timeline_cast_to_rotate_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_scale_timeline spine_bone_timeline_cast_to_scale_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_scale_x_timeline spine_bone_timeline_cast_to_scale_x_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_scale_y_timeline spine_bone_timeline_cast_to_scale_y_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_shear_timeline spine_bone_timeline_cast_to_shear_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_shear_x_timeline spine_bone_timeline_cast_to_shear_x_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_shear_y_timeline spine_bone_timeline_cast_to_shear_y_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_translate_timeline spine_bone_timeline_cast_to_translate_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_translate_x_timeline spine_bone_timeline_cast_to_translate_x_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_translate_y_timeline spine_bone_timeline_cast_to_translate_y_timeline(spine_bone_timeline obj);
+SPINE_C_API spine_bounding_box_attachment spine_vertex_attachment_cast_to_bounding_box_attachment(spine_vertex_attachment obj);
+SPINE_C_API spine_clipping_attachment spine_vertex_attachment_cast_to_clipping_attachment(spine_vertex_attachment obj);
+SPINE_C_API spine_mesh_attachment spine_vertex_attachment_cast_to_mesh_attachment(spine_vertex_attachment obj);
+SPINE_C_API spine_path_attachment spine_vertex_attachment_cast_to_path_attachment(spine_vertex_attachment obj);
+SPINE_C_API spine_bounding_box_attachment spine_attachment_cast_to_bounding_box_attachment(spine_attachment obj);
+SPINE_C_API spine_clipping_attachment spine_attachment_cast_to_clipping_attachment(spine_attachment obj);
+SPINE_C_API spine_mesh_attachment spine_attachment_cast_to_mesh_attachment(spine_attachment obj);
+SPINE_C_API spine_path_attachment spine_attachment_cast_to_path_attachment(spine_attachment obj);
+SPINE_C_API spine_point_attachment spine_attachment_cast_to_point_attachment(spine_attachment obj);
+SPINE_C_API spine_region_attachment spine_attachment_cast_to_region_attachment(spine_attachment obj);
+SPINE_C_API spine_vertex_attachment spine_attachment_cast_to_vertex_attachment(spine_attachment obj);
+SPINE_C_API spine_constraint_timeline1 spine_constraint_timeline_cast_to_constraint_timeline1(spine_constraint_timeline obj);
+SPINE_C_API spine_ik_constraint_timeline spine_constraint_timeline_cast_to_ik_constraint_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_path_constraint_mix_timeline spine_constraint_timeline_cast_to_path_constraint_mix_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_path_constraint_position_timeline
+spine_constraint_timeline_cast_to_path_constraint_position_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_path_constraint_spacing_timeline spine_constraint_timeline_cast_to_path_constraint_spacing_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_damping_timeline
+spine_constraint_timeline_cast_to_physics_constraint_damping_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_gravity_timeline
+spine_constraint_timeline_cast_to_physics_constraint_gravity_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_inertia_timeline
+spine_constraint_timeline_cast_to_physics_constraint_inertia_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_mass_timeline spine_constraint_timeline_cast_to_physics_constraint_mass_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_mix_timeline spine_constraint_timeline_cast_to_physics_constraint_mix_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_reset_timeline
+spine_constraint_timeline_cast_to_physics_constraint_reset_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_strength_timeline
+spine_constraint_timeline_cast_to_physics_constraint_strength_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_timeline spine_constraint_timeline_cast_to_physics_constraint_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_wind_timeline spine_constraint_timeline_cast_to_physics_constraint_wind_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_slider_mix_timeline spine_constraint_timeline_cast_to_slider_mix_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_slider_timeline spine_constraint_timeline_cast_to_slider_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_transform_constraint_timeline spine_constraint_timeline_cast_to_transform_constraint_timeline(spine_constraint_timeline obj);
+SPINE_C_API spine_deform_timeline spine_slot_curve_timeline_cast_to_deform_timeline(spine_slot_curve_timeline obj);
+SPINE_C_API spine_rgb2_timeline spine_slot_curve_timeline_cast_to_rgb2_timeline(spine_slot_curve_timeline obj);
+SPINE_C_API spine_rgba2_timeline spine_slot_curve_timeline_cast_to_rgba2_timeline(spine_slot_curve_timeline obj);
+SPINE_C_API spine_rgba_timeline spine_slot_curve_timeline_cast_to_rgba_timeline(spine_slot_curve_timeline obj);
+SPINE_C_API spine_rgb_timeline spine_slot_curve_timeline_cast_to_rgb_timeline(spine_slot_curve_timeline obj);
+SPINE_C_API spine_from_rotate spine_from_property_cast_to_from_rotate(spine_from_property obj);
+SPINE_C_API spine_from_scale_x spine_from_property_cast_to_from_scale_x(spine_from_property obj);
+SPINE_C_API spine_from_scale_y spine_from_property_cast_to_from_scale_y(spine_from_property obj);
+SPINE_C_API spine_from_shear_y spine_from_property_cast_to_from_shear_y(spine_from_property obj);
+SPINE_C_API spine_from_x spine_from_property_cast_to_from_x(spine_from_property obj);
+SPINE_C_API spine_from_y spine_from_property_cast_to_from_y(spine_from_property obj);
+SPINE_C_API spine_ik_constraint spine_ik_constraint_base_cast_to_ik_constraint(spine_ik_constraint_base obj);
+SPINE_C_API spine_ik_constraint spine_constraint_cast_to_ik_constraint(spine_constraint obj);
+SPINE_C_API spine_ik_constraint_base spine_constraint_cast_to_ik_constraint_base(spine_constraint obj);
+SPINE_C_API spine_path_constraint spine_constraint_cast_to_path_constraint(spine_constraint obj);
+SPINE_C_API spine_path_constraint_base spine_constraint_cast_to_path_constraint_base(spine_constraint obj);
+SPINE_C_API spine_physics_constraint spine_constraint_cast_to_physics_constraint(spine_constraint obj);
+SPINE_C_API spine_physics_constraint_base spine_constraint_cast_to_physics_constraint_base(spine_constraint obj);
+SPINE_C_API spine_slider spine_constraint_cast_to_slider(spine_constraint obj);
+SPINE_C_API spine_slider_base spine_constraint_cast_to_slider_base(spine_constraint obj);
+SPINE_C_API spine_transform_constraint spine_constraint_cast_to_transform_constraint(spine_constraint obj);
+SPINE_C_API spine_transform_constraint_base spine_constraint_cast_to_transform_constraint_base(spine_constraint obj);
+SPINE_C_API spine_ik_constraint_data spine_constraint_data_cast_to_ik_constraint_data(spine_constraint_data obj);
+SPINE_C_API spine_path_constraint_data spine_constraint_data_cast_to_path_constraint_data(spine_constraint_data obj);
+SPINE_C_API spine_physics_constraint_data spine_constraint_data_cast_to_physics_constraint_data(spine_constraint_data obj);
+SPINE_C_API spine_slider_data spine_constraint_data_cast_to_slider_data(spine_constraint_data obj);
+SPINE_C_API spine_transform_constraint_data spine_constraint_data_cast_to_transform_constraint_data(spine_constraint_data obj);
+SPINE_C_API spine_path_constraint spine_path_constraint_base_cast_to_path_constraint(spine_path_constraint_base obj);
+SPINE_C_API spine_path_constraint_position_timeline
+spine_constraint_timeline1_cast_to_path_constraint_position_timeline(spine_constraint_timeline1 obj);
+SPINE_C_API spine_path_constraint_spacing_timeline
+spine_constraint_timeline1_cast_to_path_constraint_spacing_timeline(spine_constraint_timeline1 obj);
+SPINE_C_API spine_slider_mix_timeline spine_constraint_timeline1_cast_to_slider_mix_timeline(spine_constraint_timeline1 obj);
+SPINE_C_API spine_slider_timeline spine_constraint_timeline1_cast_to_slider_timeline(spine_constraint_timeline1 obj);
+SPINE_C_API spine_physics_constraint spine_physics_constraint_base_cast_to_physics_constraint(spine_physics_constraint_base obj);
+SPINE_C_API spine_physics_constraint_damping_timeline
+spine_physics_constraint_timeline_cast_to_physics_constraint_damping_timeline(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_gravity_timeline
+spine_physics_constraint_timeline_cast_to_physics_constraint_gravity_timeline(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_inertia_timeline
+spine_physics_constraint_timeline_cast_to_physics_constraint_inertia_timeline(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_mass_timeline
+spine_physics_constraint_timeline_cast_to_physics_constraint_mass_timeline(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_mix_timeline
+spine_physics_constraint_timeline_cast_to_physics_constraint_mix_timeline(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_strength_timeline
+spine_physics_constraint_timeline_cast_to_physics_constraint_strength_timeline(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_physics_constraint_wind_timeline
+spine_physics_constraint_timeline_cast_to_physics_constraint_wind_timeline(spine_physics_constraint_timeline obj);
+SPINE_C_API spine_rotate_timeline spine_bone_timeline1_cast_to_rotate_timeline(spine_bone_timeline1 obj);
+SPINE_C_API spine_scale_x_timeline spine_bone_timeline1_cast_to_scale_x_timeline(spine_bone_timeline1 obj);
+SPINE_C_API spine_scale_y_timeline spine_bone_timeline1_cast_to_scale_y_timeline(spine_bone_timeline1 obj);
+SPINE_C_API spine_shear_x_timeline spine_bone_timeline1_cast_to_shear_x_timeline(spine_bone_timeline1 obj);
+SPINE_C_API spine_shear_y_timeline spine_bone_timeline1_cast_to_shear_y_timeline(spine_bone_timeline1 obj);
+SPINE_C_API spine_translate_x_timeline spine_bone_timeline1_cast_to_translate_x_timeline(spine_bone_timeline1 obj);
+SPINE_C_API spine_translate_y_timeline spine_bone_timeline1_cast_to_translate_y_timeline(spine_bone_timeline1 obj);
+SPINE_C_API spine_scale_timeline spine_bone_timeline2_cast_to_scale_timeline(spine_bone_timeline2 obj);
+SPINE_C_API spine_shear_timeline spine_bone_timeline2_cast_to_shear_timeline(spine_bone_timeline2 obj);
+SPINE_C_API spine_translate_timeline spine_bone_timeline2_cast_to_translate_timeline(spine_bone_timeline2 obj);
+SPINE_C_API spine_slider spine_slider_base_cast_to_slider(spine_slider_base obj);
+SPINE_C_API spine_to_rotate spine_to_property_cast_to_to_rotate(spine_to_property obj);
+SPINE_C_API spine_to_scale_x spine_to_property_cast_to_to_scale_x(spine_to_property obj);
+SPINE_C_API spine_to_scale_y spine_to_property_cast_to_to_scale_y(spine_to_property obj);
+SPINE_C_API spine_to_shear_y spine_to_property_cast_to_to_shear_y(spine_to_property obj);
+SPINE_C_API spine_to_x spine_to_property_cast_to_to_x(spine_to_property obj);
+SPINE_C_API spine_to_y spine_to_property_cast_to_to_y(spine_to_property obj);
+SPINE_C_API spine_transform_constraint spine_transform_constraint_base_cast_to_transform_constraint(spine_transform_constraint_base obj);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SPINE_C_CASTS_H */

spine-c/src/generated/clipping_attachment.cpp

@@ -38,83 +38,83 @@ spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment self)
 
 void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
 														size_t count, /*@null*/ float *worldVertices, size_t offset, size_t stride) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (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 *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (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) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	return _self->getId();
 }
 
 spine_array_int spine_clipping_attachment_get_bones(spine_clipping_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	return (spine_array_int) &_self->getBones();
 }
 
 void spine_clipping_attachment_set_bones(spine_clipping_attachment self, spine_array_int bones) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	_self->setBones(*((Array<int> *) bones));
 }
 
 spine_array_float spine_clipping_attachment_get_vertices(spine_clipping_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	return (spine_array_float) &_self->getVertices();
 }
 
 void spine_clipping_attachment_set_vertices(spine_clipping_attachment self, spine_array_float vertices) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	_self->setVertices(*((Array<float> *) vertices));
 }
 
 size_t spine_clipping_attachment_get_world_vertices_length(spine_clipping_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	return _self->getWorldVerticesLength();
 }
 
 void spine_clipping_attachment_set_world_vertices_length(spine_clipping_attachment self, size_t inValue) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	_self->setWorldVerticesLength(inValue);
 }
 
 /*@null*/ spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	return (spine_attachment) _self->getTimelineAttachment();
 }
 
 void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, /*@null*/ spine_attachment attachment) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	_self->setTimelineAttachment((Attachment *) attachment);
 }
 
 void spine_clipping_attachment_copy_to(spine_clipping_attachment self, spine_vertex_attachment other) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	_self->copyTo(*((VertexAttachment *) other));
 }
 
 const char *spine_clipping_attachment_get_name(spine_clipping_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	return _self->getName().buffer();
 }
 
 int spine_clipping_attachment_get_ref_count(spine_clipping_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	return _self->getRefCount();
 }
 
 void spine_clipping_attachment_reference(spine_clipping_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	_self->reference();
 }
 
 void spine_clipping_attachment_dereference(spine_clipping_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
+	ClippingAttachment *_self = (ClippingAttachment *) self;
 	_self->dereference();
 }
 

spine-c/src/generated/constraint_timeline1.cpp

@@ -23,94 +23,94 @@ void spine_constraint_timeline1_set_constraint_index(spine_constraint_timeline1
 }
 
 void spine_constraint_timeline1_set_frame(spine_constraint_timeline1 self, size_t frame, float time, float value) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_constraint_timeline1_get_curve_value(spine_constraint_timeline1 self, float time) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (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 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
 	_self->setLinear(frame);
 }
 
 void spine_constraint_timeline1_set_stepped(spine_constraint_timeline1 self, size_t frame) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (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 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
 									  /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 									  bool appliedPose) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 size_t spine_constraint_timeline1_get_frame_entries(spine_constraint_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_constraint_timeline1_get_frame_count(spine_constraint_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_constraint_timeline1_get_frames(spine_constraint_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_constraint_timeline1_get_duration(spine_constraint_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_constraint_timeline1_get_property_ids(spine_constraint_timeline1 self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/curve_timeline.cpp

@@ -40,32 +40,32 @@ spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self) {
 
 void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
 								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	CurveTimeline *_self = (CurveTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline self) {
-	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	CurveTimeline *_self = (CurveTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_curve_timeline_get_frame_count(spine_curve_timeline self) {
-	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	CurveTimeline *_self = (CurveTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_curve_timeline_get_frames(spine_curve_timeline self) {
-	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	CurveTimeline *_self = (CurveTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_curve_timeline_get_duration(spine_curve_timeline self) {
-	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	CurveTimeline *_self = (CurveTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_curve_timeline_get_property_ids(spine_curve_timeline self) {
-	Timeline *_self = (Timeline *) (CurveTimeline *) self;
+	CurveTimeline *_self = (CurveTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/curve_timeline1.cpp

@@ -47,59 +47,59 @@ float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float ti
 }
 
 void spine_curve_timeline1_set_linear(spine_curve_timeline1 self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
 	_self->setLinear(frame);
 }
 
 void spine_curve_timeline1_set_stepped(spine_curve_timeline1 self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (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 *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (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) {
-	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self) {
-	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
 								 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 self) {
-	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_curve_timeline1_get_frame_count(spine_curve_timeline1 self) {
-	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_curve_timeline1_get_frames(spine_curve_timeline1 self) {
-	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_curve_timeline1_get_duration(spine_curve_timeline1 self) {
-	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_curve_timeline1_get_property_ids(spine_curve_timeline1 self) {
-	CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
+	CurveTimeline1 *_self = (CurveTimeline1 *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/deform_timeline.cpp

@@ -49,57 +49,57 @@ size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self) {
 
 void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
 								 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (DeformTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_deform_timeline_get_slot_index(spine_deform_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (DeformTimeline *) self;
 	return _self->getSlotIndex();
 }
 
 void spine_deform_timeline_set_slot_index(spine_deform_timeline self, int inValue) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (DeformTimeline *) self;
 	_self->setSlotIndex(inValue);
 }
 
 void spine_deform_timeline_set_linear(spine_deform_timeline self, size_t frame) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (DeformTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_deform_timeline_set_stepped(spine_deform_timeline self, size_t frame) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (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) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (DeformTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_deform_timeline_get_curves(spine_deform_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (DeformTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_deform_timeline_get_frame_entries(spine_deform_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (DeformTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 spine_array_float spine_deform_timeline_get_frames(spine_deform_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (DeformTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_deform_timeline_get_duration(spine_deform_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (DeformTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_deform_timeline_get_property_ids(spine_deform_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	DeformTimeline *_self = (DeformTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/draw_order_timeline.cpp

@@ -34,22 +34,22 @@ void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t
 }
 
 size_t spine_draw_order_timeline_get_frame_entries(spine_draw_order_timeline self) {
-	Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
+	DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 spine_array_float spine_draw_order_timeline_get_frames(spine_draw_order_timeline self) {
-	Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
+	DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_draw_order_timeline_get_duration(spine_draw_order_timeline self) {
-	Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
+	DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_draw_order_timeline_get_property_ids(spine_draw_order_timeline self) {
-	Timeline *_self = (Timeline *) (DrawOrderTimeline *) self;
+	DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/event_timeline.cpp

@@ -38,22 +38,22 @@ void spine_event_timeline_set_frame(spine_event_timeline self, size_t frame, spi
 }
 
 size_t spine_event_timeline_get_frame_entries(spine_event_timeline self) {
-	Timeline *_self = (Timeline *) (EventTimeline *) self;
+	EventTimeline *_self = (EventTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 spine_array_float spine_event_timeline_get_frames(spine_event_timeline self) {
-	Timeline *_self = (Timeline *) (EventTimeline *) self;
+	EventTimeline *_self = (EventTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_event_timeline_get_duration(spine_event_timeline self) {
-	Timeline *_self = (Timeline *) (EventTimeline *) self;
+	EventTimeline *_self = (EventTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_event_timeline_get_property_ids(spine_event_timeline self) {
-	Timeline *_self = (Timeline *) (EventTimeline *) self;
+	EventTimeline *_self = (EventTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/ik_constraint.cpp

@@ -63,42 +63,42 @@ void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent
 }
 
 spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self) {
-	IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self;
+	IkConstraint *_self = (IkConstraint *) self;
 	return (spine_ik_constraint_data) &_self->getData();
 }
 
 spine_ik_constraint_pose spine_ik_constraint_get_pose(spine_ik_constraint self) {
-	IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self;
+	IkConstraint *_self = (IkConstraint *) self;
 	return (spine_ik_constraint_pose) &_self->getPose();
 }
 
 spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(spine_ik_constraint self) {
-	IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self;
+	IkConstraint *_self = (IkConstraint *) self;
 	return (spine_ik_constraint_pose) &_self->getAppliedPose();
 }
 
 void spine_ik_constraint_reset_constrained(spine_ik_constraint self) {
-	IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self;
+	IkConstraint *_self = (IkConstraint *) self;
 	_self->resetConstrained();
 }
 
 void spine_ik_constraint_constrained(spine_ik_constraint self) {
-	IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self;
+	IkConstraint *_self = (IkConstraint *) self;
 	_self->constrained();
 }
 
 bool spine_ik_constraint_is_pose_equal_to_applied(spine_ik_constraint self) {
-	IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self;
+	IkConstraint *_self = (IkConstraint *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_ik_constraint_is_active(spine_ik_constraint self) {
-	IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self;
+	IkConstraint *_self = (IkConstraint *) self;
 	return _self->isActive();
 }
 
 void spine_ik_constraint_set_active(spine_ik_constraint self, bool active) {
-	IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self;
+	IkConstraint *_self = (IkConstraint *) self;
 	_self->setActive(active);
 }
 

spine-c/src/generated/ik_constraint_base.cpp

@@ -8,74 +8,62 @@ void spine_ik_constraint_base_dispose(spine_ik_constraint_base self) {
 }
 
 spine_ik_constraint_data spine_ik_constraint_base_get_data(spine_ik_constraint_base self) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	return (spine_ik_constraint_data) &_self->getData();
 }
 
 spine_ik_constraint_pose spine_ik_constraint_base_get_pose(spine_ik_constraint_base self) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	return (spine_ik_constraint_pose) &_self->getPose();
 }
 
 spine_ik_constraint_pose spine_ik_constraint_base_get_applied_pose(spine_ik_constraint_base self) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	return (spine_ik_constraint_pose) &_self->getAppliedPose();
 }
 
 void spine_ik_constraint_base_reset_constrained(spine_ik_constraint_base self) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	_self->resetConstrained();
 }
 
 void spine_ik_constraint_base_constrained(spine_ik_constraint_base self) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	_self->constrained();
 }
 
 bool spine_ik_constraint_base_is_pose_equal_to_applied(spine_ik_constraint_base self) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_ik_constraint_base_is_active(spine_ik_constraint_base self) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	return _self->isActive();
 }
 
 void spine_ik_constraint_base_set_active(spine_ik_constraint_base self, bool active) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	_self->setActive(active);
 }
 
 spine_rtti spine_ik_constraint_base_get_rtti(spine_ik_constraint_base self) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_ik_constraint_base_sort(spine_ik_constraint_base self, spine_skeleton skeleton) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	_self->sort(*((Skeleton *) skeleton));
 }
 
 bool spine_ik_constraint_base_is_source_active(spine_ik_constraint_base self) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	return _self->isSourceActive();
 }
 
 void spine_ik_constraint_base_update(spine_ik_constraint_base self, spine_skeleton skeleton, spine_physics physics) {
-	ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose>
-		*_self = (ConstraintGeneric<IkConstraint, IkConstraintData, IkConstraintPose> *) (IkConstraintBase *) self;
+	IkConstraintBase *_self = (IkConstraintBase *) self;
 	_self->update(*((Skeleton *) skeleton), (Physics) physics);
 }
 

spine-c/src/generated/ik_constraint_data.cpp

@@ -47,26 +47,22 @@ void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data self, bool un
 }
 
 const char *spine_ik_constraint_data_get_name(spine_ik_constraint_data self) {
-	ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
-		self;
+	IkConstraintData *_self = (IkConstraintData *) self;
 	return _self->getName().buffer();
 }
 
 bool spine_ik_constraint_data_get_skin_required(spine_ik_constraint_data self) {
-	ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
-		self;
+	IkConstraintData *_self = (IkConstraintData *) self;
 	return _self->getSkinRequired();
 }
 
 spine_ik_constraint_pose spine_ik_constraint_data_get_setup_pose(spine_ik_constraint_data self) {
-	ConstraintDataGeneric<IkConstraint, IkConstraintPose> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
-		self;
+	IkConstraintData *_self = (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> *_self = (ConstraintDataGeneric<IkConstraint, IkConstraintPose> *) (IkConstraintData *)
-		self;
+	IkConstraintData *_self = (IkConstraintData *) self;
 	_self->setSkinRequired(skinRequired);
 }
 

spine-c/src/generated/ik_constraint_timeline.cpp

@@ -40,53 +40,53 @@ void spine_ik_constraint_timeline_set_constraint_index(spine_ik_constraint_timel
 }
 
 void spine_ik_constraint_timeline_set_linear(spine_ik_constraint_timeline self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_ik_constraint_timeline_set_stepped(spine_ik_constraint_timeline self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	IkConstraintTimeline *_self = (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 *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	IkConstraintTimeline *_self = (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) {
-	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_ik_constraint_timeline_get_curves(spine_ik_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_ik_constraint_timeline_get_frame_entries(spine_ik_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_ik_constraint_timeline_get_frame_count(spine_ik_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_ik_constraint_timeline_get_frames(spine_ik_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_ik_constraint_timeline_get_duration(spine_ik_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_ik_constraint_timeline_get_property_ids(spine_ik_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/inherit_timeline.cpp

@@ -39,27 +39,27 @@ void spine_inherit_timeline_set_bone_index(spine_inherit_timeline self, int inVa
 }
 
 size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline self) {
-	Timeline *_self = (Timeline *) (InheritTimeline *) self;
+	InheritTimeline *_self = (InheritTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_inherit_timeline_get_frame_count(spine_inherit_timeline self) {
-	Timeline *_self = (Timeline *) (InheritTimeline *) self;
+	InheritTimeline *_self = (InheritTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_inherit_timeline_get_frames(spine_inherit_timeline self) {
-	Timeline *_self = (Timeline *) (InheritTimeline *) self;
+	InheritTimeline *_self = (InheritTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_inherit_timeline_get_duration(spine_inherit_timeline self) {
-	Timeline *_self = (Timeline *) (InheritTimeline *) self;
+	InheritTimeline *_self = (InheritTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_inherit_timeline_get_property_ids(spine_inherit_timeline self) {
-	Timeline *_self = (Timeline *) (InheritTimeline *) self;
+	InheritTimeline *_self = (InheritTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/mesh_attachment.cpp

@@ -24,7 +24,7 @@ void spine_mesh_attachment_compute_world_vertices_1(spine_mesh_attachment self,
 
 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;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, *((Array<float> *) worldVertices), offset, stride);
 }
 
@@ -154,72 +154,72 @@ spine_mesh_attachment spine_mesh_attachment_new_linked_mesh(spine_mesh_attachmen
 }
 
 int spine_mesh_attachment_get_id(spine_mesh_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	return _self->getId();
 }
 
 spine_array_int spine_mesh_attachment_get_bones(spine_mesh_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	return (spine_array_int) &_self->getBones();
 }
 
 void spine_mesh_attachment_set_bones(spine_mesh_attachment self, spine_array_int bones) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->setBones(*((Array<int> *) bones));
 }
 
 spine_array_float spine_mesh_attachment_get_vertices(spine_mesh_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	return (spine_array_float) &_self->getVertices();
 }
 
 void spine_mesh_attachment_set_vertices(spine_mesh_attachment self, spine_array_float vertices) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->setVertices(*((Array<float> *) vertices));
 }
 
 size_t spine_mesh_attachment_get_world_vertices_length(spine_mesh_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	return _self->getWorldVerticesLength();
 }
 
 void spine_mesh_attachment_set_world_vertices_length(spine_mesh_attachment self, size_t inValue) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->setWorldVerticesLength(inValue);
 }
 
 /*@null*/ spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	return (spine_attachment) _self->getTimelineAttachment();
 }
 
 void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, /*@null*/ spine_attachment attachment) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->setTimelineAttachment((Attachment *) attachment);
 }
 
 void spine_mesh_attachment_copy_to(spine_mesh_attachment self, spine_vertex_attachment other) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->copyTo(*((VertexAttachment *) other));
 }
 
 const char *spine_mesh_attachment_get_name(spine_mesh_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	return _self->getName().buffer();
 }
 
 int spine_mesh_attachment_get_ref_count(spine_mesh_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	return _self->getRefCount();
 }
 
 void spine_mesh_attachment_reference(spine_mesh_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->reference();
 }
 
 void spine_mesh_attachment_dereference(spine_mesh_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
+	MeshAttachment *_self = (MeshAttachment *) self;
 	_self->dereference();
 }
 

spine-c/src/generated/path_attachment.cpp

@@ -58,83 +58,83 @@ spine_attachment spine_path_attachment_copy(spine_path_attachment self) {
 
 void spine_path_attachment_compute_world_vertices_1(spine_path_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count,
 													/*@null*/ float *worldVertices, size_t offset, size_t stride) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
 }
 
 void spine_path_attachment_compute_world_vertices_2(spine_path_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 *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, *((Array<float> *) worldVertices), offset, stride);
 }
 
 int spine_path_attachment_get_id(spine_path_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	return _self->getId();
 }
 
 spine_array_int spine_path_attachment_get_bones(spine_path_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	return (spine_array_int) &_self->getBones();
 }
 
 void spine_path_attachment_set_bones(spine_path_attachment self, spine_array_int bones) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	_self->setBones(*((Array<int> *) bones));
 }
 
 spine_array_float spine_path_attachment_get_vertices(spine_path_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	return (spine_array_float) &_self->getVertices();
 }
 
 void spine_path_attachment_set_vertices(spine_path_attachment self, spine_array_float vertices) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	_self->setVertices(*((Array<float> *) vertices));
 }
 
 size_t spine_path_attachment_get_world_vertices_length(spine_path_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	return _self->getWorldVerticesLength();
 }
 
 void spine_path_attachment_set_world_vertices_length(spine_path_attachment self, size_t inValue) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	_self->setWorldVerticesLength(inValue);
 }
 
 /*@null*/ spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	return (spine_attachment) _self->getTimelineAttachment();
 }
 
 void spine_path_attachment_set_timeline_attachment(spine_path_attachment self, /*@null*/ spine_attachment attachment) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	_self->setTimelineAttachment((Attachment *) attachment);
 }
 
 void spine_path_attachment_copy_to(spine_path_attachment self, spine_vertex_attachment other) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	_self->copyTo(*((VertexAttachment *) other));
 }
 
 const char *spine_path_attachment_get_name(spine_path_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	return _self->getName().buffer();
 }
 
 int spine_path_attachment_get_ref_count(spine_path_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	return _self->getRefCount();
 }
 
 void spine_path_attachment_reference(spine_path_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	_self->reference();
 }
 
 void spine_path_attachment_dereference(spine_path_attachment self) {
-	VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
+	PathAttachment *_self = (PathAttachment *) self;
 	_self->dereference();
 }
 

spine-c/src/generated/path_constraint.cpp

@@ -52,42 +52,42 @@ void spine_path_constraint_set_slot(spine_path_constraint self, spine_slot slot)
 }
 
 spine_path_constraint_data spine_path_constraint_get_data(spine_path_constraint self) {
-	PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self;
+	PathConstraint *_self = (PathConstraint *) self;
 	return (spine_path_constraint_data) &_self->getData();
 }
 
 spine_path_constraint_pose spine_path_constraint_get_pose(spine_path_constraint self) {
-	PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self;
+	PathConstraint *_self = (PathConstraint *) self;
 	return (spine_path_constraint_pose) &_self->getPose();
 }
 
 spine_path_constraint_pose spine_path_constraint_get_applied_pose(spine_path_constraint self) {
-	PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self;
+	PathConstraint *_self = (PathConstraint *) self;
 	return (spine_path_constraint_pose) &_self->getAppliedPose();
 }
 
 void spine_path_constraint_reset_constrained(spine_path_constraint self) {
-	PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self;
+	PathConstraint *_self = (PathConstraint *) self;
 	_self->resetConstrained();
 }
 
 void spine_path_constraint_constrained(spine_path_constraint self) {
-	PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self;
+	PathConstraint *_self = (PathConstraint *) self;
 	_self->constrained();
 }
 
 bool spine_path_constraint_is_pose_equal_to_applied(spine_path_constraint self) {
-	PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self;
+	PathConstraint *_self = (PathConstraint *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_path_constraint_is_active(spine_path_constraint self) {
-	PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self;
+	PathConstraint *_self = (PathConstraint *) self;
 	return _self->isActive();
 }
 
 void spine_path_constraint_set_active(spine_path_constraint self, bool active) {
-	PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self;
+	PathConstraint *_self = (PathConstraint *) self;
 	_self->setActive(active);
 }
 

spine-c/src/generated/path_constraint_base.cpp

@@ -8,74 +8,62 @@ void spine_path_constraint_base_dispose(spine_path_constraint_base self) {
 }
 
 spine_path_constraint_data spine_path_constraint_base_get_data(spine_path_constraint_base self) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	return (spine_path_constraint_data) &_self->getData();
 }
 
 spine_path_constraint_pose spine_path_constraint_base_get_pose(spine_path_constraint_base self) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	return (spine_path_constraint_pose) &_self->getPose();
 }
 
 spine_path_constraint_pose spine_path_constraint_base_get_applied_pose(spine_path_constraint_base self) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	return (spine_path_constraint_pose) &_self->getAppliedPose();
 }
 
 void spine_path_constraint_base_reset_constrained(spine_path_constraint_base self) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	_self->resetConstrained();
 }
 
 void spine_path_constraint_base_constrained(spine_path_constraint_base self) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	_self->constrained();
 }
 
 bool spine_path_constraint_base_is_pose_equal_to_applied(spine_path_constraint_base self) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_path_constraint_base_is_active(spine_path_constraint_base self) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	return _self->isActive();
 }
 
 void spine_path_constraint_base_set_active(spine_path_constraint_base self, bool active) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	_self->setActive(active);
 }
 
 spine_rtti spine_path_constraint_base_get_rtti(spine_path_constraint_base self) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_path_constraint_base_sort(spine_path_constraint_base self, spine_skeleton skeleton) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	_self->sort(*((Skeleton *) skeleton));
 }
 
 bool spine_path_constraint_base_is_source_active(spine_path_constraint_base self) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	return _self->isSourceActive();
 }
 
 void spine_path_constraint_base_update(spine_path_constraint_base self, spine_skeleton skeleton, spine_physics physics) {
-	ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose>
-		*_self = (ConstraintGeneric<PathConstraint, PathConstraintData, PathConstraintPose> *) (PathConstraintBase *) self;
+	PathConstraintBase *_self = (PathConstraintBase *) self;
 	_self->update(*((Skeleton *) skeleton), (Physics) physics);
 }
 

spine-c/src/generated/path_constraint_data.cpp

@@ -77,26 +77,22 @@ void spine_path_constraint_data_set_offset_rotation(spine_path_constraint_data s
 }
 
 const char *spine_path_constraint_data_get_name(spine_path_constraint_data self) {
-	ConstraintDataGeneric<PathConstraint, PathConstraintPose>
-		*_self = (ConstraintDataGeneric<PathConstraint, PathConstraintPose> *) (PathConstraintData *) self;
+	PathConstraintData *_self = (PathConstraintData *) self;
 	return _self->getName().buffer();
 }
 
 bool spine_path_constraint_data_get_skin_required(spine_path_constraint_data self) {
-	ConstraintDataGeneric<PathConstraint, PathConstraintPose>
-		*_self = (ConstraintDataGeneric<PathConstraint, PathConstraintPose> *) (PathConstraintData *) self;
+	PathConstraintData *_self = (PathConstraintData *) self;
 	return _self->getSkinRequired();
 }
 
 spine_path_constraint_pose spine_path_constraint_data_get_setup_pose(spine_path_constraint_data self) {
-	ConstraintDataGeneric<PathConstraint, PathConstraintPose>
-		*_self = (ConstraintDataGeneric<PathConstraint, PathConstraintPose> *) (PathConstraintData *) self;
+	PathConstraintData *_self = (PathConstraintData *) self;
 	return (spine_path_constraint_pose) &_self->getSetupPose();
 }
 
 void spine_path_constraint_data_set_skin_required(spine_path_constraint_data self, bool skinRequired) {
-	ConstraintDataGeneric<PathConstraint, PathConstraintPose>
-		*_self = (ConstraintDataGeneric<PathConstraint, PathConstraintPose> *) (PathConstraintData *) self;
+	PathConstraintData *_self = (PathConstraintData *) self;
 	_self->setSkinRequired(skinRequired);
 }
 

spine-c/src/generated/path_constraint_mix_timeline.cpp

@@ -40,54 +40,54 @@ void spine_path_constraint_mix_timeline_set_constraint_index(spine_path_constrai
 }
 
 void spine_path_constraint_mix_timeline_set_linear(spine_path_constraint_mix_timeline self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (PathConstraintMixTimeline *) self;
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_path_constraint_mix_timeline_set_stepped(spine_path_constraint_mix_timeline self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (PathConstraintMixTimeline *) self;
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_path_constraint_mix_timeline_set_bezier(spine_path_constraint_mix_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 *) (PathConstraintMixTimeline *) self;
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_path_constraint_mix_timeline_get_bezier_value(spine_path_constraint_mix_timeline self, float time, size_t frame, size_t valueOffset,
 														  size_t i) {
-	CurveTimeline *_self = (CurveTimeline *) (PathConstraintMixTimeline *) self;
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_path_constraint_mix_timeline_get_curves(spine_path_constraint_mix_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (PathConstraintMixTimeline *) self;
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_path_constraint_mix_timeline_get_frame_entries(spine_path_constraint_mix_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (PathConstraintMixTimeline *) self;
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_path_constraint_mix_timeline_get_frame_count(spine_path_constraint_mix_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (PathConstraintMixTimeline *) self;
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_path_constraint_mix_timeline_get_frames(spine_path_constraint_mix_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (PathConstraintMixTimeline *) self;
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_path_constraint_mix_timeline_get_duration(spine_path_constraint_mix_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (PathConstraintMixTimeline *) self;
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_path_constraint_mix_timeline_get_property_ids(spine_path_constraint_mix_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (PathConstraintMixTimeline *) self;
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/path_constraint_position_timeline.cpp

@@ -25,99 +25,99 @@ void spine_path_constraint_position_timeline_apply(spine_path_constraint_positio
 }
 
 int spine_path_constraint_position_timeline_get_constraint_index(spine_path_constraint_position_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_path_constraint_position_timeline_set_constraint_index(spine_path_constraint_position_timeline self, int inValue) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_path_constraint_position_timeline_set_frame(spine_path_constraint_position_timeline self, size_t frame, float time, float value) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_path_constraint_position_timeline_get_curve_value(spine_path_constraint_position_timeline self, float time) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_path_constraint_position_timeline_get_relative_value(spine_path_constraint_position_timeline self, float time, float alpha,
 																 spine_mix_blend blend, float current, float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_path_constraint_position_timeline_get_absolute_value_1(spine_path_constraint_position_timeline self, float time, float alpha,
 																   spine_mix_blend blend, float current, float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_path_constraint_position_timeline_get_absolute_value_2(spine_path_constraint_position_timeline self, float time, float alpha,
 																   spine_mix_blend blend, float current, float setup, float value) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_path_constraint_position_timeline_get_scale_value(spine_path_constraint_position_timeline self, float time, float alpha,
 															  spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_path_constraint_position_timeline_set_linear(spine_path_constraint_position_timeline self, size_t frame) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_path_constraint_position_timeline_set_stepped(spine_path_constraint_position_timeline self, size_t frame) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_path_constraint_position_timeline_set_bezier(spine_path_constraint_position_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) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_path_constraint_position_timeline_get_bezier_value(spine_path_constraint_position_timeline self, float time, size_t frame,
 															   size_t valueOffset, size_t i) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_path_constraint_position_timeline_get_curves(spine_path_constraint_position_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_path_constraint_position_timeline_get_frame_entries(spine_path_constraint_position_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_path_constraint_position_timeline_get_frame_count(spine_path_constraint_position_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_path_constraint_position_timeline_get_frames(spine_path_constraint_position_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_path_constraint_position_timeline_get_duration(spine_path_constraint_position_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_path_constraint_position_timeline_get_property_ids(spine_path_constraint_position_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintPositionTimeline *) self;
+	PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/path_constraint_spacing_timeline.cpp

@@ -24,99 +24,99 @@ void spine_path_constraint_spacing_timeline_apply(spine_path_constraint_spacing_
 }
 
 int spine_path_constraint_spacing_timeline_get_constraint_index(spine_path_constraint_spacing_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_path_constraint_spacing_timeline_set_constraint_index(spine_path_constraint_spacing_timeline self, int inValue) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_path_constraint_spacing_timeline_set_frame(spine_path_constraint_spacing_timeline self, size_t frame, float time, float value) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_path_constraint_spacing_timeline_get_curve_value(spine_path_constraint_spacing_timeline self, float time) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_path_constraint_spacing_timeline_get_relative_value(spine_path_constraint_spacing_timeline self, float time, float alpha,
 																spine_mix_blend blend, float current, float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_path_constraint_spacing_timeline_get_absolute_value_1(spine_path_constraint_spacing_timeline self, float time, float alpha,
 																  spine_mix_blend blend, float current, float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_path_constraint_spacing_timeline_get_absolute_value_2(spine_path_constraint_spacing_timeline self, float time, float alpha,
 																  spine_mix_blend blend, float current, float setup, float value) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_path_constraint_spacing_timeline_get_scale_value(spine_path_constraint_spacing_timeline self, float time, float alpha,
 															 spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_path_constraint_spacing_timeline_set_linear(spine_path_constraint_spacing_timeline self, size_t frame) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_path_constraint_spacing_timeline_set_stepped(spine_path_constraint_spacing_timeline self, size_t frame) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_path_constraint_spacing_timeline_set_bezier(spine_path_constraint_spacing_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) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_path_constraint_spacing_timeline_get_bezier_value(spine_path_constraint_spacing_timeline self, float time, size_t frame,
 															  size_t valueOffset, size_t i) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_path_constraint_spacing_timeline_get_curves(spine_path_constraint_spacing_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_path_constraint_spacing_timeline_get_frame_entries(spine_path_constraint_spacing_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_path_constraint_spacing_timeline_get_frame_count(spine_path_constraint_spacing_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_path_constraint_spacing_timeline_get_frames(spine_path_constraint_spacing_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_path_constraint_spacing_timeline_get_duration(spine_path_constraint_spacing_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_path_constraint_spacing_timeline_get_property_ids(spine_path_constraint_spacing_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (PathConstraintSpacingTimeline *) self;
+	PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/physics_constraint.cpp

@@ -62,42 +62,42 @@ void spine_physics_constraint_set_bone(spine_physics_constraint self, spine_bone
 }
 
 spine_physics_constraint_data spine_physics_constraint_get_data(spine_physics_constraint self) {
-	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self;
+	PhysicsConstraint *_self = (PhysicsConstraint *) self;
 	return (spine_physics_constraint_data) &_self->getData();
 }
 
 spine_physics_constraint_pose spine_physics_constraint_get_pose(spine_physics_constraint self) {
-	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self;
+	PhysicsConstraint *_self = (PhysicsConstraint *) self;
 	return (spine_physics_constraint_pose) &_self->getPose();
 }
 
 spine_physics_constraint_pose spine_physics_constraint_get_applied_pose(spine_physics_constraint self) {
-	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self;
+	PhysicsConstraint *_self = (PhysicsConstraint *) self;
 	return (spine_physics_constraint_pose) &_self->getAppliedPose();
 }
 
 void spine_physics_constraint_reset_constrained(spine_physics_constraint self) {
-	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self;
+	PhysicsConstraint *_self = (PhysicsConstraint *) self;
 	_self->resetConstrained();
 }
 
 void spine_physics_constraint_constrained(spine_physics_constraint self) {
-	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self;
+	PhysicsConstraint *_self = (PhysicsConstraint *) self;
 	_self->constrained();
 }
 
 bool spine_physics_constraint_is_pose_equal_to_applied(spine_physics_constraint self) {
-	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self;
+	PhysicsConstraint *_self = (PhysicsConstraint *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_physics_constraint_is_active(spine_physics_constraint self) {
-	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self;
+	PhysicsConstraint *_self = (PhysicsConstraint *) self;
 	return _self->isActive();
 }
 
 void spine_physics_constraint_set_active(spine_physics_constraint self, bool active) {
-	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self;
+	PhysicsConstraint *_self = (PhysicsConstraint *) self;
 	_self->setActive(active);
 }
 

spine-c/src/generated/physics_constraint_base.cpp

@@ -8,74 +8,62 @@ void spine_physics_constraint_base_dispose(spine_physics_constraint_base self) {
 }
 
 spine_physics_constraint_data spine_physics_constraint_base_get_data(spine_physics_constraint_base self) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	return (spine_physics_constraint_data) &_self->getData();
 }
 
 spine_physics_constraint_pose spine_physics_constraint_base_get_pose(spine_physics_constraint_base self) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	return (spine_physics_constraint_pose) &_self->getPose();
 }
 
 spine_physics_constraint_pose spine_physics_constraint_base_get_applied_pose(spine_physics_constraint_base self) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	return (spine_physics_constraint_pose) &_self->getAppliedPose();
 }
 
 void spine_physics_constraint_base_reset_constrained(spine_physics_constraint_base self) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	_self->resetConstrained();
 }
 
 void spine_physics_constraint_base_constrained(spine_physics_constraint_base self) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	_self->constrained();
 }
 
 bool spine_physics_constraint_base_is_pose_equal_to_applied(spine_physics_constraint_base self) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_physics_constraint_base_is_active(spine_physics_constraint_base self) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	return _self->isActive();
 }
 
 void spine_physics_constraint_base_set_active(spine_physics_constraint_base self, bool active) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	_self->setActive(active);
 }
 
 spine_rtti spine_physics_constraint_base_get_rtti(spine_physics_constraint_base self) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_physics_constraint_base_sort(spine_physics_constraint_base self, spine_skeleton skeleton) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	_self->sort(*((Skeleton *) skeleton));
 }
 
 bool spine_physics_constraint_base_is_source_active(spine_physics_constraint_base self) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	return _self->isSourceActive();
 }
 
 void spine_physics_constraint_base_update(spine_physics_constraint_base self, spine_skeleton skeleton, spine_physics physics) {
-	ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose>
-		*_self = (ConstraintGeneric<PhysicsConstraint, PhysicsConstraintData, PhysicsConstraintPose> *) (PhysicsConstraintBase *) self;
+	PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self;
 	_self->update(*((Skeleton *) skeleton), (Physics) physics);
 }
 

spine-c/src/generated/physics_constraint_damping_timeline.cpp

@@ -21,104 +21,104 @@ spine_rtti spine_physics_constraint_damping_timeline_get_rtti(spine_physics_cons
 void spine_physics_constraint_damping_timeline_apply(spine_physics_constraint_damping_timeline self, spine_skeleton skeleton, float lastTime,
 													 float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
 													 spine_mix_direction direction, bool appliedPose) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_physics_constraint_damping_timeline_get_constraint_index(spine_physics_constraint_damping_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_physics_constraint_damping_timeline_set_constraint_index(spine_physics_constraint_damping_timeline self, int inValue) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_physics_constraint_damping_timeline_set_frame(spine_physics_constraint_damping_timeline self, size_t frame, float time, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_physics_constraint_damping_timeline_get_curve_value(spine_physics_constraint_damping_timeline self, float time) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_physics_constraint_damping_timeline_get_relative_value(spine_physics_constraint_damping_timeline self, float time, float alpha,
 																   spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_damping_timeline_get_absolute_value_1(spine_physics_constraint_damping_timeline self, float time, float alpha,
 																	 spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_damping_timeline_get_absolute_value_2(spine_physics_constraint_damping_timeline self, float time, float alpha,
 																	 spine_mix_blend blend, float current, float setup, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_physics_constraint_damping_timeline_get_scale_value(spine_physics_constraint_damping_timeline self, float time, float alpha,
 																spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_physics_constraint_damping_timeline_set_linear(spine_physics_constraint_damping_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_physics_constraint_damping_timeline_set_stepped(spine_physics_constraint_damping_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_physics_constraint_damping_timeline_set_bezier(spine_physics_constraint_damping_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) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_physics_constraint_damping_timeline_get_bezier_value(spine_physics_constraint_damping_timeline self, float time, size_t frame,
 																 size_t valueOffset, size_t i) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_physics_constraint_damping_timeline_get_curves(spine_physics_constraint_damping_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_physics_constraint_damping_timeline_get_frame_entries(spine_physics_constraint_damping_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_physics_constraint_damping_timeline_get_frame_count(spine_physics_constraint_damping_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_physics_constraint_damping_timeline_get_frames(spine_physics_constraint_damping_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_physics_constraint_damping_timeline_get_duration(spine_physics_constraint_damping_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_physics_constraint_damping_timeline_get_property_ids(spine_physics_constraint_damping_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
+	PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/physics_constraint_data.cpp

@@ -172,26 +172,22 @@ void spine_physics_constraint_data_set_mix_global(spine_physics_constraint_data
 }
 
 const char *spine_physics_constraint_data_get_name(spine_physics_constraint_data self) {
-	ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose>
-		*_self = (ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose> *) (PhysicsConstraintData *) self;
+	PhysicsConstraintData *_self = (PhysicsConstraintData *) self;
 	return _self->getName().buffer();
 }
 
 bool spine_physics_constraint_data_get_skin_required(spine_physics_constraint_data self) {
-	ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose>
-		*_self = (ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose> *) (PhysicsConstraintData *) self;
+	PhysicsConstraintData *_self = (PhysicsConstraintData *) self;
 	return _self->getSkinRequired();
 }
 
 spine_physics_constraint_pose spine_physics_constraint_data_get_setup_pose(spine_physics_constraint_data self) {
-	ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose>
-		*_self = (ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose> *) (PhysicsConstraintData *) self;
+	PhysicsConstraintData *_self = (PhysicsConstraintData *) self;
 	return (spine_physics_constraint_pose) &_self->getSetupPose();
 }
 
 void spine_physics_constraint_data_set_skin_required(spine_physics_constraint_data self, bool skinRequired) {
-	ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose>
-		*_self = (ConstraintDataGeneric<PhysicsConstraint, PhysicsConstraintPose> *) (PhysicsConstraintData *) self;
+	PhysicsConstraintData *_self = (PhysicsConstraintData *) self;
 	_self->setSkinRequired(skinRequired);
 }
 

spine-c/src/generated/physics_constraint_gravity_timeline.cpp

@@ -21,104 +21,104 @@ spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(spine_physics_cons
 void spine_physics_constraint_gravity_timeline_apply(spine_physics_constraint_gravity_timeline self, spine_skeleton skeleton, float lastTime,
 													 float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
 													 spine_mix_direction direction, bool appliedPose) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_physics_constraint_gravity_timeline_get_constraint_index(spine_physics_constraint_gravity_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_physics_constraint_gravity_timeline_set_constraint_index(spine_physics_constraint_gravity_timeline self, int inValue) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_physics_constraint_gravity_timeline_set_frame(spine_physics_constraint_gravity_timeline self, size_t frame, float time, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_physics_constraint_gravity_timeline_get_curve_value(spine_physics_constraint_gravity_timeline self, float time) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_physics_constraint_gravity_timeline_get_relative_value(spine_physics_constraint_gravity_timeline self, float time, float alpha,
 																   spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_gravity_timeline_get_absolute_value_1(spine_physics_constraint_gravity_timeline self, float time, float alpha,
 																	 spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_gravity_timeline_get_absolute_value_2(spine_physics_constraint_gravity_timeline self, float time, float alpha,
 																	 spine_mix_blend blend, float current, float setup, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_physics_constraint_gravity_timeline_get_scale_value(spine_physics_constraint_gravity_timeline self, float time, float alpha,
 																spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_physics_constraint_gravity_timeline_set_linear(spine_physics_constraint_gravity_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_physics_constraint_gravity_timeline_set_stepped(spine_physics_constraint_gravity_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_physics_constraint_gravity_timeline_set_bezier(spine_physics_constraint_gravity_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) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_physics_constraint_gravity_timeline_get_bezier_value(spine_physics_constraint_gravity_timeline self, float time, size_t frame,
 																 size_t valueOffset, size_t i) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_physics_constraint_gravity_timeline_get_curves(spine_physics_constraint_gravity_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_physics_constraint_gravity_timeline_get_frame_entries(spine_physics_constraint_gravity_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_physics_constraint_gravity_timeline_get_frame_count(spine_physics_constraint_gravity_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_physics_constraint_gravity_timeline_get_frames(spine_physics_constraint_gravity_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_physics_constraint_gravity_timeline_get_duration(spine_physics_constraint_gravity_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_physics_constraint_gravity_timeline_get_property_ids(spine_physics_constraint_gravity_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
+	PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/physics_constraint_inertia_timeline.cpp

@@ -21,104 +21,104 @@ spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(spine_physics_cons
 void spine_physics_constraint_inertia_timeline_apply(spine_physics_constraint_inertia_timeline self, spine_skeleton skeleton, float lastTime,
 													 float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
 													 spine_mix_direction direction, bool appliedPose) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_physics_constraint_inertia_timeline_get_constraint_index(spine_physics_constraint_inertia_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_physics_constraint_inertia_timeline_set_constraint_index(spine_physics_constraint_inertia_timeline self, int inValue) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_physics_constraint_inertia_timeline_set_frame(spine_physics_constraint_inertia_timeline self, size_t frame, float time, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_physics_constraint_inertia_timeline_get_curve_value(spine_physics_constraint_inertia_timeline self, float time) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_physics_constraint_inertia_timeline_get_relative_value(spine_physics_constraint_inertia_timeline self, float time, float alpha,
 																   spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_inertia_timeline_get_absolute_value_1(spine_physics_constraint_inertia_timeline self, float time, float alpha,
 																	 spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_inertia_timeline_get_absolute_value_2(spine_physics_constraint_inertia_timeline self, float time, float alpha,
 																	 spine_mix_blend blend, float current, float setup, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_physics_constraint_inertia_timeline_get_scale_value(spine_physics_constraint_inertia_timeline self, float time, float alpha,
 																spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_physics_constraint_inertia_timeline_set_linear(spine_physics_constraint_inertia_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_physics_constraint_inertia_timeline_set_stepped(spine_physics_constraint_inertia_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_physics_constraint_inertia_timeline_set_bezier(spine_physics_constraint_inertia_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) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_physics_constraint_inertia_timeline_get_bezier_value(spine_physics_constraint_inertia_timeline self, float time, size_t frame,
 																 size_t valueOffset, size_t i) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_physics_constraint_inertia_timeline_get_curves(spine_physics_constraint_inertia_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_physics_constraint_inertia_timeline_get_frame_entries(spine_physics_constraint_inertia_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_physics_constraint_inertia_timeline_get_frame_count(spine_physics_constraint_inertia_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_physics_constraint_inertia_timeline_get_frames(spine_physics_constraint_inertia_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_physics_constraint_inertia_timeline_get_duration(spine_physics_constraint_inertia_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_physics_constraint_inertia_timeline_get_property_ids(spine_physics_constraint_inertia_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
+	PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/physics_constraint_mass_timeline.cpp

@@ -21,104 +21,104 @@ spine_rtti spine_physics_constraint_mass_timeline_get_rtti(spine_physics_constra
 void spine_physics_constraint_mass_timeline_apply(spine_physics_constraint_mass_timeline self, spine_skeleton skeleton, float lastTime, float time,
 												  /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
 												  spine_mix_direction direction, bool appliedPose) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_physics_constraint_mass_timeline_get_constraint_index(spine_physics_constraint_mass_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_physics_constraint_mass_timeline_set_constraint_index(spine_physics_constraint_mass_timeline self, int inValue) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_physics_constraint_mass_timeline_set_frame(spine_physics_constraint_mass_timeline self, size_t frame, float time, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_physics_constraint_mass_timeline_get_curve_value(spine_physics_constraint_mass_timeline self, float time) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_physics_constraint_mass_timeline_get_relative_value(spine_physics_constraint_mass_timeline self, float time, float alpha,
 																spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_mass_timeline_get_absolute_value_1(spine_physics_constraint_mass_timeline self, float time, float alpha,
 																  spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_mass_timeline_get_absolute_value_2(spine_physics_constraint_mass_timeline self, float time, float alpha,
 																  spine_mix_blend blend, float current, float setup, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_physics_constraint_mass_timeline_get_scale_value(spine_physics_constraint_mass_timeline self, float time, float alpha,
 															 spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_physics_constraint_mass_timeline_set_linear(spine_physics_constraint_mass_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_physics_constraint_mass_timeline_set_stepped(spine_physics_constraint_mass_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_physics_constraint_mass_timeline_set_bezier(spine_physics_constraint_mass_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) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_physics_constraint_mass_timeline_get_bezier_value(spine_physics_constraint_mass_timeline self, float time, size_t frame,
 															  size_t valueOffset, size_t i) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_physics_constraint_mass_timeline_get_curves(spine_physics_constraint_mass_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_physics_constraint_mass_timeline_get_frame_entries(spine_physics_constraint_mass_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_physics_constraint_mass_timeline_get_frame_count(spine_physics_constraint_mass_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_physics_constraint_mass_timeline_get_frames(spine_physics_constraint_mass_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_physics_constraint_mass_timeline_get_duration(spine_physics_constraint_mass_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_physics_constraint_mass_timeline_get_property_ids(spine_physics_constraint_mass_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
+	PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/physics_constraint_mix_timeline.cpp

@@ -21,104 +21,104 @@ spine_rtti spine_physics_constraint_mix_timeline_get_rtti(spine_physics_constrai
 void spine_physics_constraint_mix_timeline_apply(spine_physics_constraint_mix_timeline self, spine_skeleton skeleton, float lastTime, float time,
 												 /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
 												 spine_mix_direction direction, bool appliedPose) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_physics_constraint_mix_timeline_get_constraint_index(spine_physics_constraint_mix_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_physics_constraint_mix_timeline_set_constraint_index(spine_physics_constraint_mix_timeline self, int inValue) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_physics_constraint_mix_timeline_set_frame(spine_physics_constraint_mix_timeline self, size_t frame, float time, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_physics_constraint_mix_timeline_get_curve_value(spine_physics_constraint_mix_timeline self, float time) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_physics_constraint_mix_timeline_get_relative_value(spine_physics_constraint_mix_timeline self, float time, float alpha,
 															   spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_mix_timeline_get_absolute_value_1(spine_physics_constraint_mix_timeline self, float time, float alpha,
 																 spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_mix_timeline_get_absolute_value_2(spine_physics_constraint_mix_timeline self, float time, float alpha,
 																 spine_mix_blend blend, float current, float setup, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_physics_constraint_mix_timeline_get_scale_value(spine_physics_constraint_mix_timeline self, float time, float alpha,
 															spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_physics_constraint_mix_timeline_set_linear(spine_physics_constraint_mix_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_physics_constraint_mix_timeline_set_stepped(spine_physics_constraint_mix_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_physics_constraint_mix_timeline_set_bezier(spine_physics_constraint_mix_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) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_physics_constraint_mix_timeline_get_bezier_value(spine_physics_constraint_mix_timeline self, float time, size_t frame, size_t valueOffset,
 															 size_t i) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_physics_constraint_mix_timeline_get_curves(spine_physics_constraint_mix_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_physics_constraint_mix_timeline_get_frame_entries(spine_physics_constraint_mix_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_physics_constraint_mix_timeline_get_frame_count(spine_physics_constraint_mix_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_physics_constraint_mix_timeline_get_frames(spine_physics_constraint_mix_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_physics_constraint_mix_timeline_get_duration(spine_physics_constraint_mix_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_physics_constraint_mix_timeline_get_property_ids(spine_physics_constraint_mix_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMixTimeline *) self;
+	PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/physics_constraint_reset_timeline.cpp

@@ -44,22 +44,22 @@ void spine_physics_constraint_reset_timeline_set_frame(spine_physics_constraint_
 }
 
 size_t spine_physics_constraint_reset_timeline_get_frame_entries(spine_physics_constraint_reset_timeline self) {
-	Timeline *_self = (Timeline *) (PhysicsConstraintResetTimeline *) self;
+	PhysicsConstraintResetTimeline *_self = (PhysicsConstraintResetTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 spine_array_float spine_physics_constraint_reset_timeline_get_frames(spine_physics_constraint_reset_timeline self) {
-	Timeline *_self = (Timeline *) (PhysicsConstraintResetTimeline *) self;
+	PhysicsConstraintResetTimeline *_self = (PhysicsConstraintResetTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_physics_constraint_reset_timeline_get_duration(spine_physics_constraint_reset_timeline self) {
-	Timeline *_self = (Timeline *) (PhysicsConstraintResetTimeline *) self;
+	PhysicsConstraintResetTimeline *_self = (PhysicsConstraintResetTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_physics_constraint_reset_timeline_get_property_ids(spine_physics_constraint_reset_timeline self) {
-	Timeline *_self = (Timeline *) (PhysicsConstraintResetTimeline *) self;
+	PhysicsConstraintResetTimeline *_self = (PhysicsConstraintResetTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/physics_constraint_strength_timeline.cpp

@@ -21,104 +21,104 @@ spine_rtti spine_physics_constraint_strength_timeline_get_rtti(spine_physics_con
 void spine_physics_constraint_strength_timeline_apply(spine_physics_constraint_strength_timeline self, spine_skeleton skeleton, float lastTime,
 													  float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
 													  spine_mix_direction direction, bool appliedPose) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_physics_constraint_strength_timeline_get_constraint_index(spine_physics_constraint_strength_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_physics_constraint_strength_timeline_set_constraint_index(spine_physics_constraint_strength_timeline self, int inValue) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_physics_constraint_strength_timeline_set_frame(spine_physics_constraint_strength_timeline self, size_t frame, float time, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_physics_constraint_strength_timeline_get_curve_value(spine_physics_constraint_strength_timeline self, float time) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_physics_constraint_strength_timeline_get_relative_value(spine_physics_constraint_strength_timeline self, float time, float alpha,
 																	spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_strength_timeline_get_absolute_value_1(spine_physics_constraint_strength_timeline self, float time, float alpha,
 																	  spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_strength_timeline_get_absolute_value_2(spine_physics_constraint_strength_timeline self, float time, float alpha,
 																	  spine_mix_blend blend, float current, float setup, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_physics_constraint_strength_timeline_get_scale_value(spine_physics_constraint_strength_timeline self, float time, float alpha,
 																 spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_physics_constraint_strength_timeline_set_linear(spine_physics_constraint_strength_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_physics_constraint_strength_timeline_set_stepped(spine_physics_constraint_strength_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_physics_constraint_strength_timeline_set_bezier(spine_physics_constraint_strength_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) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_physics_constraint_strength_timeline_get_bezier_value(spine_physics_constraint_strength_timeline self, float time, size_t frame,
 																  size_t valueOffset, size_t i) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_physics_constraint_strength_timeline_get_curves(spine_physics_constraint_strength_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_physics_constraint_strength_timeline_get_frame_entries(spine_physics_constraint_strength_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_physics_constraint_strength_timeline_get_frame_count(spine_physics_constraint_strength_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_physics_constraint_strength_timeline_get_frames(spine_physics_constraint_strength_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_physics_constraint_strength_timeline_get_duration(spine_physics_constraint_strength_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_physics_constraint_strength_timeline_get_property_ids(spine_physics_constraint_strength_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintStrengthTimeline *) self;
+	PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/physics_constraint_timeline.cpp

@@ -30,88 +30,88 @@ void spine_physics_constraint_timeline_set_constraint_index(spine_physics_constr
 }
 
 void spine_physics_constraint_timeline_set_frame(spine_physics_constraint_timeline self, size_t frame, float time, float value) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_physics_constraint_timeline_get_curve_value(spine_physics_constraint_timeline self, float time) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_physics_constraint_timeline_get_relative_value(spine_physics_constraint_timeline self, float time, float alpha, spine_mix_blend blend,
 														   float current, float setup) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_timeline_get_absolute_value_1(spine_physics_constraint_timeline self, float time, float alpha, spine_mix_blend blend,
 															 float current, float setup) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_timeline_get_absolute_value_2(spine_physics_constraint_timeline self, float time, float alpha, spine_mix_blend blend,
 															 float current, float setup, float value) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_physics_constraint_timeline_get_scale_value(spine_physics_constraint_timeline self, float time, float alpha, spine_mix_blend blend,
 														spine_mix_direction direction, float current, float setup) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_physics_constraint_timeline_set_linear(spine_physics_constraint_timeline self, size_t frame) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_physics_constraint_timeline_set_stepped(spine_physics_constraint_timeline self, size_t frame) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_physics_constraint_timeline_set_bezier(spine_physics_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) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_physics_constraint_timeline_get_bezier_value(spine_physics_constraint_timeline self, float time, size_t frame, size_t valueOffset,
 														 size_t i) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_physics_constraint_timeline_get_curves(spine_physics_constraint_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_physics_constraint_timeline_get_frame_entries(spine_physics_constraint_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_physics_constraint_timeline_get_frame_count(spine_physics_constraint_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_physics_constraint_timeline_get_frames(spine_physics_constraint_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_physics_constraint_timeline_get_duration(spine_physics_constraint_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_physics_constraint_timeline_get_property_ids(spine_physics_constraint_timeline self) {
-	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/physics_constraint_wind_timeline.cpp

@@ -21,104 +21,104 @@ spine_rtti spine_physics_constraint_wind_timeline_get_rtti(spine_physics_constra
 void spine_physics_constraint_wind_timeline_apply(spine_physics_constraint_wind_timeline self, spine_skeleton skeleton, float lastTime, float time,
 												  /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
 												  spine_mix_direction direction, bool appliedPose) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_physics_constraint_wind_timeline_get_constraint_index(spine_physics_constraint_wind_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_physics_constraint_wind_timeline_set_constraint_index(spine_physics_constraint_wind_timeline self, int inValue) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_physics_constraint_wind_timeline_set_frame(spine_physics_constraint_wind_timeline self, size_t frame, float time, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_physics_constraint_wind_timeline_get_curve_value(spine_physics_constraint_wind_timeline self, float time) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_physics_constraint_wind_timeline_get_relative_value(spine_physics_constraint_wind_timeline self, float time, float alpha,
 																spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_wind_timeline_get_absolute_value_1(spine_physics_constraint_wind_timeline self, float time, float alpha,
 																  spine_mix_blend blend, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_physics_constraint_wind_timeline_get_absolute_value_2(spine_physics_constraint_wind_timeline self, float time, float alpha,
 																  spine_mix_blend blend, float current, float setup, float value) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_physics_constraint_wind_timeline_get_scale_value(spine_physics_constraint_wind_timeline self, float time, float alpha,
 															 spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_physics_constraint_wind_timeline_set_linear(spine_physics_constraint_wind_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_physics_constraint_wind_timeline_set_stepped(spine_physics_constraint_wind_timeline self, size_t frame) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_physics_constraint_wind_timeline_set_bezier(spine_physics_constraint_wind_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) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_physics_constraint_wind_timeline_get_bezier_value(spine_physics_constraint_wind_timeline self, float time, size_t frame,
 															  size_t valueOffset, size_t i) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_physics_constraint_wind_timeline_get_curves(spine_physics_constraint_wind_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_physics_constraint_wind_timeline_get_frame_entries(spine_physics_constraint_wind_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_physics_constraint_wind_timeline_get_frame_count(spine_physics_constraint_wind_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_physics_constraint_wind_timeline_get_frames(spine_physics_constraint_wind_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_physics_constraint_wind_timeline_get_duration(spine_physics_constraint_wind_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_physics_constraint_wind_timeline_get_property_ids(spine_physics_constraint_wind_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintWindTimeline *) self;
+	PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/point_attachment.cpp

@@ -67,22 +67,22 @@ spine_attachment spine_point_attachment_copy(spine_point_attachment self) {
 }
 
 const char *spine_point_attachment_get_name(spine_point_attachment self) {
-	Attachment *_self = (Attachment *) (PointAttachment *) self;
+	PointAttachment *_self = (PointAttachment *) self;
 	return _self->getName().buffer();
 }
 
 int spine_point_attachment_get_ref_count(spine_point_attachment self) {
-	Attachment *_self = (Attachment *) (PointAttachment *) self;
+	PointAttachment *_self = (PointAttachment *) self;
 	return _self->getRefCount();
 }
 
 void spine_point_attachment_reference(spine_point_attachment self) {
-	Attachment *_self = (Attachment *) (PointAttachment *) self;
+	PointAttachment *_self = (PointAttachment *) self;
 	_self->reference();
 }
 
 void spine_point_attachment_dereference(spine_point_attachment self) {
-	Attachment *_self = (Attachment *) (PointAttachment *) self;
+	PointAttachment *_self = (PointAttachment *) self;
 	_self->dereference();
 }
 

spine-c/src/generated/region_attachment.cpp

@@ -154,22 +154,22 @@ spine_attachment spine_region_attachment_copy(spine_region_attachment self) {
 }
 
 const char *spine_region_attachment_get_name(spine_region_attachment self) {
-	Attachment *_self = (Attachment *) (RegionAttachment *) self;
+	RegionAttachment *_self = (RegionAttachment *) self;
 	return _self->getName().buffer();
 }
 
 int spine_region_attachment_get_ref_count(spine_region_attachment self) {
-	Attachment *_self = (Attachment *) (RegionAttachment *) self;
+	RegionAttachment *_self = (RegionAttachment *) self;
 	return _self->getRefCount();
 }
 
 void spine_region_attachment_reference(spine_region_attachment self) {
-	Attachment *_self = (Attachment *) (RegionAttachment *) self;
+	RegionAttachment *_self = (RegionAttachment *) self;
 	_self->reference();
 }
 
 void spine_region_attachment_dereference(spine_region_attachment self) {
-	Attachment *_self = (Attachment *) (RegionAttachment *) self;
+	RegionAttachment *_self = (RegionAttachment *) self;
 	_self->dereference();
 }
 

spine-c/src/generated/rgb2_timeline.cpp

@@ -23,68 +23,68 @@ void spine_rgb2_timeline_set_frame(spine_rgb2_timeline self, int frame, float ti
 
 void spine_rgb2_timeline_apply(spine_rgb2_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
 							   float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_rgb2_timeline_get_slot_index(spine_rgb2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	return _self->getSlotIndex();
 }
 
 void spine_rgb2_timeline_set_slot_index(spine_rgb2_timeline self, int inValue) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	_self->setSlotIndex(inValue);
 }
 
 void spine_rgb2_timeline_set_linear(spine_rgb2_timeline self, size_t frame) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_rgb2_timeline_set_stepped(spine_rgb2_timeline self, size_t frame) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_rgb2_timeline_set_bezier(spine_rgb2_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) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_rgb2_timeline_get_bezier_value(spine_rgb2_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_rgb2_timeline_get_curves(spine_rgb2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_rgb2_timeline_get_frame_entries(spine_rgb2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_rgb2_timeline_get_frame_count(spine_rgb2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_rgb2_timeline_get_frames(spine_rgb2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_rgb2_timeline_get_duration(spine_rgb2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_rgb2_timeline_get_property_ids(spine_rgb2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	RGB2Timeline *_self = (RGB2Timeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/rgb_timeline.cpp

@@ -23,68 +23,68 @@ void spine_rgb_timeline_set_frame(spine_rgb_timeline self, int frame, float time
 
 void spine_rgb_timeline_apply(spine_rgb_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
 							  float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_rgb_timeline_get_slot_index(spine_rgb_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	return _self->getSlotIndex();
 }
 
 void spine_rgb_timeline_set_slot_index(spine_rgb_timeline self, int inValue) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	_self->setSlotIndex(inValue);
 }
 
 void spine_rgb_timeline_set_linear(spine_rgb_timeline self, size_t frame) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_rgb_timeline_set_stepped(spine_rgb_timeline self, size_t frame) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_rgb_timeline_set_bezier(spine_rgb_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) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_rgb_timeline_get_bezier_value(spine_rgb_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_rgb_timeline_get_curves(spine_rgb_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_rgb_timeline_get_frame_entries(spine_rgb_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_rgb_timeline_get_frame_count(spine_rgb_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_rgb_timeline_get_frames(spine_rgb_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_rgb_timeline_get_duration(spine_rgb_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_rgb_timeline_get_property_ids(spine_rgb_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	RGBTimeline *_self = (RGBTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/rgba2_timeline.cpp

@@ -24,68 +24,68 @@ void spine_rgba2_timeline_set_frame(spine_rgba2_timeline self, int frame, float
 
 void spine_rgba2_timeline_apply(spine_rgba2_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
 								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_rgba2_timeline_get_slot_index(spine_rgba2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	return _self->getSlotIndex();
 }
 
 void spine_rgba2_timeline_set_slot_index(spine_rgba2_timeline self, int inValue) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	_self->setSlotIndex(inValue);
 }
 
 void spine_rgba2_timeline_set_linear(spine_rgba2_timeline self, size_t frame) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_rgba2_timeline_set_stepped(spine_rgba2_timeline self, size_t frame) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_rgba2_timeline_set_bezier(spine_rgba2_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) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_rgba2_timeline_get_bezier_value(spine_rgba2_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_rgba2_timeline_get_curves(spine_rgba2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_rgba2_timeline_get_frame_entries(spine_rgba2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_rgba2_timeline_get_frame_count(spine_rgba2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_rgba2_timeline_get_frames(spine_rgba2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_rgba2_timeline_get_duration(spine_rgba2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_rgba2_timeline_get_property_ids(spine_rgba2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	RGBA2Timeline *_self = (RGBA2Timeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/rgba_timeline.cpp

@@ -23,68 +23,68 @@ void spine_rgba_timeline_set_frame(spine_rgba_timeline self, int frame, float ti
 
 void spine_rgba_timeline_apply(spine_rgba_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
 							   float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_rgba_timeline_get_slot_index(spine_rgba_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	return _self->getSlotIndex();
 }
 
 void spine_rgba_timeline_set_slot_index(spine_rgba_timeline self, int inValue) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	_self->setSlotIndex(inValue);
 }
 
 void spine_rgba_timeline_set_linear(spine_rgba_timeline self, size_t frame) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_rgba_timeline_set_stepped(spine_rgba_timeline self, size_t frame) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_rgba_timeline_set_bezier(spine_rgba_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) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_rgba_timeline_get_bezier_value(spine_rgba_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_rgba_timeline_get_curves(spine_rgba_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_rgba_timeline_get_frame_entries(spine_rgba_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_rgba_timeline_get_frame_count(spine_rgba_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_rgba_timeline_get_frames(spine_rgba_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_rgba_timeline_get_duration(spine_rgba_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_rgba_timeline_get_property_ids(spine_rgba_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	RGBATimeline *_self = (RGBATimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/rotate_timeline.cpp

@@ -18,102 +18,102 @@ spine_rtti spine_rotate_timeline_get_rtti(spine_rotate_timeline self) {
 
 void spine_rotate_timeline_apply(spine_rotate_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
 								 float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_rotate_timeline_get_bone_index(spine_rotate_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return _self->getBoneIndex();
 }
 
 void spine_rotate_timeline_set_bone_index(spine_rotate_timeline self, int inValue) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	_self->setBoneIndex(inValue);
 }
 
 void spine_rotate_timeline_set_frame(spine_rotate_timeline self, size_t frame, float time, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_rotate_timeline_get_curve_value(spine_rotate_timeline self, float time) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_rotate_timeline_get_relative_value(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 											   float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_rotate_timeline_get_absolute_value_1(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												 float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_rotate_timeline_get_absolute_value_2(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												 float setup, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_rotate_timeline_get_scale_value(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											float current, float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_rotate_timeline_set_linear(spine_rotate_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_rotate_timeline_set_stepped(spine_rotate_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_rotate_timeline_set_bezier(spine_rotate_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) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_rotate_timeline_get_bezier_value(spine_rotate_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_rotate_timeline_get_curves(spine_rotate_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_rotate_timeline_get_frame_entries(spine_rotate_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_rotate_timeline_get_frame_count(spine_rotate_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_rotate_timeline_get_frames(spine_rotate_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_rotate_timeline_get_duration(spine_rotate_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_rotate_timeline_get_property_ids(spine_rotate_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	RotateTimeline *_self = (RotateTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/scale_timeline.cpp

@@ -18,73 +18,73 @@ spine_rtti spine_scale_timeline_get_rtti(spine_scale_timeline self) {
 
 void spine_scale_timeline_apply(spine_scale_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
 								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_scale_timeline_get_bone_index(spine_scale_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	return _self->getBoneIndex();
 }
 
 void spine_scale_timeline_set_bone_index(spine_scale_timeline self, int inValue) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	_self->setBoneIndex(inValue);
 }
 
 void spine_scale_timeline_set_frame(spine_scale_timeline self, size_t frame, float time, float value1, float value2) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	_self->setFrame(frame, time, value1, value2);
 }
 
 void spine_scale_timeline_set_linear(spine_scale_timeline self, size_t frame) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_scale_timeline_set_stepped(spine_scale_timeline self, size_t frame) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_scale_timeline_set_bezier(spine_scale_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) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_scale_timeline_get_bezier_value(spine_scale_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_scale_timeline_get_curves(spine_scale_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_scale_timeline_get_frame_entries(spine_scale_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_scale_timeline_get_frame_count(spine_scale_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_scale_timeline_get_frames(spine_scale_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_scale_timeline_get_duration(spine_scale_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_scale_timeline_get_property_ids(spine_scale_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
+	ScaleTimeline *_self = (ScaleTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/scale_x_timeline.cpp

@@ -19,102 +19,102 @@ spine_rtti spine_scale_x_timeline_get_rtti(spine_scale_x_timeline self) {
 void spine_scale_x_timeline_apply(spine_scale_x_timeline self, spine_skeleton skeleton, float lastTime, float time,
 								  /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 								  bool appliedPose) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_scale_x_timeline_get_bone_index(spine_scale_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return _self->getBoneIndex();
 }
 
 void spine_scale_x_timeline_set_bone_index(spine_scale_x_timeline self, int inValue) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	_self->setBoneIndex(inValue);
 }
 
 void spine_scale_x_timeline_set_frame(spine_scale_x_timeline self, size_t frame, float time, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_scale_x_timeline_get_curve_value(spine_scale_x_timeline self, float time) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_scale_x_timeline_get_relative_value(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_scale_x_timeline_get_absolute_value_1(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												  float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_scale_x_timeline_get_absolute_value_2(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												  float setup, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_scale_x_timeline_get_scale_value(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend,
 											 spine_mix_direction direction, float current, float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_scale_x_timeline_set_linear(spine_scale_x_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_scale_x_timeline_set_stepped(spine_scale_x_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_scale_x_timeline_set_bezier(spine_scale_x_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) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_scale_x_timeline_get_bezier_value(spine_scale_x_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_scale_x_timeline_get_curves(spine_scale_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_scale_x_timeline_get_frame_entries(spine_scale_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_scale_x_timeline_get_frame_count(spine_scale_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_scale_x_timeline_get_frames(spine_scale_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_scale_x_timeline_get_duration(spine_scale_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_scale_x_timeline_get_property_ids(spine_scale_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleXTimeline *) self;
+	ScaleXTimeline *_self = (ScaleXTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/scale_y_timeline.cpp

@@ -19,102 +19,102 @@ spine_rtti spine_scale_y_timeline_get_rtti(spine_scale_y_timeline self) {
 void spine_scale_y_timeline_apply(spine_scale_y_timeline self, spine_skeleton skeleton, float lastTime, float time,
 								  /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 								  bool appliedPose) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_scale_y_timeline_get_bone_index(spine_scale_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return _self->getBoneIndex();
 }
 
 void spine_scale_y_timeline_set_bone_index(spine_scale_y_timeline self, int inValue) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	_self->setBoneIndex(inValue);
 }
 
 void spine_scale_y_timeline_set_frame(spine_scale_y_timeline self, size_t frame, float time, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_scale_y_timeline_get_curve_value(spine_scale_y_timeline self, float time) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_scale_y_timeline_get_relative_value(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_scale_y_timeline_get_absolute_value_1(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												  float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_scale_y_timeline_get_absolute_value_2(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												  float setup, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_scale_y_timeline_get_scale_value(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend,
 											 spine_mix_direction direction, float current, float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_scale_y_timeline_set_linear(spine_scale_y_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_scale_y_timeline_set_stepped(spine_scale_y_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_scale_y_timeline_set_bezier(spine_scale_y_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) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_scale_y_timeline_get_bezier_value(spine_scale_y_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_scale_y_timeline_get_curves(spine_scale_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_scale_y_timeline_get_frame_entries(spine_scale_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_scale_y_timeline_get_frame_count(spine_scale_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_scale_y_timeline_get_frames(spine_scale_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_scale_y_timeline_get_duration(spine_scale_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_scale_y_timeline_get_property_ids(spine_scale_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ScaleYTimeline *) self;
+	ScaleYTimeline *_self = (ScaleYTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/sequence_timeline.cpp

@@ -44,27 +44,27 @@ void spine_sequence_timeline_set_slot_index(spine_sequence_timeline self, int in
 }
 
 size_t spine_sequence_timeline_get_frame_entries(spine_sequence_timeline self) {
-	Timeline *_self = (Timeline *) (SequenceTimeline *) self;
+	SequenceTimeline *_self = (SequenceTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_sequence_timeline_get_frame_count(spine_sequence_timeline self) {
-	Timeline *_self = (Timeline *) (SequenceTimeline *) self;
+	SequenceTimeline *_self = (SequenceTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_sequence_timeline_get_frames(spine_sequence_timeline self) {
-	Timeline *_self = (Timeline *) (SequenceTimeline *) self;
+	SequenceTimeline *_self = (SequenceTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_sequence_timeline_get_duration(spine_sequence_timeline self) {
-	Timeline *_self = (Timeline *) (SequenceTimeline *) self;
+	SequenceTimeline *_self = (SequenceTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_sequence_timeline_get_property_ids(spine_sequence_timeline self) {
-	Timeline *_self = (Timeline *) (SequenceTimeline *) self;
+	SequenceTimeline *_self = (SequenceTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/shear_timeline.cpp

@@ -18,73 +18,73 @@ spine_rtti spine_shear_timeline_get_rtti(spine_shear_timeline self) {
 
 void spine_shear_timeline_apply(spine_shear_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
 								float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_shear_timeline_get_bone_index(spine_shear_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	return _self->getBoneIndex();
 }
 
 void spine_shear_timeline_set_bone_index(spine_shear_timeline self, int inValue) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	_self->setBoneIndex(inValue);
 }
 
 void spine_shear_timeline_set_frame(spine_shear_timeline self, size_t frame, float time, float value1, float value2) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	_self->setFrame(frame, time, value1, value2);
 }
 
 void spine_shear_timeline_set_linear(spine_shear_timeline self, size_t frame) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_shear_timeline_set_stepped(spine_shear_timeline self, size_t frame) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_shear_timeline_set_bezier(spine_shear_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) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_shear_timeline_get_bezier_value(spine_shear_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_shear_timeline_get_curves(spine_shear_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_shear_timeline_get_frame_entries(spine_shear_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_shear_timeline_get_frame_count(spine_shear_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_shear_timeline_get_frames(spine_shear_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_shear_timeline_get_duration(spine_shear_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_shear_timeline_get_property_ids(spine_shear_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
+	ShearTimeline *_self = (ShearTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/shear_x_timeline.cpp

@@ -19,102 +19,102 @@ spine_rtti spine_shear_x_timeline_get_rtti(spine_shear_x_timeline self) {
 void spine_shear_x_timeline_apply(spine_shear_x_timeline self, spine_skeleton skeleton, float lastTime, float time,
 								  /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 								  bool appliedPose) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_shear_x_timeline_get_bone_index(spine_shear_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return _self->getBoneIndex();
 }
 
 void spine_shear_x_timeline_set_bone_index(spine_shear_x_timeline self, int inValue) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	_self->setBoneIndex(inValue);
 }
 
 void spine_shear_x_timeline_set_frame(spine_shear_x_timeline self, size_t frame, float time, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_shear_x_timeline_get_curve_value(spine_shear_x_timeline self, float time) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_shear_x_timeline_get_relative_value(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_shear_x_timeline_get_absolute_value_1(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												  float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_shear_x_timeline_get_absolute_value_2(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												  float setup, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_shear_x_timeline_get_scale_value(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend,
 											 spine_mix_direction direction, float current, float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_shear_x_timeline_set_linear(spine_shear_x_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_shear_x_timeline_set_stepped(spine_shear_x_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_shear_x_timeline_set_bezier(spine_shear_x_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) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_shear_x_timeline_get_bezier_value(spine_shear_x_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_shear_x_timeline_get_curves(spine_shear_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_shear_x_timeline_get_frame_entries(spine_shear_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_shear_x_timeline_get_frame_count(spine_shear_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_shear_x_timeline_get_frames(spine_shear_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_shear_x_timeline_get_duration(spine_shear_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_shear_x_timeline_get_property_ids(spine_shear_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearXTimeline *) self;
+	ShearXTimeline *_self = (ShearXTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/shear_y_timeline.cpp

@@ -19,102 +19,102 @@ spine_rtti spine_shear_y_timeline_get_rtti(spine_shear_y_timeline self) {
 void spine_shear_y_timeline_apply(spine_shear_y_timeline self, spine_skeleton skeleton, float lastTime, float time,
 								  /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 								  bool appliedPose) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_shear_y_timeline_get_bone_index(spine_shear_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return _self->getBoneIndex();
 }
 
 void spine_shear_y_timeline_set_bone_index(spine_shear_y_timeline self, int inValue) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	_self->setBoneIndex(inValue);
 }
 
 void spine_shear_y_timeline_set_frame(spine_shear_y_timeline self, size_t frame, float time, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_shear_y_timeline_get_curve_value(spine_shear_y_timeline self, float time) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_shear_y_timeline_get_relative_value(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_shear_y_timeline_get_absolute_value_1(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												  float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_shear_y_timeline_get_absolute_value_2(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												  float setup, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_shear_y_timeline_get_scale_value(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend,
 											 spine_mix_direction direction, float current, float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_shear_y_timeline_set_linear(spine_shear_y_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_shear_y_timeline_set_stepped(spine_shear_y_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_shear_y_timeline_set_bezier(spine_shear_y_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) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_shear_y_timeline_get_bezier_value(spine_shear_y_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_shear_y_timeline_get_curves(spine_shear_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_shear_y_timeline_get_frame_entries(spine_shear_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_shear_y_timeline_get_frame_count(spine_shear_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_shear_y_timeline_get_frames(spine_shear_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_shear_y_timeline_get_duration(spine_shear_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_shear_y_timeline_get_property_ids(spine_shear_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (ShearYTimeline *) self;
+	ShearYTimeline *_self = (ShearYTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/slider.cpp

@@ -47,42 +47,42 @@ void spine_slider_set_bone(spine_slider self, spine_bone bone) {
 }
 
 spine_slider_data spine_slider_get_data(spine_slider self) {
-	SliderBase *_self = (SliderBase *) (Slider *) self;
+	Slider *_self = (Slider *) self;
 	return (spine_slider_data) &_self->getData();
 }
 
 spine_slider_pose spine_slider_get_pose(spine_slider self) {
-	SliderBase *_self = (SliderBase *) (Slider *) self;
+	Slider *_self = (Slider *) self;
 	return (spine_slider_pose) &_self->getPose();
 }
 
 spine_slider_pose spine_slider_get_applied_pose(spine_slider self) {
-	SliderBase *_self = (SliderBase *) (Slider *) self;
+	Slider *_self = (Slider *) self;
 	return (spine_slider_pose) &_self->getAppliedPose();
 }
 
 void spine_slider_reset_constrained(spine_slider self) {
-	SliderBase *_self = (SliderBase *) (Slider *) self;
+	Slider *_self = (Slider *) self;
 	_self->resetConstrained();
 }
 
 void spine_slider_constrained(spine_slider self) {
-	SliderBase *_self = (SliderBase *) (Slider *) self;
+	Slider *_self = (Slider *) self;
 	_self->constrained();
 }
 
 bool spine_slider_is_pose_equal_to_applied(spine_slider self) {
-	SliderBase *_self = (SliderBase *) (Slider *) self;
+	Slider *_self = (Slider *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_slider_is_active(spine_slider self) {
-	SliderBase *_self = (SliderBase *) (Slider *) self;
+	Slider *_self = (Slider *) self;
 	return _self->isActive();
 }
 
 void spine_slider_set_active(spine_slider self, bool active) {
-	SliderBase *_self = (SliderBase *) (Slider *) self;
+	Slider *_self = (Slider *) self;
 	_self->setActive(active);
 }
 

spine-c/src/generated/slider_base.cpp

@@ -8,62 +8,62 @@ void spine_slider_base_dispose(spine_slider_base self) {
 }
 
 spine_slider_data spine_slider_base_get_data(spine_slider_base self) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	return (spine_slider_data) &_self->getData();
 }
 
 spine_slider_pose spine_slider_base_get_pose(spine_slider_base self) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	return (spine_slider_pose) &_self->getPose();
 }
 
 spine_slider_pose spine_slider_base_get_applied_pose(spine_slider_base self) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	return (spine_slider_pose) &_self->getAppliedPose();
 }
 
 void spine_slider_base_reset_constrained(spine_slider_base self) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	_self->resetConstrained();
 }
 
 void spine_slider_base_constrained(spine_slider_base self) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	_self->constrained();
 }
 
 bool spine_slider_base_is_pose_equal_to_applied(spine_slider_base self) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_slider_base_is_active(spine_slider_base self) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	return _self->isActive();
 }
 
 void spine_slider_base_set_active(spine_slider_base self, bool active) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	_self->setActive(active);
 }
 
 spine_rtti spine_slider_base_get_rtti(spine_slider_base self) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_slider_base_sort(spine_slider_base self, spine_skeleton skeleton) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	_self->sort(*((Skeleton *) skeleton));
 }
 
 bool spine_slider_base_is_source_active(spine_slider_base self) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	return _self->isSourceActive();
 }
 
 void spine_slider_base_update(spine_slider_base self, spine_skeleton skeleton, spine_physics physics) {
-	ConstraintGeneric<Slider, SliderData, SliderPose> *_self = (ConstraintGeneric<Slider, SliderData, SliderPose> *) (SliderBase *) self;
+	SliderBase *_self = (SliderBase *) self;
 	_self->update(*((Skeleton *) skeleton), (Physics) physics);
 }
 

spine-c/src/generated/slider_data.cpp

@@ -102,22 +102,22 @@ void spine_slider_data_set_local(spine_slider_data self, bool local) {
 }
 
 const char *spine_slider_data_get_name(spine_slider_data self) {
-	ConstraintDataGeneric<Slider, SliderPose> *_self = (ConstraintDataGeneric<Slider, SliderPose> *) (SliderData *) self;
+	SliderData *_self = (SliderData *) self;
 	return _self->getName().buffer();
 }
 
 bool spine_slider_data_get_skin_required(spine_slider_data self) {
-	ConstraintDataGeneric<Slider, SliderPose> *_self = (ConstraintDataGeneric<Slider, SliderPose> *) (SliderData *) self;
+	SliderData *_self = (SliderData *) self;
 	return _self->getSkinRequired();
 }
 
 spine_slider_pose spine_slider_data_get_setup_pose(spine_slider_data self) {
-	ConstraintDataGeneric<Slider, SliderPose> *_self = (ConstraintDataGeneric<Slider, SliderPose> *) (SliderData *) self;
+	SliderData *_self = (SliderData *) self;
 	return (spine_slider_pose) &_self->getSetupPose();
 }
 
 void spine_slider_data_set_skin_required(spine_slider_data self, bool skinRequired) {
-	ConstraintDataGeneric<Slider, SliderPose> *_self = (ConstraintDataGeneric<Slider, SliderPose> *) (SliderData *) self;
+	SliderData *_self = (SliderData *) self;
 	_self->setSkinRequired(skinRequired);
 }
 

spine-c/src/generated/slider_mix_timeline.cpp

@@ -24,97 +24,97 @@ void spine_slider_mix_timeline_apply(spine_slider_mix_timeline self, spine_skele
 }
 
 int spine_slider_mix_timeline_get_constraint_index(spine_slider_mix_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_slider_mix_timeline_set_constraint_index(spine_slider_mix_timeline self, int inValue) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_slider_mix_timeline_set_frame(spine_slider_mix_timeline self, size_t frame, float time, float value) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_slider_mix_timeline_get_curve_value(spine_slider_mix_timeline self, float time) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_slider_mix_timeline_get_relative_value(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												   float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_slider_mix_timeline_get_absolute_value_1(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 													 float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_slider_mix_timeline_get_absolute_value_2(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 													 float setup, float value) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_slider_mix_timeline_get_scale_value(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend,
 												spine_mix_direction direction, float current, float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_slider_mix_timeline_set_linear(spine_slider_mix_timeline self, size_t frame) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_slider_mix_timeline_set_stepped(spine_slider_mix_timeline self, size_t frame) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_slider_mix_timeline_set_bezier(spine_slider_mix_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) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_slider_mix_timeline_get_bezier_value(spine_slider_mix_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_slider_mix_timeline_get_curves(spine_slider_mix_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_slider_mix_timeline_get_frame_entries(spine_slider_mix_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_slider_mix_timeline_get_frame_count(spine_slider_mix_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_slider_mix_timeline_get_frames(spine_slider_mix_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_slider_mix_timeline_get_duration(spine_slider_mix_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_slider_mix_timeline_get_property_ids(spine_slider_mix_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderMixTimeline *) self;
+	SliderMixTimeline *_self = (SliderMixTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/slider_timeline.cpp

@@ -23,97 +23,97 @@ void spine_slider_timeline_apply(spine_slider_timeline self, spine_skeleton skel
 }
 
 int spine_slider_timeline_get_constraint_index(spine_slider_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return _self->getConstraintIndex();
 }
 
 void spine_slider_timeline_set_constraint_index(spine_slider_timeline self, int inValue) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	_self->setConstraintIndex(inValue);
 }
 
 void spine_slider_timeline_set_frame(spine_slider_timeline self, size_t frame, float time, float value) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_slider_timeline_get_curve_value(spine_slider_timeline self, float time) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_slider_timeline_get_relative_value(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 											   float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_slider_timeline_get_absolute_value_1(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												 float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_slider_timeline_get_absolute_value_2(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 												 float setup, float value) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_slider_timeline_get_scale_value(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											float current, float setup) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_slider_timeline_set_linear(spine_slider_timeline self, size_t frame) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_slider_timeline_set_stepped(spine_slider_timeline self, size_t frame) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_slider_timeline_set_bezier(spine_slider_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) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_slider_timeline_get_bezier_value(spine_slider_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_slider_timeline_get_curves(spine_slider_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_slider_timeline_get_frame_entries(spine_slider_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_slider_timeline_get_frame_count(spine_slider_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_slider_timeline_get_frames(spine_slider_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_slider_timeline_get_duration(spine_slider_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_slider_timeline_get_property_ids(spine_slider_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	SliderTimeline *_self = (SliderTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/slot.cpp

@@ -22,31 +22,31 @@ void spine_slot_setup_pose(spine_slot self) {
 }
 
 spine_slot_data spine_slot_get_data(spine_slot self) {
-	PosedGeneric<SlotData, SlotPose, SlotPose> *_self = (PosedGeneric<SlotData, SlotPose, SlotPose> *) (Slot *) self;
+	Slot *_self = (Slot *) self;
 	return (spine_slot_data) &_self->getData();
 }
 
 spine_slot_pose spine_slot_get_pose(spine_slot self) {
-	PosedGeneric<SlotData, SlotPose, SlotPose> *_self = (PosedGeneric<SlotData, SlotPose, SlotPose> *) (Slot *) self;
+	Slot *_self = (Slot *) self;
 	return (spine_slot_pose) &_self->getPose();
 }
 
 spine_slot_pose spine_slot_get_applied_pose(spine_slot self) {
-	PosedGeneric<SlotData, SlotPose, SlotPose> *_self = (PosedGeneric<SlotData, SlotPose, SlotPose> *) (Slot *) self;
+	Slot *_self = (Slot *) self;
 	return (spine_slot_pose) &_self->getAppliedPose();
 }
 
 void spine_slot_reset_constrained(spine_slot self) {
-	PosedGeneric<SlotData, SlotPose, SlotPose> *_self = (PosedGeneric<SlotData, SlotPose, SlotPose> *) (Slot *) self;
+	Slot *_self = (Slot *) self;
 	_self->resetConstrained();
 }
 
 void spine_slot_constrained(spine_slot self) {
-	PosedGeneric<SlotData, SlotPose, SlotPose> *_self = (PosedGeneric<SlotData, SlotPose, SlotPose> *) (Slot *) self;
+	Slot *_self = (Slot *) self;
 	_self->constrained();
 }
 
 bool spine_slot_is_pose_equal_to_applied(spine_slot self) {
-	PosedGeneric<SlotData, SlotPose, SlotPose> *_self = (PosedGeneric<SlotData, SlotPose, SlotPose> *) (Slot *) self;
+	Slot *_self = (Slot *) self;
 	return _self->isPoseEqualToApplied();
 }

spine-c/src/generated/slot_curve_timeline.cpp

@@ -30,53 +30,53 @@ void spine_slot_curve_timeline_set_slot_index(spine_slot_curve_timeline self, in
 }
 
 void spine_slot_curve_timeline_set_linear(spine_slot_curve_timeline self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (SlotCurveTimeline *) self;
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_slot_curve_timeline_set_stepped(spine_slot_curve_timeline self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (SlotCurveTimeline *) self;
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_slot_curve_timeline_set_bezier(spine_slot_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 *) (SlotCurveTimeline *) self;
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_slot_curve_timeline_get_bezier_value(spine_slot_curve_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	CurveTimeline *_self = (CurveTimeline *) (SlotCurveTimeline *) self;
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_slot_curve_timeline_get_curves(spine_slot_curve_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (SlotCurveTimeline *) self;
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_slot_curve_timeline_get_frame_entries(spine_slot_curve_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (SlotCurveTimeline *) self;
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_slot_curve_timeline_get_frame_count(spine_slot_curve_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (SlotCurveTimeline *) self;
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_slot_curve_timeline_get_frames(spine_slot_curve_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (SlotCurveTimeline *) self;
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_slot_curve_timeline_get_duration(spine_slot_curve_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (SlotCurveTimeline *) self;
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_slot_curve_timeline_get_property_ids(spine_slot_curve_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (SlotCurveTimeline *) self;
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/slot_data.cpp

@@ -52,21 +52,21 @@ void spine_slot_data_set_visible(spine_slot_data self, bool visible) {
 }
 
 spine_slot_pose spine_slot_data_get_setup_pose(spine_slot_data self) {
-	PosedDataGeneric<SlotPose> *_self = (PosedDataGeneric<SlotPose> *) (SlotData *) self;
+	SlotData *_self = (SlotData *) self;
 	return (spine_slot_pose) &_self->getSetupPose();
 }
 
 const char *spine_slot_data_get_name(spine_slot_data self) {
-	PosedDataGeneric<SlotPose> *_self = (PosedDataGeneric<SlotPose> *) (SlotData *) self;
+	SlotData *_self = (SlotData *) self;
 	return _self->getName().buffer();
 }
 
 bool spine_slot_data_get_skin_required(spine_slot_data self) {
-	PosedDataGeneric<SlotPose> *_self = (PosedDataGeneric<SlotPose> *) (SlotData *) self;
+	SlotData *_self = (SlotData *) self;
 	return _self->getSkinRequired();
 }
 
 void spine_slot_data_set_skin_required(spine_slot_data self, bool skinRequired) {
-	PosedDataGeneric<SlotPose> *_self = (PosedDataGeneric<SlotPose> *) (SlotData *) self;
+	SlotData *_self = (SlotData *) self;
 	_self->setSkinRequired(skinRequired);
 }

spine-c/src/generated/track_entry.cpp

@@ -287,6 +287,6 @@ void spine_track_entry_set_animation_state(spine_track_entry self, /*@null*/ spi
 }
 
 /*@null*/ void *spine_track_entry_get_renderer_object(spine_track_entry self) {
-	HasRendererObject *_self = (HasRendererObject *) (TrackEntry *) self;
+	TrackEntry *_self = (TrackEntry *) self;
 	return _self->getRendererObject();
 }

spine-c/src/generated/transform_constraint.cpp

@@ -52,42 +52,42 @@ void spine_transform_constraint_set_source(spine_transform_constraint self, spin
 }
 
 spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint self) {
-	TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self;
+	TransformConstraint *_self = (TransformConstraint *) self;
 	return (spine_transform_constraint_data) &_self->getData();
 }
 
 spine_transform_constraint_pose spine_transform_constraint_get_pose(spine_transform_constraint self) {
-	TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self;
+	TransformConstraint *_self = (TransformConstraint *) self;
 	return (spine_transform_constraint_pose) &_self->getPose();
 }
 
 spine_transform_constraint_pose spine_transform_constraint_get_applied_pose(spine_transform_constraint self) {
-	TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self;
+	TransformConstraint *_self = (TransformConstraint *) self;
 	return (spine_transform_constraint_pose) &_self->getAppliedPose();
 }
 
 void spine_transform_constraint_reset_constrained(spine_transform_constraint self) {
-	TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self;
+	TransformConstraint *_self = (TransformConstraint *) self;
 	_self->resetConstrained();
 }
 
 void spine_transform_constraint_constrained(spine_transform_constraint self) {
-	TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self;
+	TransformConstraint *_self = (TransformConstraint *) self;
 	_self->constrained();
 }
 
 bool spine_transform_constraint_is_pose_equal_to_applied(spine_transform_constraint self) {
-	TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self;
+	TransformConstraint *_self = (TransformConstraint *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_transform_constraint_is_active(spine_transform_constraint self) {
-	TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self;
+	TransformConstraint *_self = (TransformConstraint *) self;
 	return _self->isActive();
 }
 
 void spine_transform_constraint_set_active(spine_transform_constraint self, bool active) {
-	TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self;
+	TransformConstraint *_self = (TransformConstraint *) self;
 	_self->setActive(active);
 }
 

spine-c/src/generated/transform_constraint_base.cpp

@@ -8,74 +8,62 @@ void spine_transform_constraint_base_dispose(spine_transform_constraint_base sel
 }
 
 spine_transform_constraint_data spine_transform_constraint_base_get_data(spine_transform_constraint_base self) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	return (spine_transform_constraint_data) &_self->getData();
 }
 
 spine_transform_constraint_pose spine_transform_constraint_base_get_pose(spine_transform_constraint_base self) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	return (spine_transform_constraint_pose) &_self->getPose();
 }
 
 spine_transform_constraint_pose spine_transform_constraint_base_get_applied_pose(spine_transform_constraint_base self) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	return (spine_transform_constraint_pose) &_self->getAppliedPose();
 }
 
 void spine_transform_constraint_base_reset_constrained(spine_transform_constraint_base self) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	_self->resetConstrained();
 }
 
 void spine_transform_constraint_base_constrained(spine_transform_constraint_base self) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	_self->constrained();
 }
 
 bool spine_transform_constraint_base_is_pose_equal_to_applied(spine_transform_constraint_base self) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	return _self->isPoseEqualToApplied();
 }
 
 bool spine_transform_constraint_base_is_active(spine_transform_constraint_base self) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	return _self->isActive();
 }
 
 void spine_transform_constraint_base_set_active(spine_transform_constraint_base self, bool active) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	_self->setActive(active);
 }
 
 spine_rtti spine_transform_constraint_base_get_rtti(spine_transform_constraint_base self) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	return (spine_rtti) &_self->getRTTI();
 }
 
 void spine_transform_constraint_base_sort(spine_transform_constraint_base self, spine_skeleton skeleton) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	_self->sort(*((Skeleton *) skeleton));
 }
 
 bool spine_transform_constraint_base_is_source_active(spine_transform_constraint_base self) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	return _self->isSourceActive();
 }
 
 void spine_transform_constraint_base_update(spine_transform_constraint_base self, spine_skeleton skeleton, spine_physics physics) {
-	ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose>
-		*_self = (ConstraintGeneric<TransformConstraint, TransformConstraintData, TransformConstraintPose> *) (TransformConstraintBase *) self;
+	TransformConstraintBase *_self = (TransformConstraintBase *) self;
 	_self->update(*((Skeleton *) skeleton), (Physics) physics);
 }
 

spine-c/src/generated/transform_constraint_data.cpp

@@ -142,26 +142,22 @@ spine_array_from_property spine_transform_constraint_data_get_properties(spine_t
 }
 
 const char *spine_transform_constraint_data_get_name(spine_transform_constraint_data self) {
-	ConstraintDataGeneric<TransformConstraint, TransformConstraintPose>
-		*_self = (ConstraintDataGeneric<TransformConstraint, TransformConstraintPose> *) (TransformConstraintData *) self;
+	TransformConstraintData *_self = (TransformConstraintData *) self;
 	return _self->getName().buffer();
 }
 
 bool spine_transform_constraint_data_get_skin_required(spine_transform_constraint_data self) {
-	ConstraintDataGeneric<TransformConstraint, TransformConstraintPose>
-		*_self = (ConstraintDataGeneric<TransformConstraint, TransformConstraintPose> *) (TransformConstraintData *) self;
+	TransformConstraintData *_self = (TransformConstraintData *) self;
 	return _self->getSkinRequired();
 }
 
 spine_transform_constraint_pose spine_transform_constraint_data_get_setup_pose(spine_transform_constraint_data self) {
-	ConstraintDataGeneric<TransformConstraint, TransformConstraintPose>
-		*_self = (ConstraintDataGeneric<TransformConstraint, TransformConstraintPose> *) (TransformConstraintData *) self;
+	TransformConstraintData *_self = (TransformConstraintData *) self;
 	return (spine_transform_constraint_pose) &_self->getSetupPose();
 }
 
 void spine_transform_constraint_data_set_skin_required(spine_transform_constraint_data self, bool skinRequired) {
-	ConstraintDataGeneric<TransformConstraint, TransformConstraintPose>
-		*_self = (ConstraintDataGeneric<TransformConstraint, TransformConstraintPose> *) (TransformConstraintData *) self;
+	TransformConstraintData *_self = (TransformConstraintData *) self;
 	_self->setSkinRequired(skinRequired);
 }
 

spine-c/src/generated/transform_constraint_timeline.cpp

@@ -41,54 +41,54 @@ void spine_transform_constraint_timeline_set_constraint_index(spine_transform_co
 }
 
 void spine_transform_constraint_timeline_set_linear(spine_transform_constraint_timeline self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (TransformConstraintTimeline *) self;
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_transform_constraint_timeline_set_stepped(spine_transform_constraint_timeline self, size_t frame) {
-	CurveTimeline *_self = (CurveTimeline *) (TransformConstraintTimeline *) self;
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_transform_constraint_timeline_set_bezier(spine_transform_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 *) (TransformConstraintTimeline *) self;
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_transform_constraint_timeline_get_bezier_value(spine_transform_constraint_timeline self, float time, size_t frame, size_t valueOffset,
 														   size_t i) {
-	CurveTimeline *_self = (CurveTimeline *) (TransformConstraintTimeline *) self;
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_transform_constraint_timeline_get_curves(spine_transform_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (TransformConstraintTimeline *) self;
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_transform_constraint_timeline_get_frame_entries(spine_transform_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (TransformConstraintTimeline *) self;
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_transform_constraint_timeline_get_frame_count(spine_transform_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (TransformConstraintTimeline *) self;
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_transform_constraint_timeline_get_frames(spine_transform_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (TransformConstraintTimeline *) self;
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_transform_constraint_timeline_get_duration(spine_transform_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (TransformConstraintTimeline *) self;
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_transform_constraint_timeline_get_property_ids(spine_transform_constraint_timeline self) {
-	CurveTimeline *_self = (CurveTimeline *) (TransformConstraintTimeline *) self;
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/translate_timeline.cpp

@@ -19,73 +19,73 @@ spine_rtti spine_translate_timeline_get_rtti(spine_translate_timeline self) {
 void spine_translate_timeline_apply(spine_translate_timeline self, spine_skeleton skeleton, float lastTime, float time,
 									/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 									bool appliedPose) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_translate_timeline_get_bone_index(spine_translate_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	return _self->getBoneIndex();
 }
 
 void spine_translate_timeline_set_bone_index(spine_translate_timeline self, int inValue) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	_self->setBoneIndex(inValue);
 }
 
 void spine_translate_timeline_set_frame(spine_translate_timeline self, size_t frame, float time, float value1, float value2) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	_self->setFrame(frame, time, value1, value2);
 }
 
 void spine_translate_timeline_set_linear(spine_translate_timeline self, size_t frame) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_translate_timeline_set_stepped(spine_translate_timeline self, size_t frame) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_translate_timeline_set_bezier(spine_translate_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) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_translate_timeline_get_bezier_value(spine_translate_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_translate_timeline_get_curves(spine_translate_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_translate_timeline_get_frame_entries(spine_translate_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_translate_timeline_get_frame_count(spine_translate_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_translate_timeline_get_frames(spine_translate_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_translate_timeline_get_duration(spine_translate_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_translate_timeline_get_property_ids(spine_translate_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
+	TranslateTimeline *_self = (TranslateTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/translate_x_timeline.cpp

@@ -19,102 +19,102 @@ spine_rtti spine_translate_x_timeline_get_rtti(spine_translate_x_timeline self)
 void spine_translate_x_timeline_apply(spine_translate_x_timeline self, spine_skeleton skeleton, float lastTime, float time,
 									  /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 									  bool appliedPose) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_translate_x_timeline_get_bone_index(spine_translate_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return _self->getBoneIndex();
 }
 
 void spine_translate_x_timeline_set_bone_index(spine_translate_x_timeline self, int inValue) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	_self->setBoneIndex(inValue);
 }
 
 void spine_translate_x_timeline_set_frame(spine_translate_x_timeline self, size_t frame, float time, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_translate_x_timeline_get_curve_value(spine_translate_x_timeline self, float time) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_translate_x_timeline_get_relative_value(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 													float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_translate_x_timeline_get_absolute_value_1(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 													  float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_translate_x_timeline_get_absolute_value_2(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 													  float setup, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_translate_x_timeline_get_scale_value(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend,
 												 spine_mix_direction direction, float current, float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_translate_x_timeline_set_linear(spine_translate_x_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_translate_x_timeline_set_stepped(spine_translate_x_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_translate_x_timeline_set_bezier(spine_translate_x_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) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_translate_x_timeline_get_bezier_value(spine_translate_x_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_translate_x_timeline_get_curves(spine_translate_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_translate_x_timeline_get_frame_entries(spine_translate_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_translate_x_timeline_get_frame_count(spine_translate_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_translate_x_timeline_get_frames(spine_translate_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_translate_x_timeline_get_duration(spine_translate_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_translate_x_timeline_get_property_ids(spine_translate_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateXTimeline *) self;
+	TranslateXTimeline *_self = (TranslateXTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/translate_y_timeline.cpp

@@ -19,102 +19,102 @@ spine_rtti spine_translate_y_timeline_get_rtti(spine_translate_y_timeline self)
 void spine_translate_y_timeline_apply(spine_translate_y_timeline self, spine_skeleton skeleton, float lastTime, float time,
 									  /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 									  bool appliedPose) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
 }
 
 int spine_translate_y_timeline_get_bone_index(spine_translate_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return _self->getBoneIndex();
 }
 
 void spine_translate_y_timeline_set_bone_index(spine_translate_y_timeline self, int inValue) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	_self->setBoneIndex(inValue);
 }
 
 void spine_translate_y_timeline_set_frame(spine_translate_y_timeline self, size_t frame, float time, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	_self->setFrame(frame, time, value);
 }
 
 float spine_translate_y_timeline_get_curve_value(spine_translate_y_timeline self, float time) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return _self->getCurveValue(time);
 }
 
 float spine_translate_y_timeline_get_relative_value(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 													float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_translate_y_timeline_get_absolute_value_1(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 													  float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
 }
 
 float spine_translate_y_timeline_get_absolute_value_2(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
 													  float setup, float value) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
 }
 
 float spine_translate_y_timeline_get_scale_value(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend,
 												 spine_mix_direction direction, float current, float setup) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
 }
 
 void spine_translate_y_timeline_set_linear(spine_translate_y_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	_self->setLinear(frame);
 }
 
 void spine_translate_y_timeline_set_stepped(spine_translate_y_timeline self, size_t frame) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	_self->setStepped(frame);
 }
 
 void spine_translate_y_timeline_set_bezier(spine_translate_y_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) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	_self->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
 }
 
 float spine_translate_y_timeline_get_bezier_value(spine_translate_y_timeline self, float time, size_t frame, size_t valueOffset, size_t i) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_translate_y_timeline_get_curves(spine_translate_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_translate_y_timeline_get_frame_entries(spine_translate_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_translate_y_timeline_get_frame_count(spine_translate_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_translate_y_timeline_get_frames(spine_translate_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_translate_y_timeline_get_duration(spine_translate_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_translate_y_timeline_get_property_ids(spine_translate_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (TranslateYTimeline *) self;
+	TranslateYTimeline *_self = (TranslateYTimeline *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 

spine-c/src/generated/vertex_attachment.cpp

@@ -75,27 +75,27 @@ void spine_vertex_attachment_copy_to(spine_vertex_attachment self, spine_vertex_
 }
 
 const char *spine_vertex_attachment_get_name(spine_vertex_attachment self) {
-	Attachment *_self = (Attachment *) (VertexAttachment *) self;
+	VertexAttachment *_self = (VertexAttachment *) self;
 	return _self->getName().buffer();
 }
 
 spine_attachment spine_vertex_attachment_copy(spine_vertex_attachment self) {
-	Attachment *_self = (Attachment *) (VertexAttachment *) self;
+	VertexAttachment *_self = (VertexAttachment *) self;
 	return (spine_attachment) &_self->copy();
 }
 
 int spine_vertex_attachment_get_ref_count(spine_vertex_attachment self) {
-	Attachment *_self = (Attachment *) (VertexAttachment *) self;
+	VertexAttachment *_self = (VertexAttachment *) self;
 	return _self->getRefCount();
 }
 
 void spine_vertex_attachment_reference(spine_vertex_attachment self) {
-	Attachment *_self = (Attachment *) (VertexAttachment *) self;
+	VertexAttachment *_self = (VertexAttachment *) self;
 	_self->reference();
 }
 
 void spine_vertex_attachment_dereference(spine_vertex_attachment self) {
-	Attachment *_self = (Attachment *) (VertexAttachment *) self;
+	VertexAttachment *_self = (VertexAttachment *) self;
 	_self->dereference();
 }
 

spine-ue/Plugins/SpinePlugin/Source/SpinePlugin/Private/SpineSkeletonAnimationComponent.cpp

@@ -40,7 +40,7 @@ void UTrackEntry::SetTrackEntry(TrackEntry *trackEntry) {
 	if (entry) entry->setRendererObject((void *) this);
 }
 
-void callback(AnimationState *state, spine::EventType type, TrackEntry *entry, Event *event, void* userData) {
+void callback(AnimationState *state, spine::EventType type, TrackEntry *entry, Event *event, void *userData) {
 	USpineSkeletonAnimationComponent *component = (USpineSkeletonAnimationComponent *) state->getRendererObject();
 
 	if (entry->getRendererObject()) {

todos/todos.md

@@ -1,7 +1,7 @@
 - 4.3 release work
     - update docs
-        - [ ] spine-c
-        - [ ] spine-cpp
+        - [x] spine-c
+        - [x] spine-cpp
         - [x] spine-flutter
         - [x] spine-ios
         - [x] spine-sdl