UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2025-12-21 01:36:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
badlogic 2016-11-04 15:28:56 +01:00
parent fcb878081c
commit e8f604f7b2
4 changed files with 88 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
spine-c/include/spine/AnimationState.h
View File

@ -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),

26
spine-cocos2dx/example/Classes/SpineboyExample.cpp
View File

@ -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->setCompleteListener( [] (int trackIndex, int loopCount) {
log("%d complete: %d", trackIndex, loopCount);
skeletonNode->setEndListener( [] (spTrackEntry* entry) {
log("%d end", 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->setCompleteListener( [] (spTrackEntry* entry) {
log("%d complete", entry->trackIndex);
});
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!");
});

75
spine-cocos2dx/src/spine/SkeletonAnimation.cpp
View File

@ -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);
}
void trackEntryCallback (spAnimationState* state, int trackIndex, spEventType type, spEvent* event, int loopCount) {
((SkeletonAnimation*)state->rendererObject)->onTrackEntryEvent(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, 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;
}
static _TrackEntryListeners* getListeners (spTrackEntry* entry) {
if (!entry->rendererObject) {
entry->rendererObject = new spine::_TrackEntryListeners();
@ -63,11 +67,6 @@ 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;
}
}
@ -229,10 +238,18 @@ 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;
}
@ -245,10 +262,18 @@ void SkeletonAnimation::setTrackStartListener (spTrackEntry* entry, const StartL
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;
}

20
spine-cocos2dx/src/spine/SkeletonAnimation.h
View File

@ -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;