[c] Codegen can generate raw json (--export-json), builds super/sub and inheritance maps for OOP languages like Swift/Dart

spine-c/build.sh

@@ -45,8 +45,6 @@ if [ "$1" = "codegen" ]; then
         exit 1
     fi
 
-    ../formatters/format-cpp.sh
-
     log_summary "✓ Code generation successful"
     exit 0
 fi

spine-c/codegen/src/index.ts

@@ -6,7 +6,7 @@ import { checkConstNonConstConflicts, checkFieldAccessorConflicts, checkMethodTy
 import { isTypeExcluded, loadExclusions } from './exclusions';
 import { generateArrays, generateTypes } from './ir-generator';
 import { extractTypes } from './type-extractor';
-import type { ClassOrStruct } from './types';
+import type { ClassOrStruct, Method } from './types';
 import { toSnakeCase } from './types';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -71,20 +71,30 @@ export async function generate() {
     const { cTypes, cEnums } = await generateTypes(types, exclusions, allExtractedTypes);
     const cArrayTypes = await generateArrays(types, arrayType, exclusions);
 
-    // Build inheritance relationships including template classes
+    // Build interface/pure type information first
+    const isInterface = buildInterfaceMap(allExtractedTypes.filter(t => t.kind !== 'enum') as ClassOrStruct[]);
+
+    // Build inheritance structure
+    const inheritance = buildInheritanceMap(
+        allExtractedTypes.filter(t => t.kind !== 'enum') as ClassOrStruct[],
+        types.filter(t => t.kind !== 'enum') as ClassOrStruct[],
+        isInterface
+    );
+
+    // Build legacy maps for RTTI switching (still needed)
     const supertypes = buildSupertypesMap(allExtractedTypes.filter(t => t.kind !== 'enum') as ClassOrStruct[], types.filter(t => t.kind !== 'enum') as ClassOrStruct[]);
+    const subtypes = buildSubtypesMap(supertypes);
 
-    console.log('Built supertypes map with', Object.keys(supertypes).length, 'entries');
-    for (const [child, supertypeList] of Object.entries(supertypes)) {
-        if (child.includes('constraint')) {
-            console.log(`  ${child} -> [${supertypeList.join(', ')}]`);
+    console.log('Built dart inheritance map with', Object.keys(inheritance).length, 'entries');
+    for (const [child, info] of Object.entries(inheritance)) {
+        if (child.includes('constraint') && (info.extends || info.mixins.length > 0)) {
+            const extendsStr = info.extends ? `extends ${info.extends}` : '';
+            const mixinsStr = info.mixins.length > 0 ? `with ${info.mixins.join(', ')}` : '';
+            console.log(`  ${child} ${extendsStr} ${mixinsStr}`.trim());
         }
     }
 
-    // Build subtypes map (opposite of supertypes)  
-    const subtypes = buildSubtypesMap(supertypes);
-    
-    return { cTypes, cEnums, cArrayTypes, supertypes, subtypes };
+    return { cTypes, cEnums, cArrayTypes, inheritance, supertypes, subtypes, isInterface };
 }
 
 /** Build supertypes map for inheritance relationships, including template classes */
@@ -154,7 +164,7 @@ function findNonTemplateSupertypes(type: ClassOrStruct, typeMap: Map<string, Cla
 /** Build subtypes map from supertypes data */
 function buildSubtypesMap(supertypes: Record<string, string[]>): Record<string, string[]> {
     const subtypes: Record<string, string[]> = {};
-    
+
     // For each type and its supertypes, add this type to each supertype's subtypes list
     for (const [childType, supertypeList] of Object.entries(supertypes)) {
         for (const supertype of supertypeList) {
@@ -166,10 +176,129 @@ function buildSubtypesMap(supertypes: Record<string, string[]>): Record<string,
             }
         }
     }
-    
+
     return subtypes;
 }
 
+/** Build interface map to identify pure/interface types */
+function buildInterfaceMap(allTypes: ClassOrStruct[]): Record<string, boolean> {
+    const interfaces: Record<string, boolean> = {};
+
+    for (const type of allTypes) {
+        const cName = `spine_${toSnakeCase(type.name)}`;
+        interfaces[cName] = isPureInterface(type);
+    }
+
+    return interfaces;
+}
+
+/** Build inheritance map with extends/implements structure */
+function buildInheritanceMap(
+    allTypes: ClassOrStruct[],
+    nonTemplateTypes: ClassOrStruct[],
+    isInterface: Record<string, boolean>
+): Record<string, { extends?: string, mixins: string[] }> {
+    const inheritance: Record<string, { extends?: string, mixins: string[] }> = {};
+    const typeMap = new Map<string, ClassOrStruct>();
+    const nonTemplateMap = new Map<string, ClassOrStruct>();
+
+    // Build type lookup maps
+    for (const type of allTypes) {
+        typeMap.set(type.name, type);
+    }
+    for (const type of nonTemplateTypes) {
+        nonTemplateMap.set(type.name, type);
+    }
+
+    // For each non-template type, determine its extends/implements
+    for (const type of nonTemplateTypes) {
+        const cName = `spine_${toSnakeCase(type.name)}`;
+        const directParents = findDirectNonTemplateParents(type, typeMap, nonTemplateMap);
+
+        const concreteParents = directParents.filter(parent => !isInterface[parent]);
+        const interfaceParents = directParents.filter(parent => isInterface[parent]);
+
+        inheritance[cName] = {
+            extends: concreteParents.length > 0 ? concreteParents[0] : undefined,
+            mixins: interfaceParents
+        };
+
+        // Fail hard if multiple concrete parents (can't represent in single inheritance languages)
+        if (concreteParents.length > 1) {
+            console.error(`\nERROR: ${cName} has multiple concrete parents: ${concreteParents.join(', ')}`);
+            console.error(`This cannot be represented in single inheritance languages like Dart, Swift, Java, etc.`);
+            console.error(`\nTo fix this, convert one of the concrete parent classes to a pure interface:`);
+            for (const parent of concreteParents) {
+                const parentTypeName = parent.replace('spine_', '').replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase()).replace(/ /g, '');
+                console.error(`  - Make ${parentTypeName} a pure interface (all methods = 0)`);
+            }
+            console.error(`\nThen update the C++ class hierarchy and rebuild.`);
+            throw new Error(`Multiple concrete inheritance detected in ${cName}. Cannot generate bindings for single inheritance languages.`);
+        }
+    }
+
+    return inheritance;
+}
+
+/** Find direct non-template parents for a type */
+function findDirectNonTemplateParents(
+    type: ClassOrStruct,
+    typeMap: Map<string, ClassOrStruct>,
+    nonTemplateMap: Map<string, ClassOrStruct>
+): string[] {
+    if (!type.superTypes) return [];
+
+    const directParents: string[] = [];
+
+    for (const superTypeName of type.superTypes) {
+        // Extract base type name from templated types
+        const baseTypeName = superTypeName.split('<')[0];
+        const superType = typeMap.get(baseTypeName);
+
+        if (!superType) continue;
+
+        if (!superType.isTemplate && nonTemplateMap.has(superType.name)) {
+            // Direct non-template parent
+            const cName = `spine_${toSnakeCase(superType.name)}`;
+            directParents.push(cName);
+        } else if (superType.isTemplate) {
+            // Template parent - recurse to find its non-template parents
+            const inheritedParents = findDirectNonTemplateParents(superType, typeMap, nonTemplateMap);
+            directParents.push(...inheritedParents);
+        }
+    }
+
+    return [...new Set(directParents)]; // Remove duplicates
+}
+
+/** Check if a class/struct is a pure interface (all methods are pure virtual or only has constructors/destructors) */
+function isPureInterface(type: ClassOrStruct): boolean {
+    if (!type.members || type.members.length === 0) {
+        return true; // No members = pure interface
+    }
+
+    const methods = type.members.filter(m => m.kind === 'method') as Method[];
+    const fields = type.members.filter(m => m.kind === 'field');
+
+    // If it has fields, it's not a pure interface
+    if (fields.length > 0) {
+        return false;
+    }
+
+    // Filter out RTTI methods (like getRTTI) which are infrastructure methods
+    const nonRttiMethods = methods.filter(method =>
+        !method.name.toLowerCase().includes('rtti')
+    );
+
+    // If no non-RTTI methods, only constructors/destructors/RTTI = pure interface
+    if (nonRttiMethods.length === 0) {
+        return true;
+    }
+
+    // Check if all non-RTTI methods are pure virtual
+    return nonRttiMethods.every(method => method.isPure === true);
+}
+
 async function main() {
     // Check if we should just export JSON for debugging
     if (process.argv.includes('--export-json')) {
@@ -177,21 +306,33 @@ async function main() {
         const originalLog = console.log;
         console.log = () => {};
 
-        const { cTypes, cEnums, cArrayTypes, supertypes, subtypes } = await generate();
+        const { cTypes, cEnums, cArrayTypes, inheritance, supertypes, subtypes, isInterface } = await generate();
 
         // Restore console.log and output JSON
         console.log = originalLog;
-        console.log(JSON.stringify({ cTypes, cEnums, cArrayTypes, supertypes, subtypes }, null, 2));
+        console.log(JSON.stringify({ cTypes, cEnums, cArrayTypes, inheritance, supertypes, subtypes, isInterface }, null, 2));
         return;
     }
 
     // Generate C types and enums
-    const { cTypes, cEnums, cArrayTypes, supertypes, subtypes } = await generate();
+    const { cTypes, cEnums, cArrayTypes, inheritance, supertypes, subtypes, isInterface } = await generate();
 
     // Write all files to disk
     const cWriter = new CWriter(path.join(__dirname, '../../src/generated'));
     await cWriter.writeAll(cTypes, cEnums, cArrayTypes);
 
+    // Format the generated code
+    console.log('Formatting generated code...');
+    try {
+        const { execSync } = await import('child_process');
+        const formatterPath = path.join(__dirname, '../../../formatters/format-cpp.sh');
+        execSync(formatterPath, { stdio: 'inherit' });
+        console.log('Code formatting complete!');
+    } catch (error) {
+        console.warn('Warning: Code formatting failed:', error);
+        console.warn('You may need to run the formatter manually');
+    }
+
     console.log('Code generation complete!');
 }
 

spine-c/include/spine-c.h

@@ -67,7 +67,6 @@
 #include "../src/generated/constraint_timeline1.h"
 #include "../src/generated/curve_timeline.h"
 #include "../src/generated/curve_timeline1.h"
-#include "../src/generated/curve_timeline2.h"
 #include "../src/generated/deform_timeline.h"
 #include "../src/generated/draw_order_timeline.h"
 #include "../src/generated/event.h"

spine-c/src/generated/alpha_timeline.cpp

@@ -23,6 +23,16 @@ void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skelet
 				 appliedPose);
 }
 
+int spine_alpha_timeline_get_slot_index(spine_alpha_timeline self) {
+	AlphaTimeline *_self = (AlphaTimeline *) self;
+	return _self->getSlotIndex();
+}
+
+void spine_alpha_timeline_set_slot_index(spine_alpha_timeline self, int inValue) {
+	AlphaTimeline *_self = (AlphaTimeline *) self;
+	_self->setSlotIndex(inValue);
+}
+
 void spine_alpha_timeline_set_frame(spine_alpha_timeline self, size_t frame, float time, float value) {
 	CurveTimeline1 *_self = (CurveTimeline1 *) (AlphaTimeline *) self;
 	_self->setFrame(frame, time, value);
@@ -107,16 +117,6 @@ spine_array_property_id spine_alpha_timeline_get_property_ids(spine_alpha_timeli
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_alpha_timeline_get_slot_index(spine_alpha_timeline self) {
-	SlotTimeline *_self = (SlotTimeline *) (AlphaTimeline *) self;
-	return _self->getSlotIndex();
-}
-
-void spine_alpha_timeline_set_slot_index(spine_alpha_timeline self, int inValue) {
-	SlotTimeline *_self = (SlotTimeline *) (AlphaTimeline *) self;
-	_self->setSlotIndex(inValue);
-}
-
 spine_rtti spine_alpha_timeline_rtti(void) {
 	return (spine_rtti) &AlphaTimeline::rtti;
 }

spine-c/src/generated/alpha_timeline.h

@@ -16,6 +16,8 @@ SPINE_C_API void spine_alpha_timeline_dispose(spine_alpha_timeline self);
 SPINE_C_API spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self);
 SPINE_C_API void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
 											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_alpha_timeline_get_slot_index(spine_alpha_timeline self);
+SPINE_C_API void spine_alpha_timeline_set_slot_index(spine_alpha_timeline self, int inValue);
 SPINE_C_API void spine_alpha_timeline_set_frame(spine_alpha_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_alpha_timeline_get_curve_value(spine_alpha_timeline self, float time);
 SPINE_C_API float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
@@ -37,8 +39,6 @@ SPINE_C_API size_t spine_alpha_timeline_get_frame_count(spine_alpha_timeline sel
 SPINE_C_API spine_array_float spine_alpha_timeline_get_frames(spine_alpha_timeline self);
 SPINE_C_API float spine_alpha_timeline_get_duration(spine_alpha_timeline self);
 SPINE_C_API spine_array_property_id spine_alpha_timeline_get_property_ids(spine_alpha_timeline self);
-SPINE_C_API int spine_alpha_timeline_get_slot_index(spine_alpha_timeline self);
-SPINE_C_API void spine_alpha_timeline_set_slot_index(spine_alpha_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_alpha_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/attachment_timeline.cpp

@@ -28,6 +28,16 @@ void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int fra
 	_self->setFrame(frame, time, String(attachmentName));
 }
 
+int spine_attachment_timeline_get_slot_index(spine_attachment_timeline self) {
+	AttachmentTimeline *_self = (AttachmentTimeline *) self;
+	return _self->getSlotIndex();
+}
+
+void spine_attachment_timeline_set_slot_index(spine_attachment_timeline self, int inValue) {
+	AttachmentTimeline *_self = (AttachmentTimeline *) self;
+	_self->setSlotIndex(inValue);
+}
+
 size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline self) {
 	Timeline *_self = (Timeline *) (AttachmentTimeline *) self;
 	return _self->getFrameEntries();
@@ -53,16 +63,6 @@ spine_array_property_id spine_attachment_timeline_get_property_ids(spine_attachm
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_attachment_timeline_get_slot_index(spine_attachment_timeline self) {
-	SlotTimeline *_self = (SlotTimeline *) (AttachmentTimeline *) self;
-	return _self->getSlotIndex();
-}
-
-void spine_attachment_timeline_set_slot_index(spine_attachment_timeline self, int inValue) {
-	SlotTimeline *_self = (SlotTimeline *) (AttachmentTimeline *) self;
-	_self->setSlotIndex(inValue);
-}
-
 spine_rtti spine_attachment_timeline_rtti(void) {
 	return (spine_rtti) &AttachmentTimeline::rtti;
 }

spine-c/src/generated/attachment_timeline.h

@@ -18,13 +18,13 @@ SPINE_C_API void spine_attachment_timeline_apply(spine_attachment_timeline self,
 												 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 												 bool appliedPose);
 SPINE_C_API void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char *attachmentName);
+SPINE_C_API int spine_attachment_timeline_get_slot_index(spine_attachment_timeline self);
+SPINE_C_API void spine_attachment_timeline_set_slot_index(spine_attachment_timeline self, int inValue);
 SPINE_C_API size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline self);
 SPINE_C_API size_t spine_attachment_timeline_get_frame_count(spine_attachment_timeline self);
 SPINE_C_API spine_array_float spine_attachment_timeline_get_frames(spine_attachment_timeline self);
 SPINE_C_API float spine_attachment_timeline_get_duration(spine_attachment_timeline self);
 SPINE_C_API spine_array_property_id spine_attachment_timeline_get_property_ids(spine_attachment_timeline self);
-SPINE_C_API int spine_attachment_timeline_get_slot_index(spine_attachment_timeline self);
-SPINE_C_API void spine_attachment_timeline_set_slot_index(spine_attachment_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_attachment_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/bone_timeline1.cpp

@@ -19,6 +19,16 @@ void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skelet
 				 appliedPose);
 }
 
+int spine_bone_timeline1_get_bone_index(spine_bone_timeline1 self) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
+	return _self->getBoneIndex();
+}
+
+void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 self, int inValue) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) self;
+	_self->setBoneIndex(inValue);
+}
+
 void spine_bone_timeline1_set_frame(spine_bone_timeline1 self, size_t frame, float time, float value) {
 	CurveTimeline1 *_self = (CurveTimeline1 *) (BoneTimeline1 *) self;
 	_self->setFrame(frame, time, value);
@@ -103,16 +113,6 @@ spine_array_property_id spine_bone_timeline1_get_property_ids(spine_bone_timelin
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_bone_timeline1_get_bone_index(spine_bone_timeline1 self) {
-	BoneTimeline *_self = (BoneTimeline *) (BoneTimeline1 *) self;
-	return _self->getBoneIndex();
-}
-
-void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 self, int inValue) {
-	BoneTimeline *_self = (BoneTimeline *) (BoneTimeline1 *) self;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_bone_timeline1_rtti(void) {
 	return (spine_rtti) &BoneTimeline1::rtti;
 }

spine-c/src/generated/bone_timeline1.h

@@ -14,6 +14,8 @@ SPINE_C_API void spine_bone_timeline1_dispose(spine_bone_timeline1 self);
 SPINE_C_API spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self);
 SPINE_C_API void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
 											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_bone_timeline1_get_bone_index(spine_bone_timeline1 self);
+SPINE_C_API void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 self, int inValue);
 SPINE_C_API void spine_bone_timeline1_set_frame(spine_bone_timeline1 self, size_t frame, float time, float value);
 SPINE_C_API float spine_bone_timeline1_get_curve_value(spine_bone_timeline1 self, float time);
 SPINE_C_API float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
