[flutter] Wrap Animation, EventData.

spine-flutter/example/lib/main.dart

@@ -80,9 +80,10 @@ class AnimationStateEvents extends StatelessWidget {
       });
       controller.animationState?.setListener((event) {
         if (event.type == EventType.Event) {
-          print("User event: { intValue: ${event.event?.getIntValue()}, floatValue: intValue: ${event.event?.getFloatValue()}, stringValue: ${event.event?.getStringValue()} }");
+          print("User event: { name: ${event.event?.getData().getName()}, intValue: ${event.event?.getIntValue()}, floatValue: intValue: ${event.event?.getFloatValue()}, stringValue: ${event.event?.getStringValue()} }");
         }
       });
+      print("Current: ${controller.animationState?.getCurrent(0)?.getAnimation().getName()}");
     });
 
     return Scaffold(

spine-flutter/lib/spine_flutter.dart

@@ -430,6 +430,15 @@ class Animation {
   final spine_animation _animation;
 
   Animation(this._animation);
+
+  String getName() {
+    final Pointer<Utf8> value = _bindings.spine_animation_get_name(_animation).cast();
+    return value.toDartString();
+  }
+
+  double getDuration() {
+    return _bindings.spine_animation_get_duration(_animation);
+  }
 }
 
 enum MixBlend {
@@ -727,6 +736,37 @@ class EventData {
   final spine_event_data _data;
 
   EventData(this._data);
+
+  String getName() {
+    final Pointer<Utf8> value = _bindings.spine_event_data_get_name(_data).cast();
+    return value.toDartString();
+  }
+
+  int getIntValue() {
+    return _bindings.spine_event_data_get_int_value(_data);
+  }
+
+  double getFloatValue() {
+    return _bindings.spine_event_data_get_float_value(_data);
+  }
+
+  String getStringValue() {
+    final Pointer<Utf8> value = _bindings.spine_event_data_get_string_value(_data).cast();
+    return value.toDartString();
+  }
+
+  String getAudioPath() {
+    final Pointer<Utf8> value = _bindings.spine_event_data_get_audio_path(_data).cast();
+    return value.toDartString();
+  }
+
+  double getVolume() {
+    return _bindings.spine_event_data_get_volume(_data);
+  }
+
+  double getBalance() {
+    return _bindings.spine_event_data_get_balance(_data);
+  }
 }
 
 class Event {

spine-flutter/lib/spine_flutter_bindings_generated.dart

@@ -188,6 +188,34 @@ class SpineFlutterBindings {
       _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,
@@ -1935,6 +1963,108 @@ class SpineFlutterBindings {
   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 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)>>(
+          '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)>();
+
+  int spine_event_data_get_int_value(
+    spine_event 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)>>(
+          '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)>();
+
+  double spine_event_data_get_float_value(
+    spine_event 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)>>(
+          '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)>();
+
+  ffi.Pointer<ffi.Int8> spine_event_data_get_string_value(
+    spine_event 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)>>(
+          '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)>();
+
+  ffi.Pointer<ffi.Int8> spine_event_data_get_audio_path(
+    spine_event 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)>>(
+          '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)>();
+
+  double spine_event_data_get_volume(
+    spine_event event,
+  ) {
+    return _spine_event_data_get_volume(
+      event,
+    );
+  }
+
+  late final _spine_event_data_get_volumePtr =
+      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
+          'spine_event_data_get_volume');
+  late final _spine_event_data_get_volume = _spine_event_data_get_volumePtr
+      .asFunction<double Function(spine_event)>();
+
+  double spine_event_data_get_balance(
+    spine_event event,
+  ) {
+    return _spine_event_data_get_balance(
+      event,
+    );
+  }
+
+  late final _spine_event_data_get_balancePtr =
+      _lookup<ffi.NativeFunction<ffi.Float Function(spine_event)>>(
+          'spine_event_data_get_balance');
+  late final _spine_event_data_get_balance = _spine_event_data_get_balancePtr
+      .asFunction<double Function(spine_event)>();
+
   spine_event_data spine_event_get_data(
     spine_event event,
   ) {
@@ -2143,9 +2273,9 @@ class spine_skeleton_drawable extends ffi.Struct {
 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_animation = ffi.Pointer<ffi.Void>;
 typedef spine_track_entry = ffi.Pointer<ffi.Void>;
 typedef spine_event = ffi.Pointer<ffi.Void>;
-typedef spine_animation = ffi.Pointer<ffi.Void>;
 typedef spine_bone = ffi.Pointer<ffi.Void>;
 typedef spine_slot = ffi.Pointer<ffi.Void>;
 typedef spine_skin = ffi.Pointer<ffi.Void>;

spine-flutter/src/spine_flutter.cpp

@@ -32,6 +32,8 @@ FFI_PLUGIN_EXPORT int spine_minor_version() {
     return SPINE_MINOR_VERSION;
 }
 
+// Atlas
+
 FFI_PLUGIN_EXPORT spine_atlas* spine_atlas_load(const char *atlasData) {
     if (!atlasData) return nullptr;
     int length = (int)strlen(atlasData);
@@ -61,6 +63,8 @@ FFI_PLUGIN_EXPORT void spine_atlas_dispose(spine_atlas *atlas) {
     SpineExtension::free(atlas, __FILE__, __LINE__);
 }
 
+// SkeletonData
+
 FFI_PLUGIN_EXPORT spine_skeleton_data_result spine_skeleton_data_load_json(spine_atlas *atlas, const char *skeletonData) {
     spine_skeleton_data_result result = { nullptr, nullptr };
     Bone::setYDown(true);
@@ -97,6 +101,8 @@ FFI_PLUGIN_EXPORT void spine_skeleton_data_dispose(spine_skeleton_data skeletonD
     delete (SkeletonData*)skeletonData;
 }
 
+// RenderCommand
+
 spine_render_command *spine_render_command_create(int numVertices, int numIndices, spine_blend_mode blendMode, int pageIndex) {
     spine_render_command *cmd = SpineExtension::alloc<spine_render_command>(1, __FILE__, __LINE__);
     cmd->positions = SpineExtension::alloc<float>(numVertices << 1, __FILE__, __LINE__);
@@ -120,6 +126,8 @@ void spine_render_command_dispose(spine_render_command *cmd) {
     SpineExtension::free(cmd, __FILE__, __LINE__);
 }
 
+// SkeletonDrawable
+
 FFI_PLUGIN_EXPORT spine_skeleton_drawable *spine_skeleton_drawable_create(spine_skeleton_data skeletonData) {
     spine_skeleton_drawable *drawable = SpineExtension::calloc<spine_skeleton_drawable>(1, __FILE__, __LINE__);
     drawable->skeleton = new Skeleton((SkeletonData*)skeletonData);
@@ -185,12 +193,12 @@ FFI_PLUGIN_EXPORT spine_render_command *spine_skeleton_drawable_render(spine_ske
         }
 
         Vector<float> *vertices = &worldVertices;
-        int verticesCount = 0;
-        Vector<float> *uvs = NULL;
+        int verticesCount;
+        Vector<float> *uvs;
         Vector<unsigned short> *indices;
-        int indicesCount = 0;
+        int indicesCount;
         Color *attachmentColor;
-        int pageIndex = -1;
+        int pageIndex;
 
         if (attachment->getRTTI().isExactly(RegionAttachment::rtti)) {
             RegionAttachment *regionAttachment = (RegionAttachment *) attachment;
@@ -271,6 +279,22 @@ FFI_PLUGIN_EXPORT spine_render_command *spine_skeleton_drawable_render(spine_ske
     return drawable->renderCommand;
 }
 
+// Animation
+
+FFI_PLUGIN_EXPORT const char* spine_animation_get_name(spine_animation animation) {
+    if (animation == nullptr) return nullptr;
+    Animation *_animation = (Animation*)animation;
+    return _animation->getName().buffer();
+}
+
+FFI_PLUGIN_EXPORT float spine_animation_get_duration(spine_animation animation) {
+    if (animation == nullptr) return 0;
+    Animation *_animation = (Animation*)animation;
+    return _animation->getDuration();
+}
+
+// AnimationState
+
 FFI_PLUGIN_EXPORT void spine_animation_state_update(spine_animation_state state, float delta) {
     if (state == nullptr) return;
     AnimationState *_state = (AnimationState*)state;
@@ -384,6 +408,8 @@ FFI_PLUGIN_EXPORT void spine_animation_state_events_reset(spine_animation_state_
     _events->events.clear();
 }
 
+// TrackEntry
+
 FFI_PLUGIN_EXPORT int spine_track_entry_get_track_index(spine_track_entry entry) {
     if (entry == nullptr) return 0;
     TrackEntry *_entry = (TrackEntry*)entry;
@@ -660,6 +686,8 @@ FFI_PLUGIN_EXPORT float spine_track_entry_get_track_complete(spine_track_entry e
     return _entry->getTrackComplete();
 }
 
+// Skeleton
+
 FFI_PLUGIN_EXPORT void spine_skeleton_update_cache(spine_skeleton skeleton) {
     if (skeleton == nullptr) return;
     Skeleton *_skeleton = (Skeleton*)skeleton;
@@ -927,6 +955,52 @@ FFI_PLUGIN_EXPORT void spine_skeleton_set_scale_y(spine_skeleton skeleton, float
     _skeleton->setScaleY(scaleY);
 }
 
+// EventData
+
+FFI_PLUGIN_EXPORT const char* spine_event_data_get_name(spine_event_data event) {
+    if (event == nullptr) return nullptr;
+    EventData *_event = (EventData*)event;
+    return _event->getName().buffer();
+}
+
+FFI_PLUGIN_EXPORT int spine_event_data_get_int_value(spine_event_data event) {
+    if (event == nullptr) return 0;
+    EventData *_event = (EventData*)event;
+    return _event->getIntValue();
+}
+
+FFI_PLUGIN_EXPORT float spine_event_data_get_float_value(spine_event_data event) {
+    if (event == nullptr) return 0;
+    EventData *_event = (EventData*)event;
+    return _event->getFloatValue();
+}
+
+FFI_PLUGIN_EXPORT const char* spine_event_data_get_string_value(spine_event_data event) {
+    if (event == nullptr) return nullptr;
+    EventData *_event = (EventData*)event;
+    return _event->getStringValue().buffer();
+}
+
+FFI_PLUGIN_EXPORT const char* spine_event_data_get_audio_path(spine_event_data event) {
+    if (event == nullptr) return nullptr;
+    EventData *_event = (EventData*)event;
+    return _event->getAudioPath().buffer();
+}
+
+FFI_PLUGIN_EXPORT float spine_event_data_get_volume(spine_event_data event) {
+    if (event == nullptr) return 0;
+    EventData *_event = (EventData*)event;
+    return _event->getVolume();
+}
+
+FFI_PLUGIN_EXPORT float spine_event_data_get_balance(spine_event_data event) {
+    if (event == nullptr) return 0;
+    EventData *_event = (EventData*)event;
+    return _event->getBalance();
+}
+
+// Event
+
 FFI_PLUGIN_EXPORT spine_event_data spine_event_get_data(spine_event event) {
     if (event == nullptr) return nullptr;
     Event *_event = (Event*)event;

spine-flutter/src/spine_flutter.h

@@ -122,6 +122,9 @@ FFI_PLUGIN_EXPORT spine_skeleton_drawable *spine_skeleton_drawable_create(spine_
 FFI_PLUGIN_EXPORT spine_render_command *spine_skeleton_drawable_render(spine_skeleton_drawable *drawable);
 FFI_PLUGIN_EXPORT void spine_skeleton_drawable_dispose(spine_skeleton_drawable *drawable);
 
+FFI_PLUGIN_EXPORT const char* spine_animation_get_name(spine_animation animation);
+FFI_PLUGIN_EXPORT float spine_animation_get_duration(spine_animation animation);
+
 FFI_PLUGIN_EXPORT void spine_animation_state_update(spine_animation_state state, float delta);
 FFI_PLUGIN_EXPORT void spine_animation_state_dispose_track_entry(spine_animation_state state, spine_track_entry entry);
 FFI_PLUGIN_EXPORT void spine_animation_state_apply(spine_animation_state state, spine_skeleton skeleton);
@@ -233,6 +236,14 @@ FFI_PLUGIN_EXPORT void spine_skeleton_set_scale_x(spine_skeleton skeleton, float
 FFI_PLUGIN_EXPORT float spine_skeleton_get_scale_y(spine_skeleton skeleton);
 FFI_PLUGIN_EXPORT void spine_skeleton_set_scale_y(spine_skeleton skeleton, float scaleY);
 
+FFI_PLUGIN_EXPORT const char* spine_event_data_get_name(spine_event event);
+FFI_PLUGIN_EXPORT int spine_event_data_get_int_value(spine_event event);
+FFI_PLUGIN_EXPORT float spine_event_data_get_float_value(spine_event event);
+FFI_PLUGIN_EXPORT const char* spine_event_data_get_string_value(spine_event event);
+FFI_PLUGIN_EXPORT const char* spine_event_data_get_audio_path(spine_event event);
+FFI_PLUGIN_EXPORT float spine_event_data_get_volume(spine_event event);
+FFI_PLUGIN_EXPORT float spine_event_data_get_balance(spine_event event);
+
 FFI_PLUGIN_EXPORT spine_event_data spine_event_get_data(spine_event event);
 FFI_PLUGIN_EXPORT float spine_event_get_time(spine_event event);
 FFI_PLUGIN_EXPORT int spine_event_get_int_value(spine_event event);