mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2025-12-21 09:46:02 +08:00
2022 lines
63 KiB
Dart
2022 lines
63 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>)>();
|
|
|
|
spine_skeleton_data_result 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<
|
|
spine_skeleton_data_result 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<
|
|
spine_skeleton_data_result Function(
|
|
ffi.Pointer<spine_atlas>, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_skeleton_data_result 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<
|
|
spine_skeleton_data_result 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<
|
|
spine_skeleton_data_result Function(
|
|
ffi.Pointer<spine_atlas>, ffi.Pointer<ffi.Uint8>, int)>();
|
|
|
|
void spine_skeleton_data_dispose(
|
|
spine_skeleton_data skeletonData,
|
|
) {
|
|
return _spine_skeleton_data_dispose(
|
|
skeletonData,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_data_disposePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_dispose');
|
|
late final _spine_skeleton_data_dispose = _spine_skeleton_data_disposePtr
|
|
.asFunction<void Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_skeleton_drawable> spine_skeleton_drawable_create(
|
|
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(
|
|
spine_skeleton_data)>>('spine_skeleton_drawable_create');
|
|
late final _spine_skeleton_drawable_create =
|
|
_spine_skeleton_drawable_createPtr.asFunction<
|
|
ffi.Pointer<spine_skeleton_drawable> Function(spine_skeleton_data)>();
|
|
|
|
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_animation_state_events_get_num_events(
|
|
spine_animation_state_events events,
|
|
) {
|
|
return _spine_animation_state_events_get_num_events(
|
|
events,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_events_get_num_eventsPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Int32 Function(spine_animation_state_events)>>(
|
|
'spine_animation_state_events_get_num_events');
|
|
late final _spine_animation_state_events_get_num_events =
|
|
_spine_animation_state_events_get_num_eventsPtr
|
|
.asFunction<int Function(spine_animation_state_events)>();
|
|
|
|
int spine_animation_state_events_get_event_type(
|
|
spine_animation_state_events events,
|
|
int index,
|
|
) {
|
|
return _spine_animation_state_events_get_event_type(
|
|
events,
|
|
index,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_events_get_event_typePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Int32 Function(spine_animation_state_events,
|
|
ffi.Int32)>>('spine_animation_state_events_get_event_type');
|
|
late final _spine_animation_state_events_get_event_type =
|
|
_spine_animation_state_events_get_event_typePtr
|
|
.asFunction<int Function(spine_animation_state_events, int)>();
|
|
|
|
spine_track_entry spine_animation_state_events_get_track_entry(
|
|
spine_animation_state_events events,
|
|
int index,
|
|
) {
|
|
return _spine_animation_state_events_get_track_entry(
|
|
events,
|
|
index,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_events_get_track_entryPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(spine_animation_state_events,
|
|
ffi.Int32)>>('spine_animation_state_events_get_track_entry');
|
|
late final _spine_animation_state_events_get_track_entry =
|
|
_spine_animation_state_events_get_track_entryPtr.asFunction<
|
|
spine_track_entry Function(spine_animation_state_events, int)>();
|
|
|
|
spine_event spine_animation_state_events_get_event(
|
|
spine_animation_state_events events,
|
|
int index,
|
|
) {
|
|
return _spine_animation_state_events_get_event(
|
|
events,
|
|
index,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_events_get_eventPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_event Function(spine_animation_state_events,
|
|
ffi.Int32)>>('spine_animation_state_events_get_event');
|
|
late final _spine_animation_state_events_get_event =
|
|
_spine_animation_state_events_get_eventPtr.asFunction<
|
|
spine_event Function(spine_animation_state_events, int)>();
|
|
|
|
void spine_animation_state_events_reset(
|
|
spine_animation_state_events events,
|
|
) {
|
|
return _spine_animation_state_events_reset(
|
|
events,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_events_resetPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_animation_state_events)>>(
|
|
'spine_animation_state_events_reset');
|
|
late final _spine_animation_state_events_reset =
|
|
_spine_animation_state_events_resetPtr
|
|
.asFunction<void Function(spine_animation_state_events)>();
|
|
|
|
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)>();
|
|
|
|
void spine_skeleton_update_cache(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_update_cache(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_update_cachePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
|
|
'spine_skeleton_update_cache');
|
|
late final _spine_skeleton_update_cache = _spine_skeleton_update_cachePtr
|
|
.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_update_world_transform(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_update_world_transform(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_update_world_transformPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
|
|
'spine_skeleton_update_world_transform');
|
|
late final _spine_skeleton_update_world_transform =
|
|
_spine_skeleton_update_world_transformPtr
|
|
.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_update_world_transform_bone(
|
|
spine_skeleton skeleton,
|
|
spine_bone parent,
|
|
) {
|
|
return _spine_skeleton_update_world_transform_bone(
|
|
skeleton,
|
|
parent,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_update_world_transform_bonePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_bone)>>(
|
|
'spine_skeleton_update_world_transform_bone');
|
|
late final _spine_skeleton_update_world_transform_bone =
|
|
_spine_skeleton_update_world_transform_bonePtr
|
|
.asFunction<void Function(spine_skeleton, spine_bone)>();
|
|
|
|
void spine_skeleton_set_to_setup_pose(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_set_to_setup_pose(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_to_setup_posePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
|
|
'spine_skeleton_set_to_setup_pose');
|
|
late final _spine_skeleton_set_to_setup_pose =
|
|
_spine_skeleton_set_to_setup_posePtr
|
|
.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_bones_to_setup_pose(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_set_bones_to_setup_pose(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_bones_to_setup_posePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
|
|
'spine_skeleton_set_bones_to_setup_pose');
|
|
late final _spine_skeleton_set_bones_to_setup_pose =
|
|
_spine_skeleton_set_bones_to_setup_posePtr
|
|
.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_slots_to_setup_pose(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_set_slots_to_setup_pose(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_slots_to_setup_posePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
|
|
'spine_skeleton_set_slots_to_setup_pose');
|
|
late final _spine_skeleton_set_slots_to_setup_pose =
|
|
_spine_skeleton_set_slots_to_setup_posePtr
|
|
.asFunction<void Function(spine_skeleton)>();
|
|
|
|
spine_bone spine_skeleton_find_bone(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> boneName,
|
|
) {
|
|
return _spine_skeleton_find_bone(
|
|
skeleton,
|
|
boneName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_find_bonePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_bone Function(spine_skeleton,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_find_bone');
|
|
late final _spine_skeleton_find_bone = _spine_skeleton_find_bonePtr
|
|
.asFunction<spine_bone Function(spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_slot spine_skeleton_find_slot(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> slotName,
|
|
) {
|
|
return _spine_skeleton_find_slot(
|
|
skeleton,
|
|
slotName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_find_slotPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_slot Function(spine_skeleton,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_find_slot');
|
|
late final _spine_skeleton_find_slot = _spine_skeleton_find_slotPtr
|
|
.asFunction<spine_slot Function(spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
void spine_skeleton_set_skin_by_name(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> skinName,
|
|
) {
|
|
return _spine_skeleton_set_skin_by_name(
|
|
skeleton,
|
|
skinName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_skin_by_namePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_skeleton,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_set_skin_by_name');
|
|
late final _spine_skeleton_set_skin_by_name =
|
|
_spine_skeleton_set_skin_by_namePtr
|
|
.asFunction<void Function(spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
void spine_skeleton_set_skin(
|
|
spine_skeleton skeleton,
|
|
spine_skin skin,
|
|
) {
|
|
return _spine_skeleton_set_skin(
|
|
skeleton,
|
|
skin,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_skinPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_skin)>>(
|
|
'spine_skeleton_set_skin');
|
|
late final _spine_skeleton_set_skin = _spine_skeleton_set_skinPtr
|
|
.asFunction<void Function(spine_skeleton, spine_skin)>();
|
|
|
|
spine_attachment spine_skeleton_get_attachment_by_name(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> slotName,
|
|
ffi.Pointer<ffi.Int8> attachmentName,
|
|
) {
|
|
return _spine_skeleton_get_attachment_by_name(
|
|
skeleton,
|
|
slotName,
|
|
attachmentName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_attachment_by_namePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_attachment Function(spine_skeleton, ffi.Pointer<ffi.Int8>,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_get_attachment_by_name');
|
|
late final _spine_skeleton_get_attachment_by_name =
|
|
_spine_skeleton_get_attachment_by_namePtr.asFunction<
|
|
spine_attachment Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_attachment spine_skeleton_get_attachment(
|
|
spine_skeleton skeleton,
|
|
int slotIndex,
|
|
ffi.Pointer<ffi.Int8> attachmentName,
|
|
) {
|
|
return _spine_skeleton_get_attachment(
|
|
skeleton,
|
|
slotIndex,
|
|
attachmentName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_attachmentPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_attachment Function(spine_skeleton, ffi.Int32,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_get_attachment');
|
|
late final _spine_skeleton_get_attachment =
|
|
_spine_skeleton_get_attachmentPtr.asFunction<
|
|
spine_attachment Function(
|
|
spine_skeleton, int, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
void spine_skeleton_set_attachment(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> slotName,
|
|
ffi.Pointer<ffi.Int8> attachmentName,
|
|
) {
|
|
return _spine_skeleton_set_attachment(
|
|
skeleton,
|
|
slotName,
|
|
attachmentName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_attachmentPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_skeleton, ffi.Pointer<ffi.Int8>,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_set_attachment');
|
|
late final _spine_skeleton_set_attachment =
|
|
_spine_skeleton_set_attachmentPtr.asFunction<
|
|
void Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_ik_constraint spine_skeleton_find_ik_constraint(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> constraintName,
|
|
) {
|
|
return _spine_skeleton_find_ik_constraint(
|
|
skeleton,
|
|
constraintName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_find_ik_constraintPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_ik_constraint Function(spine_skeleton,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_find_ik_constraint');
|
|
late final _spine_skeleton_find_ik_constraint =
|
|
_spine_skeleton_find_ik_constraintPtr.asFunction<
|
|
spine_ik_constraint Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_transform_constraint spine_skeleton_find_transform_constraint(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> constraintName,
|
|
) {
|
|
return _spine_skeleton_find_transform_constraint(
|
|
skeleton,
|
|
constraintName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_find_transform_constraintPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_transform_constraint Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>)>>(
|
|
'spine_skeleton_find_transform_constraint');
|
|
late final _spine_skeleton_find_transform_constraint =
|
|
_spine_skeleton_find_transform_constraintPtr.asFunction<
|
|
spine_transform_constraint Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_path_constraint spine_skeleton_find_path_constraint(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> constraintName,
|
|
) {
|
|
return _spine_skeleton_find_path_constraint(
|
|
skeleton,
|
|
constraintName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_find_path_constraintPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_path_constraint Function(spine_skeleton,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_find_path_constraint');
|
|
late final _spine_skeleton_find_path_constraint =
|
|
_spine_skeleton_find_path_constraintPtr.asFunction<
|
|
spine_path_constraint Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_bounds spine_skeleton_get_bounds(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_bounds(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_boundsPtr =
|
|
_lookup<ffi.NativeFunction<spine_bounds Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_bounds');
|
|
late final _spine_skeleton_get_bounds = _spine_skeleton_get_boundsPtr
|
|
.asFunction<spine_bounds Function(spine_skeleton)>();
|
|
|
|
spine_bone spine_skeleton_get_root_bone(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_root_bone(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_root_bonePtr =
|
|
_lookup<ffi.NativeFunction<spine_bone Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_root_bone');
|
|
late final _spine_skeleton_get_root_bone = _spine_skeleton_get_root_bonePtr
|
|
.asFunction<spine_bone Function(spine_skeleton)>();
|
|
|
|
spine_skeleton_data spine_skeleton_get_data(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_data(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_dataPtr =
|
|
_lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_data');
|
|
late final _spine_skeleton_get_data = _spine_skeleton_get_dataPtr
|
|
.asFunction<spine_skeleton_data Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_bones(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_bones(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_bones');
|
|
late final _spine_skeleton_get_num_bones = _spine_skeleton_get_num_bonesPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_bone> spine_skeleton_get_bones(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_bones(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_bonesPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_bones');
|
|
late final _spine_skeleton_get_bones = _spine_skeleton_get_bonesPtr
|
|
.asFunction<ffi.Pointer<spine_bone> Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_slots(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_slots(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_slotsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_slots');
|
|
late final _spine_skeleton_get_num_slots = _spine_skeleton_get_num_slotsPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_slot> spine_skeleton_get_slots(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_slots(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_slotsPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_slots');
|
|
late final _spine_skeleton_get_slots = _spine_skeleton_get_slotsPtr
|
|
.asFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_draw_order(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_draw_order(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_draw_orderPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_draw_order');
|
|
late final _spine_skeleton_get_num_draw_order =
|
|
_spine_skeleton_get_num_draw_orderPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_slot> spine_skeleton_get_draw_order(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_draw_order(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_draw_orderPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_draw_order');
|
|
late final _spine_skeleton_get_draw_order = _spine_skeleton_get_draw_orderPtr
|
|
.asFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_ik_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_ik_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_ik_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_ik_constraints');
|
|
late final _spine_skeleton_get_num_ik_constraints =
|
|
_spine_skeleton_get_num_ik_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_ik_constraint> spine_skeleton_get_ik_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_ik_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_ik_constraintsPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_ik_constraint> Function(
|
|
spine_skeleton)>>('spine_skeleton_get_ik_constraints');
|
|
late final _spine_skeleton_get_ik_constraints =
|
|
_spine_skeleton_get_ik_constraintsPtr.asFunction<
|
|
ffi.Pointer<spine_ik_constraint> Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_transform_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_transform_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_transform_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_transform_constraints');
|
|
late final _spine_skeleton_get_num_transform_constraints =
|
|
_spine_skeleton_get_num_transform_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_transform_constraint>
|
|
spine_skeleton_get_transform_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_transform_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_transform_constraintsPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_transform_constraint> Function(
|
|
spine_skeleton)>>('spine_skeleton_get_transform_constraints');
|
|
late final _spine_skeleton_get_transform_constraints =
|
|
_spine_skeleton_get_transform_constraintsPtr.asFunction<
|
|
ffi.Pointer<spine_transform_constraint> Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_path_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_path_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_path_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_path_constraints');
|
|
late final _spine_skeleton_get_num_path_constraints =
|
|
_spine_skeleton_get_num_path_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_path_constraint> spine_skeleton_get_path_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_path_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_path_constraintsPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_path_constraint> Function(
|
|
spine_skeleton)>>('spine_skeleton_get_path_constraints');
|
|
late final _spine_skeleton_get_path_constraints =
|
|
_spine_skeleton_get_path_constraintsPtr.asFunction<
|
|
ffi.Pointer<spine_path_constraint> Function(spine_skeleton)>();
|
|
|
|
spine_skin spine_skeleton_get_skin(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_skin(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_skinPtr =
|
|
_lookup<ffi.NativeFunction<spine_skin Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_skin');
|
|
late final _spine_skeleton_get_skin = _spine_skeleton_get_skinPtr
|
|
.asFunction<spine_skin Function(spine_skeleton)>();
|
|
|
|
spine_color spine_skeleton_get_color(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_color(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_colorPtr =
|
|
_lookup<ffi.NativeFunction<spine_color Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_color');
|
|
late final _spine_skeleton_get_color = _spine_skeleton_get_colorPtr
|
|
.asFunction<spine_color Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_color(
|
|
spine_skeleton skeleton,
|
|
double r,
|
|
double g,
|
|
double b,
|
|
double a,
|
|
) {
|
|
return _spine_skeleton_set_color(
|
|
skeleton,
|
|
r,
|
|
g,
|
|
b,
|
|
a,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_colorPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_skeleton, ffi.Float, ffi.Float, ffi.Float,
|
|
ffi.Float)>>('spine_skeleton_set_color');
|
|
late final _spine_skeleton_set_color =
|
|
_spine_skeleton_set_colorPtr.asFunction<
|
|
void Function(spine_skeleton, double, double, double, double)>();
|
|
|
|
void spine_skeleton_set_position(
|
|
spine_skeleton skeleton,
|
|
double x,
|
|
double y,
|
|
) {
|
|
return _spine_skeleton_set_position(
|
|
skeleton,
|
|
x,
|
|
y,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_positionPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_skeleton, ffi.Float,
|
|
ffi.Float)>>('spine_skeleton_set_position');
|
|
late final _spine_skeleton_set_position = _spine_skeleton_set_positionPtr
|
|
.asFunction<void Function(spine_skeleton, double, double)>();
|
|
|
|
double spine_skeleton_get_x(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_x(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_x');
|
|
late final _spine_skeleton_get_x =
|
|
_spine_skeleton_get_xPtr.asFunction<double Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_x(
|
|
spine_skeleton skeleton,
|
|
double x,
|
|
) {
|
|
return _spine_skeleton_set_x(
|
|
skeleton,
|
|
x,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
|
|
'spine_skeleton_set_x');
|
|
late final _spine_skeleton_set_x = _spine_skeleton_set_xPtr
|
|
.asFunction<void Function(spine_skeleton, double)>();
|
|
|
|
double spine_skeleton_get_y(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_y(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_y');
|
|
late final _spine_skeleton_get_y =
|
|
_spine_skeleton_get_yPtr.asFunction<double Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_y(
|
|
spine_skeleton skeleton,
|
|
double y,
|
|
) {
|
|
return _spine_skeleton_set_y(
|
|
skeleton,
|
|
y,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
|
|
'spine_skeleton_set_y');
|
|
late final _spine_skeleton_set_y = _spine_skeleton_set_yPtr
|
|
.asFunction<void Function(spine_skeleton, double)>();
|
|
|
|
double spine_skeleton_get_scale_x(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_scale_x(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_scale_x');
|
|
late final _spine_skeleton_get_scale_x = _spine_skeleton_get_scale_xPtr
|
|
.asFunction<double Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_scale_x(
|
|
spine_skeleton skeleton,
|
|
double scaleX,
|
|
) {
|
|
return _spine_skeleton_set_scale_x(
|
|
skeleton,
|
|
scaleX,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
|
|
'spine_skeleton_set_scale_x');
|
|
late final _spine_skeleton_set_scale_x = _spine_skeleton_set_scale_xPtr
|
|
.asFunction<void Function(spine_skeleton, double)>();
|
|
|
|
double spine_skeleton_get_scale_y(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_scale_y(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_scale_y');
|
|
late final _spine_skeleton_get_scale_y = _spine_skeleton_get_scale_yPtr
|
|
.asFunction<double Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_scale_y(
|
|
spine_skeleton skeleton,
|
|
double scaleY,
|
|
) {
|
|
return _spine_skeleton_set_scale_y(
|
|
skeleton,
|
|
scaleY,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
|
|
'spine_skeleton_set_scale_y');
|
|
late final _spine_skeleton_set_scale_y = _spine_skeleton_set_scale_yPtr
|
|
.asFunction<void Function(spine_skeleton, double)>();
|
|
}
|
|
|
|
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_result extends ffi.Struct {
|
|
external spine_skeleton_data skeletonData;
|
|
|
|
external ffi.Pointer<ffi.Int8> error;
|
|
}
|
|
|
|
typedef spine_skeleton_data = ffi.Pointer<ffi.Void>;
|
|
|
|
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;
|
|
}
|
|
|
|
abstract class spine_event_type {
|
|
static const int SPINE_EVENT_TYPE_START = 0;
|
|
static const int SPINE_EVENT_TYPE_INTERRUPT = 1;
|
|
static const int SPINE_EVENT_TYPE_END = 2;
|
|
static const int SPINE_EVENT_TYPE_COMPLETE = 3;
|
|
static const int SPINE_EVENT_TYPE_DISPOSE = 4;
|
|
static const int SPINE_EVENT_TYPE_EVENT = 5;
|
|
}
|
|
|
|
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_bounds extends ffi.Struct {
|
|
@ffi.Float()
|
|
external double x;
|
|
|
|
@ffi.Float()
|
|
external double y;
|
|
|
|
@ffi.Float()
|
|
external double width;
|
|
|
|
@ffi.Float()
|
|
external double height;
|
|
}
|
|
|
|
class spine_color extends ffi.Struct {
|
|
@ffi.Float()
|
|
external double r;
|
|
|
|
@ffi.Float()
|
|
external double g;
|
|
|
|
@ffi.Float()
|
|
external double b;
|
|
|
|
@ffi.Float()
|
|
external double a;
|
|
}
|
|
|
|
class spine_skeleton_drawable extends ffi.Struct {
|
|
external spine_skeleton skeleton;
|
|
|
|
external spine_animation_state animationState;
|
|
|
|
external spine_animation_state_events animationStateEvents;
|
|
|
|
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_animation_state_events = ffi.Pointer<ffi.Void>;
|
|
typedef spine_track_entry = ffi.Pointer<ffi.Void>;
|
|
typedef spine_event = ffi.Pointer<ffi.Void>;
|
|
typedef spine_animation = ffi.Pointer<ffi.Void>;
|
|
typedef spine_bone = ffi.Pointer<ffi.Void>;
|
|
typedef spine_slot = ffi.Pointer<ffi.Void>;
|
|
typedef spine_skin = ffi.Pointer<ffi.Void>;
|
|
typedef spine_attachment = ffi.Pointer<ffi.Void>;
|
|
typedef spine_ik_constraint = ffi.Pointer<ffi.Void>;
|
|
typedef spine_transform_constraint = ffi.Pointer<ffi.Void>;
|
|
typedef spine_path_constraint = ffi.Pointer<ffi.Void>;
|