From c8bc2bc3786efece8d0e65fe439a758ab4bf09d9 Mon Sep 17 00:00:00 2001 From: Ricardo Quesada Date: Fri, 25 Jul 2014 10:16:11 -0700 Subject: [PATCH] Supports cocos2d-x v3.2 - Changes `draw()` with the new v3.2 API: `bool transformUpdated` -> `uint32_t transformFlags` - cocos2d-ified the API: - `const char*` -> `const std::string&` - constructors and destructors are `protected` (not `public`) - using `_` prefix for ivars --- spine-cocos2dx/3.2/src/spine/PolygonBatch.cpp | 56 +++--- spine-cocos2dx/3.2/src/spine/PolygonBatch.h | 28 ++- .../3.2/src/spine/SkeletonAnimation.cpp | 70 +++---- .../3.2/src/spine/SkeletonAnimation.h | 41 ++-- .../3.2/src/spine/SkeletonRenderer.cpp | 181 +++++++++--------- .../3.2/src/spine/SkeletonRenderer.h | 59 +++--- 6 files changed, 217 insertions(+), 218 deletions(-) diff --git a/spine-cocos2dx/3.2/src/spine/PolygonBatch.cpp b/spine-cocos2dx/3.2/src/spine/PolygonBatch.cpp index a8a227873..a24b5825c 100644 --- a/spine-cocos2dx/3.2/src/spine/PolygonBatch.cpp +++ b/spine-cocos2dx/3.2/src/spine/PolygonBatch.cpp @@ -35,7 +35,7 @@ USING_NS_CC; namespace spine { -PolygonBatch* PolygonBatch::createWithCapacity (int capacity) { +PolygonBatch* PolygonBatch::createWithCapacity (ssize_t capacity) { PolygonBatch* batch = new PolygonBatch(); batch->initWithCapacity(capacity); batch->autorelease(); @@ -43,25 +43,25 @@ PolygonBatch* PolygonBatch::createWithCapacity (int capacity) { } PolygonBatch::PolygonBatch () : - capacity(0), - vertices(nullptr), verticesCount(0), - triangles(nullptr), trianglesCount(0), - texture(nullptr) + _capacity(0), + _vertices(nullptr), _verticesCount(0), + _triangles(nullptr), _trianglesCount(0), + _texture(nullptr) {} -bool PolygonBatch::initWithCapacity (int capacity) { +bool PolygonBatch::initWithCapacity (ssize_t capacity) { // 32767 is max index, so 32767 / 3 - (32767 / 3 % 3) = 10920. CCASSERT(capacity <= 10920, "capacity cannot be > 10920"); CCASSERT(capacity >= 0, "capacity cannot be < 0"); - this->capacity = capacity; - vertices = MALLOC(V2F_C4B_T2F, capacity); - triangles = MALLOC(GLushort, capacity * 3); + _capacity = capacity; + _vertices = MALLOC(V2F_C4B_T2F, capacity); + _triangles = MALLOC(GLushort, capacity * 3); return true; } PolygonBatch::~PolygonBatch () { - FREE(vertices); - FREE(triangles); + FREE(_vertices); + FREE(_triangles); } void PolygonBatch::add (const Texture2D* addTexture, @@ -70,18 +70,18 @@ void PolygonBatch::add (const Texture2D* addTexture, Color4B* color) { if ( - addTexture != texture - || verticesCount + (addVerticesCount >> 1) > capacity - || trianglesCount + addTrianglesCount > capacity * 3) { + addTexture != _texture + || _verticesCount + (addVerticesCount >> 1) > _capacity + || _trianglesCount + addTrianglesCount > _capacity * 3) { this->flush(); - texture = addTexture; + _texture = addTexture; } - for (int i = 0; i < addTrianglesCount; ++i, ++trianglesCount) - triangles[trianglesCount] = addTriangles[i] + verticesCount; + for (int i = 0; i < addTrianglesCount; ++i, ++_trianglesCount) + _triangles[_trianglesCount] = addTriangles[i] + _verticesCount; - for (int i = 0; i < addVerticesCount; i += 2, ++verticesCount) { - V2F_C4B_T2F* vertex = vertices + verticesCount; + for (int i = 0; i < addVerticesCount; i += 2, ++_verticesCount) { + V2F_C4B_T2F* vertex = _vertices + _verticesCount; vertex->vertices.x = addVertices[i]; vertex->vertices.y = addVertices[i + 1]; vertex->colors = *color; @@ -91,20 +91,22 @@ void PolygonBatch::add (const Texture2D* addTexture, } void PolygonBatch::flush () { - if (!verticesCount) return; + if (!_verticesCount) return; - GL::bindTexture2D(texture->getName()); + GL::bindTexture2D(_texture->getName()); glEnableVertexAttribArray(GLProgram::VERTEX_ATTRIB_POSITION); glEnableVertexAttribArray(GLProgram::VERTEX_ATTRIB_COLOR); glEnableVertexAttribArray(GLProgram::VERTEX_ATTRIB_TEX_COORDS); - glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), &vertices[0].vertices); - glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(V2F_C4B_T2F), &vertices[0].colors); - glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORDS, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), &vertices[0].texCoords); + glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), &_vertices[0].vertices); + glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(V2F_C4B_T2F), &_vertices[0].colors); + glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORDS, 2, GL_FLOAT, GL_FALSE, sizeof(V2F_C4B_T2F), &_vertices[0].texCoords); - glDrawElements(GL_TRIANGLES, trianglesCount, GL_UNSIGNED_SHORT, triangles); + glDrawElements(GL_TRIANGLES, _trianglesCount, GL_UNSIGNED_SHORT, _triangles); - verticesCount = 0; - trianglesCount = 0; + CC_INCREMENT_GL_DRAWN_BATCHES_AND_VERTICES(1, _verticesCount); + + _verticesCount = 0; + _trianglesCount = 0; CHECK_GL_ERROR_DEBUG(); } diff --git a/spine-cocos2dx/3.2/src/spine/PolygonBatch.h b/spine-cocos2dx/3.2/src/spine/PolygonBatch.h index 904f4ae8f..78bd22f23 100644 --- a/spine-cocos2dx/3.2/src/spine/PolygonBatch.h +++ b/spine-cocos2dx/3.2/src/spine/PolygonBatch.h @@ -37,29 +37,25 @@ namespace spine { class PolygonBatch : public cocos2d::Ref { public: - static PolygonBatch* createWithCapacity (int capacity); + static PolygonBatch* createWithCapacity (ssize_t capacity); - /** @js ctor */ - PolygonBatch(); - - /** @js NA - * @lua NA */ - virtual ~PolygonBatch(); - - bool initWithCapacity (int capacity); void add (const cocos2d::Texture2D* texture, const float* vertices, const float* uvs, int verticesCount, const int* triangles, int trianglesCount, cocos2d::Color4B* color); void flush (); -private: - int capacity; - cocos2d::V2F_C4B_T2F* vertices; - int verticesCount; - GLushort* triangles; - int trianglesCount; - const cocos2d::Texture2D* texture; +protected: + PolygonBatch(); + virtual ~PolygonBatch(); + bool initWithCapacity (ssize_t capacity); + + ssize_t _capacity; + cocos2d::V2F_C4B_T2F* _vertices; + int _verticesCount; + GLushort* _triangles; + int _trianglesCount; + const cocos2d::Texture2D* _texture; }; } diff --git a/spine-cocos2dx/3.2/src/spine/SkeletonAnimation.cpp b/spine-cocos2dx/3.2/src/spine/SkeletonAnimation.cpp index 611916ea3..19a3af487 100644 --- a/spine-cocos2dx/3.2/src/spine/SkeletonAnimation.cpp +++ b/spine-cocos2dx/3.2/src/spine/SkeletonAnimation.cpp @@ -76,13 +76,13 @@ SkeletonAnimation* SkeletonAnimation::createWithData (spSkeletonData* skeletonDa return node; } -SkeletonAnimation* SkeletonAnimation::createWithFile (const char* skeletonDataFile, spAtlas* atlas, float scale) { +SkeletonAnimation* SkeletonAnimation::createWithFile (const std::string& skeletonDataFile, spAtlas* atlas, float scale) { SkeletonAnimation* node = new SkeletonAnimation(skeletonDataFile, atlas, scale); node->autorelease(); return node; } -SkeletonAnimation* SkeletonAnimation::createWithFile (const char* skeletonDataFile, const char* atlasFile, float scale) { +SkeletonAnimation* SkeletonAnimation::createWithFile (const std::string& skeletonDataFile, const std::string& atlasFile, float scale) { SkeletonAnimation* node = new SkeletonAnimation(skeletonDataFile, atlasFile, scale); node->autorelease(); return node; @@ -90,11 +90,11 @@ SkeletonAnimation* SkeletonAnimation::createWithFile (const char* skeletonDataFi void SkeletonAnimation::initialize () { ownsAnimationStateData = true; - state = spAnimationState_create(spAnimationStateData_create(skeleton->data)); - state->rendererObject = this; - state->listener = animationCallback; + _state = spAnimationState_create(spAnimationStateData_create(_skeleton->data)); + _state->rendererObject = this; + _state->listener = animationCallback; - _spAnimationState* stateInternal = (_spAnimationState*)state; + _spAnimationState* stateInternal = (_spAnimationState*)_state; stateInternal->disposeTrackEntry = disposeTrackEntry; } @@ -103,74 +103,74 @@ SkeletonAnimation::SkeletonAnimation (spSkeletonData *skeletonData) initialize(); } -SkeletonAnimation::SkeletonAnimation (const char* skeletonDataFile, spAtlas* atlas, float scale) +SkeletonAnimation::SkeletonAnimation (const std::string& skeletonDataFile, spAtlas* atlas, float scale) : SkeletonRenderer(skeletonDataFile, atlas, scale) { initialize(); } -SkeletonAnimation::SkeletonAnimation (const char* skeletonDataFile, const char* atlasFile, float scale) +SkeletonAnimation::SkeletonAnimation (const std::string& skeletonDataFile, const std::string& atlasFile, float scale) : SkeletonRenderer(skeletonDataFile, atlasFile, scale) { initialize(); } SkeletonAnimation::~SkeletonAnimation () { - if (ownsAnimationStateData) spAnimationStateData_dispose(state->data); - spAnimationState_dispose(state); + if (ownsAnimationStateData) spAnimationStateData_dispose(_state->data); + spAnimationState_dispose(_state); } void SkeletonAnimation::update (float deltaTime) { super::update(deltaTime); - deltaTime *= timeScale; - spAnimationState_update(state, deltaTime); - spAnimationState_apply(state, skeleton); - spSkeleton_updateWorldTransform(skeleton); + deltaTime *= _timeScale; + spAnimationState_update(_state, deltaTime); + spAnimationState_apply(_state, _skeleton); + spSkeleton_updateWorldTransform(_skeleton); } void SkeletonAnimation::setAnimationStateData (spAnimationStateData* stateData) { CCASSERT(stateData, "stateData cannot be null."); - if (ownsAnimationStateData) spAnimationStateData_dispose(state->data); - spAnimationState_dispose(state); + if (ownsAnimationStateData) spAnimationStateData_dispose(_state->data); + spAnimationState_dispose(_state); ownsAnimationStateData = false; - state = spAnimationState_create(stateData); - state->rendererObject = this; - state->listener = animationCallback; + _state = spAnimationState_create(stateData); + _state->rendererObject = this; + _state->listener = animationCallback; } -void SkeletonAnimation::setMix (const char* fromAnimation, const char* toAnimation, float duration) { - spAnimationStateData_setMixByName(state->data, fromAnimation, toAnimation, duration); +void SkeletonAnimation::setMix (const std::string& fromAnimation, const std::string& toAnimation, float duration) { + spAnimationStateData_setMixByName(_state->data, fromAnimation.c_str(), toAnimation.c_str(), duration); } -spTrackEntry* SkeletonAnimation::setAnimation (int trackIndex, const char* name, bool loop) { - spAnimation* animation = spSkeletonData_findAnimation(skeleton->data, name); +spTrackEntry* SkeletonAnimation::setAnimation (int trackIndex, const std::string& name, bool loop) { + spAnimation* animation = spSkeletonData_findAnimation(_skeleton->data, name.c_str()); if (!animation) { - log("Spine: Animation not found: %s", name); + log("Spine: Animation not found: %s", name.c_str()); return 0; } - return spAnimationState_setAnimation(state, trackIndex, animation, loop); + return spAnimationState_setAnimation(_state, trackIndex, animation, loop); } -spTrackEntry* SkeletonAnimation::addAnimation (int trackIndex, const char* name, bool loop, float delay) { - spAnimation* animation = spSkeletonData_findAnimation(skeleton->data, name); +spTrackEntry* SkeletonAnimation::addAnimation (int trackIndex, const std::string& name, bool loop, float delay) { + spAnimation* animation = spSkeletonData_findAnimation(_skeleton->data, name.c_str()); if (!animation) { - log("Spine: Animation not found: %s", name); + log("Spine: Animation not found: %s", name.c_str()); return 0; } - return spAnimationState_addAnimation(state, trackIndex, animation, loop, delay); + return spAnimationState_addAnimation(_state, trackIndex, animation, loop, delay); } spTrackEntry* SkeletonAnimation::getCurrent (int trackIndex) { - return spAnimationState_getCurrent(state, trackIndex); + return spAnimationState_getCurrent(_state, trackIndex); } void SkeletonAnimation::clearTracks () { - spAnimationState_clearTracks(state); + spAnimationState_clearTracks(_state); } void SkeletonAnimation::clearTrack (int trackIndex) { - spAnimationState_clearTrack(state, trackIndex); + spAnimationState_clearTrack(_state, trackIndex); } void SkeletonAnimation::onAnimationStateEvent (int trackIndex, spEventType type, spEvent* event, int loopCount) { @@ -191,7 +191,7 @@ void SkeletonAnimation::onAnimationStateEvent (int trackIndex, spEventType type, } void SkeletonAnimation::onTrackEntryEvent (int trackIndex, spEventType type, spEvent* event, int loopCount) { - spTrackEntry* entry = spAnimationState_getCurrent(state, trackIndex); + spTrackEntry* entry = spAnimationState_getCurrent(_state, trackIndex); if (!entry->rendererObject) return; _TrackEntryListeners* listeners = (_TrackEntryListeners*)entry->rendererObject; switch (type) { @@ -226,4 +226,8 @@ void SkeletonAnimation::setEventListener (spTrackEntry* entry, spine::EventListe getListeners(entry)->eventListener = listener; } +spAnimationState* SkeletonAnimation::getState() const { + return _state; +} + } diff --git a/spine-cocos2dx/3.2/src/spine/SkeletonAnimation.h b/spine-cocos2dx/3.2/src/spine/SkeletonAnimation.h index ce5da45bb..8bc49b7a6 100644 --- a/spine-cocos2dx/3.2/src/spine/SkeletonAnimation.h +++ b/spine-cocos2dx/3.2/src/spine/SkeletonAnimation.h @@ -46,33 +46,21 @@ typedef std::function EventListener; * played later. */ class SkeletonAnimation: public SkeletonRenderer { public: - spAnimationState* state; - static SkeletonAnimation* createWithData (spSkeletonData* skeletonData); - static SkeletonAnimation* createWithFile (const char* skeletonDataFile, spAtlas* atlas, float scale = 0); - static SkeletonAnimation* createWithFile (const char* skeletonDataFile, const char* atlasFile, float scale = 0); - - SkeletonAnimation (spSkeletonData* skeletonData); - SkeletonAnimation (const char* skeletonDataFile, spAtlas* atlas, float scale = 0); - SkeletonAnimation (const char* skeletonDataFile, const char* atlasFile, float scale = 0); - - virtual ~SkeletonAnimation (); + static SkeletonAnimation* createWithFile (const std::string& skeletonDataFile, spAtlas* atlas, float scale = 0); + static SkeletonAnimation* createWithFile (const std::string& skeletonDataFile, const std::string& atlasFile, float scale = 0); virtual void update (float deltaTime); void setAnimationStateData (spAnimationStateData* stateData); - void setMix (const char* fromAnimation, const char* toAnimation, float duration); + void setMix (const std::string& fromAnimation, const std::string& toAnimation, float duration); - spTrackEntry* setAnimation (int trackIndex, const char* name, bool loop); - spTrackEntry* addAnimation (int trackIndex, const char* name, bool loop, float delay = 0); + spTrackEntry* setAnimation (int trackIndex, const std::string& name, bool loop); + spTrackEntry* addAnimation (int trackIndex, const std::string& name, bool loop, float delay = 0); spTrackEntry* getCurrent (int trackIndex = 0); void clearTracks (); void clearTrack (int trackIndex = 0); - StartListener startListener; - EndListener endListener; - CompleteListener completeListener; - EventListener eventListener; void setStartListener (spTrackEntry* entry, StartListener listener); void setEndListener (spTrackEntry* entry, EndListener listener); void setCompleteListener (spTrackEntry* entry, CompleteListener listener); @@ -81,14 +69,27 @@ public: virtual void onAnimationStateEvent (int trackIndex, spEventType type, spEvent* event, int loopCount); virtual void onTrackEntryEvent (int trackIndex, spEventType type, spEvent* event, int loopCount); + spAnimationState* getState() const; + + StartListener startListener; + EndListener endListener; + CompleteListener completeListener; + EventListener eventListener; + protected: SkeletonAnimation (); + SkeletonAnimation (spSkeletonData* skeletonData); + SkeletonAnimation (const std::string&skeletonDataFile, spAtlas* atlas, float scale = 0); + SkeletonAnimation (const std::string& skeletonDataFile, const std::string& atlasFile, float scale = 0); + virtual ~SkeletonAnimation (); + void initialize (); + + spAnimationState* _state; + + bool ownsAnimationStateData; private: typedef SkeletonRenderer super; - bool ownsAnimationStateData; - - void initialize (); }; } diff --git a/spine-cocos2dx/3.2/src/spine/SkeletonRenderer.cpp b/spine-cocos2dx/3.2/src/spine/SkeletonRenderer.cpp index 784952983..91b43f4cc 100644 --- a/spine-cocos2dx/3.2/src/spine/SkeletonRenderer.cpp +++ b/spine-cocos2dx/3.2/src/spine/SkeletonRenderer.cpp @@ -48,30 +48,30 @@ SkeletonRenderer* SkeletonRenderer::createWithData (spSkeletonData* skeletonData return node; } -SkeletonRenderer* SkeletonRenderer::createWithFile (const char* skeletonDataFile, spAtlas* atlas, float scale) { +SkeletonRenderer* SkeletonRenderer::createWithFile (const std::string& skeletonDataFile, spAtlas* atlas, float scale) { SkeletonRenderer* node = new SkeletonRenderer(skeletonDataFile, atlas, scale); node->autorelease(); return node; } -SkeletonRenderer* SkeletonRenderer::createWithFile (const char* skeletonDataFile, const char* atlasFile, float scale) { +SkeletonRenderer* SkeletonRenderer::createWithFile (const std::string& skeletonDataFile, const std::string& atlasFile, float scale) { SkeletonRenderer* node = new SkeletonRenderer(skeletonDataFile, atlasFile, scale); node->autorelease(); return node; } void SkeletonRenderer::initialize () { - atlas = 0; - debugSlots = false; - debugBones = false; - timeScale = 1; + _atlas = 0; + _debugSlots = false; + _debugBones = false; + _timeScale = 1; - worldVertices = MALLOC(float, 1000); // Max number of vertices per mesh. + _worldVertices = MALLOC(float, 1000); // Max number of vertices per mesh. - batch = PolygonBatch::createWithCapacity(2000); // Max number of vertices and triangles per batch. - batch->retain(); + _batch = PolygonBatch::createWithCapacity(2000); // Max number of vertices and triangles per batch. + _batch->retain(); - blendFunc = BlendFunc::ALPHA_PREMULTIPLIED; + _blendFunc = BlendFunc::ALPHA_PREMULTIPLIED; setOpacityModifyRGB(true); setGLProgram(ShaderCache::getInstance()->getGLProgram(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR)); @@ -79,9 +79,9 @@ void SkeletonRenderer::initialize () { } void SkeletonRenderer::setSkeletonData (spSkeletonData *skeletonData, bool ownsSkeletonData) { - skeleton = spSkeleton_create(skeletonData); - rootBone = skeleton->bones[0]; - this->ownsSkeletonData = ownsSkeletonData; + _skeleton = spSkeleton_create(skeletonData); + _rootBone = _skeleton->bones[0]; + _ownsSkeletonData = ownsSkeletonData; } SkeletonRenderer::SkeletonRenderer () { @@ -94,27 +94,27 @@ SkeletonRenderer::SkeletonRenderer (spSkeletonData *skeletonData, bool ownsSkele setSkeletonData(skeletonData, ownsSkeletonData); } -SkeletonRenderer::SkeletonRenderer (const char* skeletonDataFile, spAtlas* atlas, float scale) { +SkeletonRenderer::SkeletonRenderer (const std::string& skeletonDataFile, spAtlas* atlas, float scale) { initialize(); spSkeletonJson* json = spSkeletonJson_create(atlas); json->scale = scale; - spSkeletonData* skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonDataFile); + spSkeletonData* skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonDataFile.c_str()); CCASSERT(skeletonData, json->error ? json->error : "Error reading skeleton data."); spSkeletonJson_dispose(json); setSkeletonData(skeletonData, true); } -SkeletonRenderer::SkeletonRenderer (const char* skeletonDataFile, const char* atlasFile, float scale) { +SkeletonRenderer::SkeletonRenderer (const std::string& skeletonDataFile, const std::string& atlasFile, float scale) { initialize(); - atlas = spAtlas_createFromFile(atlasFile, 0); - CCASSERT(atlas, "Error reading atlas file."); + _atlas = spAtlas_createFromFile(atlasFile.c_str(), 0); + CCASSERT(_atlas, "Error reading atlas file."); - spSkeletonJson* json = spSkeletonJson_create(atlas); + spSkeletonJson* json = spSkeletonJson_create(_atlas); json->scale = scale; - spSkeletonData* skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonDataFile); + spSkeletonData* skeletonData = spSkeletonJson_readSkeletonDataFile(json, skeletonDataFile.c_str()); CCASSERT(skeletonData, json->error ? json->error : "Error reading skeleton data file."); spSkeletonJson_dispose(json); @@ -122,33 +122,32 @@ SkeletonRenderer::SkeletonRenderer (const char* skeletonDataFile, const char* at } SkeletonRenderer::~SkeletonRenderer () { - if (ownsSkeletonData) spSkeletonData_dispose(skeleton->data); - if (atlas) spAtlas_dispose(atlas); - spSkeleton_dispose(skeleton); - batch->release(); - FREE(worldVertices); + if (_ownsSkeletonData) spSkeletonData_dispose(_skeleton->data); + if (_atlas) spAtlas_dispose(_atlas); + spSkeleton_dispose(_skeleton); + _batch->release(); + FREE(_worldVertices); } void SkeletonRenderer::update (float deltaTime) { - spSkeleton_update(skeleton, deltaTime * timeScale); + spSkeleton_update(_skeleton, deltaTime * _timeScale); } -void SkeletonRenderer::draw (Renderer* renderer, const Mat4& transform, bool transformUpdated) { - drawCommand.init(_globalZOrder); - drawCommand.func = CC_CALLBACK_0(SkeletonRenderer::drawSkeleton, this, transform, transformUpdated); - renderer->addCommand(&drawCommand); +void SkeletonRenderer::draw (Renderer* renderer, const Mat4& transform, uint32_t transformFlags) { + _drawCommand.init(_globalZOrder); + _drawCommand.func = CC_CALLBACK_0(SkeletonRenderer::drawSkeleton, this, transform, transformFlags); + renderer->addCommand(&_drawCommand); } -void SkeletonRenderer::drawSkeleton (const Mat4 &transform, bool transformUpdated) { - getGLProgram()->use(); - getGLProgram()->setUniformsForBuiltins(transform); - GL::bindVAO(0); +void SkeletonRenderer::drawSkeleton (const Mat4 &transform, uint32_t transformFlags) { + + getGLProgramState()->apply(transform); Color3B nodeColor = getColor(); - skeleton->r = nodeColor.r / (float)255; - skeleton->g = nodeColor.g / (float)255; - skeleton->b = nodeColor.b / (float)255; - skeleton->a = getDisplayedOpacity() / (float)255; + _skeleton->r = nodeColor.r / (float)255; + _skeleton->g = nodeColor.g / (float)255; + _skeleton->b = nodeColor.b / (float)255; + _skeleton->a = getDisplayedOpacity() / (float)255; int additive = -1; Color4B color; @@ -157,14 +156,14 @@ void SkeletonRenderer::drawSkeleton (const Mat4 &transform, bool transformUpdate const int* triangles = nullptr; int trianglesCount = 0; float r = 0, g = 0, b = 0, a = 0; - for (int i = 0, n = skeleton->slotCount; i < n; i++) { - spSlot* slot = skeleton->drawOrder[i]; + for (int i = 0, n = _skeleton->slotCount; i < n; i++) { + spSlot* slot = _skeleton->drawOrder[i]; if (!slot->attachment) continue; Texture2D *texture = nullptr; switch (slot->attachment->type) { case SP_ATTACHMENT_REGION: { spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment; - spRegionAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot->bone, worldVertices); + spRegionAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot->bone, _worldVertices); texture = getTexture(attachment); uvs = attachment->uvs; verticesCount = 8; @@ -178,7 +177,7 @@ void SkeletonRenderer::drawSkeleton (const Mat4 &transform, bool transformUpdate } case SP_ATTACHMENT_MESH: { spMeshAttachment* attachment = (spMeshAttachment*)slot->attachment; - spMeshAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot, worldVertices); + spMeshAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot, _worldVertices); texture = getTexture(attachment); uvs = attachment->uvs; verticesCount = attachment->verticesCount; @@ -192,7 +191,7 @@ void SkeletonRenderer::drawSkeleton (const Mat4 &transform, bool transformUpdate } case SP_ATTACHMENT_SKINNED_MESH: { spSkinnedMeshAttachment* attachment = (spSkinnedMeshAttachment*)slot->attachment; - spSkinnedMeshAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot, worldVertices); + spSkinnedMeshAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot, _worldVertices); texture = getTexture(attachment); uvs = attachment->uvs; verticesCount = attachment->uvsCount; @@ -208,49 +207,49 @@ void SkeletonRenderer::drawSkeleton (const Mat4 &transform, bool transformUpdate } if (texture) { if (slot->data->additiveBlending != additive) { - batch->flush(); - GL::blendFunc(blendFunc.src, slot->data->additiveBlending ? GL_ONE : blendFunc.dst); + _batch->flush(); + GL::blendFunc(_blendFunc.src, slot->data->additiveBlending ? GL_ONE : _blendFunc.dst); additive = slot->data->additiveBlending; } - color.a = skeleton->a * slot->a * a * 255; - float multiplier = premultipliedAlpha ? color.a : 255; - color.r = skeleton->r * slot->r * r * multiplier; - color.g = skeleton->g * slot->g * g * multiplier; - color.b = skeleton->b * slot->b * b * multiplier; - batch->add(texture, worldVertices, uvs, verticesCount, triangles, trianglesCount, &color); + color.a = _skeleton->a * slot->a * a * 255; + float multiplier = _premultipliedAlpha ? color.a : 255; + color.r = _skeleton->r * slot->r * r * multiplier; + color.g = _skeleton->g * slot->g * g * multiplier; + color.b = _skeleton->b * slot->b * b * multiplier; + _batch->add(texture, _worldVertices, uvs, verticesCount, triangles, trianglesCount, &color); } } - batch->flush(); + _batch->flush(); - if (debugSlots || debugBones) { + if (_debugSlots || _debugBones) { Director* director = Director::getInstance(); director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW); director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW, transform); - if (debugSlots) { + if (_debugSlots) { // Slots. DrawPrimitives::setDrawColor4B(0, 0, 255, 255); glLineWidth(1); Vec2 points[4]; V3F_C4B_T2F_Quad quad; - for (int i = 0, n = skeleton->slotCount; i < n; i++) { - spSlot* slot = skeleton->drawOrder[i]; + for (int i = 0, n = _skeleton->slotCount; i < n; i++) { + spSlot* slot = _skeleton->drawOrder[i]; if (!slot->attachment || slot->attachment->type != SP_ATTACHMENT_REGION) continue; spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment; - spRegionAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot->bone, worldVertices); - points[0] = Vec2(worldVertices[0], worldVertices[1]); - points[1] = Vec2(worldVertices[2], worldVertices[3]); - points[2] = Vec2(worldVertices[4], worldVertices[5]); - points[3] = Vec2(worldVertices[6], worldVertices[7]); + spRegionAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot->bone, _worldVertices); + points[0] = Vec2(_worldVertices[0], _worldVertices[1]); + points[1] = Vec2(_worldVertices[2], _worldVertices[3]); + points[2] = Vec2(_worldVertices[4], _worldVertices[5]); + points[3] = Vec2(_worldVertices[6], _worldVertices[7]); DrawPrimitives::drawPoly(points, 4, true); } } - if (debugBones) { + if (_debugBones) { // Bone lengths. glLineWidth(2); DrawPrimitives::setDrawColor4B(255, 0, 0, 255); - for (int i = 0, n = skeleton->boneCount; i < n; i++) { - spBone *bone = skeleton->bones[i]; + for (int i = 0, n = _skeleton->boneCount; i < n; i++) { + spBone *bone = _skeleton->bones[i]; float x = bone->data->length * bone->m00 + bone->worldX; float y = bone->data->length * bone->m10 + bone->worldY; DrawPrimitives::drawLine(Vec2(bone->worldX, bone->worldY), Vec2(x, y)); @@ -258,8 +257,8 @@ void SkeletonRenderer::drawSkeleton (const Mat4 &transform, bool transformUpdate // Bone origins. DrawPrimitives::setPointSize(4); DrawPrimitives::setDrawColor4B(0, 0, 255, 255); // Root bone is blue. - for (int i = 0, n = skeleton->boneCount; i < n; i++) { - spBone *bone = skeleton->bones[i]; + for (int i = 0, n = _skeleton->boneCount; i < n; i++) { + spBone *bone = _skeleton->bones[i]; DrawPrimitives::drawPoint(Vec2(bone->worldX, bone->worldY)); if (i == 0) DrawPrimitives::setDrawColor4B(0, 255, 0, 255); } @@ -283,26 +282,26 @@ Texture2D* SkeletonRenderer::getTexture (spSkinnedMeshAttachment* attachment) co Rect SkeletonRenderer::getBoundingBox () const { float minX = FLT_MAX, minY = FLT_MAX, maxX = FLT_MIN, maxY = FLT_MIN; float scaleX = getScaleX(), scaleY = getScaleY(); - for (int i = 0; i < skeleton->slotCount; ++i) { - spSlot* slot = skeleton->slots[i]; + for (int i = 0; i < _skeleton->slotCount; ++i) { + spSlot* slot = _skeleton->slots[i]; if (!slot->attachment) continue; int verticesCount; if (slot->attachment->type == SP_ATTACHMENT_REGION) { spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment; - spRegionAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot->bone, worldVertices); + spRegionAttachment_computeWorldVertices(attachment, slot->skeleton->x, slot->skeleton->y, slot->bone, _worldVertices); verticesCount = 8; } else if (slot->attachment->type == SP_ATTACHMENT_MESH) { spMeshAttachment* mesh = (spMeshAttachment*)slot->attachment; - spMeshAttachment_computeWorldVertices(mesh, slot->skeleton->x, slot->skeleton->y, slot, worldVertices); + spMeshAttachment_computeWorldVertices(mesh, slot->skeleton->x, slot->skeleton->y, slot, _worldVertices); verticesCount = mesh->verticesCount; } else if (slot->attachment->type == SP_ATTACHMENT_SKINNED_MESH) { spSkinnedMeshAttachment* mesh = (spSkinnedMeshAttachment*)slot->attachment; - spSkinnedMeshAttachment_computeWorldVertices(mesh, slot->skeleton->x, slot->skeleton->y, slot, worldVertices); + spSkinnedMeshAttachment_computeWorldVertices(mesh, slot->skeleton->x, slot->skeleton->y, slot, _worldVertices); verticesCount = mesh->uvsCount; } else continue; for (int ii = 0; ii < verticesCount; ii += 2) { - float x = worldVertices[ii] * scaleX, y = worldVertices[ii + 1] * scaleY; + float x = _worldVertices[ii] * scaleX, y = _worldVertices[ii + 1] * scaleY; minX = min(minX, x); minY = min(minY, y); maxX = max(maxX, x); @@ -316,54 +315,54 @@ Rect SkeletonRenderer::getBoundingBox () const { // --- Convenience methods for Skeleton_* functions. void SkeletonRenderer::updateWorldTransform () { - spSkeleton_updateWorldTransform(skeleton); + spSkeleton_updateWorldTransform(_skeleton); } void SkeletonRenderer::setToSetupPose () { - spSkeleton_setToSetupPose(skeleton); + spSkeleton_setToSetupPose(_skeleton); } void SkeletonRenderer::setBonesToSetupPose () { - spSkeleton_setBonesToSetupPose(skeleton); + spSkeleton_setBonesToSetupPose(_skeleton); } void SkeletonRenderer::setSlotsToSetupPose () { - spSkeleton_setSlotsToSetupPose(skeleton); + spSkeleton_setSlotsToSetupPose(_skeleton); } -spBone* SkeletonRenderer::findBone (const char* boneName) const { - return spSkeleton_findBone(skeleton, boneName); +spBone* SkeletonRenderer::findBone (const std::string& boneName) const { + return spSkeleton_findBone(_skeleton, boneName.c_str()); } -spSlot* SkeletonRenderer::findSlot (const char* slotName) const { - return spSkeleton_findSlot(skeleton, slotName); +spSlot* SkeletonRenderer::findSlot (const std::string& slotName) const { + return spSkeleton_findSlot(_skeleton, slotName.c_str()); } -bool SkeletonRenderer::setSkin (const char* skinName) { - return spSkeleton_setSkinByName(skeleton, skinName) ? true : false; +bool SkeletonRenderer::setSkin (const std::string& skinName) { + return spSkeleton_setSkinByName(_skeleton, skinName.c_str()) ? true : false; } -spAttachment* SkeletonRenderer::getAttachment (const char* slotName, const char* attachmentName) const { - return spSkeleton_getAttachmentForSlotName(skeleton, slotName, attachmentName); +spAttachment* SkeletonRenderer::getAttachment (const std::string& slotName, const std::string& attachmentName) const { + return spSkeleton_getAttachmentForSlotName(_skeleton, slotName.c_str(), attachmentName.c_str()); } -bool SkeletonRenderer::setAttachment (const char* slotName, const char* attachmentName) { - return spSkeleton_setAttachment(skeleton, slotName, attachmentName) ? true : false; +bool SkeletonRenderer::setAttachment (const std::string& slotName, const std::string& attachmentName) { + return spSkeleton_setAttachment(_skeleton, slotName.c_str(), attachmentName.c_str()) ? true : false; } // --- CCBlendProtocol const BlendFunc& SkeletonRenderer::getBlendFunc () const { - return blendFunc; + return _blendFunc; } void SkeletonRenderer::setBlendFunc (const BlendFunc &blendFunc) { - this->blendFunc = blendFunc; + _blendFunc = blendFunc; } void SkeletonRenderer::setOpacityModifyRGB (bool value) { - premultipliedAlpha = value; + _premultipliedAlpha = value; } -bool SkeletonRenderer::isOpacityModifyRGB () { - return premultipliedAlpha; +bool SkeletonRenderer::isOpacityModifyRGB () const { + return _premultipliedAlpha; } } diff --git a/spine-cocos2dx/3.2/src/spine/SkeletonRenderer.h b/spine-cocos2dx/3.2/src/spine/SkeletonRenderer.h index 3e891cfb1..6bdf2b719 100644 --- a/spine-cocos2dx/3.2/src/spine/SkeletonRenderer.h +++ b/spine-cocos2dx/3.2/src/spine/SkeletonRenderer.h @@ -41,26 +41,13 @@ class PolygonBatch; /** Draws a skeleton. */ class SkeletonRenderer: public cocos2d::Node, public cocos2d::BlendProtocol { public: - spSkeleton* skeleton; - spBone* rootBone; - float timeScale; - bool debugSlots; - bool debugBones; - bool premultipliedAlpha; - static SkeletonRenderer* createWithData (spSkeletonData* skeletonData, bool ownsSkeletonData = false); - static SkeletonRenderer* createWithFile (const char* skeletonDataFile, spAtlas* atlas, float scale = 0); - static SkeletonRenderer* createWithFile (const char* skeletonDataFile, const char* atlasFile, float scale = 0); - - SkeletonRenderer (spSkeletonData* skeletonData, bool ownsSkeletonData = false); - SkeletonRenderer (const char* skeletonDataFile, spAtlas* atlas, float scale = 0); - SkeletonRenderer (const char* skeletonDataFile, const char* atlasFile, float scale = 0); - - virtual ~SkeletonRenderer (); + static SkeletonRenderer* createWithFile (const std::string& skeletonDataFile, spAtlas* atlas, float scale = 0); + static SkeletonRenderer* createWithFile (const std::string& skeletonDataFile, const std::string& atlasFile, float scale = 0); virtual void update (float deltaTime) override; - virtual void draw (cocos2d::Renderer* renderer, const cocos2d::Mat4& transform, bool transformUpdated) override; - virtual void drawSkeleton (const cocos2d::Mat4& transform, bool transformUpdated); + virtual void draw (cocos2d::Renderer* renderer, const cocos2d::Mat4& transform, uint32_t transformFlags) override; + virtual void drawSkeleton (const cocos2d::Mat4& transform, uint32_t transformFlags); virtual cocos2d::Rect getBoundingBox () const override; // --- Convenience methods for common Skeleton_* functions. @@ -71,41 +58,51 @@ public: void setSlotsToSetupPose (); /* Returns 0 if the bone was not found. */ - spBone* findBone (const char* boneName) const; + spBone* findBone (const std::string& boneName) const; /* Returns 0 if the slot was not found. */ - spSlot* findSlot (const char* slotName) const; + spSlot* findSlot (const std::string& slotName) const; /* Sets the skin used to look up attachments not found in the SkeletonData defaultSkin. Attachments from the new skin are * attached if the corresponding attachment from the old skin was attached. Returns false if the skin was not found. * @param skin May be 0.*/ - bool setSkin (const char* skinName); + bool setSkin (const std::string& skinName); /* Returns 0 if the slot or attachment was not found. */ - spAttachment* getAttachment (const char* slotName, const char* attachmentName) const; + spAttachment* getAttachment (const std::string& slotName, const std::string& attachmentName) const; /* Returns false if the slot or attachment was not found. */ - bool setAttachment (const char* slotName, const char* attachmentName); + bool setAttachment (const std::string& slotName, const std::string& attachmentName); // --- BlendProtocol virtual void setBlendFunc (const cocos2d::BlendFunc& blendFunc); virtual const cocos2d::BlendFunc& getBlendFunc () const; virtual void setOpacityModifyRGB (bool value); - virtual bool isOpacityModifyRGB (); + virtual bool isOpacityModifyRGB () const; protected: SkeletonRenderer (); + SkeletonRenderer (spSkeletonData* skeletonData, bool ownsSkeletonData = false); + SkeletonRenderer (const std::string& skeletonDataFile, spAtlas* atlas, float scale = 0); + SkeletonRenderer (const std::string& skeletonDataFile, const std::string& atlasFile, float scale = 0); + virtual ~SkeletonRenderer (); + void initialize (); + void setSkeletonData (spSkeletonData* skeletonData, bool ownsSkeletonData); virtual cocos2d::Texture2D* getTexture (spRegionAttachment* attachment) const; virtual cocos2d::Texture2D* getTexture (spMeshAttachment* attachment) const; virtual cocos2d::Texture2D* getTexture (spSkinnedMeshAttachment* attachment) const; -private: - bool ownsSkeletonData; - spAtlas* atlas; - cocos2d::CustomCommand drawCommand; - cocos2d::BlendFunc blendFunc; - PolygonBatch* batch; - float* worldVertices; - void initialize (); + bool _ownsSkeletonData; + spAtlas* _atlas; + cocos2d::CustomCommand _drawCommand; + cocos2d::BlendFunc _blendFunc; + PolygonBatch* _batch; + float* _worldVertices; + bool _premultipliedAlpha; + spSkeleton* _skeleton; + spBone* _rootBone; + float _timeScale; + bool _debugSlots; + bool _debugBones; }; }