mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2025-12-21 17:56:04 +08:00
4343 lines
131 KiB
Dart
4343 lines
131 KiB
Dart
// ignore_for_file: always_specify_types
|
|
// ignore_for_file: camel_case_types
|
|
// ignore_for_file: non_constant_identifier_names
|
|
|
|
// AUTO GENERATED FILE, DO NOT EDIT.
|
|
//
|
|
// Generated by `package:ffigen`.
|
|
import 'dart:ffi' as ffi;
|
|
|
|
/// Bindings for `src/spine_flutter.h`.
|
|
///
|
|
/// Regenerate bindings with `dart run ffigen --config ffigen.yaml`.
|
|
///
|
|
class SpineFlutterBindings {
|
|
/// Holds the symbol lookup function.
|
|
final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
|
|
_lookup;
|
|
|
|
/// The symbols are looked up in [dynamicLibrary].
|
|
SpineFlutterBindings(ffi.DynamicLibrary dynamicLibrary)
|
|
: _lookup = dynamicLibrary.lookup;
|
|
|
|
/// The symbols are looked up with [lookup].
|
|
SpineFlutterBindings.fromLookup(
|
|
ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
|
|
lookup)
|
|
: _lookup = lookup;
|
|
|
|
int spine_major_version() {
|
|
return _spine_major_version();
|
|
}
|
|
|
|
late final _spine_major_versionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function()>>('spine_major_version');
|
|
late final _spine_major_version =
|
|
_spine_major_versionPtr.asFunction<int Function()>();
|
|
|
|
int spine_minor_version() {
|
|
return _spine_minor_version();
|
|
}
|
|
|
|
late final _spine_minor_versionPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function()>>('spine_minor_version');
|
|
late final _spine_minor_version =
|
|
_spine_minor_versionPtr.asFunction<int Function()>();
|
|
|
|
void spine_report_leaks() {
|
|
return _spine_report_leaks();
|
|
}
|
|
|
|
late final _spine_report_leaksPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function()>>('spine_report_leaks');
|
|
late final _spine_report_leaks =
|
|
_spine_report_leaksPtr.asFunction<void Function()>();
|
|
|
|
ffi.Pointer<spine_atlas> spine_atlas_load(
|
|
ffi.Pointer<ffi.Int8> atlasData,
|
|
) {
|
|
return _spine_atlas_load(
|
|
atlasData,
|
|
);
|
|
}
|
|
|
|
late final _spine_atlas_loadPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_atlas> Function(
|
|
ffi.Pointer<ffi.Int8>)>>('spine_atlas_load');
|
|
late final _spine_atlas_load = _spine_atlas_loadPtr
|
|
.asFunction<ffi.Pointer<spine_atlas> Function(ffi.Pointer<ffi.Int8>)>();
|
|
|
|
void spine_atlas_dispose(
|
|
ffi.Pointer<spine_atlas> atlas,
|
|
) {
|
|
return _spine_atlas_dispose(
|
|
atlas,
|
|
);
|
|
}
|
|
|
|
late final _spine_atlas_disposePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<spine_atlas>)>>(
|
|
'spine_atlas_dispose');
|
|
late final _spine_atlas_dispose = _spine_atlas_disposePtr
|
|
.asFunction<void Function(ffi.Pointer<spine_atlas>)>();
|
|
|
|
spine_skeleton_data_result spine_skeleton_data_load_json(
|
|
ffi.Pointer<spine_atlas> atlas,
|
|
ffi.Pointer<ffi.Int8> skeletonData,
|
|
) {
|
|
return _spine_skeleton_data_load_json(
|
|
atlas,
|
|
skeletonData,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_data_load_jsonPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_skeleton_data_result Function(ffi.Pointer<spine_atlas>,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_data_load_json');
|
|
late final _spine_skeleton_data_load_json =
|
|
_spine_skeleton_data_load_jsonPtr.asFunction<
|
|
spine_skeleton_data_result Function(
|
|
ffi.Pointer<spine_atlas>, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_skeleton_data_result spine_skeleton_data_load_binary(
|
|
ffi.Pointer<spine_atlas> atlas,
|
|
ffi.Pointer<ffi.Uint8> skeletonData,
|
|
int length,
|
|
) {
|
|
return _spine_skeleton_data_load_binary(
|
|
atlas,
|
|
skeletonData,
|
|
length,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_data_load_binaryPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_skeleton_data_result Function(
|
|
ffi.Pointer<spine_atlas>,
|
|
ffi.Pointer<ffi.Uint8>,
|
|
ffi.Int32)>>('spine_skeleton_data_load_binary');
|
|
late final _spine_skeleton_data_load_binary =
|
|
_spine_skeleton_data_load_binaryPtr.asFunction<
|
|
spine_skeleton_data_result Function(
|
|
ffi.Pointer<spine_atlas>, ffi.Pointer<ffi.Uint8>, int)>();
|
|
|
|
spine_bone_data spine_skeleton_data_find_bone(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>('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<ffi.Int8>)>();
|
|
|
|
spine_slot_data spine_skeleton_data_find_slot(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>('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<ffi.Int8>)>();
|
|
|
|
spine_skin spine_skeleton_data_find_skin(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>('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<ffi.Int8>)>();
|
|
|
|
spine_event_data spine_skeleton_data_find_event(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>('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<ffi.Int8>)>();
|
|
|
|
spine_animation spine_skeleton_data_find_animation(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>('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<ffi.Int8>)>();
|
|
|
|
spine_ik_constraint_data spine_skeleton_data_find_ik_constraint(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>(
|
|
'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<ffi.Int8>)>();
|
|
|
|
spine_transform_constraint_data spine_skeleton_data_find_transform_constraint(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>(
|
|
'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<ffi.Int8>)>();
|
|
|
|
spine_path_constraint_data spine_skeleton_data_find_path_constraint(
|
|
spine_skeleton_data data,
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8>)>>(
|
|
'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<ffi.Int8>)>();
|
|
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8> Function(
|
|
spine_skeleton_data)>>('spine_skeleton_data_get_name');
|
|
late final _spine_skeleton_data_get_name = _spine_skeleton_data_get_namePtr
|
|
.asFunction<ffi.Pointer<ffi.Int8> Function(spine_skeleton_data)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8> Function(
|
|
spine_skeleton_data)>>('spine_skeleton_data_get_version');
|
|
late final _spine_skeleton_data_get_version =
|
|
_spine_skeleton_data_get_versionPtr
|
|
.asFunction<ffi.Pointer<ffi.Int8> Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8> Function(
|
|
spine_skeleton_data)>>('spine_skeleton_data_get_hash');
|
|
late final _spine_skeleton_data_get_hash = _spine_skeleton_data_get_hashPtr
|
|
.asFunction<ffi.Pointer<ffi.Int8> Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8> 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<ffi.Int8> Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8> 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<ffi.Int8> Function(spine_skeleton_data)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
ffi.Pointer<spine_skeleton_drawable> spine_skeleton_drawable_create(
|
|
spine_skeleton_data skeletonData,
|
|
) {
|
|
return _spine_skeleton_drawable_create(
|
|
skeletonData,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_createPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_skeleton_drawable> Function(
|
|
spine_skeleton_data)>>('spine_skeleton_drawable_create');
|
|
late final _spine_skeleton_drawable_create =
|
|
_spine_skeleton_drawable_createPtr.asFunction<
|
|
ffi.Pointer<spine_skeleton_drawable> Function(spine_skeleton_data)>();
|
|
|
|
ffi.Pointer<spine_render_command> spine_skeleton_drawable_render(
|
|
ffi.Pointer<spine_skeleton_drawable> drawable,
|
|
) {
|
|
return _spine_skeleton_drawable_render(
|
|
drawable,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_renderPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_render_command> Function(
|
|
ffi.Pointer<spine_skeleton_drawable>)>>(
|
|
'spine_skeleton_drawable_render');
|
|
late final _spine_skeleton_drawable_render =
|
|
_spine_skeleton_drawable_renderPtr.asFunction<
|
|
ffi.Pointer<spine_render_command> Function(
|
|
ffi.Pointer<spine_skeleton_drawable>)>();
|
|
|
|
void spine_skeleton_drawable_dispose(
|
|
ffi.Pointer<spine_skeleton_drawable> drawable,
|
|
) {
|
|
return _spine_skeleton_drawable_dispose(
|
|
drawable,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_drawable_disposePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(ffi.Pointer<spine_skeleton_drawable>)>>(
|
|
'spine_skeleton_drawable_dispose');
|
|
late final _spine_skeleton_drawable_dispose =
|
|
_spine_skeleton_drawable_disposePtr
|
|
.asFunction<void Function(ffi.Pointer<spine_skeleton_drawable>)>();
|
|
|
|
ffi.Pointer<ffi.Int8> spine_animation_get_name(
|
|
spine_animation animation,
|
|
) {
|
|
return _spine_animation_get_name(
|
|
animation,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_get_namePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Pointer<ffi.Int8> Function(spine_animation)>>(
|
|
'spine_animation_get_name');
|
|
late final _spine_animation_get_name = _spine_animation_get_namePtr
|
|
.asFunction<ffi.Pointer<ffi.Int8> Function(spine_animation)>();
|
|
|
|
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)>();
|
|
|
|
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_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)>();
|
|
|
|
void spine_animation_state_apply(
|
|
spine_animation_state state,
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_animation_state_apply(
|
|
state,
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_applyPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_animation_state,
|
|
spine_skeleton)>>('spine_animation_state_apply');
|
|
late final _spine_animation_state_apply = _spine_animation_state_applyPtr
|
|
.asFunction<void Function(spine_animation_state, spine_skeleton)>();
|
|
|
|
void spine_animation_state_clear_tracks(
|
|
spine_animation_state state,
|
|
) {
|
|
return _spine_animation_state_clear_tracks(
|
|
state,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_clear_tracksPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_animation_state)>>(
|
|
'spine_animation_state_clear_tracks');
|
|
late final _spine_animation_state_clear_tracks =
|
|
_spine_animation_state_clear_tracksPtr
|
|
.asFunction<void Function(spine_animation_state)>();
|
|
|
|
void spine_animation_state_clear_track(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
) {
|
|
return _spine_animation_state_clear_track(
|
|
state,
|
|
trackIndex,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_clear_trackPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_animation_state,
|
|
ffi.Int32)>>('spine_animation_state_clear_track');
|
|
late final _spine_animation_state_clear_track =
|
|
_spine_animation_state_clear_trackPtr
|
|
.asFunction<void Function(spine_animation_state, int)>();
|
|
|
|
spine_track_entry spine_animation_state_set_animation(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
ffi.Pointer<ffi.Int8> animationName,
|
|
int loop,
|
|
) {
|
|
return _spine_animation_state_set_animation(
|
|
state,
|
|
trackIndex,
|
|
animationName,
|
|
loop,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_set_animationPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(
|
|
spine_animation_state,
|
|
ffi.Int32,
|
|
ffi.Pointer<ffi.Int8>,
|
|
ffi.Int32)>>('spine_animation_state_set_animation');
|
|
late final _spine_animation_state_set_animation =
|
|
_spine_animation_state_set_animationPtr.asFunction<
|
|
spine_track_entry Function(
|
|
spine_animation_state, int, ffi.Pointer<ffi.Int8>, int)>();
|
|
|
|
spine_track_entry spine_animation_state_add_animation(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
ffi.Pointer<ffi.Int8> animationName,
|
|
int loop,
|
|
double delay,
|
|
) {
|
|
return _spine_animation_state_add_animation(
|
|
state,
|
|
trackIndex,
|
|
animationName,
|
|
loop,
|
|
delay,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_add_animationPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(
|
|
spine_animation_state,
|
|
ffi.Int32,
|
|
ffi.Pointer<ffi.Int8>,
|
|
ffi.Int32,
|
|
ffi.Float)>>('spine_animation_state_add_animation');
|
|
late final _spine_animation_state_add_animation =
|
|
_spine_animation_state_add_animationPtr.asFunction<
|
|
spine_track_entry Function(spine_animation_state, int,
|
|
ffi.Pointer<ffi.Int8>, int, double)>();
|
|
|
|
spine_track_entry spine_animation_state_set_empty_animation(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
double mixDuration,
|
|
) {
|
|
return _spine_animation_state_set_empty_animation(
|
|
state,
|
|
trackIndex,
|
|
mixDuration,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_set_empty_animationPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(spine_animation_state, ffi.Int32,
|
|
ffi.Float)>>('spine_animation_state_set_empty_animation');
|
|
late final _spine_animation_state_set_empty_animation =
|
|
_spine_animation_state_set_empty_animationPtr.asFunction<
|
|
spine_track_entry Function(spine_animation_state, int, double)>();
|
|
|
|
spine_track_entry spine_animation_state_add_empty_animation(
|
|
spine_animation_state state,
|
|
int trackIndex,
|
|
double mixDuration,
|
|
double delay,
|
|
) {
|
|
return _spine_animation_state_add_empty_animation(
|
|
state,
|
|
trackIndex,
|
|
mixDuration,
|
|
delay,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_add_empty_animationPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(
|
|
spine_animation_state,
|
|
ffi.Int32,
|
|
ffi.Float,
|
|
ffi.Float)>>('spine_animation_state_add_empty_animation');
|
|
late final _spine_animation_state_add_empty_animation =
|
|
_spine_animation_state_add_empty_animationPtr.asFunction<
|
|
spine_track_entry Function(
|
|
spine_animation_state, int, double, double)>();
|
|
|
|
void spine_animation_state_set_empty_animations(
|
|
spine_animation_state state,
|
|
double mixDuration,
|
|
) {
|
|
return _spine_animation_state_set_empty_animations(
|
|
state,
|
|
mixDuration,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_set_empty_animationsPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_animation_state,
|
|
ffi.Float)>>('spine_animation_state_set_empty_animations');
|
|
late final _spine_animation_state_set_empty_animations =
|
|
_spine_animation_state_set_empty_animationsPtr
|
|
.asFunction<void Function(spine_animation_state, double)>();
|
|
|
|
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)>();
|
|
|
|
double spine_animation_state_get_time_scale(
|
|
spine_animation_state state,
|
|
) {
|
|
return _spine_animation_state_get_time_scale(
|
|
state,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_get_time_scalePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_animation_state)>>(
|
|
'spine_animation_state_get_time_scale');
|
|
late final _spine_animation_state_get_time_scale =
|
|
_spine_animation_state_get_time_scalePtr
|
|
.asFunction<double Function(spine_animation_state)>();
|
|
|
|
void spine_animation_state_set_time_scale(
|
|
spine_animation_state state,
|
|
double timeScale,
|
|
) {
|
|
return _spine_animation_state_set_time_scale(
|
|
state,
|
|
timeScale,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_set_time_scalePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_animation_state,
|
|
ffi.Float)>>('spine_animation_state_set_time_scale');
|
|
late final _spine_animation_state_set_time_scale =
|
|
_spine_animation_state_set_time_scalePtr
|
|
.asFunction<void Function(spine_animation_state, double)>();
|
|
|
|
int spine_animation_state_events_get_num_events(
|
|
spine_animation_state_events events,
|
|
) {
|
|
return _spine_animation_state_events_get_num_events(
|
|
events,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_events_get_num_eventsPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Int32 Function(spine_animation_state_events)>>(
|
|
'spine_animation_state_events_get_num_events');
|
|
late final _spine_animation_state_events_get_num_events =
|
|
_spine_animation_state_events_get_num_eventsPtr
|
|
.asFunction<int Function(spine_animation_state_events)>();
|
|
|
|
int spine_animation_state_events_get_event_type(
|
|
spine_animation_state_events events,
|
|
int index,
|
|
) {
|
|
return _spine_animation_state_events_get_event_type(
|
|
events,
|
|
index,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_events_get_event_typePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Int32 Function(spine_animation_state_events,
|
|
ffi.Int32)>>('spine_animation_state_events_get_event_type');
|
|
late final _spine_animation_state_events_get_event_type =
|
|
_spine_animation_state_events_get_event_typePtr
|
|
.asFunction<int Function(spine_animation_state_events, int)>();
|
|
|
|
spine_track_entry spine_animation_state_events_get_track_entry(
|
|
spine_animation_state_events events,
|
|
int index,
|
|
) {
|
|
return _spine_animation_state_events_get_track_entry(
|
|
events,
|
|
index,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_events_get_track_entryPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_track_entry Function(spine_animation_state_events,
|
|
ffi.Int32)>>('spine_animation_state_events_get_track_entry');
|
|
late final _spine_animation_state_events_get_track_entry =
|
|
_spine_animation_state_events_get_track_entryPtr.asFunction<
|
|
spine_track_entry Function(spine_animation_state_events, int)>();
|
|
|
|
spine_event spine_animation_state_events_get_event(
|
|
spine_animation_state_events events,
|
|
int index,
|
|
) {
|
|
return _spine_animation_state_events_get_event(
|
|
events,
|
|
index,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_events_get_eventPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_event Function(spine_animation_state_events,
|
|
ffi.Int32)>>('spine_animation_state_events_get_event');
|
|
late final _spine_animation_state_events_get_event =
|
|
_spine_animation_state_events_get_eventPtr.asFunction<
|
|
spine_event Function(spine_animation_state_events, int)>();
|
|
|
|
void spine_animation_state_events_reset(
|
|
spine_animation_state_events events,
|
|
) {
|
|
return _spine_animation_state_events_reset(
|
|
events,
|
|
);
|
|
}
|
|
|
|
late final _spine_animation_state_events_resetPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_animation_state_events)>>(
|
|
'spine_animation_state_events_reset');
|
|
late final _spine_animation_state_events_reset =
|
|
_spine_animation_state_events_resetPtr
|
|
.asFunction<void Function(spine_animation_state_events)>();
|
|
|
|
int spine_track_entry_get_track_index(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_index(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_indexPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_track_index');
|
|
late final _spine_track_entry_get_track_index =
|
|
_spine_track_entry_get_track_indexPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
spine_animation spine_track_entry_get_animation(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animationPtr =
|
|
_lookup<ffi.NativeFunction<spine_animation Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_animation');
|
|
late final _spine_track_entry_get_animation =
|
|
_spine_track_entry_get_animationPtr
|
|
.asFunction<spine_animation Function(spine_track_entry)>();
|
|
|
|
spine_track_entry spine_track_entry_get_previous(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_previous(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_previousPtr = _lookup<
|
|
ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_previous');
|
|
late final _spine_track_entry_get_previous =
|
|
_spine_track_entry_get_previousPtr
|
|
.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
int spine_track_entry_get_loop(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_loop(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_loopPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_loop');
|
|
late final _spine_track_entry_get_loop = _spine_track_entry_get_loopPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_loop(
|
|
spine_track_entry entry,
|
|
int loop,
|
|
) {
|
|
return _spine_track_entry_set_loop(
|
|
entry,
|
|
loop,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_loopPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
|
|
'spine_track_entry_set_loop');
|
|
late final _spine_track_entry_set_loop = _spine_track_entry_set_loopPtr
|
|
.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
int spine_track_entry_get_hold_previous(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_hold_previous(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_hold_previousPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_hold_previous');
|
|
late final _spine_track_entry_get_hold_previous =
|
|
_spine_track_entry_get_hold_previousPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_hold_previous(
|
|
spine_track_entry entry,
|
|
int holdPrevious,
|
|
) {
|
|
return _spine_track_entry_set_hold_previous(
|
|
entry,
|
|
holdPrevious,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_hold_previousPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
|
|
'spine_track_entry_set_hold_previous');
|
|
late final _spine_track_entry_set_hold_previous =
|
|
_spine_track_entry_set_hold_previousPtr
|
|
.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
int spine_track_entry_get_reverse(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_reverse(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_reversePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_reverse');
|
|
late final _spine_track_entry_get_reverse = _spine_track_entry_get_reversePtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_reverse(
|
|
spine_track_entry entry,
|
|
int reverse,
|
|
) {
|
|
return _spine_track_entry_set_reverse(
|
|
entry,
|
|
reverse,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_reversePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
|
|
'spine_track_entry_set_reverse');
|
|
late final _spine_track_entry_set_reverse = _spine_track_entry_set_reversePtr
|
|
.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
int spine_track_entry_get_shortest_rotation(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_shortest_rotation(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_shortest_rotationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_shortest_rotation');
|
|
late final _spine_track_entry_get_shortest_rotation =
|
|
_spine_track_entry_get_shortest_rotationPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_shortest_rotation(
|
|
spine_track_entry entry,
|
|
int shortestRotation,
|
|
) {
|
|
return _spine_track_entry_set_shortest_rotation(
|
|
entry,
|
|
shortestRotation,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_shortest_rotationPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
|
|
'spine_track_entry_set_shortest_rotation');
|
|
late final _spine_track_entry_set_shortest_rotation =
|
|
_spine_track_entry_set_shortest_rotationPtr
|
|
.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
double spine_track_entry_get_delay(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_delay(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_delayPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_delay');
|
|
late final _spine_track_entry_get_delay = _spine_track_entry_get_delayPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_delay(
|
|
spine_track_entry entry,
|
|
double delay,
|
|
) {
|
|
return _spine_track_entry_set_delay(
|
|
entry,
|
|
delay,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_delayPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_delay');
|
|
late final _spine_track_entry_set_delay = _spine_track_entry_set_delayPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_track_time(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_time(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_track_time');
|
|
late final _spine_track_entry_get_track_time =
|
|
_spine_track_entry_get_track_timePtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_track_time(
|
|
spine_track_entry entry,
|
|
double trackTime,
|
|
) {
|
|
return _spine_track_entry_set_track_time(
|
|
entry,
|
|
trackTime,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_track_timePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_track_time');
|
|
late final _spine_track_entry_set_track_time =
|
|
_spine_track_entry_set_track_timePtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_track_end(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_end(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_endPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_track_end');
|
|
late final _spine_track_entry_get_track_end =
|
|
_spine_track_entry_get_track_endPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_track_end(
|
|
spine_track_entry entry,
|
|
double trackEnd,
|
|
) {
|
|
return _spine_track_entry_set_track_end(
|
|
entry,
|
|
trackEnd,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_track_endPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_track_end');
|
|
late final _spine_track_entry_set_track_end =
|
|
_spine_track_entry_set_track_endPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_start(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_start(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_startPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_animation_start');
|
|
late final _spine_track_entry_get_animation_start =
|
|
_spine_track_entry_get_animation_startPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_animation_start(
|
|
spine_track_entry entry,
|
|
double animationStart,
|
|
) {
|
|
return _spine_track_entry_set_animation_start(
|
|
entry,
|
|
animationStart,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_animation_startPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_animation_start');
|
|
late final _spine_track_entry_set_animation_start =
|
|
_spine_track_entry_set_animation_startPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_end(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_end(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_endPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_animation_end');
|
|
late final _spine_track_entry_get_animation_end =
|
|
_spine_track_entry_get_animation_endPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_animation_end(
|
|
spine_track_entry entry,
|
|
double animationEnd,
|
|
) {
|
|
return _spine_track_entry_set_animation_end(
|
|
entry,
|
|
animationEnd,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_animation_endPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_animation_end');
|
|
late final _spine_track_entry_set_animation_end =
|
|
_spine_track_entry_set_animation_endPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_last(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_last(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_lastPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_animation_last');
|
|
late final _spine_track_entry_get_animation_last =
|
|
_spine_track_entry_get_animation_lastPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_animation_last(
|
|
spine_track_entry entry,
|
|
double animationLast,
|
|
) {
|
|
return _spine_track_entry_set_animation_last(
|
|
entry,
|
|
animationLast,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_animation_lastPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_animation_last');
|
|
late final _spine_track_entry_set_animation_last =
|
|
_spine_track_entry_set_animation_lastPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_animation_time(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_animation_time(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_animation_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_animation_time');
|
|
late final _spine_track_entry_get_animation_time =
|
|
_spine_track_entry_get_animation_timePtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
double spine_track_entry_get_time_scale(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_time_scale(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_time_scalePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_time_scale');
|
|
late final _spine_track_entry_get_time_scale =
|
|
_spine_track_entry_get_time_scalePtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_time_scale(
|
|
spine_track_entry entry,
|
|
double timeScale,
|
|
) {
|
|
return _spine_track_entry_set_time_scale(
|
|
entry,
|
|
timeScale,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_time_scalePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_time_scale');
|
|
late final _spine_track_entry_set_time_scale =
|
|
_spine_track_entry_set_time_scalePtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_alpha(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_alpha(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_alphaPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_alpha');
|
|
late final _spine_track_entry_get_alpha = _spine_track_entry_get_alphaPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_alpha(
|
|
spine_track_entry entry,
|
|
double alpha,
|
|
) {
|
|
return _spine_track_entry_set_alpha(
|
|
entry,
|
|
alpha,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_alphaPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_alpha');
|
|
late final _spine_track_entry_set_alpha = _spine_track_entry_set_alphaPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_event_threshold(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_event_threshold(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_event_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_event_threshold');
|
|
late final _spine_track_entry_get_event_threshold =
|
|
_spine_track_entry_get_event_thresholdPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_event_threshold(
|
|
spine_track_entry entry,
|
|
double eventThreshold,
|
|
) {
|
|
return _spine_track_entry_set_event_threshold(
|
|
entry,
|
|
eventThreshold,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_event_thresholdPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_event_threshold');
|
|
late final _spine_track_entry_set_event_threshold =
|
|
_spine_track_entry_set_event_thresholdPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_attachment_threshold(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_attachment_threshold(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_attachment_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_attachment_threshold');
|
|
late final _spine_track_entry_get_attachment_threshold =
|
|
_spine_track_entry_get_attachment_thresholdPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_attachment_threshold(
|
|
spine_track_entry entry,
|
|
double attachmentThreshold,
|
|
) {
|
|
return _spine_track_entry_set_attachment_threshold(
|
|
entry,
|
|
attachmentThreshold,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_attachment_thresholdPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_attachment_threshold');
|
|
late final _spine_track_entry_set_attachment_threshold =
|
|
_spine_track_entry_set_attachment_thresholdPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_draw_order_threshold(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_draw_order_threshold(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_draw_order_thresholdPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_draw_order_threshold');
|
|
late final _spine_track_entry_get_draw_order_threshold =
|
|
_spine_track_entry_get_draw_order_thresholdPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_draw_order_threshold(
|
|
spine_track_entry entry,
|
|
double drawOrderThreshold,
|
|
) {
|
|
return _spine_track_entry_set_draw_order_threshold(
|
|
entry,
|
|
drawOrderThreshold,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_draw_order_thresholdPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_draw_order_threshold');
|
|
late final _spine_track_entry_set_draw_order_threshold =
|
|
_spine_track_entry_set_draw_order_thresholdPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
spine_track_entry spine_track_entry_get_next(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_next(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_nextPtr = _lookup<
|
|
ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_next');
|
|
late final _spine_track_entry_get_next = _spine_track_entry_get_nextPtr
|
|
.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
int spine_track_entry_is_complete(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_is_complete(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_is_completePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_is_complete');
|
|
late final _spine_track_entry_is_complete = _spine_track_entry_is_completePtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
double spine_track_entry_get_mix_time(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mix_time(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_timePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mix_time');
|
|
late final _spine_track_entry_get_mix_time =
|
|
_spine_track_entry_get_mix_timePtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_time(
|
|
spine_track_entry entry,
|
|
double mixTime,
|
|
) {
|
|
return _spine_track_entry_set_mix_time(
|
|
entry,
|
|
mixTime,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_timePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_mix_time');
|
|
late final _spine_track_entry_set_mix_time =
|
|
_spine_track_entry_set_mix_timePtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
double spine_track_entry_get_mix_duration(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mix_duration(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_durationPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mix_duration');
|
|
late final _spine_track_entry_get_mix_duration =
|
|
_spine_track_entry_get_mix_durationPtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_duration(
|
|
spine_track_entry entry,
|
|
double mixDuration,
|
|
) {
|
|
return _spine_track_entry_set_mix_duration(
|
|
entry,
|
|
mixDuration,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_durationPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Float)>>(
|
|
'spine_track_entry_set_mix_duration');
|
|
late final _spine_track_entry_set_mix_duration =
|
|
_spine_track_entry_set_mix_durationPtr
|
|
.asFunction<void Function(spine_track_entry, double)>();
|
|
|
|
int spine_track_entry_get_mix_blend(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mix_blend(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mix_blendPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mix_blend');
|
|
late final _spine_track_entry_get_mix_blend =
|
|
_spine_track_entry_get_mix_blendPtr
|
|
.asFunction<int Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_set_mix_blend(
|
|
spine_track_entry entry,
|
|
int mixBlend,
|
|
) {
|
|
return _spine_track_entry_set_mix_blend(
|
|
entry,
|
|
mixBlend,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_set_mix_blendPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_track_entry, ffi.Int32)>>(
|
|
'spine_track_entry_set_mix_blend');
|
|
late final _spine_track_entry_set_mix_blend =
|
|
_spine_track_entry_set_mix_blendPtr
|
|
.asFunction<void Function(spine_track_entry, int)>();
|
|
|
|
spine_track_entry spine_track_entry_get_mixing_from(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mixing_from(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mixing_fromPtr = _lookup<
|
|
ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mixing_from');
|
|
late final _spine_track_entry_get_mixing_from =
|
|
_spine_track_entry_get_mixing_fromPtr
|
|
.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
spine_track_entry spine_track_entry_get_mixing_to(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_mixing_to(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_mixing_toPtr = _lookup<
|
|
ffi.NativeFunction<spine_track_entry Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_mixing_to');
|
|
late final _spine_track_entry_get_mixing_to =
|
|
_spine_track_entry_get_mixing_toPtr
|
|
.asFunction<spine_track_entry Function(spine_track_entry)>();
|
|
|
|
void spine_track_entry_reset_rotation_directions(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_reset_rotation_directions(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_reset_rotation_directionsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_track_entry)>>(
|
|
'spine_track_entry_reset_rotation_directions');
|
|
late final _spine_track_entry_reset_rotation_directions =
|
|
_spine_track_entry_reset_rotation_directionsPtr
|
|
.asFunction<void Function(spine_track_entry)>();
|
|
|
|
double spine_track_entry_get_track_complete(
|
|
spine_track_entry entry,
|
|
) {
|
|
return _spine_track_entry_get_track_complete(
|
|
entry,
|
|
);
|
|
}
|
|
|
|
late final _spine_track_entry_get_track_completePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_track_entry)>>(
|
|
'spine_track_entry_get_track_complete');
|
|
late final _spine_track_entry_get_track_complete =
|
|
_spine_track_entry_get_track_completePtr
|
|
.asFunction<double Function(spine_track_entry)>();
|
|
|
|
void spine_skeleton_update_cache(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_update_cache(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_update_cachePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
|
|
'spine_skeleton_update_cache');
|
|
late final _spine_skeleton_update_cache = _spine_skeleton_update_cachePtr
|
|
.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_update_world_transform(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_update_world_transform(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_update_world_transformPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
|
|
'spine_skeleton_update_world_transform');
|
|
late final _spine_skeleton_update_world_transform =
|
|
_spine_skeleton_update_world_transformPtr
|
|
.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_update_world_transform_bone(
|
|
spine_skeleton skeleton,
|
|
spine_bone parent,
|
|
) {
|
|
return _spine_skeleton_update_world_transform_bone(
|
|
skeleton,
|
|
parent,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_update_world_transform_bonePtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_bone)>>(
|
|
'spine_skeleton_update_world_transform_bone');
|
|
late final _spine_skeleton_update_world_transform_bone =
|
|
_spine_skeleton_update_world_transform_bonePtr
|
|
.asFunction<void Function(spine_skeleton, spine_bone)>();
|
|
|
|
void spine_skeleton_set_to_setup_pose(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_set_to_setup_pose(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_to_setup_posePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
|
|
'spine_skeleton_set_to_setup_pose');
|
|
late final _spine_skeleton_set_to_setup_pose =
|
|
_spine_skeleton_set_to_setup_posePtr
|
|
.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_bones_to_setup_pose(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_set_bones_to_setup_pose(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_bones_to_setup_posePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
|
|
'spine_skeleton_set_bones_to_setup_pose');
|
|
late final _spine_skeleton_set_bones_to_setup_pose =
|
|
_spine_skeleton_set_bones_to_setup_posePtr
|
|
.asFunction<void Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_slots_to_setup_pose(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_set_slots_to_setup_pose(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_slots_to_setup_posePtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton)>>(
|
|
'spine_skeleton_set_slots_to_setup_pose');
|
|
late final _spine_skeleton_set_slots_to_setup_pose =
|
|
_spine_skeleton_set_slots_to_setup_posePtr
|
|
.asFunction<void Function(spine_skeleton)>();
|
|
|
|
spine_bone spine_skeleton_find_bone(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> boneName,
|
|
) {
|
|
return _spine_skeleton_find_bone(
|
|
skeleton,
|
|
boneName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_find_bonePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_bone Function(spine_skeleton,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_find_bone');
|
|
late final _spine_skeleton_find_bone = _spine_skeleton_find_bonePtr
|
|
.asFunction<spine_bone Function(spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_slot spine_skeleton_find_slot(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> slotName,
|
|
) {
|
|
return _spine_skeleton_find_slot(
|
|
skeleton,
|
|
slotName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_find_slotPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_slot Function(spine_skeleton,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_find_slot');
|
|
late final _spine_skeleton_find_slot = _spine_skeleton_find_slotPtr
|
|
.asFunction<spine_slot Function(spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
void spine_skeleton_set_skin_by_name(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> skinName,
|
|
) {
|
|
return _spine_skeleton_set_skin_by_name(
|
|
skeleton,
|
|
skinName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_skin_by_namePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_skeleton,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_set_skin_by_name');
|
|
late final _spine_skeleton_set_skin_by_name =
|
|
_spine_skeleton_set_skin_by_namePtr
|
|
.asFunction<void Function(spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
void spine_skeleton_set_skin(
|
|
spine_skeleton skeleton,
|
|
spine_skin skin,
|
|
) {
|
|
return _spine_skeleton_set_skin(
|
|
skeleton,
|
|
skin,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_skinPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Void Function(spine_skeleton, spine_skin)>>(
|
|
'spine_skeleton_set_skin');
|
|
late final _spine_skeleton_set_skin = _spine_skeleton_set_skinPtr
|
|
.asFunction<void Function(spine_skeleton, spine_skin)>();
|
|
|
|
spine_attachment spine_skeleton_get_attachment_by_name(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> slotName,
|
|
ffi.Pointer<ffi.Int8> attachmentName,
|
|
) {
|
|
return _spine_skeleton_get_attachment_by_name(
|
|
skeleton,
|
|
slotName,
|
|
attachmentName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_attachment_by_namePtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_attachment Function(spine_skeleton, ffi.Pointer<ffi.Int8>,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_get_attachment_by_name');
|
|
late final _spine_skeleton_get_attachment_by_name =
|
|
_spine_skeleton_get_attachment_by_namePtr.asFunction<
|
|
spine_attachment Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_attachment spine_skeleton_get_attachment(
|
|
spine_skeleton skeleton,
|
|
int slotIndex,
|
|
ffi.Pointer<ffi.Int8> attachmentName,
|
|
) {
|
|
return _spine_skeleton_get_attachment(
|
|
skeleton,
|
|
slotIndex,
|
|
attachmentName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_attachmentPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_attachment Function(spine_skeleton, ffi.Int32,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_get_attachment');
|
|
late final _spine_skeleton_get_attachment =
|
|
_spine_skeleton_get_attachmentPtr.asFunction<
|
|
spine_attachment Function(
|
|
spine_skeleton, int, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
void spine_skeleton_set_attachment(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> slotName,
|
|
ffi.Pointer<ffi.Int8> attachmentName,
|
|
) {
|
|
return _spine_skeleton_set_attachment(
|
|
skeleton,
|
|
slotName,
|
|
attachmentName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_attachmentPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_skeleton, ffi.Pointer<ffi.Int8>,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_set_attachment');
|
|
late final _spine_skeleton_set_attachment =
|
|
_spine_skeleton_set_attachmentPtr.asFunction<
|
|
void Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_ik_constraint spine_skeleton_find_ik_constraint(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> constraintName,
|
|
) {
|
|
return _spine_skeleton_find_ik_constraint(
|
|
skeleton,
|
|
constraintName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_find_ik_constraintPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_ik_constraint Function(spine_skeleton,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_find_ik_constraint');
|
|
late final _spine_skeleton_find_ik_constraint =
|
|
_spine_skeleton_find_ik_constraintPtr.asFunction<
|
|
spine_ik_constraint Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_transform_constraint spine_skeleton_find_transform_constraint(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> constraintName,
|
|
) {
|
|
return _spine_skeleton_find_transform_constraint(
|
|
skeleton,
|
|
constraintName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_find_transform_constraintPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_transform_constraint Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>)>>(
|
|
'spine_skeleton_find_transform_constraint');
|
|
late final _spine_skeleton_find_transform_constraint =
|
|
_spine_skeleton_find_transform_constraintPtr.asFunction<
|
|
spine_transform_constraint Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_path_constraint spine_skeleton_find_path_constraint(
|
|
spine_skeleton skeleton,
|
|
ffi.Pointer<ffi.Int8> constraintName,
|
|
) {
|
|
return _spine_skeleton_find_path_constraint(
|
|
skeleton,
|
|
constraintName,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_find_path_constraintPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
spine_path_constraint Function(spine_skeleton,
|
|
ffi.Pointer<ffi.Int8>)>>('spine_skeleton_find_path_constraint');
|
|
late final _spine_skeleton_find_path_constraint =
|
|
_spine_skeleton_find_path_constraintPtr.asFunction<
|
|
spine_path_constraint Function(
|
|
spine_skeleton, ffi.Pointer<ffi.Int8>)>();
|
|
|
|
spine_bounds spine_skeleton_get_bounds(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_bounds(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_boundsPtr =
|
|
_lookup<ffi.NativeFunction<spine_bounds Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_bounds');
|
|
late final _spine_skeleton_get_bounds = _spine_skeleton_get_boundsPtr
|
|
.asFunction<spine_bounds Function(spine_skeleton)>();
|
|
|
|
spine_bone spine_skeleton_get_root_bone(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_root_bone(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_root_bonePtr =
|
|
_lookup<ffi.NativeFunction<spine_bone Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_root_bone');
|
|
late final _spine_skeleton_get_root_bone = _spine_skeleton_get_root_bonePtr
|
|
.asFunction<spine_bone Function(spine_skeleton)>();
|
|
|
|
spine_skeleton_data spine_skeleton_get_data(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_data(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_dataPtr =
|
|
_lookup<ffi.NativeFunction<spine_skeleton_data Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_data');
|
|
late final _spine_skeleton_get_data = _spine_skeleton_get_dataPtr
|
|
.asFunction<spine_skeleton_data Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_bones(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_bones(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_bonesPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_bones');
|
|
late final _spine_skeleton_get_num_bones = _spine_skeleton_get_num_bonesPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_bone> spine_skeleton_get_bones(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_bones(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_bonesPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Pointer<spine_bone> Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_bones');
|
|
late final _spine_skeleton_get_bones = _spine_skeleton_get_bonesPtr
|
|
.asFunction<ffi.Pointer<spine_bone> Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_slots(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_slots(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_slotsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_slots');
|
|
late final _spine_skeleton_get_num_slots = _spine_skeleton_get_num_slotsPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_slot> spine_skeleton_get_slots(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_slots(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_slotsPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_slots');
|
|
late final _spine_skeleton_get_slots = _spine_skeleton_get_slotsPtr
|
|
.asFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_draw_order(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_draw_order(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_draw_orderPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_draw_order');
|
|
late final _spine_skeleton_get_num_draw_order =
|
|
_spine_skeleton_get_num_draw_orderPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_slot> spine_skeleton_get_draw_order(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_draw_order(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_draw_orderPtr = _lookup<
|
|
ffi.NativeFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_draw_order');
|
|
late final _spine_skeleton_get_draw_order = _spine_skeleton_get_draw_orderPtr
|
|
.asFunction<ffi.Pointer<spine_slot> Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_ik_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_ik_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_ik_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_ik_constraints');
|
|
late final _spine_skeleton_get_num_ik_constraints =
|
|
_spine_skeleton_get_num_ik_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_ik_constraint> spine_skeleton_get_ik_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_ik_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_ik_constraintsPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_ik_constraint> Function(
|
|
spine_skeleton)>>('spine_skeleton_get_ik_constraints');
|
|
late final _spine_skeleton_get_ik_constraints =
|
|
_spine_skeleton_get_ik_constraintsPtr.asFunction<
|
|
ffi.Pointer<spine_ik_constraint> Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_transform_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_transform_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_transform_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_transform_constraints');
|
|
late final _spine_skeleton_get_num_transform_constraints =
|
|
_spine_skeleton_get_num_transform_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_transform_constraint>
|
|
spine_skeleton_get_transform_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_transform_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_transform_constraintsPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_transform_constraint> Function(
|
|
spine_skeleton)>>('spine_skeleton_get_transform_constraints');
|
|
late final _spine_skeleton_get_transform_constraints =
|
|
_spine_skeleton_get_transform_constraintsPtr.asFunction<
|
|
ffi.Pointer<spine_transform_constraint> Function(spine_skeleton)>();
|
|
|
|
int spine_skeleton_get_num_path_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_num_path_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_num_path_constraintsPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Int32 Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_num_path_constraints');
|
|
late final _spine_skeleton_get_num_path_constraints =
|
|
_spine_skeleton_get_num_path_constraintsPtr
|
|
.asFunction<int Function(spine_skeleton)>();
|
|
|
|
ffi.Pointer<spine_path_constraint> spine_skeleton_get_path_constraints(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_path_constraints(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_path_constraintsPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Pointer<spine_path_constraint> Function(
|
|
spine_skeleton)>>('spine_skeleton_get_path_constraints');
|
|
late final _spine_skeleton_get_path_constraints =
|
|
_spine_skeleton_get_path_constraintsPtr.asFunction<
|
|
ffi.Pointer<spine_path_constraint> Function(spine_skeleton)>();
|
|
|
|
spine_skin spine_skeleton_get_skin(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_skin(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_skinPtr =
|
|
_lookup<ffi.NativeFunction<spine_skin Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_skin');
|
|
late final _spine_skeleton_get_skin = _spine_skeleton_get_skinPtr
|
|
.asFunction<spine_skin Function(spine_skeleton)>();
|
|
|
|
spine_color spine_skeleton_get_color(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_color(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_colorPtr =
|
|
_lookup<ffi.NativeFunction<spine_color Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_color');
|
|
late final _spine_skeleton_get_color = _spine_skeleton_get_colorPtr
|
|
.asFunction<spine_color Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_color(
|
|
spine_skeleton skeleton,
|
|
double r,
|
|
double g,
|
|
double b,
|
|
double a,
|
|
) {
|
|
return _spine_skeleton_set_color(
|
|
skeleton,
|
|
r,
|
|
g,
|
|
b,
|
|
a,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_colorPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_skeleton, ffi.Float, ffi.Float, ffi.Float,
|
|
ffi.Float)>>('spine_skeleton_set_color');
|
|
late final _spine_skeleton_set_color =
|
|
_spine_skeleton_set_colorPtr.asFunction<
|
|
void Function(spine_skeleton, double, double, double, double)>();
|
|
|
|
void spine_skeleton_set_position(
|
|
spine_skeleton skeleton,
|
|
double x,
|
|
double y,
|
|
) {
|
|
return _spine_skeleton_set_position(
|
|
skeleton,
|
|
x,
|
|
y,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_positionPtr = _lookup<
|
|
ffi.NativeFunction<
|
|
ffi.Void Function(spine_skeleton, ffi.Float,
|
|
ffi.Float)>>('spine_skeleton_set_position');
|
|
late final _spine_skeleton_set_position = _spine_skeleton_set_positionPtr
|
|
.asFunction<void Function(spine_skeleton, double, double)>();
|
|
|
|
double spine_skeleton_get_x(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_x(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_x');
|
|
late final _spine_skeleton_get_x =
|
|
_spine_skeleton_get_xPtr.asFunction<double Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_x(
|
|
spine_skeleton skeleton,
|
|
double x,
|
|
) {
|
|
return _spine_skeleton_set_x(
|
|
skeleton,
|
|
x,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
|
|
'spine_skeleton_set_x');
|
|
late final _spine_skeleton_set_x = _spine_skeleton_set_xPtr
|
|
.asFunction<void Function(spine_skeleton, double)>();
|
|
|
|
double spine_skeleton_get_y(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_y(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_y');
|
|
late final _spine_skeleton_get_y =
|
|
_spine_skeleton_get_yPtr.asFunction<double Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_y(
|
|
spine_skeleton skeleton,
|
|
double y,
|
|
) {
|
|
return _spine_skeleton_set_y(
|
|
skeleton,
|
|
y,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
|
|
'spine_skeleton_set_y');
|
|
late final _spine_skeleton_set_y = _spine_skeleton_set_yPtr
|
|
.asFunction<void Function(spine_skeleton, double)>();
|
|
|
|
double spine_skeleton_get_scale_x(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_scale_x(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_scale_x');
|
|
late final _spine_skeleton_get_scale_x = _spine_skeleton_get_scale_xPtr
|
|
.asFunction<double Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_scale_x(
|
|
spine_skeleton skeleton,
|
|
double scaleX,
|
|
) {
|
|
return _spine_skeleton_set_scale_x(
|
|
skeleton,
|
|
scaleX,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_scale_xPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
|
|
'spine_skeleton_set_scale_x');
|
|
late final _spine_skeleton_set_scale_x = _spine_skeleton_set_scale_xPtr
|
|
.asFunction<void Function(spine_skeleton, double)>();
|
|
|
|
double spine_skeleton_get_scale_y(
|
|
spine_skeleton skeleton,
|
|
) {
|
|
return _spine_skeleton_get_scale_y(
|
|
skeleton,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_get_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Float Function(spine_skeleton)>>(
|
|
'spine_skeleton_get_scale_y');
|
|
late final _spine_skeleton_get_scale_y = _spine_skeleton_get_scale_yPtr
|
|
.asFunction<double Function(spine_skeleton)>();
|
|
|
|
void spine_skeleton_set_scale_y(
|
|
spine_skeleton skeleton,
|
|
double scaleY,
|
|
) {
|
|
return _spine_skeleton_set_scale_y(
|
|
skeleton,
|
|
scaleY,
|
|
);
|
|
}
|
|
|
|
late final _spine_skeleton_set_scale_yPtr =
|
|
_lookup<ffi.NativeFunction<ffi.Void Function(spine_skeleton, ffi.Float)>>(
|
|
'spine_skeleton_set_scale_y');
|
|
late final _spine_skeleton_set_scale_y = _spine_skeleton_set_scale_yPtr
|
|
.asFunction<void Function(spine_skeleton, double)>();
|
|
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8> Function(spine_event_data)>>(
|
|
'spine_event_data_get_name');
|
|
late final _spine_event_data_get_name = _spine_event_data_get_namePtr
|
|
.asFunction<ffi.Pointer<ffi.Int8> 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)>();
|
|
|
|
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)>();
|
|
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8> 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<ffi.Int8> Function(spine_event_data)>();
|
|
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8> 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<ffi.Int8> Function(spine_event_data)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8> Function(spine_event)>>(
|
|
'spine_event_get_string_value');
|
|
late final _spine_event_get_string_value = _spine_event_get_string_valuePtr
|
|
.asFunction<ffi.Pointer<ffi.Int8> Function(spine_event)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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<ffi.Int8> 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<ffi.Int8> Function(spine_slot_data)>>(
|
|
'spine_slot_data_get_name');
|
|
late final _spine_slot_data_get_name = _spine_slot_data_get_namePtr
|
|
.asFunction<ffi.Pointer<ffi.Int8> 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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
ffi.Pointer<ffi.Int8> 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<ffi.Int8> 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<ffi.Int8> Function(spine_slot_data)>();
|
|
|
|
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_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)>();
|
|
|
|
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<ffi.Int8> 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<ffi.Int8> Function(spine_bone_data)>>(
|
|
'spine_bone_data_get_name');
|
|
late final _spine_bone_data_get_name = _spine_bone_data_get_namePtr
|
|
.asFunction<ffi.Pointer<ffi.Int8> 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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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)>();
|
|
|
|
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_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)>();
|
|
}
|
|
|
|
class spine_atlas extends ffi.Struct {
|
|
external ffi.Pointer<ffi.Void> atlas;
|
|
|
|
external ffi.Pointer<ffi.Pointer<ffi.Int8>> imagePaths;
|
|
|
|
@ffi.Int32()
|
|
external int numImagePaths;
|
|
|
|
external ffi.Pointer<ffi.Int8> error;
|
|
}
|
|
|
|
class spine_skeleton_data_result extends ffi.Struct {
|
|
external spine_skeleton_data skeletonData;
|
|
|
|
external ffi.Pointer<ffi.Int8> error;
|
|
}
|
|
|
|
typedef spine_skeleton_data = ffi.Pointer<ffi.Void>;
|
|
|
|
abstract class spine_blend_mode {
|
|
static const int SPINE_BLEND_MODE_NORMAL = 0;
|
|
static const int SPINE_BLEND_MODE_ADDITIVE = 1;
|
|
static const int SPINE_BLEND_MODE_MULTIPLY = 2;
|
|
static const int SPINE_BLEND_MODE_SCREEN = 3;
|
|
}
|
|
|
|
abstract class spine_mix_blend {
|
|
static const int SPINE_MIX_BLEND_SETUP = 0;
|
|
static const int SPINE_MIX_BLEND_FIRST = 1;
|
|
static const int SPINE_MIX_BLEND_REPLACE = 2;
|
|
static const int SPINE_MIX_BLEND_ADD = 3;
|
|
}
|
|
|
|
abstract class spine_event_type {
|
|
static const int SPINE_EVENT_TYPE_START = 0;
|
|
static const int SPINE_EVENT_TYPE_INTERRUPT = 1;
|
|
static const int SPINE_EVENT_TYPE_END = 2;
|
|
static const int SPINE_EVENT_TYPE_COMPLETE = 3;
|
|
static const int SPINE_EVENT_TYPE_DISPOSE = 4;
|
|
static const int SPINE_EVENT_TYPE_EVENT = 5;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
class spine_render_command extends ffi.Struct {
|
|
external ffi.Pointer<ffi.Float> positions;
|
|
|
|
external ffi.Pointer<ffi.Float> uvs;
|
|
|
|
external ffi.Pointer<ffi.Int32> colors;
|
|
|
|
@ffi.Int32()
|
|
external int numVertices;
|
|
|
|
external ffi.Pointer<ffi.Uint16> indices;
|
|
|
|
@ffi.Int32()
|
|
external int numIndices;
|
|
|
|
@ffi.Int32()
|
|
external int atlasPage;
|
|
|
|
@ffi.Int32()
|
|
external int blendMode;
|
|
|
|
external ffi.Pointer<spine_render_command> next;
|
|
}
|
|
|
|
class spine_bounds extends ffi.Struct {
|
|
@ffi.Float()
|
|
external double x;
|
|
|
|
@ffi.Float()
|
|
external double y;
|
|
|
|
@ffi.Float()
|
|
external double width;
|
|
|
|
@ffi.Float()
|
|
external double height;
|
|
}
|
|
|
|
class spine_color extends ffi.Struct {
|
|
@ffi.Float()
|
|
external double r;
|
|
|
|
@ffi.Float()
|
|
external double g;
|
|
|
|
@ffi.Float()
|
|
external double b;
|
|
|
|
@ffi.Float()
|
|
external double a;
|
|
}
|
|
|
|
class spine_vector extends ffi.Struct {
|
|
@ffi.Float()
|
|
external double x;
|
|
|
|
@ffi.Float()
|
|
external double y;
|
|
}
|
|
|
|
class spine_skeleton_drawable extends ffi.Struct {
|
|
external spine_skeleton skeleton;
|
|
|
|
external spine_animation_state animationState;
|
|
|
|
external spine_animation_state_events animationStateEvents;
|
|
|
|
external ffi.Pointer<ffi.Void> clipping;
|
|
|
|
external ffi.Pointer<spine_render_command> renderCommand;
|
|
}
|
|
|
|
typedef spine_skeleton = ffi.Pointer<ffi.Void>;
|
|
typedef spine_animation_state = ffi.Pointer<ffi.Void>;
|
|
typedef spine_animation_state_events = ffi.Pointer<ffi.Void>;
|
|
typedef spine_bone_data = ffi.Pointer<ffi.Void>;
|
|
typedef spine_slot_data = ffi.Pointer<ffi.Void>;
|
|
typedef spine_skin = ffi.Pointer<ffi.Void>;
|
|
typedef spine_event_data = ffi.Pointer<ffi.Void>;
|
|
typedef spine_animation = ffi.Pointer<ffi.Void>;
|
|
typedef spine_ik_constraint_data = ffi.Pointer<ffi.Void>;
|
|
typedef spine_transform_constraint_data = ffi.Pointer<ffi.Void>;
|
|
typedef spine_path_constraint_data = ffi.Pointer<ffi.Void>;
|
|
typedef spine_track_entry = ffi.Pointer<ffi.Void>;
|
|
typedef spine_event = ffi.Pointer<ffi.Void>;
|
|
typedef spine_bone = ffi.Pointer<ffi.Void>;
|
|
typedef spine_slot = ffi.Pointer<ffi.Void>;
|
|
typedef spine_attachment = ffi.Pointer<ffi.Void>;
|
|
typedef spine_ik_constraint = ffi.Pointer<ffi.Void>;
|
|
typedef spine_transform_constraint = ffi.Pointer<ffi.Void>;
|
|
typedef spine_path_constraint = ffi.Pointer<ffi.Void>;
|