UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-02-04 14:24:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

[c] ir-generator now evalutes nullability in spine-cpp based on pointer (nullable) or reference (non-nullable)

Browse Source
This commit is contained in:
Mario Zechner 2025-07-25 20:49:26 +02:00
parent 861eac1c1b
commit 4e875bc17f
187 changed files with 991 additions and 851 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
spine-c/codegen/src/c-types.ts
View File

@ -5,6 +5,7 @@ export interface CParameter {
cType: string; // C type (e.g., "float*", "spine_bone")
cppType: string; // Original C++ type (e.g., "float&", "Bone*")
isOutput: boolean; // true for non-const references that become output params
isNullable: boolean; // true for pointer types (can be null), false for references/values
}
export interface CMethod {
@ -12,6 +13,7 @@ export interface CMethod {
returnType: string; // C return type
parameters: CParameter[];
body: string; // The actual implementation code (e.g., "return ((Bone*)self)->getX();")
returnTypeNullable: boolean; // true if return type can be null (pointer types)
}
export interface CClassOrStruct {

11
spine-c/codegen/src/c-writer.ts
View File

@ -150,12 +150,14 @@ export class CWriter {
private writeMethodDeclaration(method: CMethod): string {
const params = this.formatParameters(method.parameters);
return `SPINE_C_API ${method.returnType} ${method.name}(${params});`;
const returnTypeWithAnnotation = method.returnTypeNullable ? `/*@null*/ ${method.returnType}` : method.returnType;
return `SPINE_C_API ${returnTypeWithAnnotation} ${method.name}(${params});`;
}
private writeMethodImplementation(method: CMethod): string {
const params = this.formatParameters(method.parameters);
const signature = `${method.returnType} ${method.name}(${params})`;
const returnTypeWithAnnotation = method.returnTypeNullable ? `/*@null*/ ${method.returnType}` : method.returnType;
const signature = `${returnTypeWithAnnotation} ${method.name}(${params})`;
return `${signature} {
${method.body}
@ -168,7 +170,10 @@ export class CWriter {
}
return parameters
.map(p => `${p.cType} ${p.name}`)
.map(p => {
const typeWithAnnotation = p.isNullable ? `/*@null*/ ${p.cType}` : p.cType;
return `${typeWithAnnotation} ${p.name}`;
})
.join(', ');
}

63
spine-c/codegen/src/ir-generator.ts
View File

@ -2,7 +2,7 @@ import { scanArraySpecializations } from './array-scanner';
import type { CClassOrStruct, CEnum, CEnumValue, CMethod, CParameter } from './c-types';
import { isFieldExcluded, isFieldGetterExcluded, isFieldSetterExcluded } from './exclusions';
import type { ArraySpecialization, Exclusion } from './types';
import { type ClassOrStruct, type Constructor, checkTypeSupport, type Enum, type Field, isPrimitive, type Method, type Parameter, type Type, toCFunctionName, toCTypeName, toSnakeCase } from './types';
import { type ClassOrStruct, type Constructor, checkTypeSupport, type Enum, type Field, isPrimitive, isNullable, type Method, type Parameter, type Type, toCFunctionName, toCTypeName, toSnakeCase } from './types';
/**
* Checks if a type inherits from SpineObject (directly or indirectly)
@ -103,7 +103,8 @@ export function generateConstructors(type: ClassOrStruct, knownTypeNames: Set<st
name: `${cTypeName}_create`,
returnType: cTypeName,
parameters: [],
body: `return (${cTypeName}) new (__FILE__, __LINE__) ${cppTypeName}();`
body: `return (${cTypeName}) new (__FILE__, __LINE__) ${cppTypeName}();`,
returnTypeNullable: false // Constructors never return null on success
});
} else {
// Parameterized constructor
@ -117,7 +118,8 @@ export function generateConstructors(type: ClassOrStruct, knownTypeNames: Set<st
name: `${cTypeName}_create${suffix}`,
returnType: cTypeName,
parameters: cParams,
body: `return (${cTypeName}) new (__FILE__, __LINE__) ${cppTypeName}(${cppArgs});`
body: `return (${cTypeName}) new (__FILE__, __LINE__) ${cppTypeName}(${cppArgs});`,
returnTypeNullable: false // Constructors never return null on success
});
}
i++;
@ -150,9 +152,11 @@ export function generateDestructor(type: ClassOrStruct, exclusions: Exclusion[])
name: 'self',
cType: cTypeName,
cppType: `${cppTypeName}*`,
isOutput: false
isOutput: false,
isNullable: false // Self parameter must never be null (would crash)
}],
body: `delete (${cppTypeName}*)self;`
body: `delete (${cppTypeName}*)self;`,
returnTypeNullable: false // void return type cannot be null
};
}
@ -222,7 +226,8 @@ export function generateMethods(type: ClassOrStruct, knownTypeNames: Set<string>
name: `${cTypeName}_rtti`,
returnType: 'spine_rtti',
parameters: [],
body: `return (spine_rtti)&${cppTypeName}::rtti;`
body: `return (spine_rtti)&${cppTypeName}::rtti;`,
returnTypeNullable: false // RTTI method returns a reference address, never null
});
}
@ -270,9 +275,11 @@ export function generateFieldAccessors(type: ClassOrStruct, knownTypeNames: Set<
name: 'self',
cType: cTypeName,
cppType: `${cppTypeName}*`,
isOutput: false
isOutput: false,
isNullable: false // Self parameter must never be null (would crash)
}],
body: generateFieldGetterBody(field, cppTypeName, knownTypeNames)
body: generateFieldGetterBody(field, cppTypeName, knownTypeNames),
returnTypeNullable: isNullable(field.type) // Field return type nullability depends on field type
});
} catch (e) {
console.warn(` Skipping getter for field ${type.name}::${field.name}: ${e}`);
@ -295,16 +302,19 @@ export function generateFieldAccessors(type: ClassOrStruct, knownTypeNames: Set<
name: 'self',
cType: cTypeName,
cppType: `${cppTypeName}*`,
isOutput: false
isOutput: false,
isNullable: false // Self parameter must never be null (would crash)
},
{
name: 'value',
cType: cParamType,
cppType: field.type,
isOutput: false
isOutput: false,
isNullable: isNullable(field.type) // Value parameter nullability depends on field type
}
],
body: generateFieldSetterBody(field, cppTypeName, knownTypeNames)
body: generateFieldSetterBody(field, cppTypeName, knownTypeNames),
returnTypeNullable: false // void return type cannot be null
});
} catch (e) {
console.warn(` Skipping setter for field ${type.name}::${field.name}: ${e}`);
@ -413,7 +423,8 @@ export function generateArrayType(spec: ArraySpecialization, arrayType: ClassOrS
name: `${cTypeName}_create`,
returnType: cTypeName,
parameters: [],
body: `return (${cTypeName}) new (__FILE__, __LINE__) Array<${spec.elementType}>();`
body: `return (${cTypeName}) new (__FILE__, __LINE__) Array<${spec.elementType}>();`,
returnTypeNullable: false // Array constructors never return null on success
},
{
name: `${cTypeName}_create_with_capacity`,
@ -422,9 +433,11 @@ export function generateArrayType(spec: ArraySpecialization, arrayType: ClassOrS
name: 'initialCapacity',
cType: 'size_t',
cppType: 'size_t',
isOutput: false
isOutput: false,
isNullable: false // size_t cannot be null
}],
body: `return (${cTypeName}) new (__FILE__, __LINE__) Array<${spec.elementType}>(initialCapacity);`
body: `return (${cTypeName}) new (__FILE__, __LINE__) Array<${spec.elementType}>(initialCapacity);`,
returnTypeNullable: false // Array constructors never return null on success
}
];
@ -436,9 +449,11 @@ export function generateArrayType(spec: ArraySpecialization, arrayType: ClassOrS
name: 'array',
cType: cTypeName,
cppType: `Array<${spec.elementType}>*`,
isOutput: false
isOutput: false,
isNullable: false // Array parameter must never be null (would crash)
}],
body: `delete (Array<${spec.elementType}>*)array;`
body: `delete (Array<${spec.elementType}>*)array;`,
returnTypeNullable: false // void return type cannot be null
};
// Generate array methods
@ -529,12 +544,14 @@ function convertParameters(params: Parameter[], knownTypeNames: Set<string>): CP
for (const param of params) {
const cType = toCTypeName(param.type, knownTypeNames);
const isOutput = isOutputParameter(param.type);
const paramIsNullable = isNullable(param.type);
cParams.push({
name: param.name,
cType,
cppType: param.type,
isOutput
isOutput,
isNullable: paramIsNullable
});
}
@ -650,7 +667,8 @@ function generateMethod(type: ClassOrStruct, method: Method, cTypeName: string,
name: 'self',
cType: cTypeName,
cppType: `${cppTypeName}*`,
isOutput: false
isOutput: false,
isNullable: false // Self parameter must never be null (would crash)
});
}
@ -680,7 +698,8 @@ function generateMethod(type: ClassOrStruct, method: Method, cTypeName: string,
name: cMethodName,
returnType: cReturnType,
parameters: cParams,
body
body,
returnTypeNullable: isNullable(method.returnType)
};
} catch (e) {
console.warn(`Skipping method ${type.name}::${method.name}: ${e}`);
@ -807,7 +826,8 @@ function generateArrayMethod(cTypeName: string, method: Method, cppElementType:
name: 'array',
cType: cTypeName,
cppType: `Array<${cppElementType}>*`,
isOutput: false
isOutput: false,
isNullable: false // Array parameter must never be null (would crash)
});
// Add method parameters
@ -822,7 +842,8 @@ function generateArrayMethod(cTypeName: string, method: Method, cppElementType:
name: cMethodName,
returnType: cReturnType,
parameters: cParams,
body
body,
returnTypeNullable: isNullable(method.returnType)
};
} catch (e) {
console.warn(`Skipping array method ${method.name}: ${e}`);

32
spine-c/codegen/src/types.ts
View File

@ -298,6 +298,38 @@ export function toCTypeName(cppType: string, knownTypeNames: Set<string>): strin
return `spine_${toSnakeCase(normalizedType)}`;
}
/**
* Determines if a C++ type represents a nullable value (pointer types).
* Based on spine-cpp convention: pointers are nullable, references are not.
*
* @param cppType The C++ type to check
* @returns true if the type can be null (pointer types), false otherwise
*
* Examples:
* - "Bone*" → true (pointer, can be null)
* - "const Bone*" → true (pointer, can be null)
* - "Bone&" → false (reference, cannot be null)
* - "const Bone&" → false (reference, cannot be null)
* - "int" → false (value type, cannot be null)
* - "float*" → true (pointer to primitive, can be null)
*/
export function isNullable(cppType: string): boolean {
const normalizedType = cppType.replace(/\s+/g, ' ').trim();
// Pointer types are nullable
if (normalizedType.includes('*')) {
return true;
}
// Reference types are NOT nullable
if (normalizedType.includes('&')) {
return false;
}
// Value types and primitives are NOT nullable
return false;
}
/**
* Checks if a C++ type can be represented in the C API.
* Returns null if the type can be handled, or an error message if not.

2
spine-c/src/generated/alpha_timeline.cpp
View File

@ -16,7 +16,7 @@ spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self) {
return (spine_rtti) &_self->getRTTI();
}
void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
AlphaTimeline *_self = (AlphaTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

5
spine-c/src/generated/alpha_timeline.h
View File

@ -14,8 +14,9 @@ SPINE_C_API spine_alpha_timeline spine_alpha_timeline_create(size_t frameCount,
SPINE_C_API void spine_alpha_timeline_dispose(spine_alpha_timeline self);
SPINE_C_API spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self);
SPINE_C_API void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ 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);

8
spine-c/src/generated/animation.cpp
View File

@ -3,7 +3,7 @@
using namespace spine;
spine_animation spine_animation_create(const char *name, spine_array_timeline timelines, float duration) {
spine_animation spine_animation_create(const char *name, /*@null*/ spine_array_timeline timelines, float duration) {
return (spine_animation) new (__FILE__, __LINE__) Animation(String(name), *((Array<Timeline *> *) timelines), duration);
}
@ -11,12 +11,12 @@ void spine_animation_dispose(spine_animation self) {
delete (Animation *) self;
}
spine_array_timeline spine_animation_get_timelines(spine_animation self) {
/*@null*/ spine_array_timeline spine_animation_get_timelines(spine_animation self) {
Animation *_self = (Animation *) self;
return (spine_array_timeline) &_self->getTimelines();
}
void spine_animation_set_timelines(spine_animation self, spine_array_timeline timelines) {
void spine_animation_set_timelines(spine_animation self, /*@null*/ spine_array_timeline timelines) {
Animation *_self = (Animation *) self;
_self->setTimelines(*((Array<Timeline *> *) timelines));
}
@ -36,7 +36,7 @@ void spine_animation_set_duration(spine_animation self, float inValue) {
_self->setDuration(inValue);
}
void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, spine_array_event pEvents,
void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, /*@null*/ spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
Animation *_self = (Animation *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, loop, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

8
spine-c/src/generated/animation.h
View File

@ -9,17 +9,17 @@
extern "C" {
#endif
SPINE_C_API spine_animation spine_animation_create(const char *name, spine_array_timeline timelines, float duration);
SPINE_C_API spine_animation spine_animation_create(const char *name, /*@null*/ spine_array_timeline timelines, float duration);
SPINE_C_API void spine_animation_dispose(spine_animation self);
SPINE_C_API spine_array_timeline spine_animation_get_timelines(spine_animation self);
SPINE_C_API void spine_animation_set_timelines(spine_animation self, spine_array_timeline timelines);
SPINE_C_API /*@null*/ spine_array_timeline spine_animation_get_timelines(spine_animation self);
SPINE_C_API void spine_animation_set_timelines(spine_animation self, /*@null*/ spine_array_timeline timelines);
SPINE_C_API bool spine_animation_has_timeline(spine_animation self, spine_array_property_id ids);
SPINE_C_API float spine_animation_get_duration(spine_animation self);
SPINE_C_API void spine_animation_set_duration(spine_animation self, float inValue);
SPINE_C_API void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API const char *spine_animation_get_name(spine_animation self);
SPINE_C_API spine_array_int spine_animation_get_bones(spine_animation self);

15
spine-c/src/generated/animation_state.cpp
View File

@ -3,7 +3,7 @@
using namespace spine;
spine_animation_state spine_animation_state_create(spine_animation_state_data data) {
spine_animation_state spine_animation_state_create(/*@null*/ spine_animation_state_data data) {
return (spine_animation_state) new (__FILE__, __LINE__) AnimationState((AnimationStateData *) data);
}
@ -36,7 +36,8 @@ spine_track_entry spine_animation_state_set_animation_1(spine_animation_state se
return (spine_track_entry) &_self->setAnimation(trackIndex, String(animationName), loop);
}
spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop) {
spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, /*@null*/ spine_animation animation,
bool loop) {
AnimationState *_self = (AnimationState *) self;
return (spine_track_entry) &_self->setAnimation(trackIndex, (Animation *) animation, loop);
}
@ -47,7 +48,7 @@ spine_track_entry spine_animation_state_add_animation_1(spine_animation_state se
return (spine_track_entry) &_self->addAnimation(trackIndex, String(animationName), loop, delay);
}
spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation, bool loop,
spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, /*@null*/ spine_animation animation, bool loop,
float delay) {
AnimationState *_self = (AnimationState *) self;
return (spine_track_entry) &_self->addAnimation(trackIndex, (Animation *) animation, loop, delay);
@ -68,7 +69,7 @@ void spine_animation_state_set_empty_animations(spine_animation_state self, floa
_self->setEmptyAnimations(mixDuration);
}
spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex) {
/*@null*/ spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex) {
AnimationState *_self = (AnimationState *) self;
return (spine_track_entry) _self->getCurrent(trackIndex);
}
@ -78,7 +79,7 @@ spine_animation_state_data spine_animation_state_get_data(spine_animation_state
return (spine_animation_state_data) &_self->getData();
}
spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self) {
/*@null*/ spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self) {
AnimationState *_self = (AnimationState *) self;
return (spine_array_track_entry) &_self->getTracks();
}
@ -113,12 +114,12 @@ bool spine_animation_state_get_manual_track_entry_disposal(spine_animation_state
return _self->getManualTrackEntryDisposal();
}
void spine_animation_state_dispose_track_entry(spine_animation_state self, spine_track_entry entry) {
void spine_animation_state_dispose_track_entry(spine_animation_state self, /*@null*/ spine_track_entry entry) {
AnimationState *_self = (AnimationState *) self;
_self->disposeTrackEntry((TrackEntry *) entry);
}
void *spine_animation_state_get_renderer_object(spine_animation_state self) {
/*@null*/ void *spine_animation_state_get_renderer_object(spine_animation_state self) {
HasRendererObject *_self = (HasRendererObject *) (AnimationState *) self;
return _self->getRendererObject();
}

18
spine-c/src/generated/animation_state.h
View File

@ -9,7 +9,7 @@
extern "C" {
#endif
SPINE_C_API spine_animation_state spine_animation_state_create(spine_animation_state_data data);
SPINE_C_API spine_animation_state spine_animation_state_create(/*@null*/ spine_animation_state_data data);
SPINE_C_API void spine_animation_state_dispose(spine_animation_state self);
@ -19,27 +19,27 @@ SPINE_C_API void spine_animation_state_clear_tracks(spine_animation_state self);
SPINE_C_API void spine_animation_state_clear_track(spine_animation_state self, size_t trackIndex);
SPINE_C_API spine_track_entry spine_animation_state_set_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName,
bool loop);
SPINE_C_API spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation,
bool loop);
SPINE_C_API spine_track_entry spine_animation_state_set_animation_2(spine_animation_state self, size_t trackIndex,
/*@null*/ spine_animation animation, bool loop);
SPINE_C_API spine_track_entry spine_animation_state_add_animation_1(spine_animation_state self, size_t trackIndex, const char *animationName,
bool loop, float delay);
SPINE_C_API spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex, spine_animation animation,
bool loop, float delay);
SPINE_C_API spine_track_entry spine_animation_state_add_animation_2(spine_animation_state self, size_t trackIndex,
/*@null*/ spine_animation animation, bool loop, float delay);
SPINE_C_API spine_track_entry spine_animation_state_set_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration);
SPINE_C_API spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state self, size_t trackIndex, float mixDuration,
float delay);
SPINE_C_API void spine_animation_state_set_empty_animations(spine_animation_state self, float mixDuration);
SPINE_C_API spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex);
SPINE_C_API /*@null*/ spine_track_entry spine_animation_state_get_current(spine_animation_state self, size_t trackIndex);
SPINE_C_API spine_animation_state_data spine_animation_state_get_data(spine_animation_state self);
SPINE_C_API spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self);
SPINE_C_API /*@null*/ spine_array_track_entry spine_animation_state_get_tracks(spine_animation_state self);
SPINE_C_API float spine_animation_state_get_time_scale(spine_animation_state self);
SPINE_C_API void spine_animation_state_set_time_scale(spine_animation_state self, float inValue);
SPINE_C_API void spine_animation_state_disable_queue(spine_animation_state self);
SPINE_C_API void spine_animation_state_enable_queue(spine_animation_state self);
SPINE_C_API void spine_animation_state_set_manual_track_entry_disposal(spine_animation_state self, bool inValue);
SPINE_C_API bool spine_animation_state_get_manual_track_entry_disposal(spine_animation_state self);
SPINE_C_API void spine_animation_state_dispose_track_entry(spine_animation_state self, spine_track_entry entry);
SPINE_C_API void *spine_animation_state_get_renderer_object(spine_animation_state self);
SPINE_C_API void spine_animation_state_dispose_track_entry(spine_animation_state self, /*@null*/ spine_track_entry entry);
SPINE_C_API /*@null*/ void *spine_animation_state_get_renderer_object(spine_animation_state self);
#ifdef __cplusplus
}

2
spine-c/src/generated/animation_state_data.cpp
View File

@ -3,7 +3,7 @@
using namespace spine;
spine_animation_state_data spine_animation_state_data_create(spine_skeleton_data skeletonData) {
spine_animation_state_data spine_animation_state_data_create(/*@null*/ spine_skeleton_data skeletonData) {
return (spine_animation_state_data) new (__FILE__, __LINE__) AnimationStateData((SkeletonData *) skeletonData);
}

2
spine-c/src/generated/animation_state_data.h
View File

@ -9,7 +9,7 @@
extern "C" {
#endif
SPINE_C_API spine_animation_state_data spine_animation_state_data_create(spine_skeleton_data skeletonData);
SPINE_C_API spine_animation_state_data spine_animation_state_data_create(/*@null*/ spine_skeleton_data skeletonData);
SPINE_C_API void spine_animation_state_data_dispose(spine_animation_state_data self);

346
spine-c/src/generated/arrays.cpp
View File

File diff suppressed because it is too large Load Diff

359
spine-c/src/generated/arrays.h
View File

@ -91,7 +91,7 @@ SPINE_C_API bool spine_array_float_contains(spine_array_float array, float inVal
SPINE_C_API int spine_array_float_index_of(spine_array_float array, float inValue);
SPINE_C_API float *spine_array_float_buffer(spine_array_float array);
SPINE_C_API /*@null*/ float *spine_array_float_buffer(spine_array_float array);
SPINE_C_API spine_array_int spine_array_int_create(void);
@ -119,7 +119,7 @@ SPINE_C_API bool spine_array_int_contains(spine_array_int array, int inValue);
SPINE_C_API int spine_array_int_index_of(spine_array_int array, int inValue);
SPINE_C_API int *spine_array_int_buffer(spine_array_int array);
SPINE_C_API /*@null*/ int *spine_array_int_buffer(spine_array_int array);
SPINE_C_API spine_array_unsigned_short spine_array_unsigned_short_create(void);
@ -148,7 +148,7 @@ SPINE_C_API bool spine_array_unsigned_short_contains(spine_array_unsigned_short
SPINE_C_API int spine_array_unsigned_short_index_of(spine_array_unsigned_short array, unsigned short inValue);
SPINE_C_API unsigned short *spine_array_unsigned_short_buffer(spine_array_unsigned_short array);
SPINE_C_API /*@null*/ unsigned short *spine_array_unsigned_short_buffer(spine_array_unsigned_short array);
SPINE_C_API spine_array_property_id spine_array_property_id_create(void);
@ -176,7 +176,7 @@ SPINE_C_API bool spine_array_property_id_contains(spine_array_property_id array,
SPINE_C_API int spine_array_property_id_index_of(spine_array_property_id array, int64_t inValue);
SPINE_C_API int64_t *spine_array_property_id_buffer(spine_array_property_id array);
SPINE_C_API /*@null*/ int64_t *spine_array_property_id_buffer(spine_array_property_id array);
SPINE_C_API spine_array_animation spine_array_animation_create(void);
@ -188,23 +188,24 @@ SPINE_C_API size_t spine_array_animation_get_capacity(spine_array_animation arra
SPINE_C_API size_t spine_array_animation_size(spine_array_animation array);
SPINE_C_API spine_array_animation spine_array_animation_set_size(spine_array_animation array, size_t newSize, spine_animation defaultValue);
SPINE_C_API /*@null*/ spine_array_animation spine_array_animation_set_size(spine_array_animation array, size_t newSize,
/*@null*/ spine_animation defaultValue);
SPINE_C_API void spine_array_animation_ensure_capacity(spine_array_animation array, size_t newCapacity);
SPINE_C_API void spine_array_animation_add(spine_array_animation array, spine_animation inValue);
SPINE_C_API void spine_array_animation_add(spine_array_animation array, /*@null*/ spine_animation inValue);
SPINE_C_API void spine_array_animation_add_all(spine_array_animation array, spine_array_animation inValue);
SPINE_C_API void spine_array_animation_add_all(spine_array_animation array, /*@null*/ spine_array_animation inValue);
SPINE_C_API void spine_array_animation_clear_and_add_all(spine_array_animation array, spine_array_animation inValue);
SPINE_C_API void spine_array_animation_clear_and_add_all(spine_array_animation array, /*@null*/ spine_array_animation inValue);
SPINE_C_API void spine_array_animation_remove_at(spine_array_animation array, size_t inIndex);
SPINE_C_API bool spine_array_animation_contains(spine_array_animation array, spine_animation inValue);
SPINE_C_API bool spine_array_animation_contains(spine_array_animation array, /*@null*/ spine_animation inValue);
SPINE_C_API int spine_array_animation_index_of(spine_array_animation array, spine_animation inValue);
SPINE_C_API int spine_array_animation_index_of(spine_array_animation array, /*@null*/ spine_animation inValue);
SPINE_C_API spine_animation *spine_array_animation_buffer(spine_array_animation array);
SPINE_C_API /*@null*/ spine_animation *spine_array_animation_buffer(spine_array_animation array);
SPINE_C_API spine_array_atlas_page spine_array_atlas_page_create(void);
@ -216,23 +217,24 @@ SPINE_C_API size_t spine_array_atlas_page_get_capacity(spine_array_atlas_page ar
SPINE_C_API size_t spine_array_atlas_page_size(spine_array_atlas_page array);
SPINE_C_API spine_array_atlas_page spine_array_atlas_page_set_size(spine_array_atlas_page array, size_t newSize, spine_atlas_page defaultValue);
SPINE_C_API /*@null*/ spine_array_atlas_page spine_array_atlas_page_set_size(spine_array_atlas_page array, size_t newSize,
/*@null*/ spine_atlas_page defaultValue);
SPINE_C_API void spine_array_atlas_page_ensure_capacity(spine_array_atlas_page array, size_t newCapacity);
SPINE_C_API void spine_array_atlas_page_add(spine_array_atlas_page array, spine_atlas_page inValue);
SPINE_C_API void spine_array_atlas_page_add(spine_array_atlas_page array, /*@null*/ spine_atlas_page inValue);
SPINE_C_API void spine_array_atlas_page_add_all(spine_array_atlas_page array, spine_array_atlas_page inValue);
SPINE_C_API void spine_array_atlas_page_add_all(spine_array_atlas_page array, /*@null*/ spine_array_atlas_page inValue);
SPINE_C_API void spine_array_atlas_page_clear_and_add_all(spine_array_atlas_page array, spine_array_atlas_page inValue);
SPINE_C_API void spine_array_atlas_page_clear_and_add_all(spine_array_atlas_page array, /*@null*/ spine_array_atlas_page inValue);
SPINE_C_API void spine_array_atlas_page_remove_at(spine_array_atlas_page array, size_t inIndex);
SPINE_C_API bool spine_array_atlas_page_contains(spine_array_atlas_page array, spine_atlas_page inValue);
SPINE_C_API bool spine_array_atlas_page_contains(spine_array_atlas_page array, /*@null*/ spine_atlas_page inValue);
SPINE_C_API int spine_array_atlas_page_index_of(spine_array_atlas_page array, spine_atlas_page inValue);
SPINE_C_API int spine_array_atlas_page_index_of(spine_array_atlas_page array, /*@null*/ spine_atlas_page inValue);
SPINE_C_API spine_atlas_page *spine_array_atlas_page_buffer(spine_array_atlas_page array);
SPINE_C_API /*@null*/ spine_atlas_page *spine_array_atlas_page_buffer(spine_array_atlas_page array);
SPINE_C_API spine_array_atlas_region spine_array_atlas_region_create(void);
@ -244,24 +246,24 @@ SPINE_C_API size_t spine_array_atlas_region_get_capacity(spine_array_atlas_regio
SPINE_C_API size_t spine_array_atlas_region_size(spine_array_atlas_region array);
SPINE_C_API spine_array_atlas_region spine_array_atlas_region_set_size(spine_array_atlas_region array, size_t newSize,
spine_atlas_region defaultValue);
SPINE_C_API /*@null*/ spine_array_atlas_region spine_array_atlas_region_set_size(spine_array_atlas_region array, size_t newSize,
/*@null*/ spine_atlas_region defaultValue);
SPINE_C_API void spine_array_atlas_region_ensure_capacity(spine_array_atlas_region array, size_t newCapacity);
SPINE_C_API void spine_array_atlas_region_add(spine_array_atlas_region array, spine_atlas_region inValue);
SPINE_C_API void spine_array_atlas_region_add(spine_array_atlas_region array, /*@null*/ spine_atlas_region inValue);
SPINE_C_API void spine_array_atlas_region_add_all(spine_array_atlas_region array, spine_array_atlas_region inValue);
SPINE_C_API void spine_array_atlas_region_add_all(spine_array_atlas_region array, /*@null*/ spine_array_atlas_region inValue);
SPINE_C_API void spine_array_atlas_region_clear_and_add_all(spine_array_atlas_region array, spine_array_atlas_region inValue);
SPINE_C_API void spine_array_atlas_region_clear_and_add_all(spine_array_atlas_region array, /*@null*/ spine_array_atlas_region inValue);
SPINE_C_API void spine_array_atlas_region_remove_at(spine_array_atlas_region array, size_t inIndex);
SPINE_C_API bool spine_array_atlas_region_contains(spine_array_atlas_region array, spine_atlas_region inValue);
SPINE_C_API bool spine_array_atlas_region_contains(spine_array_atlas_region array, /*@null*/ spine_atlas_region inValue);
SPINE_C_API int spine_array_atlas_region_index_of(spine_array_atlas_region array, spine_atlas_region inValue);
SPINE_C_API int spine_array_atlas_region_index_of(spine_array_atlas_region array, /*@null*/ spine_atlas_region inValue);
SPINE_C_API spine_atlas_region *spine_array_atlas_region_buffer(spine_array_atlas_region array);
SPINE_C_API /*@null*/ spine_atlas_region *spine_array_atlas_region_buffer(spine_array_atlas_region array);
SPINE_C_API spine_array_attachment spine_array_attachment_create(void);
@ -273,23 +275,24 @@ SPINE_C_API size_t spine_array_attachment_get_capacity(spine_array_attachment ar
SPINE_C_API size_t spine_array_attachment_size(spine_array_attachment array);
SPINE_C_API spine_array_attachment spine_array_attachment_set_size(spine_array_attachment array, size_t newSize, spine_attachment defaultValue);
SPINE_C_API /*@null*/ spine_array_attachment spine_array_attachment_set_size(spine_array_attachment array, size_t newSize,
/*@null*/ spine_attachment defaultValue);
SPINE_C_API void spine_array_attachment_ensure_capacity(spine_array_attachment array, size_t newCapacity);
SPINE_C_API void spine_array_attachment_add(spine_array_attachment array, spine_attachment inValue);
SPINE_C_API void spine_array_attachment_add(spine_array_attachment array, /*@null*/ spine_attachment inValue);
SPINE_C_API void spine_array_attachment_add_all(spine_array_attachment array, spine_array_attachment inValue);
SPINE_C_API void spine_array_attachment_add_all(spine_array_attachment array, /*@null*/ spine_array_attachment inValue);
SPINE_C_API void spine_array_attachment_clear_and_add_all(spine_array_attachment array, spine_array_attachment inValue);
SPINE_C_API void spine_array_attachment_clear_and_add_all(spine_array_attachment array, /*@null*/ spine_array_attachment inValue);
SPINE_C_API void spine_array_attachment_remove_at(spine_array_attachment array, size_t inIndex);
SPINE_C_API bool spine_array_attachment_contains(spine_array_attachment array, spine_attachment inValue);
SPINE_C_API bool spine_array_attachment_contains(spine_array_attachment array, /*@null*/ spine_attachment inValue);
SPINE_C_API int spine_array_attachment_index_of(spine_array_attachment array, spine_attachment inValue);
SPINE_C_API int spine_array_attachment_index_of(spine_array_attachment array, /*@null*/ spine_attachment inValue);
SPINE_C_API spine_attachment *spine_array_attachment_buffer(spine_array_attachment array);
SPINE_C_API /*@null*/ spine_attachment *spine_array_attachment_buffer(spine_array_attachment array);
SPINE_C_API spine_array_bone spine_array_bone_create(void);
@ -301,23 +304,23 @@ SPINE_C_API size_t spine_array_bone_get_capacity(spine_array_bone array);
SPINE_C_API size_t spine_array_bone_size(spine_array_bone array);
SPINE_C_API spine_array_bone spine_array_bone_set_size(spine_array_bone array, size_t newSize, spine_bone defaultValue);
SPINE_C_API /*@null*/ spine_array_bone spine_array_bone_set_size(spine_array_bone array, size_t newSize, /*@null*/ spine_bone defaultValue);
SPINE_C_API void spine_array_bone_ensure_capacity(spine_array_bone array, size_t newCapacity);
SPINE_C_API void spine_array_bone_add(spine_array_bone array, spine_bone inValue);
SPINE_C_API void spine_array_bone_add(spine_array_bone array, /*@null*/ spine_bone inValue);
SPINE_C_API void spine_array_bone_add_all(spine_array_bone array, spine_array_bone inValue);
SPINE_C_API void spine_array_bone_add_all(spine_array_bone array, /*@null*/ spine_array_bone inValue);
SPINE_C_API void spine_array_bone_clear_and_add_all(spine_array_bone array, spine_array_bone inValue);
SPINE_C_API void spine_array_bone_clear_and_add_all(spine_array_bone array, /*@null*/ spine_array_bone inValue);
SPINE_C_API void spine_array_bone_remove_at(spine_array_bone array, size_t inIndex);
SPINE_C_API bool spine_array_bone_contains(spine_array_bone array, spine_bone inValue);
SPINE_C_API bool spine_array_bone_contains(spine_array_bone array, /*@null*/ spine_bone inValue);
SPINE_C_API int spine_array_bone_index_of(spine_array_bone array, spine_bone inValue);
SPINE_C_API int spine_array_bone_index_of(spine_array_bone array, /*@null*/ spine_bone inValue);
SPINE_C_API spine_bone *spine_array_bone_buffer(spine_array_bone array);
SPINE_C_API /*@null*/ spine_bone *spine_array_bone_buffer(spine_array_bone array);
SPINE_C_API spine_array_bone_data spine_array_bone_data_create(void);
@ -329,23 +332,24 @@ SPINE_C_API size_t spine_array_bone_data_get_capacity(spine_array_bone_data arra
SPINE_C_API size_t spine_array_bone_data_size(spine_array_bone_data array);
SPINE_C_API spine_array_bone_data spine_array_bone_data_set_size(spine_array_bone_data array, size_t newSize, spine_bone_data defaultValue);
SPINE_C_API /*@null*/ spine_array_bone_data spine_array_bone_data_set_size(spine_array_bone_data array, size_t newSize,
/*@null*/ spine_bone_data defaultValue);
SPINE_C_API void spine_array_bone_data_ensure_capacity(spine_array_bone_data array, size_t newCapacity);
SPINE_C_API void spine_array_bone_data_add(spine_array_bone_data array, spine_bone_data inValue);
SPINE_C_API void spine_array_bone_data_add(spine_array_bone_data array, /*@null*/ spine_bone_data inValue);
SPINE_C_API void spine_array_bone_data_add_all(spine_array_bone_data array, spine_array_bone_data inValue);
SPINE_C_API void spine_array_bone_data_add_all(spine_array_bone_data array, /*@null*/ spine_array_bone_data inValue);
SPINE_C_API void spine_array_bone_data_clear_and_add_all(spine_array_bone_data array, spine_array_bone_data inValue);
SPINE_C_API void spine_array_bone_data_clear_and_add_all(spine_array_bone_data array, /*@null*/ spine_array_bone_data inValue);
SPINE_C_API void spine_array_bone_data_remove_at(spine_array_bone_data array, size_t inIndex);
SPINE_C_API bool spine_array_bone_data_contains(spine_array_bone_data array, spine_bone_data inValue);
SPINE_C_API bool spine_array_bone_data_contains(spine_array_bone_data array, /*@null*/ spine_bone_data inValue);
SPINE_C_API int spine_array_bone_data_index_of(spine_array_bone_data array, spine_bone_data inValue);
SPINE_C_API int spine_array_bone_data_index_of(spine_array_bone_data array, /*@null*/ spine_bone_data inValue);
SPINE_C_API spine_bone_data *spine_array_bone_data_buffer(spine_array_bone_data array);
SPINE_C_API /*@null*/ spine_bone_data *spine_array_bone_data_buffer(spine_array_bone_data array);
SPINE_C_API spine_array_bone_pose spine_array_bone_pose_create(void);
@ -357,23 +361,24 @@ SPINE_C_API size_t spine_array_bone_pose_get_capacity(spine_array_bone_pose arra
SPINE_C_API size_t spine_array_bone_pose_size(spine_array_bone_pose array);
SPINE_C_API spine_array_bone_pose spine_array_bone_pose_set_size(spine_array_bone_pose array, size_t newSize, spine_bone_pose defaultValue);
SPINE_C_API /*@null*/ spine_array_bone_pose spine_array_bone_pose_set_size(spine_array_bone_pose array, size_t newSize,
/*@null*/ spine_bone_pose defaultValue);
SPINE_C_API void spine_array_bone_pose_ensure_capacity(spine_array_bone_pose array, size_t newCapacity);
SPINE_C_API void spine_array_bone_pose_add(spine_array_bone_pose array, spine_bone_pose inValue);
SPINE_C_API void spine_array_bone_pose_add(spine_array_bone_pose array, /*@null*/ spine_bone_pose inValue);
SPINE_C_API void spine_array_bone_pose_add_all(spine_array_bone_pose array, spine_array_bone_pose inValue);
SPINE_C_API void spine_array_bone_pose_add_all(spine_array_bone_pose array, /*@null*/ spine_array_bone_pose inValue);
SPINE_C_API void spine_array_bone_pose_clear_and_add_all(spine_array_bone_pose array, spine_array_bone_pose inValue);
SPINE_C_API void spine_array_bone_pose_clear_and_add_all(spine_array_bone_pose array, /*@null*/ spine_array_bone_pose inValue);
SPINE_C_API void spine_array_bone_pose_remove_at(spine_array_bone_pose array, size_t inIndex);
SPINE_C_API bool spine_array_bone_pose_contains(spine_array_bone_pose array, spine_bone_pose inValue);
SPINE_C_API bool spine_array_bone_pose_contains(spine_array_bone_pose array, /*@null*/ spine_bone_pose inValue);
SPINE_C_API int spine_array_bone_pose_index_of(spine_array_bone_pose array, spine_bone_pose inValue);
SPINE_C_API int spine_array_bone_pose_index_of(spine_array_bone_pose array, /*@null*/ spine_bone_pose inValue);
SPINE_C_API spine_bone_pose *spine_array_bone_pose_buffer(spine_array_bone_pose array);
SPINE_C_API /*@null*/ spine_bone_pose *spine_array_bone_pose_buffer(spine_array_bone_pose array);
SPINE_C_API spine_array_bounding_box_attachment spine_array_bounding_box_attachment_create(void);
@ -385,26 +390,28 @@ SPINE_C_API size_t spine_array_bounding_box_attachment_get_capacity(spine_array_
SPINE_C_API size_t spine_array_bounding_box_attachment_size(spine_array_bounding_box_attachment array);
SPINE_C_API spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(spine_array_bounding_box_attachment array,
size_t newSize,
spine_bounding_box_attachment defaultValue);
SPINE_C_API /*@null*/ spine_array_bounding_box_attachment spine_array_bounding_box_attachment_set_size(
spine_array_bounding_box_attachment array, size_t newSize, /*@null*/ spine_bounding_box_attachment defaultValue);
SPINE_C_API void spine_array_bounding_box_attachment_ensure_capacity(spine_array_bounding_box_attachment array, size_t newCapacity);
SPINE_C_API void spine_array_bounding_box_attachment_add(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue);
SPINE_C_API void spine_array_bounding_box_attachment_add(spine_array_bounding_box_attachment array, /*@null*/ spine_bounding_box_attachment inValue);
SPINE_C_API void spine_array_bounding_box_attachment_add_all(spine_array_bounding_box_attachment array, spine_array_bounding_box_attachment inValue);
SPINE_C_API void spine_array_bounding_box_attachment_add_all(spine_array_bounding_box_attachment array,
/*@null*/ spine_array_bounding_box_attachment inValue);
SPINE_C_API void spine_array_bounding_box_attachment_clear_and_add_all(spine_array_bounding_box_attachment array,
spine_array_bounding_box_attachment inValue);
/*@null*/ spine_array_bounding_box_attachment inValue);
SPINE_C_API void spine_array_bounding_box_attachment_remove_at(spine_array_bounding_box_attachment array, size_t inIndex);
SPINE_C_API bool spine_array_bounding_box_attachment_contains(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue);
SPINE_C_API bool spine_array_bounding_box_attachment_contains(spine_array_bounding_box_attachment array,
/*@null*/ spine_bounding_box_attachment inValue);
SPINE_C_API int spine_array_bounding_box_attachment_index_of(spine_array_bounding_box_attachment array, spine_bounding_box_attachment inValue);
SPINE_C_API int spine_array_bounding_box_attachment_index_of(spine_array_bounding_box_attachment array,
/*@null*/ spine_bounding_box_attachment inValue);
SPINE_C_API spine_bounding_box_attachment *spine_array_bounding_box_attachment_buffer(spine_array_bounding_box_attachment array);
SPINE_C_API /*@null*/ spine_bounding_box_attachment *spine_array_bounding_box_attachment_buffer(spine_array_bounding_box_attachment array);
SPINE_C_API spine_array_constraint spine_array_constraint_create(void);
@ -416,23 +423,24 @@ SPINE_C_API size_t spine_array_constraint_get_capacity(spine_array_constraint ar
SPINE_C_API size_t spine_array_constraint_size(spine_array_constraint array);
SPINE_C_API spine_array_constraint spine_array_constraint_set_size(spine_array_constraint array, size_t newSize, spine_constraint defaultValue);
SPINE_C_API /*@null*/ spine_array_constraint spine_array_constraint_set_size(spine_array_constraint array, size_t newSize,
/*@null*/ spine_constraint defaultValue);
SPINE_C_API void spine_array_constraint_ensure_capacity(spine_array_constraint array, size_t newCapacity);
SPINE_C_API void spine_array_constraint_add(spine_array_constraint array, spine_constraint inValue);
SPINE_C_API void spine_array_constraint_add(spine_array_constraint array, /*@null*/ spine_constraint inValue);
SPINE_C_API void spine_array_constraint_add_all(spine_array_constraint array, spine_array_constraint inValue);
SPINE_C_API void spine_array_constraint_add_all(spine_array_constraint array, /*@null*/ spine_array_constraint inValue);
SPINE_C_API void spine_array_constraint_clear_and_add_all(spine_array_constraint array, spine_array_constraint inValue);
SPINE_C_API void spine_array_constraint_clear_and_add_all(spine_array_constraint array, /*@null*/ spine_array_constraint inValue);
SPINE_C_API void spine_array_constraint_remove_at(spine_array_constraint array, size_t inIndex);
SPINE_C_API bool spine_array_constraint_contains(spine_array_constraint array, spine_constraint inValue);
SPINE_C_API bool spine_array_constraint_contains(spine_array_constraint array, /*@null*/ spine_constraint inValue);
SPINE_C_API int spine_array_constraint_index_of(spine_array_constraint array, spine_constraint inValue);
SPINE_C_API int spine_array_constraint_index_of(spine_array_constraint array, /*@null*/ spine_constraint inValue);
SPINE_C_API spine_constraint *spine_array_constraint_buffer(spine_array_constraint array);
SPINE_C_API /*@null*/ spine_constraint *spine_array_constraint_buffer(spine_array_constraint array);
SPINE_C_API spine_array_constraint_data spine_array_constraint_data_create(void);
@ -444,24 +452,24 @@ SPINE_C_API size_t spine_array_constraint_data_get_capacity(spine_array_constrai
SPINE_C_API size_t spine_array_constraint_data_size(spine_array_constraint_data array);
SPINE_C_API spine_array_constraint_data spine_array_constraint_data_set_size(spine_array_constraint_data array, size_t newSize,
spine_constraint_data defaultValue);
SPINE_C_API /*@null*/ spine_array_constraint_data spine_array_constraint_data_set_size(spine_array_constraint_data array, size_t newSize,
/*@null*/ spine_constraint_data defaultValue);
SPINE_C_API void spine_array_constraint_data_ensure_capacity(spine_array_constraint_data array, size_t newCapacity);
SPINE_C_API void spine_array_constraint_data_add(spine_array_constraint_data array, spine_constraint_data inValue);
SPINE_C_API void spine_array_constraint_data_add(spine_array_constraint_data array, /*@null*/ spine_constraint_data inValue);
SPINE_C_API void spine_array_constraint_data_add_all(spine_array_constraint_data array, spine_array_constraint_data inValue);
SPINE_C_API void spine_array_constraint_data_add_all(spine_array_constraint_data array, /*@null*/ spine_array_constraint_data inValue);
SPINE_C_API void spine_array_constraint_data_clear_and_add_all(spine_array_constraint_data array, spine_array_constraint_data inValue);
SPINE_C_API void spine_array_constraint_data_clear_and_add_all(spine_array_constraint_data array, /*@null*/ spine_array_constraint_data inValue);
SPINE_C_API void spine_array_constraint_data_remove_at(spine_array_constraint_data array, size_t inIndex);
SPINE_C_API bool spine_array_constraint_data_contains(spine_array_constraint_data array, spine_constraint_data inValue);
SPINE_C_API bool spine_array_constraint_data_contains(spine_array_constraint_data array, /*@null*/ spine_constraint_data inValue);
SPINE_C_API int spine_array_constraint_data_index_of(spine_array_constraint_data array, spine_constraint_data inValue);
SPINE_C_API int spine_array_constraint_data_index_of(spine_array_constraint_data array, /*@null*/ spine_constraint_data inValue);
SPINE_C_API spine_constraint_data *spine_array_constraint_data_buffer(spine_array_constraint_data array);
SPINE_C_API /*@null*/ spine_constraint_data *spine_array_constraint_data_buffer(spine_array_constraint_data array);
SPINE_C_API spine_array_event spine_array_event_create(void);
@ -473,23 +481,23 @@ SPINE_C_API size_t spine_array_event_get_capacity(spine_array_event array);
SPINE_C_API size_t spine_array_event_size(spine_array_event array);
SPINE_C_API spine_array_event spine_array_event_set_size(spine_array_event array, size_t newSize, spine_event defaultValue);
SPINE_C_API /*@null*/ spine_array_event spine_array_event_set_size(spine_array_event array, size_t newSize, /*@null*/ spine_event defaultValue);
SPINE_C_API void spine_array_event_ensure_capacity(spine_array_event array, size_t newCapacity);
SPINE_C_API void spine_array_event_add(spine_array_event array, spine_event inValue);
SPINE_C_API void spine_array_event_add(spine_array_event array, /*@null*/ spine_event inValue);
SPINE_C_API void spine_array_event_add_all(spine_array_event array, spine_array_event inValue);
SPINE_C_API void spine_array_event_add_all(spine_array_event array, /*@null*/ spine_array_event inValue);
SPINE_C_API void spine_array_event_clear_and_add_all(spine_array_event array, spine_array_event inValue);
SPINE_C_API void spine_array_event_clear_and_add_all(spine_array_event array, /*@null*/ spine_array_event inValue);
SPINE_C_API void spine_array_event_remove_at(spine_array_event array, size_t inIndex);
SPINE_C_API bool spine_array_event_contains(spine_array_event array, spine_event inValue);
SPINE_C_API bool spine_array_event_contains(spine_array_event array, /*@null*/ spine_event inValue);
SPINE_C_API int spine_array_event_index_of(spine_array_event array, spine_event inValue);
SPINE_C_API int spine_array_event_index_of(spine_array_event array, /*@null*/ spine_event inValue);
SPINE_C_API spine_event *spine_array_event_buffer(spine_array_event array);
SPINE_C_API /*@null*/ spine_event *spine_array_event_buffer(spine_array_event array);
SPINE_C_API spine_array_event_data spine_array_event_data_create(void);
@ -501,23 +509,24 @@ SPINE_C_API size_t spine_array_event_data_get_capacity(spine_array_event_data ar
SPINE_C_API size_t spine_array_event_data_size(spine_array_event_data array);
SPINE_C_API spine_array_event_data spine_array_event_data_set_size(spine_array_event_data array, size_t newSize, spine_event_data defaultValue);
SPINE_C_API /*@null*/ spine_array_event_data spine_array_event_data_set_size(spine_array_event_data array, size_t newSize,
/*@null*/ spine_event_data defaultValue);
SPINE_C_API void spine_array_event_data_ensure_capacity(spine_array_event_data array, size_t newCapacity);
SPINE_C_API void spine_array_event_data_add(spine_array_event_data array, spine_event_data inValue);
SPINE_C_API void spine_array_event_data_add(spine_array_event_data array, /*@null*/ spine_event_data inValue);
SPINE_C_API void spine_array_event_data_add_all(spine_array_event_data array, spine_array_event_data inValue);
SPINE_C_API void spine_array_event_data_add_all(spine_array_event_data array, /*@null*/ spine_array_event_data inValue);
SPINE_C_API void spine_array_event_data_clear_and_add_all(spine_array_event_data array, spine_array_event_data inValue);
SPINE_C_API void spine_array_event_data_clear_and_add_all(spine_array_event_data array, /*@null*/ spine_array_event_data inValue);
SPINE_C_API void spine_array_event_data_remove_at(spine_array_event_data array, size_t inIndex);
SPINE_C_API bool spine_array_event_data_contains(spine_array_event_data array, spine_event_data inValue);
SPINE_C_API bool spine_array_event_data_contains(spine_array_event_data array, /*@null*/ spine_event_data inValue);
SPINE_C_API int spine_array_event_data_index_of(spine_array_event_data array, spine_event_data inValue);
SPINE_C_API int spine_array_event_data_index_of(spine_array_event_data array, /*@null*/ spine_event_data inValue);
SPINE_C_API spine_event_data *spine_array_event_data_buffer(spine_array_event_data array);
SPINE_C_API /*@null*/ spine_event_data *spine_array_event_data_buffer(spine_array_event_data array);
SPINE_C_API spine_array_from_property spine_array_from_property_create(void);
@ -529,24 +538,24 @@ SPINE_C_API size_t spine_array_from_property_get_capacity(spine_array_from_prope
SPINE_C_API size_t spine_array_from_property_size(spine_array_from_property array);
SPINE_C_API spine_array_from_property spine_array_from_property_set_size(spine_array_from_property array, size_t newSize,
spine_from_property defaultValue);
SPINE_C_API /*@null*/ spine_array_from_property spine_array_from_property_set_size(spine_array_from_property array, size_t newSize,
/*@null*/ spine_from_property defaultValue);
SPINE_C_API void spine_array_from_property_ensure_capacity(spine_array_from_property array, size_t newCapacity);
SPINE_C_API void spine_array_from_property_add(spine_array_from_property array, spine_from_property inValue);
SPINE_C_API void spine_array_from_property_add(spine_array_from_property array, /*@null*/ spine_from_property inValue);
SPINE_C_API void spine_array_from_property_add_all(spine_array_from_property array, spine_array_from_property inValue);
SPINE_C_API void spine_array_from_property_add_all(spine_array_from_property array, /*@null*/ spine_array_from_property inValue);
SPINE_C_API void spine_array_from_property_clear_and_add_all(spine_array_from_property array, spine_array_from_property inValue);
SPINE_C_API void spine_array_from_property_clear_and_add_all(spine_array_from_property array, /*@null*/ spine_array_from_property inValue);
SPINE_C_API void spine_array_from_property_remove_at(spine_array_from_property array, size_t inIndex);
SPINE_C_API bool spine_array_from_property_contains(spine_array_from_property array, spine_from_property inValue);
SPINE_C_API bool spine_array_from_property_contains(spine_array_from_property array, /*@null*/ spine_from_property inValue);
SPINE_C_API int spine_array_from_property_index_of(spine_array_from_property array, spine_from_property inValue);
SPINE_C_API int spine_array_from_property_index_of(spine_array_from_property array, /*@null*/ spine_from_property inValue);
SPINE_C_API spine_from_property *spine_array_from_property_buffer(spine_array_from_property array);
SPINE_C_API /*@null*/ spine_from_property *spine_array_from_property_buffer(spine_array_from_property array);
SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_create(void);
@ -558,24 +567,25 @@ SPINE_C_API size_t spine_array_physics_constraint_get_capacity(spine_array_physi
SPINE_C_API size_t spine_array_physics_constraint_size(spine_array_physics_constraint array);
SPINE_C_API spine_array_physics_constraint spine_array_physics_constraint_set_size(spine_array_physics_constraint array, size_t newSize,
spine_physics_constraint defaultValue);
SPINE_C_API /*@null*/ spine_array_physics_constraint spine_array_physics_constraint_set_size(spine_array_physics_constraint array, size_t newSize,
/*@null*/ spine_physics_constraint defaultValue);
SPINE_C_API void spine_array_physics_constraint_ensure_capacity(spine_array_physics_constraint array, size_t newCapacity);
SPINE_C_API void spine_array_physics_constraint_add(spine_array_physics_constraint array, spine_physics_constraint inValue);
SPINE_C_API void spine_array_physics_constraint_add(spine_array_physics_constraint array, /*@null*/ spine_physics_constraint inValue);
SPINE_C_API void spine_array_physics_constraint_add_all(spine_array_physics_constraint array, spine_array_physics_constraint inValue);
SPINE_C_API void spine_array_physics_constraint_add_all(spine_array_physics_constraint array, /*@null*/ spine_array_physics_constraint inValue);
SPINE_C_API void spine_array_physics_constraint_clear_and_add_all(spine_array_physics_constraint array, spine_array_physics_constraint inValue);
SPINE_C_API void spine_array_physics_constraint_clear_and_add_all(spine_array_physics_constraint array,
/*@null*/ spine_array_physics_constraint inValue);
SPINE_C_API void spine_array_physics_constraint_remove_at(spine_array_physics_constraint array, size_t inIndex);
SPINE_C_API bool spine_array_physics_constraint_contains(spine_array_physics_constraint array, spine_physics_constraint inValue);
SPINE_C_API bool spine_array_physics_constraint_contains(spine_array_physics_constraint array, /*@null*/ spine_physics_constraint inValue);
SPINE_C_API int spine_array_physics_constraint_index_of(spine_array_physics_constraint array, spine_physics_constraint inValue);
SPINE_C_API int spine_array_physics_constraint_index_of(spine_array_physics_constraint array, /*@null*/ spine_physics_constraint inValue);
SPINE_C_API spine_physics_constraint *spine_array_physics_constraint_buffer(spine_array_physics_constraint array);
SPINE_C_API /*@null*/ spine_physics_constraint *spine_array_physics_constraint_buffer(spine_array_physics_constraint array);
SPINE_C_API spine_array_polygon spine_array_polygon_create(void);
@ -587,23 +597,24 @@ SPINE_C_API size_t spine_array_polygon_get_capacity(spine_array_polygon array);
SPINE_C_API size_t spine_array_polygon_size(spine_array_polygon array);
SPINE_C_API spine_array_polygon spine_array_polygon_set_size(spine_array_polygon array, size_t newSize, spine_polygon defaultValue);
SPINE_C_API /*@null*/ spine_array_polygon spine_array_polygon_set_size(spine_array_polygon array, size_t newSize,
/*@null*/ spine_polygon defaultValue);
SPINE_C_API void spine_array_polygon_ensure_capacity(spine_array_polygon array, size_t newCapacity);
SPINE_C_API void spine_array_polygon_add(spine_array_polygon array, spine_polygon inValue);
SPINE_C_API void spine_array_polygon_add(spine_array_polygon array, /*@null*/ spine_polygon inValue);
SPINE_C_API void spine_array_polygon_add_all(spine_array_polygon array, spine_array_polygon inValue);
SPINE_C_API void spine_array_polygon_add_all(spine_array_polygon array, /*@null*/ spine_array_polygon inValue);
SPINE_C_API void spine_array_polygon_clear_and_add_all(spine_array_polygon array, spine_array_polygon inValue);
SPINE_C_API void spine_array_polygon_clear_and_add_all(spine_array_polygon array, /*@null*/ spine_array_polygon inValue);
SPINE_C_API void spine_array_polygon_remove_at(spine_array_polygon array, size_t inIndex);
SPINE_C_API bool spine_array_polygon_contains(spine_array_polygon array, spine_polygon inValue);
SPINE_C_API bool spine_array_polygon_contains(spine_array_polygon array, /*@null*/ spine_polygon inValue);
SPINE_C_API int spine_array_polygon_index_of(spine_array_polygon array, spine_polygon inValue);
SPINE_C_API int spine_array_polygon_index_of(spine_array_polygon array, /*@null*/ spine_polygon inValue);
SPINE_C_API spine_polygon *spine_array_polygon_buffer(spine_array_polygon array);
SPINE_C_API /*@null*/ spine_polygon *spine_array_polygon_buffer(spine_array_polygon array);
SPINE_C_API spine_array_skin spine_array_skin_create(void);
@ -615,23 +626,23 @@ SPINE_C_API size_t spine_array_skin_get_capacity(spine_array_skin array);
SPINE_C_API size_t spine_array_skin_size(spine_array_skin array);
SPINE_C_API spine_array_skin spine_array_skin_set_size(spine_array_skin array, size_t newSize, spine_skin defaultValue);
SPINE_C_API /*@null*/ spine_array_skin spine_array_skin_set_size(spine_array_skin array, size_t newSize, /*@null*/ spine_skin defaultValue);
SPINE_C_API void spine_array_skin_ensure_capacity(spine_array_skin array, size_t newCapacity);
SPINE_C_API void spine_array_skin_add(spine_array_skin array, spine_skin inValue);
SPINE_C_API void spine_array_skin_add(spine_array_skin array, /*@null*/ spine_skin inValue);
SPINE_C_API void spine_array_skin_add_all(spine_array_skin array, spine_array_skin inValue);
SPINE_C_API void spine_array_skin_add_all(spine_array_skin array, /*@null*/ spine_array_skin inValue);
SPINE_C_API void spine_array_skin_clear_and_add_all(spine_array_skin array, spine_array_skin inValue);
SPINE_C_API void spine_array_skin_clear_and_add_all(spine_array_skin array, /*@null*/ spine_array_skin inValue);
SPINE_C_API void spine_array_skin_remove_at(spine_array_skin array, size_t inIndex);
SPINE_C_API bool spine_array_skin_contains(spine_array_skin array, spine_skin inValue);
SPINE_C_API bool spine_array_skin_contains(spine_array_skin array, /*@null*/ spine_skin inValue);
SPINE_C_API int spine_array_skin_index_of(spine_array_skin array, spine_skin inValue);
SPINE_C_API int spine_array_skin_index_of(spine_array_skin array, /*@null*/ spine_skin inValue);
SPINE_C_API spine_skin *spine_array_skin_buffer(spine_array_skin array);
SPINE_C_API /*@null*/ spine_skin *spine_array_skin_buffer(spine_array_skin array);
SPINE_C_API spine_array_slot spine_array_slot_create(void);
@ -643,23 +654,23 @@ SPINE_C_API size_t spine_array_slot_get_capacity(spine_array_slot array);
SPINE_C_API size_t spine_array_slot_size(spine_array_slot array);
SPINE_C_API spine_array_slot spine_array_slot_set_size(spine_array_slot array, size_t newSize, spine_slot defaultValue);
SPINE_C_API /*@null*/ spine_array_slot spine_array_slot_set_size(spine_array_slot array, size_t newSize, /*@null*/ spine_slot defaultValue);
SPINE_C_API void spine_array_slot_ensure_capacity(spine_array_slot array, size_t newCapacity);
SPINE_C_API void spine_array_slot_add(spine_array_slot array, spine_slot inValue);
SPINE_C_API void spine_array_slot_add(spine_array_slot array, /*@null*/ spine_slot inValue);
SPINE_C_API void spine_array_slot_add_all(spine_array_slot array, spine_array_slot inValue);
SPINE_C_API void spine_array_slot_add_all(spine_array_slot array, /*@null*/ spine_array_slot inValue);
SPINE_C_API void spine_array_slot_clear_and_add_all(spine_array_slot array, spine_array_slot inValue);
SPINE_C_API void spine_array_slot_clear_and_add_all(spine_array_slot array, /*@null*/ spine_array_slot inValue);
SPINE_C_API void spine_array_slot_remove_at(spine_array_slot array, size_t inIndex);
SPINE_C_API bool spine_array_slot_contains(spine_array_slot array, spine_slot inValue);
SPINE_C_API bool spine_array_slot_contains(spine_array_slot array, /*@null*/ spine_slot inValue);
SPINE_C_API int spine_array_slot_index_of(spine_array_slot array, spine_slot inValue);
SPINE_C_API int spine_array_slot_index_of(spine_array_slot array, /*@null*/ spine_slot inValue);
SPINE_C_API spine_slot *spine_array_slot_buffer(spine_array_slot array);
SPINE_C_API /*@null*/ spine_slot *spine_array_slot_buffer(spine_array_slot array);
SPINE_C_API spine_array_slot_data spine_array_slot_data_create(void);
@ -671,23 +682,24 @@ SPINE_C_API size_t spine_array_slot_data_get_capacity(spine_array_slot_data arra
SPINE_C_API size_t spine_array_slot_data_size(spine_array_slot_data array);
SPINE_C_API spine_array_slot_data spine_array_slot_data_set_size(spine_array_slot_data array, size_t newSize, spine_slot_data defaultValue);
SPINE_C_API /*@null*/ spine_array_slot_data spine_array_slot_data_set_size(spine_array_slot_data array, size_t newSize,
/*@null*/ spine_slot_data defaultValue);
SPINE_C_API void spine_array_slot_data_ensure_capacity(spine_array_slot_data array, size_t newCapacity);
SPINE_C_API void spine_array_slot_data_add(spine_array_slot_data array, spine_slot_data inValue);
SPINE_C_API void spine_array_slot_data_add(spine_array_slot_data array, /*@null*/ spine_slot_data inValue);
SPINE_C_API void spine_array_slot_data_add_all(spine_array_slot_data array, spine_array_slot_data inValue);
SPINE_C_API void spine_array_slot_data_add_all(spine_array_slot_data array, /*@null*/ spine_array_slot_data inValue);
SPINE_C_API void spine_array_slot_data_clear_and_add_all(spine_array_slot_data array, spine_array_slot_data inValue);
SPINE_C_API void spine_array_slot_data_clear_and_add_all(spine_array_slot_data array, /*@null*/ spine_array_slot_data inValue);
SPINE_C_API void spine_array_slot_data_remove_at(spine_array_slot_data array, size_t inIndex);
SPINE_C_API bool spine_array_slot_data_contains(spine_array_slot_data array, spine_slot_data inValue);
SPINE_C_API bool spine_array_slot_data_contains(spine_array_slot_data array, /*@null*/ spine_slot_data inValue);
SPINE_C_API int spine_array_slot_data_index_of(spine_array_slot_data array, spine_slot_data inValue);
SPINE_C_API int spine_array_slot_data_index_of(spine_array_slot_data array, /*@null*/ spine_slot_data inValue);
SPINE_C_API spine_slot_data *spine_array_slot_data_buffer(spine_array_slot_data array);
SPINE_C_API /*@null*/ spine_slot_data *spine_array_slot_data_buffer(spine_array_slot_data array);
SPINE_C_API spine_array_texture_region spine_array_texture_region_create(void);
@ -699,24 +711,24 @@ SPINE_C_API size_t spine_array_texture_region_get_capacity(spine_array_texture_r
SPINE_C_API size_t spine_array_texture_region_size(spine_array_texture_region array);
SPINE_C_API spine_array_texture_region spine_array_texture_region_set_size(spine_array_texture_region array, size_t newSize,
spine_texture_region defaultValue);
SPINE_C_API /*@null*/ spine_array_texture_region spine_array_texture_region_set_size(spine_array_texture_region array, size_t newSize,
/*@null*/ spine_texture_region defaultValue);
SPINE_C_API void spine_array_texture_region_ensure_capacity(spine_array_texture_region array, size_t newCapacity);
SPINE_C_API void spine_array_texture_region_add(spine_array_texture_region array, spine_texture_region inValue);
SPINE_C_API void spine_array_texture_region_add(spine_array_texture_region array, /*@null*/ spine_texture_region inValue);
SPINE_C_API void spine_array_texture_region_add_all(spine_array_texture_region array, spine_array_texture_region inValue);
SPINE_C_API void spine_array_texture_region_add_all(spine_array_texture_region array, /*@null*/ spine_array_texture_region inValue);
SPINE_C_API void spine_array_texture_region_clear_and_add_all(spine_array_texture_region array, spine_array_texture_region inValue);
SPINE_C_API void spine_array_texture_region_clear_and_add_all(spine_array_texture_region array, /*@null*/ spine_array_texture_region inValue);
SPINE_C_API void spine_array_texture_region_remove_at(spine_array_texture_region array, size_t inIndex);
SPINE_C_API bool spine_array_texture_region_contains(spine_array_texture_region array, spine_texture_region inValue);
SPINE_C_API bool spine_array_texture_region_contains(spine_array_texture_region array, /*@null*/ spine_texture_region inValue);
SPINE_C_API int spine_array_texture_region_index_of(spine_array_texture_region array, spine_texture_region inValue);
SPINE_C_API int spine_array_texture_region_index_of(spine_array_texture_region array, /*@null*/ spine_texture_region inValue);
SPINE_C_API spine_texture_region *spine_array_texture_region_buffer(spine_array_texture_region array);
SPINE_C_API /*@null*/ spine_texture_region *spine_array_texture_region_buffer(spine_array_texture_region array);
SPINE_C_API spine_array_timeline spine_array_timeline_create(void);
@ -728,23 +740,24 @@ SPINE_C_API size_t spine_array_timeline_get_capacity(spine_array_timeline array)
SPINE_C_API size_t spine_array_timeline_size(spine_array_timeline array);
SPINE_C_API spine_array_timeline spine_array_timeline_set_size(spine_array_timeline array, size_t newSize, spine_timeline defaultValue);
SPINE_C_API /*@null*/ spine_array_timeline spine_array_timeline_set_size(spine_array_timeline array, size_t newSize,
/*@null*/ spine_timeline defaultValue);
SPINE_C_API void spine_array_timeline_ensure_capacity(spine_array_timeline array, size_t newCapacity);
SPINE_C_API void spine_array_timeline_add(spine_array_timeline array, spine_timeline inValue);
SPINE_C_API void spine_array_timeline_add(spine_array_timeline array, /*@null*/ spine_timeline inValue);
SPINE_C_API void spine_array_timeline_add_all(spine_array_timeline array, spine_array_timeline inValue);
SPINE_C_API void spine_array_timeline_add_all(spine_array_timeline array, /*@null*/ spine_array_timeline inValue);
SPINE_C_API void spine_array_timeline_clear_and_add_all(spine_array_timeline array, spine_array_timeline inValue);
SPINE_C_API void spine_array_timeline_clear_and_add_all(spine_array_timeline array, /*@null*/ spine_array_timeline inValue);
SPINE_C_API void spine_array_timeline_remove_at(spine_array_timeline array, size_t inIndex);
SPINE_C_API bool spine_array_timeline_contains(spine_array_timeline array, spine_timeline inValue);
SPINE_C_API bool spine_array_timeline_contains(spine_array_timeline array, /*@null*/ spine_timeline inValue);
SPINE_C_API int spine_array_timeline_index_of(spine_array_timeline array, spine_timeline inValue);
SPINE_C_API int spine_array_timeline_index_of(spine_array_timeline array, /*@null*/ spine_timeline inValue);
SPINE_C_API spine_timeline *spine_array_timeline_buffer(spine_array_timeline array);
SPINE_C_API /*@null*/ spine_timeline *spine_array_timeline_buffer(spine_array_timeline array);
SPINE_C_API spine_array_to_property spine_array_to_property_create(void);
@ -756,23 +769,24 @@ SPINE_C_API size_t spine_array_to_property_get_capacity(spine_array_to_property
SPINE_C_API size_t spine_array_to_property_size(spine_array_to_property array);
SPINE_C_API spine_array_to_property spine_array_to_property_set_size(spine_array_to_property array, size_t newSize, spine_to_property defaultValue);
SPINE_C_API /*@null*/ spine_array_to_property spine_array_to_property_set_size(spine_array_to_property array, size_t newSize,
/*@null*/ spine_to_property defaultValue);
SPINE_C_API void spine_array_to_property_ensure_capacity(spine_array_to_property array, size_t newCapacity);
SPINE_C_API void spine_array_to_property_add(spine_array_to_property array, spine_to_property inValue);
SPINE_C_API void spine_array_to_property_add(spine_array_to_property array, /*@null*/ spine_to_property inValue);
SPINE_C_API void spine_array_to_property_add_all(spine_array_to_property array, spine_array_to_property inValue);
SPINE_C_API void spine_array_to_property_add_all(spine_array_to_property array, /*@null*/ spine_array_to_property inValue);
SPINE_C_API void spine_array_to_property_clear_and_add_all(spine_array_to_property array, spine_array_to_property inValue);
SPINE_C_API void spine_array_to_property_clear_and_add_all(spine_array_to_property array, /*@null*/ spine_array_to_property inValue);
SPINE_C_API void spine_array_to_property_remove_at(spine_array_to_property array, size_t inIndex);
SPINE_C_API bool spine_array_to_property_contains(spine_array_to_property array, spine_to_property inValue);
SPINE_C_API bool spine_array_to_property_contains(spine_array_to_property array, /*@null*/ spine_to_property inValue);
SPINE_C_API int spine_array_to_property_index_of(spine_array_to_property array, spine_to_property inValue);
SPINE_C_API int spine_array_to_property_index_of(spine_array_to_property array, /*@null*/ spine_to_property inValue);
SPINE_C_API spine_to_property *spine_array_to_property_buffer(spine_array_to_property array);
SPINE_C_API /*@null*/ spine_to_property *spine_array_to_property_buffer(spine_array_to_property array);
SPINE_C_API spine_array_track_entry spine_array_track_entry_create(void);
@ -784,23 +798,24 @@ SPINE_C_API size_t spine_array_track_entry_get_capacity(spine_array_track_entry
SPINE_C_API size_t spine_array_track_entry_size(spine_array_track_entry array);
SPINE_C_API spine_array_track_entry spine_array_track_entry_set_size(spine_array_track_entry array, size_t newSize, spine_track_entry defaultValue);
SPINE_C_API /*@null*/ spine_array_track_entry spine_array_track_entry_set_size(spine_array_track_entry array, size_t newSize,
/*@null*/ spine_track_entry defaultValue);
SPINE_C_API void spine_array_track_entry_ensure_capacity(spine_array_track_entry array, size_t newCapacity);
SPINE_C_API void spine_array_track_entry_add(spine_array_track_entry array, spine_track_entry inValue);
SPINE_C_API void spine_array_track_entry_add(spine_array_track_entry array, /*@null*/ spine_track_entry inValue);
SPINE_C_API void spine_array_track_entry_add_all(spine_array_track_entry array, spine_array_track_entry inValue);
SPINE_C_API void spine_array_track_entry_add_all(spine_array_track_entry array, /*@null*/ spine_array_track_entry inValue);
SPINE_C_API void spine_array_track_entry_clear_and_add_all(spine_array_track_entry array, spine_array_track_entry inValue);
SPINE_C_API void spine_array_track_entry_clear_and_add_all(spine_array_track_entry array, /*@null*/ spine_array_track_entry inValue);
SPINE_C_API void spine_array_track_entry_remove_at(spine_array_track_entry array, size_t inIndex);
SPINE_C_API bool spine_array_track_entry_contains(spine_array_track_entry array, spine_track_entry inValue);
SPINE_C_API bool spine_array_track_entry_contains(spine_array_track_entry array, /*@null*/ spine_track_entry inValue);
SPINE_C_API int spine_array_track_entry_index_of(spine_array_track_entry array, spine_track_entry inValue);
SPINE_C_API int spine_array_track_entry_index_of(spine_array_track_entry array, /*@null*/ spine_track_entry inValue);
SPINE_C_API spine_track_entry *spine_array_track_entry_buffer(spine_array_track_entry array);
SPINE_C_API /*@null*/ spine_track_entry *spine_array_track_entry_buffer(spine_array_track_entry array);
SPINE_C_API spine_array_update spine_array_update_create(void);
@ -812,23 +827,23 @@ SPINE_C_API size_t spine_array_update_get_capacity(spine_array_update array);
SPINE_C_API size_t spine_array_update_size(spine_array_update array);
SPINE_C_API spine_array_update spine_array_update_set_size(spine_array_update array, size_t newSize, spine_update defaultValue);
SPINE_C_API /*@null*/ spine_array_update spine_array_update_set_size(spine_array_update array, size_t newSize, /*@null*/ spine_update defaultValue);
SPINE_C_API void spine_array_update_ensure_capacity(spine_array_update array, size_t newCapacity);
SPINE_C_API void spine_array_update_add(spine_array_update array, spine_update inValue);
SPINE_C_API void spine_array_update_add(spine_array_update array, /*@null*/ spine_update inValue);
SPINE_C_API void spine_array_update_add_all(spine_array_update array, spine_array_update inValue);
SPINE_C_API void spine_array_update_add_all(spine_array_update array, /*@null*/ spine_array_update inValue);
SPINE_C_API void spine_array_update_clear_and_add_all(spine_array_update array, spine_array_update inValue);
SPINE_C_API void spine_array_update_clear_and_add_all(spine_array_update array, /*@null*/ spine_array_update inValue);
SPINE_C_API void spine_array_update_remove_at(spine_array_update array, size_t inIndex);
SPINE_C_API bool spine_array_update_contains(spine_array_update array, spine_update inValue);
SPINE_C_API bool spine_array_update_contains(spine_array_update array, /*@null*/ spine_update inValue);
SPINE_C_API int spine_array_update_index_of(spine_array_update array, spine_update inValue);
SPINE_C_API int spine_array_update_index_of(spine_array_update array, /*@null*/ spine_update inValue);
SPINE_C_API spine_update *spine_array_update_buffer(spine_array_update array);
SPINE_C_API /*@null*/ spine_update *spine_array_update_buffer(spine_array_update array);
#ifdef __cplusplus
}

6
spine-c/src/generated/atlas.cpp
View File

@ -12,17 +12,17 @@ void spine_atlas_flip_v(spine_atlas self) {
_self->flipV();
}
spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name) {
/*@null*/ spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name) {
Atlas *_self = (Atlas *) self;
return (spine_atlas_region) _self->findRegion(String(name));
}
spine_array_atlas_page spine_atlas_get_pages(spine_atlas self) {
/*@null*/ spine_array_atlas_page spine_atlas_get_pages(spine_atlas self) {
Atlas *_self = (Atlas *) self;
return (spine_array_atlas_page) &_self->getPages();
}
spine_array_atlas_region spine_atlas_get_regions(spine_atlas self) {
/*@null*/ spine_array_atlas_region spine_atlas_get_regions(spine_atlas self) {
Atlas *_self = (Atlas *) self;
return (spine_array_atlas_region) &_self->getRegions();
}

6
spine-c/src/generated/atlas.h
View File

@ -12,9 +12,9 @@ extern "C" {
SPINE_C_API void spine_atlas_dispose(spine_atlas self);
SPINE_C_API void spine_atlas_flip_v(spine_atlas self);
SPINE_C_API spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name);
SPINE_C_API spine_array_atlas_page spine_atlas_get_pages(spine_atlas self);
SPINE_C_API spine_array_atlas_region spine_atlas_get_regions(spine_atlas self);
SPINE_C_API /*@null*/ spine_atlas_region spine_atlas_find_region(spine_atlas self, const char *name);
SPINE_C_API /*@null*/ spine_array_atlas_page spine_atlas_get_pages(spine_atlas self);
SPINE_C_API /*@null*/ spine_array_atlas_region spine_atlas_get_regions(spine_atlas self);
#ifdef __cplusplus
}

28
spine-c/src/generated/atlas_attachment_loader.cpp
View File

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

30
spine-c/src/generated/atlas_attachment_loader.h
View File

@ -9,23 +9,25 @@
extern "C" {
#endif
SPINE_C_API spine_atlas_attachment_loader spine_atlas_attachment_loader_create(spine_atlas atlas);
SPINE_C_API spine_atlas_attachment_loader spine_atlas_attachment_loader_create(/*@null*/ spine_atlas atlas);
SPINE_C_API void spine_atlas_attachment_loader_dispose(spine_atlas_attachment_loader self);
SPINE_C_API spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name, const char *path, spine_sequence sequence);
SPINE_C_API spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name, const char *path, spine_sequence sequence);
SPINE_C_API spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self,
spine_skin skin, const char *name);
SPINE_C_API spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name);
SPINE_C_API spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name);
SPINE_C_API spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name);
SPINE_C_API spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char *name);
SPINE_C_API /*@null*/ spine_region_attachment spine_atlas_attachment_loader_new_region_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name, const char *path,
/*@null*/ spine_sequence sequence);
SPINE_C_API /*@null*/ spine_mesh_attachment spine_atlas_attachment_loader_new_mesh_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name, const char *path,
/*@null*/ spine_sequence sequence);
SPINE_C_API /*@null*/ spine_bounding_box_attachment spine_atlas_attachment_loader_new_bounding_box_attachment(spine_atlas_attachment_loader self,
spine_skin skin, const char *name);
SPINE_C_API /*@null*/ spine_path_attachment spine_atlas_attachment_loader_new_path_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name);
SPINE_C_API /*@null*/ spine_point_attachment spine_atlas_attachment_loader_new_point_attachment(spine_atlas_attachment_loader self, spine_skin skin,
const char *name);
SPINE_C_API /*@null*/ spine_clipping_attachment spine_atlas_attachment_loader_new_clipping_attachment(spine_atlas_attachment_loader self,
spine_skin skin, const char *name);
SPINE_C_API /*@null*/ spine_atlas_region spine_atlas_attachment_loader_find_region(spine_atlas_attachment_loader self, const char *name);
#ifdef __cplusplus
}

4
spine-c/src/generated/atlas_page.cpp
View File

@ -121,12 +121,12 @@ void spine_atlas_page_set_index(spine_atlas_page self, int value) {
_self->index = value;
}
void *spine_atlas_page_get_texture(spine_atlas_page self) {
/*@null*/ void *spine_atlas_page_get_texture(spine_atlas_page self) {
AtlasPage *_self = (AtlasPage *) self;
return _self->texture;
}
void spine_atlas_page_set_texture(spine_atlas_page self, void *value) {
void spine_atlas_page_set_texture(spine_atlas_page self, /*@null*/ void *value) {
AtlasPage *_self = (AtlasPage *) self;
_self->texture = (void *) value;
}

4
spine-c/src/generated/atlas_page.h
View File

@ -35,8 +35,8 @@ SPINE_C_API bool spine_atlas_page_get_pma(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_pma(spine_atlas_page self, bool value);
SPINE_C_API int spine_atlas_page_get_index(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_index(spine_atlas_page self, int value);
SPINE_C_API void *spine_atlas_page_get_texture(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_texture(spine_atlas_page self, void *value);
SPINE_C_API /*@null*/ void *spine_atlas_page_get_texture(spine_atlas_page self);
SPINE_C_API void spine_atlas_page_set_texture(spine_atlas_page self, /*@null*/ void *value);
#ifdef __cplusplus
}

4
spine-c/src/generated/atlas_region.cpp
View File

@ -16,7 +16,7 @@ spine_rtti spine_atlas_region_get_rtti(spine_atlas_region self) {
return (spine_rtti) &_self->getRTTI();
}
spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self) {
/*@null*/ spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self) {
AtlasRegion *_self = (AtlasRegion *) self;
return (spine_atlas_page) _self->getPage();
}
@ -96,7 +96,7 @@ spine_array_float spine_atlas_region_get_values(spine_atlas_region self) {
return (spine_array_float) &_self->getValues();
}
void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value) {
void spine_atlas_region_set_page(spine_atlas_region self, /*@null*/ spine_atlas_page value) {
AtlasRegion *_self = (AtlasRegion *) self;
_self->setPage((AtlasPage *) value);
}

4
spine-c/src/generated/atlas_region.h
View File

@ -14,7 +14,7 @@ SPINE_C_API spine_atlas_region spine_atlas_region_create(void);
SPINE_C_API void spine_atlas_region_dispose(spine_atlas_region self);
SPINE_C_API spine_rtti spine_atlas_region_get_rtti(spine_atlas_region self);
SPINE_C_API spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self);
SPINE_C_API /*@null*/ spine_atlas_page spine_atlas_region_get_page(spine_atlas_region self);
SPINE_C_API const char *spine_atlas_region_get_name(spine_atlas_region self);
SPINE_C_API int spine_atlas_region_get_index(spine_atlas_region self);
SPINE_C_API int spine_atlas_region_get_x(spine_atlas_region self);
@ -30,7 +30,7 @@ SPINE_C_API int spine_atlas_region_get_degrees(spine_atlas_region self);
SPINE_C_API spine_array_int spine_atlas_region_get_splits(spine_atlas_region self);
SPINE_C_API spine_array_int spine_atlas_region_get_pads(spine_atlas_region self);
SPINE_C_API spine_array_float spine_atlas_region_get_values(spine_atlas_region self);
SPINE_C_API void spine_atlas_region_set_page(spine_atlas_region self, spine_atlas_page value);
SPINE_C_API void spine_atlas_region_set_page(spine_atlas_region self, /*@null*/ spine_atlas_page value);
SPINE_C_API void spine_atlas_region_set_name(spine_atlas_region self, const char *value);
SPINE_C_API void spine_atlas_region_set_index(spine_atlas_region self, int value);
SPINE_C_API void spine_atlas_region_set_x(spine_atlas_region self, int value);

17
spine-c/src/generated/attachment_loader.cpp
View File

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

24
spine-c/src/generated/attachment_loader.h
View File

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

5
spine-c/src/generated/attachment_timeline.cpp
View File

@ -16,8 +16,9 @@ spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline self) {
return (spine_rtti) &_self->getRTTI();
}
void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
AttachmentTimeline *_self = (AttachmentTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);

4
spine-c/src/generated/attachment_timeline.h
View File

@ -15,8 +15,8 @@ SPINE_C_API void spine_attachment_timeline_dispose(spine_attachment_timeline sel
SPINE_C_API spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline self);
SPINE_C_API void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ 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);

8
spine-c/src/generated/bone.cpp
View File

@ -3,11 +3,11 @@
using namespace spine;
spine_bone spine_bone_create(spine_bone_data data, spine_bone parent) {
spine_bone spine_bone_create(spine_bone_data data, /*@null*/ spine_bone parent) {
return (spine_bone) new (__FILE__, __LINE__) Bone(*((BoneData *) data), (Bone *) parent);
}
spine_bone spine_bone_create2(spine_bone bone, spine_bone parent) {
spine_bone spine_bone_create2(spine_bone bone, /*@null*/ spine_bone parent) {
return (spine_bone) new (__FILE__, __LINE__) Bone(*((Bone *) bone), (Bone *) parent);
}
@ -20,12 +20,12 @@ spine_rtti spine_bone_get_rtti(spine_bone self) {
return (spine_rtti) &_self->getRTTI();
}
spine_bone spine_bone_get_parent(spine_bone self) {
/*@null*/ spine_bone spine_bone_get_parent(spine_bone self) {
Bone *_self = (Bone *) self;
return (spine_bone) _self->getParent();
}
spine_array_bone spine_bone_get_children(spine_bone self) {
/*@null*/ spine_array_bone spine_bone_get_children(spine_bone self) {
Bone *_self = (Bone *) self;
return (spine_array_bone) &_self->getChildren();
}

8
spine-c/src/generated/bone.h
View File

@ -9,14 +9,14 @@
extern "C" {
#endif
SPINE_C_API spine_bone spine_bone_create(spine_bone_data data, spine_bone parent);
SPINE_C_API spine_bone spine_bone_create2(spine_bone bone, spine_bone parent);
SPINE_C_API spine_bone spine_bone_create(spine_bone_data data, /*@null*/ spine_bone parent);
SPINE_C_API spine_bone spine_bone_create2(spine_bone bone, /*@null*/ spine_bone parent);
SPINE_C_API void spine_bone_dispose(spine_bone self);
SPINE_C_API spine_rtti spine_bone_get_rtti(spine_bone self);
SPINE_C_API spine_bone spine_bone_get_parent(spine_bone self);
SPINE_C_API spine_array_bone spine_bone_get_children(spine_bone self);
SPINE_C_API /*@null*/ spine_bone spine_bone_get_parent(spine_bone self);
SPINE_C_API /*@null*/ spine_array_bone spine_bone_get_children(spine_bone self);
SPINE_C_API bool spine_bone_is_y_down(void);
SPINE_C_API void spine_bone_set_y_down(bool value);
SPINE_C_API void spine_bone_update(spine_bone self, spine_skeleton skeleton, spine_physics physics);

4
spine-c/src/generated/bone_data.cpp
View File

@ -3,7 +3,7 @@
using namespace spine;
spine_bone_data spine_bone_data_create(int index, const char *name, spine_bone_data parent) {
spine_bone_data spine_bone_data_create(int index, const char *name, /*@null*/ spine_bone_data parent) {
return (spine_bone_data) new (__FILE__, __LINE__) BoneData(index, String(name), (BoneData *) parent);
}
@ -16,7 +16,7 @@ int spine_bone_data_get_index(spine_bone_data self) {
return _self->getIndex();
}
spine_bone_data spine_bone_data_get_parent(spine_bone_data self) {
/*@null*/ spine_bone_data spine_bone_data_get_parent(spine_bone_data self) {
BoneData *_self = (BoneData *) self;
return (spine_bone_data) _self->getParent();
}

4
spine-c/src/generated/bone_data.h
View File

@ -9,12 +9,12 @@
extern "C" {
#endif
SPINE_C_API spine_bone_data spine_bone_data_create(int index, const char *name, spine_bone_data parent);
SPINE_C_API spine_bone_data spine_bone_data_create(int index, const char *name, /*@null*/ spine_bone_data parent);
SPINE_C_API void spine_bone_data_dispose(spine_bone_data self);
SPINE_C_API int spine_bone_data_get_index(spine_bone_data self);
SPINE_C_API spine_bone_data spine_bone_data_get_parent(spine_bone_data self);
SPINE_C_API /*@null*/ spine_bone_data spine_bone_data_get_parent(spine_bone_data self);
SPINE_C_API float spine_bone_data_get_length(spine_bone_data self);
SPINE_C_API void spine_bone_data_set_length(spine_bone_data self, float inValue);
SPINE_C_API spine_color spine_bone_data_get_color(spine_bone_data self);

2
spine-c/src/generated/bone_timeline1.cpp
View File

@ -12,7 +12,7 @@ spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self) {
return (spine_rtti) &_self->getRTTI();
}
void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
BoneTimeline1 *_self = (BoneTimeline1 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

5
spine-c/src/generated/bone_timeline1.h
View File

@ -12,8 +12,9 @@ extern "C" {
SPINE_C_API void spine_bone_timeline1_dispose(spine_bone_timeline1 self);
SPINE_C_API spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self);
SPINE_C_API void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ 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);

2
spine-c/src/generated/bone_timeline2.cpp
View File

@ -12,7 +12,7 @@ spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self) {
return (spine_rtti) &_self->getRTTI();
}
void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
BoneTimeline2 *_self = (BoneTimeline2 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

5
spine-c/src/generated/bone_timeline2.h
View File

@ -12,8 +12,9 @@ extern "C" {
SPINE_C_API void spine_bone_timeline2_dispose(spine_bone_timeline2 self);
SPINE_C_API spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self);
SPINE_C_API void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ 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);

7
spine-c/src/generated/bounding_box_attachment.cpp
View File

@ -27,7 +27,8 @@ spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachmen
}
void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, float *worldVertices, size_t offset, size_t stride) {
size_t start, size_t count, /*@null*/ float *worldVertices, size_t offset,
size_t stride) {
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
}
@ -74,12 +75,12 @@ void spine_bounding_box_attachment_set_world_vertices_length(spine_bounding_box_
_self->setWorldVerticesLength(inValue);
}
spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self) {
/*@null*/ spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self) {
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
return (spine_attachment) _self->getTimelineAttachment();
}
void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, spine_attachment attachment) {
void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, /*@null*/ spine_attachment attachment) {
VertexAttachment *_self = (VertexAttachment *) (BoundingBoxAttachment *) self;
_self->setTimelineAttachment((Attachment *) attachment);
}

6
spine-c/src/generated/bounding_box_attachment.h
View File

@ -17,7 +17,7 @@ SPINE_C_API spine_rtti spine_bounding_box_attachment_get_rtti(spine_bounding_box
SPINE_C_API spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment self);
SPINE_C_API spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_1(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, float *worldVertices, size_t offset,
size_t start, size_t count, /*@null*/ float *worldVertices, size_t offset,
size_t stride);
SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_2(spine_bounding_box_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, spine_array_float worldVertices, size_t offset,
@ -29,8 +29,8 @@ SPINE_C_API spine_array_float spine_bounding_box_attachment_get_vertices(spine_b
SPINE_C_API void spine_bounding_box_attachment_set_vertices(spine_bounding_box_attachment self, spine_array_float vertices);
SPINE_C_API size_t spine_bounding_box_attachment_get_world_vertices_length(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_set_world_vertices_length(spine_bounding_box_attachment self, size_t inValue);
SPINE_C_API spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, spine_attachment attachment);
SPINE_C_API /*@null*/ spine_attachment spine_bounding_box_attachment_get_timeline_attachment(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_set_timeline_attachment(spine_bounding_box_attachment self, /*@null*/ spine_attachment attachment);
SPINE_C_API void spine_bounding_box_attachment_copy_to(spine_bounding_box_attachment self, spine_vertex_attachment other);
SPINE_C_API const char *spine_bounding_box_attachment_get_name(spine_bounding_box_attachment self);
SPINE_C_API int spine_bounding_box_attachment_get_ref_count(spine_bounding_box_attachment self);

10
spine-c/src/generated/clipping_attachment.cpp
View File

@ -16,12 +16,12 @@ spine_rtti spine_clipping_attachment_get_rtti(spine_clipping_attachment self) {
return (spine_rtti) &_self->getRTTI();
}
spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self) {
/*@null*/ spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self) {
ClippingAttachment *_self = (ClippingAttachment *) self;
return (spine_slot_data) _self->getEndSlot();
}
void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, spine_slot_data inValue) {
void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, /*@null*/ spine_slot_data inValue) {
ClippingAttachment *_self = (ClippingAttachment *) self;
_self->setEndSlot((SlotData *) inValue);
}
@ -37,7 +37,7 @@ spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment self)
}
void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
size_t count, float *worldVertices, size_t offset, size_t stride) {
size_t count, /*@null*/ float *worldVertices, size_t offset, size_t stride) {
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
}
@ -83,12 +83,12 @@ void spine_clipping_attachment_set_world_vertices_length(spine_clipping_attachme
_self->setWorldVerticesLength(inValue);
}
spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self) {
/*@null*/ spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self) {
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
return (spine_attachment) _self->getTimelineAttachment();
}
void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, spine_attachment attachment) {
void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, /*@null*/ spine_attachment attachment) {
VertexAttachment *_self = (VertexAttachment *) (ClippingAttachment *) self;
_self->setTimelineAttachment((Attachment *) attachment);
}

11
spine-c/src/generated/clipping_attachment.h
View File

@ -14,12 +14,13 @@ SPINE_C_API spine_clipping_attachment spine_clipping_attachment_create(const cha
SPINE_C_API void spine_clipping_attachment_dispose(spine_clipping_attachment self);
SPINE_C_API spine_rtti spine_clipping_attachment_get_rtti(spine_clipping_attachment self);
SPINE_C_API spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, spine_slot_data inValue);
SPINE_C_API /*@null*/ spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, /*@null*/ spine_slot_data inValue);
SPINE_C_API spine_color spine_clipping_attachment_get_color(spine_clipping_attachment self);
SPINE_C_API spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_compute_world_vertices_1(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, float *worldVertices, size_t offset, size_t stride);
size_t start, size_t count, /*@null*/ float *worldVertices, size_t offset,
size_t stride);
SPINE_C_API void spine_clipping_attachment_compute_world_vertices_2(spine_clipping_attachment self, spine_skeleton skeleton, spine_slot slot,
size_t start, size_t count, spine_array_float worldVertices, size_t offset,
size_t stride);
@ -30,8 +31,8 @@ SPINE_C_API spine_array_float spine_clipping_attachment_get_vertices(spine_clipp
SPINE_C_API void spine_clipping_attachment_set_vertices(spine_clipping_attachment self, spine_array_float vertices);
SPINE_C_API size_t spine_clipping_attachment_get_world_vertices_length(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_set_world_vertices_length(spine_clipping_attachment self, size_t inValue);
SPINE_C_API spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, spine_attachment attachment);
SPINE_C_API /*@null*/ spine_attachment spine_clipping_attachment_get_timeline_attachment(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_set_timeline_attachment(spine_clipping_attachment self, /*@null*/ spine_attachment attachment);
SPINE_C_API void spine_clipping_attachment_copy_to(spine_clipping_attachment self, spine_vertex_attachment other);
SPINE_C_API const char *spine_clipping_attachment_get_name(spine_clipping_attachment self);
SPINE_C_API int spine_clipping_attachment_get_ref_count(spine_clipping_attachment self);

2
spine-c/src/generated/color.cpp
View File

@ -50,7 +50,7 @@ spine_color spine_color_clamp(spine_color self) {
return (spine_color) &_self->clamp();
}
float spine_color_parse_hex(const char *value, size_t index) {
float spine_color_parse_hex(/*@null*/ const char *value, size_t index) {
return Color::parseHex(value, index);
}

2
spine-c/src/generated/color.h
View File

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

5
spine-c/src/generated/constraint_timeline1.cpp
View File

@ -82,8 +82,9 @@ spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timelin
return (spine_array_float) &_self->getCurves();
}
void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
CurveTimeline1 *_self = (CurveTimeline1 *) (ConstraintTimeline1 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);

4
spine-c/src/generated/constraint_timeline1.h
View File

@ -32,8 +32,8 @@ SPINE_C_API float spine_constraint_timeline1_get_bezier_value(spine_constraint_t
size_t i);
SPINE_C_API spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timeline1 self);
SPINE_C_API void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
SPINE_C_API size_t spine_constraint_timeline1_get_frame_entries(spine_constraint_timeline1 self);
SPINE_C_API size_t spine_constraint_timeline1_get_frame_count(spine_constraint_timeline1 self);
SPINE_C_API spine_array_float spine_constraint_timeline1_get_frames(spine_constraint_timeline1 self);

2
spine-c/src/generated/curve_timeline.cpp
View File

@ -38,7 +38,7 @@ spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self) {
return (spine_array_float) &_self->getCurves();
}
void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
Timeline *_self = (Timeline *) (CurveTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

5
spine-c/src/generated/curve_timeline.h
View File

@ -18,8 +18,9 @@ SPINE_C_API void spine_curve_timeline_set_bezier(spine_curve_timeline self, size
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_curve_timeline_get_bezier_value(spine_curve_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self);
SPINE_C_API void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline self);
SPINE_C_API size_t spine_curve_timeline_get_frame_count(spine_curve_timeline self);
SPINE_C_API spine_array_float spine_curve_timeline_get_frames(spine_curve_timeline self);

2
spine-c/src/generated/curve_timeline1.cpp
View File

@ -72,7 +72,7 @@ spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self) {
return (spine_array_float) &_self->getCurves();
}
void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
CurveTimeline *_self = (CurveTimeline *) (CurveTimeline1 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

2
spine-c/src/generated/curve_timeline1.h
View File

@ -29,7 +29,7 @@ SPINE_C_API void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, si
SPINE_C_API float spine_curve_timeline1_get_bezier_value(spine_curve_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self);
SPINE_C_API void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 self);
SPINE_C_API size_t spine_curve_timeline1_get_frame_count(spine_curve_timeline1 self);

5
spine-c/src/generated/deform_timeline.cpp
View File

@ -3,7 +3,8 @@
using namespace spine;
spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex, spine_vertex_attachment attachment) {
spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex,
/*@null*/ spine_vertex_attachment attachment) {
return (spine_deform_timeline) new (__FILE__, __LINE__) DeformTimeline(frameCount, bezierCount, slotIndex, (VertexAttachment *) attachment);
}
@ -47,7 +48,7 @@ size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self) {
return _self->getFrameCount();
}
void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
SlotCurveTimeline *_self = (SlotCurveTimeline *) (DeformTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

4
spine-c/src/generated/deform_timeline.h
View File

@ -10,7 +10,7 @@ extern "C" {
#endif
SPINE_C_API spine_deform_timeline spine_deform_timeline_create(size_t frameCount, size_t bezierCount, int slotIndex,
spine_vertex_attachment attachment);
/*@null*/ spine_vertex_attachment attachment);
SPINE_C_API void spine_deform_timeline_dispose(spine_deform_timeline self);
@ -23,7 +23,7 @@ SPINE_C_API void spine_deform_timeline_set_bezier(spine_deform_timeline self, si
SPINE_C_API float spine_deform_timeline_get_curve_percent(spine_deform_timeline self, float time, int frame);
SPINE_C_API size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self);
SPINE_C_API void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
/*@null*/ 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);

7
spine-c/src/generated/draw_order_timeline.cpp
View File

@ -16,8 +16,9 @@ spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline self) {
return (spine_rtti) &_self->getRTTI();
}
void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
@ -28,7 +29,7 @@ size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline self)
return _self->getFrameCount();
}
void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, spine_array_int drawOrder) {
void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, /*@null*/ spine_array_int drawOrder) {
DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
_self->setFrame(frame, time, (Array<int> *) drawOrder);
}

6
spine-c/src/generated/draw_order_timeline.h
View File

@ -15,10 +15,10 @@ SPINE_C_API void spine_draw_order_timeline_dispose(spine_draw_order_timeline sel
SPINE_C_API spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline self);
SPINE_C_API void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
SPINE_C_API size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline self);
SPINE_C_API void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, spine_array_int drawOrder);
SPINE_C_API void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, /*@null*/ spine_array_int drawOrder);
SPINE_C_API size_t spine_draw_order_timeline_get_frame_entries(spine_draw_order_timeline self);
SPINE_C_API spine_array_float spine_draw_order_timeline_get_frames(spine_draw_order_timeline self);
SPINE_C_API float spine_draw_order_timeline_get_duration(spine_draw_order_timeline self);

11
spine-c/src/generated/event_queue_entry.cpp
View File

@ -3,7 +3,8 @@
using namespace spine;
spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, spine_track_entry trackEntry, spine_event event) {
spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, /*@null*/ spine_track_entry trackEntry,
/*@null*/ spine_event event) {
return (spine_event_queue_entry) new (__FILE__, __LINE__) EventQueueEntry((EventType) eventType, (TrackEntry *) trackEntry, (Event *) event);
}
@ -21,22 +22,22 @@ void spine_event_queue_entry_set__type(spine_event_queue_entry self, spine_event
_self->_type = (EventType) value;
}
spine_track_entry spine_event_queue_entry_get__entry(spine_event_queue_entry self) {
/*@null*/ spine_track_entry spine_event_queue_entry_get__entry(spine_event_queue_entry self) {
EventQueueEntry *_self = (EventQueueEntry *) self;
return (spine_track_entry) _self->_entry;
}
void spine_event_queue_entry_set__entry(spine_event_queue_entry self, spine_track_entry value) {
void spine_event_queue_entry_set__entry(spine_event_queue_entry self, /*@null*/ spine_track_entry value) {
EventQueueEntry *_self = (EventQueueEntry *) self;
_self->_entry = (TrackEntry *) value;
}
spine_event spine_event_queue_entry_get__event(spine_event_queue_entry self) {
/*@null*/ spine_event spine_event_queue_entry_get__event(spine_event_queue_entry self) {
EventQueueEntry *_self = (EventQueueEntry *) self;
return (spine_event) _self->_event;
}
void spine_event_queue_entry_set__event(spine_event_queue_entry self, spine_event value) {
void spine_event_queue_entry_set__event(spine_event_queue_entry self, /*@null*/ spine_event value) {
EventQueueEntry *_self = (EventQueueEntry *) self;
_self->_event = (Event *) value;
}

11
spine-c/src/generated/event_queue_entry.h
View File

@ -9,16 +9,17 @@
extern "C" {
#endif
SPINE_C_API spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, spine_track_entry trackEntry, spine_event event);
SPINE_C_API spine_event_queue_entry spine_event_queue_entry_create(spine_event_type eventType, /*@null*/ spine_track_entry trackEntry,
/*@null*/ spine_event event);
SPINE_C_API void spine_event_queue_entry_dispose(spine_event_queue_entry self);
SPINE_C_API spine_event_type spine_event_queue_entry_get__type(spine_event_queue_entry self);
SPINE_C_API void spine_event_queue_entry_set__type(spine_event_queue_entry self, spine_event_type value);
SPINE_C_API spine_track_entry spine_event_queue_entry_get__entry(spine_event_queue_entry self);
SPINE_C_API void spine_event_queue_entry_set__entry(spine_event_queue_entry self, spine_track_entry value);
SPINE_C_API spine_event spine_event_queue_entry_get__event(spine_event_queue_entry self);
SPINE_C_API void spine_event_queue_entry_set__event(spine_event_queue_entry self, spine_event value);
SPINE_C_API /*@null*/ spine_track_entry spine_event_queue_entry_get__entry(spine_event_queue_entry self);
SPINE_C_API void spine_event_queue_entry_set__entry(spine_event_queue_entry self, /*@null*/ spine_track_entry value);
SPINE_C_API /*@null*/ spine_event spine_event_queue_entry_get__event(spine_event_queue_entry self);
SPINE_C_API void spine_event_queue_entry_set__event(spine_event_queue_entry self, /*@null*/ spine_event value);
#ifdef __cplusplus
}

4
spine-c/src/generated/event_timeline.cpp
View File

@ -16,7 +16,7 @@ spine_rtti spine_event_timeline_get_rtti(spine_event_timeline self) {
return (spine_rtti) &_self->getRTTI();
}
void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
EventTimeline *_self = (EventTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
@ -28,7 +28,7 @@ size_t spine_event_timeline_get_frame_count(spine_event_timeline self) {
return _self->getFrameCount();
}
spine_array_event spine_event_timeline_get_events(spine_event_timeline self) {
/*@null*/ spine_array_event spine_event_timeline_get_events(spine_event_timeline self) {
EventTimeline *_self = (EventTimeline *) self;
return (spine_array_event) &_self->getEvents();
}

7
spine-c/src/generated/event_timeline.h
View File

@ -14,10 +14,11 @@ SPINE_C_API spine_event_timeline spine_event_timeline_create(size_t frameCount);
SPINE_C_API void spine_event_timeline_dispose(spine_event_timeline self);
SPINE_C_API spine_rtti spine_event_timeline_get_rtti(spine_event_timeline self);
SPINE_C_API void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
SPINE_C_API size_t spine_event_timeline_get_frame_count(spine_event_timeline self);
SPINE_C_API spine_array_event spine_event_timeline_get_events(spine_event_timeline self);
SPINE_C_API /*@null*/ spine_array_event spine_event_timeline_get_events(spine_event_timeline self);
SPINE_C_API void spine_event_timeline_set_frame(spine_event_timeline self, size_t frame, spine_event event);
SPINE_C_API size_t spine_event_timeline_get_frame_entries(spine_event_timeline self);
SPINE_C_API spine_array_float spine_event_timeline_get_frames(spine_event_timeline self);

6
spine-c/src/generated/from_property.cpp
View File

@ -12,7 +12,7 @@ spine_rtti spine_from_property_get_rtti(spine_from_property self) {
return (spine_rtti) &_self->getRTTI();
}
float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
FromProperty *_self = (FromProperty *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}
@ -31,12 +31,12 @@ void spine_from_property_set__offset(spine_from_property self, float value) {
_self->_offset = value;
}
spine_array_to_property spine_from_property_get__to(spine_from_property self) {
/*@null*/ spine_array_to_property spine_from_property_get__to(spine_from_property self) {
FromProperty *_self = (FromProperty *) self;
return (spine_array_to_property) &_self->_to;
}
void spine_from_property_set__to(spine_from_property self, spine_array_to_property value) {
void spine_from_property_set__to(spine_from_property self, /*@null*/ spine_array_to_property value) {
FromProperty *_self = (FromProperty *) self;
_self->_to = *((Array<ToProperty *> *) value);
}

7
spine-c/src/generated/from_property.h
View File

@ -12,12 +12,13 @@ extern "C" {
SPINE_C_API void spine_from_property_dispose(spine_from_property self);
SPINE_C_API spine_rtti spine_from_property_get_rtti(spine_from_property self);
SPINE_C_API float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets);
SPINE_C_API float spine_from_property_value(spine_from_property self, spine_skeleton skeleton, spine_bone_pose source, bool local,
/*@null*/ float *offsets);
SPINE_C_API spine_rtti spine_from_property_rtti(void);
SPINE_C_API float spine_from_property_get__offset(spine_from_property self);
SPINE_C_API void spine_from_property_set__offset(spine_from_property self, float value);
SPINE_C_API spine_array_to_property spine_from_property_get__to(spine_from_property self);
SPINE_C_API void spine_from_property_set__to(spine_from_property self, spine_array_to_property value);
SPINE_C_API /*@null*/ spine_array_to_property spine_from_property_get__to(spine_from_property self);
SPINE_C_API void spine_from_property_set__to(spine_from_property self, /*@null*/ spine_array_to_property value);
#ifdef __cplusplus
}

2
spine-c/src/generated/from_rotate.cpp
View File

@ -16,7 +16,7 @@ spine_rtti spine_from_rotate_get_rtti(spine_from_rotate self) {
return (spine_rtti) &_self->getRTTI();
}
float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
float spine_from_rotate_value(spine_from_rotate self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
FromRotate *_self = (FromRotate *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}

3
spine-c/src/generated/from_rotate.h
View File

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

2
spine-c/src/generated/from_scale_x.cpp
View File

@ -16,7 +16,7 @@ spine_rtti spine_from_scale_x_get_rtti(spine_from_scale_x self) {
return (spine_rtti) &_self->getRTTI();
}
float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
float spine_from_scale_x_value(spine_from_scale_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
FromScaleX *_self = (FromScaleX *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}

3
spine-c/src/generated/from_scale_x.h
View File

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

2
spine-c/src/generated/from_scale_y.cpp
View File

@ -16,7 +16,7 @@ spine_rtti spine_from_scale_y_get_rtti(spine_from_scale_y self) {
return (spine_rtti) &_self->getRTTI();
}
float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
float spine_from_scale_y_value(spine_from_scale_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
FromScaleY *_self = (FromScaleY *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}

3
spine-c/src/generated/from_scale_y.h
View File

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

2
spine-c/src/generated/from_shear_y.cpp
View File

@ -16,7 +16,7 @@ spine_rtti spine_from_shear_y_get_rtti(spine_from_shear_y self) {
return (spine_rtti) &_self->getRTTI();
}
float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
float spine_from_shear_y_value(spine_from_shear_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
FromShearY *_self = (FromShearY *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}

3
spine-c/src/generated/from_shear_y.h
View File

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

2
spine-c/src/generated/from_x.cpp
View File

@ -16,7 +16,7 @@ spine_rtti spine_from_x_get_rtti(spine_from_x self) {
return (spine_rtti) &_self->getRTTI();
}
float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
float spine_from_x_value(spine_from_x self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
FromX *_self = (FromX *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}

2
spine-c/src/generated/from_x.h
View File

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

2
spine-c/src/generated/from_y.cpp
View File

@ -16,7 +16,7 @@ spine_rtti spine_from_y_get_rtti(spine_from_y self) {
return (spine_rtti) &_self->getRTTI();
}
float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, float *offsets) {
float spine_from_y_value(spine_from_y self, spine_skeleton skeleton, spine_bone_pose source, bool local, /*@null*/ float *offsets) {
FromY *_self = (FromY *) self;
return _self->value(*((Skeleton *) skeleton), *((BonePose *) source), local, offsets);
}

2
spine-c/src/generated/from_y.h
View File

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

2
spine-c/src/generated/ik_constraint.cpp
View File

@ -41,7 +41,7 @@ spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self)
return (spine_ik_constraint_data) &_self->getData();
}
spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self) {
/*@null*/ spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self) {
IkConstraint *_self = (IkConstraint *) self;
return (spine_array_bone_pose) &_self->getBones();
}

2
spine-c/src/generated/ik_constraint.h
View File

@ -19,7 +19,7 @@ SPINE_C_API void spine_ik_constraint_update(spine_ik_constraint self, spine_skel
SPINE_C_API void spine_ik_constraint_sort(spine_ik_constraint self, spine_skeleton skeleton);
SPINE_C_API bool spine_ik_constraint_is_source_active(spine_ik_constraint self);
SPINE_C_API spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self);
SPINE_C_API spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self);
SPINE_C_API /*@null*/ spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self);
SPINE_C_API spine_bone spine_ik_constraint_get_target(spine_ik_constraint self);
SPINE_C_API void spine_ik_constraint_set_target(spine_ik_constraint self, spine_bone inValue);
SPINE_C_API void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone_pose bone, float targetX, float targetY, bool compress, bool stretch,

2
spine-c/src/generated/ik_constraint_data.cpp
View File

@ -21,7 +21,7 @@ spine_constraint spine_ik_constraint_data_create_method(spine_ik_constraint_data
return (spine_constraint) &_self->create(*((Skeleton *) skeleton));
}
spine_array_bone_data spine_ik_constraint_data_get_bones(spine_ik_constraint_data self) {
/*@null*/ spine_array_bone_data spine_ik_constraint_data_get_bones(spine_ik_constraint_data self) {
IkConstraintData *_self = (IkConstraintData *) self;
return (spine_array_bone_data) &_self->getBones();
}

2
spine-c/src/generated/ik_constraint_data.h
View File

@ -15,7 +15,7 @@ SPINE_C_API void spine_ik_constraint_data_dispose(spine_ik_constraint_data self)
SPINE_C_API spine_rtti spine_ik_constraint_data_get_rtti(spine_ik_constraint_data self);
SPINE_C_API spine_constraint spine_ik_constraint_data_create_method(spine_ik_constraint_data self, spine_skeleton skeleton);
SPINE_C_API spine_array_bone_data spine_ik_constraint_data_get_bones(spine_ik_constraint_data self);
SPINE_C_API /*@null*/ spine_array_bone_data spine_ik_constraint_data_get_bones(spine_ik_constraint_data self);
SPINE_C_API spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data self);
SPINE_C_API void spine_ik_constraint_data_set_target(spine_ik_constraint_data self, spine_bone_data inValue);
SPINE_C_API bool spine_ik_constraint_data_get_uniform(spine_ik_constraint_data self);

2
spine-c/src/generated/ik_constraint_timeline.cpp
View File

@ -17,7 +17,7 @@ spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline se
}
void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

4
spine-c/src/generated/ik_constraint_timeline.h
View File

@ -15,8 +15,8 @@ SPINE_C_API void spine_ik_constraint_timeline_dispose(spine_ik_constraint_timeli
SPINE_C_API spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline self);
SPINE_C_API void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
SPINE_C_API void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness,
int bendDirection, bool compress, bool stretch);
SPINE_C_API int spine_ik_constraint_timeline_get_constraint_index(spine_ik_constraint_timeline self);

5
spine-c/src/generated/inherit_timeline.cpp
View File

@ -21,8 +21,9 @@ void spine_inherit_timeline_set_frame(spine_inherit_timeline self, int frame, fl
_self->setFrame(frame, time, (Inherit) inherit);
}
void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time, spine_array_event pEvents,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
InheritTimeline *_self = (InheritTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);

2
spine-c/src/generated/inherit_timeline.h
View File

@ -16,7 +16,7 @@ SPINE_C_API void spine_inherit_timeline_dispose(spine_inherit_timeline self);
SPINE_C_API spine_rtti spine_inherit_timeline_get_rtti(spine_inherit_timeline self);
SPINE_C_API void spine_inherit_timeline_set_frame(spine_inherit_timeline self, int frame, float time, spine_inherit inherit);
SPINE_C_API void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
/*@null*/ 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);

4
spine-c/src/generated/linked_mesh.cpp
View File

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

6
spine-c/src/generated/linked_mesh.h
View File

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

16
spine-c/src/generated/mesh_attachment.cpp
View File

@ -17,7 +17,7 @@ spine_rtti spine_mesh_attachment_get_rtti(spine_mesh_attachment self) {
}
void spine_mesh_attachment_compute_world_vertices_1(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count,
float *worldVertices, size_t offset, size_t stride) {
/*@null*/ float *worldVertices, size_t offset, size_t stride) {
MeshAttachment *_self = (MeshAttachment *) self;
_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
}
@ -83,7 +83,7 @@ void spine_mesh_attachment_set_path(spine_mesh_attachment self, const char *inVa
_self->setPath(String(inValue));
}
spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment self) {
/*@null*/ spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment self) {
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_texture_region) _self->getRegion();
}
@ -93,22 +93,22 @@ void spine_mesh_attachment_set_region(spine_mesh_attachment self, spine_texture_
_self->setRegion(*((TextureRegion *) region));
}
spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment self) {
/*@null*/ spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment self) {
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_sequence) _self->getSequence();
}
void spine_mesh_attachment_set_sequence(spine_mesh_attachment self, spine_sequence sequence) {
void spine_mesh_attachment_set_sequence(spine_mesh_attachment self, /*@null*/ spine_sequence sequence) {
MeshAttachment *_self = (MeshAttachment *) self;
_self->setSequence((Sequence *) sequence);
}
spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self) {
/*@null*/ spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self) {
MeshAttachment *_self = (MeshAttachment *) self;
return (spine_mesh_attachment) _self->getParentMesh();
}
void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, spine_mesh_attachment inValue) {
void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, /*@null*/ spine_mesh_attachment inValue) {
MeshAttachment *_self = (MeshAttachment *) self;
_self->setParentMesh((MeshAttachment *) inValue);
}
@ -188,12 +188,12 @@ void spine_mesh_attachment_set_world_vertices_length(spine_mesh_attachment self,
_self->setWorldVerticesLength(inValue);
}
spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self) {
/*@null*/ spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self) {
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
return (spine_attachment) _self->getTimelineAttachment();
}
void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, spine_attachment attachment) {
void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, /*@null*/ spine_attachment attachment) {
VertexAttachment *_self = (VertexAttachment *) (MeshAttachment *) self;
_self->setTimelineAttachment((Attachment *) attachment);
}

16
spine-c/src/generated/mesh_attachment.h
View File

@ -15,7 +15,7 @@ SPINE_C_API void spine_mesh_attachment_dispose(spine_mesh_attachment self);
SPINE_C_API spine_rtti spine_mesh_attachment_get_rtti(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_compute_world_vertices_1(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
size_t count, float *worldVertices, size_t offset, size_t stride);
size_t count, /*@null*/ float *worldVertices, size_t offset, size_t stride);
SPINE_C_API void spine_mesh_attachment_compute_world_vertices_2(spine_mesh_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
size_t count, spine_array_float worldVertices, size_t offset, size_t stride);
SPINE_C_API void spine_mesh_attachment_update_region(spine_mesh_attachment self);
@ -29,12 +29,12 @@ SPINE_C_API void spine_mesh_attachment_set_triangles(spine_mesh_attachment self,
SPINE_C_API spine_color spine_mesh_attachment_get_color(spine_mesh_attachment self);
SPINE_C_API const char *spine_mesh_attachment_get_path(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_path(spine_mesh_attachment self, const char *inValue);
SPINE_C_API spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment self);
SPINE_C_API /*@null*/ spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_region(spine_mesh_attachment self, spine_texture_region region);
SPINE_C_API spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_sequence(spine_mesh_attachment self, spine_sequence sequence);
SPINE_C_API spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, spine_mesh_attachment inValue);
SPINE_C_API /*@null*/ spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_sequence(spine_mesh_attachment self, /*@null*/ spine_sequence sequence);
SPINE_C_API /*@null*/ spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, /*@null*/ spine_mesh_attachment inValue);
SPINE_C_API spine_array_unsigned_short spine_mesh_attachment_get_edges(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_edges(spine_mesh_attachment self, spine_array_unsigned_short inValue);
SPINE_C_API float spine_mesh_attachment_get_width(spine_mesh_attachment self);
@ -50,8 +50,8 @@ SPINE_C_API spine_array_float spine_mesh_attachment_get_vertices(spine_mesh_atta
SPINE_C_API void spine_mesh_attachment_set_vertices(spine_mesh_attachment self, spine_array_float vertices);
SPINE_C_API size_t spine_mesh_attachment_get_world_vertices_length(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_world_vertices_length(spine_mesh_attachment self, size_t inValue);
SPINE_C_API spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, spine_attachment attachment);
SPINE_C_API /*@null*/ spine_attachment spine_mesh_attachment_get_timeline_attachment(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_timeline_attachment(spine_mesh_attachment self, /*@null*/ spine_attachment attachment);
SPINE_C_API void spine_mesh_attachment_copy_to(spine_mesh_attachment self, spine_vertex_attachment other);
SPINE_C_API const char *spine_mesh_attachment_get_name(spine_mesh_attachment self);
SPINE_C_API int spine_mesh_attachment_get_ref_count(spine_mesh_attachment self);

6
spine-c/src/generated/path_attachment.cpp
View File

@ -57,7 +57,7 @@ spine_attachment spine_path_attachment_copy(spine_path_attachment self) {
}
void spine_path_attachment_compute_world_vertices_1(spine_path_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start, size_t count,
float *worldVertices, size_t offset, size_t stride) {
/*@null*/ float *worldVertices, size_t offset, size_t stride) {
VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
_self->computeWorldVertices(*((Skeleton *) skeleton), *((Slot *) slot), start, count, worldVertices, offset, stride);
}
@ -103,12 +103,12 @@ void spine_path_attachment_set_world_vertices_length(spine_path_attachment self,
_self->setWorldVerticesLength(inValue);
}
spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment self) {
/*@null*/ spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment self) {
VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
return (spine_attachment) _self->getTimelineAttachment();
}
void spine_path_attachment_set_timeline_attachment(spine_path_attachment self, spine_attachment attachment) {
void spine_path_attachment_set_timeline_attachment(spine_path_attachment self, /*@null*/ spine_attachment attachment) {
VertexAttachment *_self = (VertexAttachment *) (PathAttachment *) self;
_self->setTimelineAttachment((Attachment *) attachment);
}

6
spine-c/src/generated/path_attachment.h
View File

@ -23,7 +23,7 @@ SPINE_C_API void spine_path_attachment_set_constant_speed(spine_path_attachment
SPINE_C_API spine_color spine_path_attachment_get_color(spine_path_attachment self);
SPINE_C_API spine_attachment spine_path_attachment_copy(spine_path_attachment self);
SPINE_C_API void spine_path_attachment_compute_world_vertices_1(spine_path_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
size_t count, float *worldVertices, size_t offset, size_t stride);
size_t count, /*@null*/ float *worldVertices, size_t offset, size_t stride);
SPINE_C_API void spine_path_attachment_compute_world_vertices_2(spine_path_attachment self, spine_skeleton skeleton, spine_slot slot, size_t start,
size_t count, spine_array_float worldVertices, size_t offset, size_t stride);
SPINE_C_API int spine_path_attachment_get_id(spine_path_attachment self);
@ -33,8 +33,8 @@ SPINE_C_API spine_array_float spine_path_attachment_get_vertices(spine_path_atta
SPINE_C_API void spine_path_attachment_set_vertices(spine_path_attachment self, spine_array_float vertices);
SPINE_C_API size_t spine_path_attachment_get_world_vertices_length(spine_path_attachment self);
SPINE_C_API void spine_path_attachment_set_world_vertices_length(spine_path_attachment self, size_t inValue);
SPINE_C_API spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment self);
SPINE_C_API void spine_path_attachment_set_timeline_attachment(spine_path_attachment self, spine_attachment attachment);
SPINE_C_API /*@null*/ spine_attachment spine_path_attachment_get_timeline_attachment(spine_path_attachment self);
SPINE_C_API void spine_path_attachment_set_timeline_attachment(spine_path_attachment self, /*@null*/ spine_attachment attachment);
SPINE_C_API void spine_path_attachment_copy_to(spine_path_attachment self, spine_vertex_attachment other);
SPINE_C_API const char *spine_path_attachment_get_name(spine_path_attachment self);
SPINE_C_API int spine_path_attachment_get_ref_count(spine_path_attachment self);

2
spine-c/src/generated/path_constraint.cpp
View File

@ -36,7 +36,7 @@ bool spine_path_constraint_is_source_active(spine_path_constraint self) {
return _self->isSourceActive();
}
spine_array_bone_pose spine_path_constraint_get_bones(spine_path_constraint self) {
/*@null*/ spine_array_bone_pose spine_path_constraint_get_bones(spine_path_constraint self) {
PathConstraint *_self = (PathConstraint *) self;
return (spine_array_bone_pose) &_self->getBones();
}

2
spine-c/src/generated/path_constraint.h
View File

@ -18,7 +18,7 @@ SPINE_C_API spine_path_constraint spine_path_constraint_copy(spine_path_constrai
SPINE_C_API void spine_path_constraint_update(spine_path_constraint self, spine_skeleton skeleton, spine_physics physics);
SPINE_C_API void spine_path_constraint_sort(spine_path_constraint self, spine_skeleton skeleton);
SPINE_C_API bool spine_path_constraint_is_source_active(spine_path_constraint self);
SPINE_C_API spine_array_bone_pose spine_path_constraint_get_bones(spine_path_constraint self);
SPINE_C_API /*@null*/ spine_array_bone_pose spine_path_constraint_get_bones(spine_path_constraint self);
SPINE_C_API spine_slot spine_path_constraint_get_slot(spine_path_constraint self);
SPINE_C_API void spine_path_constraint_set_slot(spine_path_constraint self, spine_slot slot);
SPINE_C_API spine_path_constraint_data spine_path_constraint_get_data(spine_path_constraint self);

2
spine-c/src/generated/path_constraint_data.cpp
View File

@ -21,7 +21,7 @@ spine_constraint spine_path_constraint_data_create_method(spine_path_constraint_
return (spine_constraint) &_self->create(*((Skeleton *) skeleton));
}
spine_array_bone_data spine_path_constraint_data_get_bones(spine_path_constraint_data self) {
/*@null*/ spine_array_bone_data spine_path_constraint_data_get_bones(spine_path_constraint_data self) {
PathConstraintData *_self = (PathConstraintData *) self;
return (spine_array_bone_data) &_self->getBones();
}

2
spine-c/src/generated/path_constraint_data.h
View File

@ -15,7 +15,7 @@ SPINE_C_API void spine_path_constraint_data_dispose(spine_path_constraint_data s
SPINE_C_API spine_rtti spine_path_constraint_data_get_rtti(spine_path_constraint_data self);
SPINE_C_API spine_constraint spine_path_constraint_data_create_method(spine_path_constraint_data self, spine_skeleton skeleton);
SPINE_C_API spine_array_bone_data spine_path_constraint_data_get_bones(spine_path_constraint_data self);
SPINE_C_API /*@null*/ spine_array_bone_data spine_path_constraint_data_get_bones(spine_path_constraint_data self);
SPINE_C_API spine_slot_data spine_path_constraint_data_get_slot(spine_path_constraint_data self);
SPINE_C_API void spine_path_constraint_data_set_slot(spine_path_constraint_data self, spine_slot_data slot);
SPINE_C_API spine_position_mode spine_path_constraint_data_get_position_mode(spine_path_constraint_data self);

2
spine-c/src/generated/path_constraint_mix_timeline.cpp
View File

@ -17,7 +17,7 @@ spine_rtti spine_path_constraint_mix_timeline_get_rtti(spine_path_constraint_mix
}
void spine_path_constraint_mix_timeline_apply(spine_path_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,
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

2
spine-c/src/generated/path_constraint_mix_timeline.h
View File

@ -15,7 +15,7 @@ SPINE_C_API void spine_path_constraint_mix_timeline_dispose(spine_path_constrain
SPINE_C_API spine_rtti spine_path_constraint_mix_timeline_get_rtti(spine_path_constraint_mix_timeline self);
SPINE_C_API void spine_path_constraint_mix_timeline_apply(spine_path_constraint_mix_timeline self, spine_skeleton skeleton, float lastTime,
float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
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);

4
spine-c/src/generated/path_constraint_position_timeline.cpp
View File

@ -18,8 +18,8 @@ spine_rtti spine_path_constraint_position_timeline_get_rtti(spine_path_constrain
}
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) {
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);

2
spine-c/src/generated/path_constraint_position_timeline.h
View File

@ -16,7 +16,7 @@ SPINE_C_API void spine_path_constraint_position_timeline_dispose(spine_path_cons
SPINE_C_API spine_rtti spine_path_constraint_position_timeline_get_rtti(spine_path_constraint_position_timeline self);
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,
float time, /*@null*/ 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);

4
spine-c/src/generated/path_constraint_spacing_timeline.cpp
View File

@ -17,8 +17,8 @@ spine_rtti spine_path_constraint_spacing_timeline_get_rtti(spine_path_constraint
}
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) {
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);

2
spine-c/src/generated/path_constraint_spacing_timeline.h
View File

@ -16,7 +16,7 @@ SPINE_C_API void spine_path_constraint_spacing_timeline_dispose(spine_path_const
SPINE_C_API spine_rtti spine_path_constraint_spacing_timeline_get_rtti(spine_path_constraint_spacing_timeline self);
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,
float time, /*@null*/ 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);

2
spine-c/src/generated/physics_constraint_damping_timeline.cpp
View File

@ -19,7 +19,7 @@ spine_rtti spine_physics_constraint_damping_timeline_get_rtti(spine_physics_cons
}
void spine_physics_constraint_damping_timeline_apply(spine_physics_constraint_damping_timeline self, spine_skeleton skeleton, float lastTime,
float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintDampingTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

2
spine-c/src/generated/physics_constraint_damping_timeline.h
View File

@ -16,7 +16,7 @@ SPINE_C_API void spine_physics_constraint_damping_timeline_dispose(spine_physics
SPINE_C_API spine_rtti spine_physics_constraint_damping_timeline_get_rtti(spine_physics_constraint_damping_timeline self);
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,
float lastTime, float time, /*@null*/ 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);

2
spine-c/src/generated/physics_constraint_gravity_timeline.cpp
View File

@ -19,7 +19,7 @@ spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(spine_physics_cons
}
void spine_physics_constraint_gravity_timeline_apply(spine_physics_constraint_gravity_timeline self, spine_skeleton skeleton, float lastTime,
float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintGravityTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

2
spine-c/src/generated/physics_constraint_gravity_timeline.h
View File

@ -16,7 +16,7 @@ SPINE_C_API void spine_physics_constraint_gravity_timeline_dispose(spine_physics
SPINE_C_API spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(spine_physics_constraint_gravity_timeline self);
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,
float lastTime, float time, /*@null*/ 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);

2
spine-c/src/generated/physics_constraint_inertia_timeline.cpp
View File

@ -19,7 +19,7 @@ spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(spine_physics_cons
}
void spine_physics_constraint_inertia_timeline_apply(spine_physics_constraint_inertia_timeline self, spine_skeleton skeleton, float lastTime,
float time, spine_array_event pEvents, float alpha, spine_mix_blend blend,
float time, /*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintInertiaTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,

2
spine-c/src/generated/physics_constraint_inertia_timeline.h
View File

@ -16,7 +16,7 @@ SPINE_C_API void spine_physics_constraint_inertia_timeline_dispose(spine_physics
SPINE_C_API spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(spine_physics_constraint_inertia_timeline self);
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,
float lastTime, float time, /*@null*/ 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);

4
spine-c/src/generated/physics_constraint_mass_timeline.cpp
View File

@ -19,8 +19,8 @@ spine_rtti spine_physics_constraint_mass_timeline_get_rtti(spine_physics_constra
}
void spine_physics_constraint_mass_timeline_apply(spine_physics_constraint_mass_timeline self, spine_skeleton skeleton, float lastTime, float time,
spine_array_event pEvents, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event pEvents, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) (PhysicsConstraintMassTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) pEvents, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);

2
spine-c/src/generated/physics_constraint_mass_timeline.h
View File

@ -16,7 +16,7 @@ SPINE_C_API void spine_physics_constraint_mass_timeline_dispose(spine_physics_co
SPINE_C_API spine_rtti spine_physics_constraint_mass_timeline_get_rtti(spine_physics_constraint_mass_timeline self);
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,
float time, /*@null*/ 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);

Some files were not shown because too many files have changed in this diff Show More