[cocos2d-objc] added new listeners for interrupt and dispose event, fixed up samples

spine-cocos2d-objc/example/SpineboyExample.m

@@ -48,26 +48,31 @@
 	[skeletonNode setMixFrom:@"jump" to:@"run" duration:0.2f];
 
     __weak SkeletonAnimation* node = skeletonNode;
-	skeletonNode.startListener = ^(int trackIndex) {
-		spTrackEntry* entry = spAnimationState_getCurrent(node.state, trackIndex);
-		const char* animationName = (entry && entry->animation) ? entry->animation->name : 0;
-		NSLog(@"%d start: %s", trackIndex, animationName);
+	skeletonNode.startListener = ^(spTrackEntry* entry) {
+		const char* animationName = entry->animation->name;
+		NSLog(@"%d start: %s", entry->trackIndex, animationName);
 	};
-	skeletonNode.endListener = ^(int trackIndex) {
-		NSLog(@"%d end", trackIndex);
+    skeletonNode.interruptListener = ^(spTrackEntry* entry) {
+        NSLog(@"%d interrupt", entry->trackIndex);
+    };
+	skeletonNode.endListener = ^(spTrackEntry* entry) {
+		NSLog(@"%d end", entry->trackIndex);
 	};
-	skeletonNode.completeListener = ^(int trackIndex, int loopCount) {
-		NSLog(@"%d complete: %d", trackIndex, loopCount);
+    skeletonNode.disposeListener = ^(spTrackEntry* entry) {
+        NSLog(@"%d dispose", entry->trackIndex);
+    };
+	skeletonNode.completeListener = ^(spTrackEntry* entry) {
+		NSLog(@"%d complete", entry->trackIndex);
 	};
-	skeletonNode.eventListener = ^(int trackIndex, spEvent* event) {
-		NSLog(@"%d event: %s, %d, %f, %s", trackIndex, event->data->name, event->intValue, event->floatValue, event->stringValue);
+	skeletonNode.eventListener = ^(spTrackEntry* entry, spEvent* event) {
+		NSLog(@"%d event: %s, %d, %f, %s", entry->trackIndex, event->data->name, event->intValue, event->floatValue, event->stringValue);
 	};
 
 	[skeletonNode setAnimationForTrack:0 name:@"walk" loop:YES];
 	spTrackEntry* jumpEntry = [skeletonNode addAnimationForTrack:0 name:@"jump" loop:NO afterDelay:3];
 	[skeletonNode addAnimationForTrack:0 name:@"run" loop:YES afterDelay:0];
 
-	[skeletonNode setListenerForEntry:jumpEntry onStart:^(int trackIndex) {
+	[skeletonNode setListenerForEntry:jumpEntry onStart:^(spTrackEntry* entry) {
 		CCLOG(@"jumped!");
 	}];
 

spine-cocos2d-objc/src/spine/SkeletonAnimation.h

@@ -34,10 +34,12 @@
 
 @class SkeletonAnimation;
 
-typedef void(^spStartListener)(int trackIndex);
-typedef void(^spEndListener)(int trackIndex);
-typedef void(^spCompleteListener)(int trackIndex, int loopCount);
-typedef void(^spEventListener)(int trackIndex, spEvent* event);
+typedef void(^spStartListener)(spTrackEntry* entry);
+typedef void(^spInterruptListener)(spTrackEntry* entry);
+typedef void(^spEndListener)(spTrackEntry* entry);
+typedef void(^spDisposeListener)(spTrackEntry* entry);
+typedef void(^spCompleteListener)(spTrackEntry* entry);
+typedef void(^spEventListener)(spTrackEntry* entry, spEvent* event);
 
 /** Draws an animated skeleton, providing an AnimationState for applying one or more animations and queuing animations to be
  * played later. */
@@ -47,7 +49,9 @@ typedef void(^spEventListener)(int trackIndex, spEvent* event);
 	float _timeScale;
 
 	spStartListener _startListener;
+    spInterruptListener _interruptListener;
 	spEndListener _endListener;
+    spDisposeListener _disposeListener;
 	spCompleteListener _completeListener;
 	spEventListener _eventListener;
 }
@@ -70,17 +74,21 @@ typedef void(^spEventListener)(int trackIndex, spEvent* event);
 - (void) clearTrack:(int)trackIndex;
 
 - (void) setListenerForEntry:(spTrackEntry*)entry onStart:(spStartListener)listener;
+- (void) setListenerForEntry:(spTrackEntry*)entry onInterrupt:(spInterruptListener)listener;
 - (void) setListenerForEntry:(spTrackEntry*)entry onEnd:(spEndListener)listener;
+- (void) setListenerForEntry:(spTrackEntry*)entry onDispose:(spDisposeListener)listener;
 - (void) setListenerForEntry:(spTrackEntry*)entry onComplete:(spCompleteListener)listener;
 - (void) setListenerForEntry:(spTrackEntry*)entry onEvent:(spEventListener)listener;
 
-- (void) onAnimationStateEvent:(int)trackIndex type:(spEventType)type event:(spEvent*)event loopCount:(int)loopCount;
-- (void) onTrackEntryEvent:(int)trackIndex type:(spEventType)type event:(spEvent*)event loopCount:(int)loopCount;
+- (void) onAnimationStateEvent:(spTrackEntry*)entry type:(spEventType)type event:(spEvent*)event;
+- (void) onTrackEntryEvent:(spTrackEntry*)entry type:(spEventType)type event:(spEvent*)event;
 
 @property (nonatomic, readonly) spAnimationState* state;
 @property (nonatomic) float timeScale;
 @property (nonatomic, copy) spStartListener startListener;
+@property (nonatomic, copy) spInterruptListener interruptListener;
 @property (nonatomic, copy) spEndListener endListener;
+@property (nonatomic, copy) spDisposeListener disposeListener;
 @property (nonatomic, copy) spCompleteListener completeListener;
 @property (nonatomic, copy) spEventListener eventListener;
 

spine-cocos2d-objc/src/spine/SkeletonAnimation.m

@@ -32,20 +32,32 @@
 #import <spine/spine-cocos2d-objc.h>
 #import <spine/extension.h>
 
-static void animationCallback (spAnimationState* state, int trackIndex, spEventType type, spEvent* event, int loopCount) {
-	[(SkeletonAnimation*)state->rendererObject onAnimationStateEvent:trackIndex type:type event:event loopCount:loopCount];
-}
+typedef struct _TrackEntryListeners {
+    spStartListener startListener;
+    spInterruptListener interruptListener;
+    spEndListener endListener;
+    spDisposeListener disposeListener;
+    spCompleteListener completeListener;
+    spEventListener eventListener;
+} _TrackEntryListeners;
 
-void trackEntryCallback (spAnimationState* state, int trackIndex, spEventType type, spEvent* event, int loopCount) {
-	[(SkeletonAnimation*)state->rendererObject onTrackEntryEvent:trackIndex type:type event:event loopCount:loopCount];
+static void animationCallback (spAnimationState* state, spEventType type, spTrackEntry* entry, spEvent* event) {
+	[(SkeletonAnimation*)state->rendererObject onAnimationStateEvent:entry type:type event:event];
 }
 
-typedef struct _TrackEntryListeners {
-	spStartListener startListener;
-	spEndListener endListener;
-	spCompleteListener completeListener;
-	spEventListener eventListener;
-} _TrackEntryListeners;
+void trackEntryCallback (spAnimationState* state, spEventType type, spTrackEntry* entry, spEvent* event) {
+	[(SkeletonAnimation*)state->rendererObject onTrackEntryEvent:entry type:type event:event];
+    if (type == SP_ANIMATION_DISPOSE) {
+        if (entry->rendererObject) {
+            _TrackEntryListeners* listeners = (_TrackEntryListeners*)entry->rendererObject;
+            [listeners->startListener release];
+            [listeners->endListener release];
+            [listeners->completeListener release];
+            [listeners->eventListener release];
+            FREE(listeners);
+        }
+    }
+}
 
 static _TrackEntryListeners* getListeners (spTrackEntry* entry) {
 	if (!entry->rendererObject) {
@@ -55,18 +67,6 @@ static _TrackEntryListeners* getListeners (spTrackEntry* entry) {
 	return (_TrackEntryListeners*)entry->rendererObject;
 }
 
-void disposeTrackEntry (spTrackEntry* entry) {
-	if (entry->rendererObject) {
-		_TrackEntryListeners* listeners = (_TrackEntryListeners*)entry->rendererObject;
-		[listeners->startListener release];
-		[listeners->endListener release];
-		[listeners->completeListener release];
-		[listeners->eventListener release];
-		FREE(listeners);
-	}
-	_spTrackEntry_dispose(entry);
-}
-
 //
 
 @interface SkeletonAnimation (Private)
@@ -103,7 +103,6 @@ void disposeTrackEntry (spTrackEntry* entry) {
 	_state->listener = animationCallback;
 
 	_spAnimationState* stateInternal = (_spAnimationState*)_state;
-	stateInternal->disposeTrackEntry = disposeTrackEntry;
 }
 
 - (id) initWithData:(spSkeletonData*)skeletonData ownsSkeletonData:(bool)ownsSkeletonData {
@@ -138,7 +137,9 @@ void disposeTrackEntry (spTrackEntry* entry) {
 	spAnimationState_dispose(_state);
 
 	[_startListener release];
+    [_interruptListener release];
 	[_endListener release];
+    [_disposeListener release];
 	[_completeListener release];
 	[_eventListener release];
 
@@ -199,39 +200,50 @@ void disposeTrackEntry (spTrackEntry* entry) {
 	spAnimationState_clearTrack(_state, trackIndex);
 }
 
-- (void) onAnimationStateEvent:(int)trackIndex type:(spEventType)type event:(spEvent*)event loopCount:(int)loopCount {
+- (void) onAnimationStateEvent:(spTrackEntry*)entry type:(spEventType)type event:(spEvent*)event {
 	switch (type) {
 	case SP_ANIMATION_START:
-		if (_startListener) _startListener(trackIndex);
+		if (_startListener) _startListener(entry);
 		break;
+    case SP_ANIMATION_INTERRUPT:
+        if (_interruptListener) _interruptListener(entry);
+        break;
 	case SP_ANIMATION_END:
-		if (_endListener) _endListener(trackIndex);
+		if (_endListener) _endListener(entry);
 		break;
+    case SP_ANIMATION_DISPOSE:
+        if (_disposeListener) _disposeListener(entry);
+        break;
 	case SP_ANIMATION_COMPLETE:
-		if (_completeListener) _completeListener(trackIndex, loopCount);
+        if (_completeListener) _completeListener(entry);
 		break;
 	case SP_ANIMATION_EVENT:
-		if (_eventListener) _eventListener(trackIndex, event);
+		if (_eventListener) _eventListener(entry, event);
 		break;
 	}
 }
 
-- (void) onTrackEntryEvent:(int)trackIndex type:(spEventType)type event:(spEvent*)event loopCount:(int)loopCount {
-	spTrackEntry* entry = spAnimationState_getCurrent(_state, trackIndex);
+- (void) onTrackEntryEvent:(spTrackEntry*)entry type:(spEventType)type event:(spEvent*)event {
 	if (!entry->rendererObject) return;
 	_TrackEntryListeners* listeners = (_TrackEntryListeners*)entry->rendererObject;
 	switch (type) {
 	case SP_ANIMATION_START:
-		if (listeners->startListener) listeners->startListener(trackIndex);
+		if (listeners->startListener) listeners->startListener(entry);
 		break;
+    case SP_ANIMATION_INTERRUPT:
+        if (listeners->interruptListener) listeners->interruptListener(entry);
+        break;
 	case SP_ANIMATION_END:
-		if (listeners->endListener) listeners->endListener(trackIndex);
+		if (listeners->endListener) listeners->endListener(entry);
 		break;
+    case SP_ANIMATION_DISPOSE:
+        if (listeners->disposeListener) listeners->disposeListener(entry);
+        break;
 	case SP_ANIMATION_COMPLETE:
-		if (listeners->completeListener) listeners->completeListener(trackIndex, loopCount);
+		if (listeners->completeListener) listeners->completeListener(entry);
 		break;
 	case SP_ANIMATION_EVENT:
-		if (listeners->eventListener) listeners->eventListener(trackIndex, event);
+		if (listeners->eventListener) listeners->eventListener(entry, event);
 		break;
 	}
 }
@@ -240,10 +252,18 @@ void disposeTrackEntry (spTrackEntry* entry) {
 	getListeners(entry)->startListener = [listener copy];
 }
 
+- (void) setListenerForEntry:(spTrackEntry*)entry onInterrupt:(spInterruptListener)listener {
+    getListeners(entry)->interruptListener = [listener copy];
+}
+
 - (void) setListenerForEntry:(spTrackEntry*)entry onEnd:(spEndListener)listener {
 	getListeners(entry)->endListener = [listener copy];
 }
 
+- (void) setListenerForEntry:(spTrackEntry*)entry onDispose:(spDisposeListener)listener {
+    getListeners(entry)->disposeListener = [listener copy];
+}
+
 - (void) setListenerForEntry:(spTrackEntry*)entry onComplete:(spCompleteListener)listener {
 	getListeners(entry)->completeListener = [listener copy];
 }