From 3a18868d8dc02394aa4dd09bf302995b59d6bb74 Mon Sep 17 00:00:00 2001 From: badlogic Date: Fri, 4 Nov 2016 15:47:24 +0100 Subject: [PATCH] [cocos2d-objc] added new listeners for interrupt and dispose event, fixed up samples --- spine-cocos2d-objc/example/SpineboyExample.m | 27 +++--- .../src/spine/SkeletonAnimation.h | 20 ++-- .../src/spine/SkeletonAnimation.m | 92 +++++++++++-------- 3 files changed, 86 insertions(+), 53 deletions(-) diff --git a/spine-cocos2d-objc/example/SpineboyExample.m b/spine-cocos2d-objc/example/SpineboyExample.m index 905e73616..e8b108b33 100644 --- a/spine-cocos2d-objc/example/SpineboyExample.m +++ b/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!"); }]; diff --git a/spine-cocos2d-objc/src/spine/SkeletonAnimation.h b/spine-cocos2d-objc/src/spine/SkeletonAnimation.h index f6edf63fd..4c2715c92 100644 --- a/spine-cocos2d-objc/src/spine/SkeletonAnimation.h +++ b/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; diff --git a/spine-cocos2d-objc/src/spine/SkeletonAnimation.m b/spine-cocos2d-objc/src/spine/SkeletonAnimation.m index b525562de..7be6cadf8 100644 --- a/spine-cocos2d-objc/src/spine/SkeletonAnimation.m +++ b/spine-cocos2d-objc/src/spine/SkeletonAnimation.m @@ -32,21 +32,33 @@ #import #import -static void animationCallback (spAnimationState* state, int trackIndex, spEventType type, spEvent* event, int loopCount) { - [(SkeletonAnimation*)state->rendererObject onAnimationStateEvent:trackIndex type:type event:event loopCount:loopCount]; -} - -void trackEntryCallback (spAnimationState* state, int trackIndex, spEventType type, spEvent* event, int loopCount) { - [(SkeletonAnimation*)state->rendererObject onTrackEntryEvent:trackIndex type:type event:event loopCount:loopCount]; -} - typedef struct _TrackEntryListeners { - spStartListener startListener; - spEndListener endListener; - spCompleteListener completeListener; - spEventListener eventListener; + spStartListener startListener; + spInterruptListener interruptListener; + spEndListener endListener; + spDisposeListener disposeListener; + spCompleteListener completeListener; + spEventListener eventListener; } _TrackEntryListeners; +static void animationCallback (spAnimationState* state, spEventType type, spTrackEntry* entry, spEvent* event) { + [(SkeletonAnimation*)state->rendererObject onAnimationStateEvent:entry type:type event:event]; +} + +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) { entry->rendererObject = NEW(_TrackEntryListeners); @@ -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]; }