mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2026-02-04 22:34:53 +08:00
8515 lines
304 KiB
Dart
8515 lines
304 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`.
|
|
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(ffi.Int32)>>('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>)>();
|
|
|
|
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)>();
|
|
|
|
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()
|
|
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>, ffi.Int32)>>(
|
|
'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, ffi.Int32)>>(
|
|
'spine_animation_state_set_animation');
|
|
late final _spine_animation_state_set_animation =
|
|
_spine_animation_state_set_animationPtr.asFunction<spine_track_entry Function(spine_animation_state, int, 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>, ffi.Int32, 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, ffi.Int32, ffi.Float)>>(
|
|
'spine_animation_state_add_animation');
|
|
late final _spine_animation_state_add_animation = _spine_animation_state_add_animationPtr
|
|
.asFunction<spine_track_entry Function(spine_animation_state, int, 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<ffi.Int32 Function(spine_track_entry)>>('spine_track_entry_get_loop');
|
|
late final _spine_track_entry_get_loop = _spine_track_entry_get_loopPtr.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_loop(
|
|
spine_track_entry entry,
|
|
int loop,
|
|
) {
|
|
return _spine_track_entry_set_loop(
|
|
entry,
|
|
loop,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_loopPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>('spine_track_entry_set_loop');
|
|
late final _spine_track_entry_set_loop = _spine_track_entry_set_loopPtr.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
int spine_track_entry_get_hold_previous(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_hold_previous(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_hold_previousPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>('spine_track_entry_get_hold_previous');
|
|
late final _spine_track_entry_get_hold_previous = _spine_track_entry_get_hold_previousPtr.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_hold_previous(
|
|
spine_track_entry entry,
|
|
int holdPrevious,
|
|
) {
|
|
return _spine_track_entry_set_hold_previous(
|
|
entry,
|
|
holdPrevious,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_hold_previousPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>('spine_track_entry_set_hold_previous');
|
|
late final _spine_track_entry_set_hold_previous =
|
|
_spine_track_entry_set_hold_previousPtr.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
int spine_track_entry_get_reverse(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_reverse(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_reversePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>('spine_track_entry_get_reverse');
|
|
late final _spine_track_entry_get_reverse = _spine_track_entry_get_reversePtr.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_reverse(
|
|
spine_track_entry entry,
|
|
int reverse,
|
|
) {
|
|
return _spine_track_entry_set_reverse(
|
|
entry,
|
|
reverse,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_reversePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>('spine_track_entry_set_reverse');
|
|
late final _spine_track_entry_set_reverse = _spine_track_entry_set_reversePtr.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
int spine_track_entry_get_shortest_rotation(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_shortest_rotation(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_shortest_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>('spine_track_entry_get_shortest_rotation');
|
|
late final _spine_track_entry_get_shortest_rotation =
|
|
_spine_track_entry_get_shortest_rotationPtr.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_shortest_rotation(
|
|
spine_track_entry entry,
|
|
int shortestRotation,
|
|
) {
|
|
return _spine_track_entry_set_shortest_rotation(
|
|
entry,
|
|
shortestRotation,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_shortest_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>('spine_track_entry_set_shortest_rotation');
|
|
late final _spine_track_entry_set_shortest_rotation =
|
|
_spine_track_entry_set_shortest_rotationPtr.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
double spine_track_entry_get_delay(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_delay(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_delayPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_delay');
|
|
late final _spine_track_entry_get_delay = _spine_track_entry_get_delayPtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_delay(
|
|
spine_track_entry entry,
|
|
double delay,
|
|
) {
|
|
return _spine_track_entry_set_delay(
|
|
entry,
|
|
delay,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_delayPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_delay');
|
|
late final _spine_track_entry_set_delay = _spine_track_entry_set_delayPtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_track_time(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_time(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_track_time');
|
|
late final _spine_track_entry_get_track_time = _spine_track_entry_get_track_timePtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_track_time(
|
|
spine_track_entry entry,
|
|
double trackTime,
|
|
) {
|
|
return _spine_track_entry_set_track_time(
|
|
entry,
|
|
trackTime,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_track_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_track_time');
|
|
late final _spine_track_entry_set_track_time =
|
|
_spine_track_entry_set_track_timePtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_track_end(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_end(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_endPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_track_end');
|
|
late final _spine_track_entry_get_track_end = _spine_track_entry_get_track_endPtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_track_end(
|
|
spine_track_entry entry,
|
|
double trackEnd,
|
|
) {
|
|
return _spine_track_entry_set_track_end(
|
|
entry,
|
|
trackEnd,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_track_endPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_track_end');
|
|
late final _spine_track_entry_set_track_end = _spine_track_entry_set_track_endPtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_start(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_start(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_startPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_animation_start');
|
|
late final _spine_track_entry_get_animation_start =
|
|
_spine_track_entry_get_animation_startPtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_animation_start(
|
|
spine_track_entry entry,
|
|
double animationStart,
|
|
) {
|
|
return _spine_track_entry_set_animation_start(
|
|
entry,
|
|
animationStart,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_animation_startPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_animation_start');
|
|
late final _spine_track_entry_set_animation_start =
|
|
_spine_track_entry_set_animation_startPtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_end(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_end(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_endPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_animation_end');
|
|
late final _spine_track_entry_get_animation_end =
|
|
_spine_track_entry_get_animation_endPtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_animation_end(
|
|
spine_track_entry entry,
|
|
double animationEnd,
|
|
) {
|
|
return _spine_track_entry_set_animation_end(
|
|
entry,
|
|
animationEnd,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_animation_endPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_animation_end');
|
|
late final _spine_track_entry_set_animation_end =
|
|
_spine_track_entry_set_animation_endPtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_last(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_last(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_lastPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_animation_last');
|
|
late final _spine_track_entry_get_animation_last =
|
|
_spine_track_entry_get_animation_lastPtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_animation_last(
|
|
spine_track_entry entry,
|
|
double animationLast,
|
|
) {
|
|
return _spine_track_entry_set_animation_last(
|
|
entry,
|
|
animationLast,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_animation_lastPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_animation_last');
|
|
late final _spine_track_entry_set_animation_last =
|
|
_spine_track_entry_set_animation_lastPtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_time(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_time(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_animation_time');
|
|
late final _spine_track_entry_get_animation_time =
|
|
_spine_track_entry_get_animation_timePtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
double spine_track_entry_get_time_scale(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_time_scale(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_time_scalePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_time_scale');
|
|
late final _spine_track_entry_get_time_scale = _spine_track_entry_get_time_scalePtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_time_scale(
|
|
spine_track_entry entry,
|
|
double timeScale,
|
|
) {
|
|
return _spine_track_entry_set_time_scale(
|
|
entry,
|
|
timeScale,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_time_scalePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_time_scale');
|
|
late final _spine_track_entry_set_time_scale =
|
|
_spine_track_entry_set_time_scalePtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_alpha(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_alpha(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_alphaPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_alpha');
|
|
late final _spine_track_entry_get_alpha = _spine_track_entry_get_alphaPtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_alpha(
|
|
spine_track_entry entry,
|
|
double alpha,
|
|
) {
|
|
return _spine_track_entry_set_alpha(
|
|
entry,
|
|
alpha,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_alphaPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_alpha');
|
|
late final _spine_track_entry_set_alpha = _spine_track_entry_set_alphaPtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_event_threshold(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_event_threshold(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_event_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_event_threshold');
|
|
late final _spine_track_entry_get_event_threshold =
|
|
_spine_track_entry_get_event_thresholdPtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_event_threshold(
|
|
spine_track_entry entry,
|
|
double eventThreshold,
|
|
) {
|
|
return _spine_track_entry_set_event_threshold(
|
|
entry,
|
|
eventThreshold,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_event_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_event_threshold');
|
|
late final _spine_track_entry_set_event_threshold =
|
|
_spine_track_entry_set_event_thresholdPtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_attachment_threshold(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_attachment_threshold(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_attachment_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_attachment_threshold');
|
|
late final _spine_track_entry_get_attachment_threshold =
|
|
_spine_track_entry_get_attachment_thresholdPtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_attachment_threshold(
|
|
spine_track_entry entry,
|
|
double attachmentThreshold,
|
|
) {
|
|
return _spine_track_entry_set_attachment_threshold(
|
|
entry,
|
|
attachmentThreshold,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_attachment_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_attachment_threshold');
|
|
late final _spine_track_entry_set_attachment_threshold =
|
|
_spine_track_entry_set_attachment_thresholdPtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_draw_order_threshold(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_draw_order_threshold(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_draw_order_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_draw_order_threshold');
|
|
late final _spine_track_entry_get_draw_order_threshold =
|
|
_spine_track_entry_get_draw_order_thresholdPtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_draw_order_threshold(
|
|
spine_track_entry entry,
|
|
double drawOrderThreshold,
|
|
) {
|
|
return _spine_track_entry_set_draw_order_threshold(
|
|
entry,
|
|
drawOrderThreshold,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_draw_order_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_draw_order_threshold');
|
|
late final _spine_track_entry_set_draw_order_threshold =
|
|
_spine_track_entry_set_draw_order_thresholdPtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
spine_track_entry spine_track_entry_get_next(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_next(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_nextPtr =
|
|
_lookup<ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>('spine_track_entry_get_next');
|
|
late final _spine_track_entry_get_next = _spine_track_entry_get_nextPtr.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
int spine_track_entry_is_complete(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_is_complete(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_is_completePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>('spine_track_entry_is_complete');
|
|
late final _spine_track_entry_is_complete = _spine_track_entry_is_completePtr.asFunction<int Function(spine_track_entry)>();
|
|
|
|
double spine_track_entry_get_mix_time(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mix_time(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_mix_time');
|
|
late final _spine_track_entry_get_mix_time = _spine_track_entry_get_mix_timePtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_time(
|
|
spine_track_entry entry,
|
|
double mixTime,
|
|
) {
|
|
return _spine_track_entry_set_mix_time(
|
|
entry,
|
|
mixTime,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_mix_time');
|
|
late final _spine_track_entry_set_mix_time = _spine_track_entry_set_mix_timePtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_mix_duration(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mix_duration(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_durationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_mix_duration');
|
|
late final _spine_track_entry_get_mix_duration = _spine_track_entry_get_mix_durationPtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_duration(
|
|
spine_track_entry entry,
|
|
double mixDuration,
|
|
) {
|
|
return _spine_track_entry_set_mix_duration(
|
|
entry,
|
|
mixDuration,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_durationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>('spine_track_entry_set_mix_duration');
|
|
late final _spine_track_entry_set_mix_duration =
|
|
_spine_track_entry_set_mix_durationPtr.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
int spine_track_entry_get_mix_blend(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mix_blend(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_blendPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>('spine_track_entry_get_mix_blend');
|
|
late final _spine_track_entry_get_mix_blend = _spine_track_entry_get_mix_blendPtr.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_blend(
|
|
spine_track_entry entry,
|
|
int mixBlend,
|
|
) {
|
|
return _spine_track_entry_set_mix_blend(
|
|
entry,
|
|
mixBlend,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_blendPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>('spine_track_entry_set_mix_blend');
|
|
late final _spine_track_entry_set_mix_blend = _spine_track_entry_set_mix_blendPtr.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
spine_track_entry spine_track_entry_get_mixing_from(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mixing_from(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mixing_fromPtr =
|
|
_lookup<ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>('spine_track_entry_get_mixing_from');
|
|
late final _spine_track_entry_get_mixing_from =
|
|
_spine_track_entry_get_mixing_fromPtr.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
spine_track_entry spine_track_entry_get_mixing_to(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mixing_to(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mixing_toPtr =
|
|
_lookup<ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>('spine_track_entry_get_mixing_to');
|
|
late final _spine_track_entry_get_mixing_to =
|
|
_spine_track_entry_get_mixing_toPtr.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_reset_rotation_directions(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_reset_rotation_directions(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_reset_rotation_directionsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry)>>('spine_track_entry_reset_rotation_directions');
|
|
late final _spine_track_entry_reset_rotation_directions =
|
|
_spine_track_entry_reset_rotation_directionsPtr.asFunction<void Function(spine_track_entry)>();
|
|
|
|
double spine_track_entry_get_track_complete(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_complete(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_completePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>('spine_track_entry_get_track_complete');
|
|
late final _spine_track_entry_get_track_complete =
|
|
_spine_track_entry_get_track_completePtr.asFunction<double Function(spine_track_entry)>();
|
|
|
|
/// 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,
|
|
) {
|
|
return _spine_skeleton_update_world_transform(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_update_world_transformPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_update_world_transform');
|
|
late final _spine_skeleton_update_world_transform = _spine_skeleton_update_world_transformPtr.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_update_world_transform_bone(
|
|
spine_skeleton skeleton,
|
|
spine_bone parent,
|
|
) {
|
|
return _spine_skeleton_update_world_transform_bone(
|
|
skeleton,
|
|
parent,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_update_world_transform_bonePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_bone)>>('spine_skeleton_update_world_transform_bone');
|
|
late final _spine_skeleton_update_world_transform_bone =
|
|
_spine_skeleton_update_world_transform_bonePtr.asFunction<void Function(spine_skeleton, spine_bone)>();
|
|
|
|
void spine_skeleton_set_to_setup_pose(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_set_to_setup_pose(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_to_setup_posePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_set_to_setup_pose');
|
|
late final _spine_skeleton_set_to_setup_pose = _spine_skeleton_set_to_setup_posePtr.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_bones_to_setup_pose(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_set_bones_to_setup_pose(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_bones_to_setup_posePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_set_bones_to_setup_pose');
|
|
late final _spine_skeleton_set_bones_to_setup_pose =
|
|
_spine_skeleton_set_bones_to_setup_posePtr.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_slots_to_setup_pose(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_set_slots_to_setup_pose(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_slots_to_setup_posePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>('spine_skeleton_set_slots_to_setup_pose');
|
|
late final _spine_skeleton_set_slots_to_setup_pose =
|
|
_spine_skeleton_set_slots_to_setup_posePtr.asFunction<void Function(spine_skeleton)>();
|
|
|
|
spine_bone spine_skeleton_find_bone(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<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_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)>();
|
|
|
|
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)>();
|
|
|
|
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<ffi.Int32 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, ffi.Int32)>>('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)>();
|
|
|
|
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<ffi.Int32 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_transform_mode(
|
|
spine_bone_data data,
|
|
) {
|
|
return _spine_bone_data_get_transform_mode(
|
|
data,
|
|
);
|
|
}
|
|
|
|
late final _spine_bone_data_get_transform_modePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_bone_data)>>('spine_bone_data_get_transform_mode');
|
|
late final _spine_bone_data_get_transform_mode = _spine_bone_data_get_transform_modePtr.asFunction<int Function(spine_bone_data)>();
|
|
|
|
void spine_bone_data_set_transform_mode(
|
|
spine_bone_data data,
|
|
int mode,
|
|
) {
|
|
return _spine_bone_data_set_transform_mode(
|
|
data,
|
|
mode,
|
|
);
|
|
}
|
|
|
|
late final _spine_bone_data_set_transform_modePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_bone_data, ffi.Int32)>>('spine_bone_data_set_transform_mode');
|
|
late final _spine_bone_data_set_transform_mode = _spine_bone_data_set_transform_modePtr.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<ffi.Int32 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, ffi.Int32)>>('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)>();
|
|
|
|
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(ffi.Int32)>>('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<ffi.Int32 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_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_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)>();
|
|
|
|
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<ffi.Int32 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, ffi.Int32)>>('spine_bone_set_is_active');
|
|
late final _spine_bone_set_is_active = _spine_bone_set_is_activePtr.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<ffi.Int32 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, ffi.Int32)>>('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<ffi.Int32 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, ffi.Int32)>>('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()
|
|
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<ffi.Int32 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, ffi.Int32)>>('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<ffi.Int32 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, ffi.Int32)>>('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<ffi.Int32 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, ffi.Int32)>>('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<ffi.Int32 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, ffi.Int32)>>('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<ffi.Int32 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, ffi.Int32)>>('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<ffi.Int32 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, ffi.Int32)>>('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<ffi.Int32 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, ffi.Int32)>>('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)>();
|
|
|
|
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<ffi.Int32 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, ffi.Int32)>>(
|
|
'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<ffi.Int32 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, ffi.Int32)>>(
|
|
'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)>();
|
|
|
|
double 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<ffi.Float 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<double 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, ffi.Int32)>>('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)>();
|
|
|
|
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<ffi.Int32 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, ffi.Int32)>>('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 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_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_transform_mode {
|
|
static const int SPINE_TRANSFORM_MODE_NORMAL = 0;
|
|
static const int SPINE_TRANSFORM_ONLY_TRANSLATION = 1;
|
|
static const int SPINE_TRANSFORM_NO_ROTATION_OR_REFLECTION = 2;
|
|
static const int SPINE_TRANSFORM_NO_SCALE = 3;
|
|
static const int SPINE_TRANSFORM_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;
|
|
}
|
|
|
|
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 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_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_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>;
|