[cocos2dx] added new listeners for interrupt and dispose event, fixed up samples

spine-c/include/spine/AnimationState.h

@@ -63,6 +63,7 @@ struct spTrackEntry {
 	int timelinesFirstCount;
 	float* timelinesRotation;
 	int timelinesRotationCount;
+	void* rendererObject;
 
 #ifdef __cplusplus
 	spTrackEntry() :
@@ -93,6 +94,8 @@ struct spAnimationState {
 
 	float timeScale;
 
+	void* rendererObject;
+
 #ifdef __cplusplus
 	spAnimationState() :
 		data(0),

spine-cocos2dx/example/Classes/SpineboyExample.cpp

@@ -45,19 +45,23 @@ bool SpineboyExample::init () {
 
 	skeletonNode = SkeletonAnimation::createWithJsonFile("spineboy.json", "spineboy.atlas", 0.6f);
 
-	skeletonNode->setStartListener( [this] (int trackIndex) {
-		spTrackEntry* entry = spAnimationState_getCurrent(skeletonNode->getState(), trackIndex);
-		const char* animationName = (entry && entry->animation) ? entry->animation->name : 0;
-		log("%d start: %s", trackIndex, animationName);
+    skeletonNode->setStartListener( [] (spTrackEntry* entry) {
+		log("%d start: %s", entry->trackIndex, entry->animation->name);
 	});
-	skeletonNode->setEndListener( [] (int trackIndex) {
-		log("%d end", trackIndex);
+    skeletonNode->setInterruptListener( [] (spTrackEntry* entry) {
+        log("%d interrupt", entry->trackIndex);
+    });
+	skeletonNode->setEndListener( [] (spTrackEntry* entry) {
+		log("%d end", entry->trackIndex);
 	});
-	skeletonNode->setCompleteListener( [] (int trackIndex, int loopCount) {
-		log("%d complete: %d", trackIndex, loopCount);
+	skeletonNode->setCompleteListener( [] (spTrackEntry* entry) {
+		log("%d complete", entry->trackIndex);
 	});
-	skeletonNode->setEventListener( [] (int trackIndex, spEvent* event) {
-		log("%d event: %s, %d, %f, %s", trackIndex, event->data->name, event->intValue, event->floatValue, event->stringValue);
+    skeletonNode->setDisposeListener( [] (spTrackEntry* entry) {
+        log("%d dispose", entry->trackIndex);
+    });
+	skeletonNode->setEventListener( [] (spTrackEntry* entry, spEvent* event) {
+		log("%d event: %s, %d, %f, %s", entry->trackIndex, event->data->name, event->intValue, event->floatValue, event->stringValue);
 	});
 
 	skeletonNode->setMix("walk", "jump", 0.2f);
@@ -66,7 +70,7 @@ bool SpineboyExample::init () {
 	spTrackEntry* jumpEntry = skeletonNode->addAnimation(0, "jump", false, 3);
 	skeletonNode->addAnimation(0, "run", true);
 
-	skeletonNode->setTrackStartListener(jumpEntry, [] (int trackIndex) {
+	skeletonNode->setTrackStartListener(jumpEntry, [] (spTrackEntry* entry) {
 		log("jumped!");
 	});
 

spine-cocos2dx/src/spine/SkeletonAnimation.cpp

@@ -40,21 +40,25 @@ using std::vector;
 
 namespace spine {
 
-void animationCallback (spAnimationState* state, int trackIndex, spEventType type, spEvent* event, int loopCount) {
-	((SkeletonAnimation*)state->rendererObject)->onAnimationStateEvent(trackIndex, type, event, loopCount);
+typedef struct _TrackEntryListeners {
+    StartListener startListener;
+    InterruptListener interruptListener;
+    EndListener endListener;
+    DisposeListener disposeListener;
+    CompleteListener completeListener;
+    EventListener eventListener;
+} _TrackEntryListeners;
+    
+void animationCallback (spAnimationState* state, spEventType type, spTrackEntry* entry, spEvent* event) {
+	((SkeletonAnimation*)state->rendererObject)->onAnimationStateEvent(entry, type, event);
 }
 
-void trackEntryCallback (spAnimationState* state, int trackIndex, spEventType type, spEvent* event, int loopCount) {
-	((SkeletonAnimation*)state->rendererObject)->onTrackEntryEvent(trackIndex, type, event, loopCount);
+void trackEntryCallback (spAnimationState* state, spEventType type, spTrackEntry* entry, spEvent* event) {
+	((SkeletonAnimation*)state->rendererObject)->onTrackEntryEvent(entry, type, event);
+    if (type == SP_ANIMATION_DISPOSE)
+        if (entry->rendererObject) delete (spine::_TrackEntryListeners*)entry->rendererObject;
 }
 
-typedef struct _TrackEntryListeners {
-	StartListener startListener;
-	EndListener endListener;
-	CompleteListener completeListener;
-	EventListener eventListener;
-} _TrackEntryListeners;
-
 static _TrackEntryListeners* getListeners (spTrackEntry* entry) {
 	if (!entry->rendererObject) {
 		entry->rendererObject = new spine::_TrackEntryListeners();
@@ -62,12 +66,7 @@ static _TrackEntryListeners* getListeners (spTrackEntry* entry) {
 	}
 	return (_TrackEntryListeners*)entry->rendererObject;
 }
-
-void disposeTrackEntry (spTrackEntry* entry) {
-	if (entry->rendererObject) delete (spine::_TrackEntryListeners*)entry->rendererObject;
-	_spTrackEntry_dispose(entry);
-}
-
+    
 //
 
 SkeletonAnimation* SkeletonAnimation::createWithData (spSkeletonData* skeletonData, bool ownsSkeletonData) {
@@ -117,7 +116,6 @@ void SkeletonAnimation::initialize () {
 	_state->listener = animationCallback;
 
 	_spAnimationState* stateInternal = (_spAnimationState*)_state;
-	stateInternal->disposeTrackEntry = disposeTrackEntry;
 }
 
 SkeletonAnimation::SkeletonAnimation ()
@@ -188,39 +186,50 @@ void SkeletonAnimation::clearTrack (int trackIndex) {
 	spAnimationState_clearTrack(_state, trackIndex);
 }
 
-void SkeletonAnimation::onAnimationStateEvent (int trackIndex, spEventType type, spEvent* event, int loopCount) {
+void SkeletonAnimation::onAnimationStateEvent (spTrackEntry* entry, spEventType type, 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 SkeletonAnimation::onTrackEntryEvent (int trackIndex, spEventType type, spEvent* event, int loopCount) {
-	spTrackEntry* entry = spAnimationState_getCurrent(_state, trackIndex);
+void SkeletonAnimation::onTrackEntryEvent (spTrackEntry* entry, spEventType type, 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;
 	}
 }
@@ -228,10 +237,18 @@ void SkeletonAnimation::onTrackEntryEvent (int trackIndex, spEventType type, spE
 void SkeletonAnimation::setStartListener (const StartListener& listener) {
 	_startListener = listener;
 }
-
+    
+void SkeletonAnimation::setInterruptListener (const InterruptListener& listener) {
+    _interruptListener = listener;
+}
+    
 void SkeletonAnimation::setEndListener (const EndListener& listener) {
 	_endListener = listener;
 }
+    
+void SkeletonAnimation::setDisposeListener (const DisposeListener& listener) {
+    _disposeListener = listener;
+}
 
 void SkeletonAnimation::setCompleteListener (const CompleteListener& listener) {
 	_completeListener = listener;
@@ -244,10 +261,18 @@ void SkeletonAnimation::setEventListener (const EventListener& listener) {
 void SkeletonAnimation::setTrackStartListener (spTrackEntry* entry, const StartListener& listener) {
 	getListeners(entry)->startListener = listener;
 }
+    
+void SkeletonAnimation::setTrackInterruptListener (spTrackEntry* entry, const InterruptListener& listener) {
+    getListeners(entry)->interruptListener = listener;
+}
 
 void SkeletonAnimation::setTrackEndListener (spTrackEntry* entry, const EndListener& listener) {
 	getListeners(entry)->endListener = listener;
 }
+    
+void SkeletonAnimation::setTrackDisposeListener (spTrackEntry* entry, const DisposeListener& listener) {
+    getListeners(entry)->disposeListener = listener;
+}
 
 void SkeletonAnimation::setTrackCompleteListener (spTrackEntry* entry, const CompleteListener& listener) {
 	getListeners(entry)->completeListener = listener;

spine-cocos2dx/src/spine/SkeletonAnimation.h

@@ -37,10 +37,12 @@
 
 namespace spine {
 
-typedef std::function<void(int trackIndex)> StartListener;
-typedef std::function<void(int trackIndex)> EndListener;
-typedef std::function<void(int trackIndex, int loopCount)> CompleteListener;
-typedef std::function<void(int trackIndex, spEvent* event)> EventListener;
+typedef std::function<void(spTrackEntry* entry)> StartListener;
+typedef std::function<void(spTrackEntry* entry)> InterruptListener;
+typedef std::function<void(spTrackEntry* entry)> EndListener;
+typedef std::function<void(spTrackEntry* entry)> DisposeListener;
+typedef std::function<void(spTrackEntry* entry)> CompleteListener;
+typedef std::function<void(spTrackEntry* entry, spEvent* event)> EventListener;
 
 /** Draws an animated skeleton, providing an AnimationState for applying one or more animations and queuing animations to be
   * played later. */
@@ -77,17 +79,21 @@ public:
 	void clearTrack (int trackIndex = 0);
 
 	void setStartListener (const StartListener& listener);
+    void setInterruptListener (const InterruptListener& listener);
 	void setEndListener (const EndListener& listener);
+    void setDisposeListener (const DisposeListener& listener);
 	void setCompleteListener (const CompleteListener& listener);
 	void setEventListener (const EventListener& listener);
 
 	void setTrackStartListener (spTrackEntry* entry, const StartListener& listener);
+    void setTrackInterruptListener (spTrackEntry* entry, const InterruptListener& listener);
 	void setTrackEndListener (spTrackEntry* entry, const EndListener& listener);
+    void setTrackDisposeListener (spTrackEntry* entry, const DisposeListener& listener);
 	void setTrackCompleteListener (spTrackEntry* entry, const CompleteListener& listener);
 	void setTrackEventListener (spTrackEntry* entry, const EventListener& listener);
 
-	virtual void onAnimationStateEvent (int trackIndex, spEventType type, spEvent* event, int loopCount);
-	virtual void onTrackEntryEvent (int trackIndex, spEventType type, spEvent* event, int loopCount);
+	virtual void onAnimationStateEvent (spTrackEntry* entry, spEventType type, spEvent* event);
+	virtual void onTrackEntryEvent (spTrackEntry* entry, spEventType type, spEvent* event);
 
 	spAnimationState* getState() const;
 
@@ -102,7 +108,9 @@ protected:
 	bool _ownsAnimationStateData;
 
 	StartListener _startListener;
+    InterruptListener _interruptListener;
 	EndListener _endListener;
+    DisposeListener _disposeListener;
 	CompleteListener _completeListener;
 	EventListener _eventListener;