From 324a962b5f4f5ebee6941f87c7e8d4489a5d5cd1 Mon Sep 17 00:00:00 2001 From: Mario Zechner Date: Wed, 10 Sep 2025 22:04:33 +0200 Subject: [PATCH] [c] Code generator now generates cast functions, see updated spine-c docs on RTTI --- spine-c/codegen/src/c-writer.ts | 125 +- spine-c/codegen/src/index.ts | 2 +- spine-c/docs-new.md | 154 +- spine-c/include/spine-c.h | 3 + spine-c/src/generated/alpha_timeline.cpp | 32 +- spine-c/src/generated/animation_state.cpp | 2 +- spine-c/src/generated/atlas_region.cpp | 28 +- spine-c/src/generated/attachment_timeline.cpp | 10 +- spine-c/src/generated/bone.cpp | 16 +- spine-c/src/generated/bone_data.cpp | 8 +- spine-c/src/generated/bone_pose.cpp | 40 +- spine-c/src/generated/bone_timeline1.cpp | 32 +- spine-c/src/generated/bone_timeline2.cpp | 20 +- .../src/generated/bounding_box_attachment.cpp | 32 +- spine-c/src/generated/casts.cpp | 3109 +++++++++++++++++ spine-c/src/generated/casts.h | 588 ++++ spine-c/src/generated/clipping_attachment.cpp | 32 +- .../src/generated/constraint_timeline1.cpp | 34 +- spine-c/src/generated/curve_timeline.cpp | 12 +- spine-c/src/generated/curve_timeline1.cpp | 22 +- spine-c/src/generated/deform_timeline.cpp | 22 +- spine-c/src/generated/draw_order_timeline.cpp | 8 +- spine-c/src/generated/event_timeline.cpp | 8 +- spine-c/src/generated/ik_constraint.cpp | 16 +- spine-c/src/generated/ik_constraint_base.cpp | 36 +- spine-c/src/generated/ik_constraint_data.cpp | 12 +- .../src/generated/ik_constraint_timeline.cpp | 20 +- spine-c/src/generated/inherit_timeline.cpp | 10 +- spine-c/src/generated/mesh_attachment.cpp | 30 +- spine-c/src/generated/path_attachment.cpp | 32 +- spine-c/src/generated/path_constraint.cpp | 16 +- .../src/generated/path_constraint_base.cpp | 36 +- .../src/generated/path_constraint_data.cpp | 12 +- .../path_constraint_mix_timeline.cpp | 20 +- .../path_constraint_position_timeline.cpp | 36 +- .../path_constraint_spacing_timeline.cpp | 36 +- spine-c/src/generated/physics_constraint.cpp | 16 +- .../src/generated/physics_constraint_base.cpp | 36 +- .../physics_constraint_damping_timeline.cpp | 38 +- .../src/generated/physics_constraint_data.cpp | 12 +- .../physics_constraint_gravity_timeline.cpp | 38 +- .../physics_constraint_inertia_timeline.cpp | 38 +- .../physics_constraint_mass_timeline.cpp | 38 +- .../physics_constraint_mix_timeline.cpp | 38 +- .../physics_constraint_reset_timeline.cpp | 8 +- .../physics_constraint_strength_timeline.cpp | 38 +- .../generated/physics_constraint_timeline.cpp | 32 +- .../physics_constraint_wind_timeline.cpp | 38 +- spine-c/src/generated/point_attachment.cpp | 8 +- spine-c/src/generated/region_attachment.cpp | 8 +- spine-c/src/generated/rgb2_timeline.cpp | 26 +- spine-c/src/generated/rgb_timeline.cpp | 26 +- spine-c/src/generated/rgba2_timeline.cpp | 26 +- spine-c/src/generated/rgba_timeline.cpp | 26 +- spine-c/src/generated/rotate_timeline.cpp | 38 +- spine-c/src/generated/scale_timeline.cpp | 28 +- spine-c/src/generated/scale_x_timeline.cpp | 38 +- spine-c/src/generated/scale_y_timeline.cpp | 38 +- spine-c/src/generated/sequence_timeline.cpp | 10 +- spine-c/src/generated/shear_timeline.cpp | 28 +- spine-c/src/generated/shear_x_timeline.cpp | 38 +- spine-c/src/generated/shear_y_timeline.cpp | 38 +- spine-c/src/generated/slider.cpp | 16 +- spine-c/src/generated/slider_base.cpp | 24 +- spine-c/src/generated/slider_data.cpp | 8 +- spine-c/src/generated/slider_mix_timeline.cpp | 36 +- spine-c/src/generated/slider_timeline.cpp | 36 +- spine-c/src/generated/slot.cpp | 12 +- spine-c/src/generated/slot_curve_timeline.cpp | 20 +- spine-c/src/generated/slot_data.cpp | 8 +- spine-c/src/generated/track_entry.cpp | 2 +- .../src/generated/transform_constraint.cpp | 16 +- .../generated/transform_constraint_base.cpp | 36 +- .../generated/transform_constraint_data.cpp | 12 +- .../transform_constraint_timeline.cpp | 20 +- spine-c/src/generated/translate_timeline.cpp | 28 +- .../src/generated/translate_x_timeline.cpp | 38 +- .../src/generated/translate_y_timeline.cpp | 38 +- spine-c/src/generated/vertex_attachment.cpp | 10 +- .../SpineSkeletonAnimationComponent.cpp | 2 +- todos/todos.md | 4 +- 81 files changed, 4819 insertions(+), 944 deletions(-) create mode 100644 spine-c/src/generated/casts.cpp create mode 100644 spine-c/src/generated/casts.h diff --git a/spine-c/codegen/src/c-writer.ts b/spine-c/codegen/src/c-writer.ts index e4471fafa..e7133ff24 100644 --- a/spine-c/codegen/src/c-writer.ts +++ b/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, subtypes: Record, + cNameToCppName: Record): Promise { + 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 '); + 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 { 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 { + async writeAll(cClasses: CClassOrStruct[], cEnums: CEnum[], cArrayTypes: CClassOrStruct[], + supertypes: Record, subtypes: Record): Promise { await this.writeTypesHeader(cClasses, cEnums); await this.writeMainHeader(cClasses); await this.writeArrays(cArrayTypes); + + // Build C name to C++ name mapping + const cNameToCppName: Record = {}; + 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) { diff --git a/spine-c/codegen/src/index.ts b/spine-c/codegen/src/index.ts index c3ea39c0d..206b30da1 100644 --- a/spine-c/codegen/src/index.ts +++ b/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...'); diff --git a/spine-c/docs-new.md b/spine-c/docs-new.md index 4176f74d8..5e0d98c57 100644 --- a/spine-c/docs-new.md +++ b/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 `. +Include spine-c headers in your code: +```c +#include +``` ## 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 `. - -See the [example integrations](#introduction) for complete implementations. +Include spine-c headers in your code: +```c +#include +``` # 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. \ No newline at end of file +* 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. \ No newline at end of file diff --git a/spine-c/include/spine-c.h b/spine-c/include/spine-c.h index 3fcf0c4c7..b498b2e0a 100644 --- a/spine-c/include/spine-c.h +++ b/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" diff --git a/spine-c/src/generated/alpha_timeline.cpp b/spine-c/src/generated/alpha_timeline.cpp index 57ce06888..355bb3313 100644 --- a/spine-c/src/generated/alpha_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/animation_state.cpp b/spine-c/src/generated/animation_state.cpp index 2df5ddd5d..3e3ce533d 100644 --- a/spine-c/src/generated/animation_state.cpp +++ b/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(); } diff --git a/spine-c/src/generated/atlas_region.cpp b/spine-c/src/generated/atlas_region.cpp index d6104b983..dc4c45a6d 100644 --- a/spine-c/src/generated/atlas_region.cpp +++ b/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); } diff --git a/spine-c/src/generated/attachment_timeline.cpp b/spine-c/src/generated/attachment_timeline.cpp index 582ca4fc0..11954e93a 100644 --- a/spine-c/src/generated/attachment_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/bone.cpp b/spine-c/src/generated/bone.cpp index 85977d4fe..6daa61c17 100644 --- a/spine-c/src/generated/bone.cpp +++ b/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 *_self = (PosedGeneric *) (Bone *) self; + Bone *_self = (Bone *) self; return (spine_bone_data) &_self->getData(); } spine_bone_local spine_bone_get_pose(spine_bone self) { - PosedGeneric *_self = (PosedGeneric *) (Bone *) self; + Bone *_self = (Bone *) self; return (spine_bone_local) &_self->getPose(); } spine_bone_pose spine_bone_get_applied_pose(spine_bone self) { - PosedGeneric *_self = (PosedGeneric *) (Bone *) self; + Bone *_self = (Bone *) self; return (spine_bone_pose) &_self->getAppliedPose(); } void spine_bone_reset_constrained(spine_bone self) { - PosedGeneric *_self = (PosedGeneric *) (Bone *) self; + Bone *_self = (Bone *) self; _self->resetConstrained(); } void spine_bone_constrained(spine_bone self) { - PosedGeneric *_self = (PosedGeneric *) (Bone *) self; + Bone *_self = (Bone *) self; _self->constrained(); } bool spine_bone_is_pose_equal_to_applied(spine_bone self) { - PosedGeneric *_self = (PosedGeneric *) (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); } diff --git a/spine-c/src/generated/bone_data.cpp b/spine-c/src/generated/bone_data.cpp index 6435fca2e..c9a80eb8c 100644 --- a/spine-c/src/generated/bone_data.cpp +++ b/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 *_self = (PosedDataGeneric *) (BoneData *) self; + BoneData *_self = (BoneData *) self; return (spine_bone_local) &_self->getSetupPose(); } const char *spine_bone_data_get_name(spine_bone_data self) { - PosedDataGeneric *_self = (PosedDataGeneric *) (BoneData *) self; + BoneData *_self = (BoneData *) self; return _self->getName().buffer(); } bool spine_bone_data_get_skin_required(spine_bone_data self) { - PosedDataGeneric *_self = (PosedDataGeneric *) (BoneData *) self; + BoneData *_self = (BoneData *) self; return _self->getSkinRequired(); } void spine_bone_data_set_skin_required(spine_bone_data self, bool skinRequired) { - PosedDataGeneric *_self = (PosedDataGeneric *) (BoneData *) self; + BoneData *_self = (BoneData *) self; _self->setSkinRequired(skinRequired); } diff --git a/spine-c/src/generated/bone_pose.cpp b/spine-c/src/generated/bone_pose.cpp index 15f6c7ada..2055ddbba 100644 --- a/spine-c/src/generated/bone_pose.cpp +++ b/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); } diff --git a/spine-c/src/generated/bone_timeline1.cpp b/spine-c/src/generated/bone_timeline1.cpp index 4ad401792..44ce66112 100644 --- a/spine-c/src/generated/bone_timeline1.cpp +++ b/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(); } diff --git a/spine-c/src/generated/bone_timeline2.cpp b/spine-c/src/generated/bone_timeline2.cpp index 6c5b00f1b..dd202b914 100644 --- a/spine-c/src/generated/bone_timeline2.cpp +++ b/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(); } diff --git a/spine-c/src/generated/bounding_box_attachment.cpp b/spine-c/src/generated/bounding_box_attachment.cpp index 6eaa8a6a3..66e35ce29 100644 --- a/spine-c/src/generated/bounding_box_attachment.cpp +++ b/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 *) 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 *) 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 *) 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(); } diff --git a/spine-c/src/generated/casts.cpp b/spine-c/src/generated/casts.cpp new file mode 100644 index 000000000..9ec50c962 --- /dev/null +++ b/spine-c/src/generated/casts.cpp @@ -0,0 +1,3109 @@ +/****************************************************************************** + * 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. + *****************************************************************************/ + +#include "casts.h" +#include + +using namespace spine; + +// Upcast function implementations +spine_curve_timeline1 spine_alpha_timeline_cast_to_curve_timeline1(spine_alpha_timeline obj) { + AlphaTimeline *derived = (AlphaTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_alpha_timeline_cast_to_curve_timeline(spine_alpha_timeline obj) { + AlphaTimeline *derived = (AlphaTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_alpha_timeline_cast_to_timeline(spine_alpha_timeline obj) { + AlphaTimeline *derived = (AlphaTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_slot_timeline spine_alpha_timeline_cast_to_slot_timeline(spine_alpha_timeline obj) { + AlphaTimeline *derived = (AlphaTimeline *) obj; + SlotTimeline *base = static_cast(derived); + return (spine_slot_timeline) base; +} + +spine_attachment_loader spine_atlas_attachment_loader_cast_to_attachment_loader(spine_atlas_attachment_loader obj) { + AtlasAttachmentLoader *derived = (AtlasAttachmentLoader *) obj; + AttachmentLoader *base = static_cast(derived); + return (spine_attachment_loader) base; +} + +spine_texture_region spine_atlas_region_cast_to_texture_region(spine_atlas_region obj) { + AtlasRegion *derived = (AtlasRegion *) obj; + TextureRegion *base = static_cast(derived); + return (spine_texture_region) base; +} + +spine_timeline spine_attachment_timeline_cast_to_timeline(spine_attachment_timeline obj) { + AttachmentTimeline *derived = (AttachmentTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_slot_timeline spine_attachment_timeline_cast_to_slot_timeline(spine_attachment_timeline obj) { + AttachmentTimeline *derived = (AttachmentTimeline *) obj; + SlotTimeline *base = static_cast(derived); + return (spine_slot_timeline) base; +} + +spine_posed spine_bone_cast_to_posed(spine_bone obj) { + Bone *derived = (Bone *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_bone_cast_to_posed_active(spine_bone obj) { + Bone *derived = (Bone *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_update spine_bone_cast_to_update(spine_bone obj) { + Bone *derived = (Bone *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_posed_data spine_bone_data_cast_to_posed_data(spine_bone_data obj) { + BoneData *derived = (BoneData *) obj; + PosedData *base = static_cast(derived); + return (spine_posed_data) base; +} + +spine_bone_local spine_bone_pose_cast_to_bone_local(spine_bone_pose obj) { + BonePose *derived = (BonePose *) obj; + BoneLocal *base = static_cast(derived); + return (spine_bone_local) base; +} + +spine_update spine_bone_pose_cast_to_update(spine_bone_pose obj) { + BonePose *derived = (BonePose *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_curve_timeline1 spine_bone_timeline1_cast_to_curve_timeline1(spine_bone_timeline1 obj) { + BoneTimeline1 *derived = (BoneTimeline1 *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_bone_timeline1_cast_to_curve_timeline(spine_bone_timeline1 obj) { + BoneTimeline1 *derived = (BoneTimeline1 *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_bone_timeline1_cast_to_timeline(spine_bone_timeline1 obj) { + BoneTimeline1 *derived = (BoneTimeline1 *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_bone_timeline1_cast_to_bone_timeline(spine_bone_timeline1 obj) { + BoneTimeline1 *derived = (BoneTimeline1 *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_curve_timeline spine_bone_timeline2_cast_to_curve_timeline(spine_bone_timeline2 obj) { + BoneTimeline2 *derived = (BoneTimeline2 *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_bone_timeline2_cast_to_timeline(spine_bone_timeline2 obj) { + BoneTimeline2 *derived = (BoneTimeline2 *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_bone_timeline2_cast_to_bone_timeline(spine_bone_timeline2 obj) { + BoneTimeline2 *derived = (BoneTimeline2 *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_vertex_attachment spine_bounding_box_attachment_cast_to_vertex_attachment(spine_bounding_box_attachment obj) { + BoundingBoxAttachment *derived = (BoundingBoxAttachment *) obj; + VertexAttachment *base = static_cast(derived); + return (spine_vertex_attachment) base; +} + +spine_attachment spine_bounding_box_attachment_cast_to_attachment(spine_bounding_box_attachment obj) { + BoundingBoxAttachment *derived = (BoundingBoxAttachment *) obj; + Attachment *base = static_cast(derived); + return (spine_attachment) base; +} + +spine_vertex_attachment spine_clipping_attachment_cast_to_vertex_attachment(spine_clipping_attachment obj) { + ClippingAttachment *derived = (ClippingAttachment *) obj; + VertexAttachment *base = static_cast(derived); + return (spine_vertex_attachment) base; +} + +spine_attachment spine_clipping_attachment_cast_to_attachment(spine_clipping_attachment obj) { + ClippingAttachment *derived = (ClippingAttachment *) obj; + Attachment *base = static_cast(derived); + return (spine_attachment) base; +} + +spine_update spine_constraint_cast_to_update(spine_constraint obj) { + Constraint *derived = (Constraint *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_curve_timeline1 spine_constraint_timeline1_cast_to_curve_timeline1(spine_constraint_timeline1 obj) { + ConstraintTimeline1 *derived = (ConstraintTimeline1 *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_constraint_timeline1_cast_to_curve_timeline(spine_constraint_timeline1 obj) { + ConstraintTimeline1 *derived = (ConstraintTimeline1 *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_constraint_timeline1_cast_to_timeline(spine_constraint_timeline1 obj) { + ConstraintTimeline1 *derived = (ConstraintTimeline1 *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_constraint_timeline1_cast_to_constraint_timeline(spine_constraint_timeline1 obj) { + ConstraintTimeline1 *derived = (ConstraintTimeline1 *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_timeline spine_curve_timeline_cast_to_timeline(spine_curve_timeline obj) { + CurveTimeline *derived = (CurveTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_curve_timeline spine_curve_timeline1_cast_to_curve_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *derived = (CurveTimeline1 *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_curve_timeline1_cast_to_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *derived = (CurveTimeline1 *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_slot_curve_timeline spine_deform_timeline_cast_to_slot_curve_timeline(spine_deform_timeline obj) { + DeformTimeline *derived = (DeformTimeline *) obj; + SlotCurveTimeline *base = static_cast(derived); + return (spine_slot_curve_timeline) base; +} + +spine_curve_timeline spine_deform_timeline_cast_to_curve_timeline(spine_deform_timeline obj) { + DeformTimeline *derived = (DeformTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_deform_timeline_cast_to_timeline(spine_deform_timeline obj) { + DeformTimeline *derived = (DeformTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_slot_timeline spine_deform_timeline_cast_to_slot_timeline(spine_deform_timeline obj) { + DeformTimeline *derived = (DeformTimeline *) obj; + SlotTimeline *base = static_cast(derived); + return (spine_slot_timeline) base; +} + +spine_timeline spine_draw_order_timeline_cast_to_timeline(spine_draw_order_timeline obj) { + DrawOrderTimeline *derived = (DrawOrderTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_timeline spine_event_timeline_cast_to_timeline(spine_event_timeline obj) { + EventTimeline *derived = (EventTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_from_property spine_from_rotate_cast_to_from_property(spine_from_rotate obj) { + FromRotate *derived = (FromRotate *) obj; + FromProperty *base = static_cast(derived); + return (spine_from_property) base; +} + +spine_from_property spine_from_scale_x_cast_to_from_property(spine_from_scale_x obj) { + FromScaleX *derived = (FromScaleX *) obj; + FromProperty *base = static_cast(derived); + return (spine_from_property) base; +} + +spine_from_property spine_from_scale_y_cast_to_from_property(spine_from_scale_y obj) { + FromScaleY *derived = (FromScaleY *) obj; + FromProperty *base = static_cast(derived); + return (spine_from_property) base; +} + +spine_from_property spine_from_shear_y_cast_to_from_property(spine_from_shear_y obj) { + FromShearY *derived = (FromShearY *) obj; + FromProperty *base = static_cast(derived); + return (spine_from_property) base; +} + +spine_from_property spine_from_x_cast_to_from_property(spine_from_x obj) { + FromX *derived = (FromX *) obj; + FromProperty *base = static_cast(derived); + return (spine_from_property) base; +} + +spine_from_property spine_from_y_cast_to_from_property(spine_from_y obj) { + FromY *derived = (FromY *) obj; + FromProperty *base = static_cast(derived); + return (spine_from_property) base; +} + +spine_ik_constraint_base spine_ik_constraint_cast_to_ik_constraint_base(spine_ik_constraint obj) { + IkConstraint *derived = (IkConstraint *) obj; + IkConstraintBase *base = static_cast(derived); + return (spine_ik_constraint_base) base; +} + +spine_posed spine_ik_constraint_cast_to_posed(spine_ik_constraint obj) { + IkConstraint *derived = (IkConstraint *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_ik_constraint_cast_to_posed_active(spine_ik_constraint obj) { + IkConstraint *derived = (IkConstraint *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_constraint spine_ik_constraint_cast_to_constraint(spine_ik_constraint obj) { + IkConstraint *derived = (IkConstraint *) obj; + Constraint *base = static_cast(derived); + return (spine_constraint) base; +} + +spine_update spine_ik_constraint_cast_to_update(spine_ik_constraint obj) { + IkConstraint *derived = (IkConstraint *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_posed spine_ik_constraint_base_cast_to_posed(spine_ik_constraint_base obj) { + IkConstraintBase *derived = (IkConstraintBase *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_ik_constraint_base_cast_to_posed_active(spine_ik_constraint_base obj) { + IkConstraintBase *derived = (IkConstraintBase *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_constraint spine_ik_constraint_base_cast_to_constraint(spine_ik_constraint_base obj) { + IkConstraintBase *derived = (IkConstraintBase *) obj; + Constraint *base = static_cast(derived); + return (spine_constraint) base; +} + +spine_update spine_ik_constraint_base_cast_to_update(spine_ik_constraint_base obj) { + IkConstraintBase *derived = (IkConstraintBase *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_posed_data spine_ik_constraint_data_cast_to_posed_data(spine_ik_constraint_data obj) { + IkConstraintData *derived = (IkConstraintData *) obj; + PosedData *base = static_cast(derived); + return (spine_posed_data) base; +} + +spine_constraint_data spine_ik_constraint_data_cast_to_constraint_data(spine_ik_constraint_data obj) { + IkConstraintData *derived = (IkConstraintData *) obj; + ConstraintData *base = static_cast(derived); + return (spine_constraint_data) base; +} + +spine_curve_timeline spine_ik_constraint_timeline_cast_to_curve_timeline(spine_ik_constraint_timeline obj) { + IkConstraintTimeline *derived = (IkConstraintTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_ik_constraint_timeline_cast_to_timeline(spine_ik_constraint_timeline obj) { + IkConstraintTimeline *derived = (IkConstraintTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_ik_constraint_timeline_cast_to_constraint_timeline(spine_ik_constraint_timeline obj) { + IkConstraintTimeline *derived = (IkConstraintTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_timeline spine_inherit_timeline_cast_to_timeline(spine_inherit_timeline obj) { + InheritTimeline *derived = (InheritTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_inherit_timeline_cast_to_bone_timeline(spine_inherit_timeline obj) { + InheritTimeline *derived = (InheritTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_vertex_attachment spine_mesh_attachment_cast_to_vertex_attachment(spine_mesh_attachment obj) { + MeshAttachment *derived = (MeshAttachment *) obj; + VertexAttachment *base = static_cast(derived); + return (spine_vertex_attachment) base; +} + +spine_attachment spine_mesh_attachment_cast_to_attachment(spine_mesh_attachment obj) { + MeshAttachment *derived = (MeshAttachment *) obj; + Attachment *base = static_cast(derived); + return (spine_attachment) base; +} + +spine_vertex_attachment spine_path_attachment_cast_to_vertex_attachment(spine_path_attachment obj) { + PathAttachment *derived = (PathAttachment *) obj; + VertexAttachment *base = static_cast(derived); + return (spine_vertex_attachment) base; +} + +spine_attachment spine_path_attachment_cast_to_attachment(spine_path_attachment obj) { + PathAttachment *derived = (PathAttachment *) obj; + Attachment *base = static_cast(derived); + return (spine_attachment) base; +} + +spine_path_constraint_base spine_path_constraint_cast_to_path_constraint_base(spine_path_constraint obj) { + PathConstraint *derived = (PathConstraint *) obj; + PathConstraintBase *base = static_cast(derived); + return (spine_path_constraint_base) base; +} + +spine_posed spine_path_constraint_cast_to_posed(spine_path_constraint obj) { + PathConstraint *derived = (PathConstraint *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_path_constraint_cast_to_posed_active(spine_path_constraint obj) { + PathConstraint *derived = (PathConstraint *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_constraint spine_path_constraint_cast_to_constraint(spine_path_constraint obj) { + PathConstraint *derived = (PathConstraint *) obj; + Constraint *base = static_cast(derived); + return (spine_constraint) base; +} + +spine_update spine_path_constraint_cast_to_update(spine_path_constraint obj) { + PathConstraint *derived = (PathConstraint *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_posed spine_path_constraint_base_cast_to_posed(spine_path_constraint_base obj) { + PathConstraintBase *derived = (PathConstraintBase *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_path_constraint_base_cast_to_posed_active(spine_path_constraint_base obj) { + PathConstraintBase *derived = (PathConstraintBase *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_constraint spine_path_constraint_base_cast_to_constraint(spine_path_constraint_base obj) { + PathConstraintBase *derived = (PathConstraintBase *) obj; + Constraint *base = static_cast(derived); + return (spine_constraint) base; +} + +spine_update spine_path_constraint_base_cast_to_update(spine_path_constraint_base obj) { + PathConstraintBase *derived = (PathConstraintBase *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_posed_data spine_path_constraint_data_cast_to_posed_data(spine_path_constraint_data obj) { + PathConstraintData *derived = (PathConstraintData *) obj; + PosedData *base = static_cast(derived); + return (spine_posed_data) base; +} + +spine_constraint_data spine_path_constraint_data_cast_to_constraint_data(spine_path_constraint_data obj) { + PathConstraintData *derived = (PathConstraintData *) obj; + ConstraintData *base = static_cast(derived); + return (spine_constraint_data) base; +} + +spine_curve_timeline spine_path_constraint_mix_timeline_cast_to_curve_timeline(spine_path_constraint_mix_timeline obj) { + PathConstraintMixTimeline *derived = (PathConstraintMixTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_path_constraint_mix_timeline_cast_to_timeline(spine_path_constraint_mix_timeline obj) { + PathConstraintMixTimeline *derived = (PathConstraintMixTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_path_constraint_mix_timeline_cast_to_constraint_timeline(spine_path_constraint_mix_timeline obj) { + PathConstraintMixTimeline *derived = (PathConstraintMixTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_constraint_timeline1 spine_path_constraint_position_timeline_cast_to_constraint_timeline1(spine_path_constraint_position_timeline obj) { + PathConstraintPositionTimeline *derived = (PathConstraintPositionTimeline *) obj; + ConstraintTimeline1 *base = static_cast(derived); + return (spine_constraint_timeline1) base; +} + +spine_curve_timeline1 spine_path_constraint_position_timeline_cast_to_curve_timeline1(spine_path_constraint_position_timeline obj) { + PathConstraintPositionTimeline *derived = (PathConstraintPositionTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_path_constraint_position_timeline_cast_to_curve_timeline(spine_path_constraint_position_timeline obj) { + PathConstraintPositionTimeline *derived = (PathConstraintPositionTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_path_constraint_position_timeline_cast_to_timeline(spine_path_constraint_position_timeline obj) { + PathConstraintPositionTimeline *derived = (PathConstraintPositionTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_path_constraint_position_timeline_cast_to_constraint_timeline(spine_path_constraint_position_timeline obj) { + PathConstraintPositionTimeline *derived = (PathConstraintPositionTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_constraint_timeline1 spine_path_constraint_spacing_timeline_cast_to_constraint_timeline1(spine_path_constraint_spacing_timeline obj) { + PathConstraintSpacingTimeline *derived = (PathConstraintSpacingTimeline *) obj; + ConstraintTimeline1 *base = static_cast(derived); + return (spine_constraint_timeline1) base; +} + +spine_curve_timeline1 spine_path_constraint_spacing_timeline_cast_to_curve_timeline1(spine_path_constraint_spacing_timeline obj) { + PathConstraintSpacingTimeline *derived = (PathConstraintSpacingTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_path_constraint_spacing_timeline_cast_to_curve_timeline(spine_path_constraint_spacing_timeline obj) { + PathConstraintSpacingTimeline *derived = (PathConstraintSpacingTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_path_constraint_spacing_timeline_cast_to_timeline(spine_path_constraint_spacing_timeline obj) { + PathConstraintSpacingTimeline *derived = (PathConstraintSpacingTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_path_constraint_spacing_timeline_cast_to_constraint_timeline(spine_path_constraint_spacing_timeline obj) { + PathConstraintSpacingTimeline *derived = (PathConstraintSpacingTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_physics_constraint_base spine_physics_constraint_cast_to_physics_constraint_base(spine_physics_constraint obj) { + PhysicsConstraint *derived = (PhysicsConstraint *) obj; + PhysicsConstraintBase *base = static_cast(derived); + return (spine_physics_constraint_base) base; +} + +spine_posed spine_physics_constraint_cast_to_posed(spine_physics_constraint obj) { + PhysicsConstraint *derived = (PhysicsConstraint *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_physics_constraint_cast_to_posed_active(spine_physics_constraint obj) { + PhysicsConstraint *derived = (PhysicsConstraint *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_constraint spine_physics_constraint_cast_to_constraint(spine_physics_constraint obj) { + PhysicsConstraint *derived = (PhysicsConstraint *) obj; + Constraint *base = static_cast(derived); + return (spine_constraint) base; +} + +spine_update spine_physics_constraint_cast_to_update(spine_physics_constraint obj) { + PhysicsConstraint *derived = (PhysicsConstraint *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_posed spine_physics_constraint_base_cast_to_posed(spine_physics_constraint_base obj) { + PhysicsConstraintBase *derived = (PhysicsConstraintBase *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_physics_constraint_base_cast_to_posed_active(spine_physics_constraint_base obj) { + PhysicsConstraintBase *derived = (PhysicsConstraintBase *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_constraint spine_physics_constraint_base_cast_to_constraint(spine_physics_constraint_base obj) { + PhysicsConstraintBase *derived = (PhysicsConstraintBase *) obj; + Constraint *base = static_cast(derived); + return (spine_constraint) base; +} + +spine_update spine_physics_constraint_base_cast_to_update(spine_physics_constraint_base obj) { + PhysicsConstraintBase *derived = (PhysicsConstraintBase *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_physics_constraint_timeline spine_physics_constraint_damping_timeline_cast_to_physics_constraint_timeline( + spine_physics_constraint_damping_timeline obj) { + PhysicsConstraintDampingTimeline *derived = (PhysicsConstraintDampingTimeline *) obj; + PhysicsConstraintTimeline *base = static_cast(derived); + return (spine_physics_constraint_timeline) base; +} + +spine_curve_timeline1 spine_physics_constraint_damping_timeline_cast_to_curve_timeline1(spine_physics_constraint_damping_timeline obj) { + PhysicsConstraintDampingTimeline *derived = (PhysicsConstraintDampingTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_physics_constraint_damping_timeline_cast_to_curve_timeline(spine_physics_constraint_damping_timeline obj) { + PhysicsConstraintDampingTimeline *derived = (PhysicsConstraintDampingTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_physics_constraint_damping_timeline_cast_to_timeline(spine_physics_constraint_damping_timeline obj) { + PhysicsConstraintDampingTimeline *derived = (PhysicsConstraintDampingTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_physics_constraint_damping_timeline_cast_to_constraint_timeline(spine_physics_constraint_damping_timeline obj) { + PhysicsConstraintDampingTimeline *derived = (PhysicsConstraintDampingTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_posed_data spine_physics_constraint_data_cast_to_posed_data(spine_physics_constraint_data obj) { + PhysicsConstraintData *derived = (PhysicsConstraintData *) obj; + PosedData *base = static_cast(derived); + return (spine_posed_data) base; +} + +spine_constraint_data spine_physics_constraint_data_cast_to_constraint_data(spine_physics_constraint_data obj) { + PhysicsConstraintData *derived = (PhysicsConstraintData *) obj; + ConstraintData *base = static_cast(derived); + return (spine_constraint_data) base; +} + +spine_physics_constraint_timeline spine_physics_constraint_gravity_timeline_cast_to_physics_constraint_timeline( + spine_physics_constraint_gravity_timeline obj) { + PhysicsConstraintGravityTimeline *derived = (PhysicsConstraintGravityTimeline *) obj; + PhysicsConstraintTimeline *base = static_cast(derived); + return (spine_physics_constraint_timeline) base; +} + +spine_curve_timeline1 spine_physics_constraint_gravity_timeline_cast_to_curve_timeline1(spine_physics_constraint_gravity_timeline obj) { + PhysicsConstraintGravityTimeline *derived = (PhysicsConstraintGravityTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_physics_constraint_gravity_timeline_cast_to_curve_timeline(spine_physics_constraint_gravity_timeline obj) { + PhysicsConstraintGravityTimeline *derived = (PhysicsConstraintGravityTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_physics_constraint_gravity_timeline_cast_to_timeline(spine_physics_constraint_gravity_timeline obj) { + PhysicsConstraintGravityTimeline *derived = (PhysicsConstraintGravityTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_physics_constraint_gravity_timeline_cast_to_constraint_timeline(spine_physics_constraint_gravity_timeline obj) { + PhysicsConstraintGravityTimeline *derived = (PhysicsConstraintGravityTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_physics_constraint_timeline spine_physics_constraint_inertia_timeline_cast_to_physics_constraint_timeline( + spine_physics_constraint_inertia_timeline obj) { + PhysicsConstraintInertiaTimeline *derived = (PhysicsConstraintInertiaTimeline *) obj; + PhysicsConstraintTimeline *base = static_cast(derived); + return (spine_physics_constraint_timeline) base; +} + +spine_curve_timeline1 spine_physics_constraint_inertia_timeline_cast_to_curve_timeline1(spine_physics_constraint_inertia_timeline obj) { + PhysicsConstraintInertiaTimeline *derived = (PhysicsConstraintInertiaTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_physics_constraint_inertia_timeline_cast_to_curve_timeline(spine_physics_constraint_inertia_timeline obj) { + PhysicsConstraintInertiaTimeline *derived = (PhysicsConstraintInertiaTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_physics_constraint_inertia_timeline_cast_to_timeline(spine_physics_constraint_inertia_timeline obj) { + PhysicsConstraintInertiaTimeline *derived = (PhysicsConstraintInertiaTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_physics_constraint_inertia_timeline_cast_to_constraint_timeline(spine_physics_constraint_inertia_timeline obj) { + PhysicsConstraintInertiaTimeline *derived = (PhysicsConstraintInertiaTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_physics_constraint_timeline spine_physics_constraint_mass_timeline_cast_to_physics_constraint_timeline( + spine_physics_constraint_mass_timeline obj) { + PhysicsConstraintMassTimeline *derived = (PhysicsConstraintMassTimeline *) obj; + PhysicsConstraintTimeline *base = static_cast(derived); + return (spine_physics_constraint_timeline) base; +} + +spine_curve_timeline1 spine_physics_constraint_mass_timeline_cast_to_curve_timeline1(spine_physics_constraint_mass_timeline obj) { + PhysicsConstraintMassTimeline *derived = (PhysicsConstraintMassTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_physics_constraint_mass_timeline_cast_to_curve_timeline(spine_physics_constraint_mass_timeline obj) { + PhysicsConstraintMassTimeline *derived = (PhysicsConstraintMassTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_physics_constraint_mass_timeline_cast_to_timeline(spine_physics_constraint_mass_timeline obj) { + PhysicsConstraintMassTimeline *derived = (PhysicsConstraintMassTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_physics_constraint_mass_timeline_cast_to_constraint_timeline(spine_physics_constraint_mass_timeline obj) { + PhysicsConstraintMassTimeline *derived = (PhysicsConstraintMassTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_physics_constraint_timeline spine_physics_constraint_mix_timeline_cast_to_physics_constraint_timeline( + spine_physics_constraint_mix_timeline obj) { + PhysicsConstraintMixTimeline *derived = (PhysicsConstraintMixTimeline *) obj; + PhysicsConstraintTimeline *base = static_cast(derived); + return (spine_physics_constraint_timeline) base; +} + +spine_curve_timeline1 spine_physics_constraint_mix_timeline_cast_to_curve_timeline1(spine_physics_constraint_mix_timeline obj) { + PhysicsConstraintMixTimeline *derived = (PhysicsConstraintMixTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_physics_constraint_mix_timeline_cast_to_curve_timeline(spine_physics_constraint_mix_timeline obj) { + PhysicsConstraintMixTimeline *derived = (PhysicsConstraintMixTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_physics_constraint_mix_timeline_cast_to_timeline(spine_physics_constraint_mix_timeline obj) { + PhysicsConstraintMixTimeline *derived = (PhysicsConstraintMixTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_physics_constraint_mix_timeline_cast_to_constraint_timeline(spine_physics_constraint_mix_timeline obj) { + PhysicsConstraintMixTimeline *derived = (PhysicsConstraintMixTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_timeline spine_physics_constraint_reset_timeline_cast_to_timeline(spine_physics_constraint_reset_timeline obj) { + PhysicsConstraintResetTimeline *derived = (PhysicsConstraintResetTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_physics_constraint_reset_timeline_cast_to_constraint_timeline(spine_physics_constraint_reset_timeline obj) { + PhysicsConstraintResetTimeline *derived = (PhysicsConstraintResetTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_physics_constraint_timeline spine_physics_constraint_strength_timeline_cast_to_physics_constraint_timeline( + spine_physics_constraint_strength_timeline obj) { + PhysicsConstraintStrengthTimeline *derived = (PhysicsConstraintStrengthTimeline *) obj; + PhysicsConstraintTimeline *base = static_cast(derived); + return (spine_physics_constraint_timeline) base; +} + +spine_curve_timeline1 spine_physics_constraint_strength_timeline_cast_to_curve_timeline1(spine_physics_constraint_strength_timeline obj) { + PhysicsConstraintStrengthTimeline *derived = (PhysicsConstraintStrengthTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_physics_constraint_strength_timeline_cast_to_curve_timeline(spine_physics_constraint_strength_timeline obj) { + PhysicsConstraintStrengthTimeline *derived = (PhysicsConstraintStrengthTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_physics_constraint_strength_timeline_cast_to_timeline(spine_physics_constraint_strength_timeline obj) { + PhysicsConstraintStrengthTimeline *derived = (PhysicsConstraintStrengthTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_physics_constraint_strength_timeline_cast_to_constraint_timeline(spine_physics_constraint_strength_timeline obj) { + PhysicsConstraintStrengthTimeline *derived = (PhysicsConstraintStrengthTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_curve_timeline1 spine_physics_constraint_timeline_cast_to_curve_timeline1(spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *derived = (PhysicsConstraintTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_physics_constraint_timeline_cast_to_curve_timeline(spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *derived = (PhysicsConstraintTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_physics_constraint_timeline_cast_to_timeline(spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *derived = (PhysicsConstraintTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_physics_constraint_timeline_cast_to_constraint_timeline(spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *derived = (PhysicsConstraintTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_physics_constraint_timeline spine_physics_constraint_wind_timeline_cast_to_physics_constraint_timeline( + spine_physics_constraint_wind_timeline obj) { + PhysicsConstraintWindTimeline *derived = (PhysicsConstraintWindTimeline *) obj; + PhysicsConstraintTimeline *base = static_cast(derived); + return (spine_physics_constraint_timeline) base; +} + +spine_curve_timeline1 spine_physics_constraint_wind_timeline_cast_to_curve_timeline1(spine_physics_constraint_wind_timeline obj) { + PhysicsConstraintWindTimeline *derived = (PhysicsConstraintWindTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_physics_constraint_wind_timeline_cast_to_curve_timeline(spine_physics_constraint_wind_timeline obj) { + PhysicsConstraintWindTimeline *derived = (PhysicsConstraintWindTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_physics_constraint_wind_timeline_cast_to_timeline(spine_physics_constraint_wind_timeline obj) { + PhysicsConstraintWindTimeline *derived = (PhysicsConstraintWindTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_physics_constraint_wind_timeline_cast_to_constraint_timeline(spine_physics_constraint_wind_timeline obj) { + PhysicsConstraintWindTimeline *derived = (PhysicsConstraintWindTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_attachment spine_point_attachment_cast_to_attachment(spine_point_attachment obj) { + PointAttachment *derived = (PointAttachment *) obj; + Attachment *base = static_cast(derived); + return (spine_attachment) base; +} + +spine_attachment spine_region_attachment_cast_to_attachment(spine_region_attachment obj) { + RegionAttachment *derived = (RegionAttachment *) obj; + Attachment *base = static_cast(derived); + return (spine_attachment) base; +} + +spine_slot_curve_timeline spine_rgb2_timeline_cast_to_slot_curve_timeline(spine_rgb2_timeline obj) { + RGB2Timeline *derived = (RGB2Timeline *) obj; + SlotCurveTimeline *base = static_cast(derived); + return (spine_slot_curve_timeline) base; +} + +spine_curve_timeline spine_rgb2_timeline_cast_to_curve_timeline(spine_rgb2_timeline obj) { + RGB2Timeline *derived = (RGB2Timeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_rgb2_timeline_cast_to_timeline(spine_rgb2_timeline obj) { + RGB2Timeline *derived = (RGB2Timeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_slot_timeline spine_rgb2_timeline_cast_to_slot_timeline(spine_rgb2_timeline obj) { + RGB2Timeline *derived = (RGB2Timeline *) obj; + SlotTimeline *base = static_cast(derived); + return (spine_slot_timeline) base; +} + +spine_slot_curve_timeline spine_rgba2_timeline_cast_to_slot_curve_timeline(spine_rgba2_timeline obj) { + RGBA2Timeline *derived = (RGBA2Timeline *) obj; + SlotCurveTimeline *base = static_cast(derived); + return (spine_slot_curve_timeline) base; +} + +spine_curve_timeline spine_rgba2_timeline_cast_to_curve_timeline(spine_rgba2_timeline obj) { + RGBA2Timeline *derived = (RGBA2Timeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_rgba2_timeline_cast_to_timeline(spine_rgba2_timeline obj) { + RGBA2Timeline *derived = (RGBA2Timeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_slot_timeline spine_rgba2_timeline_cast_to_slot_timeline(spine_rgba2_timeline obj) { + RGBA2Timeline *derived = (RGBA2Timeline *) obj; + SlotTimeline *base = static_cast(derived); + return (spine_slot_timeline) base; +} + +spine_slot_curve_timeline spine_rgba_timeline_cast_to_slot_curve_timeline(spine_rgba_timeline obj) { + RGBATimeline *derived = (RGBATimeline *) obj; + SlotCurveTimeline *base = static_cast(derived); + return (spine_slot_curve_timeline) base; +} + +spine_curve_timeline spine_rgba_timeline_cast_to_curve_timeline(spine_rgba_timeline obj) { + RGBATimeline *derived = (RGBATimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_rgba_timeline_cast_to_timeline(spine_rgba_timeline obj) { + RGBATimeline *derived = (RGBATimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_slot_timeline spine_rgba_timeline_cast_to_slot_timeline(spine_rgba_timeline obj) { + RGBATimeline *derived = (RGBATimeline *) obj; + SlotTimeline *base = static_cast(derived); + return (spine_slot_timeline) base; +} + +spine_slot_curve_timeline spine_rgb_timeline_cast_to_slot_curve_timeline(spine_rgb_timeline obj) { + RGBTimeline *derived = (RGBTimeline *) obj; + SlotCurveTimeline *base = static_cast(derived); + return (spine_slot_curve_timeline) base; +} + +spine_curve_timeline spine_rgb_timeline_cast_to_curve_timeline(spine_rgb_timeline obj) { + RGBTimeline *derived = (RGBTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_rgb_timeline_cast_to_timeline(spine_rgb_timeline obj) { + RGBTimeline *derived = (RGBTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_slot_timeline spine_rgb_timeline_cast_to_slot_timeline(spine_rgb_timeline obj) { + RGBTimeline *derived = (RGBTimeline *) obj; + SlotTimeline *base = static_cast(derived); + return (spine_slot_timeline) base; +} + +spine_bone_timeline1 spine_rotate_timeline_cast_to_bone_timeline1(spine_rotate_timeline obj) { + RotateTimeline *derived = (RotateTimeline *) obj; + BoneTimeline1 *base = static_cast(derived); + return (spine_bone_timeline1) base; +} + +spine_curve_timeline1 spine_rotate_timeline_cast_to_curve_timeline1(spine_rotate_timeline obj) { + RotateTimeline *derived = (RotateTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_rotate_timeline_cast_to_curve_timeline(spine_rotate_timeline obj) { + RotateTimeline *derived = (RotateTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_rotate_timeline_cast_to_timeline(spine_rotate_timeline obj) { + RotateTimeline *derived = (RotateTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_rotate_timeline_cast_to_bone_timeline(spine_rotate_timeline obj) { + RotateTimeline *derived = (RotateTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_bone_timeline2 spine_scale_timeline_cast_to_bone_timeline2(spine_scale_timeline obj) { + ScaleTimeline *derived = (ScaleTimeline *) obj; + BoneTimeline2 *base = static_cast(derived); + return (spine_bone_timeline2) base; +} + +spine_curve_timeline spine_scale_timeline_cast_to_curve_timeline(spine_scale_timeline obj) { + ScaleTimeline *derived = (ScaleTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_scale_timeline_cast_to_timeline(spine_scale_timeline obj) { + ScaleTimeline *derived = (ScaleTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_scale_timeline_cast_to_bone_timeline(spine_scale_timeline obj) { + ScaleTimeline *derived = (ScaleTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_bone_timeline1 spine_scale_x_timeline_cast_to_bone_timeline1(spine_scale_x_timeline obj) { + ScaleXTimeline *derived = (ScaleXTimeline *) obj; + BoneTimeline1 *base = static_cast(derived); + return (spine_bone_timeline1) base; +} + +spine_curve_timeline1 spine_scale_x_timeline_cast_to_curve_timeline1(spine_scale_x_timeline obj) { + ScaleXTimeline *derived = (ScaleXTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_scale_x_timeline_cast_to_curve_timeline(spine_scale_x_timeline obj) { + ScaleXTimeline *derived = (ScaleXTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_scale_x_timeline_cast_to_timeline(spine_scale_x_timeline obj) { + ScaleXTimeline *derived = (ScaleXTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_scale_x_timeline_cast_to_bone_timeline(spine_scale_x_timeline obj) { + ScaleXTimeline *derived = (ScaleXTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_bone_timeline1 spine_scale_y_timeline_cast_to_bone_timeline1(spine_scale_y_timeline obj) { + ScaleYTimeline *derived = (ScaleYTimeline *) obj; + BoneTimeline1 *base = static_cast(derived); + return (spine_bone_timeline1) base; +} + +spine_curve_timeline1 spine_scale_y_timeline_cast_to_curve_timeline1(spine_scale_y_timeline obj) { + ScaleYTimeline *derived = (ScaleYTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_scale_y_timeline_cast_to_curve_timeline(spine_scale_y_timeline obj) { + ScaleYTimeline *derived = (ScaleYTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_scale_y_timeline_cast_to_timeline(spine_scale_y_timeline obj) { + ScaleYTimeline *derived = (ScaleYTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_scale_y_timeline_cast_to_bone_timeline(spine_scale_y_timeline obj) { + ScaleYTimeline *derived = (ScaleYTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_timeline spine_sequence_timeline_cast_to_timeline(spine_sequence_timeline obj) { + SequenceTimeline *derived = (SequenceTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_slot_timeline spine_sequence_timeline_cast_to_slot_timeline(spine_sequence_timeline obj) { + SequenceTimeline *derived = (SequenceTimeline *) obj; + SlotTimeline *base = static_cast(derived); + return (spine_slot_timeline) base; +} + +spine_bone_timeline2 spine_shear_timeline_cast_to_bone_timeline2(spine_shear_timeline obj) { + ShearTimeline *derived = (ShearTimeline *) obj; + BoneTimeline2 *base = static_cast(derived); + return (spine_bone_timeline2) base; +} + +spine_curve_timeline spine_shear_timeline_cast_to_curve_timeline(spine_shear_timeline obj) { + ShearTimeline *derived = (ShearTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_shear_timeline_cast_to_timeline(spine_shear_timeline obj) { + ShearTimeline *derived = (ShearTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_shear_timeline_cast_to_bone_timeline(spine_shear_timeline obj) { + ShearTimeline *derived = (ShearTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_bone_timeline1 spine_shear_x_timeline_cast_to_bone_timeline1(spine_shear_x_timeline obj) { + ShearXTimeline *derived = (ShearXTimeline *) obj; + BoneTimeline1 *base = static_cast(derived); + return (spine_bone_timeline1) base; +} + +spine_curve_timeline1 spine_shear_x_timeline_cast_to_curve_timeline1(spine_shear_x_timeline obj) { + ShearXTimeline *derived = (ShearXTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_shear_x_timeline_cast_to_curve_timeline(spine_shear_x_timeline obj) { + ShearXTimeline *derived = (ShearXTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_shear_x_timeline_cast_to_timeline(spine_shear_x_timeline obj) { + ShearXTimeline *derived = (ShearXTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_shear_x_timeline_cast_to_bone_timeline(spine_shear_x_timeline obj) { + ShearXTimeline *derived = (ShearXTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_bone_timeline1 spine_shear_y_timeline_cast_to_bone_timeline1(spine_shear_y_timeline obj) { + ShearYTimeline *derived = (ShearYTimeline *) obj; + BoneTimeline1 *base = static_cast(derived); + return (spine_bone_timeline1) base; +} + +spine_curve_timeline1 spine_shear_y_timeline_cast_to_curve_timeline1(spine_shear_y_timeline obj) { + ShearYTimeline *derived = (ShearYTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_shear_y_timeline_cast_to_curve_timeline(spine_shear_y_timeline obj) { + ShearYTimeline *derived = (ShearYTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_shear_y_timeline_cast_to_timeline(spine_shear_y_timeline obj) { + ShearYTimeline *derived = (ShearYTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_shear_y_timeline_cast_to_bone_timeline(spine_shear_y_timeline obj) { + ShearYTimeline *derived = (ShearYTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_slider_base spine_slider_cast_to_slider_base(spine_slider obj) { + Slider *derived = (Slider *) obj; + SliderBase *base = static_cast(derived); + return (spine_slider_base) base; +} + +spine_posed spine_slider_cast_to_posed(spine_slider obj) { + Slider *derived = (Slider *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_slider_cast_to_posed_active(spine_slider obj) { + Slider *derived = (Slider *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_constraint spine_slider_cast_to_constraint(spine_slider obj) { + Slider *derived = (Slider *) obj; + Constraint *base = static_cast(derived); + return (spine_constraint) base; +} + +spine_update spine_slider_cast_to_update(spine_slider obj) { + Slider *derived = (Slider *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_posed spine_slider_base_cast_to_posed(spine_slider_base obj) { + SliderBase *derived = (SliderBase *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_slider_base_cast_to_posed_active(spine_slider_base obj) { + SliderBase *derived = (SliderBase *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_constraint spine_slider_base_cast_to_constraint(spine_slider_base obj) { + SliderBase *derived = (SliderBase *) obj; + Constraint *base = static_cast(derived); + return (spine_constraint) base; +} + +spine_update spine_slider_base_cast_to_update(spine_slider_base obj) { + SliderBase *derived = (SliderBase *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_posed_data spine_slider_data_cast_to_posed_data(spine_slider_data obj) { + SliderData *derived = (SliderData *) obj; + PosedData *base = static_cast(derived); + return (spine_posed_data) base; +} + +spine_constraint_data spine_slider_data_cast_to_constraint_data(spine_slider_data obj) { + SliderData *derived = (SliderData *) obj; + ConstraintData *base = static_cast(derived); + return (spine_constraint_data) base; +} + +spine_constraint_timeline1 spine_slider_mix_timeline_cast_to_constraint_timeline1(spine_slider_mix_timeline obj) { + SliderMixTimeline *derived = (SliderMixTimeline *) obj; + ConstraintTimeline1 *base = static_cast(derived); + return (spine_constraint_timeline1) base; +} + +spine_curve_timeline1 spine_slider_mix_timeline_cast_to_curve_timeline1(spine_slider_mix_timeline obj) { + SliderMixTimeline *derived = (SliderMixTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_slider_mix_timeline_cast_to_curve_timeline(spine_slider_mix_timeline obj) { + SliderMixTimeline *derived = (SliderMixTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_slider_mix_timeline_cast_to_timeline(spine_slider_mix_timeline obj) { + SliderMixTimeline *derived = (SliderMixTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_slider_mix_timeline_cast_to_constraint_timeline(spine_slider_mix_timeline obj) { + SliderMixTimeline *derived = (SliderMixTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_constraint_timeline1 spine_slider_timeline_cast_to_constraint_timeline1(spine_slider_timeline obj) { + SliderTimeline *derived = (SliderTimeline *) obj; + ConstraintTimeline1 *base = static_cast(derived); + return (spine_constraint_timeline1) base; +} + +spine_curve_timeline1 spine_slider_timeline_cast_to_curve_timeline1(spine_slider_timeline obj) { + SliderTimeline *derived = (SliderTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_slider_timeline_cast_to_curve_timeline(spine_slider_timeline obj) { + SliderTimeline *derived = (SliderTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_slider_timeline_cast_to_timeline(spine_slider_timeline obj) { + SliderTimeline *derived = (SliderTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_slider_timeline_cast_to_constraint_timeline(spine_slider_timeline obj) { + SliderTimeline *derived = (SliderTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_posed spine_slot_cast_to_posed(spine_slot obj) { + Slot *derived = (Slot *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_curve_timeline spine_slot_curve_timeline_cast_to_curve_timeline(spine_slot_curve_timeline obj) { + SlotCurveTimeline *derived = (SlotCurveTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_slot_curve_timeline_cast_to_timeline(spine_slot_curve_timeline obj) { + SlotCurveTimeline *derived = (SlotCurveTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_slot_timeline spine_slot_curve_timeline_cast_to_slot_timeline(spine_slot_curve_timeline obj) { + SlotCurveTimeline *derived = (SlotCurveTimeline *) obj; + SlotTimeline *base = static_cast(derived); + return (spine_slot_timeline) base; +} + +spine_posed_data spine_slot_data_cast_to_posed_data(spine_slot_data obj) { + SlotData *derived = (SlotData *) obj; + PosedData *base = static_cast(derived); + return (spine_posed_data) base; +} + +spine_to_property spine_to_rotate_cast_to_to_property(spine_to_rotate obj) { + ToRotate *derived = (ToRotate *) obj; + ToProperty *base = static_cast(derived); + return (spine_to_property) base; +} + +spine_to_property spine_to_scale_x_cast_to_to_property(spine_to_scale_x obj) { + ToScaleX *derived = (ToScaleX *) obj; + ToProperty *base = static_cast(derived); + return (spine_to_property) base; +} + +spine_to_property spine_to_scale_y_cast_to_to_property(spine_to_scale_y obj) { + ToScaleY *derived = (ToScaleY *) obj; + ToProperty *base = static_cast(derived); + return (spine_to_property) base; +} + +spine_to_property spine_to_shear_y_cast_to_to_property(spine_to_shear_y obj) { + ToShearY *derived = (ToShearY *) obj; + ToProperty *base = static_cast(derived); + return (spine_to_property) base; +} + +spine_to_property spine_to_x_cast_to_to_property(spine_to_x obj) { + ToX *derived = (ToX *) obj; + ToProperty *base = static_cast(derived); + return (spine_to_property) base; +} + +spine_to_property spine_to_y_cast_to_to_property(spine_to_y obj) { + ToY *derived = (ToY *) obj; + ToProperty *base = static_cast(derived); + return (spine_to_property) base; +} + +spine_transform_constraint_base spine_transform_constraint_cast_to_transform_constraint_base(spine_transform_constraint obj) { + TransformConstraint *derived = (TransformConstraint *) obj; + TransformConstraintBase *base = static_cast(derived); + return (spine_transform_constraint_base) base; +} + +spine_posed spine_transform_constraint_cast_to_posed(spine_transform_constraint obj) { + TransformConstraint *derived = (TransformConstraint *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_transform_constraint_cast_to_posed_active(spine_transform_constraint obj) { + TransformConstraint *derived = (TransformConstraint *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_constraint spine_transform_constraint_cast_to_constraint(spine_transform_constraint obj) { + TransformConstraint *derived = (TransformConstraint *) obj; + Constraint *base = static_cast(derived); + return (spine_constraint) base; +} + +spine_update spine_transform_constraint_cast_to_update(spine_transform_constraint obj) { + TransformConstraint *derived = (TransformConstraint *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_posed spine_transform_constraint_base_cast_to_posed(spine_transform_constraint_base obj) { + TransformConstraintBase *derived = (TransformConstraintBase *) obj; + Posed *base = static_cast(derived); + return (spine_posed) base; +} + +spine_posed_active spine_transform_constraint_base_cast_to_posed_active(spine_transform_constraint_base obj) { + TransformConstraintBase *derived = (TransformConstraintBase *) obj; + PosedActive *base = static_cast(derived); + return (spine_posed_active) base; +} + +spine_constraint spine_transform_constraint_base_cast_to_constraint(spine_transform_constraint_base obj) { + TransformConstraintBase *derived = (TransformConstraintBase *) obj; + Constraint *base = static_cast(derived); + return (spine_constraint) base; +} + +spine_update spine_transform_constraint_base_cast_to_update(spine_transform_constraint_base obj) { + TransformConstraintBase *derived = (TransformConstraintBase *) obj; + Update *base = static_cast(derived); + return (spine_update) base; +} + +spine_posed_data spine_transform_constraint_data_cast_to_posed_data(spine_transform_constraint_data obj) { + TransformConstraintData *derived = (TransformConstraintData *) obj; + PosedData *base = static_cast(derived); + return (spine_posed_data) base; +} + +spine_constraint_data spine_transform_constraint_data_cast_to_constraint_data(spine_transform_constraint_data obj) { + TransformConstraintData *derived = (TransformConstraintData *) obj; + ConstraintData *base = static_cast(derived); + return (spine_constraint_data) base; +} + +spine_curve_timeline spine_transform_constraint_timeline_cast_to_curve_timeline(spine_transform_constraint_timeline obj) { + TransformConstraintTimeline *derived = (TransformConstraintTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_transform_constraint_timeline_cast_to_timeline(spine_transform_constraint_timeline obj) { + TransformConstraintTimeline *derived = (TransformConstraintTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_constraint_timeline spine_transform_constraint_timeline_cast_to_constraint_timeline(spine_transform_constraint_timeline obj) { + TransformConstraintTimeline *derived = (TransformConstraintTimeline *) obj; + ConstraintTimeline *base = static_cast(derived); + return (spine_constraint_timeline) base; +} + +spine_bone_timeline2 spine_translate_timeline_cast_to_bone_timeline2(spine_translate_timeline obj) { + TranslateTimeline *derived = (TranslateTimeline *) obj; + BoneTimeline2 *base = static_cast(derived); + return (spine_bone_timeline2) base; +} + +spine_curve_timeline spine_translate_timeline_cast_to_curve_timeline(spine_translate_timeline obj) { + TranslateTimeline *derived = (TranslateTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_translate_timeline_cast_to_timeline(spine_translate_timeline obj) { + TranslateTimeline *derived = (TranslateTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_translate_timeline_cast_to_bone_timeline(spine_translate_timeline obj) { + TranslateTimeline *derived = (TranslateTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_bone_timeline1 spine_translate_x_timeline_cast_to_bone_timeline1(spine_translate_x_timeline obj) { + TranslateXTimeline *derived = (TranslateXTimeline *) obj; + BoneTimeline1 *base = static_cast(derived); + return (spine_bone_timeline1) base; +} + +spine_curve_timeline1 spine_translate_x_timeline_cast_to_curve_timeline1(spine_translate_x_timeline obj) { + TranslateXTimeline *derived = (TranslateXTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_translate_x_timeline_cast_to_curve_timeline(spine_translate_x_timeline obj) { + TranslateXTimeline *derived = (TranslateXTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_translate_x_timeline_cast_to_timeline(spine_translate_x_timeline obj) { + TranslateXTimeline *derived = (TranslateXTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_translate_x_timeline_cast_to_bone_timeline(spine_translate_x_timeline obj) { + TranslateXTimeline *derived = (TranslateXTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_bone_timeline1 spine_translate_y_timeline_cast_to_bone_timeline1(spine_translate_y_timeline obj) { + TranslateYTimeline *derived = (TranslateYTimeline *) obj; + BoneTimeline1 *base = static_cast(derived); + return (spine_bone_timeline1) base; +} + +spine_curve_timeline1 spine_translate_y_timeline_cast_to_curve_timeline1(spine_translate_y_timeline obj) { + TranslateYTimeline *derived = (TranslateYTimeline *) obj; + CurveTimeline1 *base = static_cast(derived); + return (spine_curve_timeline1) base; +} + +spine_curve_timeline spine_translate_y_timeline_cast_to_curve_timeline(spine_translate_y_timeline obj) { + TranslateYTimeline *derived = (TranslateYTimeline *) obj; + CurveTimeline *base = static_cast(derived); + return (spine_curve_timeline) base; +} + +spine_timeline spine_translate_y_timeline_cast_to_timeline(spine_translate_y_timeline obj) { + TranslateYTimeline *derived = (TranslateYTimeline *) obj; + Timeline *base = static_cast(derived); + return (spine_timeline) base; +} + +spine_bone_timeline spine_translate_y_timeline_cast_to_bone_timeline(spine_translate_y_timeline obj) { + TranslateYTimeline *derived = (TranslateYTimeline *) obj; + BoneTimeline *base = static_cast(derived); + return (spine_bone_timeline) base; +} + +spine_attachment spine_vertex_attachment_cast_to_attachment(spine_vertex_attachment obj) { + VertexAttachment *derived = (VertexAttachment *) obj; + Attachment *base = static_cast(derived); + return (spine_attachment) base; +} + +// Downcast function implementations +spine_alpha_timeline spine_curve_timeline1_cast_to_alpha_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + AlphaTimeline *derived = static_cast(base); + return (spine_alpha_timeline) derived; +} + +spine_bone_timeline1 spine_curve_timeline1_cast_to_bone_timeline1(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + BoneTimeline1 *derived = static_cast(base); + return (spine_bone_timeline1) derived; +} + +spine_constraint_timeline1 spine_curve_timeline1_cast_to_constraint_timeline1(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + ConstraintTimeline1 *derived = static_cast(base); + return (spine_constraint_timeline1) derived; +} + +spine_path_constraint_position_timeline spine_curve_timeline1_cast_to_path_constraint_position_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + PathConstraintPositionTimeline *derived = static_cast(base); + return (spine_path_constraint_position_timeline) derived; +} + +spine_path_constraint_spacing_timeline spine_curve_timeline1_cast_to_path_constraint_spacing_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + PathConstraintSpacingTimeline *derived = static_cast(base); + return (spine_path_constraint_spacing_timeline) derived; +} + +spine_physics_constraint_damping_timeline spine_curve_timeline1_cast_to_physics_constraint_damping_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + PhysicsConstraintDampingTimeline *derived = static_cast(base); + return (spine_physics_constraint_damping_timeline) derived; +} + +spine_physics_constraint_gravity_timeline spine_curve_timeline1_cast_to_physics_constraint_gravity_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + PhysicsConstraintGravityTimeline *derived = static_cast(base); + return (spine_physics_constraint_gravity_timeline) derived; +} + +spine_physics_constraint_inertia_timeline spine_curve_timeline1_cast_to_physics_constraint_inertia_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + PhysicsConstraintInertiaTimeline *derived = static_cast(base); + return (spine_physics_constraint_inertia_timeline) derived; +} + +spine_physics_constraint_mass_timeline spine_curve_timeline1_cast_to_physics_constraint_mass_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + PhysicsConstraintMassTimeline *derived = static_cast(base); + return (spine_physics_constraint_mass_timeline) derived; +} + +spine_physics_constraint_mix_timeline spine_curve_timeline1_cast_to_physics_constraint_mix_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + PhysicsConstraintMixTimeline *derived = static_cast(base); + return (spine_physics_constraint_mix_timeline) derived; +} + +spine_physics_constraint_strength_timeline spine_curve_timeline1_cast_to_physics_constraint_strength_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + PhysicsConstraintStrengthTimeline *derived = static_cast(base); + return (spine_physics_constraint_strength_timeline) derived; +} + +spine_physics_constraint_timeline spine_curve_timeline1_cast_to_physics_constraint_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + PhysicsConstraintTimeline *derived = static_cast(base); + return (spine_physics_constraint_timeline) derived; +} + +spine_physics_constraint_wind_timeline spine_curve_timeline1_cast_to_physics_constraint_wind_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + PhysicsConstraintWindTimeline *derived = static_cast(base); + return (spine_physics_constraint_wind_timeline) derived; +} + +spine_rotate_timeline spine_curve_timeline1_cast_to_rotate_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + RotateTimeline *derived = static_cast(base); + return (spine_rotate_timeline) derived; +} + +spine_scale_x_timeline spine_curve_timeline1_cast_to_scale_x_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + ScaleXTimeline *derived = static_cast(base); + return (spine_scale_x_timeline) derived; +} + +spine_scale_y_timeline spine_curve_timeline1_cast_to_scale_y_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + ScaleYTimeline *derived = static_cast(base); + return (spine_scale_y_timeline) derived; +} + +spine_shear_x_timeline spine_curve_timeline1_cast_to_shear_x_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + ShearXTimeline *derived = static_cast(base); + return (spine_shear_x_timeline) derived; +} + +spine_shear_y_timeline spine_curve_timeline1_cast_to_shear_y_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + ShearYTimeline *derived = static_cast(base); + return (spine_shear_y_timeline) derived; +} + +spine_slider_mix_timeline spine_curve_timeline1_cast_to_slider_mix_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + SliderMixTimeline *derived = static_cast(base); + return (spine_slider_mix_timeline) derived; +} + +spine_slider_timeline spine_curve_timeline1_cast_to_slider_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + SliderTimeline *derived = static_cast(base); + return (spine_slider_timeline) derived; +} + +spine_translate_x_timeline spine_curve_timeline1_cast_to_translate_x_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + TranslateXTimeline *derived = static_cast(base); + return (spine_translate_x_timeline) derived; +} + +spine_translate_y_timeline spine_curve_timeline1_cast_to_translate_y_timeline(spine_curve_timeline1 obj) { + CurveTimeline1 *base = (CurveTimeline1 *) obj; + TranslateYTimeline *derived = static_cast(base); + return (spine_translate_y_timeline) derived; +} + +spine_alpha_timeline spine_curve_timeline_cast_to_alpha_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + AlphaTimeline *derived = static_cast(base); + return (spine_alpha_timeline) derived; +} + +spine_bone_timeline1 spine_curve_timeline_cast_to_bone_timeline1(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + BoneTimeline1 *derived = static_cast(base); + return (spine_bone_timeline1) derived; +} + +spine_bone_timeline2 spine_curve_timeline_cast_to_bone_timeline2(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + BoneTimeline2 *derived = static_cast(base); + return (spine_bone_timeline2) derived; +} + +spine_constraint_timeline1 spine_curve_timeline_cast_to_constraint_timeline1(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + ConstraintTimeline1 *derived = static_cast(base); + return (spine_constraint_timeline1) derived; +} + +spine_curve_timeline1 spine_curve_timeline_cast_to_curve_timeline1(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + CurveTimeline1 *derived = static_cast(base); + return (spine_curve_timeline1) derived; +} + +spine_deform_timeline spine_curve_timeline_cast_to_deform_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + DeformTimeline *derived = static_cast(base); + return (spine_deform_timeline) derived; +} + +spine_ik_constraint_timeline spine_curve_timeline_cast_to_ik_constraint_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + IkConstraintTimeline *derived = static_cast(base); + return (spine_ik_constraint_timeline) derived; +} + +spine_path_constraint_mix_timeline spine_curve_timeline_cast_to_path_constraint_mix_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PathConstraintMixTimeline *derived = static_cast(base); + return (spine_path_constraint_mix_timeline) derived; +} + +spine_path_constraint_position_timeline spine_curve_timeline_cast_to_path_constraint_position_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PathConstraintPositionTimeline *derived = static_cast(base); + return (spine_path_constraint_position_timeline) derived; +} + +spine_path_constraint_spacing_timeline spine_curve_timeline_cast_to_path_constraint_spacing_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PathConstraintSpacingTimeline *derived = static_cast(base); + return (spine_path_constraint_spacing_timeline) derived; +} + +spine_physics_constraint_damping_timeline spine_curve_timeline_cast_to_physics_constraint_damping_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PhysicsConstraintDampingTimeline *derived = static_cast(base); + return (spine_physics_constraint_damping_timeline) derived; +} + +spine_physics_constraint_gravity_timeline spine_curve_timeline_cast_to_physics_constraint_gravity_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PhysicsConstraintGravityTimeline *derived = static_cast(base); + return (spine_physics_constraint_gravity_timeline) derived; +} + +spine_physics_constraint_inertia_timeline spine_curve_timeline_cast_to_physics_constraint_inertia_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PhysicsConstraintInertiaTimeline *derived = static_cast(base); + return (spine_physics_constraint_inertia_timeline) derived; +} + +spine_physics_constraint_mass_timeline spine_curve_timeline_cast_to_physics_constraint_mass_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PhysicsConstraintMassTimeline *derived = static_cast(base); + return (spine_physics_constraint_mass_timeline) derived; +} + +spine_physics_constraint_mix_timeline spine_curve_timeline_cast_to_physics_constraint_mix_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PhysicsConstraintMixTimeline *derived = static_cast(base); + return (spine_physics_constraint_mix_timeline) derived; +} + +spine_physics_constraint_strength_timeline spine_curve_timeline_cast_to_physics_constraint_strength_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PhysicsConstraintStrengthTimeline *derived = static_cast(base); + return (spine_physics_constraint_strength_timeline) derived; +} + +spine_physics_constraint_timeline spine_curve_timeline_cast_to_physics_constraint_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PhysicsConstraintTimeline *derived = static_cast(base); + return (spine_physics_constraint_timeline) derived; +} + +spine_physics_constraint_wind_timeline spine_curve_timeline_cast_to_physics_constraint_wind_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + PhysicsConstraintWindTimeline *derived = static_cast(base); + return (spine_physics_constraint_wind_timeline) derived; +} + +spine_rgb2_timeline spine_curve_timeline_cast_to_rgb2_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + RGB2Timeline *derived = static_cast(base); + return (spine_rgb2_timeline) derived; +} + +spine_rgba2_timeline spine_curve_timeline_cast_to_rgba2_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + RGBA2Timeline *derived = static_cast(base); + return (spine_rgba2_timeline) derived; +} + +spine_rgba_timeline spine_curve_timeline_cast_to_rgba_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + RGBATimeline *derived = static_cast(base); + return (spine_rgba_timeline) derived; +} + +spine_rgb_timeline spine_curve_timeline_cast_to_rgb_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + RGBTimeline *derived = static_cast(base); + return (spine_rgb_timeline) derived; +} + +spine_rotate_timeline spine_curve_timeline_cast_to_rotate_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + RotateTimeline *derived = static_cast(base); + return (spine_rotate_timeline) derived; +} + +spine_scale_timeline spine_curve_timeline_cast_to_scale_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + ScaleTimeline *derived = static_cast(base); + return (spine_scale_timeline) derived; +} + +spine_scale_x_timeline spine_curve_timeline_cast_to_scale_x_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + ScaleXTimeline *derived = static_cast(base); + return (spine_scale_x_timeline) derived; +} + +spine_scale_y_timeline spine_curve_timeline_cast_to_scale_y_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + ScaleYTimeline *derived = static_cast(base); + return (spine_scale_y_timeline) derived; +} + +spine_shear_timeline spine_curve_timeline_cast_to_shear_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + ShearTimeline *derived = static_cast(base); + return (spine_shear_timeline) derived; +} + +spine_shear_x_timeline spine_curve_timeline_cast_to_shear_x_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + ShearXTimeline *derived = static_cast(base); + return (spine_shear_x_timeline) derived; +} + +spine_shear_y_timeline spine_curve_timeline_cast_to_shear_y_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + ShearYTimeline *derived = static_cast(base); + return (spine_shear_y_timeline) derived; +} + +spine_slider_mix_timeline spine_curve_timeline_cast_to_slider_mix_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + SliderMixTimeline *derived = static_cast(base); + return (spine_slider_mix_timeline) derived; +} + +spine_slider_timeline spine_curve_timeline_cast_to_slider_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + SliderTimeline *derived = static_cast(base); + return (spine_slider_timeline) derived; +} + +spine_slot_curve_timeline spine_curve_timeline_cast_to_slot_curve_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + SlotCurveTimeline *derived = static_cast(base); + return (spine_slot_curve_timeline) derived; +} + +spine_transform_constraint_timeline spine_curve_timeline_cast_to_transform_constraint_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + TransformConstraintTimeline *derived = static_cast(base); + return (spine_transform_constraint_timeline) derived; +} + +spine_translate_timeline spine_curve_timeline_cast_to_translate_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + TranslateTimeline *derived = static_cast(base); + return (spine_translate_timeline) derived; +} + +spine_translate_x_timeline spine_curve_timeline_cast_to_translate_x_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + TranslateXTimeline *derived = static_cast(base); + return (spine_translate_x_timeline) derived; +} + +spine_translate_y_timeline spine_curve_timeline_cast_to_translate_y_timeline(spine_curve_timeline obj) { + CurveTimeline *base = (CurveTimeline *) obj; + TranslateYTimeline *derived = static_cast(base); + return (spine_translate_y_timeline) derived; +} + +spine_alpha_timeline spine_timeline_cast_to_alpha_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + AlphaTimeline *derived = static_cast(base); + return (spine_alpha_timeline) derived; +} + +spine_attachment_timeline spine_timeline_cast_to_attachment_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + AttachmentTimeline *derived = static_cast(base); + return (spine_attachment_timeline) derived; +} + +spine_bone_timeline1 spine_timeline_cast_to_bone_timeline1(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + BoneTimeline1 *derived = static_cast(base); + return (spine_bone_timeline1) derived; +} + +spine_bone_timeline2 spine_timeline_cast_to_bone_timeline2(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + BoneTimeline2 *derived = static_cast(base); + return (spine_bone_timeline2) derived; +} + +spine_constraint_timeline1 spine_timeline_cast_to_constraint_timeline1(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + ConstraintTimeline1 *derived = static_cast(base); + return (spine_constraint_timeline1) derived; +} + +spine_curve_timeline spine_timeline_cast_to_curve_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + CurveTimeline *derived = static_cast(base); + return (spine_curve_timeline) derived; +} + +spine_curve_timeline1 spine_timeline_cast_to_curve_timeline1(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + CurveTimeline1 *derived = static_cast(base); + return (spine_curve_timeline1) derived; +} + +spine_deform_timeline spine_timeline_cast_to_deform_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + DeformTimeline *derived = static_cast(base); + return (spine_deform_timeline) derived; +} + +spine_draw_order_timeline spine_timeline_cast_to_draw_order_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + DrawOrderTimeline *derived = static_cast(base); + return (spine_draw_order_timeline) derived; +} + +spine_event_timeline spine_timeline_cast_to_event_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + EventTimeline *derived = static_cast(base); + return (spine_event_timeline) derived; +} + +spine_ik_constraint_timeline spine_timeline_cast_to_ik_constraint_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + IkConstraintTimeline *derived = static_cast(base); + return (spine_ik_constraint_timeline) derived; +} + +spine_inherit_timeline spine_timeline_cast_to_inherit_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + InheritTimeline *derived = static_cast(base); + return (spine_inherit_timeline) derived; +} + +spine_path_constraint_mix_timeline spine_timeline_cast_to_path_constraint_mix_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PathConstraintMixTimeline *derived = static_cast(base); + return (spine_path_constraint_mix_timeline) derived; +} + +spine_path_constraint_position_timeline spine_timeline_cast_to_path_constraint_position_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PathConstraintPositionTimeline *derived = static_cast(base); + return (spine_path_constraint_position_timeline) derived; +} + +spine_path_constraint_spacing_timeline spine_timeline_cast_to_path_constraint_spacing_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PathConstraintSpacingTimeline *derived = static_cast(base); + return (spine_path_constraint_spacing_timeline) derived; +} + +spine_physics_constraint_damping_timeline spine_timeline_cast_to_physics_constraint_damping_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PhysicsConstraintDampingTimeline *derived = static_cast(base); + return (spine_physics_constraint_damping_timeline) derived; +} + +spine_physics_constraint_gravity_timeline spine_timeline_cast_to_physics_constraint_gravity_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PhysicsConstraintGravityTimeline *derived = static_cast(base); + return (spine_physics_constraint_gravity_timeline) derived; +} + +spine_physics_constraint_inertia_timeline spine_timeline_cast_to_physics_constraint_inertia_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PhysicsConstraintInertiaTimeline *derived = static_cast(base); + return (spine_physics_constraint_inertia_timeline) derived; +} + +spine_physics_constraint_mass_timeline spine_timeline_cast_to_physics_constraint_mass_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PhysicsConstraintMassTimeline *derived = static_cast(base); + return (spine_physics_constraint_mass_timeline) derived; +} + +spine_physics_constraint_mix_timeline spine_timeline_cast_to_physics_constraint_mix_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PhysicsConstraintMixTimeline *derived = static_cast(base); + return (spine_physics_constraint_mix_timeline) derived; +} + +spine_physics_constraint_reset_timeline spine_timeline_cast_to_physics_constraint_reset_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PhysicsConstraintResetTimeline *derived = static_cast(base); + return (spine_physics_constraint_reset_timeline) derived; +} + +spine_physics_constraint_strength_timeline spine_timeline_cast_to_physics_constraint_strength_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PhysicsConstraintStrengthTimeline *derived = static_cast(base); + return (spine_physics_constraint_strength_timeline) derived; +} + +spine_physics_constraint_timeline spine_timeline_cast_to_physics_constraint_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PhysicsConstraintTimeline *derived = static_cast(base); + return (spine_physics_constraint_timeline) derived; +} + +spine_physics_constraint_wind_timeline spine_timeline_cast_to_physics_constraint_wind_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + PhysicsConstraintWindTimeline *derived = static_cast(base); + return (spine_physics_constraint_wind_timeline) derived; +} + +spine_rgb2_timeline spine_timeline_cast_to_rgb2_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + RGB2Timeline *derived = static_cast(base); + return (spine_rgb2_timeline) derived; +} + +spine_rgba2_timeline spine_timeline_cast_to_rgba2_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + RGBA2Timeline *derived = static_cast(base); + return (spine_rgba2_timeline) derived; +} + +spine_rgba_timeline spine_timeline_cast_to_rgba_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + RGBATimeline *derived = static_cast(base); + return (spine_rgba_timeline) derived; +} + +spine_rgb_timeline spine_timeline_cast_to_rgb_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + RGBTimeline *derived = static_cast(base); + return (spine_rgb_timeline) derived; +} + +spine_rotate_timeline spine_timeline_cast_to_rotate_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + RotateTimeline *derived = static_cast(base); + return (spine_rotate_timeline) derived; +} + +spine_scale_timeline spine_timeline_cast_to_scale_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + ScaleTimeline *derived = static_cast(base); + return (spine_scale_timeline) derived; +} + +spine_scale_x_timeline spine_timeline_cast_to_scale_x_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + ScaleXTimeline *derived = static_cast(base); + return (spine_scale_x_timeline) derived; +} + +spine_scale_y_timeline spine_timeline_cast_to_scale_y_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + ScaleYTimeline *derived = static_cast(base); + return (spine_scale_y_timeline) derived; +} + +spine_sequence_timeline spine_timeline_cast_to_sequence_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + SequenceTimeline *derived = static_cast(base); + return (spine_sequence_timeline) derived; +} + +spine_shear_timeline spine_timeline_cast_to_shear_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + ShearTimeline *derived = static_cast(base); + return (spine_shear_timeline) derived; +} + +spine_shear_x_timeline spine_timeline_cast_to_shear_x_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + ShearXTimeline *derived = static_cast(base); + return (spine_shear_x_timeline) derived; +} + +spine_shear_y_timeline spine_timeline_cast_to_shear_y_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + ShearYTimeline *derived = static_cast(base); + return (spine_shear_y_timeline) derived; +} + +spine_slider_mix_timeline spine_timeline_cast_to_slider_mix_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + SliderMixTimeline *derived = static_cast(base); + return (spine_slider_mix_timeline) derived; +} + +spine_slider_timeline spine_timeline_cast_to_slider_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + SliderTimeline *derived = static_cast(base); + return (spine_slider_timeline) derived; +} + +spine_slot_curve_timeline spine_timeline_cast_to_slot_curve_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + SlotCurveTimeline *derived = static_cast(base); + return (spine_slot_curve_timeline) derived; +} + +spine_transform_constraint_timeline spine_timeline_cast_to_transform_constraint_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + TransformConstraintTimeline *derived = static_cast(base); + return (spine_transform_constraint_timeline) derived; +} + +spine_translate_timeline spine_timeline_cast_to_translate_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + TranslateTimeline *derived = static_cast(base); + return (spine_translate_timeline) derived; +} + +spine_translate_x_timeline spine_timeline_cast_to_translate_x_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + TranslateXTimeline *derived = static_cast(base); + return (spine_translate_x_timeline) derived; +} + +spine_translate_y_timeline spine_timeline_cast_to_translate_y_timeline(spine_timeline obj) { + Timeline *base = (Timeline *) obj; + TranslateYTimeline *derived = static_cast(base); + return (spine_translate_y_timeline) derived; +} + +spine_alpha_timeline spine_slot_timeline_cast_to_alpha_timeline(spine_slot_timeline obj) { + SlotTimeline *base = (SlotTimeline *) obj; + AlphaTimeline *derived = static_cast(base); + return (spine_alpha_timeline) derived; +} + +spine_attachment_timeline spine_slot_timeline_cast_to_attachment_timeline(spine_slot_timeline obj) { + SlotTimeline *base = (SlotTimeline *) obj; + AttachmentTimeline *derived = static_cast(base); + return (spine_attachment_timeline) derived; +} + +spine_deform_timeline spine_slot_timeline_cast_to_deform_timeline(spine_slot_timeline obj) { + SlotTimeline *base = (SlotTimeline *) obj; + DeformTimeline *derived = static_cast(base); + return (spine_deform_timeline) derived; +} + +spine_rgb2_timeline spine_slot_timeline_cast_to_rgb2_timeline(spine_slot_timeline obj) { + SlotTimeline *base = (SlotTimeline *) obj; + RGB2Timeline *derived = static_cast(base); + return (spine_rgb2_timeline) derived; +} + +spine_rgba2_timeline spine_slot_timeline_cast_to_rgba2_timeline(spine_slot_timeline obj) { + SlotTimeline *base = (SlotTimeline *) obj; + RGBA2Timeline *derived = static_cast(base); + return (spine_rgba2_timeline) derived; +} + +spine_rgba_timeline spine_slot_timeline_cast_to_rgba_timeline(spine_slot_timeline obj) { + SlotTimeline *base = (SlotTimeline *) obj; + RGBATimeline *derived = static_cast(base); + return (spine_rgba_timeline) derived; +} + +spine_rgb_timeline spine_slot_timeline_cast_to_rgb_timeline(spine_slot_timeline obj) { + SlotTimeline *base = (SlotTimeline *) obj; + RGBTimeline *derived = static_cast(base); + return (spine_rgb_timeline) derived; +} + +spine_sequence_timeline spine_slot_timeline_cast_to_sequence_timeline(spine_slot_timeline obj) { + SlotTimeline *base = (SlotTimeline *) obj; + SequenceTimeline *derived = static_cast(base); + return (spine_sequence_timeline) derived; +} + +spine_slot_curve_timeline spine_slot_timeline_cast_to_slot_curve_timeline(spine_slot_timeline obj) { + SlotTimeline *base = (SlotTimeline *) obj; + SlotCurveTimeline *derived = static_cast(base); + return (spine_slot_curve_timeline) derived; +} + +spine_atlas_attachment_loader spine_attachment_loader_cast_to_atlas_attachment_loader(spine_attachment_loader obj) { + AttachmentLoader *base = (AttachmentLoader *) obj; + AtlasAttachmentLoader *derived = static_cast(base); + return (spine_atlas_attachment_loader) derived; +} + +spine_atlas_region spine_texture_region_cast_to_atlas_region(spine_texture_region obj) { + TextureRegion *base = (TextureRegion *) obj; + AtlasRegion *derived = static_cast(base); + return (spine_atlas_region) derived; +} + +spine_bone spine_posed_cast_to_bone(spine_posed obj) { + Posed *base = (Posed *) obj; + Bone *derived = static_cast(base); + return (spine_bone) derived; +} + +spine_ik_constraint spine_posed_cast_to_ik_constraint(spine_posed obj) { + Posed *base = (Posed *) obj; + IkConstraint *derived = static_cast(base); + return (spine_ik_constraint) derived; +} + +spine_ik_constraint_base spine_posed_cast_to_ik_constraint_base(spine_posed obj) { + Posed *base = (Posed *) obj; + IkConstraintBase *derived = static_cast(base); + return (spine_ik_constraint_base) derived; +} + +spine_path_constraint spine_posed_cast_to_path_constraint(spine_posed obj) { + Posed *base = (Posed *) obj; + PathConstraint *derived = static_cast(base); + return (spine_path_constraint) derived; +} + +spine_path_constraint_base spine_posed_cast_to_path_constraint_base(spine_posed obj) { + Posed *base = (Posed *) obj; + PathConstraintBase *derived = static_cast(base); + return (spine_path_constraint_base) derived; +} + +spine_physics_constraint spine_posed_cast_to_physics_constraint(spine_posed obj) { + Posed *base = (Posed *) obj; + PhysicsConstraint *derived = static_cast(base); + return (spine_physics_constraint) derived; +} + +spine_physics_constraint_base spine_posed_cast_to_physics_constraint_base(spine_posed obj) { + Posed *base = (Posed *) obj; + PhysicsConstraintBase *derived = static_cast(base); + return (spine_physics_constraint_base) derived; +} + +spine_slider spine_posed_cast_to_slider(spine_posed obj) { + Posed *base = (Posed *) obj; + Slider *derived = static_cast(base); + return (spine_slider) derived; +} + +spine_slider_base spine_posed_cast_to_slider_base(spine_posed obj) { + Posed *base = (Posed *) obj; + SliderBase *derived = static_cast(base); + return (spine_slider_base) derived; +} + +spine_slot spine_posed_cast_to_slot(spine_posed obj) { + Posed *base = (Posed *) obj; + Slot *derived = static_cast(base); + return (spine_slot) derived; +} + +spine_transform_constraint spine_posed_cast_to_transform_constraint(spine_posed obj) { + Posed *base = (Posed *) obj; + TransformConstraint *derived = static_cast(base); + return (spine_transform_constraint) derived; +} + +spine_transform_constraint_base spine_posed_cast_to_transform_constraint_base(spine_posed obj) { + Posed *base = (Posed *) obj; + TransformConstraintBase *derived = static_cast(base); + return (spine_transform_constraint_base) derived; +} + +spine_bone spine_posed_active_cast_to_bone(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + Bone *derived = static_cast(base); + return (spine_bone) derived; +} + +spine_ik_constraint spine_posed_active_cast_to_ik_constraint(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + IkConstraint *derived = static_cast(base); + return (spine_ik_constraint) derived; +} + +spine_ik_constraint_base spine_posed_active_cast_to_ik_constraint_base(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + IkConstraintBase *derived = static_cast(base); + return (spine_ik_constraint_base) derived; +} + +spine_path_constraint spine_posed_active_cast_to_path_constraint(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + PathConstraint *derived = static_cast(base); + return (spine_path_constraint) derived; +} + +spine_path_constraint_base spine_posed_active_cast_to_path_constraint_base(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + PathConstraintBase *derived = static_cast(base); + return (spine_path_constraint_base) derived; +} + +spine_physics_constraint spine_posed_active_cast_to_physics_constraint(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + PhysicsConstraint *derived = static_cast(base); + return (spine_physics_constraint) derived; +} + +spine_physics_constraint_base spine_posed_active_cast_to_physics_constraint_base(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + PhysicsConstraintBase *derived = static_cast(base); + return (spine_physics_constraint_base) derived; +} + +spine_slider spine_posed_active_cast_to_slider(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + Slider *derived = static_cast(base); + return (spine_slider) derived; +} + +spine_slider_base spine_posed_active_cast_to_slider_base(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + SliderBase *derived = static_cast(base); + return (spine_slider_base) derived; +} + +spine_transform_constraint spine_posed_active_cast_to_transform_constraint(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + TransformConstraint *derived = static_cast(base); + return (spine_transform_constraint) derived; +} + +spine_transform_constraint_base spine_posed_active_cast_to_transform_constraint_base(spine_posed_active obj) { + PosedActive *base = (PosedActive *) obj; + TransformConstraintBase *derived = static_cast(base); + return (spine_transform_constraint_base) derived; +} + +spine_bone spine_update_cast_to_bone(spine_update obj) { + Update *base = (Update *) obj; + Bone *derived = static_cast(base); + return (spine_bone) derived; +} + +spine_bone_pose spine_update_cast_to_bone_pose(spine_update obj) { + Update *base = (Update *) obj; + BonePose *derived = static_cast(base); + return (spine_bone_pose) derived; +} + +spine_constraint spine_update_cast_to_constraint(spine_update obj) { + Update *base = (Update *) obj; + Constraint *derived = static_cast(base); + return (spine_constraint) derived; +} + +spine_ik_constraint spine_update_cast_to_ik_constraint(spine_update obj) { + Update *base = (Update *) obj; + IkConstraint *derived = static_cast(base); + return (spine_ik_constraint) derived; +} + +spine_ik_constraint_base spine_update_cast_to_ik_constraint_base(spine_update obj) { + Update *base = (Update *) obj; + IkConstraintBase *derived = static_cast(base); + return (spine_ik_constraint_base) derived; +} + +spine_path_constraint spine_update_cast_to_path_constraint(spine_update obj) { + Update *base = (Update *) obj; + PathConstraint *derived = static_cast(base); + return (spine_path_constraint) derived; +} + +spine_path_constraint_base spine_update_cast_to_path_constraint_base(spine_update obj) { + Update *base = (Update *) obj; + PathConstraintBase *derived = static_cast(base); + return (spine_path_constraint_base) derived; +} + +spine_physics_constraint spine_update_cast_to_physics_constraint(spine_update obj) { + Update *base = (Update *) obj; + PhysicsConstraint *derived = static_cast(base); + return (spine_physics_constraint) derived; +} + +spine_physics_constraint_base spine_update_cast_to_physics_constraint_base(spine_update obj) { + Update *base = (Update *) obj; + PhysicsConstraintBase *derived = static_cast(base); + return (spine_physics_constraint_base) derived; +} + +spine_slider spine_update_cast_to_slider(spine_update obj) { + Update *base = (Update *) obj; + Slider *derived = static_cast(base); + return (spine_slider) derived; +} + +spine_slider_base spine_update_cast_to_slider_base(spine_update obj) { + Update *base = (Update *) obj; + SliderBase *derived = static_cast(base); + return (spine_slider_base) derived; +} + +spine_transform_constraint spine_update_cast_to_transform_constraint(spine_update obj) { + Update *base = (Update *) obj; + TransformConstraint *derived = static_cast(base); + return (spine_transform_constraint) derived; +} + +spine_transform_constraint_base spine_update_cast_to_transform_constraint_base(spine_update obj) { + Update *base = (Update *) obj; + TransformConstraintBase *derived = static_cast(base); + return (spine_transform_constraint_base) derived; +} + +spine_bone_data spine_posed_data_cast_to_bone_data(spine_posed_data obj) { + PosedData *base = (PosedData *) obj; + BoneData *derived = static_cast(base); + return (spine_bone_data) derived; +} + +spine_ik_constraint_data spine_posed_data_cast_to_ik_constraint_data(spine_posed_data obj) { + PosedData *base = (PosedData *) obj; + IkConstraintData *derived = static_cast(base); + return (spine_ik_constraint_data) derived; +} + +spine_path_constraint_data spine_posed_data_cast_to_path_constraint_data(spine_posed_data obj) { + PosedData *base = (PosedData *) obj; + PathConstraintData *derived = static_cast(base); + return (spine_path_constraint_data) derived; +} + +spine_physics_constraint_data spine_posed_data_cast_to_physics_constraint_data(spine_posed_data obj) { + PosedData *base = (PosedData *) obj; + PhysicsConstraintData *derived = static_cast(base); + return (spine_physics_constraint_data) derived; +} + +spine_slider_data spine_posed_data_cast_to_slider_data(spine_posed_data obj) { + PosedData *base = (PosedData *) obj; + SliderData *derived = static_cast(base); + return (spine_slider_data) derived; +} + +spine_slot_data spine_posed_data_cast_to_slot_data(spine_posed_data obj) { + PosedData *base = (PosedData *) obj; + SlotData *derived = static_cast(base); + return (spine_slot_data) derived; +} + +spine_transform_constraint_data spine_posed_data_cast_to_transform_constraint_data(spine_posed_data obj) { + PosedData *base = (PosedData *) obj; + TransformConstraintData *derived = static_cast(base); + return (spine_transform_constraint_data) derived; +} + +spine_bone_pose spine_bone_local_cast_to_bone_pose(spine_bone_local obj) { + BoneLocal *base = (BoneLocal *) obj; + BonePose *derived = static_cast(base); + return (spine_bone_pose) derived; +} + +spine_bone_timeline1 spine_bone_timeline_cast_to_bone_timeline1(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + BoneTimeline1 *derived = static_cast(base); + return (spine_bone_timeline1) derived; +} + +spine_bone_timeline2 spine_bone_timeline_cast_to_bone_timeline2(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + BoneTimeline2 *derived = static_cast(base); + return (spine_bone_timeline2) derived; +} + +spine_inherit_timeline spine_bone_timeline_cast_to_inherit_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + InheritTimeline *derived = static_cast(base); + return (spine_inherit_timeline) derived; +} + +spine_rotate_timeline spine_bone_timeline_cast_to_rotate_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + RotateTimeline *derived = static_cast(base); + return (spine_rotate_timeline) derived; +} + +spine_scale_timeline spine_bone_timeline_cast_to_scale_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + ScaleTimeline *derived = static_cast(base); + return (spine_scale_timeline) derived; +} + +spine_scale_x_timeline spine_bone_timeline_cast_to_scale_x_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + ScaleXTimeline *derived = static_cast(base); + return (spine_scale_x_timeline) derived; +} + +spine_scale_y_timeline spine_bone_timeline_cast_to_scale_y_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + ScaleYTimeline *derived = static_cast(base); + return (spine_scale_y_timeline) derived; +} + +spine_shear_timeline spine_bone_timeline_cast_to_shear_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + ShearTimeline *derived = static_cast(base); + return (spine_shear_timeline) derived; +} + +spine_shear_x_timeline spine_bone_timeline_cast_to_shear_x_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + ShearXTimeline *derived = static_cast(base); + return (spine_shear_x_timeline) derived; +} + +spine_shear_y_timeline spine_bone_timeline_cast_to_shear_y_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + ShearYTimeline *derived = static_cast(base); + return (spine_shear_y_timeline) derived; +} + +spine_translate_timeline spine_bone_timeline_cast_to_translate_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + TranslateTimeline *derived = static_cast(base); + return (spine_translate_timeline) derived; +} + +spine_translate_x_timeline spine_bone_timeline_cast_to_translate_x_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + TranslateXTimeline *derived = static_cast(base); + return (spine_translate_x_timeline) derived; +} + +spine_translate_y_timeline spine_bone_timeline_cast_to_translate_y_timeline(spine_bone_timeline obj) { + BoneTimeline *base = (BoneTimeline *) obj; + TranslateYTimeline *derived = static_cast(base); + return (spine_translate_y_timeline) derived; +} + +spine_bounding_box_attachment spine_vertex_attachment_cast_to_bounding_box_attachment(spine_vertex_attachment obj) { + VertexAttachment *base = (VertexAttachment *) obj; + BoundingBoxAttachment *derived = static_cast(base); + return (spine_bounding_box_attachment) derived; +} + +spine_clipping_attachment spine_vertex_attachment_cast_to_clipping_attachment(spine_vertex_attachment obj) { + VertexAttachment *base = (VertexAttachment *) obj; + ClippingAttachment *derived = static_cast(base); + return (spine_clipping_attachment) derived; +} + +spine_mesh_attachment spine_vertex_attachment_cast_to_mesh_attachment(spine_vertex_attachment obj) { + VertexAttachment *base = (VertexAttachment *) obj; + MeshAttachment *derived = static_cast(base); + return (spine_mesh_attachment) derived; +} + +spine_path_attachment spine_vertex_attachment_cast_to_path_attachment(spine_vertex_attachment obj) { + VertexAttachment *base = (VertexAttachment *) obj; + PathAttachment *derived = static_cast(base); + return (spine_path_attachment) derived; +} + +spine_bounding_box_attachment spine_attachment_cast_to_bounding_box_attachment(spine_attachment obj) { + Attachment *base = (Attachment *) obj; + BoundingBoxAttachment *derived = static_cast(base); + return (spine_bounding_box_attachment) derived; +} + +spine_clipping_attachment spine_attachment_cast_to_clipping_attachment(spine_attachment obj) { + Attachment *base = (Attachment *) obj; + ClippingAttachment *derived = static_cast(base); + return (spine_clipping_attachment) derived; +} + +spine_mesh_attachment spine_attachment_cast_to_mesh_attachment(spine_attachment obj) { + Attachment *base = (Attachment *) obj; + MeshAttachment *derived = static_cast(base); + return (spine_mesh_attachment) derived; +} + +spine_path_attachment spine_attachment_cast_to_path_attachment(spine_attachment obj) { + Attachment *base = (Attachment *) obj; + PathAttachment *derived = static_cast(base); + return (spine_path_attachment) derived; +} + +spine_point_attachment spine_attachment_cast_to_point_attachment(spine_attachment obj) { + Attachment *base = (Attachment *) obj; + PointAttachment *derived = static_cast(base); + return (spine_point_attachment) derived; +} + +spine_region_attachment spine_attachment_cast_to_region_attachment(spine_attachment obj) { + Attachment *base = (Attachment *) obj; + RegionAttachment *derived = static_cast(base); + return (spine_region_attachment) derived; +} + +spine_vertex_attachment spine_attachment_cast_to_vertex_attachment(spine_attachment obj) { + Attachment *base = (Attachment *) obj; + VertexAttachment *derived = static_cast(base); + return (spine_vertex_attachment) derived; +} + +spine_constraint_timeline1 spine_constraint_timeline_cast_to_constraint_timeline1(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + ConstraintTimeline1 *derived = static_cast(base); + return (spine_constraint_timeline1) derived; +} + +spine_ik_constraint_timeline spine_constraint_timeline_cast_to_ik_constraint_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + IkConstraintTimeline *derived = static_cast(base); + return (spine_ik_constraint_timeline) derived; +} + +spine_path_constraint_mix_timeline spine_constraint_timeline_cast_to_path_constraint_mix_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PathConstraintMixTimeline *derived = static_cast(base); + return (spine_path_constraint_mix_timeline) derived; +} + +spine_path_constraint_position_timeline spine_constraint_timeline_cast_to_path_constraint_position_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PathConstraintPositionTimeline *derived = static_cast(base); + return (spine_path_constraint_position_timeline) derived; +} + +spine_path_constraint_spacing_timeline spine_constraint_timeline_cast_to_path_constraint_spacing_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PathConstraintSpacingTimeline *derived = static_cast(base); + return (spine_path_constraint_spacing_timeline) derived; +} + +spine_physics_constraint_damping_timeline spine_constraint_timeline_cast_to_physics_constraint_damping_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PhysicsConstraintDampingTimeline *derived = static_cast(base); + return (spine_physics_constraint_damping_timeline) derived; +} + +spine_physics_constraint_gravity_timeline spine_constraint_timeline_cast_to_physics_constraint_gravity_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PhysicsConstraintGravityTimeline *derived = static_cast(base); + return (spine_physics_constraint_gravity_timeline) derived; +} + +spine_physics_constraint_inertia_timeline spine_constraint_timeline_cast_to_physics_constraint_inertia_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PhysicsConstraintInertiaTimeline *derived = static_cast(base); + return (spine_physics_constraint_inertia_timeline) derived; +} + +spine_physics_constraint_mass_timeline spine_constraint_timeline_cast_to_physics_constraint_mass_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PhysicsConstraintMassTimeline *derived = static_cast(base); + return (spine_physics_constraint_mass_timeline) derived; +} + +spine_physics_constraint_mix_timeline spine_constraint_timeline_cast_to_physics_constraint_mix_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PhysicsConstraintMixTimeline *derived = static_cast(base); + return (spine_physics_constraint_mix_timeline) derived; +} + +spine_physics_constraint_reset_timeline spine_constraint_timeline_cast_to_physics_constraint_reset_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PhysicsConstraintResetTimeline *derived = static_cast(base); + return (spine_physics_constraint_reset_timeline) derived; +} + +spine_physics_constraint_strength_timeline spine_constraint_timeline_cast_to_physics_constraint_strength_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PhysicsConstraintStrengthTimeline *derived = static_cast(base); + return (spine_physics_constraint_strength_timeline) derived; +} + +spine_physics_constraint_timeline spine_constraint_timeline_cast_to_physics_constraint_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PhysicsConstraintTimeline *derived = static_cast(base); + return (spine_physics_constraint_timeline) derived; +} + +spine_physics_constraint_wind_timeline spine_constraint_timeline_cast_to_physics_constraint_wind_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + PhysicsConstraintWindTimeline *derived = static_cast(base); + return (spine_physics_constraint_wind_timeline) derived; +} + +spine_slider_mix_timeline spine_constraint_timeline_cast_to_slider_mix_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + SliderMixTimeline *derived = static_cast(base); + return (spine_slider_mix_timeline) derived; +} + +spine_slider_timeline spine_constraint_timeline_cast_to_slider_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + SliderTimeline *derived = static_cast(base); + return (spine_slider_timeline) derived; +} + +spine_transform_constraint_timeline spine_constraint_timeline_cast_to_transform_constraint_timeline(spine_constraint_timeline obj) { + ConstraintTimeline *base = (ConstraintTimeline *) obj; + TransformConstraintTimeline *derived = static_cast(base); + return (spine_transform_constraint_timeline) derived; +} + +spine_deform_timeline spine_slot_curve_timeline_cast_to_deform_timeline(spine_slot_curve_timeline obj) { + SlotCurveTimeline *base = (SlotCurveTimeline *) obj; + DeformTimeline *derived = static_cast(base); + return (spine_deform_timeline) derived; +} + +spine_rgb2_timeline spine_slot_curve_timeline_cast_to_rgb2_timeline(spine_slot_curve_timeline obj) { + SlotCurveTimeline *base = (SlotCurveTimeline *) obj; + RGB2Timeline *derived = static_cast(base); + return (spine_rgb2_timeline) derived; +} + +spine_rgba2_timeline spine_slot_curve_timeline_cast_to_rgba2_timeline(spine_slot_curve_timeline obj) { + SlotCurveTimeline *base = (SlotCurveTimeline *) obj; + RGBA2Timeline *derived = static_cast(base); + return (spine_rgba2_timeline) derived; +} + +spine_rgba_timeline spine_slot_curve_timeline_cast_to_rgba_timeline(spine_slot_curve_timeline obj) { + SlotCurveTimeline *base = (SlotCurveTimeline *) obj; + RGBATimeline *derived = static_cast(base); + return (spine_rgba_timeline) derived; +} + +spine_rgb_timeline spine_slot_curve_timeline_cast_to_rgb_timeline(spine_slot_curve_timeline obj) { + SlotCurveTimeline *base = (SlotCurveTimeline *) obj; + RGBTimeline *derived = static_cast(base); + return (spine_rgb_timeline) derived; +} + +spine_from_rotate spine_from_property_cast_to_from_rotate(spine_from_property obj) { + FromProperty *base = (FromProperty *) obj; + FromRotate *derived = static_cast(base); + return (spine_from_rotate) derived; +} + +spine_from_scale_x spine_from_property_cast_to_from_scale_x(spine_from_property obj) { + FromProperty *base = (FromProperty *) obj; + FromScaleX *derived = static_cast(base); + return (spine_from_scale_x) derived; +} + +spine_from_scale_y spine_from_property_cast_to_from_scale_y(spine_from_property obj) { + FromProperty *base = (FromProperty *) obj; + FromScaleY *derived = static_cast(base); + return (spine_from_scale_y) derived; +} + +spine_from_shear_y spine_from_property_cast_to_from_shear_y(spine_from_property obj) { + FromProperty *base = (FromProperty *) obj; + FromShearY *derived = static_cast(base); + return (spine_from_shear_y) derived; +} + +spine_from_x spine_from_property_cast_to_from_x(spine_from_property obj) { + FromProperty *base = (FromProperty *) obj; + FromX *derived = static_cast(base); + return (spine_from_x) derived; +} + +spine_from_y spine_from_property_cast_to_from_y(spine_from_property obj) { + FromProperty *base = (FromProperty *) obj; + FromY *derived = static_cast(base); + return (spine_from_y) derived; +} + +spine_ik_constraint spine_ik_constraint_base_cast_to_ik_constraint(spine_ik_constraint_base obj) { + IkConstraintBase *base = (IkConstraintBase *) obj; + IkConstraint *derived = static_cast(base); + return (spine_ik_constraint) derived; +} + +spine_ik_constraint spine_constraint_cast_to_ik_constraint(spine_constraint obj) { + Constraint *base = (Constraint *) obj; + IkConstraint *derived = static_cast(base); + return (spine_ik_constraint) derived; +} + +spine_ik_constraint_base spine_constraint_cast_to_ik_constraint_base(spine_constraint obj) { + Constraint *base = (Constraint *) obj; + IkConstraintBase *derived = static_cast(base); + return (spine_ik_constraint_base) derived; +} + +spine_path_constraint spine_constraint_cast_to_path_constraint(spine_constraint obj) { + Constraint *base = (Constraint *) obj; + PathConstraint *derived = static_cast(base); + return (spine_path_constraint) derived; +} + +spine_path_constraint_base spine_constraint_cast_to_path_constraint_base(spine_constraint obj) { + Constraint *base = (Constraint *) obj; + PathConstraintBase *derived = static_cast(base); + return (spine_path_constraint_base) derived; +} + +spine_physics_constraint spine_constraint_cast_to_physics_constraint(spine_constraint obj) { + Constraint *base = (Constraint *) obj; + PhysicsConstraint *derived = static_cast(base); + return (spine_physics_constraint) derived; +} + +spine_physics_constraint_base spine_constraint_cast_to_physics_constraint_base(spine_constraint obj) { + Constraint *base = (Constraint *) obj; + PhysicsConstraintBase *derived = static_cast(base); + return (spine_physics_constraint_base) derived; +} + +spine_slider spine_constraint_cast_to_slider(spine_constraint obj) { + Constraint *base = (Constraint *) obj; + Slider *derived = static_cast(base); + return (spine_slider) derived; +} + +spine_slider_base spine_constraint_cast_to_slider_base(spine_constraint obj) { + Constraint *base = (Constraint *) obj; + SliderBase *derived = static_cast(base); + return (spine_slider_base) derived; +} + +spine_transform_constraint spine_constraint_cast_to_transform_constraint(spine_constraint obj) { + Constraint *base = (Constraint *) obj; + TransformConstraint *derived = static_cast(base); + return (spine_transform_constraint) derived; +} + +spine_transform_constraint_base spine_constraint_cast_to_transform_constraint_base(spine_constraint obj) { + Constraint *base = (Constraint *) obj; + TransformConstraintBase *derived = static_cast(base); + return (spine_transform_constraint_base) derived; +} + +spine_ik_constraint_data spine_constraint_data_cast_to_ik_constraint_data(spine_constraint_data obj) { + ConstraintData *base = (ConstraintData *) obj; + IkConstraintData *derived = static_cast(base); + return (spine_ik_constraint_data) derived; +} + +spine_path_constraint_data spine_constraint_data_cast_to_path_constraint_data(spine_constraint_data obj) { + ConstraintData *base = (ConstraintData *) obj; + PathConstraintData *derived = static_cast(base); + return (spine_path_constraint_data) derived; +} + +spine_physics_constraint_data spine_constraint_data_cast_to_physics_constraint_data(spine_constraint_data obj) { + ConstraintData *base = (ConstraintData *) obj; + PhysicsConstraintData *derived = static_cast(base); + return (spine_physics_constraint_data) derived; +} + +spine_slider_data spine_constraint_data_cast_to_slider_data(spine_constraint_data obj) { + ConstraintData *base = (ConstraintData *) obj; + SliderData *derived = static_cast(base); + return (spine_slider_data) derived; +} + +spine_transform_constraint_data spine_constraint_data_cast_to_transform_constraint_data(spine_constraint_data obj) { + ConstraintData *base = (ConstraintData *) obj; + TransformConstraintData *derived = static_cast(base); + return (spine_transform_constraint_data) derived; +} + +spine_path_constraint spine_path_constraint_base_cast_to_path_constraint(spine_path_constraint_base obj) { + PathConstraintBase *base = (PathConstraintBase *) obj; + PathConstraint *derived = static_cast(base); + return (spine_path_constraint) derived; +} + +spine_path_constraint_position_timeline spine_constraint_timeline1_cast_to_path_constraint_position_timeline(spine_constraint_timeline1 obj) { + ConstraintTimeline1 *base = (ConstraintTimeline1 *) obj; + PathConstraintPositionTimeline *derived = static_cast(base); + return (spine_path_constraint_position_timeline) derived; +} + +spine_path_constraint_spacing_timeline spine_constraint_timeline1_cast_to_path_constraint_spacing_timeline(spine_constraint_timeline1 obj) { + ConstraintTimeline1 *base = (ConstraintTimeline1 *) obj; + PathConstraintSpacingTimeline *derived = static_cast(base); + return (spine_path_constraint_spacing_timeline) derived; +} + +spine_slider_mix_timeline spine_constraint_timeline1_cast_to_slider_mix_timeline(spine_constraint_timeline1 obj) { + ConstraintTimeline1 *base = (ConstraintTimeline1 *) obj; + SliderMixTimeline *derived = static_cast(base); + return (spine_slider_mix_timeline) derived; +} + +spine_slider_timeline spine_constraint_timeline1_cast_to_slider_timeline(spine_constraint_timeline1 obj) { + ConstraintTimeline1 *base = (ConstraintTimeline1 *) obj; + SliderTimeline *derived = static_cast(base); + return (spine_slider_timeline) derived; +} + +spine_physics_constraint spine_physics_constraint_base_cast_to_physics_constraint(spine_physics_constraint_base obj) { + PhysicsConstraintBase *base = (PhysicsConstraintBase *) obj; + PhysicsConstraint *derived = static_cast(base); + return (spine_physics_constraint) derived; +} + +spine_physics_constraint_damping_timeline spine_physics_constraint_timeline_cast_to_physics_constraint_damping_timeline( + spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *base = (PhysicsConstraintTimeline *) obj; + PhysicsConstraintDampingTimeline *derived = static_cast(base); + return (spine_physics_constraint_damping_timeline) derived; +} + +spine_physics_constraint_gravity_timeline spine_physics_constraint_timeline_cast_to_physics_constraint_gravity_timeline( + spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *base = (PhysicsConstraintTimeline *) obj; + PhysicsConstraintGravityTimeline *derived = static_cast(base); + return (spine_physics_constraint_gravity_timeline) derived; +} + +spine_physics_constraint_inertia_timeline spine_physics_constraint_timeline_cast_to_physics_constraint_inertia_timeline( + spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *base = (PhysicsConstraintTimeline *) obj; + PhysicsConstraintInertiaTimeline *derived = static_cast(base); + return (spine_physics_constraint_inertia_timeline) derived; +} + +spine_physics_constraint_mass_timeline spine_physics_constraint_timeline_cast_to_physics_constraint_mass_timeline( + spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *base = (PhysicsConstraintTimeline *) obj; + PhysicsConstraintMassTimeline *derived = static_cast(base); + return (spine_physics_constraint_mass_timeline) derived; +} + +spine_physics_constraint_mix_timeline spine_physics_constraint_timeline_cast_to_physics_constraint_mix_timeline( + spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *base = (PhysicsConstraintTimeline *) obj; + PhysicsConstraintMixTimeline *derived = static_cast(base); + return (spine_physics_constraint_mix_timeline) derived; +} + +spine_physics_constraint_strength_timeline spine_physics_constraint_timeline_cast_to_physics_constraint_strength_timeline( + spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *base = (PhysicsConstraintTimeline *) obj; + PhysicsConstraintStrengthTimeline *derived = static_cast(base); + return (spine_physics_constraint_strength_timeline) derived; +} + +spine_physics_constraint_wind_timeline spine_physics_constraint_timeline_cast_to_physics_constraint_wind_timeline( + spine_physics_constraint_timeline obj) { + PhysicsConstraintTimeline *base = (PhysicsConstraintTimeline *) obj; + PhysicsConstraintWindTimeline *derived = static_cast(base); + return (spine_physics_constraint_wind_timeline) derived; +} + +spine_rotate_timeline spine_bone_timeline1_cast_to_rotate_timeline(spine_bone_timeline1 obj) { + BoneTimeline1 *base = (BoneTimeline1 *) obj; + RotateTimeline *derived = static_cast(base); + return (spine_rotate_timeline) derived; +} + +spine_scale_x_timeline spine_bone_timeline1_cast_to_scale_x_timeline(spine_bone_timeline1 obj) { + BoneTimeline1 *base = (BoneTimeline1 *) obj; + ScaleXTimeline *derived = static_cast(base); + return (spine_scale_x_timeline) derived; +} + +spine_scale_y_timeline spine_bone_timeline1_cast_to_scale_y_timeline(spine_bone_timeline1 obj) { + BoneTimeline1 *base = (BoneTimeline1 *) obj; + ScaleYTimeline *derived = static_cast(base); + return (spine_scale_y_timeline) derived; +} + +spine_shear_x_timeline spine_bone_timeline1_cast_to_shear_x_timeline(spine_bone_timeline1 obj) { + BoneTimeline1 *base = (BoneTimeline1 *) obj; + ShearXTimeline *derived = static_cast(base); + return (spine_shear_x_timeline) derived; +} + +spine_shear_y_timeline spine_bone_timeline1_cast_to_shear_y_timeline(spine_bone_timeline1 obj) { + BoneTimeline1 *base = (BoneTimeline1 *) obj; + ShearYTimeline *derived = static_cast(base); + return (spine_shear_y_timeline) derived; +} + +spine_translate_x_timeline spine_bone_timeline1_cast_to_translate_x_timeline(spine_bone_timeline1 obj) { + BoneTimeline1 *base = (BoneTimeline1 *) obj; + TranslateXTimeline *derived = static_cast(base); + return (spine_translate_x_timeline) derived; +} + +spine_translate_y_timeline spine_bone_timeline1_cast_to_translate_y_timeline(spine_bone_timeline1 obj) { + BoneTimeline1 *base = (BoneTimeline1 *) obj; + TranslateYTimeline *derived = static_cast(base); + return (spine_translate_y_timeline) derived; +} + +spine_scale_timeline spine_bone_timeline2_cast_to_scale_timeline(spine_bone_timeline2 obj) { + BoneTimeline2 *base = (BoneTimeline2 *) obj; + ScaleTimeline *derived = static_cast(base); + return (spine_scale_timeline) derived; +} + +spine_shear_timeline spine_bone_timeline2_cast_to_shear_timeline(spine_bone_timeline2 obj) { + BoneTimeline2 *base = (BoneTimeline2 *) obj; + ShearTimeline *derived = static_cast(base); + return (spine_shear_timeline) derived; +} + +spine_translate_timeline spine_bone_timeline2_cast_to_translate_timeline(spine_bone_timeline2 obj) { + BoneTimeline2 *base = (BoneTimeline2 *) obj; + TranslateTimeline *derived = static_cast(base); + return (spine_translate_timeline) derived; +} + +spine_slider spine_slider_base_cast_to_slider(spine_slider_base obj) { + SliderBase *base = (SliderBase *) obj; + Slider *derived = static_cast(base); + return (spine_slider) derived; +} + +spine_to_rotate spine_to_property_cast_to_to_rotate(spine_to_property obj) { + ToProperty *base = (ToProperty *) obj; + ToRotate *derived = static_cast(base); + return (spine_to_rotate) derived; +} + +spine_to_scale_x spine_to_property_cast_to_to_scale_x(spine_to_property obj) { + ToProperty *base = (ToProperty *) obj; + ToScaleX *derived = static_cast(base); + return (spine_to_scale_x) derived; +} + +spine_to_scale_y spine_to_property_cast_to_to_scale_y(spine_to_property obj) { + ToProperty *base = (ToProperty *) obj; + ToScaleY *derived = static_cast(base); + return (spine_to_scale_y) derived; +} + +spine_to_shear_y spine_to_property_cast_to_to_shear_y(spine_to_property obj) { + ToProperty *base = (ToProperty *) obj; + ToShearY *derived = static_cast(base); + return (spine_to_shear_y) derived; +} + +spine_to_x spine_to_property_cast_to_to_x(spine_to_property obj) { + ToProperty *base = (ToProperty *) obj; + ToX *derived = static_cast(base); + return (spine_to_x) derived; +} + +spine_to_y spine_to_property_cast_to_to_y(spine_to_property obj) { + ToProperty *base = (ToProperty *) obj; + ToY *derived = static_cast(base); + return (spine_to_y) derived; +} + +spine_transform_constraint spine_transform_constraint_base_cast_to_transform_constraint(spine_transform_constraint_base obj) { + TransformConstraintBase *base = (TransformConstraintBase *) obj; + TransformConstraint *derived = static_cast(base); + return (spine_transform_constraint) derived; +} diff --git a/spine-c/src/generated/casts.h b/spine-c/src/generated/casts.h new file mode 100644 index 000000000..05dcce939 --- /dev/null +++ b/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 */ diff --git a/spine-c/src/generated/clipping_attachment.cpp b/spine-c/src/generated/clipping_attachment.cpp index 0c0148614..e7bda2492 100644 --- a/spine-c/src/generated/clipping_attachment.cpp +++ b/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 *) 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 *) 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 *) 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(); } diff --git a/spine-c/src/generated/constraint_timeline1.cpp b/spine-c/src/generated/constraint_timeline1.cpp index 4ea358017..d8ae2f214 100644 --- a/spine-c/src/generated/constraint_timeline1.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/curve_timeline.cpp b/spine-c/src/generated/curve_timeline.cpp index 42a7b81ed..057656949 100644 --- a/spine-c/src/generated/curve_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/curve_timeline1.cpp b/spine-c/src/generated/curve_timeline1.cpp index 3c350661d..e9c39cbb8 100644 --- a/spine-c/src/generated/curve_timeline1.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/deform_timeline.cpp b/spine-c/src/generated/deform_timeline.cpp index aac612079..0a1db2b3d 100644 --- a/spine-c/src/generated/deform_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/draw_order_timeline.cpp b/spine-c/src/generated/draw_order_timeline.cpp index cab84548f..cc42fbf16 100644 --- a/spine-c/src/generated/draw_order_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/event_timeline.cpp b/spine-c/src/generated/event_timeline.cpp index 88c4e82cf..7aa61592d 100644 --- a/spine-c/src/generated/event_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/ik_constraint.cpp b/spine-c/src/generated/ik_constraint.cpp index 3dc6ce1dd..637582583 100644 --- a/spine-c/src/generated/ik_constraint.cpp +++ b/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); } diff --git a/spine-c/src/generated/ik_constraint_base.cpp b/spine-c/src/generated/ik_constraint_base.cpp index f0dcfd8e3..cd16c7f65 100644 --- a/spine-c/src/generated/ik_constraint_base.cpp +++ b/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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + IkConstraintBase *_self = (IkConstraintBase *) self; _self->resetConstrained(); } void spine_ik_constraint_base_constrained(spine_ik_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + IkConstraintBase *_self = (IkConstraintBase *) self; _self->constrained(); } bool spine_ik_constraint_base_is_pose_equal_to_applied(spine_ik_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + IkConstraintBase *_self = (IkConstraintBase *) self; return _self->isPoseEqualToApplied(); } bool spine_ik_constraint_base_is_active(spine_ik_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + IkConstraintBase *_self = (IkConstraintBase *) self; return _self->isActive(); } void spine_ik_constraint_base_set_active(spine_ik_constraint_base self, bool active) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + IkConstraintBase *_self = (IkConstraintBase *) self; _self->setActive(active); } spine_rtti spine_ik_constraint_base_get_rtti(spine_ik_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + IkConstraintBase *_self = (IkConstraintBase *) self; _self->sort(*((Skeleton *) skeleton)); } bool spine_ik_constraint_base_is_source_active(spine_ik_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + IkConstraintBase *_self = (IkConstraintBase *) self; _self->update(*((Skeleton *) skeleton), (Physics) physics); } diff --git a/spine-c/src/generated/ik_constraint_data.cpp b/spine-c/src/generated/ik_constraint_data.cpp index 8bd68ffc2..3a6d3f4e8 100644 --- a/spine-c/src/generated/ik_constraint_data.cpp +++ b/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 *_self = (ConstraintDataGeneric *) (IkConstraintData *) - self; + IkConstraintData *_self = (IkConstraintData *) self; return _self->getName().buffer(); } bool spine_ik_constraint_data_get_skin_required(spine_ik_constraint_data self) { - ConstraintDataGeneric *_self = (ConstraintDataGeneric *) (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 *_self = (ConstraintDataGeneric *) (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 *_self = (ConstraintDataGeneric *) (IkConstraintData *) - self; + IkConstraintData *_self = (IkConstraintData *) self; _self->setSkinRequired(skinRequired); } diff --git a/spine-c/src/generated/ik_constraint_timeline.cpp b/spine-c/src/generated/ik_constraint_timeline.cpp index e1440331f..dcc42d7d4 100644 --- a/spine-c/src/generated/ik_constraint_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/inherit_timeline.cpp b/spine-c/src/generated/inherit_timeline.cpp index c449771b3..8f03ceb1a 100644 --- a/spine-c/src/generated/inherit_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/mesh_attachment.cpp b/spine-c/src/generated/mesh_attachment.cpp index d8729ea74..78dfa5bef 100644 --- a/spine-c/src/generated/mesh_attachment.cpp +++ b/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 *) 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 *) 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 *) 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(); } diff --git a/spine-c/src/generated/path_attachment.cpp b/spine-c/src/generated/path_attachment.cpp index 2531f616e..67b9e21dc 100644 --- a/spine-c/src/generated/path_attachment.cpp +++ b/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 *) 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 *) 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 *) 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(); } diff --git a/spine-c/src/generated/path_constraint.cpp b/spine-c/src/generated/path_constraint.cpp index 2093b60b8..86060582d 100644 --- a/spine-c/src/generated/path_constraint.cpp +++ b/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); } diff --git a/spine-c/src/generated/path_constraint_base.cpp b/spine-c/src/generated/path_constraint_base.cpp index 2804d54fc..d2d46aadc 100644 --- a/spine-c/src/generated/path_constraint_base.cpp +++ b/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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + PathConstraintBase *_self = (PathConstraintBase *) self; _self->resetConstrained(); } void spine_path_constraint_base_constrained(spine_path_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + PathConstraintBase *_self = (PathConstraintBase *) self; _self->constrained(); } bool spine_path_constraint_base_is_pose_equal_to_applied(spine_path_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + PathConstraintBase *_self = (PathConstraintBase *) self; return _self->isPoseEqualToApplied(); } bool spine_path_constraint_base_is_active(spine_path_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + PathConstraintBase *_self = (PathConstraintBase *) self; return _self->isActive(); } void spine_path_constraint_base_set_active(spine_path_constraint_base self, bool active) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + PathConstraintBase *_self = (PathConstraintBase *) self; _self->setActive(active); } spine_rtti spine_path_constraint_base_get_rtti(spine_path_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + PathConstraintBase *_self = (PathConstraintBase *) self; _self->sort(*((Skeleton *) skeleton)); } bool spine_path_constraint_base_is_source_active(spine_path_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + PathConstraintBase *_self = (PathConstraintBase *) self; _self->update(*((Skeleton *) skeleton), (Physics) physics); } diff --git a/spine-c/src/generated/path_constraint_data.cpp b/spine-c/src/generated/path_constraint_data.cpp index 18419a407..7abc14843 100644 --- a/spine-c/src/generated/path_constraint_data.cpp +++ b/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 - *_self = (ConstraintDataGeneric *) (PathConstraintData *) self; + PathConstraintData *_self = (PathConstraintData *) self; return _self->getName().buffer(); } bool spine_path_constraint_data_get_skin_required(spine_path_constraint_data self) { - ConstraintDataGeneric - *_self = (ConstraintDataGeneric *) (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 - *_self = (ConstraintDataGeneric *) (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 - *_self = (ConstraintDataGeneric *) (PathConstraintData *) self; + PathConstraintData *_self = (PathConstraintData *) self; _self->setSkinRequired(skinRequired); } diff --git a/spine-c/src/generated/path_constraint_mix_timeline.cpp b/spine-c/src/generated/path_constraint_mix_timeline.cpp index 9f106947a..e6b00db68 100644 --- a/spine-c/src/generated/path_constraint_mix_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/path_constraint_position_timeline.cpp b/spine-c/src/generated/path_constraint_position_timeline.cpp index 42922241e..b1a357305 100644 --- a/spine-c/src/generated/path_constraint_position_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/path_constraint_spacing_timeline.cpp b/spine-c/src/generated/path_constraint_spacing_timeline.cpp index 5ccf19c38..af7f85d89 100644 --- a/spine-c/src/generated/path_constraint_spacing_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/physics_constraint.cpp b/spine-c/src/generated/physics_constraint.cpp index 573863102..6f3a42327 100644 --- a/spine-c/src/generated/physics_constraint.cpp +++ b/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); } diff --git a/spine-c/src/generated/physics_constraint_base.cpp b/spine-c/src/generated/physics_constraint_base.cpp index 108079119..ad3549d1d 100644 --- a/spine-c/src/generated/physics_constraint_base.cpp +++ b/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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self; _self->resetConstrained(); } void spine_physics_constraint_base_constrained(spine_physics_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self; _self->constrained(); } bool spine_physics_constraint_base_is_pose_equal_to_applied(spine_physics_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self; return _self->isPoseEqualToApplied(); } bool spine_physics_constraint_base_is_active(spine_physics_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self; return _self->isActive(); } void spine_physics_constraint_base_set_active(spine_physics_constraint_base self, bool active) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self; _self->setActive(active); } spine_rtti spine_physics_constraint_base_get_rtti(spine_physics_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self; _self->sort(*((Skeleton *) skeleton)); } bool spine_physics_constraint_base_is_source_active(spine_physics_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) self; _self->update(*((Skeleton *) skeleton), (Physics) physics); } diff --git a/spine-c/src/generated/physics_constraint_damping_timeline.cpp b/spine-c/src/generated/physics_constraint_damping_timeline.cpp index 81fbf286b..a79d7343f 100644 --- a/spine-c/src/generated/physics_constraint_damping_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/physics_constraint_data.cpp b/spine-c/src/generated/physics_constraint_data.cpp index 0381ebf56..2fef4c8f2 100644 --- a/spine-c/src/generated/physics_constraint_data.cpp +++ b/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 - *_self = (ConstraintDataGeneric *) (PhysicsConstraintData *) self; + PhysicsConstraintData *_self = (PhysicsConstraintData *) self; return _self->getName().buffer(); } bool spine_physics_constraint_data_get_skin_required(spine_physics_constraint_data self) { - ConstraintDataGeneric - *_self = (ConstraintDataGeneric *) (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 - *_self = (ConstraintDataGeneric *) (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 - *_self = (ConstraintDataGeneric *) (PhysicsConstraintData *) self; + PhysicsConstraintData *_self = (PhysicsConstraintData *) self; _self->setSkinRequired(skinRequired); } diff --git a/spine-c/src/generated/physics_constraint_gravity_timeline.cpp b/spine-c/src/generated/physics_constraint_gravity_timeline.cpp index 0beb044ac..358015873 100644 --- a/spine-c/src/generated/physics_constraint_gravity_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/physics_constraint_inertia_timeline.cpp b/spine-c/src/generated/physics_constraint_inertia_timeline.cpp index f30cb82c0..b42f82faf 100644 --- a/spine-c/src/generated/physics_constraint_inertia_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/physics_constraint_mass_timeline.cpp b/spine-c/src/generated/physics_constraint_mass_timeline.cpp index f07d431f8..b392e9ef0 100644 --- a/spine-c/src/generated/physics_constraint_mass_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/physics_constraint_mix_timeline.cpp b/spine-c/src/generated/physics_constraint_mix_timeline.cpp index b0c248d27..c8dedc629 100644 --- a/spine-c/src/generated/physics_constraint_mix_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/physics_constraint_reset_timeline.cpp b/spine-c/src/generated/physics_constraint_reset_timeline.cpp index 934575ec7..6fb5a45ae 100644 --- a/spine-c/src/generated/physics_constraint_reset_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/physics_constraint_strength_timeline.cpp b/spine-c/src/generated/physics_constraint_strength_timeline.cpp index 1dc2c2614..c139fb1bd 100644 --- a/spine-c/src/generated/physics_constraint_strength_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/physics_constraint_timeline.cpp b/spine-c/src/generated/physics_constraint_timeline.cpp index edc25c73b..dcad4cb73 100644 --- a/spine-c/src/generated/physics_constraint_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/physics_constraint_wind_timeline.cpp b/spine-c/src/generated/physics_constraint_wind_timeline.cpp index 8a5170055..faab05df0 100644 --- a/spine-c/src/generated/physics_constraint_wind_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/point_attachment.cpp b/spine-c/src/generated/point_attachment.cpp index 9c3fd9644..293753c79 100644 --- a/spine-c/src/generated/point_attachment.cpp +++ b/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(); } diff --git a/spine-c/src/generated/region_attachment.cpp b/spine-c/src/generated/region_attachment.cpp index 0f2ef47bb..124b9b8d5 100644 --- a/spine-c/src/generated/region_attachment.cpp +++ b/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(); } diff --git a/spine-c/src/generated/rgb2_timeline.cpp b/spine-c/src/generated/rgb2_timeline.cpp index fdcf4ff17..f2b706bd3 100644 --- a/spine-c/src/generated/rgb2_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/rgb_timeline.cpp b/spine-c/src/generated/rgb_timeline.cpp index b51f33c23..4d90b6b53 100644 --- a/spine-c/src/generated/rgb_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/rgba2_timeline.cpp b/spine-c/src/generated/rgba2_timeline.cpp index 938953e97..eacfbf47a 100644 --- a/spine-c/src/generated/rgba2_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/rgba_timeline.cpp b/spine-c/src/generated/rgba_timeline.cpp index 384ab4fe3..5a7fa5033 100644 --- a/spine-c/src/generated/rgba_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/rotate_timeline.cpp b/spine-c/src/generated/rotate_timeline.cpp index 98f290063..4408dbd6e 100644 --- a/spine-c/src/generated/rotate_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/scale_timeline.cpp b/spine-c/src/generated/scale_timeline.cpp index c7969f1c7..dbef1f539 100644 --- a/spine-c/src/generated/scale_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/scale_x_timeline.cpp b/spine-c/src/generated/scale_x_timeline.cpp index 779aec5db..322e89680 100644 --- a/spine-c/src/generated/scale_x_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/scale_y_timeline.cpp b/spine-c/src/generated/scale_y_timeline.cpp index 90154f926..1111e46f4 100644 --- a/spine-c/src/generated/scale_y_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/sequence_timeline.cpp b/spine-c/src/generated/sequence_timeline.cpp index 669f485d2..d9ce5bc11 100644 --- a/spine-c/src/generated/sequence_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/shear_timeline.cpp b/spine-c/src/generated/shear_timeline.cpp index 7c0682c12..1a34af5cd 100644 --- a/spine-c/src/generated/shear_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/shear_x_timeline.cpp b/spine-c/src/generated/shear_x_timeline.cpp index c4aaabfcf..51514d96a 100644 --- a/spine-c/src/generated/shear_x_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/shear_y_timeline.cpp b/spine-c/src/generated/shear_y_timeline.cpp index 11ff06e1e..71771177f 100644 --- a/spine-c/src/generated/shear_y_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/slider.cpp b/spine-c/src/generated/slider.cpp index 39cc7460f..d68ada84d 100644 --- a/spine-c/src/generated/slider.cpp +++ b/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); } diff --git a/spine-c/src/generated/slider_base.cpp b/spine-c/src/generated/slider_base.cpp index dbeb5ec27..eec3055ae 100644 --- a/spine-c/src/generated/slider_base.cpp +++ b/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 *_self = (ConstraintGeneric *) (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 *_self = (ConstraintGeneric *) (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 *_self = (ConstraintGeneric *) (SliderBase *) self; + SliderBase *_self = (SliderBase *) self; return (spine_slider_pose) &_self->getAppliedPose(); } void spine_slider_base_reset_constrained(spine_slider_base self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + SliderBase *_self = (SliderBase *) self; _self->resetConstrained(); } void spine_slider_base_constrained(spine_slider_base self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + SliderBase *_self = (SliderBase *) self; _self->constrained(); } bool spine_slider_base_is_pose_equal_to_applied(spine_slider_base self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + SliderBase *_self = (SliderBase *) self; return _self->isPoseEqualToApplied(); } bool spine_slider_base_is_active(spine_slider_base self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + SliderBase *_self = (SliderBase *) self; return _self->isActive(); } void spine_slider_base_set_active(spine_slider_base self, bool active) { - ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + SliderBase *_self = (SliderBase *) self; _self->setActive(active); } spine_rtti spine_slider_base_get_rtti(spine_slider_base self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + SliderBase *_self = (SliderBase *) self; return (spine_rtti) &_self->getRTTI(); } void spine_slider_base_sort(spine_slider_base self, spine_skeleton skeleton) { - ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + SliderBase *_self = (SliderBase *) self; _self->sort(*((Skeleton *) skeleton)); } bool spine_slider_base_is_source_active(spine_slider_base self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (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 *_self = (ConstraintGeneric *) (SliderBase *) self; + SliderBase *_self = (SliderBase *) self; _self->update(*((Skeleton *) skeleton), (Physics) physics); } diff --git a/spine-c/src/generated/slider_data.cpp b/spine-c/src/generated/slider_data.cpp index 8c6766fd0..b1b122f9b 100644 --- a/spine-c/src/generated/slider_data.cpp +++ b/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 *_self = (ConstraintDataGeneric *) (SliderData *) self; + SliderData *_self = (SliderData *) self; return _self->getName().buffer(); } bool spine_slider_data_get_skin_required(spine_slider_data self) { - ConstraintDataGeneric *_self = (ConstraintDataGeneric *) (SliderData *) self; + SliderData *_self = (SliderData *) self; return _self->getSkinRequired(); } spine_slider_pose spine_slider_data_get_setup_pose(spine_slider_data self) { - ConstraintDataGeneric *_self = (ConstraintDataGeneric *) (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 *_self = (ConstraintDataGeneric *) (SliderData *) self; + SliderData *_self = (SliderData *) self; _self->setSkinRequired(skinRequired); } diff --git a/spine-c/src/generated/slider_mix_timeline.cpp b/spine-c/src/generated/slider_mix_timeline.cpp index 8ec070633..fe924b341 100644 --- a/spine-c/src/generated/slider_mix_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/slider_timeline.cpp b/spine-c/src/generated/slider_timeline.cpp index 349cfb18e..828da720c 100644 --- a/spine-c/src/generated/slider_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/slot.cpp b/spine-c/src/generated/slot.cpp index 7d510318d..532514122 100644 --- a/spine-c/src/generated/slot.cpp +++ b/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 *_self = (PosedGeneric *) (Slot *) self; + Slot *_self = (Slot *) self; return (spine_slot_data) &_self->getData(); } spine_slot_pose spine_slot_get_pose(spine_slot self) { - PosedGeneric *_self = (PosedGeneric *) (Slot *) self; + Slot *_self = (Slot *) self; return (spine_slot_pose) &_self->getPose(); } spine_slot_pose spine_slot_get_applied_pose(spine_slot self) { - PosedGeneric *_self = (PosedGeneric *) (Slot *) self; + Slot *_self = (Slot *) self; return (spine_slot_pose) &_self->getAppliedPose(); } void spine_slot_reset_constrained(spine_slot self) { - PosedGeneric *_self = (PosedGeneric *) (Slot *) self; + Slot *_self = (Slot *) self; _self->resetConstrained(); } void spine_slot_constrained(spine_slot self) { - PosedGeneric *_self = (PosedGeneric *) (Slot *) self; + Slot *_self = (Slot *) self; _self->constrained(); } bool spine_slot_is_pose_equal_to_applied(spine_slot self) { - PosedGeneric *_self = (PosedGeneric *) (Slot *) self; + Slot *_self = (Slot *) self; return _self->isPoseEqualToApplied(); } diff --git a/spine-c/src/generated/slot_curve_timeline.cpp b/spine-c/src/generated/slot_curve_timeline.cpp index 58df43c69..4c4dbc522 100644 --- a/spine-c/src/generated/slot_curve_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/slot_data.cpp b/spine-c/src/generated/slot_data.cpp index c5e531a7f..0e62bc177 100644 --- a/spine-c/src/generated/slot_data.cpp +++ b/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 *_self = (PosedDataGeneric *) (SlotData *) self; + SlotData *_self = (SlotData *) self; return (spine_slot_pose) &_self->getSetupPose(); } const char *spine_slot_data_get_name(spine_slot_data self) { - PosedDataGeneric *_self = (PosedDataGeneric *) (SlotData *) self; + SlotData *_self = (SlotData *) self; return _self->getName().buffer(); } bool spine_slot_data_get_skin_required(spine_slot_data self) { - PosedDataGeneric *_self = (PosedDataGeneric *) (SlotData *) self; + SlotData *_self = (SlotData *) self; return _self->getSkinRequired(); } void spine_slot_data_set_skin_required(spine_slot_data self, bool skinRequired) { - PosedDataGeneric *_self = (PosedDataGeneric *) (SlotData *) self; + SlotData *_self = (SlotData *) self; _self->setSkinRequired(skinRequired); } diff --git a/spine-c/src/generated/track_entry.cpp b/spine-c/src/generated/track_entry.cpp index c3fd2ecd3..014b5ddfc 100644 --- a/spine-c/src/generated/track_entry.cpp +++ b/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(); } diff --git a/spine-c/src/generated/transform_constraint.cpp b/spine-c/src/generated/transform_constraint.cpp index 5f75845e9..f7bf76e41 100644 --- a/spine-c/src/generated/transform_constraint.cpp +++ b/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); } diff --git a/spine-c/src/generated/transform_constraint_base.cpp b/spine-c/src/generated/transform_constraint_base.cpp index fcf471759..f7a41621f 100644 --- a/spine-c/src/generated/transform_constraint_base.cpp +++ b/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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) self; _self->resetConstrained(); } void spine_transform_constraint_base_constrained(spine_transform_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) self; _self->constrained(); } bool spine_transform_constraint_base_is_pose_equal_to_applied(spine_transform_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) self; return _self->isPoseEqualToApplied(); } bool spine_transform_constraint_base_is_active(spine_transform_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) self; return _self->isActive(); } void spine_transform_constraint_base_set_active(spine_transform_constraint_base self, bool active) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) self; _self->setActive(active); } spine_rtti spine_transform_constraint_base_get_rtti(spine_transform_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) self; _self->sort(*((Skeleton *) skeleton)); } bool spine_transform_constraint_base_is_source_active(spine_transform_constraint_base self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (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 - *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) self; _self->update(*((Skeleton *) skeleton), (Physics) physics); } diff --git a/spine-c/src/generated/transform_constraint_data.cpp b/spine-c/src/generated/transform_constraint_data.cpp index 24e15985b..337216180 100644 --- a/spine-c/src/generated/transform_constraint_data.cpp +++ b/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 - *_self = (ConstraintDataGeneric *) (TransformConstraintData *) self; + TransformConstraintData *_self = (TransformConstraintData *) self; return _self->getName().buffer(); } bool spine_transform_constraint_data_get_skin_required(spine_transform_constraint_data self) { - ConstraintDataGeneric - *_self = (ConstraintDataGeneric *) (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 - *_self = (ConstraintDataGeneric *) (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 - *_self = (ConstraintDataGeneric *) (TransformConstraintData *) self; + TransformConstraintData *_self = (TransformConstraintData *) self; _self->setSkinRequired(skinRequired); } diff --git a/spine-c/src/generated/transform_constraint_timeline.cpp b/spine-c/src/generated/transform_constraint_timeline.cpp index feb3637e3..1e4a4daa1 100644 --- a/spine-c/src/generated/transform_constraint_timeline.cpp +++ b/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(); } diff --git a/spine-c/src/generated/translate_timeline.cpp b/spine-c/src/generated/translate_timeline.cpp index 4b73a6838..8fcd2c36a 100644 --- a/spine-c/src/generated/translate_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/translate_x_timeline.cpp b/spine-c/src/generated/translate_x_timeline.cpp index fc501fcac..35e9fa2b9 100644 --- a/spine-c/src/generated/translate_x_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/translate_y_timeline.cpp b/spine-c/src/generated/translate_y_timeline.cpp index 151411454..8c51ee11e 100644 --- a/spine-c/src/generated/translate_y_timeline.cpp +++ b/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 *) 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(); } diff --git a/spine-c/src/generated/vertex_attachment.cpp b/spine-c/src/generated/vertex_attachment.cpp index 9d1aea708..2190826ce 100644 --- a/spine-c/src/generated/vertex_attachment.cpp +++ b/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(); } diff --git a/spine-ue/Plugins/SpinePlugin/Source/SpinePlugin/Private/SpineSkeletonAnimationComponent.cpp b/spine-ue/Plugins/SpinePlugin/Source/SpinePlugin/Private/SpineSkeletonAnimationComponent.cpp index ec283db16..90d8c9ef4 100644 --- a/spine-ue/Plugins/SpinePlugin/Source/SpinePlugin/Private/SpineSkeletonAnimationComponent.cpp +++ b/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()) { diff --git a/todos/todos.md b/todos/todos.md index 80e6b05a0..63cd63e16 100644 --- a/todos/todos.md +++ b/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