mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2026-02-06 15:24:55 +08:00
7812 lines
359 KiB
Dart
7812 lines
359 KiB
Dart
// ignore_for_file: always_specify_types, constant_identifier_names
|
|
// ignore_for_file: camel_case_types
|
|
// ignore_for_file: non_constant_identifier_names
|
|
|
|
// AUTO GENERATED FILE, DO NOT EDIT.
|
|
//
|
|
// Generated by `package:ffigen`.
|
|
// ignore_for_file: type=lint
|
|
import 'ffi_proxy.dart' 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_enable_debug_extension(int enable) {
|
|
return _spine_enable_debug_extension(enable);
|
|
}
|
|
|
|
late final _spine_enable_debug_extensionPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bool)>>(
|
|
'spine_enable_debug_extension',
|
|
);
|
|
late final _spine_enable_debug_extension = _spine_enable_debug_extensionPtr.asFunction<void Function(int)>();
|
|
|
|
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()>();
|
|
|
|
double spine_color_get_r(spine_color color) {
|
|
return _spine_color_get_r(color);
|
|
}
|
|
|
|
late final _spine_color_get_rPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>('spine_color_get_r');
|
|
late final _spine_color_get_r = _spine_color_get_rPtr.asFunction<double Function(spine_color)>();
|
|
|
|
double spine_color_get_g(spine_color color) {
|
|
return _spine_color_get_g(color);
|
|
}
|
|
|
|
late final _spine_color_get_gPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>('spine_color_get_g');
|
|
late final _spine_color_get_g = _spine_color_get_gPtr.asFunction<double Function(spine_color)>();
|
|
|
|
double spine_color_get_b(spine_color color) {
|
|
return _spine_color_get_b(color);
|
|
}
|
|
|
|
late final _spine_color_get_bPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>('spine_color_get_b');
|
|
late final _spine_color_get_b = _spine_color_get_bPtr.asFunction<double Function(spine_color)>();
|
|
|
|
double spine_color_get_a(spine_color color) {
|
|
return _spine_color_get_a(color);
|
|
}
|
|
|
|
late final _spine_color_get_aPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_color)>>('spine_color_get_a');
|
|
late final _spine_color_get_a = _spine_color_get_aPtr.asFunction<double Function(spine_color)>();
|
|
|
|
double spine_bounds_get_x(spine_bounds bounds) {
|
|
return _spine_bounds_get_x(bounds);
|
|
}
|
|
|
|
late final _spine_bounds_get_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bounds)>>(
|
|
'spine_bounds_get_x',
|
|
);
|
|
late final _spine_bounds_get_x = _spine_bounds_get_xPtr.asFunction<double Function(spine_bounds)>();
|
|
|
|
double spine_bounds_get_y(spine_bounds bounds) {
|
|
return _spine_bounds_get_y(bounds);
|
|
}
|
|
|
|
late final _spine_bounds_get_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bounds)>>(
|
|
'spine_bounds_get_y',
|
|
);
|
|
late final _spine_bounds_get_y = _spine_bounds_get_yPtr.asFunction<double Function(spine_bounds)>();
|
|
|
|
double spine_bounds_get_width(spine_bounds bounds) {
|
|
return _spine_bounds_get_width(bounds);
|
|
}
|
|
|
|
late final _spine_bounds_get_widthPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bounds)>>(
|
|
'spine_bounds_get_width',
|
|
);
|
|
late final _spine_bounds_get_width = _spine_bounds_get_widthPtr.asFunction<double Function(spine_bounds)>();
|
|
|
|
double spine_bounds_get_height(spine_bounds bounds) {
|
|
return _spine_bounds_get_height(bounds);
|
|
}
|
|
|
|
late final _spine_bounds_get_heightPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bounds)>>(
|
|
'spine_bounds_get_height',
|
|
);
|
|
late final _spine_bounds_get_height = _spine_bounds_get_heightPtr.asFunction<double Function(spine_bounds)>();
|
|
|
|
double spine_vector_get_x(spine_vector vector) {
|
|
return _spine_vector_get_x(vector);
|
|
}
|
|
|
|
late final _spine_vector_get_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_vector)>>(
|
|
'spine_vector_get_x',
|
|
);
|
|
late final _spine_vector_get_x = _spine_vector_get_xPtr.asFunction<double Function(spine_vector)>();
|
|
|
|
double spine_vector_get_y(spine_vector vector) {
|
|
return _spine_vector_get_y(vector);
|
|
}
|
|
|
|
late final _spine_vector_get_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_vector)>>(
|
|
'spine_vector_get_y',
|
|
);
|
|
late final _spine_vector_get_y = _spine_vector_get_yPtr.asFunction<double Function(spine_vector)>();
|
|
|
|
spine_atlas spine_atlas_load(ffi.Pointer<utf8> atlasData) {
|
|
return _spine_atlas_load(atlasData);
|
|
}
|
|
|
|
late final _spine_atlas_loadPtr = _lookup<ffi.NativeFunction<spine_atlas Function(ffi.Pointer<utf8>)>>(
|
|
'spine_atlas_load',
|
|
);
|
|
late final _spine_atlas_load = _spine_atlas_loadPtr.asFunction<spine_atlas Function(ffi.Pointer<utf8>)>();
|
|
|
|
int spine_atlas_get_num_image_paths(spine_atlas atlas) {
|
|
return _spine_atlas_get_num_image_paths(atlas);
|
|
}
|
|
|
|
late final _spine_atlas_get_num_image_pathsPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_atlas)>>(
|
|
'spine_atlas_get_num_image_paths',
|
|
);
|
|
late final _spine_atlas_get_num_image_paths = _spine_atlas_get_num_image_pathsPtr
|
|
.asFunction<int Function(spine_atlas)>();
|
|
|
|
ffi.Pointer<utf8> spine_atlas_get_image_path(spine_atlas atlas, int index) {
|
|
return _spine_atlas_get_image_path(atlas, index);
|
|
}
|
|
|
|
late final _spine_atlas_get_image_pathPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_atlas, ffi.Int32)>>('spine_atlas_get_image_path');
|
|
late final _spine_atlas_get_image_path = _spine_atlas_get_image_pathPtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_atlas, int)>();
|
|
|
|
ffi.Pointer<utf8> spine_atlas_get_error(spine_atlas atlas) {
|
|
return _spine_atlas_get_error(atlas);
|
|
}
|
|
|
|
late final _spine_atlas_get_errorPtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_atlas)>>(
|
|
'spine_atlas_get_error',
|
|
);
|
|
late final _spine_atlas_get_error = _spine_atlas_get_errorPtr.asFunction<ffi.Pointer<utf8> Function(spine_atlas)>();
|
|
|
|
void spine_atlas_dispose(spine_atlas atlas) {
|
|
return _spine_atlas_dispose(atlas);
|
|
}
|
|
|
|
late final _spine_atlas_disposePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_atlas)>>(
|
|
'spine_atlas_dispose',
|
|
);
|
|
late final _spine_atlas_dispose = _spine_atlas_disposePtr.asFunction<void Function(spine_atlas)>();
|
|
|
|
spine_skeleton_data_result spine_skeleton_data_load_json(spine_atlas atlas, ffi.Pointer<utf8> skeletonData) {
|
|
return _spine_skeleton_data_load_json(atlas, skeletonData);
|
|
}
|
|
|
|
late final _spine_skeleton_data_load_jsonPtr =
|
|
_lookup<ffi.NativeFunction<spine_skeleton_data_result Function(spine_atlas, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_data_load_json',
|
|
);
|
|
late final _spine_skeleton_data_load_json = _spine_skeleton_data_load_jsonPtr
|
|
.asFunction<spine_skeleton_data_result Function(spine_atlas, ffi.Pointer<utf8>)>();
|
|
|
|
spine_skeleton_data_result spine_skeleton_data_load_binary(
|
|
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(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(spine_atlas, ffi.Pointer<ffi.Uint8>, int)>();
|
|
|
|
ffi.Pointer<utf8> spine_skeleton_data_result_get_error(spine_skeleton_data_result result) {
|
|
return _spine_skeleton_data_result_get_error(result);
|
|
}
|
|
|
|
late final _spine_skeleton_data_result_get_errorPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skeleton_data_result)>>(
|
|
'spine_skeleton_data_result_get_error',
|
|
);
|
|
late final _spine_skeleton_data_result_get_error = _spine_skeleton_data_result_get_errorPtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_skeleton_data_result)>();
|
|
|
|
spine_skeleton_data spine_skeleton_data_result_get_data(spine_skeleton_data_result result) {
|
|
return _spine_skeleton_data_result_get_data(result);
|
|
}
|
|
|
|
late final _spine_skeleton_data_result_get_dataPtr =
|
|
_lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_skeleton_data_result)>>(
|
|
'spine_skeleton_data_result_get_data',
|
|
);
|
|
late final _spine_skeleton_data_result_get_data = _spine_skeleton_data_result_get_dataPtr
|
|
.asFunction<spine_skeleton_data Function(spine_skeleton_data_result)>();
|
|
|
|
void spine_skeleton_data_result_dispose(spine_skeleton_data_result result) {
|
|
return _spine_skeleton_data_result_dispose(result);
|
|
}
|
|
|
|
late final _spine_skeleton_data_result_disposePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data_result)>>('spine_skeleton_data_result_dispose');
|
|
late final _spine_skeleton_data_result_dispose = _spine_skeleton_data_result_disposePtr
|
|
.asFunction<void Function(spine_skeleton_data_result)>();
|
|
|
|
spine_bone_data spine_skeleton_data_find_bone(spine_skeleton_data data, ffi.Pointer<utf8> name) {
|
|
return _spine_skeleton_data_find_bone(data, name);
|
|
}
|
|
|
|
late final _spine_skeleton_data_find_bonePtr =
|
|
_lookup<ffi.NativeFunction<spine_bone_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_data_find_bone',
|
|
);
|
|
late final _spine_skeleton_data_find_bone = _spine_skeleton_data_find_bonePtr
|
|
.asFunction<spine_bone_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();
|
|
|
|
spine_slot_data spine_skeleton_data_find_slot(spine_skeleton_data data, ffi.Pointer<utf8> name) {
|
|
return _spine_skeleton_data_find_slot(data, name);
|
|
}
|
|
|
|
late final _spine_skeleton_data_find_slotPtr =
|
|
_lookup<ffi.NativeFunction<spine_slot_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_data_find_slot',
|
|
);
|
|
late final _spine_skeleton_data_find_slot = _spine_skeleton_data_find_slotPtr
|
|
.asFunction<spine_slot_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();
|
|
|
|
spine_skin spine_skeleton_data_find_skin(spine_skeleton_data data, ffi.Pointer<utf8> name) {
|
|
return _spine_skeleton_data_find_skin(data, name);
|
|
}
|
|
|
|
late final _spine_skeleton_data_find_skinPtr =
|
|
_lookup<ffi.NativeFunction<spine_skin Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_data_find_skin',
|
|
);
|
|
late final _spine_skeleton_data_find_skin = _spine_skeleton_data_find_skinPtr
|
|
.asFunction<spine_skin Function(spine_skeleton_data, ffi.Pointer<utf8>)>();
|
|
|
|
spine_event_data spine_skeleton_data_find_event(spine_skeleton_data data, ffi.Pointer<utf8> name) {
|
|
return _spine_skeleton_data_find_event(data, name);
|
|
}
|
|
|
|
late final _spine_skeleton_data_find_eventPtr =
|
|
_lookup<ffi.NativeFunction<spine_event_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_data_find_event',
|
|
);
|
|
late final _spine_skeleton_data_find_event = _spine_skeleton_data_find_eventPtr
|
|
.asFunction<spine_event_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();
|
|
|
|
spine_animation spine_skeleton_data_find_animation(spine_skeleton_data data, ffi.Pointer<utf8> name) {
|
|
return _spine_skeleton_data_find_animation(data, name);
|
|
}
|
|
|
|
late final _spine_skeleton_data_find_animationPtr =
|
|
_lookup<ffi.NativeFunction<spine_animation Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_data_find_animation',
|
|
);
|
|
late final _spine_skeleton_data_find_animation = _spine_skeleton_data_find_animationPtr
|
|
.asFunction<spine_animation Function(spine_skeleton_data, ffi.Pointer<utf8>)>();
|
|
|
|
spine_ik_constraint_data spine_skeleton_data_find_ik_constraint(spine_skeleton_data data, ffi.Pointer<utf8> name) {
|
|
return _spine_skeleton_data_find_ik_constraint(data, name);
|
|
}
|
|
|
|
late final _spine_skeleton_data_find_ik_constraintPtr =
|
|
_lookup<ffi.NativeFunction<spine_ik_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_data_find_ik_constraint',
|
|
);
|
|
late final _spine_skeleton_data_find_ik_constraint = _spine_skeleton_data_find_ik_constraintPtr
|
|
.asFunction<spine_ik_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();
|
|
|
|
spine_transform_constraint_data spine_skeleton_data_find_transform_constraint(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<utf8> name,
|
|
) {
|
|
return _spine_skeleton_data_find_transform_constraint(data, name);
|
|
}
|
|
|
|
late final _spine_skeleton_data_find_transform_constraintPtr =
|
|
_lookup<ffi.NativeFunction<spine_transform_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_data_find_transform_constraint',
|
|
);
|
|
late final _spine_skeleton_data_find_transform_constraint = _spine_skeleton_data_find_transform_constraintPtr
|
|
.asFunction<spine_transform_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();
|
|
|
|
spine_path_constraint_data spine_skeleton_data_find_path_constraint(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<utf8> name,
|
|
) {
|
|
return _spine_skeleton_data_find_path_constraint(data, name);
|
|
}
|
|
|
|
late final _spine_skeleton_data_find_path_constraintPtr =
|
|
_lookup<ffi.NativeFunction<spine_path_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_data_find_path_constraint',
|
|
);
|
|
late final _spine_skeleton_data_find_path_constraint = _spine_skeleton_data_find_path_constraintPtr
|
|
.asFunction<spine_path_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();
|
|
|
|
spine_physics_constraint_data spine_skeleton_data_find_physics_constraint(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<utf8> name,
|
|
) {
|
|
return _spine_skeleton_data_find_physics_constraint(data, name);
|
|
}
|
|
|
|
late final _spine_skeleton_data_find_physics_constraintPtr =
|
|
_lookup<ffi.NativeFunction<spine_physics_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_data_find_physics_constraint',
|
|
);
|
|
late final _spine_skeleton_data_find_physics_constraint = _spine_skeleton_data_find_physics_constraintPtr
|
|
.asFunction<spine_physics_constraint_data Function(spine_skeleton_data, ffi.Pointer<utf8>)>();
|
|
|
|
ffi.Pointer<utf8> spine_skeleton_data_get_name(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_name(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_namePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>>('spine_skeleton_data_get_name');
|
|
late final _spine_skeleton_data_get_name = _spine_skeleton_data_get_namePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>();
|
|
|
|
/// OMITTED setName()
|
|
int spine_skeleton_data_get_num_bones(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_num_bones(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_num_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>('spine_skeleton_data_get_num_bones');
|
|
late final _spine_skeleton_data_get_num_bones = _spine_skeleton_data_get_num_bonesPtr
|
|
.asFunction<int Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_bone_data> spine_skeleton_data_get_bones(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_bones(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_bone_data> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_bones',
|
|
);
|
|
late final _spine_skeleton_data_get_bones = _spine_skeleton_data_get_bonesPtr
|
|
.asFunction<ffi.Pointer<spine_bone_data> Function(spine_skeleton_data)>();
|
|
|
|
int spine_skeleton_data_get_num_slots(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_num_slots(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_num_slotsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>('spine_skeleton_data_get_num_slots');
|
|
late final _spine_skeleton_data_get_num_slots = _spine_skeleton_data_get_num_slotsPtr
|
|
.asFunction<int Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_slot_data> spine_skeleton_data_get_slots(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_slots(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_slotsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_slot_data> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_slots',
|
|
);
|
|
late final _spine_skeleton_data_get_slots = _spine_skeleton_data_get_slotsPtr
|
|
.asFunction<ffi.Pointer<spine_slot_data> Function(spine_skeleton_data)>();
|
|
|
|
int spine_skeleton_data_get_num_skins(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_num_skins(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_num_skinsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>('spine_skeleton_data_get_num_skins');
|
|
late final _spine_skeleton_data_get_num_skins = _spine_skeleton_data_get_num_skinsPtr
|
|
.asFunction<int Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_skin> spine_skeleton_data_get_skins(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_skins(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_skinsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_skin> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_skins',
|
|
);
|
|
late final _spine_skeleton_data_get_skins = _spine_skeleton_data_get_skinsPtr
|
|
.asFunction<ffi.Pointer<spine_skin> Function(spine_skeleton_data)>();
|
|
|
|
spine_skin spine_skeleton_data_get_default_skin(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_default_skin(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_default_skinPtr =
|
|
_lookup<ffi.NativeFunction<spine_skin Function(spine_skeleton_data)>>('spine_skeleton_data_get_default_skin');
|
|
late final _spine_skeleton_data_get_default_skin = _spine_skeleton_data_get_default_skinPtr
|
|
.asFunction<spine_skin Function(spine_skeleton_data)>();
|
|
|
|
void spine_skeleton_data_set_default_skin(spine_skeleton_data data, spine_skin skin) {
|
|
return _spine_skeleton_data_set_default_skin(data, skin);
|
|
}
|
|
|
|
late final _spine_skeleton_data_set_default_skinPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, spine_skin)>>(
|
|
'spine_skeleton_data_set_default_skin',
|
|
);
|
|
late final _spine_skeleton_data_set_default_skin = _spine_skeleton_data_set_default_skinPtr
|
|
.asFunction<void Function(spine_skeleton_data, spine_skin)>();
|
|
|
|
int spine_skeleton_data_get_num_events(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_num_events(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_num_eventsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>('spine_skeleton_data_get_num_events');
|
|
late final _spine_skeleton_data_get_num_events = _spine_skeleton_data_get_num_eventsPtr
|
|
.asFunction<int Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_event_data> spine_skeleton_data_get_events(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_events(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_eventsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_event_data> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_events',
|
|
);
|
|
late final _spine_skeleton_data_get_events = _spine_skeleton_data_get_eventsPtr
|
|
.asFunction<ffi.Pointer<spine_event_data> Function(spine_skeleton_data)>();
|
|
|
|
int spine_skeleton_data_get_num_animations(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_num_animations(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_num_animationsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>('spine_skeleton_data_get_num_animations');
|
|
late final _spine_skeleton_data_get_num_animations = _spine_skeleton_data_get_num_animationsPtr
|
|
.asFunction<int Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_animation> spine_skeleton_data_get_animations(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_animations(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_animationsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_animation> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_animations',
|
|
);
|
|
late final _spine_skeleton_data_get_animations = _spine_skeleton_data_get_animationsPtr
|
|
.asFunction<ffi.Pointer<spine_animation> Function(spine_skeleton_data)>();
|
|
|
|
int spine_skeleton_data_get_num_ik_constraints(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_num_ik_constraints(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_num_ik_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_num_ik_constraints',
|
|
);
|
|
late final _spine_skeleton_data_get_num_ik_constraints = _spine_skeleton_data_get_num_ik_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_ik_constraint_data> spine_skeleton_data_get_ik_constraints(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_ik_constraints(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_ik_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_ik_constraint_data> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_ik_constraints',
|
|
);
|
|
late final _spine_skeleton_data_get_ik_constraints = _spine_skeleton_data_get_ik_constraintsPtr
|
|
.asFunction<ffi.Pointer<spine_ik_constraint_data> Function(spine_skeleton_data)>();
|
|
|
|
int spine_skeleton_data_get_num_transform_constraints(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_num_transform_constraints(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_num_transform_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_num_transform_constraints',
|
|
);
|
|
late final _spine_skeleton_data_get_num_transform_constraints = _spine_skeleton_data_get_num_transform_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_transform_constraint_data> spine_skeleton_data_get_transform_constraints(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_transform_constraints(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_transform_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_transform_constraint_data> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_transform_constraints',
|
|
);
|
|
late final _spine_skeleton_data_get_transform_constraints = _spine_skeleton_data_get_transform_constraintsPtr
|
|
.asFunction<ffi.Pointer<spine_transform_constraint_data> Function(spine_skeleton_data)>();
|
|
|
|
int spine_skeleton_data_get_num_path_constraints(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_num_path_constraints(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_num_path_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_num_path_constraints',
|
|
);
|
|
late final _spine_skeleton_data_get_num_path_constraints = _spine_skeleton_data_get_num_path_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_path_constraint_data> spine_skeleton_data_get_path_constraints(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_path_constraints(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_path_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_path_constraint_data> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_path_constraints',
|
|
);
|
|
late final _spine_skeleton_data_get_path_constraints = _spine_skeleton_data_get_path_constraintsPtr
|
|
.asFunction<ffi.Pointer<spine_path_constraint_data> Function(spine_skeleton_data)>();
|
|
|
|
int spine_skeleton_data_get_num_physics_constraints(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_num_physics_constraints(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_num_physics_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_num_physics_constraints',
|
|
);
|
|
late final _spine_skeleton_data_get_num_physics_constraints = _spine_skeleton_data_get_num_physics_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_physics_constraint_data> spine_skeleton_data_get_physics_constraints(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_physics_constraints(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_physics_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_physics_constraint_data> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_physics_constraints',
|
|
);
|
|
late final _spine_skeleton_data_get_physics_constraints = _spine_skeleton_data_get_physics_constraintsPtr
|
|
.asFunction<ffi.Pointer<spine_physics_constraint_data> Function(spine_skeleton_data)>();
|
|
|
|
double spine_skeleton_data_get_x(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_x(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_x',
|
|
);
|
|
late final _spine_skeleton_data_get_x = _spine_skeleton_data_get_xPtr
|
|
.asFunction<double Function(spine_skeleton_data)>();
|
|
|
|
void spine_skeleton_data_set_x(spine_skeleton_data data, double x) {
|
|
return _spine_skeleton_data_set_x(data, x);
|
|
}
|
|
|
|
late final _spine_skeleton_data_set_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>('spine_skeleton_data_set_x');
|
|
late final _spine_skeleton_data_set_x = _spine_skeleton_data_set_xPtr
|
|
.asFunction<void Function(spine_skeleton_data, double)>();
|
|
|
|
double spine_skeleton_data_get_y(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_y(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_y',
|
|
);
|
|
late final _spine_skeleton_data_get_y = _spine_skeleton_data_get_yPtr
|
|
.asFunction<double Function(spine_skeleton_data)>();
|
|
|
|
void spine_skeleton_data_set_y(spine_skeleton_data data, double y) {
|
|
return _spine_skeleton_data_set_y(data, y);
|
|
}
|
|
|
|
late final _spine_skeleton_data_set_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>('spine_skeleton_data_set_y');
|
|
late final _spine_skeleton_data_set_y = _spine_skeleton_data_set_yPtr
|
|
.asFunction<void Function(spine_skeleton_data, double)>();
|
|
|
|
double spine_skeleton_data_get_width(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_width(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_widthPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_width',
|
|
);
|
|
late final _spine_skeleton_data_get_width = _spine_skeleton_data_get_widthPtr
|
|
.asFunction<double Function(spine_skeleton_data)>();
|
|
|
|
void spine_skeleton_data_set_width(spine_skeleton_data data, double width) {
|
|
return _spine_skeleton_data_set_width(data, width);
|
|
}
|
|
|
|
late final _spine_skeleton_data_set_widthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>('spine_skeleton_data_set_width');
|
|
late final _spine_skeleton_data_set_width = _spine_skeleton_data_set_widthPtr
|
|
.asFunction<void Function(spine_skeleton_data, double)>();
|
|
|
|
double spine_skeleton_data_get_height(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_height(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_heightPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_height',
|
|
);
|
|
late final _spine_skeleton_data_get_height = _spine_skeleton_data_get_heightPtr
|
|
.asFunction<double Function(spine_skeleton_data)>();
|
|
|
|
void spine_skeleton_data_set_height(spine_skeleton_data data, double height) {
|
|
return _spine_skeleton_data_set_height(data, height);
|
|
}
|
|
|
|
late final _spine_skeleton_data_set_heightPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_data, ffi.Float)>>('spine_skeleton_data_set_height');
|
|
late final _spine_skeleton_data_set_height = _spine_skeleton_data_set_heightPtr
|
|
.asFunction<void Function(spine_skeleton_data, double)>();
|
|
|
|
ffi.Pointer<utf8> spine_skeleton_data_get_version(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_version(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_versionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>>('spine_skeleton_data_get_version');
|
|
late final _spine_skeleton_data_get_version = _spine_skeleton_data_get_versionPtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>();
|
|
|
|
/// OMITTED setVersion()
|
|
ffi.Pointer<utf8> spine_skeleton_data_get_hash(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_hash(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_hashPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>>('spine_skeleton_data_get_hash');
|
|
late final _spine_skeleton_data_get_hash = _spine_skeleton_data_get_hashPtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>();
|
|
|
|
/// OMITTED setHash()
|
|
ffi.Pointer<utf8> spine_skeleton_data_get_images_path(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_images_path(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_images_pathPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_images_path',
|
|
);
|
|
late final _spine_skeleton_data_get_images_path = _spine_skeleton_data_get_images_pathPtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>();
|
|
|
|
/// OMITTED setImagesPath()
|
|
ffi.Pointer<utf8> spine_skeleton_data_get_audio_path(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_audio_path(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_audio_pathPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_audio_path',
|
|
);
|
|
late final _spine_skeleton_data_get_audio_path = _spine_skeleton_data_get_audio_pathPtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_skeleton_data)>();
|
|
|
|
/// OMITTED setAudioPath()
|
|
double spine_skeleton_data_get_fps(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_fps(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_fpsPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_data_get_fps',
|
|
);
|
|
late final _spine_skeleton_data_get_fps = _spine_skeleton_data_get_fpsPtr
|
|
.asFunction<double Function(spine_skeleton_data)>();
|
|
|
|
/// OMITTED setFps()
|
|
double spine_skeleton_data_get_reference_scale(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_get_reference_scale(data);
|
|
}
|
|
|
|
late final _spine_skeleton_data_get_reference_scalePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton_data)>>('spine_skeleton_data_get_reference_scale');
|
|
late final _spine_skeleton_data_get_reference_scale = _spine_skeleton_data_get_reference_scalePtr
|
|
.asFunction<double Function(spine_skeleton_data)>();
|
|
|
|
void spine_skeleton_data_dispose(spine_skeleton_data data) {
|
|
return _spine_skeleton_data_dispose(data);
|
|
}
|
|
|
|
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)>();
|
|
|
|
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<spine_skeleton_drawable Function(spine_skeleton_data)>>(
|
|
'spine_skeleton_drawable_create',
|
|
);
|
|
late final _spine_skeleton_drawable_create = _spine_skeleton_drawable_createPtr
|
|
.asFunction<spine_skeleton_drawable Function(spine_skeleton_data)>();
|
|
|
|
spine_render_command spine_skeleton_drawable_render(spine_skeleton_drawable drawable) {
|
|
return _spine_skeleton_drawable_render(drawable);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_renderPtr =
|
|
_lookup<ffi.NativeFunction<spine_render_command Function(spine_skeleton_drawable)>>(
|
|
'spine_skeleton_drawable_render',
|
|
);
|
|
late final _spine_skeleton_drawable_render = _spine_skeleton_drawable_renderPtr
|
|
.asFunction<spine_render_command Function(spine_skeleton_drawable)>();
|
|
|
|
void spine_skeleton_drawable_dispose(spine_skeleton_drawable drawable) {
|
|
return _spine_skeleton_drawable_dispose(drawable);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_disposePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton_drawable)>>('spine_skeleton_drawable_dispose');
|
|
late final _spine_skeleton_drawable_dispose = _spine_skeleton_drawable_disposePtr
|
|
.asFunction<void Function(spine_skeleton_drawable)>();
|
|
|
|
spine_skeleton spine_skeleton_drawable_get_skeleton(spine_skeleton_drawable drawable) {
|
|
return _spine_skeleton_drawable_get_skeleton(drawable);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_get_skeletonPtr =
|
|
_lookup<ffi.NativeFunction<spine_skeleton Function(spine_skeleton_drawable)>>(
|
|
'spine_skeleton_drawable_get_skeleton',
|
|
);
|
|
late final _spine_skeleton_drawable_get_skeleton = _spine_skeleton_drawable_get_skeletonPtr
|
|
.asFunction<spine_skeleton Function(spine_skeleton_drawable)>();
|
|
|
|
spine_animation_state spine_skeleton_drawable_get_animation_state(spine_skeleton_drawable drawable) {
|
|
return _spine_skeleton_drawable_get_animation_state(drawable);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_get_animation_statePtr =
|
|
_lookup<ffi.NativeFunction<spine_animation_state Function(spine_skeleton_drawable)>>(
|
|
'spine_skeleton_drawable_get_animation_state',
|
|
);
|
|
late final _spine_skeleton_drawable_get_animation_state = _spine_skeleton_drawable_get_animation_statePtr
|
|
.asFunction<spine_animation_state Function(spine_skeleton_drawable)>();
|
|
|
|
spine_animation_state_data spine_skeleton_drawable_get_animation_state_data(spine_skeleton_drawable drawable) {
|
|
return _spine_skeleton_drawable_get_animation_state_data(drawable);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_get_animation_state_dataPtr =
|
|
_lookup<ffi.NativeFunction<spine_animation_state_data Function(spine_skeleton_drawable)>>(
|
|
'spine_skeleton_drawable_get_animation_state_data',
|
|
);
|
|
late final _spine_skeleton_drawable_get_animation_state_data = _spine_skeleton_drawable_get_animation_state_dataPtr
|
|
.asFunction<spine_animation_state_data Function(spine_skeleton_drawable)>();
|
|
|
|
spine_animation_state_events spine_skeleton_drawable_get_animation_state_events(spine_skeleton_drawable drawable) {
|
|
return _spine_skeleton_drawable_get_animation_state_events(drawable);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_get_animation_state_eventsPtr =
|
|
_lookup<ffi.NativeFunction<spine_animation_state_events Function(spine_skeleton_drawable)>>(
|
|
'spine_skeleton_drawable_get_animation_state_events',
|
|
);
|
|
late final _spine_skeleton_drawable_get_animation_state_events =
|
|
_spine_skeleton_drawable_get_animation_state_eventsPtr
|
|
.asFunction<spine_animation_state_events Function(spine_skeleton_drawable)>();
|
|
|
|
ffi.Pointer<ffi.Float> spine_render_command_get_positions(spine_render_command command) {
|
|
return _spine_render_command_get_positions(command);
|
|
}
|
|
|
|
late final _spine_render_command_get_positionsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_render_command)>>(
|
|
'spine_render_command_get_positions',
|
|
);
|
|
late final _spine_render_command_get_positions = _spine_render_command_get_positionsPtr
|
|
.asFunction<ffi.Pointer<ffi.Float> Function(spine_render_command)>();
|
|
|
|
ffi.Pointer<ffi.Float> spine_render_command_get_uvs(spine_render_command command) {
|
|
return _spine_render_command_get_uvs(command);
|
|
}
|
|
|
|
late final _spine_render_command_get_uvsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_render_command)>>(
|
|
'spine_render_command_get_uvs',
|
|
);
|
|
late final _spine_render_command_get_uvs = _spine_render_command_get_uvsPtr
|
|
.asFunction<ffi.Pointer<ffi.Float> Function(spine_render_command)>();
|
|
|
|
ffi.Pointer<ffi.Int32> spine_render_command_get_colors(spine_render_command command) {
|
|
return _spine_render_command_get_colors(command);
|
|
}
|
|
|
|
late final _spine_render_command_get_colorsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Int32> Function(spine_render_command)>>(
|
|
'spine_render_command_get_colors',
|
|
);
|
|
late final _spine_render_command_get_colors = _spine_render_command_get_colorsPtr
|
|
.asFunction<ffi.Pointer<ffi.Int32> Function(spine_render_command)>();
|
|
|
|
int spine_render_command_get_num_vertices(spine_render_command command) {
|
|
return _spine_render_command_get_num_vertices(command);
|
|
}
|
|
|
|
late final _spine_render_command_get_num_verticesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>('spine_render_command_get_num_vertices');
|
|
late final _spine_render_command_get_num_vertices = _spine_render_command_get_num_verticesPtr
|
|
.asFunction<int Function(spine_render_command)>();
|
|
|
|
ffi.Pointer<ffi.Uint16> spine_render_command_get_indices(spine_render_command command) {
|
|
return _spine_render_command_get_indices(command);
|
|
}
|
|
|
|
late final _spine_render_command_get_indicesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint16> Function(spine_render_command)>>(
|
|
'spine_render_command_get_indices',
|
|
);
|
|
late final _spine_render_command_get_indices = _spine_render_command_get_indicesPtr
|
|
.asFunction<ffi.Pointer<ffi.Uint16> Function(spine_render_command)>();
|
|
|
|
int spine_render_command_get_num_indices(spine_render_command command) {
|
|
return _spine_render_command_get_num_indices(command);
|
|
}
|
|
|
|
late final _spine_render_command_get_num_indicesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>('spine_render_command_get_num_indices');
|
|
late final _spine_render_command_get_num_indices = _spine_render_command_get_num_indicesPtr
|
|
.asFunction<int Function(spine_render_command)>();
|
|
|
|
int spine_render_command_get_atlas_page(spine_render_command command) {
|
|
return _spine_render_command_get_atlas_page(command);
|
|
}
|
|
|
|
late final _spine_render_command_get_atlas_pagePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>('spine_render_command_get_atlas_page');
|
|
late final _spine_render_command_get_atlas_page = _spine_render_command_get_atlas_pagePtr
|
|
.asFunction<int Function(spine_render_command)>();
|
|
|
|
int spine_render_command_get_blend_mode(spine_render_command command) {
|
|
return _spine_render_command_get_blend_mode(command);
|
|
}
|
|
|
|
late final _spine_render_command_get_blend_modePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_render_command)>>('spine_render_command_get_blend_mode');
|
|
late final _spine_render_command_get_blend_mode = _spine_render_command_get_blend_modePtr
|
|
.asFunction<int Function(spine_render_command)>();
|
|
|
|
spine_render_command spine_render_command_get_next(spine_render_command command) {
|
|
return _spine_render_command_get_next(command);
|
|
}
|
|
|
|
late final _spine_render_command_get_nextPtr =
|
|
_lookup<ffi.NativeFunction<spine_render_command Function(spine_render_command)>>('spine_render_command_get_next');
|
|
late final _spine_render_command_get_next = _spine_render_command_get_nextPtr
|
|
.asFunction<spine_render_command Function(spine_render_command)>();
|
|
|
|
ffi.Pointer<utf8> spine_animation_get_name(spine_animation animation) {
|
|
return _spine_animation_get_name(animation);
|
|
}
|
|
|
|
late final _spine_animation_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_animation)>>(
|
|
'spine_animation_get_name',
|
|
);
|
|
late final _spine_animation_get_name = _spine_animation_get_namePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_animation)>();
|
|
|
|
/// OMITTED getTimelines()
|
|
/// OMITTED hasTimeline()
|
|
double spine_animation_get_duration(spine_animation animation) {
|
|
return _spine_animation_get_duration(animation);
|
|
}
|
|
|
|
late final _spine_animation_get_durationPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_animation)>>(
|
|
'spine_animation_get_duration',
|
|
);
|
|
late final _spine_animation_get_duration = _spine_animation_get_durationPtr
|
|
.asFunction<double Function(spine_animation)>();
|
|
|
|
/// OMITTED setDuration()
|
|
spine_skeleton_data spine_animation_state_data_get_skeleton_data(spine_animation_state_data stateData) {
|
|
return _spine_animation_state_data_get_skeleton_data(stateData);
|
|
}
|
|
|
|
late final _spine_animation_state_data_get_skeleton_dataPtr =
|
|
_lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_animation_state_data)>>(
|
|
'spine_animation_state_data_get_skeleton_data',
|
|
);
|
|
late final _spine_animation_state_data_get_skeleton_data = _spine_animation_state_data_get_skeleton_dataPtr
|
|
.asFunction<spine_skeleton_data Function(spine_animation_state_data)>();
|
|
|
|
double spine_animation_state_data_get_default_mix(spine_animation_state_data stateData) {
|
|
return _spine_animation_state_data_get_default_mix(stateData);
|
|
}
|
|
|
|
late final _spine_animation_state_data_get_default_mixPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_animation_state_data)>>(
|
|
'spine_animation_state_data_get_default_mix',
|
|
);
|
|
late final _spine_animation_state_data_get_default_mix = _spine_animation_state_data_get_default_mixPtr
|
|
.asFunction<double Function(spine_animation_state_data)>();
|
|
|
|
void spine_animation_state_data_set_default_mix(spine_animation_state_data stateData, double defaultMix) {
|
|
return _spine_animation_state_data_set_default_mix(stateData, defaultMix);
|
|
}
|
|
|
|
late final _spine_animation_state_data_set_default_mixPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state_data, ffi.Float)>>(
|
|
'spine_animation_state_data_set_default_mix',
|
|
);
|
|
late final _spine_animation_state_data_set_default_mix = _spine_animation_state_data_set_default_mixPtr
|
|
.asFunction<void Function(spine_animation_state_data, double)>();
|
|
|
|
void spine_animation_state_data_set_mix(
|
|
spine_animation_state_data stateData,
|
|
spine_animation from,
|
|
spine_animation to,
|
|
double duration,
|
|
) {
|
|
return _spine_animation_state_data_set_mix(stateData, from, to, duration);
|
|
}
|
|
|
|
late final _spine_animation_state_data_set_mixPtr =
|
|
_lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_animation_state_data, spine_animation, spine_animation, ffi.Float)>
|
|
>('spine_animation_state_data_set_mix');
|
|
late final _spine_animation_state_data_set_mix = _spine_animation_state_data_set_mixPtr
|
|
.asFunction<void Function(spine_animation_state_data, spine_animation, spine_animation, double)>();
|
|
|
|
double spine_animation_state_data_get_mix(
|
|
spine_animation_state_data stateData,
|
|
spine_animation from,
|
|
spine_animation to,
|
|
) {
|
|
return _spine_animation_state_data_get_mix(stateData, from, to);
|
|
}
|
|
|
|
late final _spine_animation_state_data_get_mixPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_animation_state_data, spine_animation, spine_animation)>>(
|
|
'spine_animation_state_data_get_mix',
|
|
);
|
|
late final _spine_animation_state_data_get_mix = _spine_animation_state_data_get_mixPtr
|
|
.asFunction<double Function(spine_animation_state_data, spine_animation, spine_animation)>();
|
|
|
|
void spine_animation_state_data_set_mix_by_name(
|
|
spine_animation_state_data stateData,
|
|
ffi.Pointer<utf8> fromName,
|
|
ffi.Pointer<utf8> toName,
|
|
double duration,
|
|
) {
|
|
return _spine_animation_state_data_set_mix_by_name(stateData, fromName, toName, duration);
|
|
}
|
|
|
|
late final _spine_animation_state_data_set_mix_by_namePtr =
|
|
_lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_animation_state_data, ffi.Pointer<utf8>, ffi.Pointer<utf8>, ffi.Float)
|
|
>
|
|
>('spine_animation_state_data_set_mix_by_name');
|
|
late final _spine_animation_state_data_set_mix_by_name = _spine_animation_state_data_set_mix_by_namePtr
|
|
.asFunction<void Function(spine_animation_state_data, ffi.Pointer<utf8>, ffi.Pointer<utf8>, double)>();
|
|
|
|
double spine_animation_state_data_get_mix_by_name(
|
|
spine_animation_state_data stateData,
|
|
ffi.Pointer<utf8> fromName,
|
|
ffi.Pointer<utf8> toName,
|
|
) {
|
|
return _spine_animation_state_data_get_mix_by_name(stateData, fromName, toName);
|
|
}
|
|
|
|
late final _spine_animation_state_data_get_mix_by_namePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_animation_state_data, ffi.Pointer<utf8>, ffi.Pointer<utf8>)>>(
|
|
'spine_animation_state_data_get_mix_by_name',
|
|
);
|
|
late final _spine_animation_state_data_get_mix_by_name = _spine_animation_state_data_get_mix_by_namePtr
|
|
.asFunction<double Function(spine_animation_state_data, ffi.Pointer<utf8>, ffi.Pointer<utf8>)>();
|
|
|
|
void spine_animation_state_data_clear(spine_animation_state_data stateData) {
|
|
return _spine_animation_state_data_clear(stateData);
|
|
}
|
|
|
|
late final _spine_animation_state_data_clearPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state_data)>>('spine_animation_state_data_clear');
|
|
late final _spine_animation_state_data_clear = _spine_animation_state_data_clearPtr
|
|
.asFunction<void Function(spine_animation_state_data)>();
|
|
|
|
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)>();
|
|
|
|
int spine_animation_state_get_num_tracks(spine_animation_state state) {
|
|
return _spine_animation_state_get_num_tracks(state);
|
|
}
|
|
|
|
late final _spine_animation_state_get_num_tracksPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_animation_state)>>('spine_animation_state_get_num_tracks');
|
|
late final _spine_animation_state_get_num_tracks = _spine_animation_state_get_num_tracksPtr
|
|
.asFunction<int Function(spine_animation_state)>();
|
|
|
|
spine_track_entry spine_animation_state_set_animation_by_name(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
ffi.Pointer<utf8> animationName,
|
|
int loop,
|
|
) {
|
|
return _spine_animation_state_set_animation_by_name(state, trackIndex, animationName, loop);
|
|
}
|
|
|
|
late final _spine_animation_state_set_animation_by_namePtr =
|
|
_lookup<
|
|
ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Int32, ffi.Pointer<utf8>, spine_bool)>
|
|
>('spine_animation_state_set_animation_by_name');
|
|
late final _spine_animation_state_set_animation_by_name = _spine_animation_state_set_animation_by_namePtr
|
|
.asFunction<spine_track_entry Function(spine_animation_state, int, ffi.Pointer<utf8>, int)>();
|
|
|
|
spine_track_entry spine_animation_state_set_animation(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
spine_animation animation,
|
|
int loop,
|
|
) {
|
|
return _spine_animation_state_set_animation(state, trackIndex, animation, loop);
|
|
}
|
|
|
|
late final _spine_animation_state_set_animationPtr =
|
|
_lookup<
|
|
ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Int32, spine_animation, spine_bool)>
|
|
>('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, spine_animation, int)>();
|
|
|
|
spine_track_entry spine_animation_state_add_animation_by_name(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
ffi.Pointer<utf8> animationName,
|
|
int loop,
|
|
double delay,
|
|
) {
|
|
return _spine_animation_state_add_animation_by_name(state, trackIndex, animationName, loop, delay);
|
|
}
|
|
|
|
late final _spine_animation_state_add_animation_by_namePtr =
|
|
_lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(spine_animation_state, ffi.Int32, ffi.Pointer<utf8>, spine_bool, ffi.Float)
|
|
>
|
|
>('spine_animation_state_add_animation_by_name');
|
|
late final _spine_animation_state_add_animation_by_name = _spine_animation_state_add_animation_by_namePtr
|
|
.asFunction<spine_track_entry Function(spine_animation_state, int, ffi.Pointer<utf8>, int, double)>();
|
|
|
|
spine_track_entry spine_animation_state_add_animation(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
spine_animation animation,
|
|
int loop,
|
|
double delay,
|
|
) {
|
|
return _spine_animation_state_add_animation(state, trackIndex, animation, loop, delay);
|
|
}
|
|
|
|
late final _spine_animation_state_add_animationPtr =
|
|
_lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(spine_animation_state, ffi.Int32, spine_animation, spine_bool, 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, spine_animation, 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)>();
|
|
|
|
spine_track_entry spine_animation_state_get_current(spine_animation_state state, int trackIndex) {
|
|
return _spine_animation_state_get_current(state, trackIndex);
|
|
}
|
|
|
|
late final _spine_animation_state_get_currentPtr =
|
|
_lookup<ffi.NativeFunction<spine_track_entry Function(spine_animation_state, ffi.Int32)>>(
|
|
'spine_animation_state_get_current',
|
|
);
|
|
late final _spine_animation_state_get_current = _spine_animation_state_get_currentPtr
|
|
.asFunction<spine_track_entry Function(spine_animation_state, int)>();
|
|
|
|
spine_animation_state_data spine_animation_state_get_data(spine_animation_state state) {
|
|
return _spine_animation_state_get_data(state);
|
|
}
|
|
|
|
late final _spine_animation_state_get_dataPtr =
|
|
_lookup<ffi.NativeFunction<spine_animation_state_data Function(spine_animation_state)>>(
|
|
'spine_animation_state_get_data',
|
|
);
|
|
late final _spine_animation_state_get_data = _spine_animation_state_get_dataPtr
|
|
.asFunction<spine_animation_state_data Function(spine_animation_state)>();
|
|
|
|
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)>();
|
|
|
|
/// OMITTED setListener()
|
|
/// OMITTED setListener()
|
|
/// OMITTED disableQueue()
|
|
/// OMITTED enableQueue()
|
|
/// OMITTED setManualTrackEntryDisposal()
|
|
/// OMITTED getManualTrackEntryDisposal()
|
|
void spine_animation_state_dispose_track_entry(spine_animation_state state, spine_track_entry entry) {
|
|
return _spine_animation_state_dispose_track_entry(state, entry);
|
|
}
|
|
|
|
late final _spine_animation_state_dispose_track_entryPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state, spine_track_entry)>>(
|
|
'spine_animation_state_dispose_track_entry',
|
|
);
|
|
late final _spine_animation_state_dispose_track_entry = _spine_animation_state_dispose_track_entryPtr
|
|
.asFunction<void Function(spine_animation_state, spine_track_entry)>();
|
|
|
|
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<spine_bool 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, spine_bool)>>('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<spine_bool 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, spine_bool)>>(
|
|
'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<spine_bool 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, spine_bool)>>('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<spine_bool 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, spine_bool)>>(
|
|
'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_alpha_attachment_threshold(spine_track_entry entry) {
|
|
return _spine_track_entry_get_alpha_attachment_threshold(entry);
|
|
}
|
|
|
|
late final _spine_track_entry_get_alpha_attachment_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_alpha_attachment_threshold',
|
|
);
|
|
late final _spine_track_entry_get_alpha_attachment_threshold = _spine_track_entry_get_alpha_attachment_thresholdPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_alpha_attachment_threshold(spine_track_entry entry, double attachmentThreshold) {
|
|
return _spine_track_entry_set_alpha_attachment_threshold(entry, attachmentThreshold);
|
|
}
|
|
|
|
late final _spine_track_entry_set_alpha_attachment_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_alpha_attachment_threshold',
|
|
);
|
|
late final _spine_track_entry_set_alpha_attachment_threshold = _spine_track_entry_set_alpha_attachment_thresholdPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_mix_attachment_threshold(spine_track_entry entry) {
|
|
return _spine_track_entry_get_mix_attachment_threshold(entry);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_attachment_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mix_attachment_threshold',
|
|
);
|
|
late final _spine_track_entry_get_mix_attachment_threshold = _spine_track_entry_get_mix_attachment_thresholdPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_attachment_threshold(spine_track_entry entry, double attachmentThreshold) {
|
|
return _spine_track_entry_set_mix_attachment_threshold(entry, attachmentThreshold);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_attachment_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_mix_attachment_threshold',
|
|
);
|
|
late final _spine_track_entry_set_mix_attachment_threshold = _spine_track_entry_set_mix_attachment_thresholdPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_mix_draw_order_threshold(spine_track_entry entry) {
|
|
return _spine_track_entry_get_mix_draw_order_threshold(entry);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_draw_order_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mix_draw_order_threshold',
|
|
);
|
|
late final _spine_track_entry_get_mix_draw_order_threshold = _spine_track_entry_get_mix_draw_order_thresholdPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_draw_order_threshold(spine_track_entry entry, double drawOrderThreshold) {
|
|
return _spine_track_entry_set_mix_draw_order_threshold(entry, drawOrderThreshold);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_draw_order_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_mix_draw_order_threshold',
|
|
);
|
|
late final _spine_track_entry_set_mix_draw_order_threshold = _spine_track_entry_set_mix_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<spine_bool 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)>();
|
|
|
|
int spine_track_entry_was_applied(spine_track_entry entry) {
|
|
return _spine_track_entry_was_applied(entry);
|
|
}
|
|
|
|
late final _spine_track_entry_was_appliedPtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_track_entry)>>(
|
|
'spine_track_entry_was_applied',
|
|
);
|
|
late final _spine_track_entry_was_applied = _spine_track_entry_was_appliedPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
int spine_track_entry_is_next_ready(spine_track_entry entry) {
|
|
return _spine_track_entry_is_next_ready(entry);
|
|
}
|
|
|
|
late final _spine_track_entry_is_next_readyPtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_track_entry)>>(
|
|
'spine_track_entry_is_next_ready',
|
|
);
|
|
late final _spine_track_entry_is_next_ready = _spine_track_entry_is_next_readyPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
/// OMITTED setListener()
|
|
/// OMITTED setListener()
|
|
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)>();
|
|
|
|
/// OMITTED printUpdateCache()
|
|
void spine_skeleton_update_world_transform(spine_skeleton skeleton, int physics) {
|
|
return _spine_skeleton_update_world_transform(skeleton, physics);
|
|
}
|
|
|
|
late final _spine_skeleton_update_world_transformPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Int32)>>(
|
|
'spine_skeleton_update_world_transform',
|
|
);
|
|
late final _spine_skeleton_update_world_transform = _spine_skeleton_update_world_transformPtr
|
|
.asFunction<void Function(spine_skeleton, int)>();
|
|
|
|
void spine_skeleton_update_world_transform_bone(spine_skeleton skeleton, int physics, spine_bone parent) {
|
|
return _spine_skeleton_update_world_transform_bone(skeleton, physics, parent);
|
|
}
|
|
|
|
late final _spine_skeleton_update_world_transform_bonePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Int32, 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, int, 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<utf8> boneName) {
|
|
return _spine_skeleton_find_bone(skeleton, boneName);
|
|
}
|
|
|
|
late final _spine_skeleton_find_bonePtr =
|
|
_lookup<ffi.NativeFunction<spine_bone Function(spine_skeleton, ffi.Pointer<utf8>)>>('spine_skeleton_find_bone');
|
|
late final _spine_skeleton_find_bone = _spine_skeleton_find_bonePtr
|
|
.asFunction<spine_bone Function(spine_skeleton, ffi.Pointer<utf8>)>();
|
|
|
|
spine_slot spine_skeleton_find_slot(spine_skeleton skeleton, ffi.Pointer<utf8> slotName) {
|
|
return _spine_skeleton_find_slot(skeleton, slotName);
|
|
}
|
|
|
|
late final _spine_skeleton_find_slotPtr =
|
|
_lookup<ffi.NativeFunction<spine_slot Function(spine_skeleton, ffi.Pointer<utf8>)>>('spine_skeleton_find_slot');
|
|
late final _spine_skeleton_find_slot = _spine_skeleton_find_slotPtr
|
|
.asFunction<spine_slot Function(spine_skeleton, ffi.Pointer<utf8>)>();
|
|
|
|
void spine_skeleton_set_skin_by_name(spine_skeleton skeleton, ffi.Pointer<utf8> 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<utf8>)>>(
|
|
'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<utf8>)>();
|
|
|
|
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<utf8> slotName,
|
|
ffi.Pointer<utf8> 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<utf8>, ffi.Pointer<utf8>)>>(
|
|
'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<utf8>, ffi.Pointer<utf8>)>();
|
|
|
|
spine_attachment spine_skeleton_get_attachment(
|
|
spine_skeleton skeleton,
|
|
int slotIndex,
|
|
ffi.Pointer<utf8> 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<utf8>)>>(
|
|
'spine_skeleton_get_attachment',
|
|
);
|
|
late final _spine_skeleton_get_attachment = _spine_skeleton_get_attachmentPtr
|
|
.asFunction<spine_attachment Function(spine_skeleton, int, ffi.Pointer<utf8>)>();
|
|
|
|
void spine_skeleton_set_attachment(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<utf8> slotName,
|
|
ffi.Pointer<utf8> 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<utf8>, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_set_attachment',
|
|
);
|
|
late final _spine_skeleton_set_attachment = _spine_skeleton_set_attachmentPtr
|
|
.asFunction<void Function(spine_skeleton, ffi.Pointer<utf8>, ffi.Pointer<utf8>)>();
|
|
|
|
spine_ik_constraint spine_skeleton_find_ik_constraint(spine_skeleton skeleton, ffi.Pointer<utf8> 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<utf8>)>>(
|
|
'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<utf8>)>();
|
|
|
|
spine_transform_constraint spine_skeleton_find_transform_constraint(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<utf8> 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<utf8>)>>(
|
|
'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<utf8>)>();
|
|
|
|
spine_path_constraint spine_skeleton_find_path_constraint(spine_skeleton skeleton, ffi.Pointer<utf8> 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<utf8>)>>(
|
|
'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<utf8>)>();
|
|
|
|
spine_physics_constraint spine_skeleton_find_physics_constraint(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<utf8> constraintName,
|
|
) {
|
|
return _spine_skeleton_find_physics_constraint(skeleton, constraintName);
|
|
}
|
|
|
|
late final _spine_skeleton_find_physics_constraintPtr =
|
|
_lookup<ffi.NativeFunction<spine_physics_constraint Function(spine_skeleton, ffi.Pointer<utf8>)>>(
|
|
'spine_skeleton_find_physics_constraint',
|
|
);
|
|
late final _spine_skeleton_find_physics_constraint = _spine_skeleton_find_physics_constraintPtr
|
|
.asFunction<spine_physics_constraint Function(spine_skeleton, ffi.Pointer<utf8>)>();
|
|
|
|
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)>();
|
|
|
|
/// OMITTED getUpdateCacheList()
|
|
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)>();
|
|
|
|
int spine_skeleton_get_num_physics_constraints(spine_skeleton skeleton) {
|
|
return _spine_skeleton_get_num_physics_constraints(skeleton);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_physics_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>('spine_skeleton_get_num_physics_constraints');
|
|
late final _spine_skeleton_get_num_physics_constraints = _spine_skeleton_get_num_physics_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_physics_constraint> spine_skeleton_get_physics_constraints(spine_skeleton skeleton) {
|
|
return _spine_skeleton_get_physics_constraints(skeleton);
|
|
}
|
|
|
|
late final _spine_skeleton_get_physics_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_physics_constraint> Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_physics_constraints',
|
|
);
|
|
late final _spine_skeleton_get_physics_constraints = _spine_skeleton_get_physics_constraintsPtr
|
|
.asFunction<ffi.Pointer<spine_physics_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)>();
|
|
|
|
double spine_skeleton_get_time(spine_skeleton skeleton) {
|
|
return _spine_skeleton_get_time(skeleton);
|
|
}
|
|
|
|
late final _spine_skeleton_get_timePtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_time',
|
|
);
|
|
late final _spine_skeleton_get_time = _spine_skeleton_get_timePtr.asFunction<double Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_time(spine_skeleton skeleton, double time) {
|
|
return _spine_skeleton_set_time(skeleton, time);
|
|
}
|
|
|
|
late final _spine_skeleton_set_timePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
|
|
'spine_skeleton_set_time',
|
|
);
|
|
late final _spine_skeleton_set_time = _spine_skeleton_set_timePtr.asFunction<void Function(spine_skeleton, double)>();
|
|
|
|
void spine_skeleton_update(spine_skeleton skeleton, double delta) {
|
|
return _spine_skeleton_update(skeleton, delta);
|
|
}
|
|
|
|
late final _spine_skeleton_updatePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
|
|
'spine_skeleton_update',
|
|
);
|
|
late final _spine_skeleton_update = _spine_skeleton_updatePtr.asFunction<void Function(spine_skeleton, double)>();
|
|
|
|
ffi.Pointer<utf8> spine_event_data_get_name(spine_event_data event) {
|
|
return _spine_event_data_get_name(event);
|
|
}
|
|
|
|
late final _spine_event_data_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_event_data)>>(
|
|
'spine_event_data_get_name',
|
|
);
|
|
late final _spine_event_data_get_name = _spine_event_data_get_namePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_event_data)>();
|
|
|
|
int spine_event_data_get_int_value(spine_event_data event) {
|
|
return _spine_event_data_get_int_value(event);
|
|
}
|
|
|
|
late final _spine_event_data_get_int_valuePtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_event_data)>>(
|
|
'spine_event_data_get_int_value',
|
|
);
|
|
late final _spine_event_data_get_int_value = _spine_event_data_get_int_valuePtr
|
|
.asFunction<int Function(spine_event_data)>();
|
|
|
|
void spine_event_data_set_int_value(spine_event_data event, int value) {
|
|
return _spine_event_data_set_int_value(event, value);
|
|
}
|
|
|
|
late final _spine_event_data_set_int_valuePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Int32)>>('spine_event_data_set_int_value');
|
|
late final _spine_event_data_set_int_value = _spine_event_data_set_int_valuePtr
|
|
.asFunction<void Function(spine_event_data, int)>();
|
|
|
|
double spine_event_data_get_float_value(spine_event_data event) {
|
|
return _spine_event_data_get_float_value(event);
|
|
}
|
|
|
|
late final _spine_event_data_get_float_valuePtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_data)>>(
|
|
'spine_event_data_get_float_value',
|
|
);
|
|
late final _spine_event_data_get_float_value = _spine_event_data_get_float_valuePtr
|
|
.asFunction<double Function(spine_event_data)>();
|
|
|
|
void spine_event_data_set_float_value(spine_event_data event, double value) {
|
|
return _spine_event_data_set_float_value(event, value);
|
|
}
|
|
|
|
late final _spine_event_data_set_float_valuePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Float)>>('spine_event_data_set_float_value');
|
|
late final _spine_event_data_set_float_value = _spine_event_data_set_float_valuePtr
|
|
.asFunction<void Function(spine_event_data, double)>();
|
|
|
|
ffi.Pointer<utf8> spine_event_data_get_string_value(spine_event_data event) {
|
|
return _spine_event_data_get_string_value(event);
|
|
}
|
|
|
|
late final _spine_event_data_get_string_valuePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_event_data)>>('spine_event_data_get_string_value');
|
|
late final _spine_event_data_get_string_value = _spine_event_data_get_string_valuePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_event_data)>();
|
|
|
|
void spine_event_data_set_string_value(spine_event_data event, ffi.Pointer<utf8> value) {
|
|
return _spine_event_data_set_string_value(event, value);
|
|
}
|
|
|
|
late final _spine_event_data_set_string_valuePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Pointer<utf8>)>>(
|
|
'spine_event_data_set_string_value',
|
|
);
|
|
late final _spine_event_data_set_string_value = _spine_event_data_set_string_valuePtr
|
|
.asFunction<void Function(spine_event_data, ffi.Pointer<utf8>)>();
|
|
|
|
ffi.Pointer<utf8> spine_event_data_get_audio_path(spine_event_data event) {
|
|
return _spine_event_data_get_audio_path(event);
|
|
}
|
|
|
|
late final _spine_event_data_get_audio_pathPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_event_data)>>('spine_event_data_get_audio_path');
|
|
late final _spine_event_data_get_audio_path = _spine_event_data_get_audio_pathPtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_event_data)>();
|
|
|
|
/// OMITTED setAudioPath()
|
|
double spine_event_data_get_volume(spine_event_data event) {
|
|
return _spine_event_data_get_volume(event);
|
|
}
|
|
|
|
late final _spine_event_data_get_volumePtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_data)>>(
|
|
'spine_event_data_get_volume',
|
|
);
|
|
late final _spine_event_data_get_volume = _spine_event_data_get_volumePtr
|
|
.asFunction<double Function(spine_event_data)>();
|
|
|
|
void spine_event_data_set_volume(spine_event_data event, double volume) {
|
|
return _spine_event_data_set_volume(event, volume);
|
|
}
|
|
|
|
late final _spine_event_data_set_volumePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Float)>>('spine_event_data_set_volume');
|
|
late final _spine_event_data_set_volume = _spine_event_data_set_volumePtr
|
|
.asFunction<void Function(spine_event_data, double)>();
|
|
|
|
double spine_event_data_get_balance(spine_event_data event) {
|
|
return _spine_event_data_get_balance(event);
|
|
}
|
|
|
|
late final _spine_event_data_get_balancePtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_event_data)>>(
|
|
'spine_event_data_get_balance',
|
|
);
|
|
late final _spine_event_data_get_balance = _spine_event_data_get_balancePtr
|
|
.asFunction<double Function(spine_event_data)>();
|
|
|
|
void spine_event_data_set_balance(spine_event_data event, double balance) {
|
|
return _spine_event_data_set_balance(event, balance);
|
|
}
|
|
|
|
late final _spine_event_data_set_balancePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_event_data, ffi.Float)>>('spine_event_data_set_balance');
|
|
late final _spine_event_data_set_balance = _spine_event_data_set_balancePtr
|
|
.asFunction<void Function(spine_event_data, double)>();
|
|
|
|
spine_event_data spine_event_get_data(spine_event event) {
|
|
return _spine_event_get_data(event);
|
|
}
|
|
|
|
late final _spine_event_get_dataPtr = _lookup<ffi.NativeFunction<spine_event_data Function(spine_event)>>(
|
|
'spine_event_get_data',
|
|
);
|
|
late final _spine_event_get_data = _spine_event_get_dataPtr.asFunction<spine_event_data Function(spine_event)>();
|
|
|
|
double spine_event_get_time(spine_event event) {
|
|
return _spine_event_get_time(event);
|
|
}
|
|
|
|
late final _spine_event_get_timePtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
|
|
'spine_event_get_time',
|
|
);
|
|
late final _spine_event_get_time = _spine_event_get_timePtr.asFunction<double Function(spine_event)>();
|
|
|
|
int spine_event_get_int_value(spine_event event) {
|
|
return _spine_event_get_int_value(event);
|
|
}
|
|
|
|
late final _spine_event_get_int_valuePtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_event)>>(
|
|
'spine_event_get_int_value',
|
|
);
|
|
late final _spine_event_get_int_value = _spine_event_get_int_valuePtr.asFunction<int Function(spine_event)>();
|
|
|
|
void spine_event_set_int_value(spine_event event, int value) {
|
|
return _spine_event_set_int_value(event, value);
|
|
}
|
|
|
|
late final _spine_event_set_int_valuePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Int32)>>(
|
|
'spine_event_set_int_value',
|
|
);
|
|
late final _spine_event_set_int_value = _spine_event_set_int_valuePtr.asFunction<void Function(spine_event, int)>();
|
|
|
|
double spine_event_get_float_value(spine_event event) {
|
|
return _spine_event_get_float_value(event);
|
|
}
|
|
|
|
late final _spine_event_get_float_valuePtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
|
|
'spine_event_get_float_value',
|
|
);
|
|
late final _spine_event_get_float_value = _spine_event_get_float_valuePtr.asFunction<double Function(spine_event)>();
|
|
|
|
void spine_event_set_float_value(spine_event event, double value) {
|
|
return _spine_event_set_float_value(event, value);
|
|
}
|
|
|
|
late final _spine_event_set_float_valuePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Float)>>(
|
|
'spine_event_set_float_value',
|
|
);
|
|
late final _spine_event_set_float_value = _spine_event_set_float_valuePtr
|
|
.asFunction<void Function(spine_event, double)>();
|
|
|
|
ffi.Pointer<utf8> spine_event_get_string_value(spine_event event) {
|
|
return _spine_event_get_string_value(event);
|
|
}
|
|
|
|
late final _spine_event_get_string_valuePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_event)>>(
|
|
'spine_event_get_string_value',
|
|
);
|
|
late final _spine_event_get_string_value = _spine_event_get_string_valuePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_event)>();
|
|
|
|
void spine_event_set_string_value(spine_event event, ffi.Pointer<utf8> value) {
|
|
return _spine_event_set_string_value(event, value);
|
|
}
|
|
|
|
late final _spine_event_set_string_valuePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Pointer<utf8>)>>('spine_event_set_string_value');
|
|
late final _spine_event_set_string_value = _spine_event_set_string_valuePtr
|
|
.asFunction<void Function(spine_event, ffi.Pointer<utf8>)>();
|
|
|
|
double spine_event_get_volume(spine_event event) {
|
|
return _spine_event_get_volume(event);
|
|
}
|
|
|
|
late final _spine_event_get_volumePtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
|
|
'spine_event_get_volume',
|
|
);
|
|
late final _spine_event_get_volume = _spine_event_get_volumePtr.asFunction<double Function(spine_event)>();
|
|
|
|
void spine_event_set_volume(spine_event event, double volume) {
|
|
return _spine_event_set_volume(event, volume);
|
|
}
|
|
|
|
late final _spine_event_set_volumePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Float)>>(
|
|
'spine_event_set_volume',
|
|
);
|
|
late final _spine_event_set_volume = _spine_event_set_volumePtr.asFunction<void Function(spine_event, double)>();
|
|
|
|
double spine_event_get_balance(spine_event event) {
|
|
return _spine_event_get_balance(event);
|
|
}
|
|
|
|
late final _spine_event_get_balancePtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
|
|
'spine_event_get_balance',
|
|
);
|
|
late final _spine_event_get_balance = _spine_event_get_balancePtr.asFunction<double Function(spine_event)>();
|
|
|
|
void spine_event_set_balance(spine_event event, double balance) {
|
|
return _spine_event_set_balance(event, balance);
|
|
}
|
|
|
|
late final _spine_event_set_balancePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_event, ffi.Float)>>(
|
|
'spine_event_set_balance',
|
|
);
|
|
late final _spine_event_set_balance = _spine_event_set_balancePtr.asFunction<void Function(spine_event, double)>();
|
|
|
|
int spine_slot_data_get_index(spine_slot_data slot) {
|
|
return _spine_slot_data_get_index(slot);
|
|
}
|
|
|
|
late final _spine_slot_data_get_indexPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_slot_data)>>(
|
|
'spine_slot_data_get_index',
|
|
);
|
|
late final _spine_slot_data_get_index = _spine_slot_data_get_indexPtr.asFunction<int Function(spine_slot_data)>();
|
|
|
|
ffi.Pointer<utf8> spine_slot_data_get_name(spine_slot_data slot) {
|
|
return _spine_slot_data_get_name(slot);
|
|
}
|
|
|
|
late final _spine_slot_data_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_slot_data)>>(
|
|
'spine_slot_data_get_name',
|
|
);
|
|
late final _spine_slot_data_get_name = _spine_slot_data_get_namePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_slot_data)>();
|
|
|
|
spine_bone_data spine_slot_data_get_bone_data(spine_slot_data slot) {
|
|
return _spine_slot_data_get_bone_data(slot);
|
|
}
|
|
|
|
late final _spine_slot_data_get_bone_dataPtr = _lookup<ffi.NativeFunction<spine_bone_data Function(spine_slot_data)>>(
|
|
'spine_slot_data_get_bone_data',
|
|
);
|
|
late final _spine_slot_data_get_bone_data = _spine_slot_data_get_bone_dataPtr
|
|
.asFunction<spine_bone_data Function(spine_slot_data)>();
|
|
|
|
spine_color spine_slot_data_get_color(spine_slot_data slot) {
|
|
return _spine_slot_data_get_color(slot);
|
|
}
|
|
|
|
late final _spine_slot_data_get_colorPtr = _lookup<ffi.NativeFunction<spine_color Function(spine_slot_data)>>(
|
|
'spine_slot_data_get_color',
|
|
);
|
|
late final _spine_slot_data_get_color = _spine_slot_data_get_colorPtr
|
|
.asFunction<spine_color Function(spine_slot_data)>();
|
|
|
|
void spine_slot_data_set_color(spine_slot_data slot, double r, double g, double b, double a) {
|
|
return _spine_slot_data_set_color(slot, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_slot_data_set_colorPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
|
|
'spine_slot_data_set_color',
|
|
);
|
|
late final _spine_slot_data_set_color = _spine_slot_data_set_colorPtr
|
|
.asFunction<void Function(spine_slot_data, double, double, double, double)>();
|
|
|
|
spine_color spine_slot_data_get_dark_color(spine_slot_data slot) {
|
|
return _spine_slot_data_get_dark_color(slot);
|
|
}
|
|
|
|
late final _spine_slot_data_get_dark_colorPtr = _lookup<ffi.NativeFunction<spine_color Function(spine_slot_data)>>(
|
|
'spine_slot_data_get_dark_color',
|
|
);
|
|
late final _spine_slot_data_get_dark_color = _spine_slot_data_get_dark_colorPtr
|
|
.asFunction<spine_color Function(spine_slot_data)>();
|
|
|
|
void spine_slot_data_set_dark_color(spine_slot_data slot, double r, double g, double b, double a) {
|
|
return _spine_slot_data_set_dark_color(slot, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_slot_data_set_dark_colorPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
|
|
'spine_slot_data_set_dark_color',
|
|
);
|
|
late final _spine_slot_data_set_dark_color = _spine_slot_data_set_dark_colorPtr
|
|
.asFunction<void Function(spine_slot_data, double, double, double, double)>();
|
|
|
|
int spine_slot_data_has_dark_color(spine_slot_data slot) {
|
|
return _spine_slot_data_has_dark_color(slot);
|
|
}
|
|
|
|
late final _spine_slot_data_has_dark_colorPtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_slot_data)>>(
|
|
'spine_slot_data_has_dark_color',
|
|
);
|
|
late final _spine_slot_data_has_dark_color = _spine_slot_data_has_dark_colorPtr
|
|
.asFunction<int Function(spine_slot_data)>();
|
|
|
|
void spine_slot_data_set_has_dark_color(spine_slot_data slot, int hasDarkColor) {
|
|
return _spine_slot_data_set_has_dark_color(slot, hasDarkColor);
|
|
}
|
|
|
|
late final _spine_slot_data_set_has_dark_colorPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, spine_bool)>>('spine_slot_data_set_has_dark_color');
|
|
late final _spine_slot_data_set_has_dark_color = _spine_slot_data_set_has_dark_colorPtr
|
|
.asFunction<void Function(spine_slot_data, int)>();
|
|
|
|
ffi.Pointer<utf8> spine_slot_data_get_attachment_name(spine_slot_data slot) {
|
|
return _spine_slot_data_get_attachment_name(slot);
|
|
}
|
|
|
|
late final _spine_slot_data_get_attachment_namePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_slot_data)>>('spine_slot_data_get_attachment_name');
|
|
late final _spine_slot_data_get_attachment_name = _spine_slot_data_get_attachment_namePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_slot_data)>();
|
|
|
|
void spine_slot_data_set_attachment_name(spine_slot_data slot, ffi.Pointer<utf8> attachmentName) {
|
|
return _spine_slot_data_set_attachment_name(slot, attachmentName);
|
|
}
|
|
|
|
late final _spine_slot_data_set_attachment_namePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Pointer<utf8>)>>(
|
|
'spine_slot_data_set_attachment_name',
|
|
);
|
|
late final _spine_slot_data_set_attachment_name = _spine_slot_data_set_attachment_namePtr
|
|
.asFunction<void Function(spine_slot_data, ffi.Pointer<utf8>)>();
|
|
|
|
int spine_slot_data_get_blend_mode(spine_slot_data slot) {
|
|
return _spine_slot_data_get_blend_mode(slot);
|
|
}
|
|
|
|
late final _spine_slot_data_get_blend_modePtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_slot_data)>>(
|
|
'spine_slot_data_get_blend_mode',
|
|
);
|
|
late final _spine_slot_data_get_blend_mode = _spine_slot_data_get_blend_modePtr
|
|
.asFunction<int Function(spine_slot_data)>();
|
|
|
|
void spine_slot_data_set_blend_mode(spine_slot_data slot, int blendMode) {
|
|
return _spine_slot_data_set_blend_mode(slot, blendMode);
|
|
}
|
|
|
|
late final _spine_slot_data_set_blend_modePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, ffi.Int32)>>('spine_slot_data_set_blend_mode');
|
|
late final _spine_slot_data_set_blend_mode = _spine_slot_data_set_blend_modePtr
|
|
.asFunction<void Function(spine_slot_data, int)>();
|
|
|
|
int spine_slot_data_is_visible(spine_slot_data slot) {
|
|
return _spine_slot_data_is_visible(slot);
|
|
}
|
|
|
|
late final _spine_slot_data_is_visiblePtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_slot_data)>>(
|
|
'spine_slot_data_is_visible',
|
|
);
|
|
late final _spine_slot_data_is_visible = _spine_slot_data_is_visiblePtr.asFunction<int Function(spine_slot_data)>();
|
|
|
|
void spine_slot_data_set_visible(spine_slot_data slot, int visible) {
|
|
return _spine_slot_data_set_visible(slot, visible);
|
|
}
|
|
|
|
late final _spine_slot_data_set_visiblePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_slot_data, spine_bool)>>('spine_slot_data_set_visible');
|
|
late final _spine_slot_data_set_visible = _spine_slot_data_set_visiblePtr
|
|
.asFunction<void Function(spine_slot_data, int)>();
|
|
|
|
/// OMITTED getPath()/setPath()
|
|
void spine_slot_set_to_setup_pose(spine_slot slot) {
|
|
return _spine_slot_set_to_setup_pose(slot);
|
|
}
|
|
|
|
late final _spine_slot_set_to_setup_posePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot)>>(
|
|
'spine_slot_set_to_setup_pose',
|
|
);
|
|
late final _spine_slot_set_to_setup_pose = _spine_slot_set_to_setup_posePtr.asFunction<void Function(spine_slot)>();
|
|
|
|
spine_slot_data spine_slot_get_data(spine_slot slot) {
|
|
return _spine_slot_get_data(slot);
|
|
}
|
|
|
|
late final _spine_slot_get_dataPtr = _lookup<ffi.NativeFunction<spine_slot_data Function(spine_slot)>>(
|
|
'spine_slot_get_data',
|
|
);
|
|
late final _spine_slot_get_data = _spine_slot_get_dataPtr.asFunction<spine_slot_data Function(spine_slot)>();
|
|
|
|
spine_bone spine_slot_get_bone(spine_slot slot) {
|
|
return _spine_slot_get_bone(slot);
|
|
}
|
|
|
|
late final _spine_slot_get_bonePtr = _lookup<ffi.NativeFunction<spine_bone Function(spine_slot)>>(
|
|
'spine_slot_get_bone',
|
|
);
|
|
late final _spine_slot_get_bone = _spine_slot_get_bonePtr.asFunction<spine_bone Function(spine_slot)>();
|
|
|
|
spine_skeleton spine_slot_get_skeleton(spine_slot slot) {
|
|
return _spine_slot_get_skeleton(slot);
|
|
}
|
|
|
|
late final _spine_slot_get_skeletonPtr = _lookup<ffi.NativeFunction<spine_skeleton Function(spine_slot)>>(
|
|
'spine_slot_get_skeleton',
|
|
);
|
|
late final _spine_slot_get_skeleton = _spine_slot_get_skeletonPtr.asFunction<spine_skeleton Function(spine_slot)>();
|
|
|
|
spine_color spine_slot_get_color(spine_slot slot) {
|
|
return _spine_slot_get_color(slot);
|
|
}
|
|
|
|
late final _spine_slot_get_colorPtr = _lookup<ffi.NativeFunction<spine_color Function(spine_slot)>>(
|
|
'spine_slot_get_color',
|
|
);
|
|
late final _spine_slot_get_color = _spine_slot_get_colorPtr.asFunction<spine_color Function(spine_slot)>();
|
|
|
|
void spine_slot_set_color(spine_slot slot, double r, double g, double b, double a) {
|
|
return _spine_slot_set_color(slot, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_slot_set_colorPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_slot, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
|
|
'spine_slot_set_color',
|
|
);
|
|
late final _spine_slot_set_color = _spine_slot_set_colorPtr
|
|
.asFunction<void Function(spine_slot, double, double, double, double)>();
|
|
|
|
spine_color spine_slot_get_dark_color(spine_slot slot) {
|
|
return _spine_slot_get_dark_color(slot);
|
|
}
|
|
|
|
late final _spine_slot_get_dark_colorPtr = _lookup<ffi.NativeFunction<spine_color Function(spine_slot)>>(
|
|
'spine_slot_get_dark_color',
|
|
);
|
|
late final _spine_slot_get_dark_color = _spine_slot_get_dark_colorPtr.asFunction<spine_color Function(spine_slot)>();
|
|
|
|
void spine_slot_set_dark_color(spine_slot slot, double r, double g, double b, double a) {
|
|
return _spine_slot_set_dark_color(slot, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_slot_set_dark_colorPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_slot, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
|
|
'spine_slot_set_dark_color',
|
|
);
|
|
late final _spine_slot_set_dark_color = _spine_slot_set_dark_colorPtr
|
|
.asFunction<void Function(spine_slot, double, double, double, double)>();
|
|
|
|
int spine_slot_has_dark_color(spine_slot slot) {
|
|
return _spine_slot_has_dark_color(slot);
|
|
}
|
|
|
|
late final _spine_slot_has_dark_colorPtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_slot)>>(
|
|
'spine_slot_has_dark_color',
|
|
);
|
|
late final _spine_slot_has_dark_color = _spine_slot_has_dark_colorPtr.asFunction<int Function(spine_slot)>();
|
|
|
|
spine_attachment spine_slot_get_attachment(spine_slot slot) {
|
|
return _spine_slot_get_attachment(slot);
|
|
}
|
|
|
|
late final _spine_slot_get_attachmentPtr = _lookup<ffi.NativeFunction<spine_attachment Function(spine_slot)>>(
|
|
'spine_slot_get_attachment',
|
|
);
|
|
late final _spine_slot_get_attachment = _spine_slot_get_attachmentPtr
|
|
.asFunction<spine_attachment Function(spine_slot)>();
|
|
|
|
void spine_slot_set_attachment(spine_slot slot, spine_attachment attachment) {
|
|
return _spine_slot_set_attachment(slot, attachment);
|
|
}
|
|
|
|
late final _spine_slot_set_attachmentPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_slot, spine_attachment)>>('spine_slot_set_attachment');
|
|
late final _spine_slot_set_attachment = _spine_slot_set_attachmentPtr
|
|
.asFunction<void Function(spine_slot, spine_attachment)>();
|
|
|
|
/// OMITTED getDeform()
|
|
int spine_slot_get_sequence_index(spine_slot slot) {
|
|
return _spine_slot_get_sequence_index(slot);
|
|
}
|
|
|
|
late final _spine_slot_get_sequence_indexPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_slot)>>(
|
|
'spine_slot_get_sequence_index',
|
|
);
|
|
late final _spine_slot_get_sequence_index = _spine_slot_get_sequence_indexPtr.asFunction<int Function(spine_slot)>();
|
|
|
|
void spine_slot_set_sequence_index(spine_slot slot, int sequenceIndex) {
|
|
return _spine_slot_set_sequence_index(slot, sequenceIndex);
|
|
}
|
|
|
|
late final _spine_slot_set_sequence_indexPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_slot, ffi.Int32)>>(
|
|
'spine_slot_set_sequence_index',
|
|
);
|
|
late final _spine_slot_set_sequence_index = _spine_slot_set_sequence_indexPtr
|
|
.asFunction<void Function(spine_slot, int)>();
|
|
|
|
int spine_bone_data_get_index(spine_bone_data data) {
|
|
return _spine_bone_data_get_index(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_indexPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_index',
|
|
);
|
|
late final _spine_bone_data_get_index = _spine_bone_data_get_indexPtr.asFunction<int Function(spine_bone_data)>();
|
|
|
|
ffi.Pointer<utf8> spine_bone_data_get_name(spine_bone_data data) {
|
|
return _spine_bone_data_get_name(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_name',
|
|
);
|
|
late final _spine_bone_data_get_name = _spine_bone_data_get_namePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_bone_data)>();
|
|
|
|
spine_bone_data spine_bone_data_get_parent(spine_bone_data data) {
|
|
return _spine_bone_data_get_parent(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_parentPtr = _lookup<ffi.NativeFunction<spine_bone_data Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_parent',
|
|
);
|
|
late final _spine_bone_data_get_parent = _spine_bone_data_get_parentPtr
|
|
.asFunction<spine_bone_data Function(spine_bone_data)>();
|
|
|
|
double spine_bone_data_get_length(spine_bone_data data) {
|
|
return _spine_bone_data_get_length(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_lengthPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_length',
|
|
);
|
|
late final _spine_bone_data_get_length = _spine_bone_data_get_lengthPtr
|
|
.asFunction<double Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_length(spine_bone_data data, double length) {
|
|
return _spine_bone_data_set_length(data, length);
|
|
}
|
|
|
|
late final _spine_bone_data_set_lengthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_length');
|
|
late final _spine_bone_data_set_length = _spine_bone_data_set_lengthPtr
|
|
.asFunction<void Function(spine_bone_data, double)>();
|
|
|
|
double spine_bone_data_get_x(spine_bone_data data) {
|
|
return _spine_bone_data_get_x(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_x',
|
|
);
|
|
late final _spine_bone_data_get_x = _spine_bone_data_get_xPtr.asFunction<double Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_x(spine_bone_data data, double x) {
|
|
return _spine_bone_data_set_x(data, x);
|
|
}
|
|
|
|
late final _spine_bone_data_set_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>(
|
|
'spine_bone_data_set_x',
|
|
);
|
|
late final _spine_bone_data_set_x = _spine_bone_data_set_xPtr.asFunction<void Function(spine_bone_data, double)>();
|
|
|
|
double spine_bone_data_get_y(spine_bone_data data) {
|
|
return _spine_bone_data_get_y(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_y',
|
|
);
|
|
late final _spine_bone_data_get_y = _spine_bone_data_get_yPtr.asFunction<double Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_y(spine_bone_data data, double y) {
|
|
return _spine_bone_data_set_y(data, y);
|
|
}
|
|
|
|
late final _spine_bone_data_set_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>(
|
|
'spine_bone_data_set_y',
|
|
);
|
|
late final _spine_bone_data_set_y = _spine_bone_data_set_yPtr.asFunction<void Function(spine_bone_data, double)>();
|
|
|
|
double spine_bone_data_get_rotation(spine_bone_data data) {
|
|
return _spine_bone_data_get_rotation(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_rotationPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_rotation',
|
|
);
|
|
late final _spine_bone_data_get_rotation = _spine_bone_data_get_rotationPtr
|
|
.asFunction<double Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_rotation(spine_bone_data data, double rotation) {
|
|
return _spine_bone_data_set_rotation(data, rotation);
|
|
}
|
|
|
|
late final _spine_bone_data_set_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_rotation');
|
|
late final _spine_bone_data_set_rotation = _spine_bone_data_set_rotationPtr
|
|
.asFunction<void Function(spine_bone_data, double)>();
|
|
|
|
double spine_bone_data_get_scale_x(spine_bone_data data) {
|
|
return _spine_bone_data_get_scale_x(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_scale_x',
|
|
);
|
|
late final _spine_bone_data_get_scale_x = _spine_bone_data_get_scale_xPtr
|
|
.asFunction<double Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_scale_x(spine_bone_data data, double scaleX) {
|
|
return _spine_bone_data_set_scale_x(data, scaleX);
|
|
}
|
|
|
|
late final _spine_bone_data_set_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_scale_x');
|
|
late final _spine_bone_data_set_scale_x = _spine_bone_data_set_scale_xPtr
|
|
.asFunction<void Function(spine_bone_data, double)>();
|
|
|
|
double spine_bone_data_get_scale_y(spine_bone_data data) {
|
|
return _spine_bone_data_get_scale_y(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_scale_y',
|
|
);
|
|
late final _spine_bone_data_get_scale_y = _spine_bone_data_get_scale_yPtr
|
|
.asFunction<double Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_scale_y(spine_bone_data data, double scaleY) {
|
|
return _spine_bone_data_set_scale_y(data, scaleY);
|
|
}
|
|
|
|
late final _spine_bone_data_set_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_scale_y');
|
|
late final _spine_bone_data_set_scale_y = _spine_bone_data_set_scale_yPtr
|
|
.asFunction<void Function(spine_bone_data, double)>();
|
|
|
|
double spine_bone_data_get_shear_x(spine_bone_data data) {
|
|
return _spine_bone_data_get_shear_x(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_shear_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_shear_x',
|
|
);
|
|
late final _spine_bone_data_get_shear_x = _spine_bone_data_get_shear_xPtr
|
|
.asFunction<double Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_shear_x(spine_bone_data data, double shearx) {
|
|
return _spine_bone_data_set_shear_x(data, shearx);
|
|
}
|
|
|
|
late final _spine_bone_data_set_shear_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_shear_x');
|
|
late final _spine_bone_data_set_shear_x = _spine_bone_data_set_shear_xPtr
|
|
.asFunction<void Function(spine_bone_data, double)>();
|
|
|
|
double spine_bone_data_get_shear_y(spine_bone_data data) {
|
|
return _spine_bone_data_get_shear_y(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_shear_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_shear_y',
|
|
);
|
|
late final _spine_bone_data_get_shear_y = _spine_bone_data_get_shear_yPtr
|
|
.asFunction<double Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_shear_y(spine_bone_data data, double shearY) {
|
|
return _spine_bone_data_set_shear_y(data, shearY);
|
|
}
|
|
|
|
late final _spine_bone_data_set_shear_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float)>>('spine_bone_data_set_shear_y');
|
|
late final _spine_bone_data_set_shear_y = _spine_bone_data_set_shear_yPtr
|
|
.asFunction<void Function(spine_bone_data, double)>();
|
|
|
|
int spine_bone_data_get_inherit(spine_bone_data data) {
|
|
return _spine_bone_data_get_inherit(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_inheritPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_inherit',
|
|
);
|
|
late final _spine_bone_data_get_inherit = _spine_bone_data_get_inheritPtr.asFunction<int Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_inherit(spine_bone_data data, int inherit) {
|
|
return _spine_bone_data_set_inherit(data, inherit);
|
|
}
|
|
|
|
late final _spine_bone_data_set_inheritPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Int32)>>('spine_bone_data_set_inherit');
|
|
late final _spine_bone_data_set_inherit = _spine_bone_data_set_inheritPtr
|
|
.asFunction<void Function(spine_bone_data, int)>();
|
|
|
|
int spine_bone_data_is_skin_required(spine_bone_data data) {
|
|
return _spine_bone_data_is_skin_required(data);
|
|
}
|
|
|
|
late final _spine_bone_data_is_skin_requiredPtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_bone_data)>>(
|
|
'spine_bone_data_is_skin_required',
|
|
);
|
|
late final _spine_bone_data_is_skin_required = _spine_bone_data_is_skin_requiredPtr
|
|
.asFunction<int Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_is_skin_required(spine_bone_data data, int isSkinRequired) {
|
|
return _spine_bone_data_set_is_skin_required(data, isSkinRequired);
|
|
}
|
|
|
|
late final _spine_bone_data_set_is_skin_requiredPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, spine_bool)>>(
|
|
'spine_bone_data_set_is_skin_required',
|
|
);
|
|
late final _spine_bone_data_set_is_skin_required = _spine_bone_data_set_is_skin_requiredPtr
|
|
.asFunction<void Function(spine_bone_data, int)>();
|
|
|
|
spine_color spine_bone_data_get_color(spine_bone_data data) {
|
|
return _spine_bone_data_get_color(data);
|
|
}
|
|
|
|
late final _spine_bone_data_get_colorPtr = _lookup<ffi.NativeFunction<spine_color Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_color',
|
|
);
|
|
late final _spine_bone_data_get_color = _spine_bone_data_get_colorPtr
|
|
.asFunction<spine_color Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_color(spine_bone_data data, double r, double g, double b, double a) {
|
|
return _spine_bone_data_set_color(data, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_bone_data_set_colorPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
|
|
'spine_bone_data_set_color',
|
|
);
|
|
late final _spine_bone_data_set_color = _spine_bone_data_set_colorPtr
|
|
.asFunction<void Function(spine_bone_data, double, double, double, double)>();
|
|
|
|
int spine_bone_data_is_visible(spine_bone_data data) {
|
|
return _spine_bone_data_is_visible(data);
|
|
}
|
|
|
|
late final _spine_bone_data_is_visiblePtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_bone_data)>>(
|
|
'spine_bone_data_is_visible',
|
|
);
|
|
late final _spine_bone_data_is_visible = _spine_bone_data_is_visiblePtr.asFunction<int Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_visible(spine_bone_data data, int isVisible) {
|
|
return _spine_bone_data_set_visible(data, isVisible);
|
|
}
|
|
|
|
late final _spine_bone_data_set_visiblePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, spine_bool)>>('spine_bone_data_set_visible');
|
|
late final _spine_bone_data_set_visible = _spine_bone_data_set_visiblePtr
|
|
.asFunction<void Function(spine_bone_data, int)>();
|
|
|
|
/// Omitted getIcon()/setIcon()
|
|
void spine_bone_set_is_y_down(int yDown) {
|
|
return _spine_bone_set_is_y_down(yDown);
|
|
}
|
|
|
|
late final _spine_bone_set_is_y_downPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bool)>>(
|
|
'spine_bone_set_is_y_down',
|
|
);
|
|
late final _spine_bone_set_is_y_down = _spine_bone_set_is_y_downPtr.asFunction<void Function(int)>();
|
|
|
|
int spine_bone_get_is_y_down() {
|
|
return _spine_bone_get_is_y_down();
|
|
}
|
|
|
|
late final _spine_bone_get_is_y_downPtr = _lookup<ffi.NativeFunction<spine_bool Function()>>(
|
|
'spine_bone_get_is_y_down',
|
|
);
|
|
late final _spine_bone_get_is_y_down = _spine_bone_get_is_y_downPtr.asFunction<int Function()>();
|
|
|
|
void spine_bone_update(spine_bone bone) {
|
|
return _spine_bone_update(bone);
|
|
}
|
|
|
|
late final _spine_bone_updatePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>('spine_bone_update');
|
|
late final _spine_bone_update = _spine_bone_updatePtr.asFunction<void Function(spine_bone)>();
|
|
|
|
void spine_bone_update_world_transform(spine_bone bone) {
|
|
return _spine_bone_update_world_transform(bone);
|
|
}
|
|
|
|
late final _spine_bone_update_world_transformPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>(
|
|
'spine_bone_update_world_transform',
|
|
);
|
|
late final _spine_bone_update_world_transform = _spine_bone_update_world_transformPtr
|
|
.asFunction<void Function(spine_bone)>();
|
|
|
|
void spine_bone_update_world_transform_with(
|
|
spine_bone bone,
|
|
double x,
|
|
double y,
|
|
double rotation,
|
|
double scaleX,
|
|
double scaleY,
|
|
double shearX,
|
|
double shearY,
|
|
) {
|
|
return _spine_bone_update_world_transform_with(bone, x, y, rotation, scaleX, scaleY, shearX, shearY);
|
|
}
|
|
|
|
late final _spine_bone_update_world_transform_withPtr =
|
|
_lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_bone, ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float, ffi.Float)
|
|
>
|
|
>('spine_bone_update_world_transform_with');
|
|
late final _spine_bone_update_world_transform_with = _spine_bone_update_world_transform_withPtr
|
|
.asFunction<void Function(spine_bone, double, double, double, double, double, double, double)>();
|
|
|
|
void spine_bone_update_applied_transform(spine_bone bone) {
|
|
return _spine_bone_update_applied_transform(bone);
|
|
}
|
|
|
|
late final _spine_bone_update_applied_transformPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>(
|
|
'spine_bone_update_applied_transform',
|
|
);
|
|
late final _spine_bone_update_applied_transform = _spine_bone_update_applied_transformPtr
|
|
.asFunction<void Function(spine_bone)>();
|
|
|
|
void spine_bone_set_to_setup_pose(spine_bone bone) {
|
|
return _spine_bone_set_to_setup_pose(bone);
|
|
}
|
|
|
|
late final _spine_bone_set_to_setup_posePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone)>>(
|
|
'spine_bone_set_to_setup_pose',
|
|
);
|
|
late final _spine_bone_set_to_setup_pose = _spine_bone_set_to_setup_posePtr.asFunction<void Function(spine_bone)>();
|
|
|
|
spine_vector spine_bone_world_to_local(spine_bone bone, double worldX, double worldY) {
|
|
return _spine_bone_world_to_local(bone, worldX, worldY);
|
|
}
|
|
|
|
late final _spine_bone_world_to_localPtr =
|
|
_lookup<ffi.NativeFunction<spine_vector Function(spine_bone, ffi.Float, ffi.Float)>>('spine_bone_world_to_local');
|
|
late final _spine_bone_world_to_local = _spine_bone_world_to_localPtr
|
|
.asFunction<spine_vector Function(spine_bone, double, double)>();
|
|
|
|
spine_vector spine_bone_world_to_parent(spine_bone bone, double worldX, double worldY) {
|
|
return _spine_bone_world_to_parent(bone, worldX, worldY);
|
|
}
|
|
|
|
late final _spine_bone_world_to_parentPtr =
|
|
_lookup<ffi.NativeFunction<spine_vector Function(spine_bone, ffi.Float, ffi.Float)>>(
|
|
'spine_bone_world_to_parent',
|
|
);
|
|
late final _spine_bone_world_to_parent = _spine_bone_world_to_parentPtr
|
|
.asFunction<spine_vector Function(spine_bone, double, double)>();
|
|
|
|
spine_vector spine_bone_local_to_world(spine_bone bone, double localX, double localY) {
|
|
return _spine_bone_local_to_world(bone, localX, localY);
|
|
}
|
|
|
|
late final _spine_bone_local_to_worldPtr =
|
|
_lookup<ffi.NativeFunction<spine_vector Function(spine_bone, ffi.Float, ffi.Float)>>('spine_bone_local_to_world');
|
|
late final _spine_bone_local_to_world = _spine_bone_local_to_worldPtr
|
|
.asFunction<spine_vector Function(spine_bone, double, double)>();
|
|
|
|
spine_vector spine_bone_parent_to_world(spine_bone bone, double localX, double localY) {
|
|
return _spine_bone_parent_to_world(bone, localX, localY);
|
|
}
|
|
|
|
late final _spine_bone_parent_to_worldPtr =
|
|
_lookup<ffi.NativeFunction<spine_vector Function(spine_bone, ffi.Float, ffi.Float)>>(
|
|
'spine_bone_parent_to_world',
|
|
);
|
|
late final _spine_bone_parent_to_world = _spine_bone_parent_to_worldPtr
|
|
.asFunction<spine_vector Function(spine_bone, double, double)>();
|
|
|
|
double spine_bone_world_to_local_rotation(spine_bone bone, double worldRotation) {
|
|
return _spine_bone_world_to_local_rotation(bone, worldRotation);
|
|
}
|
|
|
|
late final _spine_bone_world_to_local_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_bone, ffi.Float)>>('spine_bone_world_to_local_rotation');
|
|
late final _spine_bone_world_to_local_rotation = _spine_bone_world_to_local_rotationPtr
|
|
.asFunction<double Function(spine_bone, double)>();
|
|
|
|
double spine_bone_local_to_world_rotation(spine_bone bone, double localRotation) {
|
|
return _spine_bone_local_to_world_rotation(bone, localRotation);
|
|
}
|
|
|
|
late final _spine_bone_local_to_world_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_bone, ffi.Float)>>('spine_bone_local_to_world_rotation');
|
|
late final _spine_bone_local_to_world_rotation = _spine_bone_local_to_world_rotationPtr
|
|
.asFunction<double Function(spine_bone, double)>();
|
|
|
|
void spine_bone_rotate_world(spine_bone bone, double degrees) {
|
|
return _spine_bone_rotate_world(bone, degrees);
|
|
}
|
|
|
|
late final _spine_bone_rotate_worldPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_rotate_world',
|
|
);
|
|
late final _spine_bone_rotate_world = _spine_bone_rotate_worldPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_world_to_local_rotation_x(spine_bone bone) {
|
|
return _spine_bone_get_world_to_local_rotation_x(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_world_to_local_rotation_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_world_to_local_rotation_x',
|
|
);
|
|
late final _spine_bone_get_world_to_local_rotation_x = _spine_bone_get_world_to_local_rotation_xPtr
|
|
.asFunction<double Function(spine_bone)>();
|
|
|
|
double spine_bone_get_world_to_local_rotation_y(spine_bone bone) {
|
|
return _spine_bone_get_world_to_local_rotation_y(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_world_to_local_rotation_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_world_to_local_rotation_y',
|
|
);
|
|
late final _spine_bone_get_world_to_local_rotation_y = _spine_bone_get_world_to_local_rotation_yPtr
|
|
.asFunction<double Function(spine_bone)>();
|
|
|
|
spine_bone_data spine_bone_get_data(spine_bone bone) {
|
|
return _spine_bone_get_data(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_dataPtr = _lookup<ffi.NativeFunction<spine_bone_data Function(spine_bone)>>(
|
|
'spine_bone_get_data',
|
|
);
|
|
late final _spine_bone_get_data = _spine_bone_get_dataPtr.asFunction<spine_bone_data Function(spine_bone)>();
|
|
|
|
spine_skeleton spine_bone_get_skeleton(spine_bone bone) {
|
|
return _spine_bone_get_skeleton(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_skeletonPtr = _lookup<ffi.NativeFunction<spine_skeleton Function(spine_bone)>>(
|
|
'spine_bone_get_skeleton',
|
|
);
|
|
late final _spine_bone_get_skeleton = _spine_bone_get_skeletonPtr.asFunction<spine_skeleton Function(spine_bone)>();
|
|
|
|
spine_bone spine_bone_get_parent(spine_bone bone) {
|
|
return _spine_bone_get_parent(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_parentPtr = _lookup<ffi.NativeFunction<spine_bone Function(spine_bone)>>(
|
|
'spine_bone_get_parent',
|
|
);
|
|
late final _spine_bone_get_parent = _spine_bone_get_parentPtr.asFunction<spine_bone Function(spine_bone)>();
|
|
|
|
int spine_bone_get_num_children(spine_bone bone) {
|
|
return _spine_bone_get_num_children(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_num_childrenPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone)>>(
|
|
'spine_bone_get_num_children',
|
|
);
|
|
late final _spine_bone_get_num_children = _spine_bone_get_num_childrenPtr.asFunction<int Function(spine_bone)>();
|
|
|
|
ffi.Pointer<spine_bone> spine_bone_get_children(spine_bone bone) {
|
|
return _spine_bone_get_children(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_childrenPtr = _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_bone)>>(
|
|
'spine_bone_get_children',
|
|
);
|
|
late final _spine_bone_get_children = _spine_bone_get_childrenPtr
|
|
.asFunction<ffi.Pointer<spine_bone> Function(spine_bone)>();
|
|
|
|
double spine_bone_get_x(spine_bone bone) {
|
|
return _spine_bone_get_x(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_x');
|
|
late final _spine_bone_get_x = _spine_bone_get_xPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_x(spine_bone bone, double x) {
|
|
return _spine_bone_set_x(bone, x);
|
|
}
|
|
|
|
late final _spine_bone_set_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_x',
|
|
);
|
|
late final _spine_bone_set_x = _spine_bone_set_xPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_y(spine_bone bone) {
|
|
return _spine_bone_get_y(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_y');
|
|
late final _spine_bone_get_y = _spine_bone_get_yPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_y(spine_bone bone, double y) {
|
|
return _spine_bone_set_y(bone, y);
|
|
}
|
|
|
|
late final _spine_bone_set_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_y',
|
|
);
|
|
late final _spine_bone_set_y = _spine_bone_set_yPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_rotation(spine_bone bone) {
|
|
return _spine_bone_get_rotation(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_rotationPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_rotation',
|
|
);
|
|
late final _spine_bone_get_rotation = _spine_bone_get_rotationPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_rotation(spine_bone bone, double rotation) {
|
|
return _spine_bone_set_rotation(bone, rotation);
|
|
}
|
|
|
|
late final _spine_bone_set_rotationPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_rotation',
|
|
);
|
|
late final _spine_bone_set_rotation = _spine_bone_set_rotationPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_scale_x(spine_bone bone) {
|
|
return _spine_bone_get_scale_x(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_scale_x',
|
|
);
|
|
late final _spine_bone_get_scale_x = _spine_bone_get_scale_xPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_scale_x(spine_bone bone, double scaleX) {
|
|
return _spine_bone_set_scale_x(bone, scaleX);
|
|
}
|
|
|
|
late final _spine_bone_set_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_scale_x',
|
|
);
|
|
late final _spine_bone_set_scale_x = _spine_bone_set_scale_xPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_scale_y(spine_bone bone) {
|
|
return _spine_bone_get_scale_y(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_scale_y',
|
|
);
|
|
late final _spine_bone_get_scale_y = _spine_bone_get_scale_yPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_scale_y(spine_bone bone, double scaleY) {
|
|
return _spine_bone_set_scale_y(bone, scaleY);
|
|
}
|
|
|
|
late final _spine_bone_set_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_scale_y',
|
|
);
|
|
late final _spine_bone_set_scale_y = _spine_bone_set_scale_yPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_shear_x(spine_bone bone) {
|
|
return _spine_bone_get_shear_x(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_shear_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_shear_x',
|
|
);
|
|
late final _spine_bone_get_shear_x = _spine_bone_get_shear_xPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_shear_x(spine_bone bone, double shearX) {
|
|
return _spine_bone_set_shear_x(bone, shearX);
|
|
}
|
|
|
|
late final _spine_bone_set_shear_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_shear_x',
|
|
);
|
|
late final _spine_bone_set_shear_x = _spine_bone_set_shear_xPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_shear_y(spine_bone bone) {
|
|
return _spine_bone_get_shear_y(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_shear_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_shear_y',
|
|
);
|
|
late final _spine_bone_get_shear_y = _spine_bone_get_shear_yPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_shear_y(spine_bone bone, double shearY) {
|
|
return _spine_bone_set_shear_y(bone, shearY);
|
|
}
|
|
|
|
late final _spine_bone_set_shear_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_shear_y',
|
|
);
|
|
late final _spine_bone_set_shear_y = _spine_bone_set_shear_yPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_applied_rotation(spine_bone bone) {
|
|
return _spine_bone_get_applied_rotation(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_applied_rotationPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_applied_rotation',
|
|
);
|
|
late final _spine_bone_get_applied_rotation = _spine_bone_get_applied_rotationPtr
|
|
.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_applied_rotation(spine_bone bone, double rotation) {
|
|
return _spine_bone_set_applied_rotation(bone, rotation);
|
|
}
|
|
|
|
late final _spine_bone_set_applied_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>('spine_bone_set_applied_rotation');
|
|
late final _spine_bone_set_applied_rotation = _spine_bone_set_applied_rotationPtr
|
|
.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_a_x(spine_bone bone) {
|
|
return _spine_bone_get_a_x(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_a_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_a_x');
|
|
late final _spine_bone_get_a_x = _spine_bone_get_a_xPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_a_x(spine_bone bone, double x) {
|
|
return _spine_bone_set_a_x(bone, x);
|
|
}
|
|
|
|
late final _spine_bone_set_a_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_a_x',
|
|
);
|
|
late final _spine_bone_set_a_x = _spine_bone_set_a_xPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_a_y(spine_bone bone) {
|
|
return _spine_bone_get_a_y(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_a_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_a_y');
|
|
late final _spine_bone_get_a_y = _spine_bone_get_a_yPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_a_y(spine_bone bone, double y) {
|
|
return _spine_bone_set_a_y(bone, y);
|
|
}
|
|
|
|
late final _spine_bone_set_a_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_a_y',
|
|
);
|
|
late final _spine_bone_set_a_y = _spine_bone_set_a_yPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_a_scale_x(spine_bone bone) {
|
|
return _spine_bone_get_a_scale_x(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_a_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_a_scale_x',
|
|
);
|
|
late final _spine_bone_get_a_scale_x = _spine_bone_get_a_scale_xPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_a_scale_x(spine_bone bone, double scaleX) {
|
|
return _spine_bone_set_a_scale_x(bone, scaleX);
|
|
}
|
|
|
|
late final _spine_bone_set_a_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_a_scale_x',
|
|
);
|
|
late final _spine_bone_set_a_scale_x = _spine_bone_set_a_scale_xPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_a_scale_y(spine_bone bone) {
|
|
return _spine_bone_get_a_scale_y(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_a_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_a_scale_y',
|
|
);
|
|
late final _spine_bone_get_a_scale_y = _spine_bone_get_a_scale_yPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_a_scale_y(spine_bone bone, double scaleY) {
|
|
return _spine_bone_set_a_scale_y(bone, scaleY);
|
|
}
|
|
|
|
late final _spine_bone_set_a_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_a_scale_y',
|
|
);
|
|
late final _spine_bone_set_a_scale_y = _spine_bone_set_a_scale_yPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_a_shear_x(spine_bone bone) {
|
|
return _spine_bone_get_a_shear_x(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_a_shear_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_a_shear_x',
|
|
);
|
|
late final _spine_bone_get_a_shear_x = _spine_bone_get_a_shear_xPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_a_shear_x(spine_bone bone, double shearX) {
|
|
return _spine_bone_set_a_shear_x(bone, shearX);
|
|
}
|
|
|
|
late final _spine_bone_set_a_shear_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_a_shear_x',
|
|
);
|
|
late final _spine_bone_set_a_shear_x = _spine_bone_set_a_shear_xPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_a_shear_y(spine_bone bone) {
|
|
return _spine_bone_get_a_shear_y(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_a_shear_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_a_shear_y',
|
|
);
|
|
late final _spine_bone_get_a_shear_y = _spine_bone_get_a_shear_yPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_a_shear_y(spine_bone bone, double shearY) {
|
|
return _spine_bone_set_a_shear_y(bone, shearY);
|
|
}
|
|
|
|
late final _spine_bone_set_a_shear_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_a_shear_y',
|
|
);
|
|
late final _spine_bone_set_a_shear_y = _spine_bone_set_a_shear_yPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_a(spine_bone bone) {
|
|
return _spine_bone_get_a(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_aPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_a');
|
|
late final _spine_bone_get_a = _spine_bone_get_aPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_a(spine_bone bone, double a) {
|
|
return _spine_bone_set_a(bone, a);
|
|
}
|
|
|
|
late final _spine_bone_set_aPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_a',
|
|
);
|
|
late final _spine_bone_set_a = _spine_bone_set_aPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_b(spine_bone bone) {
|
|
return _spine_bone_get_b(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_bPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_b');
|
|
late final _spine_bone_get_b = _spine_bone_get_bPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_b(spine_bone bone, double b) {
|
|
return _spine_bone_set_b(bone, b);
|
|
}
|
|
|
|
late final _spine_bone_set_bPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_b',
|
|
);
|
|
late final _spine_bone_set_b = _spine_bone_set_bPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_c(spine_bone bone) {
|
|
return _spine_bone_get_c(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_cPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_c');
|
|
late final _spine_bone_get_c = _spine_bone_get_cPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_c(spine_bone bone, double c) {
|
|
return _spine_bone_set_c(bone, c);
|
|
}
|
|
|
|
late final _spine_bone_set_cPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_c',
|
|
);
|
|
late final _spine_bone_set_c = _spine_bone_set_cPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_d(spine_bone bone) {
|
|
return _spine_bone_get_d(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_dPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>('spine_bone_get_d');
|
|
late final _spine_bone_get_d = _spine_bone_get_dPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_d(spine_bone bone, double d) {
|
|
return _spine_bone_set_d(bone, d);
|
|
}
|
|
|
|
late final _spine_bone_set_dPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_d',
|
|
);
|
|
late final _spine_bone_set_d = _spine_bone_set_dPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_world_x(spine_bone bone) {
|
|
return _spine_bone_get_world_x(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_world_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_world_x',
|
|
);
|
|
late final _spine_bone_get_world_x = _spine_bone_get_world_xPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_world_x(spine_bone bone, double worldX) {
|
|
return _spine_bone_set_world_x(bone, worldX);
|
|
}
|
|
|
|
late final _spine_bone_set_world_xPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_world_x',
|
|
);
|
|
late final _spine_bone_set_world_x = _spine_bone_set_world_xPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_world_y(spine_bone bone) {
|
|
return _spine_bone_get_world_y(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_world_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_world_y',
|
|
);
|
|
late final _spine_bone_get_world_y = _spine_bone_get_world_yPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
void spine_bone_set_world_y(spine_bone bone, double worldY) {
|
|
return _spine_bone_set_world_y(bone, worldY);
|
|
}
|
|
|
|
late final _spine_bone_set_world_yPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Float)>>(
|
|
'spine_bone_set_world_y',
|
|
);
|
|
late final _spine_bone_set_world_y = _spine_bone_set_world_yPtr.asFunction<void Function(spine_bone, double)>();
|
|
|
|
double spine_bone_get_world_rotation_x(spine_bone bone) {
|
|
return _spine_bone_get_world_rotation_x(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_world_rotation_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_world_rotation_x',
|
|
);
|
|
late final _spine_bone_get_world_rotation_x = _spine_bone_get_world_rotation_xPtr
|
|
.asFunction<double Function(spine_bone)>();
|
|
|
|
double spine_bone_get_world_rotation_y(spine_bone bone) {
|
|
return _spine_bone_get_world_rotation_y(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_world_rotation_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_world_rotation_y',
|
|
);
|
|
late final _spine_bone_get_world_rotation_y = _spine_bone_get_world_rotation_yPtr
|
|
.asFunction<double Function(spine_bone)>();
|
|
|
|
double spine_bone_get_world_scale_x(spine_bone bone) {
|
|
return _spine_bone_get_world_scale_x(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_world_scale_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_world_scale_x',
|
|
);
|
|
late final _spine_bone_get_world_scale_x = _spine_bone_get_world_scale_xPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
double spine_bone_get_world_scale_y(spine_bone bone) {
|
|
return _spine_bone_get_world_scale_y(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_world_scale_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_bone)>>(
|
|
'spine_bone_get_world_scale_y',
|
|
);
|
|
late final _spine_bone_get_world_scale_y = _spine_bone_get_world_scale_yPtr.asFunction<double Function(spine_bone)>();
|
|
|
|
int spine_bone_get_is_active(spine_bone bone) {
|
|
return _spine_bone_get_is_active(bone);
|
|
}
|
|
|
|
late final _spine_bone_get_is_activePtr = _lookup<ffi.NativeFunction<spine_bool Function(spine_bone)>>(
|
|
'spine_bone_get_is_active',
|
|
);
|
|
late final _spine_bone_get_is_active = _spine_bone_get_is_activePtr.asFunction<int Function(spine_bone)>();
|
|
|
|
void spine_bone_set_is_active(spine_bone bone, int isActive) {
|
|
return _spine_bone_set_is_active(bone, isActive);
|
|
}
|
|
|
|
late final _spine_bone_set_is_activePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, spine_bool)>>(
|
|
'spine_bone_set_is_active',
|
|
);
|
|
late final _spine_bone_set_is_active = _spine_bone_set_is_activePtr.asFunction<void Function(spine_bone, int)>();
|
|
|
|
int spine_bone_get_inherit(spine_bone data) {
|
|
return _spine_bone_get_inherit(data);
|
|
}
|
|
|
|
late final _spine_bone_get_inheritPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone)>>(
|
|
'spine_bone_get_inherit',
|
|
);
|
|
late final _spine_bone_get_inherit = _spine_bone_get_inheritPtr.asFunction<int Function(spine_bone)>();
|
|
|
|
void spine_bone_set_inherit(spine_bone data, int inherit) {
|
|
return _spine_bone_set_inherit(data, inherit);
|
|
}
|
|
|
|
late final _spine_bone_set_inheritPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_bone, ffi.Int32)>>(
|
|
'spine_bone_set_inherit',
|
|
);
|
|
late final _spine_bone_set_inherit = _spine_bone_set_inheritPtr.asFunction<void Function(spine_bone, int)>();
|
|
|
|
ffi.Pointer<utf8> spine_attachment_get_name(spine_attachment attachment) {
|
|
return _spine_attachment_get_name(attachment);
|
|
}
|
|
|
|
late final _spine_attachment_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_attachment)>>(
|
|
'spine_attachment_get_name',
|
|
);
|
|
late final _spine_attachment_get_name = _spine_attachment_get_namePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_attachment)>();
|
|
|
|
int spine_attachment_get_type(spine_attachment attachment) {
|
|
return _spine_attachment_get_type(attachment);
|
|
}
|
|
|
|
late final _spine_attachment_get_typePtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_attachment)>>(
|
|
'spine_attachment_get_type',
|
|
);
|
|
late final _spine_attachment_get_type = _spine_attachment_get_typePtr.asFunction<int Function(spine_attachment)>();
|
|
|
|
spine_attachment spine_attachment_copy(spine_attachment attachment) {
|
|
return _spine_attachment_copy(attachment);
|
|
}
|
|
|
|
late final _spine_attachment_copyPtr = _lookup<ffi.NativeFunction<spine_attachment Function(spine_attachment)>>(
|
|
'spine_attachment_copy',
|
|
);
|
|
late final _spine_attachment_copy = _spine_attachment_copyPtr
|
|
.asFunction<spine_attachment Function(spine_attachment)>();
|
|
|
|
void spine_attachment_dispose(spine_attachment attachment) {
|
|
return _spine_attachment_dispose(attachment);
|
|
}
|
|
|
|
late final _spine_attachment_disposePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_attachment)>>(
|
|
'spine_attachment_dispose',
|
|
);
|
|
late final _spine_attachment_dispose = _spine_attachment_disposePtr.asFunction<void Function(spine_attachment)>();
|
|
|
|
spine_vector spine_point_attachment_compute_world_position(spine_point_attachment attachment, spine_bone bone) {
|
|
return _spine_point_attachment_compute_world_position(attachment, bone);
|
|
}
|
|
|
|
late final _spine_point_attachment_compute_world_positionPtr =
|
|
_lookup<ffi.NativeFunction<spine_vector Function(spine_point_attachment, spine_bone)>>(
|
|
'spine_point_attachment_compute_world_position',
|
|
);
|
|
late final _spine_point_attachment_compute_world_position = _spine_point_attachment_compute_world_positionPtr
|
|
.asFunction<spine_vector Function(spine_point_attachment, spine_bone)>();
|
|
|
|
double spine_point_attachment_compute_world_rotation(spine_point_attachment attachment, spine_bone bone) {
|
|
return _spine_point_attachment_compute_world_rotation(attachment, bone);
|
|
}
|
|
|
|
late final _spine_point_attachment_compute_world_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment, spine_bone)>>(
|
|
'spine_point_attachment_compute_world_rotation',
|
|
);
|
|
late final _spine_point_attachment_compute_world_rotation = _spine_point_attachment_compute_world_rotationPtr
|
|
.asFunction<double Function(spine_point_attachment, spine_bone)>();
|
|
|
|
double spine_point_attachment_get_x(spine_point_attachment attachment) {
|
|
return _spine_point_attachment_get_x(attachment);
|
|
}
|
|
|
|
late final _spine_point_attachment_get_xPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment)>>(
|
|
'spine_point_attachment_get_x',
|
|
);
|
|
late final _spine_point_attachment_get_x = _spine_point_attachment_get_xPtr
|
|
.asFunction<double Function(spine_point_attachment)>();
|
|
|
|
void spine_point_attachment_set_x(spine_point_attachment attachment, double x) {
|
|
return _spine_point_attachment_set_x(attachment, x);
|
|
}
|
|
|
|
late final _spine_point_attachment_set_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment, ffi.Float)>>('spine_point_attachment_set_x');
|
|
late final _spine_point_attachment_set_x = _spine_point_attachment_set_xPtr
|
|
.asFunction<void Function(spine_point_attachment, double)>();
|
|
|
|
double spine_point_attachment_get_y(spine_point_attachment attachment) {
|
|
return _spine_point_attachment_get_y(attachment);
|
|
}
|
|
|
|
late final _spine_point_attachment_get_yPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment)>>(
|
|
'spine_point_attachment_get_y',
|
|
);
|
|
late final _spine_point_attachment_get_y = _spine_point_attachment_get_yPtr
|
|
.asFunction<double Function(spine_point_attachment)>();
|
|
|
|
void spine_point_attachment_set_y(spine_point_attachment attachment, double y) {
|
|
return _spine_point_attachment_set_y(attachment, y);
|
|
}
|
|
|
|
late final _spine_point_attachment_set_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment, ffi.Float)>>('spine_point_attachment_set_y');
|
|
late final _spine_point_attachment_set_y = _spine_point_attachment_set_yPtr
|
|
.asFunction<void Function(spine_point_attachment, double)>();
|
|
|
|
double spine_point_attachment_get_rotation(spine_point_attachment attachment) {
|
|
return _spine_point_attachment_get_rotation(attachment);
|
|
}
|
|
|
|
late final _spine_point_attachment_get_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_point_attachment)>>('spine_point_attachment_get_rotation');
|
|
late final _spine_point_attachment_get_rotation = _spine_point_attachment_get_rotationPtr
|
|
.asFunction<double Function(spine_point_attachment)>();
|
|
|
|
void spine_point_attachment_set_rotation(spine_point_attachment attachment, double rotation) {
|
|
return _spine_point_attachment_set_rotation(attachment, rotation);
|
|
}
|
|
|
|
late final _spine_point_attachment_set_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_point_attachment, ffi.Float)>>(
|
|
'spine_point_attachment_set_rotation',
|
|
);
|
|
late final _spine_point_attachment_set_rotation = _spine_point_attachment_set_rotationPtr
|
|
.asFunction<void Function(spine_point_attachment, double)>();
|
|
|
|
spine_color spine_point_attachment_get_color(spine_point_attachment attachment) {
|
|
return _spine_point_attachment_get_color(attachment);
|
|
}
|
|
|
|
late final _spine_point_attachment_get_colorPtr =
|
|
_lookup<ffi.NativeFunction<spine_color Function(spine_point_attachment)>>('spine_point_attachment_get_color');
|
|
late final _spine_point_attachment_get_color = _spine_point_attachment_get_colorPtr
|
|
.asFunction<spine_color Function(spine_point_attachment)>();
|
|
|
|
void spine_point_attachment_set_color(spine_point_attachment attachment, double r, double g, double b, double a) {
|
|
return _spine_point_attachment_set_color(attachment, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_point_attachment_set_colorPtr =
|
|
_lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_point_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>
|
|
>('spine_point_attachment_set_color');
|
|
late final _spine_point_attachment_set_color = _spine_point_attachment_set_colorPtr
|
|
.asFunction<void Function(spine_point_attachment, double, double, double, double)>();
|
|
|
|
void spine_region_attachment_update_region(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_update_region(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_update_regionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment)>>('spine_region_attachment_update_region');
|
|
late final _spine_region_attachment_update_region = _spine_region_attachment_update_regionPtr
|
|
.asFunction<void Function(spine_region_attachment)>();
|
|
|
|
void spine_region_attachment_compute_world_vertices(
|
|
spine_region_attachment attachment,
|
|
spine_slot slot,
|
|
ffi.Pointer<ffi.Float> worldVertices,
|
|
) {
|
|
return _spine_region_attachment_compute_world_vertices(attachment, slot, worldVertices);
|
|
}
|
|
|
|
late final _spine_region_attachment_compute_world_verticesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, spine_slot, ffi.Pointer<ffi.Float>)>>(
|
|
'spine_region_attachment_compute_world_vertices',
|
|
);
|
|
late final _spine_region_attachment_compute_world_vertices = _spine_region_attachment_compute_world_verticesPtr
|
|
.asFunction<void Function(spine_region_attachment, spine_slot, ffi.Pointer<ffi.Float>)>();
|
|
|
|
double spine_region_attachment_get_x(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_x(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_x');
|
|
late final _spine_region_attachment_get_x = _spine_region_attachment_get_xPtr
|
|
.asFunction<double Function(spine_region_attachment)>();
|
|
|
|
void spine_region_attachment_set_x(spine_region_attachment attachment, double x) {
|
|
return _spine_region_attachment_set_x(attachment, x);
|
|
}
|
|
|
|
late final _spine_region_attachment_set_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
|
|
'spine_region_attachment_set_x',
|
|
);
|
|
late final _spine_region_attachment_set_x = _spine_region_attachment_set_xPtr
|
|
.asFunction<void Function(spine_region_attachment, double)>();
|
|
|
|
double spine_region_attachment_get_y(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_y(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_y');
|
|
late final _spine_region_attachment_get_y = _spine_region_attachment_get_yPtr
|
|
.asFunction<double Function(spine_region_attachment)>();
|
|
|
|
void spine_region_attachment_set_y(spine_region_attachment attachment, double y) {
|
|
return _spine_region_attachment_set_y(attachment, y);
|
|
}
|
|
|
|
late final _spine_region_attachment_set_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
|
|
'spine_region_attachment_set_y',
|
|
);
|
|
late final _spine_region_attachment_set_y = _spine_region_attachment_set_yPtr
|
|
.asFunction<void Function(spine_region_attachment, double)>();
|
|
|
|
double spine_region_attachment_get_rotation(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_rotation(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_rotation');
|
|
late final _spine_region_attachment_get_rotation = _spine_region_attachment_get_rotationPtr
|
|
.asFunction<double Function(spine_region_attachment)>();
|
|
|
|
void spine_region_attachment_set_rotation(spine_region_attachment attachment, double rotation) {
|
|
return _spine_region_attachment_set_rotation(attachment, rotation);
|
|
}
|
|
|
|
late final _spine_region_attachment_set_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
|
|
'spine_region_attachment_set_rotation',
|
|
);
|
|
late final _spine_region_attachment_set_rotation = _spine_region_attachment_set_rotationPtr
|
|
.asFunction<void Function(spine_region_attachment, double)>();
|
|
|
|
double spine_region_attachment_get_scale_x(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_scale_x(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_scale_x');
|
|
late final _spine_region_attachment_get_scale_x = _spine_region_attachment_get_scale_xPtr
|
|
.asFunction<double Function(spine_region_attachment)>();
|
|
|
|
void spine_region_attachment_set_scale_x(spine_region_attachment attachment, double scaleX) {
|
|
return _spine_region_attachment_set_scale_x(attachment, scaleX);
|
|
}
|
|
|
|
late final _spine_region_attachment_set_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
|
|
'spine_region_attachment_set_scale_x',
|
|
);
|
|
late final _spine_region_attachment_set_scale_x = _spine_region_attachment_set_scale_xPtr
|
|
.asFunction<void Function(spine_region_attachment, double)>();
|
|
|
|
double spine_region_attachment_get_scale_y(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_scale_y(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_scale_y');
|
|
late final _spine_region_attachment_get_scale_y = _spine_region_attachment_get_scale_yPtr
|
|
.asFunction<double Function(spine_region_attachment)>();
|
|
|
|
void spine_region_attachment_set_scale_y(spine_region_attachment attachment, double scaleY) {
|
|
return _spine_region_attachment_set_scale_y(attachment, scaleY);
|
|
}
|
|
|
|
late final _spine_region_attachment_set_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
|
|
'spine_region_attachment_set_scale_y',
|
|
);
|
|
late final _spine_region_attachment_set_scale_y = _spine_region_attachment_set_scale_yPtr
|
|
.asFunction<void Function(spine_region_attachment, double)>();
|
|
|
|
double spine_region_attachment_get_width(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_width(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_widthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_width');
|
|
late final _spine_region_attachment_get_width = _spine_region_attachment_get_widthPtr
|
|
.asFunction<double Function(spine_region_attachment)>();
|
|
|
|
void spine_region_attachment_set_width(spine_region_attachment attachment, double width) {
|
|
return _spine_region_attachment_set_width(attachment, width);
|
|
}
|
|
|
|
late final _spine_region_attachment_set_widthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
|
|
'spine_region_attachment_set_width',
|
|
);
|
|
late final _spine_region_attachment_set_width = _spine_region_attachment_set_widthPtr
|
|
.asFunction<void Function(spine_region_attachment, double)>();
|
|
|
|
double spine_region_attachment_get_height(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_height(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_heightPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_region_attachment)>>('spine_region_attachment_get_height');
|
|
late final _spine_region_attachment_get_height = _spine_region_attachment_get_heightPtr
|
|
.asFunction<double Function(spine_region_attachment)>();
|
|
|
|
void spine_region_attachment_set_height(spine_region_attachment attachment, double height) {
|
|
return _spine_region_attachment_set_height(attachment, height);
|
|
}
|
|
|
|
late final _spine_region_attachment_set_heightPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float)>>(
|
|
'spine_region_attachment_set_height',
|
|
);
|
|
late final _spine_region_attachment_set_height = _spine_region_attachment_set_heightPtr
|
|
.asFunction<void Function(spine_region_attachment, double)>();
|
|
|
|
spine_color spine_region_attachment_get_color(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_color(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_colorPtr =
|
|
_lookup<ffi.NativeFunction<spine_color Function(spine_region_attachment)>>('spine_region_attachment_get_color');
|
|
late final _spine_region_attachment_get_color = _spine_region_attachment_get_colorPtr
|
|
.asFunction<spine_color Function(spine_region_attachment)>();
|
|
|
|
void spine_region_attachment_set_color(spine_region_attachment attachment, double r, double g, double b, double a) {
|
|
return _spine_region_attachment_set_color(attachment, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_region_attachment_set_colorPtr =
|
|
_lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_region_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>
|
|
>('spine_region_attachment_set_color');
|
|
late final _spine_region_attachment_set_color = _spine_region_attachment_set_colorPtr
|
|
.asFunction<void Function(spine_region_attachment, double, double, double, double)>();
|
|
|
|
ffi.Pointer<utf8> spine_region_attachment_get_path(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_path(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_pathPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_region_attachment)>>(
|
|
'spine_region_attachment_get_path',
|
|
);
|
|
late final _spine_region_attachment_get_path = _spine_region_attachment_get_pathPtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_region_attachment)>();
|
|
|
|
/// OMITTED setPath()
|
|
spine_texture_region spine_region_attachment_get_region(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_region(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_regionPtr =
|
|
_lookup<ffi.NativeFunction<spine_texture_region Function(spine_region_attachment)>>(
|
|
'spine_region_attachment_get_region',
|
|
);
|
|
late final _spine_region_attachment_get_region = _spine_region_attachment_get_regionPtr
|
|
.asFunction<spine_texture_region Function(spine_region_attachment)>();
|
|
|
|
/// OMITTED setRegion()
|
|
spine_sequence spine_region_attachment_get_sequence(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_sequence(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_sequencePtr =
|
|
_lookup<ffi.NativeFunction<spine_sequence Function(spine_region_attachment)>>(
|
|
'spine_region_attachment_get_sequence',
|
|
);
|
|
late final _spine_region_attachment_get_sequence = _spine_region_attachment_get_sequencePtr
|
|
.asFunction<spine_sequence Function(spine_region_attachment)>();
|
|
|
|
/// OMITTED setSequence()
|
|
int spine_region_attachment_get_num_offset(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_num_offset(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_num_offsetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_region_attachment)>>(
|
|
'spine_region_attachment_get_num_offset',
|
|
);
|
|
late final _spine_region_attachment_get_num_offset = _spine_region_attachment_get_num_offsetPtr
|
|
.asFunction<int Function(spine_region_attachment)>();
|
|
|
|
ffi.Pointer<ffi.Float> spine_region_attachment_get_offset(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_offset(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_offsetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_region_attachment)>>(
|
|
'spine_region_attachment_get_offset',
|
|
);
|
|
late final _spine_region_attachment_get_offset = _spine_region_attachment_get_offsetPtr
|
|
.asFunction<ffi.Pointer<ffi.Float> Function(spine_region_attachment)>();
|
|
|
|
int spine_region_attachment_get_num_uvs(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_num_uvs(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_num_uvsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_region_attachment)>>('spine_region_attachment_get_num_uvs');
|
|
late final _spine_region_attachment_get_num_uvs = _spine_region_attachment_get_num_uvsPtr
|
|
.asFunction<int Function(spine_region_attachment)>();
|
|
|
|
ffi.Pointer<ffi.Float> spine_region_attachment_get_uvs(spine_region_attachment attachment) {
|
|
return _spine_region_attachment_get_uvs(attachment);
|
|
}
|
|
|
|
late final _spine_region_attachment_get_uvsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_region_attachment)>>(
|
|
'spine_region_attachment_get_uvs',
|
|
);
|
|
late final _spine_region_attachment_get_uvs = _spine_region_attachment_get_uvsPtr
|
|
.asFunction<ffi.Pointer<ffi.Float> Function(spine_region_attachment)>();
|
|
|
|
int spine_vertex_attachment_get_world_vertices_length(spine_vertex_attachment attachment) {
|
|
return _spine_vertex_attachment_get_world_vertices_length(attachment);
|
|
}
|
|
|
|
late final _spine_vertex_attachment_get_world_vertices_lengthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_vertex_attachment)>>(
|
|
'spine_vertex_attachment_get_world_vertices_length',
|
|
);
|
|
late final _spine_vertex_attachment_get_world_vertices_length = _spine_vertex_attachment_get_world_vertices_lengthPtr
|
|
.asFunction<int Function(spine_vertex_attachment)>();
|
|
|
|
void spine_vertex_attachment_compute_world_vertices(
|
|
spine_vertex_attachment attachment,
|
|
spine_slot slot,
|
|
ffi.Pointer<ffi.Float> worldVertices,
|
|
) {
|
|
return _spine_vertex_attachment_compute_world_vertices(attachment, slot, worldVertices);
|
|
}
|
|
|
|
late final _spine_vertex_attachment_compute_world_verticesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment, spine_slot, ffi.Pointer<ffi.Float>)>>(
|
|
'spine_vertex_attachment_compute_world_vertices',
|
|
);
|
|
late final _spine_vertex_attachment_compute_world_vertices = _spine_vertex_attachment_compute_world_verticesPtr
|
|
.asFunction<void Function(spine_vertex_attachment, spine_slot, ffi.Pointer<ffi.Float>)>();
|
|
|
|
/// OMITTED getId()
|
|
int spine_vertex_attachment_get_num_bones(spine_vertex_attachment attachment) {
|
|
return _spine_vertex_attachment_get_num_bones(attachment);
|
|
}
|
|
|
|
late final _spine_vertex_attachment_get_num_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_vertex_attachment)>>('spine_vertex_attachment_get_num_bones');
|
|
late final _spine_vertex_attachment_get_num_bones = _spine_vertex_attachment_get_num_bonesPtr
|
|
.asFunction<int Function(spine_vertex_attachment)>();
|
|
|
|
ffi.Pointer<ffi.Int32> spine_vertex_attachment_get_bones(spine_vertex_attachment attachment) {
|
|
return _spine_vertex_attachment_get_bones(attachment);
|
|
}
|
|
|
|
late final _spine_vertex_attachment_get_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Int32> Function(spine_vertex_attachment)>>(
|
|
'spine_vertex_attachment_get_bones',
|
|
);
|
|
late final _spine_vertex_attachment_get_bones = _spine_vertex_attachment_get_bonesPtr
|
|
.asFunction<ffi.Pointer<ffi.Int32> Function(spine_vertex_attachment)>();
|
|
|
|
int spine_vertex_attachment_get_num_vertices(spine_vertex_attachment attachment) {
|
|
return _spine_vertex_attachment_get_num_vertices(attachment);
|
|
}
|
|
|
|
late final _spine_vertex_attachment_get_num_verticesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_vertex_attachment)>>(
|
|
'spine_vertex_attachment_get_num_vertices',
|
|
);
|
|
late final _spine_vertex_attachment_get_num_vertices = _spine_vertex_attachment_get_num_verticesPtr
|
|
.asFunction<int Function(spine_vertex_attachment)>();
|
|
|
|
ffi.Pointer<ffi.Float> spine_vertex_attachment_get_vertices(spine_vertex_attachment attachment) {
|
|
return _spine_vertex_attachment_get_vertices(attachment);
|
|
}
|
|
|
|
late final _spine_vertex_attachment_get_verticesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_vertex_attachment)>>(
|
|
'spine_vertex_attachment_get_vertices',
|
|
);
|
|
late final _spine_vertex_attachment_get_vertices = _spine_vertex_attachment_get_verticesPtr
|
|
.asFunction<ffi.Pointer<ffi.Float> Function(spine_vertex_attachment)>();
|
|
|
|
spine_attachment spine_vertex_attachment_get_timeline_attachment(spine_vertex_attachment timelineAttachment) {
|
|
return _spine_vertex_attachment_get_timeline_attachment(timelineAttachment);
|
|
}
|
|
|
|
late final _spine_vertex_attachment_get_timeline_attachmentPtr =
|
|
_lookup<ffi.NativeFunction<spine_attachment Function(spine_vertex_attachment)>>(
|
|
'spine_vertex_attachment_get_timeline_attachment',
|
|
);
|
|
late final _spine_vertex_attachment_get_timeline_attachment = _spine_vertex_attachment_get_timeline_attachmentPtr
|
|
.asFunction<spine_attachment Function(spine_vertex_attachment)>();
|
|
|
|
void spine_vertex_attachment_set_timeline_attachment(
|
|
spine_vertex_attachment attachment,
|
|
spine_attachment timelineAttachment,
|
|
) {
|
|
return _spine_vertex_attachment_set_timeline_attachment(attachment, timelineAttachment);
|
|
}
|
|
|
|
late final _spine_vertex_attachment_set_timeline_attachmentPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_vertex_attachment, spine_attachment)>>(
|
|
'spine_vertex_attachment_set_timeline_attachment',
|
|
);
|
|
late final _spine_vertex_attachment_set_timeline_attachment = _spine_vertex_attachment_set_timeline_attachmentPtr
|
|
.asFunction<void Function(spine_vertex_attachment, spine_attachment)>();
|
|
|
|
/// OMITTED copyTo()
|
|
void spine_mesh_attachment_update_region(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_update_region(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_update_regionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment)>>('spine_mesh_attachment_update_region');
|
|
late final _spine_mesh_attachment_update_region = _spine_mesh_attachment_update_regionPtr
|
|
.asFunction<void Function(spine_mesh_attachment)>();
|
|
|
|
int spine_mesh_attachment_get_hull_length(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_hull_length(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_hull_lengthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_hull_length');
|
|
late final _spine_mesh_attachment_get_hull_length = _spine_mesh_attachment_get_hull_lengthPtr
|
|
.asFunction<int Function(spine_mesh_attachment)>();
|
|
|
|
void spine_mesh_attachment_set_hull_length(spine_mesh_attachment attachment, int hullLength) {
|
|
return _spine_mesh_attachment_set_hull_length(attachment, hullLength);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_set_hull_lengthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Int32)>>(
|
|
'spine_mesh_attachment_set_hull_length',
|
|
);
|
|
late final _spine_mesh_attachment_set_hull_length = _spine_mesh_attachment_set_hull_lengthPtr
|
|
.asFunction<void Function(spine_mesh_attachment, int)>();
|
|
|
|
int spine_mesh_attachment_get_num_region_uvs(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_num_region_uvs(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_num_region_uvsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_mesh_attachment)>>(
|
|
'spine_mesh_attachment_get_num_region_uvs',
|
|
);
|
|
late final _spine_mesh_attachment_get_num_region_uvs = _spine_mesh_attachment_get_num_region_uvsPtr
|
|
.asFunction<int Function(spine_mesh_attachment)>();
|
|
|
|
ffi.Pointer<ffi.Float> spine_mesh_attachment_get_region_uvs(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_region_uvs(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_region_uvsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_mesh_attachment)>>(
|
|
'spine_mesh_attachment_get_region_uvs',
|
|
);
|
|
late final _spine_mesh_attachment_get_region_uvs = _spine_mesh_attachment_get_region_uvsPtr
|
|
.asFunction<ffi.Pointer<ffi.Float> Function(spine_mesh_attachment)>();
|
|
|
|
int spine_mesh_attachment_get_num_uvs(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_num_uvs(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_num_uvsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_num_uvs');
|
|
late final _spine_mesh_attachment_get_num_uvs = _spine_mesh_attachment_get_num_uvsPtr
|
|
.asFunction<int Function(spine_mesh_attachment)>();
|
|
|
|
ffi.Pointer<ffi.Float> spine_mesh_attachment_get_uvs(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_uvs(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_uvsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_mesh_attachment)>>(
|
|
'spine_mesh_attachment_get_uvs',
|
|
);
|
|
late final _spine_mesh_attachment_get_uvs = _spine_mesh_attachment_get_uvsPtr
|
|
.asFunction<ffi.Pointer<ffi.Float> Function(spine_mesh_attachment)>();
|
|
|
|
int spine_mesh_attachment_get_num_triangles(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_num_triangles(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_num_trianglesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_num_triangles');
|
|
late final _spine_mesh_attachment_get_num_triangles = _spine_mesh_attachment_get_num_trianglesPtr
|
|
.asFunction<int Function(spine_mesh_attachment)>();
|
|
|
|
ffi.Pointer<ffi.Uint16> spine_mesh_attachment_get_triangles(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_triangles(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_trianglesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint16> Function(spine_mesh_attachment)>>(
|
|
'spine_mesh_attachment_get_triangles',
|
|
);
|
|
late final _spine_mesh_attachment_get_triangles = _spine_mesh_attachment_get_trianglesPtr
|
|
.asFunction<ffi.Pointer<ffi.Uint16> Function(spine_mesh_attachment)>();
|
|
|
|
spine_color spine_mesh_attachment_get_color(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_color(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_colorPtr =
|
|
_lookup<ffi.NativeFunction<spine_color Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_color');
|
|
late final _spine_mesh_attachment_get_color = _spine_mesh_attachment_get_colorPtr
|
|
.asFunction<spine_color Function(spine_mesh_attachment)>();
|
|
|
|
void spine_mesh_attachment_set_color(spine_mesh_attachment attachment, double r, double g, double b, double a) {
|
|
return _spine_mesh_attachment_set_color(attachment, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_set_colorPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
|
|
'spine_mesh_attachment_set_color',
|
|
);
|
|
late final _spine_mesh_attachment_set_color = _spine_mesh_attachment_set_colorPtr
|
|
.asFunction<void Function(spine_mesh_attachment, double, double, double, double)>();
|
|
|
|
ffi.Pointer<utf8> spine_mesh_attachment_get_path(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_path(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_pathPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_path');
|
|
late final _spine_mesh_attachment_get_path = _spine_mesh_attachment_get_pathPtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_mesh_attachment)>();
|
|
|
|
/// OMITTED setPath()
|
|
spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_region(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_regionPtr =
|
|
_lookup<ffi.NativeFunction<spine_texture_region Function(spine_mesh_attachment)>>(
|
|
'spine_mesh_attachment_get_region',
|
|
);
|
|
late final _spine_mesh_attachment_get_region = _spine_mesh_attachment_get_regionPtr
|
|
.asFunction<spine_texture_region Function(spine_mesh_attachment)>();
|
|
|
|
/// OMITTED setRegion()
|
|
spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_sequence(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_sequencePtr =
|
|
_lookup<ffi.NativeFunction<spine_sequence Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_sequence');
|
|
late final _spine_mesh_attachment_get_sequence = _spine_mesh_attachment_get_sequencePtr
|
|
.asFunction<spine_sequence Function(spine_mesh_attachment)>();
|
|
|
|
/// OMITTED setSequence()
|
|
spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_parent_mesh(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_parent_meshPtr =
|
|
_lookup<ffi.NativeFunction<spine_mesh_attachment Function(spine_mesh_attachment)>>(
|
|
'spine_mesh_attachment_get_parent_mesh',
|
|
);
|
|
late final _spine_mesh_attachment_get_parent_mesh = _spine_mesh_attachment_get_parent_meshPtr
|
|
.asFunction<spine_mesh_attachment Function(spine_mesh_attachment)>();
|
|
|
|
void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment attachment, spine_mesh_attachment parentMesh) {
|
|
return _spine_mesh_attachment_set_parent_mesh(attachment, parentMesh);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_set_parent_meshPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, spine_mesh_attachment)>>(
|
|
'spine_mesh_attachment_set_parent_mesh',
|
|
);
|
|
late final _spine_mesh_attachment_set_parent_mesh = _spine_mesh_attachment_set_parent_meshPtr
|
|
.asFunction<void Function(spine_mesh_attachment, spine_mesh_attachment)>();
|
|
|
|
int spine_mesh_attachment_get_num_edges(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_num_edges(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_num_edgesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_num_edges');
|
|
late final _spine_mesh_attachment_get_num_edges = _spine_mesh_attachment_get_num_edgesPtr
|
|
.asFunction<int Function(spine_mesh_attachment)>();
|
|
|
|
ffi.Pointer<ffi.Uint16> spine_mesh_attachment_get_edges(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_edges(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_edgesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint16> Function(spine_mesh_attachment)>>(
|
|
'spine_mesh_attachment_get_edges',
|
|
);
|
|
late final _spine_mesh_attachment_get_edges = _spine_mesh_attachment_get_edgesPtr
|
|
.asFunction<ffi.Pointer<ffi.Uint16> Function(spine_mesh_attachment)>();
|
|
|
|
double spine_mesh_attachment_get_width(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_width(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_widthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_width');
|
|
late final _spine_mesh_attachment_get_width = _spine_mesh_attachment_get_widthPtr
|
|
.asFunction<double Function(spine_mesh_attachment)>();
|
|
|
|
void spine_mesh_attachment_set_width(spine_mesh_attachment attachment, double width) {
|
|
return _spine_mesh_attachment_set_width(attachment, width);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_set_widthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Float)>>(
|
|
'spine_mesh_attachment_set_width',
|
|
);
|
|
late final _spine_mesh_attachment_set_width = _spine_mesh_attachment_set_widthPtr
|
|
.asFunction<void Function(spine_mesh_attachment, double)>();
|
|
|
|
double spine_mesh_attachment_get_height(spine_mesh_attachment attachment) {
|
|
return _spine_mesh_attachment_get_height(attachment);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_get_heightPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_mesh_attachment)>>('spine_mesh_attachment_get_height');
|
|
late final _spine_mesh_attachment_get_height = _spine_mesh_attachment_get_heightPtr
|
|
.asFunction<double Function(spine_mesh_attachment)>();
|
|
|
|
void spine_mesh_attachment_set_height(spine_mesh_attachment attachment, double height) {
|
|
return _spine_mesh_attachment_set_height(attachment, height);
|
|
}
|
|
|
|
late final _spine_mesh_attachment_set_heightPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_mesh_attachment, ffi.Float)>>(
|
|
'spine_mesh_attachment_set_height',
|
|
);
|
|
late final _spine_mesh_attachment_set_height = _spine_mesh_attachment_set_heightPtr
|
|
.asFunction<void Function(spine_mesh_attachment, double)>();
|
|
|
|
/// OMITTED newLinkedMesh()
|
|
spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment attachment) {
|
|
return _spine_clipping_attachment_get_end_slot(attachment);
|
|
}
|
|
|
|
late final _spine_clipping_attachment_get_end_slotPtr =
|
|
_lookup<ffi.NativeFunction<spine_slot_data Function(spine_clipping_attachment)>>(
|
|
'spine_clipping_attachment_get_end_slot',
|
|
);
|
|
late final _spine_clipping_attachment_get_end_slot = _spine_clipping_attachment_get_end_slotPtr
|
|
.asFunction<spine_slot_data Function(spine_clipping_attachment)>();
|
|
|
|
void spine_clipping_attachment_set_end_slot(spine_clipping_attachment attachment, spine_slot_data endSlot) {
|
|
return _spine_clipping_attachment_set_end_slot(attachment, endSlot);
|
|
}
|
|
|
|
late final _spine_clipping_attachment_set_end_slotPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment, spine_slot_data)>>(
|
|
'spine_clipping_attachment_set_end_slot',
|
|
);
|
|
late final _spine_clipping_attachment_set_end_slot = _spine_clipping_attachment_set_end_slotPtr
|
|
.asFunction<void Function(spine_clipping_attachment, spine_slot_data)>();
|
|
|
|
spine_color spine_clipping_attachment_get_color(spine_clipping_attachment attachment) {
|
|
return _spine_clipping_attachment_get_color(attachment);
|
|
}
|
|
|
|
late final _spine_clipping_attachment_get_colorPtr =
|
|
_lookup<ffi.NativeFunction<spine_color Function(spine_clipping_attachment)>>(
|
|
'spine_clipping_attachment_get_color',
|
|
);
|
|
late final _spine_clipping_attachment_get_color = _spine_clipping_attachment_get_colorPtr
|
|
.asFunction<spine_color Function(spine_clipping_attachment)>();
|
|
|
|
void spine_clipping_attachment_set_color(
|
|
spine_clipping_attachment attachment,
|
|
double r,
|
|
double g,
|
|
double b,
|
|
double a,
|
|
) {
|
|
return _spine_clipping_attachment_set_color(attachment, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_clipping_attachment_set_colorPtr =
|
|
_lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_clipping_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>
|
|
>('spine_clipping_attachment_set_color');
|
|
late final _spine_clipping_attachment_set_color = _spine_clipping_attachment_set_colorPtr
|
|
.asFunction<void Function(spine_clipping_attachment, double, double, double, double)>();
|
|
|
|
spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment attachment) {
|
|
return _spine_bounding_box_attachment_get_color(attachment);
|
|
}
|
|
|
|
late final _spine_bounding_box_attachment_get_colorPtr =
|
|
_lookup<ffi.NativeFunction<spine_color Function(spine_bounding_box_attachment)>>(
|
|
'spine_bounding_box_attachment_get_color',
|
|
);
|
|
late final _spine_bounding_box_attachment_get_color = _spine_bounding_box_attachment_get_colorPtr
|
|
.asFunction<spine_color Function(spine_bounding_box_attachment)>();
|
|
|
|
void spine_bounding_box_attachment_set_color(
|
|
spine_bounding_box_attachment attachment,
|
|
double r,
|
|
double g,
|
|
double b,
|
|
double a,
|
|
) {
|
|
return _spine_bounding_box_attachment_set_color(attachment, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_bounding_box_attachment_set_colorPtr =
|
|
_lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_bounding_box_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>
|
|
>('spine_bounding_box_attachment_set_color');
|
|
late final _spine_bounding_box_attachment_set_color = _spine_bounding_box_attachment_set_colorPtr
|
|
.asFunction<void Function(spine_bounding_box_attachment, double, double, double, double)>();
|
|
|
|
int spine_path_attachment_get_num_lengths(spine_path_attachment attachment) {
|
|
return _spine_path_attachment_get_num_lengths(attachment);
|
|
}
|
|
|
|
late final _spine_path_attachment_get_num_lengthsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_attachment)>>('spine_path_attachment_get_num_lengths');
|
|
late final _spine_path_attachment_get_num_lengths = _spine_path_attachment_get_num_lengthsPtr
|
|
.asFunction<int Function(spine_path_attachment)>();
|
|
|
|
ffi.Pointer<ffi.Float> spine_path_attachment_get_lengths(spine_path_attachment attachment) {
|
|
return _spine_path_attachment_get_lengths(attachment);
|
|
}
|
|
|
|
late final _spine_path_attachment_get_lengthsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Float> Function(spine_path_attachment)>>(
|
|
'spine_path_attachment_get_lengths',
|
|
);
|
|
late final _spine_path_attachment_get_lengths = _spine_path_attachment_get_lengthsPtr
|
|
.asFunction<ffi.Pointer<ffi.Float> Function(spine_path_attachment)>();
|
|
|
|
int spine_path_attachment_get_is_closed(spine_path_attachment attachment) {
|
|
return _spine_path_attachment_get_is_closed(attachment);
|
|
}
|
|
|
|
late final _spine_path_attachment_get_is_closedPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_path_attachment)>>('spine_path_attachment_get_is_closed');
|
|
late final _spine_path_attachment_get_is_closed = _spine_path_attachment_get_is_closedPtr
|
|
.asFunction<int Function(spine_path_attachment)>();
|
|
|
|
void spine_path_attachment_set_is_closed(spine_path_attachment attachment, int isClosed) {
|
|
return _spine_path_attachment_set_is_closed(attachment, isClosed);
|
|
}
|
|
|
|
late final _spine_path_attachment_set_is_closedPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, spine_bool)>>(
|
|
'spine_path_attachment_set_is_closed',
|
|
);
|
|
late final _spine_path_attachment_set_is_closed = _spine_path_attachment_set_is_closedPtr
|
|
.asFunction<void Function(spine_path_attachment, int)>();
|
|
|
|
int spine_path_attachment_get_is_constant_speed(spine_path_attachment attachment) {
|
|
return _spine_path_attachment_get_is_constant_speed(attachment);
|
|
}
|
|
|
|
late final _spine_path_attachment_get_is_constant_speedPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_path_attachment)>>(
|
|
'spine_path_attachment_get_is_constant_speed',
|
|
);
|
|
late final _spine_path_attachment_get_is_constant_speed = _spine_path_attachment_get_is_constant_speedPtr
|
|
.asFunction<int Function(spine_path_attachment)>();
|
|
|
|
void spine_path_attachment_set_is_constant_speed(spine_path_attachment attachment, int isConstantSpeed) {
|
|
return _spine_path_attachment_set_is_constant_speed(attachment, isConstantSpeed);
|
|
}
|
|
|
|
late final _spine_path_attachment_set_is_constant_speedPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, spine_bool)>>(
|
|
'spine_path_attachment_set_is_constant_speed',
|
|
);
|
|
late final _spine_path_attachment_set_is_constant_speed = _spine_path_attachment_set_is_constant_speedPtr
|
|
.asFunction<void Function(spine_path_attachment, int)>();
|
|
|
|
spine_color spine_path_attachment_get_color(spine_path_attachment attachment) {
|
|
return _spine_path_attachment_get_color(attachment);
|
|
}
|
|
|
|
late final _spine_path_attachment_get_colorPtr =
|
|
_lookup<ffi.NativeFunction<spine_color Function(spine_path_attachment)>>('spine_path_attachment_get_color');
|
|
late final _spine_path_attachment_get_color = _spine_path_attachment_get_colorPtr
|
|
.asFunction<spine_color Function(spine_path_attachment)>();
|
|
|
|
void spine_path_attachment_set_color(spine_path_attachment attachment, double r, double g, double b, double a) {
|
|
return _spine_path_attachment_set_color(attachment, r, g, b, a);
|
|
}
|
|
|
|
late final _spine_path_attachment_set_colorPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_attachment, ffi.Float, ffi.Float, ffi.Float, ffi.Float)>>(
|
|
'spine_path_attachment_set_color',
|
|
);
|
|
late final _spine_path_attachment_set_color = _spine_path_attachment_set_colorPtr
|
|
.asFunction<void Function(spine_path_attachment, double, double, double, double)>();
|
|
|
|
void spine_skin_set_attachment(spine_skin skin, int slotIndex, ffi.Pointer<utf8> name, spine_attachment attachment) {
|
|
return _spine_skin_set_attachment(skin, slotIndex, name, attachment);
|
|
}
|
|
|
|
late final _spine_skin_set_attachmentPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, ffi.Int32, ffi.Pointer<utf8>, spine_attachment)>>(
|
|
'spine_skin_set_attachment',
|
|
);
|
|
late final _spine_skin_set_attachment = _spine_skin_set_attachmentPtr
|
|
.asFunction<void Function(spine_skin, int, ffi.Pointer<utf8>, spine_attachment)>();
|
|
|
|
spine_attachment spine_skin_get_attachment(spine_skin skin, int slotIndex, ffi.Pointer<utf8> name) {
|
|
return _spine_skin_get_attachment(skin, slotIndex, name);
|
|
}
|
|
|
|
late final _spine_skin_get_attachmentPtr =
|
|
_lookup<ffi.NativeFunction<spine_attachment Function(spine_skin, ffi.Int32, ffi.Pointer<utf8>)>>(
|
|
'spine_skin_get_attachment',
|
|
);
|
|
late final _spine_skin_get_attachment = _spine_skin_get_attachmentPtr
|
|
.asFunction<spine_attachment Function(spine_skin, int, ffi.Pointer<utf8>)>();
|
|
|
|
void spine_skin_remove_attachment(spine_skin skin, int slotIndex, ffi.Pointer<utf8> name) {
|
|
return _spine_skin_remove_attachment(skin, slotIndex, name);
|
|
}
|
|
|
|
late final _spine_skin_remove_attachmentPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, ffi.Int32, ffi.Pointer<utf8>)>>(
|
|
'spine_skin_remove_attachment',
|
|
);
|
|
late final _spine_skin_remove_attachment = _spine_skin_remove_attachmentPtr
|
|
.asFunction<void Function(spine_skin, int, ffi.Pointer<utf8>)>();
|
|
|
|
/// OMITTED findNamesForSlot()
|
|
/// OMITTED findAttachmentsForSlot()
|
|
/// OMITTED getColor()
|
|
ffi.Pointer<utf8> spine_skin_get_name(spine_skin skin) {
|
|
return _spine_skin_get_name(skin);
|
|
}
|
|
|
|
late final _spine_skin_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skin)>>(
|
|
'spine_skin_get_name',
|
|
);
|
|
late final _spine_skin_get_name = _spine_skin_get_namePtr.asFunction<ffi.Pointer<utf8> Function(spine_skin)>();
|
|
|
|
void spine_skin_add_skin(spine_skin skin, spine_skin other) {
|
|
return _spine_skin_add_skin(skin, other);
|
|
}
|
|
|
|
late final _spine_skin_add_skinPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, spine_skin)>>(
|
|
'spine_skin_add_skin',
|
|
);
|
|
late final _spine_skin_add_skin = _spine_skin_add_skinPtr.asFunction<void Function(spine_skin, spine_skin)>();
|
|
|
|
void spine_skin_copy_skin(spine_skin skin, spine_skin other) {
|
|
return _spine_skin_copy_skin(skin, other);
|
|
}
|
|
|
|
late final _spine_skin_copy_skinPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin, spine_skin)>>(
|
|
'spine_skin_copy_skin',
|
|
);
|
|
late final _spine_skin_copy_skin = _spine_skin_copy_skinPtr.asFunction<void Function(spine_skin, spine_skin)>();
|
|
|
|
spine_skin_entries spine_skin_get_entries(spine_skin skin) {
|
|
return _spine_skin_get_entries(skin);
|
|
}
|
|
|
|
late final _spine_skin_get_entriesPtr = _lookup<ffi.NativeFunction<spine_skin_entries Function(spine_skin)>>(
|
|
'spine_skin_get_entries',
|
|
);
|
|
late final _spine_skin_get_entries = _spine_skin_get_entriesPtr.asFunction<spine_skin_entries Function(spine_skin)>();
|
|
|
|
int spine_skin_entries_get_num_entries(spine_skin_entries entries) {
|
|
return _spine_skin_entries_get_num_entries(entries);
|
|
}
|
|
|
|
late final _spine_skin_entries_get_num_entriesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skin_entries)>>('spine_skin_entries_get_num_entries');
|
|
late final _spine_skin_entries_get_num_entries = _spine_skin_entries_get_num_entriesPtr
|
|
.asFunction<int Function(spine_skin_entries)>();
|
|
|
|
spine_skin_entry spine_skin_entries_get_entry(spine_skin_entries entries, int index) {
|
|
return _spine_skin_entries_get_entry(entries, index);
|
|
}
|
|
|
|
late final _spine_skin_entries_get_entryPtr =
|
|
_lookup<ffi.NativeFunction<spine_skin_entry Function(spine_skin_entries, ffi.Int32)>>(
|
|
'spine_skin_entries_get_entry',
|
|
);
|
|
late final _spine_skin_entries_get_entry = _spine_skin_entries_get_entryPtr
|
|
.asFunction<spine_skin_entry Function(spine_skin_entries, int)>();
|
|
|
|
void spine_skin_entries_dispose(spine_skin_entries entries) {
|
|
return _spine_skin_entries_dispose(entries);
|
|
}
|
|
|
|
late final _spine_skin_entries_disposePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin_entries)>>(
|
|
'spine_skin_entries_dispose',
|
|
);
|
|
late final _spine_skin_entries_dispose = _spine_skin_entries_disposePtr
|
|
.asFunction<void Function(spine_skin_entries)>();
|
|
|
|
int spine_skin_entry_get_slot_index(spine_skin_entry entry) {
|
|
return _spine_skin_entry_get_slot_index(entry);
|
|
}
|
|
|
|
late final _spine_skin_entry_get_slot_indexPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skin_entry)>>(
|
|
'spine_skin_entry_get_slot_index',
|
|
);
|
|
late final _spine_skin_entry_get_slot_index = _spine_skin_entry_get_slot_indexPtr
|
|
.asFunction<int Function(spine_skin_entry)>();
|
|
|
|
ffi.Pointer<utf8> spine_skin_entry_get_name(spine_skin_entry entry) {
|
|
return _spine_skin_entry_get_name(entry);
|
|
}
|
|
|
|
late final _spine_skin_entry_get_namePtr = _lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_skin_entry)>>(
|
|
'spine_skin_entry_get_name',
|
|
);
|
|
late final _spine_skin_entry_get_name = _spine_skin_entry_get_namePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_skin_entry)>();
|
|
|
|
spine_attachment spine_skin_entry_get_attachment(spine_skin_entry entry) {
|
|
return _spine_skin_entry_get_attachment(entry);
|
|
}
|
|
|
|
late final _spine_skin_entry_get_attachmentPtr =
|
|
_lookup<ffi.NativeFunction<spine_attachment Function(spine_skin_entry)>>('spine_skin_entry_get_attachment');
|
|
late final _spine_skin_entry_get_attachment = _spine_skin_entry_get_attachmentPtr
|
|
.asFunction<spine_attachment Function(spine_skin_entry)>();
|
|
|
|
int spine_skin_get_num_bones(spine_skin skin) {
|
|
return _spine_skin_get_num_bones(skin);
|
|
}
|
|
|
|
late final _spine_skin_get_num_bonesPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skin)>>(
|
|
'spine_skin_get_num_bones',
|
|
);
|
|
late final _spine_skin_get_num_bones = _spine_skin_get_num_bonesPtr.asFunction<int Function(spine_skin)>();
|
|
|
|
ffi.Pointer<spine_bone_data> spine_skin_get_bones(spine_skin skin) {
|
|
return _spine_skin_get_bones(skin);
|
|
}
|
|
|
|
late final _spine_skin_get_bonesPtr = _lookup<ffi.NativeFunction<ffi.Pointer<spine_bone_data> Function(spine_skin)>>(
|
|
'spine_skin_get_bones',
|
|
);
|
|
late final _spine_skin_get_bones = _spine_skin_get_bonesPtr
|
|
.asFunction<ffi.Pointer<spine_bone_data> Function(spine_skin)>();
|
|
|
|
int spine_skin_get_num_constraints(spine_skin skin) {
|
|
return _spine_skin_get_num_constraints(skin);
|
|
}
|
|
|
|
late final _spine_skin_get_num_constraintsPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skin)>>(
|
|
'spine_skin_get_num_constraints',
|
|
);
|
|
late final _spine_skin_get_num_constraints = _spine_skin_get_num_constraintsPtr
|
|
.asFunction<int Function(spine_skin)>();
|
|
|
|
ffi.Pointer<spine_constraint_data> spine_skin_get_constraints(spine_skin skin) {
|
|
return _spine_skin_get_constraints(skin);
|
|
}
|
|
|
|
late final _spine_skin_get_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_constraint_data> Function(spine_skin)>>(
|
|
'spine_skin_get_constraints',
|
|
);
|
|
late final _spine_skin_get_constraints = _spine_skin_get_constraintsPtr
|
|
.asFunction<ffi.Pointer<spine_constraint_data> Function(spine_skin)>();
|
|
|
|
spine_skin spine_skin_create(ffi.Pointer<utf8> name) {
|
|
return _spine_skin_create(name);
|
|
}
|
|
|
|
late final _spine_skin_createPtr = _lookup<ffi.NativeFunction<spine_skin Function(ffi.Pointer<utf8>)>>(
|
|
'spine_skin_create',
|
|
);
|
|
late final _spine_skin_create = _spine_skin_createPtr.asFunction<spine_skin Function(ffi.Pointer<utf8>)>();
|
|
|
|
void spine_skin_dispose(spine_skin skin) {
|
|
return _spine_skin_dispose(skin);
|
|
}
|
|
|
|
late final _spine_skin_disposePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_skin)>>('spine_skin_dispose');
|
|
late final _spine_skin_dispose = _spine_skin_disposePtr.asFunction<void Function(spine_skin)>();
|
|
|
|
int spine_constraint_data_get_type(spine_constraint_data data) {
|
|
return _spine_constraint_data_get_type(data);
|
|
}
|
|
|
|
late final _spine_constraint_data_get_typePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_constraint_data)>>('spine_constraint_data_get_type');
|
|
late final _spine_constraint_data_get_type = _spine_constraint_data_get_typePtr
|
|
.asFunction<int Function(spine_constraint_data)>();
|
|
|
|
ffi.Pointer<utf8> spine_constraint_data_get_name(spine_constraint_data data) {
|
|
return _spine_constraint_data_get_name(data);
|
|
}
|
|
|
|
late final _spine_constraint_data_get_namePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_constraint_data)>>('spine_constraint_data_get_name');
|
|
late final _spine_constraint_data_get_name = _spine_constraint_data_get_namePtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_constraint_data)>();
|
|
|
|
int spine_constraint_data_get_order(spine_constraint_data data) {
|
|
return _spine_constraint_data_get_order(data);
|
|
}
|
|
|
|
late final _spine_constraint_data_get_orderPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Uint64 Function(spine_constraint_data)>>('spine_constraint_data_get_order');
|
|
late final _spine_constraint_data_get_order = _spine_constraint_data_get_orderPtr
|
|
.asFunction<int Function(spine_constraint_data)>();
|
|
|
|
void spine_constraint_data_set_order(spine_constraint_data data, int order) {
|
|
return _spine_constraint_data_set_order(data, order);
|
|
}
|
|
|
|
late final _spine_constraint_data_set_orderPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_data, ffi.Uint64)>>(
|
|
'spine_constraint_data_set_order',
|
|
);
|
|
late final _spine_constraint_data_set_order = _spine_constraint_data_set_orderPtr
|
|
.asFunction<void Function(spine_constraint_data, int)>();
|
|
|
|
int spine_constraint_data_get_is_skin_required(spine_constraint_data data) {
|
|
return _spine_constraint_data_get_is_skin_required(data);
|
|
}
|
|
|
|
late final _spine_constraint_data_get_is_skin_requiredPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_constraint_data)>>(
|
|
'spine_constraint_data_get_is_skin_required',
|
|
);
|
|
late final _spine_constraint_data_get_is_skin_required = _spine_constraint_data_get_is_skin_requiredPtr
|
|
.asFunction<int Function(spine_constraint_data)>();
|
|
|
|
void spine_constraint_data_set_is_skin_required(spine_constraint_data data, int isSkinRequired) {
|
|
return _spine_constraint_data_set_is_skin_required(data, isSkinRequired);
|
|
}
|
|
|
|
late final _spine_constraint_data_set_is_skin_requiredPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_constraint_data, spine_bool)>>(
|
|
'spine_constraint_data_set_is_skin_required',
|
|
);
|
|
late final _spine_constraint_data_set_is_skin_required = _spine_constraint_data_set_is_skin_requiredPtr
|
|
.asFunction<void Function(spine_constraint_data, int)>();
|
|
|
|
int spine_ik_constraint_data_get_num_bones(spine_ik_constraint_data data) {
|
|
return _spine_ik_constraint_data_get_num_bones(data);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_get_num_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint_data)>>(
|
|
'spine_ik_constraint_data_get_num_bones',
|
|
);
|
|
late final _spine_ik_constraint_data_get_num_bones = _spine_ik_constraint_data_get_num_bonesPtr
|
|
.asFunction<int Function(spine_ik_constraint_data)>();
|
|
|
|
ffi.Pointer<spine_bone_data> spine_ik_constraint_data_get_bones(spine_ik_constraint_data data) {
|
|
return _spine_ik_constraint_data_get_bones(data);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_get_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_bone_data> Function(spine_ik_constraint_data)>>(
|
|
'spine_ik_constraint_data_get_bones',
|
|
);
|
|
late final _spine_ik_constraint_data_get_bones = _spine_ik_constraint_data_get_bonesPtr
|
|
.asFunction<ffi.Pointer<spine_bone_data> Function(spine_ik_constraint_data)>();
|
|
|
|
spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data data) {
|
|
return _spine_ik_constraint_data_get_target(data);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_get_targetPtr =
|
|
_lookup<ffi.NativeFunction<spine_bone_data Function(spine_ik_constraint_data)>>(
|
|
'spine_ik_constraint_data_get_target',
|
|
);
|
|
late final _spine_ik_constraint_data_get_target = _spine_ik_constraint_data_get_targetPtr
|
|
.asFunction<spine_bone_data Function(spine_ik_constraint_data)>();
|
|
|
|
void spine_ik_constraint_data_set_target(spine_ik_constraint_data data, spine_bone_data target) {
|
|
return _spine_ik_constraint_data_set_target(data, target);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_set_targetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, spine_bone_data)>>(
|
|
'spine_ik_constraint_data_set_target',
|
|
);
|
|
late final _spine_ik_constraint_data_set_target = _spine_ik_constraint_data_set_targetPtr
|
|
.asFunction<void Function(spine_ik_constraint_data, spine_bone_data)>();
|
|
|
|
int spine_ik_constraint_data_get_bend_direction(spine_ik_constraint_data data) {
|
|
return _spine_ik_constraint_data_get_bend_direction(data);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_get_bend_directionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint_data)>>(
|
|
'spine_ik_constraint_data_get_bend_direction',
|
|
);
|
|
late final _spine_ik_constraint_data_get_bend_direction = _spine_ik_constraint_data_get_bend_directionPtr
|
|
.asFunction<int Function(spine_ik_constraint_data)>();
|
|
|
|
void spine_ik_constraint_data_set_bend_direction(spine_ik_constraint_data data, int bendDirection) {
|
|
return _spine_ik_constraint_data_set_bend_direction(data, bendDirection);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_set_bend_directionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, ffi.Int32)>>(
|
|
'spine_ik_constraint_data_set_bend_direction',
|
|
);
|
|
late final _spine_ik_constraint_data_set_bend_direction = _spine_ik_constraint_data_set_bend_directionPtr
|
|
.asFunction<void Function(spine_ik_constraint_data, int)>();
|
|
|
|
int spine_ik_constraint_data_get_compress(spine_ik_constraint_data data) {
|
|
return _spine_ik_constraint_data_get_compress(data);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_get_compressPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint_data)>>(
|
|
'spine_ik_constraint_data_get_compress',
|
|
);
|
|
late final _spine_ik_constraint_data_get_compress = _spine_ik_constraint_data_get_compressPtr
|
|
.asFunction<int Function(spine_ik_constraint_data)>();
|
|
|
|
void spine_ik_constraint_data_set_compress(spine_ik_constraint_data data, int compress) {
|
|
return _spine_ik_constraint_data_set_compress(data, compress);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_set_compressPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, spine_bool)>>(
|
|
'spine_ik_constraint_data_set_compress',
|
|
);
|
|
late final _spine_ik_constraint_data_set_compress = _spine_ik_constraint_data_set_compressPtr
|
|
.asFunction<void Function(spine_ik_constraint_data, int)>();
|
|
|
|
int spine_ik_constraint_data_get_stretch(spine_ik_constraint_data data) {
|
|
return _spine_ik_constraint_data_get_stretch(data);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_get_stretchPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint_data)>>(
|
|
'spine_ik_constraint_data_get_stretch',
|
|
);
|
|
late final _spine_ik_constraint_data_get_stretch = _spine_ik_constraint_data_get_stretchPtr
|
|
.asFunction<int Function(spine_ik_constraint_data)>();
|
|
|
|
void spine_ik_constraint_data_set_stretch(spine_ik_constraint_data data, int stretch) {
|
|
return _spine_ik_constraint_data_set_stretch(data, stretch);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_set_stretchPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, spine_bool)>>(
|
|
'spine_ik_constraint_data_set_stretch',
|
|
);
|
|
late final _spine_ik_constraint_data_set_stretch = _spine_ik_constraint_data_set_stretchPtr
|
|
.asFunction<void Function(spine_ik_constraint_data, int)>();
|
|
|
|
int spine_ik_constraint_data_get_uniform(spine_ik_constraint_data data) {
|
|
return _spine_ik_constraint_data_get_uniform(data);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_get_uniformPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint_data)>>(
|
|
'spine_ik_constraint_data_get_uniform',
|
|
);
|
|
late final _spine_ik_constraint_data_get_uniform = _spine_ik_constraint_data_get_uniformPtr
|
|
.asFunction<int Function(spine_ik_constraint_data)>();
|
|
|
|
void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data data, int uniform) {
|
|
return _spine_ik_constraint_data_set_uniform(data, uniform);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_set_uniformPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, spine_bool)>>(
|
|
'spine_ik_constraint_data_set_uniform',
|
|
);
|
|
late final _spine_ik_constraint_data_set_uniform = _spine_ik_constraint_data_set_uniformPtr
|
|
.asFunction<void Function(spine_ik_constraint_data, int)>();
|
|
|
|
double spine_ik_constraint_data_get_mix(spine_ik_constraint_data data) {
|
|
return _spine_ik_constraint_data_get_mix(data);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_get_mixPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_data)>>('spine_ik_constraint_data_get_mix');
|
|
late final _spine_ik_constraint_data_get_mix = _spine_ik_constraint_data_get_mixPtr
|
|
.asFunction<double Function(spine_ik_constraint_data)>();
|
|
|
|
void spine_ik_constraint_data_set_mix(spine_ik_constraint_data data, double mix) {
|
|
return _spine_ik_constraint_data_set_mix(data, mix);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_set_mixPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, ffi.Float)>>(
|
|
'spine_ik_constraint_data_set_mix',
|
|
);
|
|
late final _spine_ik_constraint_data_set_mix = _spine_ik_constraint_data_set_mixPtr
|
|
.asFunction<void Function(spine_ik_constraint_data, double)>();
|
|
|
|
double spine_ik_constraint_data_get_softness(spine_ik_constraint_data data) {
|
|
return _spine_ik_constraint_data_get_softness(data);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_get_softnessPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_data)>>(
|
|
'spine_ik_constraint_data_get_softness',
|
|
);
|
|
late final _spine_ik_constraint_data_get_softness = _spine_ik_constraint_data_get_softnessPtr
|
|
.asFunction<double Function(spine_ik_constraint_data)>();
|
|
|
|
void spine_ik_constraint_data_set_softness(spine_ik_constraint_data data, double softness) {
|
|
return _spine_ik_constraint_data_set_softness(data, softness);
|
|
}
|
|
|
|
late final _spine_ik_constraint_data_set_softnessPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint_data, ffi.Float)>>(
|
|
'spine_ik_constraint_data_set_softness',
|
|
);
|
|
late final _spine_ik_constraint_data_set_softness = _spine_ik_constraint_data_set_softnessPtr
|
|
.asFunction<void Function(spine_ik_constraint_data, double)>();
|
|
|
|
void spine_ik_constraint_update(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_update(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_updatePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint)>>(
|
|
'spine_ik_constraint_update',
|
|
);
|
|
late final _spine_ik_constraint_update = _spine_ik_constraint_updatePtr
|
|
.asFunction<void Function(spine_ik_constraint)>();
|
|
|
|
int spine_ik_constraint_get_order(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_order(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_orderPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint)>>(
|
|
'spine_ik_constraint_get_order',
|
|
);
|
|
late final _spine_ik_constraint_get_order = _spine_ik_constraint_get_orderPtr
|
|
.asFunction<int Function(spine_ik_constraint)>();
|
|
|
|
spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_data(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_dataPtr =
|
|
_lookup<ffi.NativeFunction<spine_ik_constraint_data Function(spine_ik_constraint)>>(
|
|
'spine_ik_constraint_get_data',
|
|
);
|
|
late final _spine_ik_constraint_get_data = _spine_ik_constraint_get_dataPtr
|
|
.asFunction<spine_ik_constraint_data Function(spine_ik_constraint)>();
|
|
|
|
int spine_ik_constraint_get_num_bones(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_num_bones(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_num_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint)>>('spine_ik_constraint_get_num_bones');
|
|
late final _spine_ik_constraint_get_num_bones = _spine_ik_constraint_get_num_bonesPtr
|
|
.asFunction<int Function(spine_ik_constraint)>();
|
|
|
|
ffi.Pointer<spine_bone> spine_ik_constraint_get_bones(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_bones(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_ik_constraint)>>(
|
|
'spine_ik_constraint_get_bones',
|
|
);
|
|
late final _spine_ik_constraint_get_bones = _spine_ik_constraint_get_bonesPtr
|
|
.asFunction<ffi.Pointer<spine_bone> Function(spine_ik_constraint)>();
|
|
|
|
spine_bone spine_ik_constraint_get_target(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_target(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_targetPtr = _lookup<ffi.NativeFunction<spine_bone Function(spine_ik_constraint)>>(
|
|
'spine_ik_constraint_get_target',
|
|
);
|
|
late final _spine_ik_constraint_get_target = _spine_ik_constraint_get_targetPtr
|
|
.asFunction<spine_bone Function(spine_ik_constraint)>();
|
|
|
|
void spine_ik_constraint_set_target(spine_ik_constraint constraint, spine_bone target) {
|
|
return _spine_ik_constraint_set_target(constraint, target);
|
|
}
|
|
|
|
late final _spine_ik_constraint_set_targetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, spine_bone)>>('spine_ik_constraint_set_target');
|
|
late final _spine_ik_constraint_set_target = _spine_ik_constraint_set_targetPtr
|
|
.asFunction<void Function(spine_ik_constraint, spine_bone)>();
|
|
|
|
int spine_ik_constraint_get_bend_direction(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_bend_direction(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_bend_directionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint)>>('spine_ik_constraint_get_bend_direction');
|
|
late final _spine_ik_constraint_get_bend_direction = _spine_ik_constraint_get_bend_directionPtr
|
|
.asFunction<int Function(spine_ik_constraint)>();
|
|
|
|
void spine_ik_constraint_set_bend_direction(spine_ik_constraint constraint, int bendDirection) {
|
|
return _spine_ik_constraint_set_bend_direction(constraint, bendDirection);
|
|
}
|
|
|
|
late final _spine_ik_constraint_set_bend_directionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, ffi.Int32)>>(
|
|
'spine_ik_constraint_set_bend_direction',
|
|
);
|
|
late final _spine_ik_constraint_set_bend_direction = _spine_ik_constraint_set_bend_directionPtr
|
|
.asFunction<void Function(spine_ik_constraint, int)>();
|
|
|
|
int spine_ik_constraint_get_compress(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_compress(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_compressPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint)>>('spine_ik_constraint_get_compress');
|
|
late final _spine_ik_constraint_get_compress = _spine_ik_constraint_get_compressPtr
|
|
.asFunction<int Function(spine_ik_constraint)>();
|
|
|
|
void spine_ik_constraint_set_compress(spine_ik_constraint constraint, int compress) {
|
|
return _spine_ik_constraint_set_compress(constraint, compress);
|
|
}
|
|
|
|
late final _spine_ik_constraint_set_compressPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, spine_bool)>>(
|
|
'spine_ik_constraint_set_compress',
|
|
);
|
|
late final _spine_ik_constraint_set_compress = _spine_ik_constraint_set_compressPtr
|
|
.asFunction<void Function(spine_ik_constraint, int)>();
|
|
|
|
int spine_ik_constraint_get_stretch(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_stretch(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_stretchPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint)>>('spine_ik_constraint_get_stretch');
|
|
late final _spine_ik_constraint_get_stretch = _spine_ik_constraint_get_stretchPtr
|
|
.asFunction<int Function(spine_ik_constraint)>();
|
|
|
|
void spine_ik_constraint_set_stretch(spine_ik_constraint constraint, int stretch) {
|
|
return _spine_ik_constraint_set_stretch(constraint, stretch);
|
|
}
|
|
|
|
late final _spine_ik_constraint_set_stretchPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, spine_bool)>>(
|
|
'spine_ik_constraint_set_stretch',
|
|
);
|
|
late final _spine_ik_constraint_set_stretch = _spine_ik_constraint_set_stretchPtr
|
|
.asFunction<void Function(spine_ik_constraint, int)>();
|
|
|
|
double spine_ik_constraint_get_mix(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_mix(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_mixPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint)>>(
|
|
'spine_ik_constraint_get_mix',
|
|
);
|
|
late final _spine_ik_constraint_get_mix = _spine_ik_constraint_get_mixPtr
|
|
.asFunction<double Function(spine_ik_constraint)>();
|
|
|
|
void spine_ik_constraint_set_mix(spine_ik_constraint constraint, double mix) {
|
|
return _spine_ik_constraint_set_mix(constraint, mix);
|
|
}
|
|
|
|
late final _spine_ik_constraint_set_mixPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, ffi.Float)>>('spine_ik_constraint_set_mix');
|
|
late final _spine_ik_constraint_set_mix = _spine_ik_constraint_set_mixPtr
|
|
.asFunction<void Function(spine_ik_constraint, double)>();
|
|
|
|
double spine_ik_constraint_get_softness(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_softness(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_softnessPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint)>>('spine_ik_constraint_get_softness');
|
|
late final _spine_ik_constraint_get_softness = _spine_ik_constraint_get_softnessPtr
|
|
.asFunction<double Function(spine_ik_constraint)>();
|
|
|
|
void spine_ik_constraint_set_softness(spine_ik_constraint constraint, double softness) {
|
|
return _spine_ik_constraint_set_softness(constraint, softness);
|
|
}
|
|
|
|
late final _spine_ik_constraint_set_softnessPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, ffi.Float)>>(
|
|
'spine_ik_constraint_set_softness',
|
|
);
|
|
late final _spine_ik_constraint_set_softness = _spine_ik_constraint_set_softnessPtr
|
|
.asFunction<void Function(spine_ik_constraint, double)>();
|
|
|
|
int spine_ik_constraint_get_is_active(spine_ik_constraint constraint) {
|
|
return _spine_ik_constraint_get_is_active(constraint);
|
|
}
|
|
|
|
late final _spine_ik_constraint_get_is_activePtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_ik_constraint)>>('spine_ik_constraint_get_is_active');
|
|
late final _spine_ik_constraint_get_is_active = _spine_ik_constraint_get_is_activePtr
|
|
.asFunction<int Function(spine_ik_constraint)>();
|
|
|
|
void spine_ik_constraint_set_is_active(spine_ik_constraint constraint, int isActive) {
|
|
return _spine_ik_constraint_set_is_active(constraint, isActive);
|
|
}
|
|
|
|
late final _spine_ik_constraint_set_is_activePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_ik_constraint, spine_bool)>>(
|
|
'spine_ik_constraint_set_is_active',
|
|
);
|
|
late final _spine_ik_constraint_set_is_active = _spine_ik_constraint_set_is_activePtr
|
|
.asFunction<void Function(spine_ik_constraint, int)>();
|
|
|
|
/// OMITTED setToSetupPose()
|
|
int spine_transform_constraint_data_get_num_bones(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_num_bones(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_num_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_num_bones',
|
|
);
|
|
late final _spine_transform_constraint_data_get_num_bones = _spine_transform_constraint_data_get_num_bonesPtr
|
|
.asFunction<int Function(spine_transform_constraint_data)>();
|
|
|
|
ffi.Pointer<spine_bone_data> spine_transform_constraint_data_get_bones(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_bones(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_bone_data> Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_bones',
|
|
);
|
|
late final _spine_transform_constraint_data_get_bones = _spine_transform_constraint_data_get_bonesPtr
|
|
.asFunction<ffi.Pointer<spine_bone_data> Function(spine_transform_constraint_data)>();
|
|
|
|
spine_bone_data spine_transform_constraint_data_get_target(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_target(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_targetPtr =
|
|
_lookup<ffi.NativeFunction<spine_bone_data Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_target',
|
|
);
|
|
late final _spine_transform_constraint_data_get_target = _spine_transform_constraint_data_get_targetPtr
|
|
.asFunction<spine_bone_data Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_target(spine_transform_constraint_data data, spine_bone_data target) {
|
|
return _spine_transform_constraint_data_set_target(data, target);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_targetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, spine_bone_data)>>(
|
|
'spine_transform_constraint_data_set_target',
|
|
);
|
|
late final _spine_transform_constraint_data_set_target = _spine_transform_constraint_data_set_targetPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, spine_bone_data)>();
|
|
|
|
double spine_transform_constraint_data_get_mix_rotate(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_mix_rotate(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_mix_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_mix_rotate',
|
|
);
|
|
late final _spine_transform_constraint_data_get_mix_rotate = _spine_transform_constraint_data_get_mix_rotatePtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_mix_rotate(spine_transform_constraint_data data, double mixRotate) {
|
|
return _spine_transform_constraint_data_set_mix_rotate(data, mixRotate);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_mix_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_mix_rotate',
|
|
);
|
|
late final _spine_transform_constraint_data_set_mix_rotate = _spine_transform_constraint_data_set_mix_rotatePtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_mix_x(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_mix_x(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_mix_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_mix_x',
|
|
);
|
|
late final _spine_transform_constraint_data_get_mix_x = _spine_transform_constraint_data_get_mix_xPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_mix_x(spine_transform_constraint_data data, double mixX) {
|
|
return _spine_transform_constraint_data_set_mix_x(data, mixX);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_mix_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_mix_x',
|
|
);
|
|
late final _spine_transform_constraint_data_set_mix_x = _spine_transform_constraint_data_set_mix_xPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_mix_y(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_mix_y(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_mix_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_mix_y',
|
|
);
|
|
late final _spine_transform_constraint_data_get_mix_y = _spine_transform_constraint_data_get_mix_yPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_mix_y(spine_transform_constraint_data data, double mixY) {
|
|
return _spine_transform_constraint_data_set_mix_y(data, mixY);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_mix_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_mix_y',
|
|
);
|
|
late final _spine_transform_constraint_data_set_mix_y = _spine_transform_constraint_data_set_mix_yPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_mix_scale_x(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_mix_scale_x(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_mix_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_mix_scale_x',
|
|
);
|
|
late final _spine_transform_constraint_data_get_mix_scale_x = _spine_transform_constraint_data_get_mix_scale_xPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_mix_scale_x(spine_transform_constraint_data data, double mixScaleX) {
|
|
return _spine_transform_constraint_data_set_mix_scale_x(data, mixScaleX);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_mix_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_mix_scale_x',
|
|
);
|
|
late final _spine_transform_constraint_data_set_mix_scale_x = _spine_transform_constraint_data_set_mix_scale_xPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_mix_scale_y(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_mix_scale_y(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_mix_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_mix_scale_y',
|
|
);
|
|
late final _spine_transform_constraint_data_get_mix_scale_y = _spine_transform_constraint_data_get_mix_scale_yPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_mix_scale_y(spine_transform_constraint_data data, double mixScaleY) {
|
|
return _spine_transform_constraint_data_set_mix_scale_y(data, mixScaleY);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_mix_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_mix_scale_y',
|
|
);
|
|
late final _spine_transform_constraint_data_set_mix_scale_y = _spine_transform_constraint_data_set_mix_scale_yPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_mix_shear_y(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_mix_shear_y(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_mix_shear_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_mix_shear_y',
|
|
);
|
|
late final _spine_transform_constraint_data_get_mix_shear_y = _spine_transform_constraint_data_get_mix_shear_yPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_mix_shear_y(spine_transform_constraint_data data, double mixShearY) {
|
|
return _spine_transform_constraint_data_set_mix_shear_y(data, mixShearY);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_mix_shear_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_mix_shear_y',
|
|
);
|
|
late final _spine_transform_constraint_data_set_mix_shear_y = _spine_transform_constraint_data_set_mix_shear_yPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_offset_rotation(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_offset_rotation(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_offset_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_offset_rotation',
|
|
);
|
|
late final _spine_transform_constraint_data_get_offset_rotation =
|
|
_spine_transform_constraint_data_get_offset_rotationPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_offset_rotation(
|
|
spine_transform_constraint_data data,
|
|
double offsetRotation,
|
|
) {
|
|
return _spine_transform_constraint_data_set_offset_rotation(data, offsetRotation);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_offset_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_offset_rotation',
|
|
);
|
|
late final _spine_transform_constraint_data_set_offset_rotation =
|
|
_spine_transform_constraint_data_set_offset_rotationPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_offset_x(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_offset_x(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_offset_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_offset_x',
|
|
);
|
|
late final _spine_transform_constraint_data_get_offset_x = _spine_transform_constraint_data_get_offset_xPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_offset_x(spine_transform_constraint_data data, double offsetX) {
|
|
return _spine_transform_constraint_data_set_offset_x(data, offsetX);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_offset_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_offset_x',
|
|
);
|
|
late final _spine_transform_constraint_data_set_offset_x = _spine_transform_constraint_data_set_offset_xPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_offset_y(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_offset_y(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_offset_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_offset_y',
|
|
);
|
|
late final _spine_transform_constraint_data_get_offset_y = _spine_transform_constraint_data_get_offset_yPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_offset_y(spine_transform_constraint_data data, double offsetY) {
|
|
return _spine_transform_constraint_data_set_offset_y(data, offsetY);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_offset_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_offset_y',
|
|
);
|
|
late final _spine_transform_constraint_data_set_offset_y = _spine_transform_constraint_data_set_offset_yPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_offset_scale_x(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_offset_scale_x(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_offset_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_offset_scale_x',
|
|
);
|
|
late final _spine_transform_constraint_data_get_offset_scale_x =
|
|
_spine_transform_constraint_data_get_offset_scale_xPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_offset_scale_x(spine_transform_constraint_data data, double offsetScaleX) {
|
|
return _spine_transform_constraint_data_set_offset_scale_x(data, offsetScaleX);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_offset_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_offset_scale_x',
|
|
);
|
|
late final _spine_transform_constraint_data_set_offset_scale_x =
|
|
_spine_transform_constraint_data_set_offset_scale_xPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_offset_scale_y(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_offset_scale_y(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_offset_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_offset_scale_y',
|
|
);
|
|
late final _spine_transform_constraint_data_get_offset_scale_y =
|
|
_spine_transform_constraint_data_get_offset_scale_yPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_offset_scale_y(spine_transform_constraint_data data, double offsetScaleY) {
|
|
return _spine_transform_constraint_data_set_offset_scale_y(data, offsetScaleY);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_offset_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_offset_scale_y',
|
|
);
|
|
late final _spine_transform_constraint_data_set_offset_scale_y =
|
|
_spine_transform_constraint_data_set_offset_scale_yPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
double spine_transform_constraint_data_get_offset_shear_y(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_offset_shear_y(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_offset_shear_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_offset_shear_y',
|
|
);
|
|
late final _spine_transform_constraint_data_get_offset_shear_y =
|
|
_spine_transform_constraint_data_get_offset_shear_yPtr
|
|
.asFunction<double Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_offset_shear_y(spine_transform_constraint_data data, double offsetShearY) {
|
|
return _spine_transform_constraint_data_set_offset_shear_y(data, offsetShearY);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_offset_shear_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>(
|
|
'spine_transform_constraint_data_set_offset_shear_y',
|
|
);
|
|
late final _spine_transform_constraint_data_set_offset_shear_y =
|
|
_spine_transform_constraint_data_set_offset_shear_yPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, double)>();
|
|
|
|
int spine_transform_constraint_data_get_is_relative(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_is_relative(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_is_relativePtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_is_relative',
|
|
);
|
|
late final _spine_transform_constraint_data_get_is_relative = _spine_transform_constraint_data_get_is_relativePtr
|
|
.asFunction<int Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_is_relative(spine_transform_constraint_data data, int isRelative) {
|
|
return _spine_transform_constraint_data_set_is_relative(data, isRelative);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_is_relativePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, spine_bool)>>(
|
|
'spine_transform_constraint_data_set_is_relative',
|
|
);
|
|
late final _spine_transform_constraint_data_set_is_relative = _spine_transform_constraint_data_set_is_relativePtr
|
|
.asFunction<void Function(spine_transform_constraint_data, int)>();
|
|
|
|
int spine_transform_constraint_data_get_is_local(spine_transform_constraint_data data) {
|
|
return _spine_transform_constraint_data_get_is_local(data);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_get_is_localPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_transform_constraint_data)>>(
|
|
'spine_transform_constraint_data_get_is_local',
|
|
);
|
|
late final _spine_transform_constraint_data_get_is_local = _spine_transform_constraint_data_get_is_localPtr
|
|
.asFunction<int Function(spine_transform_constraint_data)>();
|
|
|
|
void spine_transform_constraint_data_set_is_local(spine_transform_constraint_data data, int isLocal) {
|
|
return _spine_transform_constraint_data_set_is_local(data, isLocal);
|
|
}
|
|
|
|
late final _spine_transform_constraint_data_set_is_localPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint_data, spine_bool)>>(
|
|
'spine_transform_constraint_data_set_is_local',
|
|
);
|
|
late final _spine_transform_constraint_data_set_is_local = _spine_transform_constraint_data_set_is_localPtr
|
|
.asFunction<void Function(spine_transform_constraint_data, int)>();
|
|
|
|
void spine_transform_constraint_update(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_update(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_updatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint)>>('spine_transform_constraint_update');
|
|
late final _spine_transform_constraint_update = _spine_transform_constraint_updatePtr
|
|
.asFunction<void Function(spine_transform_constraint)>();
|
|
|
|
int spine_transform_constraint_get_order(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_order(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_orderPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_order',
|
|
);
|
|
late final _spine_transform_constraint_get_order = _spine_transform_constraint_get_orderPtr
|
|
.asFunction<int Function(spine_transform_constraint)>();
|
|
|
|
spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_data(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_dataPtr =
|
|
_lookup<ffi.NativeFunction<spine_transform_constraint_data Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_data',
|
|
);
|
|
late final _spine_transform_constraint_get_data = _spine_transform_constraint_get_dataPtr
|
|
.asFunction<spine_transform_constraint_data Function(spine_transform_constraint)>();
|
|
|
|
int spine_transform_constraint_get_num_bones(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_num_bones(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_num_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_num_bones',
|
|
);
|
|
late final _spine_transform_constraint_get_num_bones = _spine_transform_constraint_get_num_bonesPtr
|
|
.asFunction<int Function(spine_transform_constraint)>();
|
|
|
|
ffi.Pointer<spine_bone> spine_transform_constraint_get_bones(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_bones(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_bones',
|
|
);
|
|
late final _spine_transform_constraint_get_bones = _spine_transform_constraint_get_bonesPtr
|
|
.asFunction<ffi.Pointer<spine_bone> Function(spine_transform_constraint)>();
|
|
|
|
spine_bone spine_transform_constraint_get_target(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_target(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_targetPtr =
|
|
_lookup<ffi.NativeFunction<spine_bone Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_target',
|
|
);
|
|
late final _spine_transform_constraint_get_target = _spine_transform_constraint_get_targetPtr
|
|
.asFunction<spine_bone Function(spine_transform_constraint)>();
|
|
|
|
void spine_transform_constraint_set_target(spine_transform_constraint constraint, spine_bone target) {
|
|
return _spine_transform_constraint_set_target(constraint, target);
|
|
}
|
|
|
|
late final _spine_transform_constraint_set_targetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, spine_bone)>>(
|
|
'spine_transform_constraint_set_target',
|
|
);
|
|
late final _spine_transform_constraint_set_target = _spine_transform_constraint_set_targetPtr
|
|
.asFunction<void Function(spine_transform_constraint, spine_bone)>();
|
|
|
|
double spine_transform_constraint_get_mix_rotate(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_mix_rotate(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_mix_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_mix_rotate',
|
|
);
|
|
late final _spine_transform_constraint_get_mix_rotate = _spine_transform_constraint_get_mix_rotatePtr
|
|
.asFunction<double Function(spine_transform_constraint)>();
|
|
|
|
void spine_transform_constraint_set_mix_rotate(spine_transform_constraint constraint, double mixRotate) {
|
|
return _spine_transform_constraint_set_mix_rotate(constraint, mixRotate);
|
|
}
|
|
|
|
late final _spine_transform_constraint_set_mix_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
|
|
'spine_transform_constraint_set_mix_rotate',
|
|
);
|
|
late final _spine_transform_constraint_set_mix_rotate = _spine_transform_constraint_set_mix_rotatePtr
|
|
.asFunction<void Function(spine_transform_constraint, double)>();
|
|
|
|
double spine_transform_constraint_get_mix_x(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_mix_x(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_mix_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_mix_x',
|
|
);
|
|
late final _spine_transform_constraint_get_mix_x = _spine_transform_constraint_get_mix_xPtr
|
|
.asFunction<double Function(spine_transform_constraint)>();
|
|
|
|
void spine_transform_constraint_set_mix_x(spine_transform_constraint constraint, double mixX) {
|
|
return _spine_transform_constraint_set_mix_x(constraint, mixX);
|
|
}
|
|
|
|
late final _spine_transform_constraint_set_mix_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
|
|
'spine_transform_constraint_set_mix_x',
|
|
);
|
|
late final _spine_transform_constraint_set_mix_x = _spine_transform_constraint_set_mix_xPtr
|
|
.asFunction<void Function(spine_transform_constraint, double)>();
|
|
|
|
double spine_transform_constraint_get_mix_y(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_mix_y(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_mix_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_mix_y',
|
|
);
|
|
late final _spine_transform_constraint_get_mix_y = _spine_transform_constraint_get_mix_yPtr
|
|
.asFunction<double Function(spine_transform_constraint)>();
|
|
|
|
void spine_transform_constraint_set_mix_y(spine_transform_constraint constraint, double mixY) {
|
|
return _spine_transform_constraint_set_mix_y(constraint, mixY);
|
|
}
|
|
|
|
late final _spine_transform_constraint_set_mix_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
|
|
'spine_transform_constraint_set_mix_y',
|
|
);
|
|
late final _spine_transform_constraint_set_mix_y = _spine_transform_constraint_set_mix_yPtr
|
|
.asFunction<void Function(spine_transform_constraint, double)>();
|
|
|
|
double spine_transform_constraint_get_mix_scale_x(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_mix_scale_x(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_mix_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_mix_scale_x',
|
|
);
|
|
late final _spine_transform_constraint_get_mix_scale_x = _spine_transform_constraint_get_mix_scale_xPtr
|
|
.asFunction<double Function(spine_transform_constraint)>();
|
|
|
|
void spine_transform_constraint_set_mix_scale_x(spine_transform_constraint constraint, double mixScaleX) {
|
|
return _spine_transform_constraint_set_mix_scale_x(constraint, mixScaleX);
|
|
}
|
|
|
|
late final _spine_transform_constraint_set_mix_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
|
|
'spine_transform_constraint_set_mix_scale_x',
|
|
);
|
|
late final _spine_transform_constraint_set_mix_scale_x = _spine_transform_constraint_set_mix_scale_xPtr
|
|
.asFunction<void Function(spine_transform_constraint, double)>();
|
|
|
|
double spine_transform_constraint_get_mix_scale_y(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_mix_scale_y(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_mix_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_mix_scale_y',
|
|
);
|
|
late final _spine_transform_constraint_get_mix_scale_y = _spine_transform_constraint_get_mix_scale_yPtr
|
|
.asFunction<double Function(spine_transform_constraint)>();
|
|
|
|
void spine_transform_constraint_set_mix_scale_y(spine_transform_constraint constraint, double mixScaleY) {
|
|
return _spine_transform_constraint_set_mix_scale_y(constraint, mixScaleY);
|
|
}
|
|
|
|
late final _spine_transform_constraint_set_mix_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
|
|
'spine_transform_constraint_set_mix_scale_y',
|
|
);
|
|
late final _spine_transform_constraint_set_mix_scale_y = _spine_transform_constraint_set_mix_scale_yPtr
|
|
.asFunction<void Function(spine_transform_constraint, double)>();
|
|
|
|
double spine_transform_constraint_get_mix_shear_y(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_mix_shear_y(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_mix_shear_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_mix_shear_y',
|
|
);
|
|
late final _spine_transform_constraint_get_mix_shear_y = _spine_transform_constraint_get_mix_shear_yPtr
|
|
.asFunction<double Function(spine_transform_constraint)>();
|
|
|
|
void spine_transform_constraint_set_mix_shear_y(spine_transform_constraint constraint, double mixShearY) {
|
|
return _spine_transform_constraint_set_mix_shear_y(constraint, mixShearY);
|
|
}
|
|
|
|
late final _spine_transform_constraint_set_mix_shear_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, ffi.Float)>>(
|
|
'spine_transform_constraint_set_mix_shear_y',
|
|
);
|
|
late final _spine_transform_constraint_set_mix_shear_y = _spine_transform_constraint_set_mix_shear_yPtr
|
|
.asFunction<void Function(spine_transform_constraint, double)>();
|
|
|
|
int spine_transform_constraint_get_is_active(spine_transform_constraint constraint) {
|
|
return _spine_transform_constraint_get_is_active(constraint);
|
|
}
|
|
|
|
late final _spine_transform_constraint_get_is_activePtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_transform_constraint)>>(
|
|
'spine_transform_constraint_get_is_active',
|
|
);
|
|
late final _spine_transform_constraint_get_is_active = _spine_transform_constraint_get_is_activePtr
|
|
.asFunction<int Function(spine_transform_constraint)>();
|
|
|
|
void spine_transform_constraint_set_is_active(spine_transform_constraint constraint, int isActive) {
|
|
return _spine_transform_constraint_set_is_active(constraint, isActive);
|
|
}
|
|
|
|
late final _spine_transform_constraint_set_is_activePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_transform_constraint, spine_bool)>>(
|
|
'spine_transform_constraint_set_is_active',
|
|
);
|
|
late final _spine_transform_constraint_set_is_active = _spine_transform_constraint_set_is_activePtr
|
|
.asFunction<void Function(spine_transform_constraint, int)>();
|
|
|
|
/// OMITTED setToSetupPose()
|
|
int spine_path_constraint_data_get_num_bones(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_num_bones(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_num_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_num_bones',
|
|
);
|
|
late final _spine_path_constraint_data_get_num_bones = _spine_path_constraint_data_get_num_bonesPtr
|
|
.asFunction<int Function(spine_path_constraint_data)>();
|
|
|
|
ffi.Pointer<spine_bone_data> spine_path_constraint_data_get_bones(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_bones(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_bone_data> Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_bones',
|
|
);
|
|
late final _spine_path_constraint_data_get_bones = _spine_path_constraint_data_get_bonesPtr
|
|
.asFunction<ffi.Pointer<spine_bone_data> Function(spine_path_constraint_data)>();
|
|
|
|
spine_slot_data spine_path_constraint_data_get_target(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_target(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_targetPtr =
|
|
_lookup<ffi.NativeFunction<spine_slot_data Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_target',
|
|
);
|
|
late final _spine_path_constraint_data_get_target = _spine_path_constraint_data_get_targetPtr
|
|
.asFunction<spine_slot_data Function(spine_path_constraint_data)>();
|
|
|
|
void spine_path_constraint_data_set_target(spine_path_constraint_data data, spine_slot_data target) {
|
|
return _spine_path_constraint_data_set_target(data, target);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_set_targetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, spine_slot_data)>>(
|
|
'spine_path_constraint_data_set_target',
|
|
);
|
|
late final _spine_path_constraint_data_set_target = _spine_path_constraint_data_set_targetPtr
|
|
.asFunction<void Function(spine_path_constraint_data, spine_slot_data)>();
|
|
|
|
int spine_path_constraint_data_get_position_mode(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_position_mode(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_position_modePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_position_mode',
|
|
);
|
|
late final _spine_path_constraint_data_get_position_mode = _spine_path_constraint_data_get_position_modePtr
|
|
.asFunction<int Function(spine_path_constraint_data)>();
|
|
|
|
void spine_path_constraint_data_set_position_mode(spine_path_constraint_data data, int positionMode) {
|
|
return _spine_path_constraint_data_set_position_mode(data, positionMode);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_set_position_modePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Int32)>>(
|
|
'spine_path_constraint_data_set_position_mode',
|
|
);
|
|
late final _spine_path_constraint_data_set_position_mode = _spine_path_constraint_data_set_position_modePtr
|
|
.asFunction<void Function(spine_path_constraint_data, int)>();
|
|
|
|
int spine_path_constraint_data_get_spacing_mode(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_spacing_mode(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_spacing_modePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_spacing_mode',
|
|
);
|
|
late final _spine_path_constraint_data_get_spacing_mode = _spine_path_constraint_data_get_spacing_modePtr
|
|
.asFunction<int Function(spine_path_constraint_data)>();
|
|
|
|
void spine_path_constraint_data_set_spacing_mode(spine_path_constraint_data data, int spacingMode) {
|
|
return _spine_path_constraint_data_set_spacing_mode(data, spacingMode);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_set_spacing_modePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Int32)>>(
|
|
'spine_path_constraint_data_set_spacing_mode',
|
|
);
|
|
late final _spine_path_constraint_data_set_spacing_mode = _spine_path_constraint_data_set_spacing_modePtr
|
|
.asFunction<void Function(spine_path_constraint_data, int)>();
|
|
|
|
int spine_path_constraint_data_get_rotate_mode(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_rotate_mode(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_rotate_modePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_rotate_mode',
|
|
);
|
|
late final _spine_path_constraint_data_get_rotate_mode = _spine_path_constraint_data_get_rotate_modePtr
|
|
.asFunction<int Function(spine_path_constraint_data)>();
|
|
|
|
void spine_path_constraint_data_set_rotate_mode(spine_path_constraint_data data, int rotateMode) {
|
|
return _spine_path_constraint_data_set_rotate_mode(data, rotateMode);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_set_rotate_modePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Int32)>>(
|
|
'spine_path_constraint_data_set_rotate_mode',
|
|
);
|
|
late final _spine_path_constraint_data_set_rotate_mode = _spine_path_constraint_data_set_rotate_modePtr
|
|
.asFunction<void Function(spine_path_constraint_data, int)>();
|
|
|
|
double spine_path_constraint_data_get_offset_rotation(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_offset_rotation(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_offset_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_offset_rotation',
|
|
);
|
|
late final _spine_path_constraint_data_get_offset_rotation = _spine_path_constraint_data_get_offset_rotationPtr
|
|
.asFunction<double Function(spine_path_constraint_data)>();
|
|
|
|
void spine_path_constraint_data_set_offset_rotation(spine_path_constraint_data data, double offsetRotation) {
|
|
return _spine_path_constraint_data_set_offset_rotation(data, offsetRotation);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_set_offset_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
|
|
'spine_path_constraint_data_set_offset_rotation',
|
|
);
|
|
late final _spine_path_constraint_data_set_offset_rotation = _spine_path_constraint_data_set_offset_rotationPtr
|
|
.asFunction<void Function(spine_path_constraint_data, double)>();
|
|
|
|
double spine_path_constraint_data_get_position(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_position(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_positionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_position',
|
|
);
|
|
late final _spine_path_constraint_data_get_position = _spine_path_constraint_data_get_positionPtr
|
|
.asFunction<double Function(spine_path_constraint_data)>();
|
|
|
|
void spine_path_constraint_data_set_position(spine_path_constraint_data data, double position) {
|
|
return _spine_path_constraint_data_set_position(data, position);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_set_positionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
|
|
'spine_path_constraint_data_set_position',
|
|
);
|
|
late final _spine_path_constraint_data_set_position = _spine_path_constraint_data_set_positionPtr
|
|
.asFunction<void Function(spine_path_constraint_data, double)>();
|
|
|
|
double spine_path_constraint_data_get_spacing(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_spacing(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_spacingPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_spacing',
|
|
);
|
|
late final _spine_path_constraint_data_get_spacing = _spine_path_constraint_data_get_spacingPtr
|
|
.asFunction<double Function(spine_path_constraint_data)>();
|
|
|
|
void spine_path_constraint_data_set_spacing(spine_path_constraint_data data, double spacing) {
|
|
return _spine_path_constraint_data_set_spacing(data, spacing);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_set_spacingPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
|
|
'spine_path_constraint_data_set_spacing',
|
|
);
|
|
late final _spine_path_constraint_data_set_spacing = _spine_path_constraint_data_set_spacingPtr
|
|
.asFunction<void Function(spine_path_constraint_data, double)>();
|
|
|
|
double spine_path_constraint_data_get_mix_rotate(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_mix_rotate(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_mix_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_mix_rotate',
|
|
);
|
|
late final _spine_path_constraint_data_get_mix_rotate = _spine_path_constraint_data_get_mix_rotatePtr
|
|
.asFunction<double Function(spine_path_constraint_data)>();
|
|
|
|
void spine_path_constraint_data_set_mix_rotate(spine_path_constraint_data data, double mixRotate) {
|
|
return _spine_path_constraint_data_set_mix_rotate(data, mixRotate);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_set_mix_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
|
|
'spine_path_constraint_data_set_mix_rotate',
|
|
);
|
|
late final _spine_path_constraint_data_set_mix_rotate = _spine_path_constraint_data_set_mix_rotatePtr
|
|
.asFunction<void Function(spine_path_constraint_data, double)>();
|
|
|
|
double spine_path_constraint_data_get_mix_x(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_mix_x(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_mix_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_mix_x',
|
|
);
|
|
late final _spine_path_constraint_data_get_mix_x = _spine_path_constraint_data_get_mix_xPtr
|
|
.asFunction<double Function(spine_path_constraint_data)>();
|
|
|
|
void spine_path_constraint_data_set_mix_x(spine_path_constraint_data data, double mixX) {
|
|
return _spine_path_constraint_data_set_mix_x(data, mixX);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_set_mix_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
|
|
'spine_path_constraint_data_set_mix_x',
|
|
);
|
|
late final _spine_path_constraint_data_set_mix_x = _spine_path_constraint_data_set_mix_xPtr
|
|
.asFunction<void Function(spine_path_constraint_data, double)>();
|
|
|
|
double spine_path_constraint_data_get_mix_y(spine_path_constraint_data data) {
|
|
return _spine_path_constraint_data_get_mix_y(data);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_get_mix_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint_data)>>(
|
|
'spine_path_constraint_data_get_mix_y',
|
|
);
|
|
late final _spine_path_constraint_data_get_mix_y = _spine_path_constraint_data_get_mix_yPtr
|
|
.asFunction<double Function(spine_path_constraint_data)>();
|
|
|
|
void spine_path_constraint_data_set_mix_y(spine_path_constraint_data data, double mixY) {
|
|
return _spine_path_constraint_data_set_mix_y(data, mixY);
|
|
}
|
|
|
|
late final _spine_path_constraint_data_set_mix_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint_data, ffi.Float)>>(
|
|
'spine_path_constraint_data_set_mix_y',
|
|
);
|
|
late final _spine_path_constraint_data_set_mix_y = _spine_path_constraint_data_set_mix_yPtr
|
|
.asFunction<void Function(spine_path_constraint_data, double)>();
|
|
|
|
void spine_path_constraint_update(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_update(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_updatePtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint)>>(
|
|
'spine_path_constraint_update',
|
|
);
|
|
late final _spine_path_constraint_update = _spine_path_constraint_updatePtr
|
|
.asFunction<void Function(spine_path_constraint)>();
|
|
|
|
int spine_path_constraint_get_order(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_order(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_orderPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint)>>('spine_path_constraint_get_order');
|
|
late final _spine_path_constraint_get_order = _spine_path_constraint_get_orderPtr
|
|
.asFunction<int Function(spine_path_constraint)>();
|
|
|
|
spine_path_constraint_data spine_path_constraint_get_data(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_data(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_dataPtr =
|
|
_lookup<ffi.NativeFunction<spine_path_constraint_data Function(spine_path_constraint)>>(
|
|
'spine_path_constraint_get_data',
|
|
);
|
|
late final _spine_path_constraint_get_data = _spine_path_constraint_get_dataPtr
|
|
.asFunction<spine_path_constraint_data Function(spine_path_constraint)>();
|
|
|
|
int spine_path_constraint_get_num_bones(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_num_bones(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_num_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_path_constraint)>>('spine_path_constraint_get_num_bones');
|
|
late final _spine_path_constraint_get_num_bones = _spine_path_constraint_get_num_bonesPtr
|
|
.asFunction<int Function(spine_path_constraint)>();
|
|
|
|
ffi.Pointer<spine_bone> spine_path_constraint_get_bones(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_bones(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_path_constraint)>>(
|
|
'spine_path_constraint_get_bones',
|
|
);
|
|
late final _spine_path_constraint_get_bones = _spine_path_constraint_get_bonesPtr
|
|
.asFunction<ffi.Pointer<spine_bone> Function(spine_path_constraint)>();
|
|
|
|
spine_slot spine_path_constraint_get_target(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_target(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_targetPtr =
|
|
_lookup<ffi.NativeFunction<spine_slot Function(spine_path_constraint)>>('spine_path_constraint_get_target');
|
|
late final _spine_path_constraint_get_target = _spine_path_constraint_get_targetPtr
|
|
.asFunction<spine_slot Function(spine_path_constraint)>();
|
|
|
|
void spine_path_constraint_set_target(spine_path_constraint constraint, spine_slot target) {
|
|
return _spine_path_constraint_set_target(constraint, target);
|
|
}
|
|
|
|
late final _spine_path_constraint_set_targetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, spine_slot)>>(
|
|
'spine_path_constraint_set_target',
|
|
);
|
|
late final _spine_path_constraint_set_target = _spine_path_constraint_set_targetPtr
|
|
.asFunction<void Function(spine_path_constraint, spine_slot)>();
|
|
|
|
double spine_path_constraint_get_position(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_position(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_positionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint)>>('spine_path_constraint_get_position');
|
|
late final _spine_path_constraint_get_position = _spine_path_constraint_get_positionPtr
|
|
.asFunction<double Function(spine_path_constraint)>();
|
|
|
|
void spine_path_constraint_set_position(spine_path_constraint constraint, double position) {
|
|
return _spine_path_constraint_set_position(constraint, position);
|
|
}
|
|
|
|
late final _spine_path_constraint_set_positionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Float)>>(
|
|
'spine_path_constraint_set_position',
|
|
);
|
|
late final _spine_path_constraint_set_position = _spine_path_constraint_set_positionPtr
|
|
.asFunction<void Function(spine_path_constraint, double)>();
|
|
|
|
double spine_path_constraint_get_spacing(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_spacing(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_spacingPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint)>>('spine_path_constraint_get_spacing');
|
|
late final _spine_path_constraint_get_spacing = _spine_path_constraint_get_spacingPtr
|
|
.asFunction<double Function(spine_path_constraint)>();
|
|
|
|
void spine_path_constraint_set_spacing(spine_path_constraint constraint, double spacing) {
|
|
return _spine_path_constraint_set_spacing(constraint, spacing);
|
|
}
|
|
|
|
late final _spine_path_constraint_set_spacingPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Float)>>(
|
|
'spine_path_constraint_set_spacing',
|
|
);
|
|
late final _spine_path_constraint_set_spacing = _spine_path_constraint_set_spacingPtr
|
|
.asFunction<void Function(spine_path_constraint, double)>();
|
|
|
|
double spine_path_constraint_get_mix_rotate(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_mix_rotate(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_mix_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint)>>('spine_path_constraint_get_mix_rotate');
|
|
late final _spine_path_constraint_get_mix_rotate = _spine_path_constraint_get_mix_rotatePtr
|
|
.asFunction<double Function(spine_path_constraint)>();
|
|
|
|
void spine_path_constraint_set_mix_rotate(spine_path_constraint constraint, double mixRotate) {
|
|
return _spine_path_constraint_set_mix_rotate(constraint, mixRotate);
|
|
}
|
|
|
|
late final _spine_path_constraint_set_mix_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Float)>>(
|
|
'spine_path_constraint_set_mix_rotate',
|
|
);
|
|
late final _spine_path_constraint_set_mix_rotate = _spine_path_constraint_set_mix_rotatePtr
|
|
.asFunction<void Function(spine_path_constraint, double)>();
|
|
|
|
double spine_path_constraint_get_mix_x(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_mix_x(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_mix_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint)>>('spine_path_constraint_get_mix_x');
|
|
late final _spine_path_constraint_get_mix_x = _spine_path_constraint_get_mix_xPtr
|
|
.asFunction<double Function(spine_path_constraint)>();
|
|
|
|
void spine_path_constraint_set_mix_x(spine_path_constraint constraint, double mixX) {
|
|
return _spine_path_constraint_set_mix_x(constraint, mixX);
|
|
}
|
|
|
|
late final _spine_path_constraint_set_mix_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Float)>>(
|
|
'spine_path_constraint_set_mix_x',
|
|
);
|
|
late final _spine_path_constraint_set_mix_x = _spine_path_constraint_set_mix_xPtr
|
|
.asFunction<void Function(spine_path_constraint, double)>();
|
|
|
|
double spine_path_constraint_get_mix_y(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_mix_y(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_mix_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_path_constraint)>>('spine_path_constraint_get_mix_y');
|
|
late final _spine_path_constraint_get_mix_y = _spine_path_constraint_get_mix_yPtr
|
|
.asFunction<double Function(spine_path_constraint)>();
|
|
|
|
void spine_path_constraint_set_mix_y(spine_path_constraint constraint, double mixY) {
|
|
return _spine_path_constraint_set_mix_y(constraint, mixY);
|
|
}
|
|
|
|
late final _spine_path_constraint_set_mix_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, ffi.Float)>>(
|
|
'spine_path_constraint_set_mix_y',
|
|
);
|
|
late final _spine_path_constraint_set_mix_y = _spine_path_constraint_set_mix_yPtr
|
|
.asFunction<void Function(spine_path_constraint, double)>();
|
|
|
|
int spine_path_constraint_get_is_active(spine_path_constraint constraint) {
|
|
return _spine_path_constraint_get_is_active(constraint);
|
|
}
|
|
|
|
late final _spine_path_constraint_get_is_activePtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_path_constraint)>>('spine_path_constraint_get_is_active');
|
|
late final _spine_path_constraint_get_is_active = _spine_path_constraint_get_is_activePtr
|
|
.asFunction<int Function(spine_path_constraint)>();
|
|
|
|
void spine_path_constraint_set_is_active(spine_path_constraint constraint, int isActive) {
|
|
return _spine_path_constraint_set_is_active(constraint, isActive);
|
|
}
|
|
|
|
late final _spine_path_constraint_set_is_activePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_path_constraint, spine_bool)>>(
|
|
'spine_path_constraint_set_is_active',
|
|
);
|
|
late final _spine_path_constraint_set_is_active = _spine_path_constraint_set_is_activePtr
|
|
.asFunction<void Function(spine_path_constraint, int)>();
|
|
|
|
/// OMITTED setToSetupPose()
|
|
void spine_physics_constraint_data_set_bone(spine_physics_constraint_data data, spine_bone_data bone) {
|
|
return _spine_physics_constraint_data_set_bone(data, bone);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_bonePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_bone_data)>>(
|
|
'spine_physics_constraint_data_set_bone',
|
|
);
|
|
late final _spine_physics_constraint_data_set_bone = _spine_physics_constraint_data_set_bonePtr
|
|
.asFunction<void Function(spine_physics_constraint_data, spine_bone_data)>();
|
|
|
|
spine_bone_data spine_physics_constraint_data_get_bone(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_bone(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_bonePtr =
|
|
_lookup<ffi.NativeFunction<spine_bone_data Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_bone',
|
|
);
|
|
late final _spine_physics_constraint_data_get_bone = _spine_physics_constraint_data_get_bonePtr
|
|
.asFunction<spine_bone_data Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_x(spine_physics_constraint_data data, double x) {
|
|
return _spine_physics_constraint_data_set_x(data, x);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_x',
|
|
);
|
|
late final _spine_physics_constraint_data_set_x = _spine_physics_constraint_data_set_xPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_x(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_x(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_x',
|
|
);
|
|
late final _spine_physics_constraint_data_get_x = _spine_physics_constraint_data_get_xPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_y(spine_physics_constraint_data data, double y) {
|
|
return _spine_physics_constraint_data_set_y(data, y);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_y',
|
|
);
|
|
late final _spine_physics_constraint_data_set_y = _spine_physics_constraint_data_set_yPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_y(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_y(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_y',
|
|
);
|
|
late final _spine_physics_constraint_data_get_y = _spine_physics_constraint_data_get_yPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_rotate(spine_physics_constraint_data data, double rotate) {
|
|
return _spine_physics_constraint_data_set_rotate(data, rotate);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_rotate',
|
|
);
|
|
late final _spine_physics_constraint_data_set_rotate = _spine_physics_constraint_data_set_rotatePtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_rotate(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_rotate(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_rotate',
|
|
);
|
|
late final _spine_physics_constraint_data_get_rotate = _spine_physics_constraint_data_get_rotatePtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_scale_x(spine_physics_constraint_data data, double scaleX) {
|
|
return _spine_physics_constraint_data_set_scale_x(data, scaleX);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_scale_x',
|
|
);
|
|
late final _spine_physics_constraint_data_set_scale_x = _spine_physics_constraint_data_set_scale_xPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_scale_x(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_scale_x(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_scale_x',
|
|
);
|
|
late final _spine_physics_constraint_data_get_scale_x = _spine_physics_constraint_data_get_scale_xPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_shear_x(spine_physics_constraint_data data, double shearX) {
|
|
return _spine_physics_constraint_data_set_shear_x(data, shearX);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_shear_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_shear_x',
|
|
);
|
|
late final _spine_physics_constraint_data_set_shear_x = _spine_physics_constraint_data_set_shear_xPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_shear_x(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_shear_x(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_shear_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_shear_x',
|
|
);
|
|
late final _spine_physics_constraint_data_get_shear_x = _spine_physics_constraint_data_get_shear_xPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_limit(spine_physics_constraint_data data, double limit) {
|
|
return _spine_physics_constraint_data_set_limit(data, limit);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_limitPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_limit',
|
|
);
|
|
late final _spine_physics_constraint_data_set_limit = _spine_physics_constraint_data_set_limitPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_limit(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_limit(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_limitPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_limit',
|
|
);
|
|
late final _spine_physics_constraint_data_get_limit = _spine_physics_constraint_data_get_limitPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_step(spine_physics_constraint_data data, double step) {
|
|
return _spine_physics_constraint_data_set_step(data, step);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_stepPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_step',
|
|
);
|
|
late final _spine_physics_constraint_data_set_step = _spine_physics_constraint_data_set_stepPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_step(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_step(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_stepPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_step',
|
|
);
|
|
late final _spine_physics_constraint_data_get_step = _spine_physics_constraint_data_get_stepPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_inertia(spine_physics_constraint_data data, double inertia) {
|
|
return _spine_physics_constraint_data_set_inertia(data, inertia);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_inertiaPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_inertia',
|
|
);
|
|
late final _spine_physics_constraint_data_set_inertia = _spine_physics_constraint_data_set_inertiaPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_inertia(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_inertia(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_inertiaPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_inertia',
|
|
);
|
|
late final _spine_physics_constraint_data_get_inertia = _spine_physics_constraint_data_get_inertiaPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_strength(spine_physics_constraint_data data, double strength) {
|
|
return _spine_physics_constraint_data_set_strength(data, strength);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_strengthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_strength',
|
|
);
|
|
late final _spine_physics_constraint_data_set_strength = _spine_physics_constraint_data_set_strengthPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_strength(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_strength(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_strengthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_strength',
|
|
);
|
|
late final _spine_physics_constraint_data_get_strength = _spine_physics_constraint_data_get_strengthPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_damping(spine_physics_constraint_data data, double damping) {
|
|
return _spine_physics_constraint_data_set_damping(data, damping);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_dampingPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_damping',
|
|
);
|
|
late final _spine_physics_constraint_data_set_damping = _spine_physics_constraint_data_set_dampingPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_damping(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_damping(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_dampingPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_damping',
|
|
);
|
|
late final _spine_physics_constraint_data_get_damping = _spine_physics_constraint_data_get_dampingPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_mass_inverse(spine_physics_constraint_data data, double massInverse) {
|
|
return _spine_physics_constraint_data_set_mass_inverse(data, massInverse);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_mass_inversePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_mass_inverse',
|
|
);
|
|
late final _spine_physics_constraint_data_set_mass_inverse = _spine_physics_constraint_data_set_mass_inversePtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_mass_inverse(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_mass_inverse(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_mass_inversePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_mass_inverse',
|
|
);
|
|
late final _spine_physics_constraint_data_get_mass_inverse = _spine_physics_constraint_data_get_mass_inversePtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_wind(spine_physics_constraint_data data, double wind) {
|
|
return _spine_physics_constraint_data_set_wind(data, wind);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_windPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_wind',
|
|
);
|
|
late final _spine_physics_constraint_data_set_wind = _spine_physics_constraint_data_set_windPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_wind(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_wind(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_windPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_wind',
|
|
);
|
|
late final _spine_physics_constraint_data_get_wind = _spine_physics_constraint_data_get_windPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_gravity(spine_physics_constraint_data data, double gravity) {
|
|
return _spine_physics_constraint_data_set_gravity(data, gravity);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_gravityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_gravity',
|
|
);
|
|
late final _spine_physics_constraint_data_set_gravity = _spine_physics_constraint_data_set_gravityPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_gravity(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_gravity(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_gravityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_gravity',
|
|
);
|
|
late final _spine_physics_constraint_data_get_gravity = _spine_physics_constraint_data_get_gravityPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_mix(spine_physics_constraint_data data, double mix) {
|
|
return _spine_physics_constraint_data_set_mix(data, mix);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_mixPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, ffi.Float)>>(
|
|
'spine_physics_constraint_data_set_mix',
|
|
);
|
|
late final _spine_physics_constraint_data_set_mix = _spine_physics_constraint_data_set_mixPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, double)>();
|
|
|
|
double spine_physics_constraint_data_get_mix(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_get_mix(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_get_mixPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_get_mix',
|
|
);
|
|
late final _spine_physics_constraint_data_get_mix = _spine_physics_constraint_data_get_mixPtr
|
|
.asFunction<double Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_inertia_global(spine_physics_constraint_data data, int inertiaGlobal) {
|
|
return _spine_physics_constraint_data_set_inertia_global(data, inertiaGlobal);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_inertia_globalPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_bool)>>(
|
|
'spine_physics_constraint_data_set_inertia_global',
|
|
);
|
|
late final _spine_physics_constraint_data_set_inertia_global = _spine_physics_constraint_data_set_inertia_globalPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, int)>();
|
|
|
|
int spine_physics_constraint_data_is_inertia_global(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_is_inertia_global(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_is_inertia_globalPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_is_inertia_global',
|
|
);
|
|
late final _spine_physics_constraint_data_is_inertia_global = _spine_physics_constraint_data_is_inertia_globalPtr
|
|
.asFunction<int Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_strength_global(spine_physics_constraint_data data, int strengthGlobal) {
|
|
return _spine_physics_constraint_data_set_strength_global(data, strengthGlobal);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_strength_globalPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_bool)>>(
|
|
'spine_physics_constraint_data_set_strength_global',
|
|
);
|
|
late final _spine_physics_constraint_data_set_strength_global = _spine_physics_constraint_data_set_strength_globalPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, int)>();
|
|
|
|
int spine_physics_constraint_data_is_strength_global(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_is_strength_global(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_is_strength_globalPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_is_strength_global',
|
|
);
|
|
late final _spine_physics_constraint_data_is_strength_global = _spine_physics_constraint_data_is_strength_globalPtr
|
|
.asFunction<int Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_damping_global(spine_physics_constraint_data data, int dampingGlobal) {
|
|
return _spine_physics_constraint_data_set_damping_global(data, dampingGlobal);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_damping_globalPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_bool)>>(
|
|
'spine_physics_constraint_data_set_damping_global',
|
|
);
|
|
late final _spine_physics_constraint_data_set_damping_global = _spine_physics_constraint_data_set_damping_globalPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, int)>();
|
|
|
|
int spine_physics_constraint_data_is_damping_global(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_is_damping_global(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_is_damping_globalPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_is_damping_global',
|
|
);
|
|
late final _spine_physics_constraint_data_is_damping_global = _spine_physics_constraint_data_is_damping_globalPtr
|
|
.asFunction<int Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_mass_global(spine_physics_constraint_data data, int massGlobal) {
|
|
return _spine_physics_constraint_data_set_mass_global(data, massGlobal);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_mass_globalPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_bool)>>(
|
|
'spine_physics_constraint_data_set_mass_global',
|
|
);
|
|
late final _spine_physics_constraint_data_set_mass_global = _spine_physics_constraint_data_set_mass_globalPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, int)>();
|
|
|
|
int spine_physics_constraint_data_is_mass_global(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_is_mass_global(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_is_mass_globalPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_is_mass_global',
|
|
);
|
|
late final _spine_physics_constraint_data_is_mass_global = _spine_physics_constraint_data_is_mass_globalPtr
|
|
.asFunction<int Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_wind_global(spine_physics_constraint_data data, int windGlobal) {
|
|
return _spine_physics_constraint_data_set_wind_global(data, windGlobal);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_wind_globalPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_bool)>>(
|
|
'spine_physics_constraint_data_set_wind_global',
|
|
);
|
|
late final _spine_physics_constraint_data_set_wind_global = _spine_physics_constraint_data_set_wind_globalPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, int)>();
|
|
|
|
int spine_physics_constraint_data_is_wind_global(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_is_wind_global(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_is_wind_globalPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_is_wind_global',
|
|
);
|
|
late final _spine_physics_constraint_data_is_wind_global = _spine_physics_constraint_data_is_wind_globalPtr
|
|
.asFunction<int Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_gravity_global(spine_physics_constraint_data data, int gravityGlobal) {
|
|
return _spine_physics_constraint_data_set_gravity_global(data, gravityGlobal);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_gravity_globalPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_bool)>>(
|
|
'spine_physics_constraint_data_set_gravity_global',
|
|
);
|
|
late final _spine_physics_constraint_data_set_gravity_global = _spine_physics_constraint_data_set_gravity_globalPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, int)>();
|
|
|
|
int spine_physics_constraint_data_is_gravity_global(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_is_gravity_global(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_is_gravity_globalPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_is_gravity_global',
|
|
);
|
|
late final _spine_physics_constraint_data_is_gravity_global = _spine_physics_constraint_data_is_gravity_globalPtr
|
|
.asFunction<int Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_data_set_mix_global(spine_physics_constraint_data data, int mixGlobal) {
|
|
return _spine_physics_constraint_data_set_mix_global(data, mixGlobal);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_set_mix_globalPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint_data, spine_bool)>>(
|
|
'spine_physics_constraint_data_set_mix_global',
|
|
);
|
|
late final _spine_physics_constraint_data_set_mix_global = _spine_physics_constraint_data_set_mix_globalPtr
|
|
.asFunction<void Function(spine_physics_constraint_data, int)>();
|
|
|
|
int spine_physics_constraint_data_is_mix_global(spine_physics_constraint_data data) {
|
|
return _spine_physics_constraint_data_is_mix_global(data);
|
|
}
|
|
|
|
late final _spine_physics_constraint_data_is_mix_globalPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint_data)>>(
|
|
'spine_physics_constraint_data_is_mix_global',
|
|
);
|
|
late final _spine_physics_constraint_data_is_mix_global = _spine_physics_constraint_data_is_mix_globalPtr
|
|
.asFunction<int Function(spine_physics_constraint_data)>();
|
|
|
|
void spine_physics_constraint_set_bone(spine_physics_constraint constraint, spine_bone bone) {
|
|
return _spine_physics_constraint_set_bone(constraint, bone);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_bonePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, spine_bone)>>(
|
|
'spine_physics_constraint_set_bone',
|
|
);
|
|
late final _spine_physics_constraint_set_bone = _spine_physics_constraint_set_bonePtr
|
|
.asFunction<void Function(spine_physics_constraint, spine_bone)>();
|
|
|
|
spine_bone spine_physics_constraint_get_bone(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_bone(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_bonePtr =
|
|
_lookup<ffi.NativeFunction<spine_bone Function(spine_physics_constraint)>>('spine_physics_constraint_get_bone');
|
|
late final _spine_physics_constraint_get_bone = _spine_physics_constraint_get_bonePtr
|
|
.asFunction<spine_bone Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_inertia(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_inertia(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_inertiaPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_inertia',
|
|
);
|
|
late final _spine_physics_constraint_set_inertia = _spine_physics_constraint_set_inertiaPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_inertia(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_inertia(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_inertiaPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_inertia');
|
|
late final _spine_physics_constraint_get_inertia = _spine_physics_constraint_get_inertiaPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_strength(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_strength(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_strengthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_strength',
|
|
);
|
|
late final _spine_physics_constraint_set_strength = _spine_physics_constraint_set_strengthPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_strength(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_strength(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_strengthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_strength',
|
|
);
|
|
late final _spine_physics_constraint_get_strength = _spine_physics_constraint_get_strengthPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_damping(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_damping(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_dampingPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_damping',
|
|
);
|
|
late final _spine_physics_constraint_set_damping = _spine_physics_constraint_set_dampingPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_damping(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_damping(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_dampingPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_damping');
|
|
late final _spine_physics_constraint_get_damping = _spine_physics_constraint_get_dampingPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_mass_inverse(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_mass_inverse(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_mass_inversePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_mass_inverse',
|
|
);
|
|
late final _spine_physics_constraint_set_mass_inverse = _spine_physics_constraint_set_mass_inversePtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_mass_inverse(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_mass_inverse(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_mass_inversePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_mass_inverse',
|
|
);
|
|
late final _spine_physics_constraint_get_mass_inverse = _spine_physics_constraint_get_mass_inversePtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_wind(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_wind(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_windPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_wind',
|
|
);
|
|
late final _spine_physics_constraint_set_wind = _spine_physics_constraint_set_windPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_wind(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_wind(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_windPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_wind');
|
|
late final _spine_physics_constraint_get_wind = _spine_physics_constraint_get_windPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_gravity(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_gravity(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_gravityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_gravity',
|
|
);
|
|
late final _spine_physics_constraint_set_gravity = _spine_physics_constraint_set_gravityPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_gravity(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_gravity(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_gravityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_gravity');
|
|
late final _spine_physics_constraint_get_gravity = _spine_physics_constraint_get_gravityPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_mix(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_mix(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_mixPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_mix',
|
|
);
|
|
late final _spine_physics_constraint_set_mix = _spine_physics_constraint_set_mixPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_mix(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_mix(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_mixPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_mix');
|
|
late final _spine_physics_constraint_get_mix = _spine_physics_constraint_get_mixPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_reset(spine_physics_constraint constraint, int value) {
|
|
return _spine_physics_constraint_set_reset(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_resetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, spine_bool)>>(
|
|
'spine_physics_constraint_set_reset',
|
|
);
|
|
late final _spine_physics_constraint_set_reset = _spine_physics_constraint_set_resetPtr
|
|
.asFunction<void Function(spine_physics_constraint, int)>();
|
|
|
|
int spine_physics_constraint_get_reset(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_reset(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_resetPtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint)>>('spine_physics_constraint_get_reset');
|
|
late final _spine_physics_constraint_get_reset = _spine_physics_constraint_get_resetPtr
|
|
.asFunction<int Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_ux(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_ux(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_uxPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_ux',
|
|
);
|
|
late final _spine_physics_constraint_set_ux = _spine_physics_constraint_set_uxPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_ux(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_ux(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_uxPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_ux');
|
|
late final _spine_physics_constraint_get_ux = _spine_physics_constraint_get_uxPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_uy(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_uy(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_uyPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_uy',
|
|
);
|
|
late final _spine_physics_constraint_set_uy = _spine_physics_constraint_set_uyPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_uy(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_uy(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_uyPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_uy');
|
|
late final _spine_physics_constraint_get_uy = _spine_physics_constraint_get_uyPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_cx(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_cx(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_cxPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_cx',
|
|
);
|
|
late final _spine_physics_constraint_set_cx = _spine_physics_constraint_set_cxPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_cx(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_cx(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_cxPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_cx');
|
|
late final _spine_physics_constraint_get_cx = _spine_physics_constraint_get_cxPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_cy(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_cy(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_cyPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_cy',
|
|
);
|
|
late final _spine_physics_constraint_set_cy = _spine_physics_constraint_set_cyPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_cy(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_cy(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_cyPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_cy');
|
|
late final _spine_physics_constraint_get_cy = _spine_physics_constraint_get_cyPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_tx(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_tx(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_txPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_tx',
|
|
);
|
|
late final _spine_physics_constraint_set_tx = _spine_physics_constraint_set_txPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_tx(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_tx(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_txPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_tx');
|
|
late final _spine_physics_constraint_get_tx = _spine_physics_constraint_get_txPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_ty(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_ty(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_tyPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_ty',
|
|
);
|
|
late final _spine_physics_constraint_set_ty = _spine_physics_constraint_set_tyPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_ty(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_ty(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_tyPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>('spine_physics_constraint_get_ty');
|
|
late final _spine_physics_constraint_get_ty = _spine_physics_constraint_get_tyPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_x_offset(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_x_offset(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_x_offsetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_x_offset',
|
|
);
|
|
late final _spine_physics_constraint_set_x_offset = _spine_physics_constraint_set_x_offsetPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_x_offset(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_x_offset(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_x_offsetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_x_offset',
|
|
);
|
|
late final _spine_physics_constraint_get_x_offset = _spine_physics_constraint_get_x_offsetPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_x_velocity(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_x_velocity(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_x_velocityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_x_velocity',
|
|
);
|
|
late final _spine_physics_constraint_set_x_velocity = _spine_physics_constraint_set_x_velocityPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_x_velocity(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_x_velocity(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_x_velocityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_x_velocity',
|
|
);
|
|
late final _spine_physics_constraint_get_x_velocity = _spine_physics_constraint_get_x_velocityPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_y_offset(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_y_offset(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_y_offsetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_y_offset',
|
|
);
|
|
late final _spine_physics_constraint_set_y_offset = _spine_physics_constraint_set_y_offsetPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_y_offset(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_y_offset(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_y_offsetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_y_offset',
|
|
);
|
|
late final _spine_physics_constraint_get_y_offset = _spine_physics_constraint_get_y_offsetPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_y_velocity(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_y_velocity(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_y_velocityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_y_velocity',
|
|
);
|
|
late final _spine_physics_constraint_set_y_velocity = _spine_physics_constraint_set_y_velocityPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_y_velocity(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_y_velocity(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_y_velocityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_y_velocity',
|
|
);
|
|
late final _spine_physics_constraint_get_y_velocity = _spine_physics_constraint_get_y_velocityPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_rotate_offset(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_rotate_offset(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_rotate_offsetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_rotate_offset',
|
|
);
|
|
late final _spine_physics_constraint_set_rotate_offset = _spine_physics_constraint_set_rotate_offsetPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_rotate_offset(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_rotate_offset(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_rotate_offsetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_rotate_offset',
|
|
);
|
|
late final _spine_physics_constraint_get_rotate_offset = _spine_physics_constraint_get_rotate_offsetPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_rotate_velocity(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_rotate_velocity(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_rotate_velocityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_rotate_velocity',
|
|
);
|
|
late final _spine_physics_constraint_set_rotate_velocity = _spine_physics_constraint_set_rotate_velocityPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_rotate_velocity(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_rotate_velocity(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_rotate_velocityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_rotate_velocity',
|
|
);
|
|
late final _spine_physics_constraint_get_rotate_velocity = _spine_physics_constraint_get_rotate_velocityPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_scale_offset(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_scale_offset(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_scale_offsetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_scale_offset',
|
|
);
|
|
late final _spine_physics_constraint_set_scale_offset = _spine_physics_constraint_set_scale_offsetPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_scale_offset(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_scale_offset(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_scale_offsetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_scale_offset',
|
|
);
|
|
late final _spine_physics_constraint_get_scale_offset = _spine_physics_constraint_get_scale_offsetPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_scale_velocity(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_scale_velocity(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_scale_velocityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_scale_velocity',
|
|
);
|
|
late final _spine_physics_constraint_set_scale_velocity = _spine_physics_constraint_set_scale_velocityPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_scale_velocity(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_scale_velocity(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_scale_velocityPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_scale_velocity',
|
|
);
|
|
late final _spine_physics_constraint_get_scale_velocity = _spine_physics_constraint_get_scale_velocityPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_active(spine_physics_constraint constraint, int value) {
|
|
return _spine_physics_constraint_set_active(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_activePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, spine_bool)>>(
|
|
'spine_physics_constraint_set_active',
|
|
);
|
|
late final _spine_physics_constraint_set_active = _spine_physics_constraint_set_activePtr
|
|
.asFunction<void Function(spine_physics_constraint, int)>();
|
|
|
|
int spine_physics_constraint_is_active(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_is_active(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_is_activePtr =
|
|
_lookup<ffi.NativeFunction<spine_bool Function(spine_physics_constraint)>>('spine_physics_constraint_is_active');
|
|
late final _spine_physics_constraint_is_active = _spine_physics_constraint_is_activePtr
|
|
.asFunction<int Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_remaining(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_remaining(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_remainingPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_remaining',
|
|
);
|
|
late final _spine_physics_constraint_set_remaining = _spine_physics_constraint_set_remainingPtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_remaining(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_remaining(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_remainingPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_remaining',
|
|
);
|
|
late final _spine_physics_constraint_get_remaining = _spine_physics_constraint_get_remainingPtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_set_last_time(spine_physics_constraint constraint, double value) {
|
|
return _spine_physics_constraint_set_last_time(constraint, value);
|
|
}
|
|
|
|
late final _spine_physics_constraint_set_last_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float)>>(
|
|
'spine_physics_constraint_set_last_time',
|
|
);
|
|
late final _spine_physics_constraint_set_last_time = _spine_physics_constraint_set_last_timePtr
|
|
.asFunction<void Function(spine_physics_constraint, double)>();
|
|
|
|
double spine_physics_constraint_get_last_time(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_get_last_time(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_get_last_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_physics_constraint)>>(
|
|
'spine_physics_constraint_get_last_time',
|
|
);
|
|
late final _spine_physics_constraint_get_last_time = _spine_physics_constraint_get_last_timePtr
|
|
.asFunction<double Function(spine_physics_constraint)>();
|
|
|
|
void spine_physics_constraint_reset(spine_physics_constraint constraint) {
|
|
return _spine_physics_constraint_reset(constraint);
|
|
}
|
|
|
|
late final _spine_physics_constraint_resetPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint)>>('spine_physics_constraint_reset');
|
|
late final _spine_physics_constraint_reset = _spine_physics_constraint_resetPtr
|
|
.asFunction<void Function(spine_physics_constraint)>();
|
|
|
|
/// Omitted setToSetupPose()
|
|
void spine_physics_constraint_update(spine_physics_constraint data, int physics) {
|
|
return _spine_physics_constraint_update(data, physics);
|
|
}
|
|
|
|
late final _spine_physics_constraint_updatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Int32)>>(
|
|
'spine_physics_constraint_update',
|
|
);
|
|
late final _spine_physics_constraint_update = _spine_physics_constraint_updatePtr
|
|
.asFunction<void Function(spine_physics_constraint, int)>();
|
|
|
|
void spine_physics_constraint_translate(spine_physics_constraint data, double x, double y) {
|
|
return _spine_physics_constraint_translate(data, x, y);
|
|
}
|
|
|
|
late final _spine_physics_constraint_translatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float, ffi.Float)>>(
|
|
'spine_physics_constraint_translate',
|
|
);
|
|
late final _spine_physics_constraint_translate = _spine_physics_constraint_translatePtr
|
|
.asFunction<void Function(spine_physics_constraint, double, double)>();
|
|
|
|
void spine_physics_constraint_rotate(spine_physics_constraint data, double x, double y, double degrees) {
|
|
return _spine_physics_constraint_rotate(data, x, y, degrees);
|
|
}
|
|
|
|
late final _spine_physics_constraint_rotatePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_physics_constraint, ffi.Float, ffi.Float, ffi.Float)>>(
|
|
'spine_physics_constraint_rotate',
|
|
);
|
|
late final _spine_physics_constraint_rotate = _spine_physics_constraint_rotatePtr
|
|
.asFunction<void Function(spine_physics_constraint, double, double, double)>();
|
|
|
|
/// OMITTED copy()
|
|
void spine_sequence_apply(spine_sequence sequence, spine_slot slot, spine_attachment attachment) {
|
|
return _spine_sequence_apply(sequence, slot, attachment);
|
|
}
|
|
|
|
late final _spine_sequence_applyPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, spine_slot, spine_attachment)>>(
|
|
'spine_sequence_apply',
|
|
);
|
|
late final _spine_sequence_apply = _spine_sequence_applyPtr
|
|
.asFunction<void Function(spine_sequence, spine_slot, spine_attachment)>();
|
|
|
|
ffi.Pointer<utf8> spine_sequence_get_path(spine_sequence sequence, ffi.Pointer<utf8> basePath, int index) {
|
|
return _spine_sequence_get_path(sequence, basePath, index);
|
|
}
|
|
|
|
late final _spine_sequence_get_pathPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<utf8> Function(spine_sequence, ffi.Pointer<utf8>, ffi.Int32)>>(
|
|
'spine_sequence_get_path',
|
|
);
|
|
late final _spine_sequence_get_path = _spine_sequence_get_pathPtr
|
|
.asFunction<ffi.Pointer<utf8> Function(spine_sequence, ffi.Pointer<utf8>, int)>();
|
|
|
|
int spine_sequence_get_id(spine_sequence sequence) {
|
|
return _spine_sequence_get_id(sequence);
|
|
}
|
|
|
|
late final _spine_sequence_get_idPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_sequence)>>(
|
|
'spine_sequence_get_id',
|
|
);
|
|
late final _spine_sequence_get_id = _spine_sequence_get_idPtr.asFunction<int Function(spine_sequence)>();
|
|
|
|
void spine_sequence_set_id(spine_sequence sequence, int id) {
|
|
return _spine_sequence_set_id(sequence, id);
|
|
}
|
|
|
|
late final _spine_sequence_set_idPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int32)>>(
|
|
'spine_sequence_set_id',
|
|
);
|
|
late final _spine_sequence_set_id = _spine_sequence_set_idPtr.asFunction<void Function(spine_sequence, int)>();
|
|
|
|
int spine_sequence_get_start(spine_sequence sequence) {
|
|
return _spine_sequence_get_start(sequence);
|
|
}
|
|
|
|
late final _spine_sequence_get_startPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_sequence)>>(
|
|
'spine_sequence_get_start',
|
|
);
|
|
late final _spine_sequence_get_start = _spine_sequence_get_startPtr.asFunction<int Function(spine_sequence)>();
|
|
|
|
void spine_sequence_set_start(spine_sequence sequence, int start) {
|
|
return _spine_sequence_set_start(sequence, start);
|
|
}
|
|
|
|
late final _spine_sequence_set_startPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int32)>>(
|
|
'spine_sequence_set_start',
|
|
);
|
|
late final _spine_sequence_set_start = _spine_sequence_set_startPtr.asFunction<void Function(spine_sequence, int)>();
|
|
|
|
int spine_sequence_get_digits(spine_sequence sequence) {
|
|
return _spine_sequence_get_digits(sequence);
|
|
}
|
|
|
|
late final _spine_sequence_get_digitsPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_sequence)>>(
|
|
'spine_sequence_get_digits',
|
|
);
|
|
late final _spine_sequence_get_digits = _spine_sequence_get_digitsPtr.asFunction<int Function(spine_sequence)>();
|
|
|
|
void spine_sequence_set_digits(spine_sequence sequence, int digits) {
|
|
return _spine_sequence_set_digits(sequence, digits);
|
|
}
|
|
|
|
late final _spine_sequence_set_digitsPtr = _lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int32)>>(
|
|
'spine_sequence_set_digits',
|
|
);
|
|
late final _spine_sequence_set_digits = _spine_sequence_set_digitsPtr
|
|
.asFunction<void Function(spine_sequence, int)>();
|
|
|
|
int spine_sequence_get_setup_index(spine_sequence sequence) {
|
|
return _spine_sequence_get_setup_index(sequence);
|
|
}
|
|
|
|
late final _spine_sequence_get_setup_indexPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_sequence)>>(
|
|
'spine_sequence_get_setup_index',
|
|
);
|
|
late final _spine_sequence_get_setup_index = _spine_sequence_get_setup_indexPtr
|
|
.asFunction<int Function(spine_sequence)>();
|
|
|
|
void spine_sequence_set_setup_index(spine_sequence sequence, int setupIndex) {
|
|
return _spine_sequence_set_setup_index(sequence, setupIndex);
|
|
}
|
|
|
|
late final _spine_sequence_set_setup_indexPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_sequence, ffi.Int32)>>('spine_sequence_set_setup_index');
|
|
late final _spine_sequence_set_setup_index = _spine_sequence_set_setup_indexPtr
|
|
.asFunction<void Function(spine_sequence, int)>();
|
|
|
|
int spine_sequence_get_num_regions(spine_sequence sequence) {
|
|
return _spine_sequence_get_num_regions(sequence);
|
|
}
|
|
|
|
late final _spine_sequence_get_num_regionsPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_sequence)>>(
|
|
'spine_sequence_get_num_regions',
|
|
);
|
|
late final _spine_sequence_get_num_regions = _spine_sequence_get_num_regionsPtr
|
|
.asFunction<int Function(spine_sequence)>();
|
|
|
|
ffi.Pointer<spine_texture_region> spine_sequence_get_regions(spine_sequence sequence) {
|
|
return _spine_sequence_get_regions(sequence);
|
|
}
|
|
|
|
late final _spine_sequence_get_regionsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<spine_texture_region> Function(spine_sequence)>>(
|
|
'spine_sequence_get_regions',
|
|
);
|
|
late final _spine_sequence_get_regions = _spine_sequence_get_regionsPtr
|
|
.asFunction<ffi.Pointer<spine_texture_region> Function(spine_sequence)>();
|
|
|
|
ffi.Pointer<ffi.Void> spine_texture_region_get_texture(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_texture(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_texturePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(spine_texture_region)>>(
|
|
'spine_texture_region_get_texture',
|
|
);
|
|
late final _spine_texture_region_get_texture = _spine_texture_region_get_texturePtr
|
|
.asFunction<ffi.Pointer<ffi.Void> Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_texture(spine_texture_region textureRegion, ffi.Pointer<ffi.Void> texture) {
|
|
return _spine_texture_region_set_texture(textureRegion, texture);
|
|
}
|
|
|
|
late final _spine_texture_region_set_texturePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Pointer<ffi.Void>)>>(
|
|
'spine_texture_region_set_texture',
|
|
);
|
|
late final _spine_texture_region_set_texture = _spine_texture_region_set_texturePtr
|
|
.asFunction<void Function(spine_texture_region, ffi.Pointer<ffi.Void>)>();
|
|
|
|
double spine_texture_region_get_u(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_u(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_uPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>(
|
|
'spine_texture_region_get_u',
|
|
);
|
|
late final _spine_texture_region_get_u = _spine_texture_region_get_uPtr
|
|
.asFunction<double Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_u(spine_texture_region textureRegion, double u) {
|
|
return _spine_texture_region_set_u(textureRegion, u);
|
|
}
|
|
|
|
late final _spine_texture_region_set_uPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>('spine_texture_region_set_u');
|
|
late final _spine_texture_region_set_u = _spine_texture_region_set_uPtr
|
|
.asFunction<void Function(spine_texture_region, double)>();
|
|
|
|
double spine_texture_region_get_v(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_v(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_vPtr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>(
|
|
'spine_texture_region_get_v',
|
|
);
|
|
late final _spine_texture_region_get_v = _spine_texture_region_get_vPtr
|
|
.asFunction<double Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_v(spine_texture_region textureRegion, double v) {
|
|
return _spine_texture_region_set_v(textureRegion, v);
|
|
}
|
|
|
|
late final _spine_texture_region_set_vPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>('spine_texture_region_set_v');
|
|
late final _spine_texture_region_set_v = _spine_texture_region_set_vPtr
|
|
.asFunction<void Function(spine_texture_region, double)>();
|
|
|
|
double spine_texture_region_get_u2(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_u2(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_u2Ptr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>(
|
|
'spine_texture_region_get_u2',
|
|
);
|
|
late final _spine_texture_region_get_u2 = _spine_texture_region_get_u2Ptr
|
|
.asFunction<double Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_u2(spine_texture_region textureRegion, double u2) {
|
|
return _spine_texture_region_set_u2(textureRegion, u2);
|
|
}
|
|
|
|
late final _spine_texture_region_set_u2Ptr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>('spine_texture_region_set_u2');
|
|
late final _spine_texture_region_set_u2 = _spine_texture_region_set_u2Ptr
|
|
.asFunction<void Function(spine_texture_region, double)>();
|
|
|
|
double spine_texture_region_get_v2(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_v2(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_v2Ptr = _lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>(
|
|
'spine_texture_region_get_v2',
|
|
);
|
|
late final _spine_texture_region_get_v2 = _spine_texture_region_get_v2Ptr
|
|
.asFunction<double Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_v2(spine_texture_region textureRegion, double v2) {
|
|
return _spine_texture_region_set_v2(textureRegion, v2);
|
|
}
|
|
|
|
late final _spine_texture_region_set_v2Ptr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>('spine_texture_region_set_v2');
|
|
late final _spine_texture_region_set_v2 = _spine_texture_region_set_v2Ptr
|
|
.asFunction<void Function(spine_texture_region, double)>();
|
|
|
|
int spine_texture_region_get_degrees(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_degrees(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_degreesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_texture_region)>>('spine_texture_region_get_degrees');
|
|
late final _spine_texture_region_get_degrees = _spine_texture_region_get_degreesPtr
|
|
.asFunction<int Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_degrees(spine_texture_region textureRegion, int degrees) {
|
|
return _spine_texture_region_set_degrees(textureRegion, degrees);
|
|
}
|
|
|
|
late final _spine_texture_region_set_degreesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int32)>>(
|
|
'spine_texture_region_set_degrees',
|
|
);
|
|
late final _spine_texture_region_set_degrees = _spine_texture_region_set_degreesPtr
|
|
.asFunction<void Function(spine_texture_region, int)>();
|
|
|
|
double spine_texture_region_get_offset_x(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_offset_x(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_offset_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>('spine_texture_region_get_offset_x');
|
|
late final _spine_texture_region_get_offset_x = _spine_texture_region_get_offset_xPtr
|
|
.asFunction<double Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_offset_x(spine_texture_region textureRegion, double offsetX) {
|
|
return _spine_texture_region_set_offset_x(textureRegion, offsetX);
|
|
}
|
|
|
|
late final _spine_texture_region_set_offset_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>(
|
|
'spine_texture_region_set_offset_x',
|
|
);
|
|
late final _spine_texture_region_set_offset_x = _spine_texture_region_set_offset_xPtr
|
|
.asFunction<void Function(spine_texture_region, double)>();
|
|
|
|
double spine_texture_region_get_offset_y(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_offset_y(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_offset_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_texture_region)>>('spine_texture_region_get_offset_y');
|
|
late final _spine_texture_region_get_offset_y = _spine_texture_region_get_offset_yPtr
|
|
.asFunction<double Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_offset_y(spine_texture_region textureRegion, double offsetY) {
|
|
return _spine_texture_region_set_offset_y(textureRegion, offsetY);
|
|
}
|
|
|
|
late final _spine_texture_region_set_offset_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Float)>>(
|
|
'spine_texture_region_set_offset_y',
|
|
);
|
|
late final _spine_texture_region_set_offset_y = _spine_texture_region_set_offset_yPtr
|
|
.asFunction<void Function(spine_texture_region, double)>();
|
|
|
|
int spine_texture_region_get_width(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_width(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_widthPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(spine_texture_region)>>(
|
|
'spine_texture_region_get_width',
|
|
);
|
|
late final _spine_texture_region_get_width = _spine_texture_region_get_widthPtr
|
|
.asFunction<int Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_width(spine_texture_region textureRegion, int width) {
|
|
return _spine_texture_region_set_width(textureRegion, width);
|
|
}
|
|
|
|
late final _spine_texture_region_set_widthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int32)>>('spine_texture_region_set_width');
|
|
late final _spine_texture_region_set_width = _spine_texture_region_set_widthPtr
|
|
.asFunction<void Function(spine_texture_region, int)>();
|
|
|
|
int spine_texture_region_get_height(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_height(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_heightPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_texture_region)>>('spine_texture_region_get_height');
|
|
late final _spine_texture_region_get_height = _spine_texture_region_get_heightPtr
|
|
.asFunction<int Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_height(spine_texture_region textureRegion, int height) {
|
|
return _spine_texture_region_set_height(textureRegion, height);
|
|
}
|
|
|
|
late final _spine_texture_region_set_heightPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int32)>>(
|
|
'spine_texture_region_set_height',
|
|
);
|
|
late final _spine_texture_region_set_height = _spine_texture_region_set_heightPtr
|
|
.asFunction<void Function(spine_texture_region, int)>();
|
|
|
|
int spine_texture_region_get_original_width(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_original_width(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_original_widthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_texture_region)>>('spine_texture_region_get_original_width');
|
|
late final _spine_texture_region_get_original_width = _spine_texture_region_get_original_widthPtr
|
|
.asFunction<int Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_original_width(spine_texture_region textureRegion, int originalWidth) {
|
|
return _spine_texture_region_set_original_width(textureRegion, originalWidth);
|
|
}
|
|
|
|
late final _spine_texture_region_set_original_widthPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int32)>>(
|
|
'spine_texture_region_set_original_width',
|
|
);
|
|
late final _spine_texture_region_set_original_width = _spine_texture_region_set_original_widthPtr
|
|
.asFunction<void Function(spine_texture_region, int)>();
|
|
|
|
int spine_texture_region_get_original_height(spine_texture_region textureRegion) {
|
|
return _spine_texture_region_get_original_height(textureRegion);
|
|
}
|
|
|
|
late final _spine_texture_region_get_original_heightPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_texture_region)>>('spine_texture_region_get_original_height');
|
|
late final _spine_texture_region_get_original_height = _spine_texture_region_get_original_heightPtr
|
|
.asFunction<int Function(spine_texture_region)>();
|
|
|
|
void spine_texture_region_set_original_height(spine_texture_region textureRegion, int originalHeight) {
|
|
return _spine_texture_region_set_original_height(textureRegion, originalHeight);
|
|
}
|
|
|
|
late final _spine_texture_region_set_original_heightPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_texture_region, ffi.Int32)>>(
|
|
'spine_texture_region_set_original_height',
|
|
);
|
|
late final _spine_texture_region_set_original_height = _spine_texture_region_set_original_heightPtr
|
|
.asFunction<void Function(spine_texture_region, int)>();
|
|
}
|
|
|
|
class spine_skeleton_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_skeleton_data_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_bone_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_bone_data_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_slot_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_slot_data_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_skin_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_attachment_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_region_attachment_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_vertex_attachment_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_mesh_attachment_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_clipping_attachment_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_bounding_box_attachment_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_path_attachment_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_point_attachment_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_texture_region_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_sequence_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_constraint_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_constraint_data_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_ik_constraint_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_ik_constraint_data_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_transform_constraint_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_transform_constraint_data_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_path_constraint_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_path_constraint_data_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_physics_constraint_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_physics_constraint_data_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_animation_state_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_animation_state_data_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_animation_state_events_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_event_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_event_data_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_track_entry_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_animation_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_atlas_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_skeleton_data_result_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_render_command_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_bounds_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_color_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_vector_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_skeleton_drawable_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_skin_entry_wrapper extends ffi.Opaque {}
|
|
|
|
class spine_skin_entries_wrapper extends ffi.Opaque {}
|
|
|
|
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;
|
|
}
|
|
|
|
abstract class spine_attachment_type {
|
|
static const int SPINE_ATTACHMENT_REGION = 0;
|
|
static const int SPINE_ATTACHMENT_MESH = 1;
|
|
static const int SPINE_ATTACHMENT_CLIPPING = 2;
|
|
static const int SPINE_ATTACHMENT_BOUNDING_BOX = 3;
|
|
static const int SPINE_ATTACHMENT_PATH = 4;
|
|
static const int SPINE_ATTACHMENT_POINT = 5;
|
|
}
|
|
|
|
abstract class spine_constraint_type {
|
|
static const int SPINE_CONSTRAINT_IK = 0;
|
|
static const int SPINE_CONSTRAINT_TRANSFORM = 1;
|
|
static const int SPINE_CONSTRAINT_PATH = 2;
|
|
}
|
|
|
|
abstract class spine_inherit {
|
|
static const int SPINE_INHERIT_NORMAL = 0;
|
|
static const int SPINE_INHERIT_ONLY_TRANSLATION = 1;
|
|
static const int SPINE_INHERIT_NO_ROTATION_OR_REFLECTION = 2;
|
|
static const int SPINE_INHERIT_NO_SCALE = 3;
|
|
static const int SPINE_INHERIT_NO_SCALE_OR_REFLECTION = 4;
|
|
}
|
|
|
|
abstract class spine_position_mode {
|
|
static const int SPINE_POSITION_MODE_FIXED = 0;
|
|
static const int SPINE_POSITION_MODE_PERCENT = 1;
|
|
}
|
|
|
|
abstract class spine_spacing_mode {
|
|
static const int SPINE_SPACING_MODE_LENGTH = 0;
|
|
static const int SPINE_SPACING_MODE_FIXED = 1;
|
|
static const int SPINE_SPACING_MODE_PERCENT = 2;
|
|
static const int SPINE_SPACING_MODE_PROPORTIONAL = 3;
|
|
}
|
|
|
|
abstract class spine_rotate_mode {
|
|
static const int SPINE_ROTATE_MODE_TANGENT = 0;
|
|
static const int SPINE_ROTATE_MODE_CHAIN = 1;
|
|
static const int SPINE_ROTATE_MODE_CHAIN_SCALE = 2;
|
|
}
|
|
|
|
abstract class spine_physics {
|
|
static const int SPINE_PHYSICS_NONE = 0;
|
|
static const int SPINE_PHYSICS_RESET = 1;
|
|
static const int SPINE_PHYSICS_UPDATE = 2;
|
|
static const int SPINE_PHYSICS_POSE = 3;
|
|
}
|
|
|
|
typedef spine_bool = ffi.Int32;
|
|
typedef Dartspine_bool = int;
|
|
typedef spine_color = ffi.Pointer<spine_color_wrapper>;
|
|
typedef spine_bounds = ffi.Pointer<spine_bounds_wrapper>;
|
|
typedef spine_vector = ffi.Pointer<spine_vector_wrapper>;
|
|
typedef spine_atlas = ffi.Pointer<spine_atlas_wrapper>;
|
|
typedef utf8 = ffi.Char;
|
|
typedef Dartutf8 = int;
|
|
typedef spine_skeleton_data_result = ffi.Pointer<spine_skeleton_data_result_wrapper>;
|
|
typedef spine_skeleton_data = ffi.Pointer<spine_skeleton_data_wrapper>;
|
|
typedef spine_bone_data = ffi.Pointer<spine_bone_data_wrapper>;
|
|
typedef spine_slot_data = ffi.Pointer<spine_slot_data_wrapper>;
|
|
typedef spine_skin = ffi.Pointer<spine_skin_wrapper>;
|
|
typedef spine_event_data = ffi.Pointer<spine_event_data_wrapper>;
|
|
typedef spine_animation = ffi.Pointer<spine_animation_wrapper>;
|
|
typedef spine_ik_constraint_data = ffi.Pointer<spine_ik_constraint_data_wrapper>;
|
|
typedef spine_transform_constraint_data = ffi.Pointer<spine_transform_constraint_data_wrapper>;
|
|
typedef spine_path_constraint_data = ffi.Pointer<spine_path_constraint_data_wrapper>;
|
|
typedef spine_physics_constraint_data = ffi.Pointer<spine_physics_constraint_data_wrapper>;
|
|
typedef spine_skeleton_drawable = ffi.Pointer<spine_skeleton_drawable_wrapper>;
|
|
typedef spine_render_command = ffi.Pointer<spine_render_command_wrapper>;
|
|
typedef spine_skeleton = ffi.Pointer<spine_skeleton_wrapper>;
|
|
typedef spine_animation_state = ffi.Pointer<spine_animation_state_wrapper>;
|
|
typedef spine_animation_state_data = ffi.Pointer<spine_animation_state_data_wrapper>;
|
|
typedef spine_animation_state_events = ffi.Pointer<spine_animation_state_events_wrapper>;
|
|
typedef spine_track_entry = ffi.Pointer<spine_track_entry_wrapper>;
|
|
typedef spine_event = ffi.Pointer<spine_event_wrapper>;
|
|
typedef spine_bone = ffi.Pointer<spine_bone_wrapper>;
|
|
typedef spine_slot = ffi.Pointer<spine_slot_wrapper>;
|
|
typedef spine_attachment = ffi.Pointer<spine_attachment_wrapper>;
|
|
typedef spine_ik_constraint = ffi.Pointer<spine_ik_constraint_wrapper>;
|
|
typedef spine_transform_constraint = ffi.Pointer<spine_transform_constraint_wrapper>;
|
|
typedef spine_path_constraint = ffi.Pointer<spine_path_constraint_wrapper>;
|
|
typedef spine_physics_constraint = ffi.Pointer<spine_physics_constraint_wrapper>;
|
|
typedef spine_point_attachment = ffi.Pointer<spine_point_attachment_wrapper>;
|
|
typedef spine_region_attachment = ffi.Pointer<spine_region_attachment_wrapper>;
|
|
typedef spine_texture_region = ffi.Pointer<spine_texture_region_wrapper>;
|
|
typedef spine_sequence = ffi.Pointer<spine_sequence_wrapper>;
|
|
typedef spine_vertex_attachment = ffi.Pointer<spine_vertex_attachment_wrapper>;
|
|
typedef spine_mesh_attachment = ffi.Pointer<spine_mesh_attachment_wrapper>;
|
|
typedef spine_clipping_attachment = ffi.Pointer<spine_clipping_attachment_wrapper>;
|
|
typedef spine_bounding_box_attachment = ffi.Pointer<spine_bounding_box_attachment_wrapper>;
|
|
typedef spine_path_attachment = ffi.Pointer<spine_path_attachment_wrapper>;
|
|
typedef spine_skin_entries = ffi.Pointer<spine_skin_entries_wrapper>;
|
|
typedef spine_skin_entry = ffi.Pointer<spine_skin_entry_wrapper>;
|
|
typedef spine_constraint_data = ffi.Pointer<spine_constraint_data_wrapper>;
|