mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2025-12-21 17:56:04 +08:00
1217 lines
38 KiB
Dart
1217 lines
38 KiB
Dart
// ignore_for_file: always_specify_types
|
|
// ignore_for_file: camel_case_types
|
|
// ignore_for_file: non_constant_identifier_names
|
|
|
|
// AUTO GENERATED FILE, DO NOT EDIT.
|
|
//
|
|
// Generated by `package:ffigen`.
|
|
import 'dart:ffi' as ffi;
|
|
|
|
/// Bindings for `src/spine_flutter.h`.
|
|
///
|
|
/// Regenerate bindings with `dart run ffigen --config ffigen.yaml`.
|
|
///
|
|
class SpineFlutterBindings {
|
|
/// Holds the symbol lookup function.
|
|
final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
|
|
_lookup;
|
|
|
|
/// The symbols are looked up in [dynamicLibrary].
|
|
SpineFlutterBindings(ffi.DynamicLibrary dynamicLibrary)
|
|
: _lookup = dynamicLibrary.lookup;
|
|
|
|
/// The symbols are looked up with [lookup].
|
|
SpineFlutterBindings.fromLookup(
|
|
ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
|
|
lookup)
|
|
: _lookup = lookup;
|
|
|
|
int spine_major_version() {
|
|
return _spine_major_version();
|
|
}
|
|
|
|
late final _spine_major_versionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function()>>('spine_major_version');
|
|
late final _spine_major_version =
|
|
_spine_major_versionPtr.asFunction<int Function()>();
|
|
|
|
int spine_minor_version() {
|
|
return _spine_minor_version();
|
|
}
|
|
|
|
late final _spine_minor_versionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function()>>('spine_minor_version');
|
|
late final _spine_minor_version =
|
|
_spine_minor_versionPtr.asFunction<int Function()>();
|
|
|
|
void spine_report_leaks() {
|
|
return _spine_report_leaks();
|
|
}
|
|
|
|
late final _spine_report_leaksPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function()>>('spine_report_leaks');
|
|
late final _spine_report_leaks =
|
|
_spine_report_leaksPtr.asFunction<void Function()>();
|
|
|
|
ffi.Pointer<spine_atlas> spine_atlas_load(
|
|
ffi.Pointer<ffi.Int8> atlasData,
|
|
) {
|
|
return _spine_atlas_load(
|
|
atlasData,
|
|
);
|
|
}
|
|
|
|
late final _spine_atlas_loadPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_atlas> Function(
|
|
ffi.Pointer<ffi.Int8>)>>('spine_atlas_load');
|
|
late final _spine_atlas_load = _spine_atlas_loadPtr
|
|
.asFunction<ffi.Pointer<spine_atlas> Function(ffi.Pointer<ffi.Int8>)>();
|
|
|
|
void spine_atlas_dispose(
|
|
ffi.Pointer<spine_atlas> atlas,
|
|
) {
|
|
return _spine_atlas_dispose(
|
|
atlas,
|
|
);
|
|
}
|
|
|
|
late final _spine_atlas_disposePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<spine_atlas>)>>(
|
|
'spine_atlas_dispose');
|
|
late final _spine_atlas_dispose = _spine_atlas_disposePtr
|
|
.asFunction<void Function(ffi.Pointer<spine_atlas>)>();
|
|
|
|
ffi.Pointer<spine_skeleton_data> spine_skeleton_data_load_json(
|
|
ffi.Pointer<spine_atlas> atlas,
|
|
ffi.Pointer<ffi.Int8> skeletonData,
|
|
) {
|
|
return _spine_skeleton_data_load_json(
|
|
atlas,
|
|
skeletonData,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_data_load_jsonPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_skeleton_data> Function(ffi.Pointer<spine_atlas>,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_data_load_json');
|
|
late final _spine_skeleton_data_load_json =
|
|
_spine_skeleton_data_load_jsonPtr.asFunction<
|
|
ffi.Pointer<spine_skeleton_data> Function(
|
|
ffi.Pointer<spine_atlas>, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
ffi.Pointer<spine_skeleton_data> spine_skeleton_data_load_binary(
|
|
ffi.Pointer<spine_atlas> atlas,
|
|
ffi.Pointer<ffi.Uint8> skeletonData,
|
|
int length,
|
|
) {
|
|
return _spine_skeleton_data_load_binary(
|
|
atlas,
|
|
skeletonData,
|
|
length,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_data_load_binaryPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_skeleton_data> Function(
|
|
ffi.Pointer<spine_atlas>,
|
|
ffi.Pointer<ffi.Uint8>,
|
|
ffi.Int32)>>('spine_skeleton_data_load_binary');
|
|
late final _spine_skeleton_data_load_binary =
|
|
_spine_skeleton_data_load_binaryPtr.asFunction<
|
|
ffi.Pointer<spine_skeleton_data> Function(
|
|
ffi.Pointer<spine_atlas>, ffi.Pointer<ffi.Uint8>, int)>();
|
|
|
|
void spine_skeleton_data_dispose(
|
|
ffi.Pointer<spine_skeleton_data> skeletonData,
|
|
) {
|
|
return _spine_skeleton_data_dispose(
|
|
skeletonData,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_data_disposePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(ffi.Pointer<spine_skeleton_data>)>>(
|
|
'spine_skeleton_data_dispose');
|
|
late final _spine_skeleton_data_dispose = _spine_skeleton_data_disposePtr
|
|
.asFunction<void Function(ffi.Pointer<spine_skeleton_data>)>();
|
|
|
|
ffi.Pointer<spine_skeleton_drawable> spine_skeleton_drawable_create(
|
|
ffi.Pointer<spine_skeleton_data> skeletonData,
|
|
) {
|
|
return _spine_skeleton_drawable_create(
|
|
skeletonData,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_createPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_skeleton_drawable> Function(
|
|
ffi.Pointer<spine_skeleton_data>)>>(
|
|
'spine_skeleton_drawable_create');
|
|
late final _spine_skeleton_drawable_create =
|
|
_spine_skeleton_drawable_createPtr.asFunction<
|
|
ffi.Pointer<spine_skeleton_drawable> Function(
|
|
ffi.Pointer<spine_skeleton_data>)>();
|
|
|
|
void spine_skeleton_drawable_update(
|
|
ffi.Pointer<spine_skeleton_drawable> drawable,
|
|
double deltaTime,
|
|
) {
|
|
return _spine_skeleton_drawable_update(
|
|
drawable,
|
|
deltaTime,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_updatePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(ffi.Pointer<spine_skeleton_drawable>,
|
|
ffi.Float)>>('spine_skeleton_drawable_update');
|
|
late final _spine_skeleton_drawable_update =
|
|
_spine_skeleton_drawable_updatePtr.asFunction<
|
|
void Function(ffi.Pointer<spine_skeleton_drawable>, double)>();
|
|
|
|
ffi.Pointer<spine_render_command> spine_skeleton_drawable_render(
|
|
ffi.Pointer<spine_skeleton_drawable> drawable,
|
|
) {
|
|
return _spine_skeleton_drawable_render(
|
|
drawable,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_renderPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_render_command> Function(
|
|
ffi.Pointer<spine_skeleton_drawable>)>>(
|
|
'spine_skeleton_drawable_render');
|
|
late final _spine_skeleton_drawable_render =
|
|
_spine_skeleton_drawable_renderPtr.asFunction<
|
|
ffi.Pointer<spine_render_command> Function(
|
|
ffi.Pointer<spine_skeleton_drawable>)>();
|
|
|
|
void spine_skeleton_drawable_dispose(
|
|
ffi.Pointer<spine_skeleton_drawable> drawable,
|
|
) {
|
|
return _spine_skeleton_drawable_dispose(
|
|
drawable,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_disposePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(ffi.Pointer<spine_skeleton_drawable>)>>(
|
|
'spine_skeleton_drawable_dispose');
|
|
late final _spine_skeleton_drawable_dispose =
|
|
_spine_skeleton_drawable_disposePtr
|
|
.asFunction<void Function(ffi.Pointer<spine_skeleton_drawable>)>();
|
|
|
|
void spine_animation_state_update(
|
|
spine_animation_state state,
|
|
double delta,
|
|
) {
|
|
return _spine_animation_state_update(
|
|
state,
|
|
delta,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_updatePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_animation_state,
|
|
ffi.Float)>>('spine_animation_state_update');
|
|
late final _spine_animation_state_update = _spine_animation_state_updatePtr
|
|
.asFunction<void Function(spine_animation_state, double)>();
|
|
|
|
void spine_animation_state_apply(
|
|
spine_animation_state state,
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_animation_state_apply(
|
|
state,
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_applyPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_animation_state,
|
|
spine_skeleton)>>('spine_animation_state_apply');
|
|
late final _spine_animation_state_apply = _spine_animation_state_applyPtr
|
|
.asFunction<void Function(spine_animation_state, spine_skeleton)>();
|
|
|
|
void spine_animation_state_clear_tracks(
|
|
spine_animation_state state,
|
|
) {
|
|
return _spine_animation_state_clear_tracks(
|
|
state,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_clear_tracksPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state)>>(
|
|
'spine_animation_state_clear_tracks');
|
|
late final _spine_animation_state_clear_tracks =
|
|
_spine_animation_state_clear_tracksPtr
|
|
.asFunction<void Function(spine_animation_state)>();
|
|
|
|
void spine_animation_state_clear_track(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
) {
|
|
return _spine_animation_state_clear_track(
|
|
state,
|
|
trackIndex,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_clear_trackPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_animation_state,
|
|
ffi.Int32)>>('spine_animation_state_clear_track');
|
|
late final _spine_animation_state_clear_track =
|
|
_spine_animation_state_clear_trackPtr
|
|
.asFunction<void Function(spine_animation_state, int)>();
|
|
|
|
spine_track_entry spine_animation_state_set_animation(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
ffi.Pointer<ffi.Int8> animationName,
|
|
int loop,
|
|
) {
|
|
return _spine_animation_state_set_animation(
|
|
state,
|
|
trackIndex,
|
|
animationName,
|
|
loop,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_set_animationPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(
|
|
spine_animation_state,
|
|
ffi.Int32,
|
|
ffi.Pointer<ffi.Int8>,
|
|
ffi.Int32)>>('spine_animation_state_set_animation');
|
|
late final _spine_animation_state_set_animation =
|
|
_spine_animation_state_set_animationPtr.asFunction<
|
|
spine_track_entry Function(
|
|
spine_animation_state, int, ffi.Pointer<ffi.Int8>, int)>();
|
|
|
|
spine_track_entry spine_animation_state_add_animation(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
ffi.Pointer<ffi.Int8> animationName,
|
|
int loop,
|
|
double delay,
|
|
) {
|
|
return _spine_animation_state_add_animation(
|
|
state,
|
|
trackIndex,
|
|
animationName,
|
|
loop,
|
|
delay,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_add_animationPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(
|
|
spine_animation_state,
|
|
ffi.Int32,
|
|
ffi.Pointer<ffi.Int8>,
|
|
ffi.Int32,
|
|
ffi.Float)>>('spine_animation_state_add_animation');
|
|
late final _spine_animation_state_add_animation =
|
|
_spine_animation_state_add_animationPtr.asFunction<
|
|
spine_track_entry Function(spine_animation_state, int,
|
|
ffi.Pointer<ffi.Int8>, int, double)>();
|
|
|
|
spine_track_entry spine_animation_state_set_empty_animation(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
double mixDuration,
|
|
) {
|
|
return _spine_animation_state_set_empty_animation(
|
|
state,
|
|
trackIndex,
|
|
mixDuration,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_set_empty_animationPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(spine_animation_state, ffi.Int32,
|
|
ffi.Float)>>('spine_animation_state_set_empty_animation');
|
|
late final _spine_animation_state_set_empty_animation =
|
|
_spine_animation_state_set_empty_animationPtr.asFunction<
|
|
spine_track_entry Function(spine_animation_state, int, double)>();
|
|
|
|
spine_track_entry spine_animation_state_add_empty_animation(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
double mixDuration,
|
|
double delay,
|
|
) {
|
|
return _spine_animation_state_add_empty_animation(
|
|
state,
|
|
trackIndex,
|
|
mixDuration,
|
|
delay,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_add_empty_animationPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(
|
|
spine_animation_state,
|
|
ffi.Int32,
|
|
ffi.Float,
|
|
ffi.Float)>>('spine_animation_state_add_empty_animation');
|
|
late final _spine_animation_state_add_empty_animation =
|
|
_spine_animation_state_add_empty_animationPtr.asFunction<
|
|
spine_track_entry Function(
|
|
spine_animation_state, int, double, double)>();
|
|
|
|
void spine_animation_state_set_empty_animations(
|
|
spine_animation_state state,
|
|
double mixDuration,
|
|
) {
|
|
return _spine_animation_state_set_empty_animations(
|
|
state,
|
|
mixDuration,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_set_empty_animationsPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_animation_state,
|
|
ffi.Float)>>('spine_animation_state_set_empty_animations');
|
|
late final _spine_animation_state_set_empty_animations =
|
|
_spine_animation_state_set_empty_animationsPtr
|
|
.asFunction<void Function(spine_animation_state, double)>();
|
|
|
|
double spine_animation_state_get_time_scale(
|
|
spine_animation_state state,
|
|
) {
|
|
return _spine_animation_state_get_time_scale(
|
|
state,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_get_time_scalePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_animation_state)>>(
|
|
'spine_animation_state_get_time_scale');
|
|
late final _spine_animation_state_get_time_scale =
|
|
_spine_animation_state_get_time_scalePtr
|
|
.asFunction<double Function(spine_animation_state)>();
|
|
|
|
void spine_animation_state_set_time_scale(
|
|
spine_animation_state state,
|
|
double timeScale,
|
|
) {
|
|
return _spine_animation_state_set_time_scale(
|
|
state,
|
|
timeScale,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_set_time_scalePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_animation_state,
|
|
ffi.Float)>>('spine_animation_state_set_time_scale');
|
|
late final _spine_animation_state_set_time_scale =
|
|
_spine_animation_state_set_time_scalePtr
|
|
.asFunction<void Function(spine_animation_state, double)>();
|
|
|
|
int spine_track_entry_get_track_index(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_index(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_indexPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_track_index');
|
|
late final _spine_track_entry_get_track_index =
|
|
_spine_track_entry_get_track_indexPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
spine_animation spine_track_entry_get_animation(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animationPtr =
|
|
_lookup<ffi.NativeFunction<spine_animation Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_animation');
|
|
late final _spine_track_entry_get_animation =
|
|
_spine_track_entry_get_animationPtr
|
|
.asFunction<spine_animation Function(spine_track_entry)>();
|
|
|
|
spine_track_entry spine_track_entry_get_previous(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_previous(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_previousPtr = _lookup<
|
|
ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_previous');
|
|
late final _spine_track_entry_get_previous =
|
|
_spine_track_entry_get_previousPtr
|
|
.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
int spine_track_entry_get_loop(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_loop(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_loopPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_loop');
|
|
late final _spine_track_entry_get_loop = _spine_track_entry_get_loopPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_loop(
|
|
spine_track_entry entry,
|
|
int loop,
|
|
) {
|
|
return _spine_track_entry_set_loop(
|
|
entry,
|
|
loop,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_loopPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
|
|
'spine_track_entry_set_loop');
|
|
late final _spine_track_entry_set_loop = _spine_track_entry_set_loopPtr
|
|
.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
int spine_track_entry_get_hold_previous(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_hold_previous(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_hold_previousPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_hold_previous');
|
|
late final _spine_track_entry_get_hold_previous =
|
|
_spine_track_entry_get_hold_previousPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_hold_previous(
|
|
spine_track_entry entry,
|
|
int holdPrevious,
|
|
) {
|
|
return _spine_track_entry_set_hold_previous(
|
|
entry,
|
|
holdPrevious,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_hold_previousPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
|
|
'spine_track_entry_set_hold_previous');
|
|
late final _spine_track_entry_set_hold_previous =
|
|
_spine_track_entry_set_hold_previousPtr
|
|
.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
int spine_track_entry_get_reverse(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_reverse(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_reversePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_reverse');
|
|
late final _spine_track_entry_get_reverse = _spine_track_entry_get_reversePtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_reverse(
|
|
spine_track_entry entry,
|
|
int reverse,
|
|
) {
|
|
return _spine_track_entry_set_reverse(
|
|
entry,
|
|
reverse,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_reversePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
|
|
'spine_track_entry_set_reverse');
|
|
late final _spine_track_entry_set_reverse = _spine_track_entry_set_reversePtr
|
|
.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
int spine_track_entry_get_shortest_rotation(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_shortest_rotation(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_shortest_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_shortest_rotation');
|
|
late final _spine_track_entry_get_shortest_rotation =
|
|
_spine_track_entry_get_shortest_rotationPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_shortest_rotation(
|
|
spine_track_entry entry,
|
|
int shortestRotation,
|
|
) {
|
|
return _spine_track_entry_set_shortest_rotation(
|
|
entry,
|
|
shortestRotation,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_shortest_rotationPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
|
|
'spine_track_entry_set_shortest_rotation');
|
|
late final _spine_track_entry_set_shortest_rotation =
|
|
_spine_track_entry_set_shortest_rotationPtr
|
|
.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
double spine_track_entry_get_delay(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_delay(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_delayPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_delay');
|
|
late final _spine_track_entry_get_delay = _spine_track_entry_get_delayPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_delay(
|
|
spine_track_entry entry,
|
|
double delay,
|
|
) {
|
|
return _spine_track_entry_set_delay(
|
|
entry,
|
|
delay,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_delayPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_delay');
|
|
late final _spine_track_entry_set_delay = _spine_track_entry_set_delayPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_track_time(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_time(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_track_time');
|
|
late final _spine_track_entry_get_track_time =
|
|
_spine_track_entry_get_track_timePtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_track_time(
|
|
spine_track_entry entry,
|
|
double trackTime,
|
|
) {
|
|
return _spine_track_entry_set_track_time(
|
|
entry,
|
|
trackTime,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_track_timePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_track_time');
|
|
late final _spine_track_entry_set_track_time =
|
|
_spine_track_entry_set_track_timePtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_track_end(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_end(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_endPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_track_end');
|
|
late final _spine_track_entry_get_track_end =
|
|
_spine_track_entry_get_track_endPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_track_end(
|
|
spine_track_entry entry,
|
|
double trackEnd,
|
|
) {
|
|
return _spine_track_entry_set_track_end(
|
|
entry,
|
|
trackEnd,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_track_endPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_track_end');
|
|
late final _spine_track_entry_set_track_end =
|
|
_spine_track_entry_set_track_endPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_start(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_start(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_startPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_animation_start');
|
|
late final _spine_track_entry_get_animation_start =
|
|
_spine_track_entry_get_animation_startPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_animation_start(
|
|
spine_track_entry entry,
|
|
double animationStart,
|
|
) {
|
|
return _spine_track_entry_set_animation_start(
|
|
entry,
|
|
animationStart,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_animation_startPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_animation_start');
|
|
late final _spine_track_entry_set_animation_start =
|
|
_spine_track_entry_set_animation_startPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_end(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_end(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_endPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_animation_end');
|
|
late final _spine_track_entry_get_animation_end =
|
|
_spine_track_entry_get_animation_endPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_animation_end(
|
|
spine_track_entry entry,
|
|
double animationEnd,
|
|
) {
|
|
return _spine_track_entry_set_animation_end(
|
|
entry,
|
|
animationEnd,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_animation_endPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_animation_end');
|
|
late final _spine_track_entry_set_animation_end =
|
|
_spine_track_entry_set_animation_endPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_last(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_last(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_lastPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_animation_last');
|
|
late final _spine_track_entry_get_animation_last =
|
|
_spine_track_entry_get_animation_lastPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_animation_last(
|
|
spine_track_entry entry,
|
|
double animationLast,
|
|
) {
|
|
return _spine_track_entry_set_animation_last(
|
|
entry,
|
|
animationLast,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_animation_lastPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_animation_last');
|
|
late final _spine_track_entry_set_animation_last =
|
|
_spine_track_entry_set_animation_lastPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_time(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_time(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_animation_time');
|
|
late final _spine_track_entry_get_animation_time =
|
|
_spine_track_entry_get_animation_timePtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
double spine_track_entry_get_time_scale(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_time_scale(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_time_scalePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_time_scale');
|
|
late final _spine_track_entry_get_time_scale =
|
|
_spine_track_entry_get_time_scalePtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_time_scale(
|
|
spine_track_entry entry,
|
|
double timeScale,
|
|
) {
|
|
return _spine_track_entry_set_time_scale(
|
|
entry,
|
|
timeScale,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_time_scalePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_time_scale');
|
|
late final _spine_track_entry_set_time_scale =
|
|
_spine_track_entry_set_time_scalePtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_alpha(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_alpha(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_alphaPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_alpha');
|
|
late final _spine_track_entry_get_alpha = _spine_track_entry_get_alphaPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_alpha(
|
|
spine_track_entry entry,
|
|
double alpha,
|
|
) {
|
|
return _spine_track_entry_set_alpha(
|
|
entry,
|
|
alpha,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_alphaPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_alpha');
|
|
late final _spine_track_entry_set_alpha = _spine_track_entry_set_alphaPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_event_threshold(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_event_threshold(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_event_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_event_threshold');
|
|
late final _spine_track_entry_get_event_threshold =
|
|
_spine_track_entry_get_event_thresholdPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_event_threshold(
|
|
spine_track_entry entry,
|
|
double eventThreshold,
|
|
) {
|
|
return _spine_track_entry_set_event_threshold(
|
|
entry,
|
|
eventThreshold,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_event_thresholdPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_event_threshold');
|
|
late final _spine_track_entry_set_event_threshold =
|
|
_spine_track_entry_set_event_thresholdPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_attachment_threshold(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_attachment_threshold(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_attachment_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_attachment_threshold');
|
|
late final _spine_track_entry_get_attachment_threshold =
|
|
_spine_track_entry_get_attachment_thresholdPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_attachment_threshold(
|
|
spine_track_entry entry,
|
|
double attachmentThreshold,
|
|
) {
|
|
return _spine_track_entry_set_attachment_threshold(
|
|
entry,
|
|
attachmentThreshold,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_attachment_thresholdPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_attachment_threshold');
|
|
late final _spine_track_entry_set_attachment_threshold =
|
|
_spine_track_entry_set_attachment_thresholdPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_draw_order_threshold(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_draw_order_threshold(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_draw_order_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_draw_order_threshold');
|
|
late final _spine_track_entry_get_draw_order_threshold =
|
|
_spine_track_entry_get_draw_order_thresholdPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_draw_order_threshold(
|
|
spine_track_entry entry,
|
|
double drawOrderThreshold,
|
|
) {
|
|
return _spine_track_entry_set_draw_order_threshold(
|
|
entry,
|
|
drawOrderThreshold,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_draw_order_thresholdPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_draw_order_threshold');
|
|
late final _spine_track_entry_set_draw_order_threshold =
|
|
_spine_track_entry_set_draw_order_thresholdPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
spine_track_entry spine_track_entry_get_next(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_next(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_nextPtr = _lookup<
|
|
ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_next');
|
|
late final _spine_track_entry_get_next = _spine_track_entry_get_nextPtr
|
|
.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
int spine_track_entry_is_complete(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_is_complete(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_is_completePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_is_complete');
|
|
late final _spine_track_entry_is_complete = _spine_track_entry_is_completePtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
double spine_track_entry_get_mix_time(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mix_time(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mix_time');
|
|
late final _spine_track_entry_get_mix_time =
|
|
_spine_track_entry_get_mix_timePtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_time(
|
|
spine_track_entry entry,
|
|
double mixTime,
|
|
) {
|
|
return _spine_track_entry_set_mix_time(
|
|
entry,
|
|
mixTime,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_timePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_mix_time');
|
|
late final _spine_track_entry_set_mix_time =
|
|
_spine_track_entry_set_mix_timePtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_mix_duration(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mix_duration(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_durationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mix_duration');
|
|
late final _spine_track_entry_get_mix_duration =
|
|
_spine_track_entry_get_mix_durationPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_duration(
|
|
spine_track_entry entry,
|
|
double mixDuration,
|
|
) {
|
|
return _spine_track_entry_set_mix_duration(
|
|
entry,
|
|
mixDuration,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_durationPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_mix_duration');
|
|
late final _spine_track_entry_set_mix_duration =
|
|
_spine_track_entry_set_mix_durationPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
int spine_track_entry_get_mix_blend(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mix_blend(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_blendPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mix_blend');
|
|
late final _spine_track_entry_get_mix_blend =
|
|
_spine_track_entry_get_mix_blendPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_blend(
|
|
spine_track_entry entry,
|
|
int mixBlend,
|
|
) {
|
|
return _spine_track_entry_set_mix_blend(
|
|
entry,
|
|
mixBlend,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_blendPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
|
|
'spine_track_entry_set_mix_blend');
|
|
late final _spine_track_entry_set_mix_blend =
|
|
_spine_track_entry_set_mix_blendPtr
|
|
.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
spine_track_entry spine_track_entry_get_mixing_from(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mixing_from(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mixing_fromPtr = _lookup<
|
|
ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mixing_from');
|
|
late final _spine_track_entry_get_mixing_from =
|
|
_spine_track_entry_get_mixing_fromPtr
|
|
.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
spine_track_entry spine_track_entry_get_mixing_to(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mixing_to(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mixing_toPtr = _lookup<
|
|
ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mixing_to');
|
|
late final _spine_track_entry_get_mixing_to =
|
|
_spine_track_entry_get_mixing_toPtr
|
|
.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_reset_rotation_directions(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_reset_rotation_directions(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_reset_rotation_directionsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry)>>(
|
|
'spine_track_entry_reset_rotation_directions');
|
|
late final _spine_track_entry_reset_rotation_directions =
|
|
_spine_track_entry_reset_rotation_directionsPtr
|
|
.asFunction<void Function(spine_track_entry)>();
|
|
|
|
double spine_track_entry_get_track_complete(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_complete(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_completePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_track_complete');
|
|
late final _spine_track_entry_get_track_complete =
|
|
_spine_track_entry_get_track_completePtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
}
|
|
|
|
class spine_atlas extends ffi.Struct {
|
|
external ffi.Pointer<ffi.Void> atlas;
|
|
|
|
external ffi.Pointer<ffi.Pointer<ffi.Int8>> imagePaths;
|
|
|
|
@ffi.Int32()
|
|
external int numImagePaths;
|
|
|
|
external ffi.Pointer<ffi.Int8> error;
|
|
}
|
|
|
|
class spine_skeleton_data extends ffi.Struct {
|
|
external ffi.Pointer<ffi.Void> skeletonData;
|
|
|
|
external ffi.Pointer<ffi.Int8> error;
|
|
}
|
|
|
|
abstract class spine_blend_mode {
|
|
static const int SPINE_BLEND_MODE_NORMAL = 0;
|
|
static const int SPINE_BLEND_MODE_ADDITIVE = 1;
|
|
static const int SPINE_BLEND_MODE_MULTIPLY = 2;
|
|
static const int SPINE_BLEND_MODE_SCREEN = 3;
|
|
}
|
|
|
|
abstract class spine_mix_blend {
|
|
static const int SPINE_MIX_BLEND_SETUP = 0;
|
|
static const int SPINE_MIX_BLEND_FIRST = 1;
|
|
static const int SPINE_MIX_BLEND_REPLACE = 2;
|
|
static const int SPINE_MIX_BLEND_ADD = 3;
|
|
}
|
|
|
|
class spine_render_command extends ffi.Struct {
|
|
external ffi.Pointer<ffi.Float> positions;
|
|
|
|
external ffi.Pointer<ffi.Float> uvs;
|
|
|
|
external ffi.Pointer<ffi.Int32> colors;
|
|
|
|
@ffi.Int32()
|
|
external int numVertices;
|
|
|
|
external ffi.Pointer<ffi.Uint16> indices;
|
|
|
|
@ffi.Int32()
|
|
external int numIndices;
|
|
|
|
@ffi.Int32()
|
|
external int atlasPage;
|
|
|
|
@ffi.Int32()
|
|
external int blendMode;
|
|
|
|
external ffi.Pointer<spine_render_command> next;
|
|
}
|
|
|
|
class spine_skeleton_drawable extends ffi.Struct {
|
|
external spine_skeleton skeleton;
|
|
|
|
external spine_animation_state animationState;
|
|
|
|
external ffi.Pointer<ffi.Void> clipping;
|
|
|
|
external ffi.Pointer<spine_render_command> renderCommand;
|
|
}
|
|
|
|
typedef spine_skeleton = ffi.Pointer<ffi.Void>;
|
|
typedef spine_animation_state = ffi.Pointer<ffi.Void>;
|
|
typedef spine_track_entry = ffi.Pointer<ffi.Void>;
|
|
typedef spine_animation = ffi.Pointer<ffi.Void>;
|