@@ -35,8 +37,6 @@ SPINE_C_API size_t spine_bone_timeline1_get_frame_count(spine_bone_timeline1 sel
 SPINE_C_API spine_array_float spine_bone_timeline1_get_frames(spine_bone_timeline1 self);
 SPINE_C_API float spine_bone_timeline1_get_duration(spine_bone_timeline1 self);
 SPINE_C_API spine_array_property_id spine_bone_timeline1_get_property_ids(spine_bone_timeline1 self);
-SPINE_C_API int spine_bone_timeline1_get_bone_index(spine_bone_timeline1 self);
-SPINE_C_API void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 self, int inValue);
 SPINE_C_API spine_rtti spine_bone_timeline1_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/bone_timeline2.cpp

@@ -19,77 +19,72 @@ void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skelet
 				 appliedPose);
 }
 
-void spine_bone_timeline2_set_frame(spine_bone_timeline2 self, size_t frame, float time, float value1, float value2) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
-	_self->setFrame(frame, time, value1, value2);
+int spine_bone_timeline2_get_bone_index(spine_bone_timeline2 self) {
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
+	return _self->getBoneIndex();
 }
 
-float spine_bone_timeline2_get_curve_value(spine_bone_timeline2 self, float time) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
-	return _self->getCurveValue(time);
+void spine_bone_timeline2_set_bone_index(spine_bone_timeline2 self, int inValue) {
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
+	_self->setBoneIndex(inValue);
+}
+
+void spine_bone_timeline2_set_frame(spine_bone_timeline2 self, size_t frame, float time, float value1, float value2) {
+	BoneTimeline2 *_self = (BoneTimeline2 *) self;
+	_self->setFrame(frame, time, value1, value2);
 }
 
 void spine_bone_timeline2_set_linear(spine_bone_timeline2 self, size_t frame) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
 	_self->setLinear(frame);
 }
 
 void spine_bone_timeline2_set_stepped(spine_bone_timeline2 self, size_t frame) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
 	_self->setStepped(frame);
 }
 
 void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1, float cx1,
 									 float cy1, float cx2, float cy2, float time2, float value2) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	CurveTimeline *_self = (CurveTimeline *) (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) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
 	return _self->getBezierValue(time, frame, valueOffset, i);
 }
 
 spine_array_float spine_bone_timeline2_get_curves(spine_bone_timeline2 self) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
 	return (spine_array_float) &_self->getCurves();
 }
 
 size_t spine_bone_timeline2_get_frame_entries(spine_bone_timeline2 self) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
 	return _self->getFrameEntries();
 }
 
 size_t spine_bone_timeline2_get_frame_count(spine_bone_timeline2 self) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
 	return _self->getFrameCount();
 }
 
 spine_array_float spine_bone_timeline2_get_frames(spine_bone_timeline2 self) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
 	return (spine_array_float) &_self->getFrames();
 }
 
 float spine_bone_timeline2_get_duration(spine_bone_timeline2 self) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
 	return _self->getDuration();
 }
 
 spine_array_property_id spine_bone_timeline2_get_property_ids(spine_bone_timeline2 self) {
-	CurveTimeline2 *_self = (CurveTimeline2 *) (BoneTimeline2 *) self;
+	CurveTimeline *_self = (CurveTimeline *) (BoneTimeline2 *) self;
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_bone_timeline2_get_bone_index(spine_bone_timeline2 self) {
-	BoneTimeline *_self = (BoneTimeline *) (BoneTimeline2 *) self;
-	return _self->getBoneIndex();
-}
-
-void spine_bone_timeline2_set_bone_index(spine_bone_timeline2 self, int inValue) {
-	BoneTimeline *_self = (BoneTimeline *) (BoneTimeline2 *) self;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_bone_timeline2_rtti(void) {
 	return (spine_rtti) &BoneTimeline2::rtti;
 }

spine-c/src/generated/bone_timeline2.h

@@ -14,8 +14,9 @@ SPINE_C_API void spine_bone_timeline2_dispose(spine_bone_timeline2 self);
 SPINE_C_API spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self);
 SPINE_C_API void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
 											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_bone_timeline2_get_bone_index(spine_bone_timeline2 self);
+SPINE_C_API void spine_bone_timeline2_set_bone_index(spine_bone_timeline2 self, int inValue);
 SPINE_C_API void spine_bone_timeline2_set_frame(spine_bone_timeline2 self, size_t frame, float time, float value1, float value2);
-SPINE_C_API float spine_bone_timeline2_get_curve_value(spine_bone_timeline2 self, float time);
 SPINE_C_API void spine_bone_timeline2_set_linear(spine_bone_timeline2 self, size_t frame);
 SPINE_C_API void spine_bone_timeline2_set_stepped(spine_bone_timeline2 self, size_t frame);
 SPINE_C_API void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1,
@@ -27,8 +28,6 @@ SPINE_C_API size_t spine_bone_timeline2_get_frame_count(spine_bone_timeline2 sel
 SPINE_C_API spine_array_float spine_bone_timeline2_get_frames(spine_bone_timeline2 self);
 SPINE_C_API float spine_bone_timeline2_get_duration(spine_bone_timeline2 self);
 SPINE_C_API spine_array_property_id spine_bone_timeline2_get_property_ids(spine_bone_timeline2 self);
-SPINE_C_API int spine_bone_timeline2_get_bone_index(spine_bone_timeline2 self);
-SPINE_C_API void spine_bone_timeline2_set_bone_index(spine_bone_timeline2 self, int inValue);
 SPINE_C_API spine_rtti spine_bone_timeline2_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/constraint_timeline1.cpp

@@ -12,6 +12,16 @@ spine_rtti spine_constraint_timeline1_get_rtti(spine_constraint_timeline1 self)
 	return (spine_rtti) &_self->getRTTI();
 }
 
+int spine_constraint_timeline1_get_constraint_index(spine_constraint_timeline1 self) {
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
+	return _self->getConstraintIndex();
+}
+
+void spine_constraint_timeline1_set_constraint_index(spine_constraint_timeline1 self, int inValue) {
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
+	_self->setConstraintIndex(inValue);
+}
+
 void spine_constraint_timeline1_set_frame(spine_constraint_timeline1 self, size_t frame, float time, float value) {
 	CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
 	_self->setFrame(frame, time, value);
@@ -104,16 +114,6 @@ spine_array_property_id spine_constraint_timeline1_get_property_ids(spine_constr
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_constraint_timeline1_get_constraint_index(spine_constraint_timeline1 self) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (ConstraintTimeline1 *) self;
-	return _self->getConstraintIndex();
-}
-
-void spine_constraint_timeline1_set_constraint_index(spine_constraint_timeline1 self, int inValue) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (ConstraintTimeline1 *) self;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_constraint_timeline1_rtti(void) {
 	return (spine_rtti) &ConstraintTimeline1::rtti;
 }

spine-c/src/generated/constraint_timeline1.h

@@ -12,6 +12,8 @@ extern "C" {
 SPINE_C_API void spine_constraint_timeline1_dispose(spine_constraint_timeline1 self);
 
 SPINE_C_API spine_rtti spine_constraint_timeline1_get_rtti(spine_constraint_timeline1 self);
+SPINE_C_API int spine_constraint_timeline1_get_constraint_index(spine_constraint_timeline1 self);
+SPINE_C_API void spine_constraint_timeline1_set_constraint_index(spine_constraint_timeline1 self, int inValue);
 SPINE_C_API void spine_constraint_timeline1_set_frame(spine_constraint_timeline1 self, size_t frame, float time, float value);
 SPINE_C_API float spine_constraint_timeline1_get_curve_value(spine_constraint_timeline1 self, float time);
 SPINE_C_API float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
@@ -37,8 +39,6 @@ SPINE_C_API size_t spine_constraint_timeline1_get_frame_count(spine_constraint_t
 SPINE_C_API spine_array_float spine_constraint_timeline1_get_frames(spine_constraint_timeline1 self);
 SPINE_C_API float spine_constraint_timeline1_get_duration(spine_constraint_timeline1 self);
 SPINE_C_API spine_array_property_id spine_constraint_timeline1_get_property_ids(spine_constraint_timeline1 self);
-SPINE_C_API int spine_constraint_timeline1_get_constraint_index(spine_constraint_timeline1 self);
-SPINE_C_API void spine_constraint_timeline1_set_constraint_index(spine_constraint_timeline1 self, int inValue);
 SPINE_C_API spine_rtti spine_constraint_timeline1_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/curve_timeline2.cpp

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

spine-c/src/generated/curve_timeline2.h

@@ -1,37 +0,0 @@
-#ifndef SPINE_SPINE_CURVE_TIMELINE2_H
-#define SPINE_SPINE_CURVE_TIMELINE2_H
-
-#include "../base.h"
-#include "types.h"
-#include "arrays.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-SPINE_C_API void spine_curve_timeline2_dispose(spine_curve_timeline2 self);
-
-SPINE_C_API spine_rtti spine_curve_timeline2_get_rtti(spine_curve_timeline2 self);
-SPINE_C_API void spine_curve_timeline2_set_frame(spine_curve_timeline2 self, size_t frame, float time, float value1, float value2);
-SPINE_C_API float spine_curve_timeline2_get_curve_value(spine_curve_timeline2 self, float time);
-SPINE_C_API void spine_curve_timeline2_set_linear(spine_curve_timeline2 self, size_t frame);
-SPINE_C_API void spine_curve_timeline2_set_stepped(spine_curve_timeline2 self, size_t frame);
-SPINE_C_API void spine_curve_timeline2_set_bezier(spine_curve_timeline2 self, size_t bezier, size_t frame, float value, float time1, float value1,
-												  float cx1, float cy1, float cx2, float cy2, float time2, float value2);
-SPINE_C_API float spine_curve_timeline2_get_bezier_value(spine_curve_timeline2 self, float time, size_t frame, size_t valueOffset, size_t i);
-SPINE_C_API spine_array_float spine_curve_timeline2_get_curves(spine_curve_timeline2 self);
-SPINE_C_API void spine_curve_timeline2_apply(spine_curve_timeline2 self, spine_skeleton skeleton, float lastTime, float time,
-											 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
-											 bool appliedPose);
-SPINE_C_API size_t spine_curve_timeline2_get_frame_entries(spine_curve_timeline2 self);
-SPINE_C_API size_t spine_curve_timeline2_get_frame_count(spine_curve_timeline2 self);
-SPINE_C_API spine_array_float spine_curve_timeline2_get_frames(spine_curve_timeline2 self);
-SPINE_C_API float spine_curve_timeline2_get_duration(spine_curve_timeline2 self);
-SPINE_C_API spine_array_property_id spine_curve_timeline2_get_property_ids(spine_curve_timeline2 self);
-SPINE_C_API spine_rtti spine_curve_timeline2_rtti(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* SPINE_SPINE_CURVE_TIMELINE2_H */

spine-c/src/generated/deform_timeline.cpp

@@ -54,6 +54,16 @@ void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skel
 				 appliedPose);
 }
 
+int spine_deform_timeline_get_slot_index(spine_deform_timeline self) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	return _self->getSlotIndex();
+}
+
+void spine_deform_timeline_set_slot_index(spine_deform_timeline self, int inValue) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
+	_self->setSlotIndex(inValue);
+}
+
 void spine_deform_timeline_set_linear(spine_deform_timeline self, size_t frame) {
 	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
 	_self->setLinear(frame);
@@ -94,16 +104,6 @@ spine_array_property_id spine_deform_timeline_get_property_ids(spine_deform_time
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_deform_timeline_get_slot_index(spine_deform_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
-	return _self->getSlotIndex();
-}
-
-void spine_deform_timeline_set_slot_index(spine_deform_timeline self, int inValue) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
-	_self->setSlotIndex(inValue);
-}
-
 spine_rtti spine_deform_timeline_rtti(void) {
 	return (spine_rtti) &DeformTimeline::rtti;
 }

spine-c/src/generated/deform_timeline.h

@@ -25,6 +25,8 @@ SPINE_C_API size_t spine_deform_timeline_get_frame_count(spine_deform_timeline s
 SPINE_C_API void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time,
 											 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											 bool appliedPose);
+SPINE_C_API int spine_deform_timeline_get_slot_index(spine_deform_timeline self);
+SPINE_C_API void spine_deform_timeline_set_slot_index(spine_deform_timeline self, int inValue);
 SPINE_C_API void spine_deform_timeline_set_linear(spine_deform_timeline self, size_t frame);
 SPINE_C_API void spine_deform_timeline_set_stepped(spine_deform_timeline self, size_t frame);
 SPINE_C_API float spine_deform_timeline_get_bezier_value(spine_deform_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
@@ -33,8 +35,6 @@ SPINE_C_API size_t spine_deform_timeline_get_frame_entries(spine_deform_timeline
 SPINE_C_API spine_array_float spine_deform_timeline_get_frames(spine_deform_timeline self);
 SPINE_C_API float spine_deform_timeline_get_duration(spine_deform_timeline self);
 SPINE_C_API spine_array_property_id spine_deform_timeline_get_property_ids(spine_deform_timeline self);
-SPINE_C_API int spine_deform_timeline_get_slot_index(spine_deform_timeline self);
-SPINE_C_API void spine_deform_timeline_set_slot_index(spine_deform_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_deform_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/ik_constraint_timeline.cpp

@@ -30,6 +30,16 @@ void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, i
 	_self->setFrame(frame, time, mix, softness, bendDirection, compress, stretch);
 }
 
+int spine_ik_constraint_timeline_get_constraint_index(spine_ik_constraint_timeline self) {
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
+	return _self->getConstraintIndex();
+}
+
+void spine_ik_constraint_timeline_set_constraint_index(spine_ik_constraint_timeline self, int inValue) {
+	IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
+	_self->setConstraintIndex(inValue);
+}
+
 void spine_ik_constraint_timeline_set_linear(spine_ik_constraint_timeline self, size_t frame) {
 	CurveTimeline *_self = (CurveTimeline *) (IkConstraintTimeline *) self;
 	_self->setLinear(frame);
@@ -81,16 +91,6 @@ spine_array_property_id spine_ik_constraint_timeline_get_property_ids(spine_ik_c
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_ik_constraint_timeline_get_constraint_index(spine_ik_constraint_timeline self) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (IkConstraintTimeline *) self;
-	return _self->getConstraintIndex();
-}
-
-void spine_ik_constraint_timeline_set_constraint_index(spine_ik_constraint_timeline self, int inValue) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (IkConstraintTimeline *) self;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_ik_constraint_timeline_rtti(void) {
 	return (spine_rtti) &IkConstraintTimeline::rtti;
 }

spine-c/src/generated/ik_constraint_timeline.h

@@ -19,6 +19,8 @@ SPINE_C_API void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline
 													bool appliedPose);
 SPINE_C_API void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness,
 														int bendDirection, bool compress, bool stretch);
+SPINE_C_API int spine_ik_constraint_timeline_get_constraint_index(spine_ik_constraint_timeline self);
+SPINE_C_API void spine_ik_constraint_timeline_set_constraint_index(spine_ik_constraint_timeline self, int inValue);
 SPINE_C_API void spine_ik_constraint_timeline_set_linear(spine_ik_constraint_timeline self, size_t frame);
 SPINE_C_API void spine_ik_constraint_timeline_set_stepped(spine_ik_constraint_timeline self, size_t frame);
 SPINE_C_API void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_timeline self, size_t bezier, size_t frame, float value, float time1,
@@ -31,8 +33,6 @@ SPINE_C_API size_t spine_ik_constraint_timeline_get_frame_count(spine_ik_constra
 SPINE_C_API spine_array_float spine_ik_constraint_timeline_get_frames(spine_ik_constraint_timeline self);
 SPINE_C_API float spine_ik_constraint_timeline_get_duration(spine_ik_constraint_timeline self);
 SPINE_C_API spine_array_property_id spine_ik_constraint_timeline_get_property_ids(spine_ik_constraint_timeline self);
-SPINE_C_API int spine_ik_constraint_timeline_get_constraint_index(spine_ik_constraint_timeline self);
-SPINE_C_API void spine_ik_constraint_timeline_set_constraint_index(spine_ik_constraint_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_ik_constraint_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/inherit_timeline.cpp

@@ -28,6 +28,16 @@ void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton sk
 				 appliedPose);
 }
 
+int spine_inherit_timeline_get_bone_index(spine_inherit_timeline self) {
+	InheritTimeline *_self = (InheritTimeline *) self;
+	return _self->getBoneIndex();
+}
+
+void spine_inherit_timeline_set_bone_index(spine_inherit_timeline self, int inValue) {
+	InheritTimeline *_self = (InheritTimeline *) self;
+	_self->setBoneIndex(inValue);
+}
+
 size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline self) {
 	Timeline *_self = (Timeline *) (InheritTimeline *) self;
 	return _self->getFrameEntries();
@@ -53,16 +63,6 @@ spine_array_property_id spine_inherit_timeline_get_property_ids(spine_inherit_ti
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_inherit_timeline_get_bone_index(spine_inherit_timeline self) {
-	BoneTimeline *_self = (BoneTimeline *) (InheritTimeline *) self;
-	return _self->getBoneIndex();
-}
-
-void spine_inherit_timeline_set_bone_index(spine_inherit_timeline self, int inValue) {
-	BoneTimeline *_self = (BoneTimeline *) (InheritTimeline *) self;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_inherit_timeline_rtti(void) {
 	return (spine_rtti) &InheritTimeline::rtti;
 }

spine-c/src/generated/inherit_timeline.h

@@ -18,13 +18,13 @@ SPINE_C_API void spine_inherit_timeline_set_frame(spine_inherit_timeline self, i
 SPINE_C_API void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time,
 											  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											  bool appliedPose);
+SPINE_C_API int spine_inherit_timeline_get_bone_index(spine_inherit_timeline self);
+SPINE_C_API void spine_inherit_timeline_set_bone_index(spine_inherit_timeline self, int inValue);
 SPINE_C_API size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline self);
 SPINE_C_API size_t spine_inherit_timeline_get_frame_count(spine_inherit_timeline self);
 SPINE_C_API spine_array_float spine_inherit_timeline_get_frames(spine_inherit_timeline self);
 SPINE_C_API float spine_inherit_timeline_get_duration(spine_inherit_timeline self);
 SPINE_C_API spine_array_property_id spine_inherit_timeline_get_property_ids(spine_inherit_timeline self);
-SPINE_C_API int spine_inherit_timeline_get_bone_index(spine_inherit_timeline self);
-SPINE_C_API void spine_inherit_timeline_set_bone_index(spine_inherit_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_inherit_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/path_constraint_mix_timeline.cpp

@@ -30,6 +30,16 @@ void spine_path_constraint_mix_timeline_set_frame(spine_path_constraint_mix_time
 	_self->setFrame(frame, time, mixRotate, mixX, mixY);
 }
 
+int spine_path_constraint_mix_timeline_get_constraint_index(spine_path_constraint_mix_timeline self) {
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
+	return _self->getConstraintIndex();
+}
+
+void spine_path_constraint_mix_timeline_set_constraint_index(spine_path_constraint_mix_timeline self, int inValue) {
+	PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
+	_self->setConstraintIndex(inValue);
+}
+
 void spine_path_constraint_mix_timeline_set_linear(spine_path_constraint_mix_timeline self, size_t frame) {
 	CurveTimeline *_self = (CurveTimeline *) (PathConstraintMixTimeline *) self;
 	_self->setLinear(frame);
@@ -82,16 +92,6 @@ spine_array_property_id spine_path_constraint_mix_timeline_get_property_ids(spin
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_path_constraint_mix_timeline_get_constraint_index(spine_path_constraint_mix_timeline self) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (PathConstraintMixTimeline *) self;
-	return _self->getConstraintIndex();
-}
-
-void spine_path_constraint_mix_timeline_set_constraint_index(spine_path_constraint_mix_timeline self, int inValue) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (PathConstraintMixTimeline *) self;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_path_constraint_mix_timeline_rtti(void) {
 	return (spine_rtti) &PathConstraintMixTimeline::rtti;
 }

spine-c/src/generated/path_constraint_mix_timeline.h

@@ -19,6 +19,8 @@ SPINE_C_API void spine_path_constraint_mix_timeline_apply(spine_path_constraint_
 														  spine_mix_direction direction, bool appliedPose);
 SPINE_C_API void spine_path_constraint_mix_timeline_set_frame(spine_path_constraint_mix_timeline self, int frame, float time, float mixRotate,
 															  float mixX, float mixY);
+SPINE_C_API int spine_path_constraint_mix_timeline_get_constraint_index(spine_path_constraint_mix_timeline self);
+SPINE_C_API void spine_path_constraint_mix_timeline_set_constraint_index(spine_path_constraint_mix_timeline self, int inValue);
 SPINE_C_API void spine_path_constraint_mix_timeline_set_linear(spine_path_constraint_mix_timeline self, size_t frame);
 SPINE_C_API void spine_path_constraint_mix_timeline_set_stepped(spine_path_constraint_mix_timeline self, size_t frame);
 SPINE_C_API void spine_path_constraint_mix_timeline_set_bezier(spine_path_constraint_mix_timeline self, size_t bezier, size_t frame, float value,
@@ -32,8 +34,6 @@ SPINE_C_API size_t spine_path_constraint_mix_timeline_get_frame_count(spine_path
 SPINE_C_API spine_array_float spine_path_constraint_mix_timeline_get_frames(spine_path_constraint_mix_timeline self);
 SPINE_C_API float spine_path_constraint_mix_timeline_get_duration(spine_path_constraint_mix_timeline self);
 SPINE_C_API spine_array_property_id spine_path_constraint_mix_timeline_get_property_ids(spine_path_constraint_mix_timeline self);
-SPINE_C_API int spine_path_constraint_mix_timeline_get_constraint_index(spine_path_constraint_mix_timeline self);
-SPINE_C_API void spine_path_constraint_mix_timeline_set_constraint_index(spine_path_constraint_mix_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_path_constraint_mix_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/path_constraint_position_timeline.cpp

@@ -25,6 +25,16 @@ void spine_path_constraint_position_timeline_apply(spine_path_constraint_positio
 				 appliedPose);
 }
 
+int spine_path_constraint_position_timeline_get_constraint_index(spine_path_constraint_position_timeline self) {
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -112,16 +122,6 @@ spine_array_property_id spine_path_constraint_position_timeline_get_property_ids
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_path_constraint_position_timeline_get_constraint_index(spine_path_constraint_position_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (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;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_path_constraint_position_timeline_rtti(void) {
 	return (spine_rtti) &PathConstraintPositionTimeline::rtti;
 }

spine-c/src/generated/path_constraint_position_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API spine_rtti spine_path_constraint_position_timeline_get_rtti(spine_pa
 SPINE_C_API void spine_path_constraint_position_timeline_apply(spine_path_constraint_position_timeline self, spine_skeleton skeleton, float lastTime,
 															   float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
 															   spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_path_constraint_position_timeline_get_constraint_index(spine_path_constraint_position_timeline self);
+SPINE_C_API void spine_path_constraint_position_timeline_set_constraint_index(spine_path_constraint_position_timeline self, int inValue);
 SPINE_C_API void spine_path_constraint_position_timeline_set_frame(spine_path_constraint_position_timeline self, size_t frame, float time,
 																   float value);
 SPINE_C_API float spine_path_constraint_position_timeline_get_curve_value(spine_path_constraint_position_timeline self, float time);
@@ -43,8 +45,6 @@ SPINE_C_API size_t spine_path_constraint_position_timeline_get_frame_count(spine
 SPINE_C_API spine_array_float spine_path_constraint_position_timeline_get_frames(spine_path_constraint_position_timeline self);
 SPINE_C_API float spine_path_constraint_position_timeline_get_duration(spine_path_constraint_position_timeline self);
 SPINE_C_API spine_array_property_id spine_path_constraint_position_timeline_get_property_ids(spine_path_constraint_position_timeline self);
-SPINE_C_API int spine_path_constraint_position_timeline_get_constraint_index(spine_path_constraint_position_timeline self);
-SPINE_C_API void spine_path_constraint_position_timeline_set_constraint_index(spine_path_constraint_position_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_path_constraint_position_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/path_constraint_spacing_timeline.cpp

@@ -24,6 +24,16 @@ void spine_path_constraint_spacing_timeline_apply(spine_path_constraint_spacing_
 				 appliedPose);
 }
 
+int spine_path_constraint_spacing_timeline_get_constraint_index(spine_path_constraint_spacing_timeline self) {
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -111,16 +121,6 @@ spine_array_property_id spine_path_constraint_spacing_timeline_get_property_ids(
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_path_constraint_spacing_timeline_get_constraint_index(spine_path_constraint_spacing_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (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;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_path_constraint_spacing_timeline_rtti(void) {
 	return (spine_rtti) &PathConstraintSpacingTimeline::rtti;
 }

spine-c/src/generated/path_constraint_spacing_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API spine_rtti spine_path_constraint_spacing_timeline_get_rtti(spine_pat
 SPINE_C_API void spine_path_constraint_spacing_timeline_apply(spine_path_constraint_spacing_timeline self, spine_skeleton skeleton, float lastTime,
 															  float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
 															  spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_path_constraint_spacing_timeline_get_constraint_index(spine_path_constraint_spacing_timeline self);
+SPINE_C_API void spine_path_constraint_spacing_timeline_set_constraint_index(spine_path_constraint_spacing_timeline self, int inValue);
 SPINE_C_API void spine_path_constraint_spacing_timeline_set_frame(spine_path_constraint_spacing_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_path_constraint_spacing_timeline_get_curve_value(spine_path_constraint_spacing_timeline self, float time);
 SPINE_C_API float spine_path_constraint_spacing_timeline_get_relative_value(spine_path_constraint_spacing_timeline self, float time, float alpha,
@@ -42,8 +44,6 @@ SPINE_C_API size_t spine_path_constraint_spacing_timeline_get_frame_count(spine_
 SPINE_C_API spine_array_float spine_path_constraint_spacing_timeline_get_frames(spine_path_constraint_spacing_timeline self);
 SPINE_C_API float spine_path_constraint_spacing_timeline_get_duration(spine_path_constraint_spacing_timeline self);
 SPINE_C_API spine_array_property_id spine_path_constraint_spacing_timeline_get_property_ids(spine_path_constraint_spacing_timeline self);
-SPINE_C_API int spine_path_constraint_spacing_timeline_get_constraint_index(spine_path_constraint_spacing_timeline self);
-SPINE_C_API void spine_path_constraint_spacing_timeline_set_constraint_index(spine_path_constraint_spacing_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_path_constraint_spacing_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/physics_constraint_damping_timeline.cpp

@@ -26,6 +26,16 @@ void spine_physics_constraint_damping_timeline_apply(spine_physics_constraint_da
 				 appliedPose);
 }
 
+int spine_physics_constraint_damping_timeline_get_constraint_index(spine_physics_constraint_damping_timeline self) {
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -113,16 +123,6 @@ spine_array_property_id spine_physics_constraint_damping_timeline_get_property_i
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_physics_constraint_damping_timeline_get_constraint_index(spine_physics_constraint_damping_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_physics_constraint_damping_timeline_rtti(void) {
 	return (spine_rtti) &PhysicsConstraintDampingTimeline::rtti;
 }

spine-c/src/generated/physics_constraint_damping_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API spine_rtti spine_physics_constraint_damping_timeline_get_rtti(spine_
 SPINE_C_API void spine_physics_constraint_damping_timeline_apply(spine_physics_constraint_damping_timeline self, spine_skeleton skeleton,
 																 float lastTime, float time, spine_array_event pEvents, float alpha,
 																 spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_physics_constraint_damping_timeline_get_constraint_index(spine_physics_constraint_damping_timeline self);
+SPINE_C_API void spine_physics_constraint_damping_timeline_set_constraint_index(spine_physics_constraint_damping_timeline self, int inValue);
 SPINE_C_API void spine_physics_constraint_damping_timeline_set_frame(spine_physics_constraint_damping_timeline self, size_t frame, float time,
 																	 float value);
 SPINE_C_API float spine_physics_constraint_damping_timeline_get_curve_value(spine_physics_constraint_damping_timeline self, float time);
@@ -44,8 +46,6 @@ SPINE_C_API size_t spine_physics_constraint_damping_timeline_get_frame_count(spi
 SPINE_C_API spine_array_float spine_physics_constraint_damping_timeline_get_frames(spine_physics_constraint_damping_timeline self);
 SPINE_C_API float spine_physics_constraint_damping_timeline_get_duration(spine_physics_constraint_damping_timeline self);
 SPINE_C_API spine_array_property_id spine_physics_constraint_damping_timeline_get_property_ids(spine_physics_constraint_damping_timeline self);
-SPINE_C_API int spine_physics_constraint_damping_timeline_get_constraint_index(spine_physics_constraint_damping_timeline self);
-SPINE_C_API void spine_physics_constraint_damping_timeline_set_constraint_index(spine_physics_constraint_damping_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_physics_constraint_damping_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/physics_constraint_gravity_timeline.cpp

@@ -26,6 +26,16 @@ void spine_physics_constraint_gravity_timeline_apply(spine_physics_constraint_gr
 				 appliedPose);
 }
 
+int spine_physics_constraint_gravity_timeline_get_constraint_index(spine_physics_constraint_gravity_timeline self) {
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -113,16 +123,6 @@ spine_array_property_id spine_physics_constraint_gravity_timeline_get_property_i
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_physics_constraint_gravity_timeline_get_constraint_index(spine_physics_constraint_gravity_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_physics_constraint_gravity_timeline_rtti(void) {
 	return (spine_rtti) &PhysicsConstraintGravityTimeline::rtti;
 }

spine-c/src/generated/physics_constraint_gravity_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(spine_
 SPINE_C_API void spine_physics_constraint_gravity_timeline_apply(spine_physics_constraint_gravity_timeline self, spine_skeleton skeleton,
 																 float lastTime, float time, spine_array_event pEvents, float alpha,
 																 spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_physics_constraint_gravity_timeline_get_constraint_index(spine_physics_constraint_gravity_timeline self);
+SPINE_C_API void spine_physics_constraint_gravity_timeline_set_constraint_index(spine_physics_constraint_gravity_timeline self, int inValue);
 SPINE_C_API void spine_physics_constraint_gravity_timeline_set_frame(spine_physics_constraint_gravity_timeline self, size_t frame, float time,
 																	 float value);
 SPINE_C_API float spine_physics_constraint_gravity_timeline_get_curve_value(spine_physics_constraint_gravity_timeline self, float time);
@@ -44,8 +46,6 @@ SPINE_C_API size_t spine_physics_constraint_gravity_timeline_get_frame_count(spi
 SPINE_C_API spine_array_float spine_physics_constraint_gravity_timeline_get_frames(spine_physics_constraint_gravity_timeline self);
 SPINE_C_API float spine_physics_constraint_gravity_timeline_get_duration(spine_physics_constraint_gravity_timeline self);
 SPINE_C_API spine_array_property_id spine_physics_constraint_gravity_timeline_get_property_ids(spine_physics_constraint_gravity_timeline self);
-SPINE_C_API int spine_physics_constraint_gravity_timeline_get_constraint_index(spine_physics_constraint_gravity_timeline self);
-SPINE_C_API void spine_physics_constraint_gravity_timeline_set_constraint_index(spine_physics_constraint_gravity_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_physics_constraint_gravity_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/physics_constraint_inertia_timeline.cpp

@@ -26,6 +26,16 @@ void spine_physics_constraint_inertia_timeline_apply(spine_physics_constraint_in
 				 appliedPose);
 }
 
+int spine_physics_constraint_inertia_timeline_get_constraint_index(spine_physics_constraint_inertia_timeline self) {
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -113,16 +123,6 @@ spine_array_property_id spine_physics_constraint_inertia_timeline_get_property_i
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_physics_constraint_inertia_timeline_get_constraint_index(spine_physics_constraint_inertia_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_physics_constraint_inertia_timeline_rtti(void) {
 	return (spine_rtti) &PhysicsConstraintInertiaTimeline::rtti;
 }

spine-c/src/generated/physics_constraint_inertia_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(spine_
 SPINE_C_API void spine_physics_constraint_inertia_timeline_apply(spine_physics_constraint_inertia_timeline self, spine_skeleton skeleton,
 																 float lastTime, float time, spine_array_event pEvents, float alpha,
 																 spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_physics_constraint_inertia_timeline_get_constraint_index(spine_physics_constraint_inertia_timeline self);
+SPINE_C_API void spine_physics_constraint_inertia_timeline_set_constraint_index(spine_physics_constraint_inertia_timeline self, int inValue);
 SPINE_C_API void spine_physics_constraint_inertia_timeline_set_frame(spine_physics_constraint_inertia_timeline self, size_t frame, float time,
 																	 float value);
 SPINE_C_API float spine_physics_constraint_inertia_timeline_get_curve_value(spine_physics_constraint_inertia_timeline self, float time);
@@ -44,8 +46,6 @@ SPINE_C_API size_t spine_physics_constraint_inertia_timeline_get_frame_count(spi
 SPINE_C_API spine_array_float spine_physics_constraint_inertia_timeline_get_frames(spine_physics_constraint_inertia_timeline self);
 SPINE_C_API float spine_physics_constraint_inertia_timeline_get_duration(spine_physics_constraint_inertia_timeline self);
 SPINE_C_API spine_array_property_id spine_physics_constraint_inertia_timeline_get_property_ids(spine_physics_constraint_inertia_timeline self);
-SPINE_C_API int spine_physics_constraint_inertia_timeline_get_constraint_index(spine_physics_constraint_inertia_timeline self);
-SPINE_C_API void spine_physics_constraint_inertia_timeline_set_constraint_index(spine_physics_constraint_inertia_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_physics_constraint_inertia_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/physics_constraint_mass_timeline.cpp

@@ -26,6 +26,16 @@ void spine_physics_constraint_mass_timeline_apply(spine_physics_constraint_mass_
 				 appliedPose);
 }
 
+int spine_physics_constraint_mass_timeline_get_constraint_index(spine_physics_constraint_mass_timeline self) {
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -113,16 +123,6 @@ spine_array_property_id spine_physics_constraint_mass_timeline_get_property_ids(
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_physics_constraint_mass_timeline_get_constraint_index(spine_physics_constraint_mass_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_physics_constraint_mass_timeline_rtti(void) {
 	return (spine_rtti) &PhysicsConstraintMassTimeline::rtti;
 }

spine-c/src/generated/physics_constraint_mass_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API spine_rtti spine_physics_constraint_mass_timeline_get_rtti(spine_phy
 SPINE_C_API void spine_physics_constraint_mass_timeline_apply(spine_physics_constraint_mass_timeline self, spine_skeleton skeleton, float lastTime,
 															  float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
 															  spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_physics_constraint_mass_timeline_get_constraint_index(spine_physics_constraint_mass_timeline self);
+SPINE_C_API void spine_physics_constraint_mass_timeline_set_constraint_index(spine_physics_constraint_mass_timeline self, int inValue);
 SPINE_C_API void spine_physics_constraint_mass_timeline_set_frame(spine_physics_constraint_mass_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_physics_constraint_mass_timeline_get_curve_value(spine_physics_constraint_mass_timeline self, float time);
 SPINE_C_API float spine_physics_constraint_mass_timeline_get_relative_value(spine_physics_constraint_mass_timeline self, float time, float alpha,
@@ -42,8 +44,6 @@ SPINE_C_API size_t spine_physics_constraint_mass_timeline_get_frame_count(spine_
 SPINE_C_API spine_array_float spine_physics_constraint_mass_timeline_get_frames(spine_physics_constraint_mass_timeline self);
 SPINE_C_API float spine_physics_constraint_mass_timeline_get_duration(spine_physics_constraint_mass_timeline self);
 SPINE_C_API spine_array_property_id spine_physics_constraint_mass_timeline_get_property_ids(spine_physics_constraint_mass_timeline self);
-SPINE_C_API int spine_physics_constraint_mass_timeline_get_constraint_index(spine_physics_constraint_mass_timeline self);
-SPINE_C_API void spine_physics_constraint_mass_timeline_set_constraint_index(spine_physics_constraint_mass_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_physics_constraint_mass_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/physics_constraint_mix_timeline.cpp

@@ -26,6 +26,16 @@ void spine_physics_constraint_mix_timeline_apply(spine_physics_constraint_mix_ti
 				 appliedPose);
 }
 
+int spine_physics_constraint_mix_timeline_get_constraint_index(spine_physics_constraint_mix_timeline self) {
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -113,16 +123,6 @@ spine_array_property_id spine_physics_constraint_mix_timeline_get_property_ids(s
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_physics_constraint_mix_timeline_get_constraint_index(spine_physics_constraint_mix_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_physics_constraint_mix_timeline_rtti(void) {
 	return (spine_rtti) &PhysicsConstraintMixTimeline::rtti;
 }

spine-c/src/generated/physics_constraint_mix_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API spine_rtti spine_physics_constraint_mix_timeline_get_rtti(spine_phys
 SPINE_C_API void spine_physics_constraint_mix_timeline_apply(spine_physics_constraint_mix_timeline self, spine_skeleton skeleton, float lastTime,
 															 float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
 															 spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_physics_constraint_mix_timeline_get_constraint_index(spine_physics_constraint_mix_timeline self);
+SPINE_C_API void spine_physics_constraint_mix_timeline_set_constraint_index(spine_physics_constraint_mix_timeline self, int inValue);
 SPINE_C_API void spine_physics_constraint_mix_timeline_set_frame(spine_physics_constraint_mix_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_physics_constraint_mix_timeline_get_curve_value(spine_physics_constraint_mix_timeline self, float time);
 SPINE_C_API float spine_physics_constraint_mix_timeline_get_relative_value(spine_physics_constraint_mix_timeline self, float time, float alpha,
@@ -42,8 +44,6 @@ SPINE_C_API size_t spine_physics_constraint_mix_timeline_get_frame_count(spine_p
 SPINE_C_API spine_array_float spine_physics_constraint_mix_timeline_get_frames(spine_physics_constraint_mix_timeline self);
 SPINE_C_API float spine_physics_constraint_mix_timeline_get_duration(spine_physics_constraint_mix_timeline self);
 SPINE_C_API spine_array_property_id spine_physics_constraint_mix_timeline_get_property_ids(spine_physics_constraint_mix_timeline self);
-SPINE_C_API int spine_physics_constraint_mix_timeline_get_constraint_index(spine_physics_constraint_mix_timeline self);
-SPINE_C_API void spine_physics_constraint_mix_timeline_set_constraint_index(spine_physics_constraint_mix_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_physics_constraint_mix_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/physics_constraint_reset_timeline.cpp

@@ -34,6 +34,11 @@ int spine_physics_constraint_reset_timeline_get_constraint_index(spine_physics_c
 	return _self->getConstraintIndex();
 }
 
+void spine_physics_constraint_reset_timeline_set_constraint_index(spine_physics_constraint_reset_timeline self, int inValue) {
+	PhysicsConstraintResetTimeline *_self = (PhysicsConstraintResetTimeline *) self;
+	_self->setConstraintIndex(inValue);
+}
+
 void spine_physics_constraint_reset_timeline_set_frame(spine_physics_constraint_reset_timeline self, int frame, float time) {
 	PhysicsConstraintResetTimeline *_self = (PhysicsConstraintResetTimeline *) self;
 	_self->setFrame(frame, time);
@@ -59,11 +64,6 @@ spine_array_property_id spine_physics_constraint_reset_timeline_get_property_ids
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-void spine_physics_constraint_reset_timeline_set_constraint_index(spine_physics_constraint_reset_timeline self, int inValue) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (PhysicsConstraintResetTimeline *) self;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_physics_constraint_reset_timeline_rtti(void) {
 	return (spine_rtti) &PhysicsConstraintResetTimeline::rtti;
 }

spine-c/src/generated/physics_constraint_reset_timeline.h

@@ -19,12 +19,12 @@ SPINE_C_API void spine_physics_constraint_reset_timeline_apply(spine_physics_con
 															   spine_mix_direction direction, bool appliedPose);
 SPINE_C_API int spine_physics_constraint_reset_timeline_get_frame_count(spine_physics_constraint_reset_timeline self);
 SPINE_C_API int spine_physics_constraint_reset_timeline_get_constraint_index(spine_physics_constraint_reset_timeline self);
+SPINE_C_API void spine_physics_constraint_reset_timeline_set_constraint_index(spine_physics_constraint_reset_timeline self, int inValue);
 SPINE_C_API void spine_physics_constraint_reset_timeline_set_frame(spine_physics_constraint_reset_timeline self, int frame, float time);
 SPINE_C_API size_t spine_physics_constraint_reset_timeline_get_frame_entries(spine_physics_constraint_reset_timeline self);
 SPINE_C_API spine_array_float spine_physics_constraint_reset_timeline_get_frames(spine_physics_constraint_reset_timeline self);
 SPINE_C_API float spine_physics_constraint_reset_timeline_get_duration(spine_physics_constraint_reset_timeline self);
 SPINE_C_API spine_array_property_id spine_physics_constraint_reset_timeline_get_property_ids(spine_physics_constraint_reset_timeline self);
-SPINE_C_API void spine_physics_constraint_reset_timeline_set_constraint_index(spine_physics_constraint_reset_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_physics_constraint_reset_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/physics_constraint_strength_timeline.cpp

@@ -26,6 +26,16 @@ void spine_physics_constraint_strength_timeline_apply(spine_physics_constraint_s
 				 appliedPose);
 }
 
+int spine_physics_constraint_strength_timeline_get_constraint_index(spine_physics_constraint_strength_timeline self) {
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -113,16 +123,6 @@ spine_array_property_id spine_physics_constraint_strength_timeline_get_property_
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_physics_constraint_strength_timeline_get_constraint_index(spine_physics_constraint_strength_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_physics_constraint_strength_timeline_rtti(void) {
 	return (spine_rtti) &PhysicsConstraintStrengthTimeline::rtti;
 }

spine-c/src/generated/physics_constraint_strength_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API spine_rtti spine_physics_constraint_strength_timeline_get_rtti(spine
 SPINE_C_API void spine_physics_constraint_strength_timeline_apply(spine_physics_constraint_strength_timeline self, spine_skeleton skeleton,
 																  float lastTime, float time, spine_array_event pEvents, float alpha,
 																  spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_physics_constraint_strength_timeline_get_constraint_index(spine_physics_constraint_strength_timeline self);
+SPINE_C_API void spine_physics_constraint_strength_timeline_set_constraint_index(spine_physics_constraint_strength_timeline self, int inValue);
 SPINE_C_API void spine_physics_constraint_strength_timeline_set_frame(spine_physics_constraint_strength_timeline self, size_t frame, float time,
 																	  float value);
 SPINE_C_API float spine_physics_constraint_strength_timeline_get_curve_value(spine_physics_constraint_strength_timeline self, float time);
@@ -44,8 +46,6 @@ SPINE_C_API size_t spine_physics_constraint_strength_timeline_get_frame_count(sp
 SPINE_C_API spine_array_float spine_physics_constraint_strength_timeline_get_frames(spine_physics_constraint_strength_timeline self);
 SPINE_C_API float spine_physics_constraint_strength_timeline_get_duration(spine_physics_constraint_strength_timeline self);
 SPINE_C_API spine_array_property_id spine_physics_constraint_strength_timeline_get_property_ids(spine_physics_constraint_strength_timeline self);
-SPINE_C_API int spine_physics_constraint_strength_timeline_get_constraint_index(spine_physics_constraint_strength_timeline self);
-SPINE_C_API void spine_physics_constraint_strength_timeline_set_constraint_index(spine_physics_constraint_strength_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_physics_constraint_strength_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/physics_constraint_timeline.cpp

@@ -20,6 +20,16 @@ void spine_physics_constraint_timeline_apply(spine_physics_constraint_timeline s
 				 appliedPose);
 }
 
+int spine_physics_constraint_timeline_get_constraint_index(spine_physics_constraint_timeline self) {
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
+	return _self->getConstraintIndex();
+}
+
+void spine_physics_constraint_timeline_set_constraint_index(spine_physics_constraint_timeline self, int inValue) {
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
+	_self->setConstraintIndex(inValue);
+}
+
 void spine_physics_constraint_timeline_set_frame(spine_physics_constraint_timeline self, size_t frame, float time, float value) {
 	CurveTimeline1 *_self = (CurveTimeline1 *) (PhysicsConstraintTimeline *) self;
 	_self->setFrame(frame, time, value);
@@ -106,16 +116,6 @@ spine_array_property_id spine_physics_constraint_timeline_get_property_ids(spine
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_physics_constraint_timeline_get_constraint_index(spine_physics_constraint_timeline self) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (PhysicsConstraintTimeline *) self;
-	return _self->getConstraintIndex();
-}
-
-void spine_physics_constraint_timeline_set_constraint_index(spine_physics_constraint_timeline self, int inValue) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (PhysicsConstraintTimeline *) self;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_physics_constraint_timeline_rtti(void) {
 	return (spine_rtti) &PhysicsConstraintTimeline::rtti;
 }

spine-c/src/generated/physics_constraint_timeline.h

@@ -15,6 +15,8 @@ SPINE_C_API spine_rtti spine_physics_constraint_timeline_get_rtti(spine_physics_
 SPINE_C_API void spine_physics_constraint_timeline_apply(spine_physics_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
 														 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 														 bool appliedPose);
+SPINE_C_API int spine_physics_constraint_timeline_get_constraint_index(spine_physics_constraint_timeline self);
+SPINE_C_API void spine_physics_constraint_timeline_set_constraint_index(spine_physics_constraint_timeline self, int inValue);
 SPINE_C_API void spine_physics_constraint_timeline_set_frame(spine_physics_constraint_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_physics_constraint_timeline_get_curve_value(spine_physics_constraint_timeline self, float time);
 SPINE_C_API float spine_physics_constraint_timeline_get_relative_value(spine_physics_constraint_timeline self, float time, float alpha,
@@ -38,8 +40,6 @@ SPINE_C_API size_t spine_physics_constraint_timeline_get_frame_count(spine_physi
 SPINE_C_API spine_array_float spine_physics_constraint_timeline_get_frames(spine_physics_constraint_timeline self);
 SPINE_C_API float spine_physics_constraint_timeline_get_duration(spine_physics_constraint_timeline self);
 SPINE_C_API spine_array_property_id spine_physics_constraint_timeline_get_property_ids(spine_physics_constraint_timeline self);
-SPINE_C_API int spine_physics_constraint_timeline_get_constraint_index(spine_physics_constraint_timeline self);
-SPINE_C_API void spine_physics_constraint_timeline_set_constraint_index(spine_physics_constraint_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_physics_constraint_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/physics_constraint_wind_timeline.cpp

@@ -26,6 +26,16 @@ void spine_physics_constraint_wind_timeline_apply(spine_physics_constraint_wind_
 				 appliedPose);
 }
 
+int spine_physics_constraint_wind_timeline_get_constraint_index(spine_physics_constraint_wind_timeline self) {
+	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -113,16 +123,6 @@ spine_array_property_id spine_physics_constraint_wind_timeline_get_property_ids(
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_physics_constraint_wind_timeline_get_constraint_index(spine_physics_constraint_wind_timeline self) {
-	PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (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;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_physics_constraint_wind_timeline_rtti(void) {
 	return (spine_rtti) &PhysicsConstraintWindTimeline::rtti;
 }

spine-c/src/generated/physics_constraint_wind_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API spine_rtti spine_physics_constraint_wind_timeline_get_rtti(spine_phy
 SPINE_C_API void spine_physics_constraint_wind_timeline_apply(spine_physics_constraint_wind_timeline self, spine_skeleton skeleton, float lastTime,
 															  float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
 															  spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_physics_constraint_wind_timeline_get_constraint_index(spine_physics_constraint_wind_timeline self);
+SPINE_C_API void spine_physics_constraint_wind_timeline_set_constraint_index(spine_physics_constraint_wind_timeline self, int inValue);
 SPINE_C_API void spine_physics_constraint_wind_timeline_set_frame(spine_physics_constraint_wind_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_physics_constraint_wind_timeline_get_curve_value(spine_physics_constraint_wind_timeline self, float time);
 SPINE_C_API float spine_physics_constraint_wind_timeline_get_relative_value(spine_physics_constraint_wind_timeline self, float time, float alpha,
@@ -42,8 +44,6 @@ SPINE_C_API size_t spine_physics_constraint_wind_timeline_get_frame_count(spine_
 SPINE_C_API spine_array_float spine_physics_constraint_wind_timeline_get_frames(spine_physics_constraint_wind_timeline self);
 SPINE_C_API float spine_physics_constraint_wind_timeline_get_duration(spine_physics_constraint_wind_timeline self);
 SPINE_C_API spine_array_property_id spine_physics_constraint_wind_timeline_get_property_ids(spine_physics_constraint_wind_timeline self);
-SPINE_C_API int spine_physics_constraint_wind_timeline_get_constraint_index(spine_physics_constraint_wind_timeline self);
-SPINE_C_API void spine_physics_constraint_wind_timeline_set_constraint_index(spine_physics_constraint_wind_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_physics_constraint_wind_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/rgb2_timeline.cpp

@@ -28,6 +28,16 @@ void spine_rgb2_timeline_apply(spine_rgb2_timeline self, spine_skeleton skeleton
 				 appliedPose);
 }
 
+int spine_rgb2_timeline_get_slot_index(spine_rgb2_timeline self) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	return _self->getSlotIndex();
+}
+
+void spine_rgb2_timeline_set_slot_index(spine_rgb2_timeline self, int inValue) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
+	_self->setSlotIndex(inValue);
+}
+
 void spine_rgb2_timeline_set_linear(spine_rgb2_timeline self, size_t frame) {
 	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
 	_self->setLinear(frame);
@@ -79,16 +89,6 @@ spine_array_property_id spine_rgb2_timeline_get_property_ids(spine_rgb2_timeline
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_rgb2_timeline_get_slot_index(spine_rgb2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
-	return _self->getSlotIndex();
-}
-
-void spine_rgb2_timeline_set_slot_index(spine_rgb2_timeline self, int inValue) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGB2Timeline *) self;
-	_self->setSlotIndex(inValue);
-}
-
 spine_rtti spine_rgb2_timeline_rtti(void) {
 	return (spine_rtti) &RGB2Timeline::rtti;
 }

spine-c/src/generated/rgb2_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API void spine_rgb2_timeline_set_frame(spine_rgb2_timeline self, int fra
 											   float b2);
 SPINE_C_API void spine_rgb2_timeline_apply(spine_rgb2_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
 										   float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_rgb2_timeline_get_slot_index(spine_rgb2_timeline self);
+SPINE_C_API void spine_rgb2_timeline_set_slot_index(spine_rgb2_timeline self, int inValue);
 SPINE_C_API void spine_rgb2_timeline_set_linear(spine_rgb2_timeline self, size_t frame);
 SPINE_C_API void spine_rgb2_timeline_set_stepped(spine_rgb2_timeline self, size_t frame);
 SPINE_C_API void spine_rgb2_timeline_set_bezier(spine_rgb2_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
@@ -29,8 +31,6 @@ SPINE_C_API size_t spine_rgb2_timeline_get_frame_count(spine_rgb2_timeline self)
 SPINE_C_API spine_array_float spine_rgb2_timeline_get_frames(spine_rgb2_timeline self);
 SPINE_C_API float spine_rgb2_timeline_get_duration(spine_rgb2_timeline self);
 SPINE_C_API spine_array_property_id spine_rgb2_timeline_get_property_ids(spine_rgb2_timeline self);
-SPINE_C_API int spine_rgb2_timeline_get_slot_index(spine_rgb2_timeline self);
-SPINE_C_API void spine_rgb2_timeline_set_slot_index(spine_rgb2_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_rgb2_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/rgb_timeline.cpp

@@ -28,6 +28,16 @@ void spine_rgb_timeline_apply(spine_rgb_timeline self, spine_skeleton skeleton,
 				 appliedPose);
 }
 
+int spine_rgb_timeline_get_slot_index(spine_rgb_timeline self) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	return _self->getSlotIndex();
+}
+
+void spine_rgb_timeline_set_slot_index(spine_rgb_timeline self, int inValue) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
+	_self->setSlotIndex(inValue);
+}
+
 void spine_rgb_timeline_set_linear(spine_rgb_timeline self, size_t frame) {
 	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
 	_self->setLinear(frame);
@@ -79,16 +89,6 @@ spine_array_property_id spine_rgb_timeline_get_property_ids(spine_rgb_timeline s
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_rgb_timeline_get_slot_index(spine_rgb_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
-	return _self->getSlotIndex();
-}
-
-void spine_rgb_timeline_set_slot_index(spine_rgb_timeline self, int inValue) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBTimeline *) self;
-	_self->setSlotIndex(inValue);
-}
-
 spine_rtti spine_rgb_timeline_rtti(void) {
 	return (spine_rtti) &RGBTimeline::rtti;
 }

spine-c/src/generated/rgb_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_rgb_timeline_get_rtti(spine_rgb_timeline self);
 SPINE_C_API void spine_rgb_timeline_set_frame(spine_rgb_timeline self, int frame, float time, float r, float g, float b);
 SPINE_C_API void spine_rgb_timeline_apply(spine_rgb_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
 										  float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_rgb_timeline_get_slot_index(spine_rgb_timeline self);
+SPINE_C_API void spine_rgb_timeline_set_slot_index(spine_rgb_timeline self, int inValue);
 SPINE_C_API void spine_rgb_timeline_set_linear(spine_rgb_timeline self, size_t frame);
 SPINE_C_API void spine_rgb_timeline_set_stepped(spine_rgb_timeline self, size_t frame);
 SPINE_C_API void spine_rgb_timeline_set_bezier(spine_rgb_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
@@ -28,8 +30,6 @@ SPINE_C_API size_t spine_rgb_timeline_get_frame_count(spine_rgb_timeline self);
 SPINE_C_API spine_array_float spine_rgb_timeline_get_frames(spine_rgb_timeline self);
 SPINE_C_API float spine_rgb_timeline_get_duration(spine_rgb_timeline self);
 SPINE_C_API spine_array_property_id spine_rgb_timeline_get_property_ids(spine_rgb_timeline self);
-SPINE_C_API int spine_rgb_timeline_get_slot_index(spine_rgb_timeline self);
-SPINE_C_API void spine_rgb_timeline_set_slot_index(spine_rgb_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_rgb_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/rgba2_timeline.cpp

@@ -29,6 +29,16 @@ void spine_rgba2_timeline_apply(spine_rgba2_timeline self, spine_skeleton skelet
 				 appliedPose);
 }
 
+int spine_rgba2_timeline_get_slot_index(spine_rgba2_timeline self) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	return _self->getSlotIndex();
+}
+
+void spine_rgba2_timeline_set_slot_index(spine_rgba2_timeline self, int inValue) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
+	_self->setSlotIndex(inValue);
+}
+
 void spine_rgba2_timeline_set_linear(spine_rgba2_timeline self, size_t frame) {
 	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
 	_self->setLinear(frame);
@@ -80,16 +90,6 @@ spine_array_property_id spine_rgba2_timeline_get_property_ids(spine_rgba2_timeli
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_rgba2_timeline_get_slot_index(spine_rgba2_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
-	return _self->getSlotIndex();
-}
-
-void spine_rgba2_timeline_set_slot_index(spine_rgba2_timeline self, int inValue) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBA2Timeline *) self;
-	_self->setSlotIndex(inValue);
-}
-
 spine_rtti spine_rgba2_timeline_rtti(void) {
 	return (spine_rtti) &RGBA2Timeline::rtti;
 }

spine-c/src/generated/rgba2_timeline.h

@@ -18,6 +18,8 @@ SPINE_C_API void spine_rgba2_timeline_set_frame(spine_rgba2_timeline self, int f
 												float g2, float b2);
 SPINE_C_API void spine_rgba2_timeline_apply(spine_rgba2_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
 											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_rgba2_timeline_get_slot_index(spine_rgba2_timeline self);
+SPINE_C_API void spine_rgba2_timeline_set_slot_index(spine_rgba2_timeline self, int inValue);
 SPINE_C_API void spine_rgba2_timeline_set_linear(spine_rgba2_timeline self, size_t frame);
 SPINE_C_API void spine_rgba2_timeline_set_stepped(spine_rgba2_timeline self, size_t frame);
 SPINE_C_API void spine_rgba2_timeline_set_bezier(spine_rgba2_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
@@ -29,8 +31,6 @@ SPINE_C_API size_t spine_rgba2_timeline_get_frame_count(spine_rgba2_timeline sel
 SPINE_C_API spine_array_float spine_rgba2_timeline_get_frames(spine_rgba2_timeline self);
 SPINE_C_API float spine_rgba2_timeline_get_duration(spine_rgba2_timeline self);
 SPINE_C_API spine_array_property_id spine_rgba2_timeline_get_property_ids(spine_rgba2_timeline self);
-SPINE_C_API int spine_rgba2_timeline_get_slot_index(spine_rgba2_timeline self);
-SPINE_C_API void spine_rgba2_timeline_set_slot_index(spine_rgba2_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_rgba2_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/rgba_timeline.cpp

@@ -28,6 +28,16 @@ void spine_rgba_timeline_apply(spine_rgba_timeline self, spine_skeleton skeleton
 				 appliedPose);
 }
 
+int spine_rgba_timeline_get_slot_index(spine_rgba_timeline self) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	return _self->getSlotIndex();
+}
+
+void spine_rgba_timeline_set_slot_index(spine_rgba_timeline self, int inValue) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
+	_self->setSlotIndex(inValue);
+}
+
 void spine_rgba_timeline_set_linear(spine_rgba_timeline self, size_t frame) {
 	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
 	_self->setLinear(frame);
@@ -79,16 +89,6 @@ spine_array_property_id spine_rgba_timeline_get_property_ids(spine_rgba_timeline
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_rgba_timeline_get_slot_index(spine_rgba_timeline self) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
-	return _self->getSlotIndex();
-}
-
-void spine_rgba_timeline_set_slot_index(spine_rgba_timeline self, int inValue) {
-	SlotCurveTimeline *_self = (SlotCurveTimeline *) (RGBATimeline *) self;
-	_self->setSlotIndex(inValue);
-}
-
 spine_rtti spine_rgba_timeline_rtti(void) {
 	return (spine_rtti) &RGBATimeline::rtti;
 }

spine-c/src/generated/rgba_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_rgba_timeline_get_rtti(spine_rgba_timeline self);
 SPINE_C_API void spine_rgba_timeline_set_frame(spine_rgba_timeline self, int frame, float time, float r, float g, float b, float a);
 SPINE_C_API void spine_rgba_timeline_apply(spine_rgba_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
 										   float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_rgba_timeline_get_slot_index(spine_rgba_timeline self);
+SPINE_C_API void spine_rgba_timeline_set_slot_index(spine_rgba_timeline self, int inValue);
 SPINE_C_API void spine_rgba_timeline_set_linear(spine_rgba_timeline self, size_t frame);
 SPINE_C_API void spine_rgba_timeline_set_stepped(spine_rgba_timeline self, size_t frame);
 SPINE_C_API void spine_rgba_timeline_set_bezier(spine_rgba_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
@@ -28,8 +30,6 @@ SPINE_C_API size_t spine_rgba_timeline_get_frame_count(spine_rgba_timeline self)
 SPINE_C_API spine_array_float spine_rgba_timeline_get_frames(spine_rgba_timeline self);
 SPINE_C_API float spine_rgba_timeline_get_duration(spine_rgba_timeline self);
 SPINE_C_API spine_array_property_id spine_rgba_timeline_get_property_ids(spine_rgba_timeline self);
-SPINE_C_API int spine_rgba_timeline_get_slot_index(spine_rgba_timeline self);
-SPINE_C_API void spine_rgba_timeline_set_slot_index(spine_rgba_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_rgba_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/rotate_timeline.cpp

@@ -23,6 +23,16 @@ void spine_rotate_timeline_apply(spine_rotate_timeline self, spine_skeleton skel
 				 appliedPose);
 }
 
+int spine_rotate_timeline_get_bone_index(spine_rotate_timeline self) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
+	return _self->getBoneIndex();
+}
+
+void spine_rotate_timeline_set_bone_index(spine_rotate_timeline self, int inValue) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
 	_self->setFrame(frame, time, value);
@@ -108,16 +118,6 @@ spine_array_property_id spine_rotate_timeline_get_property_ids(spine_rotate_time
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_rotate_timeline_get_bone_index(spine_rotate_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
-	return _self->getBoneIndex();
-}
-
-void spine_rotate_timeline_set_bone_index(spine_rotate_timeline self, int inValue) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (RotateTimeline *) self;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_rotate_timeline_rtti(void) {
 	return (spine_rtti) &RotateTimeline::rtti;
 }

spine-c/src/generated/rotate_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_rotate_timeline_get_rtti(spine_rotate_timeline self
 SPINE_C_API void spine_rotate_timeline_apply(spine_rotate_timeline self, spine_skeleton skeleton, float lastTime, float time,
 											 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											 bool appliedPose);
+SPINE_C_API int spine_rotate_timeline_get_bone_index(spine_rotate_timeline self);
+SPINE_C_API void spine_rotate_timeline_set_bone_index(spine_rotate_timeline self, int inValue);
 SPINE_C_API void spine_rotate_timeline_set_frame(spine_rotate_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_rotate_timeline_get_curve_value(spine_rotate_timeline self, float time);
 SPINE_C_API float spine_rotate_timeline_get_relative_value(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend, float current,
@@ -38,8 +40,6 @@ SPINE_C_API size_t spine_rotate_timeline_get_frame_count(spine_rotate_timeline s
 SPINE_C_API spine_array_float spine_rotate_timeline_get_frames(spine_rotate_timeline self);
 SPINE_C_API float spine_rotate_timeline_get_duration(spine_rotate_timeline self);
 SPINE_C_API spine_array_property_id spine_rotate_timeline_get_property_ids(spine_rotate_timeline self);
-SPINE_C_API int spine_rotate_timeline_get_bone_index(spine_rotate_timeline self);
-SPINE_C_API void spine_rotate_timeline_set_bone_index(spine_rotate_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_rotate_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/scale_timeline.cpp

@@ -23,14 +23,19 @@ void spine_scale_timeline_apply(spine_scale_timeline self, spine_skeleton skelet
 				 appliedPose);
 }
 
-void spine_scale_timeline_set_frame(spine_scale_timeline self, size_t frame, float time, float value1, float value2) {
+int spine_scale_timeline_get_bone_index(spine_scale_timeline self) {
 	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
-	_self->setFrame(frame, time, value1, value2);
+	return _self->getBoneIndex();
 }
 
-float spine_scale_timeline_get_curve_value(spine_scale_timeline self, float time) {
+void spine_scale_timeline_set_bone_index(spine_scale_timeline self, int inValue) {
 	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
-	return _self->getCurveValue(time);
+	_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;
+	_self->setFrame(frame, time, value1, value2);
 }
 
 void spine_scale_timeline_set_linear(spine_scale_timeline self, size_t frame) {
@@ -84,16 +89,6 @@ spine_array_property_id spine_scale_timeline_get_property_ids(spine_scale_timeli
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_scale_timeline_get_bone_index(spine_scale_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
-	return _self->getBoneIndex();
-}
-
-void spine_scale_timeline_set_bone_index(spine_scale_timeline self, int inValue) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ScaleTimeline *) self;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_scale_timeline_rtti(void) {
 	return (spine_rtti) &ScaleTimeline::rtti;
 }

spine-c/src/generated/scale_timeline.h

@@ -16,8 +16,9 @@ SPINE_C_API void spine_scale_timeline_dispose(spine_scale_timeline self);
 SPINE_C_API spine_rtti spine_scale_timeline_get_rtti(spine_scale_timeline self);
 SPINE_C_API void spine_scale_timeline_apply(spine_scale_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
 											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_scale_timeline_get_bone_index(spine_scale_timeline self);
+SPINE_C_API void spine_scale_timeline_set_bone_index(spine_scale_timeline self, int inValue);
 SPINE_C_API void spine_scale_timeline_set_frame(spine_scale_timeline self, size_t frame, float time, float value1, float value2);
-SPINE_C_API float spine_scale_timeline_get_curve_value(spine_scale_timeline self, float time);
 SPINE_C_API void spine_scale_timeline_set_linear(spine_scale_timeline self, size_t frame);
 SPINE_C_API void spine_scale_timeline_set_stepped(spine_scale_timeline self, size_t frame);
 SPINE_C_API void spine_scale_timeline_set_bezier(spine_scale_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
@@ -29,8 +30,6 @@ SPINE_C_API size_t spine_scale_timeline_get_frame_count(spine_scale_timeline sel
 SPINE_C_API spine_array_float spine_scale_timeline_get_frames(spine_scale_timeline self);
 SPINE_C_API float spine_scale_timeline_get_duration(spine_scale_timeline self);
 SPINE_C_API spine_array_property_id spine_scale_timeline_get_property_ids(spine_scale_timeline self);
-SPINE_C_API int spine_scale_timeline_get_bone_index(spine_scale_timeline self);
-SPINE_C_API void spine_scale_timeline_set_bone_index(spine_scale_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_scale_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/scale_x_timeline.cpp

@@ -23,6 +23,16 @@ void spine_scale_x_timeline_apply(spine_scale_x_timeline self, spine_skeleton sk
 				 appliedPose);
 }
 
+int spine_scale_x_timeline_get_bone_index(spine_scale_x_timeline self) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -108,16 +118,6 @@ spine_array_property_id spine_scale_x_timeline_get_property_ids(spine_scale_x_ti
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_scale_x_timeline_get_bone_index(spine_scale_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_scale_x_timeline_rtti(void) {
 	return (spine_rtti) &ScaleXTimeline::rtti;
 }

spine-c/src/generated/scale_x_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_scale_x_timeline_get_rtti(spine_scale_x_timeline se
 SPINE_C_API void spine_scale_x_timeline_apply(spine_scale_x_timeline self, spine_skeleton skeleton, float lastTime, float time,
 											  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											  bool appliedPose);
+SPINE_C_API int spine_scale_x_timeline_get_bone_index(spine_scale_x_timeline self);
+SPINE_C_API void spine_scale_x_timeline_set_bone_index(spine_scale_x_timeline self, int inValue);
 SPINE_C_API void spine_scale_x_timeline_set_frame(spine_scale_x_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_scale_x_timeline_get_curve_value(spine_scale_x_timeline self, float time);
 SPINE_C_API float spine_scale_x_timeline_get_relative_value(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend,
@@ -38,8 +40,6 @@ SPINE_C_API size_t spine_scale_x_timeline_get_frame_count(spine_scale_x_timeline
 SPINE_C_API spine_array_float spine_scale_x_timeline_get_frames(spine_scale_x_timeline self);
 SPINE_C_API float spine_scale_x_timeline_get_duration(spine_scale_x_timeline self);
 SPINE_C_API spine_array_property_id spine_scale_x_timeline_get_property_ids(spine_scale_x_timeline self);
-SPINE_C_API int spine_scale_x_timeline_get_bone_index(spine_scale_x_timeline self);
-SPINE_C_API void spine_scale_x_timeline_set_bone_index(spine_scale_x_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_scale_x_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/scale_y_timeline.cpp

@@ -23,6 +23,16 @@ void spine_scale_y_timeline_apply(spine_scale_y_timeline self, spine_skeleton sk
 				 appliedPose);
 }
 
+int spine_scale_y_timeline_get_bone_index(spine_scale_y_timeline self) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -108,16 +118,6 @@ spine_array_property_id spine_scale_y_timeline_get_property_ids(spine_scale_y_ti
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_scale_y_timeline_get_bone_index(spine_scale_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_scale_y_timeline_rtti(void) {
 	return (spine_rtti) &ScaleYTimeline::rtti;
 }

spine-c/src/generated/scale_y_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_scale_y_timeline_get_rtti(spine_scale_y_timeline se
 SPINE_C_API void spine_scale_y_timeline_apply(spine_scale_y_timeline self, spine_skeleton skeleton, float lastTime, float time,
 											  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											  bool appliedPose);
+SPINE_C_API int spine_scale_y_timeline_get_bone_index(spine_scale_y_timeline self);
+SPINE_C_API void spine_scale_y_timeline_set_bone_index(spine_scale_y_timeline self, int inValue);
 SPINE_C_API void spine_scale_y_timeline_set_frame(spine_scale_y_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_scale_y_timeline_get_curve_value(spine_scale_y_timeline self, float time);
 SPINE_C_API float spine_scale_y_timeline_get_relative_value(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend,
@@ -38,8 +40,6 @@ SPINE_C_API size_t spine_scale_y_timeline_get_frame_count(spine_scale_y_timeline
 SPINE_C_API spine_array_float spine_scale_y_timeline_get_frames(spine_scale_y_timeline self);
 SPINE_C_API float spine_scale_y_timeline_get_duration(spine_scale_y_timeline self);
 SPINE_C_API spine_array_property_id spine_scale_y_timeline_get_property_ids(spine_scale_y_timeline self);
-SPINE_C_API int spine_scale_y_timeline_get_bone_index(spine_scale_y_timeline self);
-SPINE_C_API void spine_scale_y_timeline_set_bone_index(spine_scale_y_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_scale_y_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/sequence_timeline.cpp

@@ -33,6 +33,16 @@ spine_attachment spine_sequence_timeline_get_attachment(spine_sequence_timeline
 	return (spine_attachment) _self->getAttachment();
 }
 
+int spine_sequence_timeline_get_slot_index(spine_sequence_timeline self) {
+	SequenceTimeline *_self = (SequenceTimeline *) self;
+	return _self->getSlotIndex();
+}
+
+void spine_sequence_timeline_set_slot_index(spine_sequence_timeline self, int inValue) {
+	SequenceTimeline *_self = (SequenceTimeline *) self;
+	_self->setSlotIndex(inValue);
+}
+
 size_t spine_sequence_timeline_get_frame_entries(spine_sequence_timeline self) {
 	Timeline *_self = (Timeline *) (SequenceTimeline *) self;
 	return _self->getFrameEntries();
@@ -58,16 +68,6 @@ spine_array_property_id spine_sequence_timeline_get_property_ids(spine_sequence_
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_sequence_timeline_get_slot_index(spine_sequence_timeline self) {
-	SlotTimeline *_self = (SlotTimeline *) (SequenceTimeline *) self;
-	return _self->getSlotIndex();
-}
-
-void spine_sequence_timeline_set_slot_index(spine_sequence_timeline self, int inValue) {
-	SlotTimeline *_self = (SlotTimeline *) (SequenceTimeline *) self;
-	_self->setSlotIndex(inValue);
-}
-
 spine_rtti spine_sequence_timeline_rtti(void) {
 	return (spine_rtti) &SequenceTimeline::rtti;
 }

spine-c/src/generated/sequence_timeline.h

@@ -20,13 +20,13 @@ SPINE_C_API void spine_sequence_timeline_apply(spine_sequence_timeline self, spi
 SPINE_C_API void spine_sequence_timeline_set_frame(spine_sequence_timeline self, int frame, float time, spine_sequence_mode mode, int index,
 												   float delay);
 SPINE_C_API spine_attachment spine_sequence_timeline_get_attachment(spine_sequence_timeline self);
+SPINE_C_API int spine_sequence_timeline_get_slot_index(spine_sequence_timeline self);
+SPINE_C_API void spine_sequence_timeline_set_slot_index(spine_sequence_timeline self, int inValue);
 SPINE_C_API size_t spine_sequence_timeline_get_frame_entries(spine_sequence_timeline self);
 SPINE_C_API size_t spine_sequence_timeline_get_frame_count(spine_sequence_timeline self);
 SPINE_C_API spine_array_float spine_sequence_timeline_get_frames(spine_sequence_timeline self);
 SPINE_C_API float spine_sequence_timeline_get_duration(spine_sequence_timeline self);
 SPINE_C_API spine_array_property_id spine_sequence_timeline_get_property_ids(spine_sequence_timeline self);
-SPINE_C_API int spine_sequence_timeline_get_slot_index(spine_sequence_timeline self);
-SPINE_C_API void spine_sequence_timeline_set_slot_index(spine_sequence_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_sequence_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/shear_timeline.cpp

@@ -23,14 +23,19 @@ void spine_shear_timeline_apply(spine_shear_timeline self, spine_skeleton skelet
 				 appliedPose);
 }
 
-void spine_shear_timeline_set_frame(spine_shear_timeline self, size_t frame, float time, float value1, float value2) {
+int spine_shear_timeline_get_bone_index(spine_shear_timeline self) {
 	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
-	_self->setFrame(frame, time, value1, value2);
+	return _self->getBoneIndex();
 }
 
-float spine_shear_timeline_get_curve_value(spine_shear_timeline self, float time) {
+void spine_shear_timeline_set_bone_index(spine_shear_timeline self, int inValue) {
 	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
-	return _self->getCurveValue(time);
+	_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;
+	_self->setFrame(frame, time, value1, value2);
 }
 
 void spine_shear_timeline_set_linear(spine_shear_timeline self, size_t frame) {
@@ -84,16 +89,6 @@ spine_array_property_id spine_shear_timeline_get_property_ids(spine_shear_timeli
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_shear_timeline_get_bone_index(spine_shear_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
-	return _self->getBoneIndex();
-}
-
-void spine_shear_timeline_set_bone_index(spine_shear_timeline self, int inValue) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (ShearTimeline *) self;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_shear_timeline_rtti(void) {
 	return (spine_rtti) &ShearTimeline::rtti;
 }

spine-c/src/generated/shear_timeline.h

@@ -16,8 +16,9 @@ SPINE_C_API void spine_shear_timeline_dispose(spine_shear_timeline self);
 SPINE_C_API spine_rtti spine_shear_timeline_get_rtti(spine_shear_timeline self);
 SPINE_C_API void spine_shear_timeline_apply(spine_shear_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
 											float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
+SPINE_C_API int spine_shear_timeline_get_bone_index(spine_shear_timeline self);
+SPINE_C_API void spine_shear_timeline_set_bone_index(spine_shear_timeline self, int inValue);
 SPINE_C_API void spine_shear_timeline_set_frame(spine_shear_timeline self, size_t frame, float time, float value1, float value2);
-SPINE_C_API float spine_shear_timeline_get_curve_value(spine_shear_timeline self, float time);
 SPINE_C_API void spine_shear_timeline_set_linear(spine_shear_timeline self, size_t frame);
 SPINE_C_API void spine_shear_timeline_set_stepped(spine_shear_timeline self, size_t frame);
 SPINE_C_API void spine_shear_timeline_set_bezier(spine_shear_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
@@ -29,8 +30,6 @@ SPINE_C_API size_t spine_shear_timeline_get_frame_count(spine_shear_timeline sel
 SPINE_C_API spine_array_float spine_shear_timeline_get_frames(spine_shear_timeline self);
 SPINE_C_API float spine_shear_timeline_get_duration(spine_shear_timeline self);
 SPINE_C_API spine_array_property_id spine_shear_timeline_get_property_ids(spine_shear_timeline self);
-SPINE_C_API int spine_shear_timeline_get_bone_index(spine_shear_timeline self);
-SPINE_C_API void spine_shear_timeline_set_bone_index(spine_shear_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_shear_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/shear_x_timeline.cpp

@@ -23,6 +23,16 @@ void spine_shear_x_timeline_apply(spine_shear_x_timeline self, spine_skeleton sk
 				 appliedPose);
 }
 
+int spine_shear_x_timeline_get_bone_index(spine_shear_x_timeline self) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -108,16 +118,6 @@ spine_array_property_id spine_shear_x_timeline_get_property_ids(spine_shear_x_ti
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_shear_x_timeline_get_bone_index(spine_shear_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_shear_x_timeline_rtti(void) {
 	return (spine_rtti) &ShearXTimeline::rtti;
 }

spine-c/src/generated/shear_x_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_shear_x_timeline_get_rtti(spine_shear_x_timeline se
 SPINE_C_API void spine_shear_x_timeline_apply(spine_shear_x_timeline self, spine_skeleton skeleton, float lastTime, float time,
 											  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											  bool appliedPose);
+SPINE_C_API int spine_shear_x_timeline_get_bone_index(spine_shear_x_timeline self);
+SPINE_C_API void spine_shear_x_timeline_set_bone_index(spine_shear_x_timeline self, int inValue);
 SPINE_C_API void spine_shear_x_timeline_set_frame(spine_shear_x_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_shear_x_timeline_get_curve_value(spine_shear_x_timeline self, float time);
 SPINE_C_API float spine_shear_x_timeline_get_relative_value(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend,
@@ -38,8 +40,6 @@ SPINE_C_API size_t spine_shear_x_timeline_get_frame_count(spine_shear_x_timeline
 SPINE_C_API spine_array_float spine_shear_x_timeline_get_frames(spine_shear_x_timeline self);
 SPINE_C_API float spine_shear_x_timeline_get_duration(spine_shear_x_timeline self);
 SPINE_C_API spine_array_property_id spine_shear_x_timeline_get_property_ids(spine_shear_x_timeline self);
-SPINE_C_API int spine_shear_x_timeline_get_bone_index(spine_shear_x_timeline self);
-SPINE_C_API void spine_shear_x_timeline_set_bone_index(spine_shear_x_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_shear_x_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/shear_y_timeline.cpp

@@ -23,6 +23,16 @@ void spine_shear_y_timeline_apply(spine_shear_y_timeline self, spine_skeleton sk
 				 appliedPose);
 }
 
+int spine_shear_y_timeline_get_bone_index(spine_shear_y_timeline self) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -108,16 +118,6 @@ spine_array_property_id spine_shear_y_timeline_get_property_ids(spine_shear_y_ti
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_shear_y_timeline_get_bone_index(spine_shear_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_shear_y_timeline_rtti(void) {
 	return (spine_rtti) &ShearYTimeline::rtti;
 }

spine-c/src/generated/shear_y_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_shear_y_timeline_get_rtti(spine_shear_y_timeline se
 SPINE_C_API void spine_shear_y_timeline_apply(spine_shear_y_timeline self, spine_skeleton skeleton, float lastTime, float time,
 											  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											  bool appliedPose);
+SPINE_C_API int spine_shear_y_timeline_get_bone_index(spine_shear_y_timeline self);
+SPINE_C_API void spine_shear_y_timeline_set_bone_index(spine_shear_y_timeline self, int inValue);
 SPINE_C_API void spine_shear_y_timeline_set_frame(spine_shear_y_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_shear_y_timeline_get_curve_value(spine_shear_y_timeline self, float time);
 SPINE_C_API float spine_shear_y_timeline_get_relative_value(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend,
@@ -38,8 +40,6 @@ SPINE_C_API size_t spine_shear_y_timeline_get_frame_count(spine_shear_y_timeline
 SPINE_C_API spine_array_float spine_shear_y_timeline_get_frames(spine_shear_y_timeline self);
 SPINE_C_API float spine_shear_y_timeline_get_duration(spine_shear_y_timeline self);
 SPINE_C_API spine_array_property_id spine_shear_y_timeline_get_property_ids(spine_shear_y_timeline self);
-SPINE_C_API int spine_shear_y_timeline_get_bone_index(spine_shear_y_timeline self);
-SPINE_C_API void spine_shear_y_timeline_set_bone_index(spine_shear_y_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_shear_y_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/slider_mix_timeline.cpp

@@ -23,6 +23,16 @@ void spine_slider_mix_timeline_apply(spine_slider_mix_timeline self, spine_skele
 				 appliedPose);
 }
 
+int spine_slider_mix_timeline_get_constraint_index(spine_slider_mix_timeline self) {
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -108,16 +118,6 @@ spine_array_property_id spine_slider_mix_timeline_get_property_ids(spine_slider_
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_slider_mix_timeline_get_constraint_index(spine_slider_mix_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (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;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_slider_mix_timeline_rtti(void) {
 	return (spine_rtti) &SliderMixTimeline::rtti;
 }

spine-c/src/generated/slider_mix_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_slider_mix_timeline_get_rtti(spine_slider_mix_timel
 SPINE_C_API void spine_slider_mix_timeline_apply(spine_slider_mix_timeline self, spine_skeleton skeleton, float lastTime, float time,
 												 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 												 bool appliedPose);
+SPINE_C_API int spine_slider_mix_timeline_get_constraint_index(spine_slider_mix_timeline self);
+SPINE_C_API void spine_slider_mix_timeline_set_constraint_index(spine_slider_mix_timeline self, int inValue);
 SPINE_C_API void spine_slider_mix_timeline_set_frame(spine_slider_mix_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_slider_mix_timeline_get_curve_value(spine_slider_mix_timeline self, float time);
 SPINE_C_API float spine_slider_mix_timeline_get_relative_value(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend,
@@ -38,8 +40,6 @@ SPINE_C_API size_t spine_slider_mix_timeline_get_frame_count(spine_slider_mix_ti
 SPINE_C_API spine_array_float spine_slider_mix_timeline_get_frames(spine_slider_mix_timeline self);
 SPINE_C_API float spine_slider_mix_timeline_get_duration(spine_slider_mix_timeline self);
 SPINE_C_API spine_array_property_id spine_slider_mix_timeline_get_property_ids(spine_slider_mix_timeline self);
-SPINE_C_API int spine_slider_mix_timeline_get_constraint_index(spine_slider_mix_timeline self);
-SPINE_C_API void spine_slider_mix_timeline_set_constraint_index(spine_slider_mix_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_slider_mix_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/slider_timeline.cpp

@@ -23,6 +23,16 @@ void spine_slider_timeline_apply(spine_slider_timeline self, spine_skeleton skel
 				 appliedPose);
 }
 
+int spine_slider_timeline_get_constraint_index(spine_slider_timeline self) {
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
+	return _self->getConstraintIndex();
+}
+
+void spine_slider_timeline_set_constraint_index(spine_slider_timeline self, int inValue) {
+	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (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;
 	_self->setFrame(frame, time, value);
@@ -108,16 +118,6 @@ spine_array_property_id spine_slider_timeline_get_property_ids(spine_slider_time
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_slider_timeline_get_constraint_index(spine_slider_timeline self) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
-	return _self->getConstraintIndex();
-}
-
-void spine_slider_timeline_set_constraint_index(spine_slider_timeline self, int inValue) {
-	ConstraintTimeline1 *_self = (ConstraintTimeline1 *) (SliderTimeline *) self;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_slider_timeline_rtti(void) {
 	return (spine_rtti) &SliderTimeline::rtti;
 }

spine-c/src/generated/slider_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_slider_timeline_get_rtti(spine_slider_timeline self
 SPINE_C_API void spine_slider_timeline_apply(spine_slider_timeline self, spine_skeleton skeleton, float lastTime, float time,
 											 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 											 bool appliedPose);
+SPINE_C_API int spine_slider_timeline_get_constraint_index(spine_slider_timeline self);
+SPINE_C_API void spine_slider_timeline_set_constraint_index(spine_slider_timeline self, int inValue);
 SPINE_C_API void spine_slider_timeline_set_frame(spine_slider_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_slider_timeline_get_curve_value(spine_slider_timeline self, float time);
 SPINE_C_API float spine_slider_timeline_get_relative_value(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, float current,
@@ -38,8 +40,6 @@ SPINE_C_API size_t spine_slider_timeline_get_frame_count(spine_slider_timeline s
 SPINE_C_API spine_array_float spine_slider_timeline_get_frames(spine_slider_timeline self);
 SPINE_C_API float spine_slider_timeline_get_duration(spine_slider_timeline self);
 SPINE_C_API spine_array_property_id spine_slider_timeline_get_property_ids(spine_slider_timeline self);
-SPINE_C_API int spine_slider_timeline_get_constraint_index(spine_slider_timeline self);
-SPINE_C_API void spine_slider_timeline_set_constraint_index(spine_slider_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_slider_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/slot_curve_timeline.cpp

@@ -19,6 +19,16 @@ void spine_slot_curve_timeline_apply(spine_slot_curve_timeline self, spine_skele
 				 appliedPose);
 }
 
+int spine_slot_curve_timeline_get_slot_index(spine_slot_curve_timeline self) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
+	return _self->getSlotIndex();
+}
+
+void spine_slot_curve_timeline_set_slot_index(spine_slot_curve_timeline self, int inValue) {
+	SlotCurveTimeline *_self = (SlotCurveTimeline *) self;
+	_self->setSlotIndex(inValue);
+}
+
 void spine_slot_curve_timeline_set_linear(spine_slot_curve_timeline self, size_t frame) {
 	CurveTimeline *_self = (CurveTimeline *) (SlotCurveTimeline *) self;
 	_self->setLinear(frame);
@@ -70,16 +80,6 @@ spine_array_property_id spine_slot_curve_timeline_get_property_ids(spine_slot_cu
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_slot_curve_timeline_get_slot_index(spine_slot_curve_timeline self) {
-	SlotTimeline *_self = (SlotTimeline *) (SlotCurveTimeline *) self;
-	return _self->getSlotIndex();
-}
-
-void spine_slot_curve_timeline_set_slot_index(spine_slot_curve_timeline self, int inValue) {
-	SlotTimeline *_self = (SlotTimeline *) (SlotCurveTimeline *) self;
-	_self->setSlotIndex(inValue);
-}
-
 spine_rtti spine_slot_curve_timeline_rtti(void) {
 	return (spine_rtti) &SlotCurveTimeline::rtti;
 }

spine-c/src/generated/slot_curve_timeline.h

@@ -15,6 +15,8 @@ SPINE_C_API spine_rtti spine_slot_curve_timeline_get_rtti(spine_slot_curve_timel
 SPINE_C_API void spine_slot_curve_timeline_apply(spine_slot_curve_timeline self, spine_skeleton skeleton, float lastTime, float time,
 												 spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 												 bool appliedPose);
+SPINE_C_API int spine_slot_curve_timeline_get_slot_index(spine_slot_curve_timeline self);
+SPINE_C_API void spine_slot_curve_timeline_set_slot_index(spine_slot_curve_timeline self, int inValue);
 SPINE_C_API void spine_slot_curve_timeline_set_linear(spine_slot_curve_timeline self, size_t frame);
 SPINE_C_API void spine_slot_curve_timeline_set_stepped(spine_slot_curve_timeline self, size_t frame);
 SPINE_C_API void spine_slot_curve_timeline_set_bezier(spine_slot_curve_timeline self, size_t bezier, size_t frame, float value, float time1,
@@ -26,8 +28,6 @@ SPINE_C_API size_t spine_slot_curve_timeline_get_frame_count(spine_slot_curve_ti
 SPINE_C_API spine_array_float spine_slot_curve_timeline_get_frames(spine_slot_curve_timeline self);
 SPINE_C_API float spine_slot_curve_timeline_get_duration(spine_slot_curve_timeline self);
 SPINE_C_API spine_array_property_id spine_slot_curve_timeline_get_property_ids(spine_slot_curve_timeline self);
-SPINE_C_API int spine_slot_curve_timeline_get_slot_index(spine_slot_curve_timeline self);
-SPINE_C_API void spine_slot_curve_timeline_set_slot_index(spine_slot_curve_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_slot_curve_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/transform_constraint_timeline.cpp

@@ -31,6 +31,16 @@ void spine_transform_constraint_timeline_set_frame(spine_transform_constraint_ti
 	_self->setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY);
 }
 
+int spine_transform_constraint_timeline_get_constraint_index(spine_transform_constraint_timeline self) {
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
+	return _self->getConstraintIndex();
+}
+
+void spine_transform_constraint_timeline_set_constraint_index(spine_transform_constraint_timeline self, int inValue) {
+	TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self;
+	_self->setConstraintIndex(inValue);
+}
+
 void spine_transform_constraint_timeline_set_linear(spine_transform_constraint_timeline self, size_t frame) {
 	CurveTimeline *_self = (CurveTimeline *) (TransformConstraintTimeline *) self;
 	_self->setLinear(frame);
@@ -83,16 +93,6 @@ spine_array_property_id spine_transform_constraint_timeline_get_property_ids(spi
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_transform_constraint_timeline_get_constraint_index(spine_transform_constraint_timeline self) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (TransformConstraintTimeline *) self;
-	return _self->getConstraintIndex();
-}
-
-void spine_transform_constraint_timeline_set_constraint_index(spine_transform_constraint_timeline self, int inValue) {
-	ConstraintTimeline *_self = (ConstraintTimeline *) (TransformConstraintTimeline *) self;
-	_self->setConstraintIndex(inValue);
-}
-
 spine_rtti spine_transform_constraint_timeline_rtti(void) {
 	return (spine_rtti) &TransformConstraintTimeline::rtti;
 }

spine-c/src/generated/transform_constraint_timeline.h

@@ -20,6 +20,8 @@ SPINE_C_API void spine_transform_constraint_timeline_apply(spine_transform_const
 														   spine_mix_direction direction, bool appliedPose);
 SPINE_C_API void spine_transform_constraint_timeline_set_frame(spine_transform_constraint_timeline self, int frame, float time, float mixRotate,
 															   float mixX, float mixY, float mixScaleX, float mixScaleY, float mixShearY);
+SPINE_C_API int spine_transform_constraint_timeline_get_constraint_index(spine_transform_constraint_timeline self);
+SPINE_C_API void spine_transform_constraint_timeline_set_constraint_index(spine_transform_constraint_timeline self, int inValue);
 SPINE_C_API void spine_transform_constraint_timeline_set_linear(spine_transform_constraint_timeline self, size_t frame);
 SPINE_C_API void spine_transform_constraint_timeline_set_stepped(spine_transform_constraint_timeline self, size_t frame);
 SPINE_C_API void spine_transform_constraint_timeline_set_bezier(spine_transform_constraint_timeline self, size_t bezier, size_t frame, float value,
@@ -33,8 +35,6 @@ SPINE_C_API size_t spine_transform_constraint_timeline_get_frame_count(spine_tra
 SPINE_C_API spine_array_float spine_transform_constraint_timeline_get_frames(spine_transform_constraint_timeline self);
 SPINE_C_API float spine_transform_constraint_timeline_get_duration(spine_transform_constraint_timeline self);
 SPINE_C_API spine_array_property_id spine_transform_constraint_timeline_get_property_ids(spine_transform_constraint_timeline self);
-SPINE_C_API int spine_transform_constraint_timeline_get_constraint_index(spine_transform_constraint_timeline self);
-SPINE_C_API void spine_transform_constraint_timeline_set_constraint_index(spine_transform_constraint_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_transform_constraint_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/translate_timeline.cpp

@@ -23,14 +23,19 @@ void spine_translate_timeline_apply(spine_translate_timeline self, spine_skeleto
 				 appliedPose);
 }
 
-void spine_translate_timeline_set_frame(spine_translate_timeline self, size_t frame, float time, float value1, float value2) {
+int spine_translate_timeline_get_bone_index(spine_translate_timeline self) {
 	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
-	_self->setFrame(frame, time, value1, value2);
+	return _self->getBoneIndex();
 }
 
-float spine_translate_timeline_get_curve_value(spine_translate_timeline self, float time) {
+void spine_translate_timeline_set_bone_index(spine_translate_timeline self, int inValue) {
 	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
-	return _self->getCurveValue(time);
+	_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;
+	_self->setFrame(frame, time, value1, value2);
 }
 
 void spine_translate_timeline_set_linear(spine_translate_timeline self, size_t frame) {
@@ -84,16 +89,6 @@ spine_array_property_id spine_translate_timeline_get_property_ids(spine_translat
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_translate_timeline_get_bone_index(spine_translate_timeline self) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
-	return _self->getBoneIndex();
-}
-
-void spine_translate_timeline_set_bone_index(spine_translate_timeline self, int inValue) {
-	BoneTimeline2 *_self = (BoneTimeline2 *) (TranslateTimeline *) self;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_translate_timeline_rtti(void) {
 	return (spine_rtti) &TranslateTimeline::rtti;
 }

spine-c/src/generated/translate_timeline.h

@@ -17,8 +17,9 @@ SPINE_C_API spine_rtti spine_translate_timeline_get_rtti(spine_translate_timelin
 SPINE_C_API void spine_translate_timeline_apply(spine_translate_timeline self, spine_skeleton skeleton, float lastTime, float time,
 												spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 												bool appliedPose);
+SPINE_C_API int spine_translate_timeline_get_bone_index(spine_translate_timeline self);
+SPINE_C_API void spine_translate_timeline_set_bone_index(spine_translate_timeline self, int inValue);
 SPINE_C_API void spine_translate_timeline_set_frame(spine_translate_timeline self, size_t frame, float time, float value1, float value2);
-SPINE_C_API float spine_translate_timeline_get_curve_value(spine_translate_timeline self, float time);
 SPINE_C_API void spine_translate_timeline_set_linear(spine_translate_timeline self, size_t frame);
 SPINE_C_API void spine_translate_timeline_set_stepped(spine_translate_timeline self, size_t frame);
 SPINE_C_API void spine_translate_timeline_set_bezier(spine_translate_timeline self, size_t bezier, size_t frame, float value, float time1,
@@ -30,8 +31,6 @@ SPINE_C_API size_t spine_translate_timeline_get_frame_count(spine_translate_time
 SPINE_C_API spine_array_float spine_translate_timeline_get_frames(spine_translate_timeline self);
 SPINE_C_API float spine_translate_timeline_get_duration(spine_translate_timeline self);
 SPINE_C_API spine_array_property_id spine_translate_timeline_get_property_ids(spine_translate_timeline self);
-SPINE_C_API int spine_translate_timeline_get_bone_index(spine_translate_timeline self);
-SPINE_C_API void spine_translate_timeline_set_bone_index(spine_translate_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_translate_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/translate_x_timeline.cpp

@@ -23,6 +23,16 @@ void spine_translate_x_timeline_apply(spine_translate_x_timeline self, spine_ske
 				 appliedPose);
 }
 
+int spine_translate_x_timeline_get_bone_index(spine_translate_x_timeline self) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -108,16 +118,6 @@ spine_array_property_id spine_translate_x_timeline_get_property_ids(spine_transl
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_translate_x_timeline_get_bone_index(spine_translate_x_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_translate_x_timeline_rtti(void) {
 	return (spine_rtti) &TranslateXTimeline::rtti;
 }

spine-c/src/generated/translate_x_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_translate_x_timeline_get_rtti(spine_translate_x_tim
 SPINE_C_API void spine_translate_x_timeline_apply(spine_translate_x_timeline self, spine_skeleton skeleton, float lastTime, float time,
 												  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 												  bool appliedPose);
+SPINE_C_API int spine_translate_x_timeline_get_bone_index(spine_translate_x_timeline self);
+SPINE_C_API void spine_translate_x_timeline_set_bone_index(spine_translate_x_timeline self, int inValue);
 SPINE_C_API void spine_translate_x_timeline_set_frame(spine_translate_x_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_translate_x_timeline_get_curve_value(spine_translate_x_timeline self, float time);
 SPINE_C_API float spine_translate_x_timeline_get_relative_value(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend,
@@ -39,8 +41,6 @@ SPINE_C_API size_t spine_translate_x_timeline_get_frame_count(spine_translate_x_
 SPINE_C_API spine_array_float spine_translate_x_timeline_get_frames(spine_translate_x_timeline self);
 SPINE_C_API float spine_translate_x_timeline_get_duration(spine_translate_x_timeline self);
 SPINE_C_API spine_array_property_id spine_translate_x_timeline_get_property_ids(spine_translate_x_timeline self);
-SPINE_C_API int spine_translate_x_timeline_get_bone_index(spine_translate_x_timeline self);
-SPINE_C_API void spine_translate_x_timeline_set_bone_index(spine_translate_x_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_translate_x_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/translate_y_timeline.cpp

@@ -23,6 +23,16 @@ void spine_translate_y_timeline_apply(spine_translate_y_timeline self, spine_ske
 				 appliedPose);
 }
 
+int spine_translate_y_timeline_get_bone_index(spine_translate_y_timeline self) {
+	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
+	_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;
 	_self->setFrame(frame, time, value);
@@ -108,16 +118,6 @@ spine_array_property_id spine_translate_y_timeline_get_property_ids(spine_transl
 	return (spine_array_property_id) &_self->getPropertyIds();
 }
 
-int spine_translate_y_timeline_get_bone_index(spine_translate_y_timeline self) {
-	BoneTimeline1 *_self = (BoneTimeline1 *) (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;
-	_self->setBoneIndex(inValue);
-}
-
 spine_rtti spine_translate_y_timeline_rtti(void) {
 	return (spine_rtti) &TranslateYTimeline::rtti;
 }

spine-c/src/generated/translate_y_timeline.h

@@ -17,6 +17,8 @@ SPINE_C_API spine_rtti spine_translate_y_timeline_get_rtti(spine_translate_y_tim
 SPINE_C_API void spine_translate_y_timeline_apply(spine_translate_y_timeline self, spine_skeleton skeleton, float lastTime, float time,
 												  spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
 												  bool appliedPose);
+SPINE_C_API int spine_translate_y_timeline_get_bone_index(spine_translate_y_timeline self);
+SPINE_C_API void spine_translate_y_timeline_set_bone_index(spine_translate_y_timeline self, int inValue);
 SPINE_C_API void spine_translate_y_timeline_set_frame(spine_translate_y_timeline self, size_t frame, float time, float value);
 SPINE_C_API float spine_translate_y_timeline_get_curve_value(spine_translate_y_timeline self, float time);
 SPINE_C_API float spine_translate_y_timeline_get_relative_value(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend,
@@ -39,8 +41,6 @@ SPINE_C_API size_t spine_translate_y_timeline_get_frame_count(spine_translate_y_
 SPINE_C_API spine_array_float spine_translate_y_timeline_get_frames(spine_translate_y_timeline self);
 SPINE_C_API float spine_translate_y_timeline_get_duration(spine_translate_y_timeline self);
 SPINE_C_API spine_array_property_id spine_translate_y_timeline_get_property_ids(spine_translate_y_timeline self);
-SPINE_C_API int spine_translate_y_timeline_get_bone_index(spine_translate_y_timeline self);
-SPINE_C_API void spine_translate_y_timeline_set_bone_index(spine_translate_y_timeline self, int inValue);
 SPINE_C_API spine_rtti spine_translate_y_timeline_rtti(void);
 
 #ifdef __cplusplus

spine-c/src/generated/types.h

@@ -64,7 +64,6 @@ SPINE_OPAQUE_TYPE(spine_constraint_timeline)
 SPINE_OPAQUE_TYPE(spine_constraint_timeline1)
 SPINE_OPAQUE_TYPE(spine_curve_timeline)
 SPINE_OPAQUE_TYPE(spine_curve_timeline1)
-SPINE_OPAQUE_TYPE(spine_curve_timeline2)
 SPINE_OPAQUE_TYPE(spine_deform_timeline)
 SPINE_OPAQUE_TYPE(spine_draw_order_timeline)
 SPINE_OPAQUE_TYPE(spine_event)