From 7183e3b0bdbf023ad4791c8a68905e133cb2e709 Mon Sep 17 00:00:00 2001 From: sp-stefano-lanza <35223005+sp-stefano-lanza@users.noreply.github.com> Date: Tue, 16 Oct 2018 15:46:49 +0200 Subject: [PATCH] Feature/new skeleton culling (#1196) * Fix culling of skeleton and clean up code * Optionally draw the bounding rectangle of skeletons * Add Visual Studio compiler support * Fix indentation * Fix indentation * Fix indentation * Revert some indentation changes --- .../example/Classes/AppDelegate.cpp | 2 +- .../example/Classes/BatchingExample.cpp | 4 +- .../example/Classes/CoinExample.cpp | 6 +- .../example/Classes/GoblinsExample.cpp | 6 +- .../example/Classes/RaptorExample.cpp | 3 +- .../SkeletonRendererSeparatorExample.cpp | 11 +- .../example/Classes/SpineboyExample.cpp | 6 +- .../example/Classes/TankExample.cpp | 7 +- spine-cocos2dx/src/spine/SkeletonRenderer.cpp | 759 +++++++++++------- spine-cocos2dx/src/spine/SkeletonRenderer.h | 12 +- .../src/spine/SkeletonTwoColorBatch.cpp | 2 +- 11 files changed, 505 insertions(+), 313 deletions(-) diff --git a/spine-cocos2dx/example/Classes/AppDelegate.cpp b/spine-cocos2dx/example/Classes/AppDelegate.cpp index 3cad127b2..4c2222736 100644 --- a/spine-cocos2dx/example/Classes/AppDelegate.cpp +++ b/spine-cocos2dx/example/Classes/AppDelegate.cpp @@ -65,7 +65,7 @@ bool AppDelegate::applicationDidFinishLaunching () { glview->setDesignResolutionSize(designResolutionSize.width, designResolutionSize.height, ResolutionPolicy::NO_BORDER); #endif - Size frameSize = glview->getFrameSize(); + cocos2d::Size frameSize = glview->getFrameSize(); vector searchPath; diff --git a/spine-cocos2dx/example/Classes/BatchingExample.cpp b/spine-cocos2dx/example/Classes/BatchingExample.cpp index 4ba7ac497..4062144f7 100644 --- a/spine-cocos2dx/example/Classes/BatchingExample.cpp +++ b/spine-cocos2dx/example/Classes/BatchingExample.cpp @@ -67,14 +67,14 @@ bool BatchingExample::init () { int xMin = _contentSize.width * 0.10f, xMax = _contentSize.width * 0.90f; int yMin = 0, yMax = _contentSize.height * 0.7f; - for (int i = 0, j = 0; i < NUM_SKELETONS; i++) { + for (int i = 0; i < NUM_SKELETONS; i++) { // Each skeleton node shares the same atlas, skeleton data, and mix times. SkeletonAnimation* skeletonNode = SkeletonAnimation::createWithData(_skeletonData, false); skeletonNode->setAnimationStateData(_stateData); skeletonNode->setAnimation(0, "walk", true); skeletonNode->addAnimation(0, "jump", true, RandomHelper::random_int(0, 300) / 100.0f); - skeletonNode->addAnimation(0, "run", true); + skeletonNode->addAnimation(0, "run", true); // alternative setting two color tint for groups of 10 skeletons // should end up with #skeletons / 10 batches diff --git a/spine-cocos2dx/example/Classes/CoinExample.cpp b/spine-cocos2dx/example/Classes/CoinExample.cpp index 0ec89b805..1a29ea92c 100644 --- a/spine-cocos2dx/example/Classes/CoinExample.cpp +++ b/spine-cocos2dx/example/Classes/CoinExample.cpp @@ -53,8 +53,10 @@ bool CoinExample::init () { EventListenerTouchOneByOne* listener = EventListenerTouchOneByOne::create(); listener->onTouchBegan = [this] (Touch* touch, Event* event) -> bool { - if (!skeletonNode->getDebugBonesEnabled()) - skeletonNode->setDebugBonesEnabled(true); + if (!skeletonNode->getDebugBonesEnabled()) { + skeletonNode->setDebugBonesEnabled(true); + skeletonNode->setDebugBoundingRectEnabled(true); + } else if (skeletonNode->getTimeScale() == 1) skeletonNode->setTimeScale(0.3f); else diff --git a/spine-cocos2dx/example/Classes/GoblinsExample.cpp b/spine-cocos2dx/example/Classes/GoblinsExample.cpp index 47648c007..a5af16b92 100644 --- a/spine-cocos2dx/example/Classes/GoblinsExample.cpp +++ b/spine-cocos2dx/example/Classes/GoblinsExample.cpp @@ -54,8 +54,10 @@ bool GoblinsExample::init () { EventListenerTouchOneByOne* listener = EventListenerTouchOneByOne::create(); listener->onTouchBegan = [this] (Touch* touch, Event* event) -> bool { - if (!skeletonNode->getDebugBonesEnabled()) - skeletonNode->setDebugBonesEnabled(true); + if (!skeletonNode->getDebugBonesEnabled()) { + skeletonNode->setDebugBonesEnabled(true); + skeletonNode->setDebugBoundingRectEnabled(true); + } else if (skeletonNode->getTimeScale() == 1) skeletonNode->setTimeScale(0.3f); else diff --git a/spine-cocos2dx/example/Classes/RaptorExample.cpp b/spine-cocos2dx/example/Classes/RaptorExample.cpp index cfd610a88..d224b5594 100644 --- a/spine-cocos2dx/example/Classes/RaptorExample.cpp +++ b/spine-cocos2dx/example/Classes/RaptorExample.cpp @@ -66,7 +66,8 @@ bool RaptorExample::init () { listener->onTouchBegan = [this] (Touch* touch, Event* event) -> bool { if (!skeletonNode->getDebugBonesEnabled()) { skeletonNode->setDebugBonesEnabled(true); - skeletonNode->setDebugMeshesEnabled(true); + skeletonNode->setDebugMeshesEnabled(true); + skeletonNode->setDebugBoundingRectEnabled(true); } else if (skeletonNode->getTimeScale() == 1) skeletonNode->setTimeScale(0.3f); else diff --git a/spine-cocos2dx/example/Classes/SkeletonRendererSeparatorExample.cpp b/spine-cocos2dx/example/Classes/SkeletonRendererSeparatorExample.cpp index 5ebdfc4eb..99459b36a 100644 --- a/spine-cocos2dx/example/Classes/SkeletonRendererSeparatorExample.cpp +++ b/spine-cocos2dx/example/Classes/SkeletonRendererSeparatorExample.cpp @@ -77,8 +77,15 @@ bool SkeletonRendererSeparatorExample::init () { EventListenerTouchOneByOne* listener = EventListenerTouchOneByOne::create(); listener->onTouchBegan = [this] (Touch* touch, Event* event) -> bool { - if (!backNode->getDebugBonesEnabled()) - backNode->setDebugBonesEnabled(true); + if (!backNode->getDebugBonesEnabled()) + { + backNode->setDebugBonesEnabled(true); + backNode->setDebugSlotsEnabled(true); + backNode->setDebugBoundingRectEnabled(true); + frontNode->setDebugBonesEnabled(true); + frontNode->setDebugSlotsEnabled(true); + frontNode->setDebugBoundingRectEnabled(true); + } else if (backNode->getTimeScale() == 1) backNode->setTimeScale(0.3f); else diff --git a/spine-cocos2dx/example/Classes/SpineboyExample.cpp b/spine-cocos2dx/example/Classes/SpineboyExample.cpp index 3c8966f6a..8993ed8d5 100644 --- a/spine-cocos2dx/example/Classes/SpineboyExample.cpp +++ b/spine-cocos2dx/example/Classes/SpineboyExample.cpp @@ -84,8 +84,10 @@ bool SpineboyExample::init () { EventListenerTouchOneByOne* listener = EventListenerTouchOneByOne::create(); listener->onTouchBegan = [this] (Touch* touch, Event* event) -> bool { - if (!skeletonNode->getDebugBonesEnabled()) - skeletonNode->setDebugBonesEnabled(true); + if (!skeletonNode->getDebugBonesEnabled()) { + skeletonNode->setDebugBonesEnabled(true); + skeletonNode->setDebugBoundingRectEnabled(true); + } else if (skeletonNode->getTimeScale() == 1) skeletonNode->setTimeScale(0.3f); else diff --git a/spine-cocos2dx/example/Classes/TankExample.cpp b/spine-cocos2dx/example/Classes/TankExample.cpp index b6fa26130..c1444fbff 100644 --- a/spine-cocos2dx/example/Classes/TankExample.cpp +++ b/spine-cocos2dx/example/Classes/TankExample.cpp @@ -53,8 +53,11 @@ bool TankExample::init () { EventListenerTouchOneByOne* listener = EventListenerTouchOneByOne::create(); listener->onTouchBegan = [this] (Touch* touch, Event* event) -> bool { - if (!skeletonNode->getDebugBonesEnabled()) - skeletonNode->setDebugBonesEnabled(true); + if (!skeletonNode->getDebugBonesEnabled()) { + skeletonNode->setDebugBonesEnabled(true); + skeletonNode->setDebugSlotsEnabled(true); + skeletonNode->setDebugBoundingRectEnabled(true); + } else if (skeletonNode->getTimeScale() == 1) skeletonNode->setTimeScale(0.3f); else diff --git a/spine-cocos2dx/src/spine/SkeletonRenderer.cpp b/spine-cocos2dx/src/spine/SkeletonRenderer.cpp index d11e572b0..f8ca7353b 100644 --- a/spine-cocos2dx/src/spine/SkeletonRenderer.cpp +++ b/spine-cocos2dx/src/spine/SkeletonRenderer.cpp @@ -36,34 +36,32 @@ #include #include -#define INITIAL_WORLD_VERTICES_LENGTH 1000 -// Used for transforming attachments for bounding boxes & debug rendering -static float* worldVertices = nullptr; -static size_t worldVerticesLength = 0; - -void ensureWorldVerticesCapacity(size_t capacity) { - if (worldVerticesLength < capacity) { - float* newWorldVertices = new float[capacity]; - memcpy(newWorldVertices, worldVertices, capacity * sizeof(float)); - delete[] worldVertices; - worldVertices = newWorldVertices; - worldVerticesLength = capacity; - } -} - USING_NS_CC; -using std::min; -using std::max; + namespace spine { -void SkeletonRenderer::destroyScratchBuffers() { - if (worldVertices) { - delete[] worldVertices; - worldVertices = nullptr; - worldVerticesLength = 0; - } -} + +int computeTotalCoordCount(const spSkeleton& skeleton, int startSlotIndex, int endSlotIndex); +cocos2d::Rect computeBoundingRect(const float* coords, int vertexCount); +void interleaveCoordinates(float* dst, const float* src, int vertexCount, int dstStride); +BlendFunc makeBlendFunc(int blendMode, bool premultipliedAlpha); +void transformWorldVertices(float* dstCoord, int coordCount, const spSkeleton& skeleton, int startSlotIndex, int endSlotIndex); +bool cullRectangle(const Mat4 &transform, const cocos2d::Rect& rect, const Camera& camera); +Color4B spColorToColor4B(const spColor& color); +bool slotIsOutRange(const spSlot& slot, int startSlotIndex, int endSlotIndex); + + +// C Variable length array +#ifdef _MSC_VER + // VLA not supported, use _alloca + #define VLA(type, arr, count) \ + type* arr = static_cast( _alloca(sizeof(type) * count) ) +#else + #define VLA(type, arr, count) \ + type arr[count] +#endif + SkeletonRenderer* SkeletonRenderer::createWithSkeleton(spSkeleton* skeleton, bool ownsSkeleton, bool ownsSkeletonData) { SkeletonRenderer* node = new SkeletonRenderer(skeleton, ownsSkeleton, ownsSkeletonData); @@ -90,11 +88,6 @@ SkeletonRenderer* SkeletonRenderer::createWithFile (const std::string& skeletonD } void SkeletonRenderer::initialize () { - if (!worldVertices) { - worldVertices = new float[INITIAL_WORLD_VERTICES_LENGTH]; - worldVerticesLength = INITIAL_WORLD_VERTICES_LENGTH; - } - _clipper = spSkeletonClipping_create(); _blendFunc = BlendFunc::ALPHA_PREMULTIPLIED; @@ -144,26 +137,26 @@ void SkeletonRenderer::setSkeletonData (spSkeletonData *skeletonData, bool ownsS } SkeletonRenderer::SkeletonRenderer () - : _atlas(nullptr), _attachmentLoader(nullptr), _debugSlots(false), _debugBones(false), _debugMeshes(false), _timeScale(1), _effect(nullptr), _startSlotIndex(-1), _endSlotIndex(-1) { + : _atlas(nullptr), _attachmentLoader(nullptr), _debugSlots(false), _debugBones(false), _debugMeshes(false), _debugBoundingRect(false), _timeScale(1), _effect(nullptr), _startSlotIndex(0), _endSlotIndex(std::numeric_limits::max()) { } SkeletonRenderer::SkeletonRenderer(spSkeleton* skeleton, bool ownsSkeleton, bool ownsSkeletonData) - : _atlas(nullptr), _attachmentLoader(nullptr), _debugSlots(false), _debugBones(false), _debugMeshes(false), _timeScale(1), _effect(nullptr), _startSlotIndex(-1), _endSlotIndex(-1) { + : _atlas(nullptr), _attachmentLoader(nullptr), _debugSlots(false), _debugBones(false), _debugMeshes(false), _debugBoundingRect(false), _timeScale(1), _effect(nullptr), _startSlotIndex(0), _endSlotIndex(std::numeric_limits::max()) { initWithSkeleton(skeleton, ownsSkeleton, ownsSkeletonData); } SkeletonRenderer::SkeletonRenderer (spSkeletonData *skeletonData, bool ownsSkeletonData) - : _atlas(nullptr), _attachmentLoader(nullptr), _debugSlots(false), _debugBones(false), _debugMeshes(false), _timeScale(1), _effect(nullptr), _startSlotIndex(-1), _endSlotIndex(-1) { + : _atlas(nullptr), _attachmentLoader(nullptr), _debugSlots(false), _debugBones(false), _debugMeshes(false), _debugBoundingRect(false), _timeScale(1), _effect(nullptr), _startSlotIndex(0), _endSlotIndex(std::numeric_limits::max()) { initWithData(skeletonData, ownsSkeletonData); } SkeletonRenderer::SkeletonRenderer (const std::string& skeletonDataFile, spAtlas* atlas, float scale) - : _atlas(nullptr), _attachmentLoader(nullptr), _debugSlots(false), _debugBones(false), _debugMeshes(false), _timeScale(1), _effect(nullptr), _startSlotIndex(-1), _endSlotIndex(-1) { + : _atlas(nullptr), _attachmentLoader(nullptr), _debugSlots(false), _debugBones(false), _debugMeshes(false), _debugBoundingRect(false), _timeScale(1), _effect(nullptr), _startSlotIndex(0), _endSlotIndex(std::numeric_limits::max()) { initWithJsonFile(skeletonDataFile, atlas, scale); } SkeletonRenderer::SkeletonRenderer (const std::string& skeletonDataFile, const std::string& atlasFile, float scale) - : _atlas(nullptr), _attachmentLoader(nullptr), _debugSlots(false), _debugBones(false), _debugMeshes(false), _timeScale(1), _effect(nullptr), _startSlotIndex(-1), _endSlotIndex(-1) { + : _atlas(nullptr), _attachmentLoader(nullptr), _debugSlots(false), _debugBones(false), _debugMeshes(false), _debugBoundingRect(false), _timeScale(1), _effect(nullptr), _startSlotIndex(0), _endSlotIndex(std::numeric_limits::max()) { initWithJsonFile(skeletonDataFile, atlasFile, scale); } @@ -262,53 +255,68 @@ void SkeletonRenderer::update (float deltaTime) { } void SkeletonRenderer::draw (Renderer* renderer, const Mat4& transform, uint32_t transformFlags) { - SkeletonBatch* batch = SkeletonBatch::getInstance(); - SkeletonTwoColorBatch* twoColorBatch = SkeletonTwoColorBatch::getInstance(); - bool isTwoColorTint = this->isTwoColorTint(); + assert(_skeleton); // Early exit if the skeleton is invisible if (getDisplayedOpacity() == 0 || _skeleton->color.a == 0){ return; } - if (_effect) _effect->begin(_effect, _skeleton); + const int coordCount = computeTotalCoordCount(*_skeleton, _startSlotIndex, _endSlotIndex); + if (coordCount == 0) + { + return; + } + assert(coordCount % 2 == 0); - Color4F nodeColor; - nodeColor.r = getDisplayedColor().r / (float)255; - nodeColor.g = getDisplayedColor().g / (float)255; - nodeColor.b = getDisplayedColor().b / (float)255; - nodeColor.a = getDisplayedOpacity() / (float)255; + VLA(float, worldCoords, coordCount); + transformWorldVertices(worldCoords, coordCount, *_skeleton, _startSlotIndex, _endSlotIndex); - Color4F color; - Color4F darkColor; - float darkPremultipliedAlpha = _premultipliedAlpha ? 255 : 0; + #if CC_USE_CULLING + const Camera* camera = Camera::getVisitingCamera(); + const cocos2d::Rect brect = computeBoundingRect(worldCoords, coordCount / 2); + _boundingRect = brect; + if (camera && cullRectangle(transform, brect, *camera)) + { + return; + } + #endif + + const float* worldCoordPtr = worldCoords; + SkeletonBatch* batch = SkeletonBatch::getInstance(); + SkeletonTwoColorBatch* twoColorBatch = SkeletonTwoColorBatch::getInstance(); + const bool hasSingleTint = (isTwoColorTint() == false); + + if (_effect) { + _effect->begin(_effect, _skeleton); + } + + const Color3B displayedColor = getDisplayedColor(); + spColor nodeColor; + nodeColor.r = displayedColor.r / 255.f; + nodeColor.g = displayedColor.g / 255.f; + nodeColor.b = displayedColor.b / 255.f; + nodeColor.a = getDisplayedOpacity() / 255.f; + + spColor color; + spColor darkColor; + const float darkPremultipliedAlpha = _premultipliedAlpha ? 1.f : 0; AttachmentVertices* attachmentVertices = nullptr; TwoColorTrianglesCommand* lastTwoColorTrianglesCommand = nullptr; - bool inRange = _startSlotIndex != -1 || _endSlotIndex != -1 ? false : true; for (int i = 0, n = _skeleton->slotsCount; i < n; ++i) { spSlot* slot = _skeleton->drawOrder[i]; - if (_startSlotIndex >= 0 && _startSlotIndex == slot->data->index) { - inRange = true; - } - - if (!inRange) { - spSkeletonClipping_clipEnd(_clipper, slot); - continue; - } - - if (_endSlotIndex >= 0 && _endSlotIndex == slot->data->index) { - inRange = false; - } - if (!slot->attachment) { spSkeletonClipping_clipEnd(_clipper, slot); continue; } + if (slotIsOutRange(*slot, _startSlotIndex, _endSlotIndex)) { + spSkeletonClipping_clipEnd(_clipper, slot); + continue; + } // Early exit if slot is invisible if (slot->color.a == 0) { - spSkeletonClipping_clipEnd(_clipper, slot); continue; } @@ -317,58 +325,66 @@ void SkeletonRenderer::draw (Renderer* renderer, const Mat4& transform, uint32_t switch (slot->attachment->type) { case SP_ATTACHMENT_REGION: { - spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment; - attachmentVertices = getAttachmentVertices(attachment); - + spRegionAttachment* attachment = reinterpret_cast(slot->attachment); // Early exit if attachment is invisible if (attachment->color.a == 0) { spSkeletonClipping_clipEnd(_clipper, slot); continue; } + attachmentVertices = getAttachmentVertices(attachment); - if (!isTwoColorTint) { + float* dstTriangleVertices = nullptr; + int dstStride = 0; // in floats + if (hasSingleTint) { triangles.indices = attachmentVertices->_triangles->indices; triangles.indexCount = attachmentVertices->_triangles->indexCount; triangles.verts = batch->allocateVertices(attachmentVertices->_triangles->vertCount); triangles.vertCount = attachmentVertices->_triangles->vertCount; - memcpy(triangles.verts, attachmentVertices->_triangles->verts, sizeof(cocos2d::V3F_C4B_T2F) * attachmentVertices->_triangles->vertCount); - spRegionAttachment_computeWorldVertices(attachment, slot->bone, (float*)triangles.verts, 0, 6); + assert(triangles.vertCount == 4); + std::memcpy(triangles.verts, attachmentVertices->_triangles->verts, sizeof(cocos2d::V3F_C4B_T2F) * attachmentVertices->_triangles->vertCount); + dstStride = sizeof(V3F_C4B_T2F) / sizeof(float); + dstTriangleVertices = reinterpret_cast(triangles.verts); } else { trianglesTwoColor.indices = attachmentVertices->_triangles->indices; trianglesTwoColor.indexCount = attachmentVertices->_triangles->indexCount; trianglesTwoColor.verts = twoColorBatch->allocateVertices(attachmentVertices->_triangles->vertCount); trianglesTwoColor.vertCount = attachmentVertices->_triangles->vertCount; + assert(trianglesTwoColor.vertCount == 4); for (int i = 0; i < trianglesTwoColor.vertCount; i++) { trianglesTwoColor.verts[i].texCoords = attachmentVertices->_triangles->verts[i].texCoords; } - spRegionAttachment_computeWorldVertices(attachment, slot->bone, (float*)trianglesTwoColor.verts, 0, 7); + dstTriangleVertices = reinterpret_cast(trianglesTwoColor.verts); + dstStride = sizeof(V3F_C4B_C4B_T2F) / sizeof(float); } + // Copy world vertices to triangle vertices + interleaveCoordinates(dstTriangleVertices, worldCoordPtr, 4, dstStride); + worldCoordPtr += 8; - color.r = attachment->color.r; - color.g = attachment->color.g; - color.b = attachment->color.b; - color.a = attachment->color.a; + color = attachment->color; break; } case SP_ATTACHMENT_MESH: { - spMeshAttachment* attachment = (spMeshAttachment*)slot->attachment; - attachmentVertices = getAttachmentVertices(attachment); - + spMeshAttachment* attachment = reinterpret_cast(slot->attachment); // Early exit if attachment is invisible if (attachment->color.a == 0) { spSkeletonClipping_clipEnd(_clipper, slot); continue; } + attachmentVertices = getAttachmentVertices(attachment); - if (!isTwoColorTint) { + float* dstTriangleVertices = nullptr; + int dstStride = 0; // in floats + int dstVertexCount = 0; + if (hasSingleTint) { triangles.indices = attachmentVertices->_triangles->indices; triangles.indexCount = attachmentVertices->_triangles->indexCount; triangles.verts = batch->allocateVertices(attachmentVertices->_triangles->vertCount); triangles.vertCount = attachmentVertices->_triangles->vertCount; - memcpy(triangles.verts, attachmentVertices->_triangles->verts, sizeof(cocos2d::V3F_C4B_T2F) * attachmentVertices->_triangles->vertCount); - int vertexSizeInFloats = sizeof(cocos2d::V3F_C4B_T2F) / sizeof(float); - spVertexAttachment_computeWorldVertices(SUPER(attachment), slot, 0, attachment->super.worldVerticesLength, (float*)triangles.verts, 0, vertexSizeInFloats); + std::memcpy(triangles.verts, attachmentVertices->_triangles->verts, sizeof(cocos2d::V3F_C4B_T2F) * attachmentVertices->_triangles->vertCount); + dstTriangleVertices = (float*)triangles.verts; + dstStride = sizeof(V3F_C4B_T2F) / sizeof(float); + dstVertexCount = triangles.vertCount; } else { trianglesTwoColor.indices = attachmentVertices->_triangles->indices; trianglesTwoColor.indexCount = attachmentVertices->_triangles->indexCount; @@ -377,19 +393,21 @@ void SkeletonRenderer::draw (Renderer* renderer, const Mat4& transform, uint32_t for (int i = 0; i < trianglesTwoColor.vertCount; i++) { trianglesTwoColor.verts[i].texCoords = attachmentVertices->_triangles->verts[i].texCoords; } - int vertexSizeInFloats = sizeof(V3F_C4B_C4B_T2F) / sizeof(float); - spVertexAttachment_computeWorldVertices(SUPER(attachment), slot, 0, attachment->super.worldVerticesLength, (float*)trianglesTwoColor.verts, 0, vertexSizeInFloats); + dstTriangleVertices = (float*)trianglesTwoColor.verts; + dstStride = sizeof(V3F_C4B_C4B_T2F) / sizeof(float); + dstVertexCount = trianglesTwoColor.vertCount; } - color.r = attachment->color.r; - color.g = attachment->color.g; - color.b = attachment->color.b; - color.a = attachment->color.a; + // Copy world vertices to triangle vertices + assert(dstVertexCount * 2 == attachment->super.worldVerticesLength); + interleaveCoordinates(dstTriangleVertices, worldCoordPtr, dstVertexCount, dstStride); + worldCoordPtr += dstVertexCount * 2; + color = attachment->color; break; } case SP_ATTACHMENT_CLIPPING: { - spClippingAttachment* clip = (spClippingAttachment*)slot->attachment; + spClippingAttachment* clip = reinterpret_cast(slot->attachment); spSkeletonClipping_clipStart(_clipper, slot, clip); continue; } @@ -398,54 +416,35 @@ void SkeletonRenderer::draw (Renderer* renderer, const Mat4& transform, uint32_t continue; } - float alpha = nodeColor.a * _skeleton->color.a * slot->color.a * color.a * 255; - // skip rendering if the color of this attachment is 0 - if (alpha == 0){ - spSkeletonClipping_clipEnd(_clipper, slot); - continue; - } - float multiplier = _premultipliedAlpha ? alpha : 255; - - float red = nodeColor.r * _skeleton->color.r * slot->color.r * multiplier; - float green = nodeColor.g * _skeleton->color.g * slot->color.g * multiplier; - float blue = nodeColor.b * _skeleton->color.b * slot->color.b * multiplier; - - color.r = red * color.r; - color.g = green * color.g; - color.b = blue * color.b; - color.a = alpha; - if (slot->darkColor) { - darkColor.r = red * slot->darkColor->r; - darkColor.g = green * slot->darkColor->g; - darkColor.b = blue * slot->darkColor->b; + darkColor = *slot->darkColor; } else { darkColor.r = 0; darkColor.g = 0; darkColor.b = 0; } darkColor.a = darkPremultipliedAlpha; - - BlendFunc blendFunc; - switch (slot->data->blendMode) { - case SP_BLEND_MODE_ADDITIVE: - blendFunc.src = _premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA; - blendFunc.dst = GL_ONE; - break; - case SP_BLEND_MODE_MULTIPLY: - blendFunc.src = GL_DST_COLOR; - blendFunc.dst = GL_ONE_MINUS_SRC_ALPHA; - break; - case SP_BLEND_MODE_SCREEN: - blendFunc.src = GL_ONE; - blendFunc.dst = GL_ONE_MINUS_SRC_COLOR; - break; - default: - blendFunc.src = _premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA; - blendFunc.dst = GL_ONE_MINUS_SRC_ALPHA; + color.a *= nodeColor.a * _skeleton->color.a * slot->color.a; + // skip rendering if the color of this attachment is 0 + if (color.a == 0){ + spSkeletonClipping_clipEnd(_clipper, slot); + continue; + } + color.r *= nodeColor.r * _skeleton->color.r * slot->color.r; + color.g *= nodeColor.g * _skeleton->color.g * slot->color.g; + color.b *= nodeColor.b * _skeleton->color.b * slot->color.b; + if (_premultipliedAlpha) + { + color.r *= color.a; + color.g *= color.a; + color.b *= color.a; } - if (!isTwoColorTint) { + const cocos2d::Color4B color4B = spColorToColor4B(color); + const cocos2d::Color4B darkColor4B = spColorToColor4B(darkColor); + const BlendFunc blendFunc = makeBlendFunc(slot->data->blendMode, _premultipliedAlpha); + + if (hasSingleTint) { if (spSkeletonClipping_isClipping(_clipper)) { spSkeletonClipping_clipTriangles(_clipper, (float*)&triangles.verts[0].vertices, triangles.vertCount * sizeof(cocos2d::V3F_C4B_T2F) / 4, triangles.indices, triangles.indexCount, (float*)&triangles.verts[0].texCoords, 6); batch->deallocateVertices(triangles.vertCount); @@ -458,80 +457,60 @@ void SkeletonRenderer::draw (Renderer* renderer, const Mat4& transform, uint32_t triangles.vertCount = _clipper->clippedVertices->size >> 1; triangles.verts = batch->allocateVertices(triangles.vertCount); triangles.indexCount = _clipper->clippedTriangles->size; - triangles.indices = batch->allocateIndices(triangles.indexCount); - memcpy(triangles.indices, _clipper->clippedTriangles->items, sizeof(unsigned short) * _clipper->clippedTriangles->size); + triangles.indices = + batch->allocateIndices(triangles.indexCount); + std::memcpy(triangles.indices, _clipper->clippedTriangles->items, sizeof(unsigned short) * _clipper->clippedTriangles->size); cocos2d::TrianglesCommand* batchedTriangles = batch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture, _glProgramState, blendFunc, triangles, transform, transformFlags); - float* verts = _clipper->clippedVertices->items; - float* uvs = _clipper->clippedUVs->items; + const float* verts = _clipper->clippedVertices->items; + const float* uvs = _clipper->clippedUVs->items; if (_effect) { - spColor light; - spColor dark; - light.r = color.r / 255.0f; - light.g = color.g / 255.0f; - light.b = color.b / 255.0f; - light.a = color.a / 255.0f; - dark.r = dark.g = dark.b = dark.a = 0; - for (int v = 0, vn = batchedTriangles->getTriangles().vertCount, vv = 0; v < vn; ++v, vv+=2) { - V3F_C4B_T2F* vertex = batchedTriangles->getTriangles().verts + v; - spColor lightCopy = light; - spColor darkCopy = dark; + V3F_C4B_T2F* vertex = batchedTriangles->getTriangles().verts; + spColor darkTmp; + for (int v = 0, vn = batchedTriangles->getTriangles().vertCount, vv = 0; v < vn; ++v, vv+=2, ++vertex) { + spColor lightCopy = color; vertex->vertices.x = verts[vv]; vertex->vertices.y = verts[vv + 1]; vertex->texCoords.u = uvs[vv]; vertex->texCoords.v = uvs[vv + 1]; - _effect->transform(_effect, &vertex->vertices.x, &vertex->vertices.y, &vertex->texCoords.u, &vertex->texCoords.v, &lightCopy, &darkCopy); - vertex->colors.r = (GLubyte)(lightCopy.r * 255); - vertex->colors.g = (GLubyte)(lightCopy.g * 255); - vertex->colors.b = (GLubyte)(lightCopy.b * 255); - vertex->colors.a = (GLubyte)(lightCopy.a * 255); + _effect->transform(_effect, &vertex->vertices.x, &vertex->vertices.y, &vertex->texCoords.u, &vertex->texCoords.v, &lightCopy, &darkTmp); + vertex->colors = spColorToColor4B(lightCopy); } } else { - for (int v = 0, vn = batchedTriangles->getTriangles().vertCount, vv = 0; v < vn; ++v, vv+=2) { - V3F_C4B_T2F* vertex = batchedTriangles->getTriangles().verts + v; + const cocos2d::Color4B color4B = spColorToColor4B(color); + V3F_C4B_T2F* vertex = batchedTriangles->getTriangles().verts; + for (int v = 0, vn = batchedTriangles->getTriangles().vertCount, vv = 0; v < vn; ++v, vv+=2, ++vertex) { vertex->vertices.x = verts[vv]; vertex->vertices.y = verts[vv + 1]; vertex->texCoords.u = uvs[vv]; vertex->texCoords.v = uvs[vv + 1]; - vertex->colors.r = (GLubyte)color.r; - vertex->colors.g = (GLubyte)color.g; - vertex->colors.b = (GLubyte)color.b; - vertex->colors.a = (GLubyte)color.a; + vertex->colors = color4B; } } } else { + // Not clipping + cocos2d::TrianglesCommand* batchedTriangles = batch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture, _glProgramState, blendFunc, triangles, transform, transformFlags); if (_effect) { - spColor light; - spColor dark; - light.r = color.r / 255.0f; - light.g = color.g / 255.0f; - light.b = color.b / 255.0f; - light.a = color.a / 255.0f; - dark.r = dark.g = dark.b = dark.a = 0; - for (int v = 0, vn = batchedTriangles->getTriangles().vertCount; v < vn; ++v) { - V3F_C4B_T2F* vertex = batchedTriangles->getTriangles().verts + v; - spColor lightCopy = light; - spColor darkCopy = dark; - _effect->transform(_effect, &vertex->vertices.x, &vertex->vertices.y, &vertex->texCoords.u, &vertex->texCoords.v, &lightCopy, &darkCopy); - vertex->colors.r = (GLubyte)(lightCopy.r * 255); - vertex->colors.g = (GLubyte)(lightCopy.g * 255); - vertex->colors.b = (GLubyte)(lightCopy.b * 255); - vertex->colors.a = (GLubyte)(lightCopy.a * 255); + V3F_C4B_T2F* vertex = batchedTriangles->getTriangles().verts; + spColor darkTmp; + for (int v = 0, vn = batchedTriangles->getTriangles().vertCount; v < vn; ++v, ++vertex) { + spColor lightCopy = color; + _effect->transform(_effect, &vertex->vertices.x, &vertex->vertices.y, &vertex->texCoords.u, &vertex->texCoords.v, &lightCopy, &darkTmp); + vertex->colors = spColorToColor4B(lightCopy); } } else { - for (int v = 0, vn = batchedTriangles->getTriangles().vertCount; v < vn; ++v) { - V3F_C4B_T2F* vertex = batchedTriangles->getTriangles().verts + v; - vertex->colors.r = (GLubyte)color.r; - vertex->colors.g = (GLubyte)color.g; - vertex->colors.b = (GLubyte)color.b; - vertex->colors.a = (GLubyte)color.a; + V3F_C4B_T2F* vertex = batchedTriangles->getTriangles().verts; + for (int v = 0, vn = batchedTriangles->getTriangles().vertCount; v < vn; ++v, ++vertex) { + vertex->colors = color4B; } } } } else { + // Two tints + if (spSkeletonClipping_isClipping(_clipper)) { spSkeletonClipping_clipTriangles(_clipper, (float*)&trianglesTwoColor.verts[0].position, trianglesTwoColor.vertCount * sizeof(V3F_C4B_C4B_T2F) / 4, trianglesTwoColor.indices, trianglesTwoColor.indexCount, (float*)&trianglesTwoColor.verts[0].texCoords, 7); twoColorBatch->deallocateVertices(trianglesTwoColor.vertCount); @@ -545,99 +524,54 @@ void SkeletonRenderer::draw (Renderer* renderer, const Mat4& transform, uint32_t trianglesTwoColor.verts = twoColorBatch->allocateVertices(trianglesTwoColor.vertCount); trianglesTwoColor.indexCount = _clipper->clippedTriangles->size; trianglesTwoColor.indices = twoColorBatch->allocateIndices(trianglesTwoColor.indexCount); - memcpy(trianglesTwoColor.indices, _clipper->clippedTriangles->items, sizeof(unsigned short) * _clipper->clippedTriangles->size); + std::memcpy(trianglesTwoColor.indices, _clipper->clippedTriangles->items, sizeof(unsigned short) * _clipper->clippedTriangles->size); TwoColorTrianglesCommand* batchedTriangles = lastTwoColorTrianglesCommand = twoColorBatch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture->getName(), _glProgramState, blendFunc, trianglesTwoColor, transform, transformFlags); - float* verts = _clipper->clippedVertices->items; - float* uvs = _clipper->clippedUVs->items; + const float* verts = _clipper->clippedVertices->items; + const float* uvs = _clipper->clippedUVs->items; if (_effect) { - spColor light; - spColor dark; - light.r = color.r / 255.0f; - light.g = color.g / 255.0f; - light.b = color.b / 255.0f; - light.a = color.a / 255.0f; - dark.r = darkColor.r / 255.0f; - dark.g = darkColor.g / 255.0f; - dark.b = darkColor.b / 255.0f; - dark.a = darkColor.a / 255.0f; - for (int v = 0, vn = batchedTriangles->getTriangles().vertCount, vv = 0; v < vn; ++v, vv += 2) { - V3F_C4B_C4B_T2F* vertex = batchedTriangles->getTriangles().verts + v; - spColor lightCopy = light; - spColor darkCopy = dark; + V3F_C4B_C4B_T2F* vertex = batchedTriangles->getTriangles().verts; + for (int v = 0, vn = batchedTriangles->getTriangles().vertCount, vv = 0; v < vn; ++v, vv += 2, ++vertex) { + spColor lightCopy = color; + spColor darkCopy = darkColor; vertex->position.x = verts[vv]; vertex->position.y = verts[vv + 1]; vertex->texCoords.u = uvs[vv]; vertex->texCoords.v = uvs[vv + 1]; _effect->transform(_effect, &vertex->position.x, &vertex->position.y, &vertex->texCoords.u, &vertex->texCoords.v, &lightCopy, &darkCopy); - vertex->color.r = (GLubyte)(lightCopy.r * 255); - vertex->color.g = (GLubyte)(lightCopy.g * 255); - vertex->color.b = (GLubyte)(lightCopy.b * 255); - vertex->color.a = (GLubyte)(lightCopy.a * 255); - vertex->color2.r = (GLubyte)(darkCopy.r * 255); - vertex->color2.g = (GLubyte)(darkCopy.g * 255); - vertex->color2.b = (GLubyte)(darkCopy.b * 255); - vertex->color2.a = (GLubyte)darkColor.a; + vertex->color = spColorToColor4B(lightCopy); + vertex->color2 = spColorToColor4B(darkCopy); } } else { - for (int v = 0, vn = batchedTriangles->getTriangles().vertCount, vv = 0; v < vn; ++v, vv += 2) { - V3F_C4B_C4B_T2F* vertex = batchedTriangles->getTriangles().verts + v; + V3F_C4B_C4B_T2F* vertex = batchedTriangles->getTriangles().verts; + for (int v = 0, vn = batchedTriangles->getTriangles().vertCount, vv = 0; v < vn; ++v, vv += 2, ++vertex) { vertex->position.x = verts[vv]; vertex->position.y = verts[vv + 1]; vertex->texCoords.u = uvs[vv]; vertex->texCoords.v = uvs[vv + 1]; - vertex->color.r = (GLubyte)color.r; - vertex->color.g = (GLubyte)color.g; - vertex->color.b = (GLubyte)color.b; - vertex->color.a = (GLubyte)color.a; - vertex->color2.r = (GLubyte)darkColor.r; - vertex->color2.g = (GLubyte)darkColor.g; - vertex->color2.b = (GLubyte)darkColor.b; - vertex->color2.a = (GLubyte)darkColor.a; + vertex->color = color4B; + vertex->color2 = darkColor4B; } } } else { TwoColorTrianglesCommand* batchedTriangles = lastTwoColorTrianglesCommand = twoColorBatch->addCommand(renderer, _globalZOrder, attachmentVertices->_texture->getName(), _glProgramState, blendFunc, trianglesTwoColor, transform, transformFlags); if (_effect) { - spColor light; - spColor dark; - light.r = color.r / 255.0f; - light.g = color.g / 255.0f; - light.b = color.b / 255.0f; - light.a = color.a / 255.0f; - dark.r = darkColor.r / 255.0f; - dark.g = darkColor.g / 255.0f; - dark.b = darkColor.b / 255.0f; - dark.a = darkColor.a / 255.0f; - - for (int v = 0, vn = batchedTriangles->getTriangles().vertCount; v < vn; ++v) { - V3F_C4B_C4B_T2F* vertex = batchedTriangles->getTriangles().verts + v; - spColor lightCopy = light; - spColor darkCopy = dark; + V3F_C4B_C4B_T2F* vertex = batchedTriangles->getTriangles().verts; + for (int v = 0, vn = batchedTriangles->getTriangles().vertCount; v < vn; ++v, ++vertex) { + spColor lightCopy = color; + spColor darkCopy = darkColor; _effect->transform(_effect, &vertex->position.x, &vertex->position.y, &vertex->texCoords.u, &vertex->texCoords.v, &lightCopy, &darkCopy); - vertex->color.r = (GLubyte)(lightCopy.r * 255); - vertex->color.g = (GLubyte)(lightCopy.g * 255); - vertex->color.b = (GLubyte)(lightCopy.b * 255); - vertex->color.a = (GLubyte)(lightCopy.a * 255); - vertex->color2.r = (GLubyte)(darkCopy.r * 255); - vertex->color2.g = (GLubyte)(darkCopy.g * 255); - vertex->color2.b = (GLubyte)(darkCopy.b * 255); - vertex->color2.a = (GLubyte)darkColor.a; + vertex->color = spColorToColor4B(lightCopy); + vertex->color2 = spColorToColor4B(darkCopy); } } else { - for (int v = 0, vn = batchedTriangles->getTriangles().vertCount; v < vn; ++v) { - V3F_C4B_C4B_T2F* vertex = batchedTriangles->getTriangles().verts + v; - vertex->color.r = (GLubyte)color.r; - vertex->color.g = (GLubyte)color.g; - vertex->color.b = (GLubyte)color.b; - vertex->color.a = (GLubyte)color.a; - vertex->color2.r = (GLubyte)darkColor.r; - vertex->color2.g = (GLubyte)darkColor.g; - vertex->color2.b = (GLubyte)darkColor.b; - vertex->color2.a = (GLubyte)darkColor.a; + V3F_C4B_C4B_T2F* vertex = batchedTriangles->getTriangles().verts; + for (int v = 0, vn = batchedTriangles->getTriangles().vertCount; v < vn; ++v, ++vertex) { + vertex->color = color4B; + vertex->color2 = darkColor4B; } } } @@ -683,10 +617,12 @@ void SkeletonRenderer::draw (Renderer* renderer, const Mat4& transform, uint32_t } } - if (_effect) _effect->end(_effect); + if (_effect) { + _effect->end(_effect); + } - if (_debugSlots || _debugBones || _debugMeshes) { - drawDebug(renderer, transform, transformFlags); + if (_debugBoundingRect || _debugSlots || _debugBones || _debugMeshes) { + drawDebug(renderer, transform, transformFlags); } } @@ -698,29 +634,52 @@ void SkeletonRenderer::drawDebug (Renderer* renderer, const Mat4 &transform, uin DrawNode* drawNode = DrawNode::create(); + // Draw bounding rectangle + if (_debugBoundingRect) { + glLineWidth(2); + const cocos2d::Rect brect = getBoundingBox(); + const Vec2 points[4] = + { + brect.origin, + { brect.origin.x + brect.size.width, brect.origin.y }, + { brect.origin.x + brect.size.width, brect.origin.y + brect.size.height }, + { brect.origin.x, brect.origin.y + brect.size.height } + }; + drawNode->drawPoly(points, 4, true, Color4F::GREEN); + } + 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->slotsCount; i < n; i++) { spSlot* slot = _skeleton->drawOrder[i]; - if (!slot->attachment || slot->attachment->type != SP_ATTACHMENT_REGION) continue; + if (!slot->attachment || slot->attachment->type != SP_ATTACHMENT_REGION) { + continue; + } + if (slotIsOutRange(*slot, _startSlotIndex, _endSlotIndex)) { + continue; + } spRegionAttachment* attachment = (spRegionAttachment*)slot->attachment; + float worldVertices[8]; spRegionAttachment_computeWorldVertices(attachment, slot->bone, worldVertices, 0, 2); - 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]); + const Vec2 points[4] = + { + { worldVertices[0], worldVertices[1] }, + { worldVertices[2], worldVertices[3] }, + { worldVertices[4], worldVertices[5] }, + { worldVertices[6], worldVertices[7] } + }; drawNode->drawPoly(points, 4, true, Color4F::BLUE); } } + if (_debugBones) { // Bone lengths. glLineWidth(2); for (int i = 0, n = _skeleton->bonesCount; i < n; i++) { - spBone *bone = _skeleton->bones[i]; + const spBone *bone = _skeleton->bones[i]; float x = bone->data->length * bone->a + bone->worldX; float y = bone->data->length * bone->c + bone->worldY; drawNode->drawLine(Vec2(bone->worldX, bone->worldY), Vec2(x, y), Color4F::RED); @@ -728,7 +687,7 @@ void SkeletonRenderer::drawDebug (Renderer* renderer, const Mat4 &transform, uin // Bone origins. auto color = Color4F::BLUE; // Root bone is blue. for (int i = 0, n = _skeleton->bonesCount; i < n; i++) { - spBone *bone = _skeleton->bones[i]; + const spBone *bone = _skeleton->bones[i]; drawNode->drawPoint(Vec2(bone->worldX, bone->worldY), 4, color); if (i == 0) color = Color4F::GREEN; } @@ -741,15 +700,20 @@ void SkeletonRenderer::drawDebug (Renderer* renderer, const Mat4 &transform, uin spSlot* slot = _skeleton->drawOrder[i]; if (!slot->attachment || slot->attachment->type != SP_ATTACHMENT_MESH) continue; spMeshAttachment* attachment = (spMeshAttachment*)slot->attachment; - ensureWorldVerticesCapacity(attachment->super.worldVerticesLength); - spVertexAttachment_computeWorldVertices(SUPER(attachment), slot, 0, attachment->super.worldVerticesLength, worldVertices, 0, 2); - for (int ii = 0; ii < attachment->trianglesCount;) { - Vec2 v1(worldVertices + (attachment->triangles[ii++] * 2)); - Vec2 v2(worldVertices + (attachment->triangles[ii++] * 2)); - Vec2 v3(worldVertices + (attachment->triangles[ii++] * 2)); - drawNode->drawLine(v1, v2, Color4F::YELLOW); - drawNode->drawLine(v2, v3, Color4F::YELLOW); - drawNode->drawLine(v3, v1, Color4F::YELLOW); + VLA(float, worldCoord, attachment->super.worldVerticesLength); + spVertexAttachment_computeWorldVertices(SUPER(attachment), slot, 0, attachment->super.worldVerticesLength, worldCoord, 0, 2); + for (int t = 0; t < attachment->trianglesCount; t += 3) { + // Fetch triangle indices + const int idx0 = attachment->triangles[t + 0]; + const int idx1 = attachment->triangles[t + 1]; + const int idx2 = attachment->triangles[t + 2]; + const Vec2 v[3] = + { + worldCoord + (idx0 * 2), + worldCoord + (idx1 * 2), + worldCoord + (idx2 * 2) + }; + drawNode->drawPoly(v, 3, true, Color4F::YELLOW); } } @@ -767,35 +731,8 @@ AttachmentVertices* SkeletonRenderer::getAttachmentVertices (spMeshAttachment* a return (AttachmentVertices*)attachment->rendererObject; } -Rect SkeletonRenderer::getBoundingBox () const { - float minX = FLT_MAX, minY = FLT_MAX, maxX = -FLT_MAX, maxY = -FLT_MAX; - float scaleX = getScaleX(), scaleY = getScaleY(); - for (int i = 0; i < _skeleton->slotsCount; ++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->bone, worldVertices, 0, 2); - verticesCount = 8; - } else if (slot->attachment->type == SP_ATTACHMENT_MESH) { - spMeshAttachment* mesh = (spMeshAttachment*)slot->attachment; - ensureWorldVerticesCapacity(mesh->super.worldVerticesLength); - spVertexAttachment_computeWorldVertices(SUPER(mesh), slot, 0, mesh->super.worldVerticesLength, worldVertices, 0, 2); - verticesCount = mesh->super.worldVerticesLength; - } else - continue; - for (int ii = 0; ii < verticesCount; ii += 2) { - float x = worldVertices[ii] * scaleX, y = worldVertices[ii + 1] * scaleY; - minX = min(minX, x); - minY = min(minY, y); - maxX = max(maxX, x); - maxY = max(maxY, y); - } - } - Vec2 position = getPosition(); - if (minX == FLT_MAX) minX = minY = maxX = maxY = 0; - return Rect(position.x + minX, position.y + minY, maxX - minX, maxY - minY); +cocos2d::Rect SkeletonRenderer::getBoundingBox () const { + return _boundingRect; } // --- Convenience methods for Skeleton_* functions. @@ -852,11 +789,11 @@ void SkeletonRenderer::setVertexEffect(spVertexEffect *effect) { } void SkeletonRenderer::setSlotsRange(int startSlotIndex, int endSlotIndex) { - this->_startSlotIndex = startSlotIndex; - this->_endSlotIndex = endSlotIndex; + _startSlotIndex = startSlotIndex == -1 ? 0 : startSlotIndex; + _endSlotIndex = endSlotIndex == -1 ? std::numeric_limits::max() : endSlotIndex; } -spSkeleton* SkeletonRenderer::getSkeleton () { +spSkeleton* SkeletonRenderer::getSkeleton () const { return _skeleton; } @@ -888,6 +825,14 @@ bool SkeletonRenderer::getDebugMeshesEnabled () const { return _debugMeshes; } +void SkeletonRenderer::setDebugBoundingRectEnabled(bool enabled) { + _debugBoundingRect = enabled; +} + +bool SkeletonRenderer::getDebugBoundingRectEnabled() const { + return _debugBoundingRect; +} + void SkeletonRenderer::onEnter () { #if CC_ENABLE_SCRIPT_BINDING if (_scriptType == kScriptTypeJavascript && ScriptEngineManager::sendNodeEventToJSExtended(this, kNodeOnEnter)) return; @@ -922,4 +867,232 @@ bool SkeletonRenderer::isOpacityModifyRGB () const { return _premultipliedAlpha; } + + cocos2d::Rect computeBoundingRect(const float* coords, int vertexCount) + { + assert(coords); + assert(vertexCount > 0); + + const float* v = coords; + float minX = v[0]; + float minY = v[1]; + float maxX = minX; + float maxY = minY; + for (int i = 1; i < vertexCount; ++i) + { + v += 2; + float x = v[0]; + float y = v[1]; + minX = std::min(minX, x); + minY = std::min(minY, y); + maxX = std::max(maxX, x); + maxY = std::max(maxY, y); + } + return { minX, minY, maxX - minX, maxY - minY }; + } + + bool slotIsOutRange(const spSlot& slot, int startSlotIndex, int endSlotIndex) + { + return startSlotIndex > slot.data->index || endSlotIndex < slot.data->index; + } + + int computeTotalCoordCount(const spSkeleton& skeleton, int startSlotIndex, int endSlotIndex) + { + int coordCount = 0; + for (int i = 0; i < skeleton.slotsCount; ++i) + { + const spSlot& slot = *skeleton.slots[i]; + if (!slot.attachment) + { + continue; + } + if (slotIsOutRange(slot, startSlotIndex, endSlotIndex)) + { + continue; + } + // Early exit if slot is invisible + if (slot.color.a == 0) { + continue; + } + if (slot.attachment->type == SP_ATTACHMENT_REGION) + { + // Early exit if attachment is invisible + spRegionAttachment* attachment = reinterpret_cast(slot.attachment); + if (attachment->color.a == 0) { + continue; + } + coordCount += 8; + } + else if (slot.attachment->type == SP_ATTACHMENT_MESH) + { + const spMeshAttachment* mesh = reinterpret_cast(slot.attachment); + // Early exit if attachment is invisible + if (mesh->color.a == 0) { + continue; + } + coordCount += mesh->super.worldVerticesLength; + } + } + return coordCount; + } + + + void transformWorldVertices(float* dstCoord, int coordCount, const spSkeleton& skeleton, int startSlotIndex, int endSlotIndex) + { + float* dstPtr = dstCoord; +#ifndef NDEBUG + float* const dstEnd = dstCoord + coordCount; +#endif + for (int i = 0; i < skeleton.slotsCount; ++i) + { + /*const*/ spSlot& slot = *skeleton.drawOrder[i]; // match the draw order of SkeletonRenderer::Draw + if (!slot.attachment) + { + continue; + } + if (slotIsOutRange(slot, startSlotIndex, endSlotIndex)) + { + continue; + } + // Early exit if slot is invisible + if (slot.color.a == 0) { + continue; + } + if (slot.attachment->type == SP_ATTACHMENT_REGION) + { + spRegionAttachment* attachment = reinterpret_cast(slot.attachment); + // Early exit if attachment is invisible + if (attachment->color.a == 0) { + continue; + } + assert(dstPtr + 8 <= dstEnd); + spRegionAttachment_computeWorldVertices(attachment, slot.bone, dstPtr, 0, 2); + dstPtr += 8; + } + else if (slot.attachment->type == SP_ATTACHMENT_MESH) + { + spMeshAttachment* mesh = reinterpret_cast(slot.attachment); + // Early exit if attachment is invisible + if (mesh->color.a == 0) { + continue; + } + assert(dstPtr + mesh->super.worldVerticesLength <= dstEnd); + spVertexAttachment_computeWorldVertices(SUPER(mesh), &slot, 0, mesh->super.worldVerticesLength, dstPtr, 0, 2); + dstPtr += mesh->super.worldVerticesLength; + } + } + assert(dstPtr == dstEnd); + } + + void interleaveCoordinates(float* __restrict dst, const float* __restrict src, int count, int dstStride) + { + if (dstStride == 2) + { + std::memcpy(dst, src, sizeof(float) * count * 2); + } + else + { + for (int i = 0; i < count; ++i) + { + dst[0] = src[0]; + dst[1] = src[1]; + dst += dstStride; + src += 2; + } + } + + } + + BlendFunc makeBlendFunc(int blendMode, bool premultipliedAlpha) + { + BlendFunc blendFunc; + switch (blendMode) { + case SP_BLEND_MODE_ADDITIVE: + blendFunc.src = premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA; + blendFunc.dst = GL_ONE; + break; + case SP_BLEND_MODE_MULTIPLY: + blendFunc.src = GL_DST_COLOR; + blendFunc.dst = GL_ONE_MINUS_SRC_ALPHA; + break; + case SP_BLEND_MODE_SCREEN: + blendFunc.src = GL_ONE; + blendFunc.dst = GL_ONE_MINUS_SRC_COLOR; + break; + default: + blendFunc.src = premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA; + blendFunc.dst = GL_ONE_MINUS_SRC_ALPHA; + break; + } + return blendFunc; + } + + + bool cullRectangle(const Mat4 &transform, const cocos2d::Rect& rect, const Camera& camera) + { + // Compute rectangle center and half extents in local space + // TODO: Pass the bounding rectangle with this representation directly + const float halfRectWidth = rect.size.width * 0.5f; + const float halfRectHeight = rect.size.height * 0.5f; + const float l_cx = rect.origin.x + halfRectWidth; + const float l_cy = rect.origin.y + halfRectHeight; + + // Transform rectangle center to world space + const float w_cx = (l_cx * transform.m[0] + l_cy * transform.m[4]) + transform.m[12]; + const float w_cy = (l_cx * transform.m[1] + l_cy * transform.m[5]) + transform.m[13]; + + // Compute rectangle half extents in world space + const float w_ex = std::abs(halfRectWidth * transform.m[0]) + std::abs(halfRectHeight * transform.m[4]); + const float w_ey = std::abs(halfRectWidth * transform.m[1]) + std::abs(halfRectHeight * transform.m[5]); + + // Transform rectangle to clip space + const Mat4& viewMatrix = camera.getViewMatrix(); + const Mat4& projectionMatrix = camera.getProjectionMatrix(); + const float c_cx = (w_cx + viewMatrix.m[12]) * projectionMatrix.m[0]; + const float c_cy = (w_cy + viewMatrix.m[13]) * projectionMatrix.m[5]; + const float c_ex = w_ex * projectionMatrix.m[0]; + const float c_ey = w_ey * projectionMatrix.m[5]; + // The rectangle has z == 0 in world space + // cw = projectionMatrix[11] * vz = -vz = wz -viewMatrix.m[14] = -viewMatrix.m[14] + const float c_w = -viewMatrix.m[14]; // w in clip space + + // For each edge, test the rectangle corner closest to it + // If its distance to the edge is negative, the whole rectangle is outside the screen + // Note: the test is conservative and can return false positives in some cases + // The test is done in clip space [-1, +1] + // e.g. left culling <==> (c_cx + c_ex) / cw < -1 <==> (c_cx + c_ex) < -cw + + // Left + if (c_cx + c_ex < -c_w) + { + return true; + } + + // Right + if (c_cx - c_ex > c_w) + { + return true; + } + + // Bottom + if (c_cy + c_ey < -c_w) + { + return true; + } + + // Top + if (c_cy - c_ey > c_w) + { + return true; + } + + return false; + } + + + Color4B spColorToColor4B(const spColor& color) + { + return { (GLubyte)(color.r * 255.f), (GLubyte)(color.g * 255.f), (GLubyte)(color.b * 255.f), (GLubyte)(color.a * 255.f) }; + } + } diff --git a/spine-cocos2dx/src/spine/SkeletonRenderer.h b/spine-cocos2dx/src/spine/SkeletonRenderer.h index 3f41e4a5d..f261daceb 100644 --- a/spine-cocos2dx/src/spine/SkeletonRenderer.h +++ b/spine-cocos2dx/src/spine/SkeletonRenderer.h @@ -49,12 +49,11 @@ public: virtual void update (float deltaTime) override; virtual void draw (cocos2d::Renderer* renderer, const cocos2d::Mat4& transform, uint32_t transformFlags) override; - virtual void drawDebug (cocos2d::Renderer* renderer, const cocos2d::Mat4& transform, uint32_t transformFlags); virtual cocos2d::Rect getBoundingBox () const override; virtual void onEnter () override; virtual void onExit () override; - spSkeleton* getSkeleton(); + spSkeleton* getSkeleton() const; void setTimeScale(float scale); float getTimeScale() const; @@ -68,6 +67,9 @@ public: void setDebugMeshesEnabled(bool enabled); bool getDebugMeshesEnabled() const; + + void setDebugBoundingRectEnabled(bool enabled); + bool getDebugBoundingRectEnabled() const; // --- Convenience methods for common Skeleton_* functions. void updateWorldTransform (); @@ -113,9 +115,6 @@ public: virtual void setOpacityModifyRGB (bool value) override; virtual bool isOpacityModifyRGB () const override; - // Frees global memory used for temporay vertex transformations. - static void destroyScratchBuffers(); - CC_CONSTRUCTOR_ACCESS: SkeletonRenderer (); SkeletonRenderer(spSkeleton* skeleton, bool ownsSkeleton = false, bool ownsSkeletonData = false); @@ -139,6 +138,7 @@ protected: virtual AttachmentVertices* getAttachmentVertices (spRegionAttachment* attachment) const; virtual AttachmentVertices* getAttachmentVertices (spMeshAttachment* attachment) const; void setupGLProgramState(bool twoColorTintEnabled); + virtual void drawDebug (cocos2d::Renderer* renderer, const cocos2d::Mat4& transform, uint32_t transformFlags); bool _ownsSkeletonData; bool _ownsSkeleton; @@ -152,8 +152,10 @@ protected: bool _debugSlots; bool _debugBones; bool _debugMeshes; + bool _debugBoundingRect; spSkeletonClipping* _clipper; spVertexEffect* _effect; + cocos2d::Rect _boundingRect; int _startSlotIndex; int _endSlotIndex; diff --git a/spine-cocos2dx/src/spine/SkeletonTwoColorBatch.cpp b/spine-cocos2dx/src/spine/SkeletonTwoColorBatch.cpp index 41b323494..99b45ed84 100644 --- a/spine-cocos2dx/src/spine/SkeletonTwoColorBatch.cpp +++ b/spine-cocos2dx/src/spine/SkeletonTwoColorBatch.cpp @@ -57,7 +57,7 @@ void TwoColorTrianglesCommand::init(float globalOrder, GLuint textureID, GLProgr if(_triangles.indexCount % 3 != 0) { int count = _triangles.indexCount; _triangles.indexCount = count / 3 * 3; - CCLOGERROR("Resize indexCount from %zd to %zd, size must be multiple times of 3", count, _triangles.indexCount); + CCLOGERROR("Resize indexCount from %d to %d, size must be multiple times of 3", count, _triangles.indexCount); } _mv = mv;