mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
478 lines
18 KiB
C++
478 lines
18 KiB
C++
/******************************************************************************
|
|
* Spine Runtimes License Agreement
|
|
* Last updated May 1, 2019. Replaces all prior versions.
|
|
*
|
|
* Copyright (c) 2013-2019, Esoteric Software LLC
|
|
*
|
|
* Integration of the Spine Runtimes into software or otherwise creating
|
|
* derivative works of the Spine Runtimes is permitted under the terms and
|
|
* conditions of Section 2 of the Spine Editor License Agreement:
|
|
* http://esotericsoftware.com/spine-editor-license
|
|
*
|
|
* Otherwise, it is permitted to integrate the Spine Runtimes into software
|
|
* or otherwise create derivative works of the Spine Runtimes (collectively,
|
|
* "Products"), provided that each user of the Products must obtain their own
|
|
* Spine Editor license and redistribution of the Products in any form must
|
|
* include this license and copyright notice.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
|
|
* NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS
|
|
* INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*****************************************************************************/
|
|
|
|
#include "SkeletonCacheAnimation.h"
|
|
#include "MiddlewareMacro.h"
|
|
#include "SkeletonCacheMgr.h"
|
|
#include "renderer/renderer/Pass.h"
|
|
#include "renderer/renderer/Technique.h"
|
|
#include "renderer/scene/assembler/CustomAssembler.hpp"
|
|
#include "renderer/gfx/Texture.h"
|
|
|
|
USING_NS_CC;
|
|
USING_NS_MW;
|
|
using namespace cocos2d::renderer;
|
|
static const std::string techStage = "opaque";
|
|
static const std::string textureKey = "texture";
|
|
|
|
namespace spine {
|
|
|
|
SkeletonCacheAnimation::SkeletonCacheAnimation (const std::string& uuid, bool isShare) {
|
|
if (isShare) {
|
|
_skeletonCache = SkeletonCacheMgr::getInstance()->buildSkeletonCache(uuid);
|
|
_skeletonCache->retain();
|
|
} else {
|
|
_skeletonCache = new SkeletonCache();
|
|
_skeletonCache->initWithUUID(uuid);
|
|
_skeletonCache->retain();
|
|
_skeletonCache->autorelease();
|
|
}
|
|
beginSchedule();
|
|
}
|
|
|
|
SkeletonCacheAnimation::~SkeletonCacheAnimation () {
|
|
if (_skeletonCache) {
|
|
_skeletonCache->release();
|
|
_skeletonCache = nullptr;
|
|
}
|
|
while (!_animationQueue.empty()) {
|
|
auto ani = _animationQueue.front();
|
|
_animationQueue.pop();
|
|
delete ani;
|
|
}
|
|
CC_SAFE_RELEASE(_nodeProxy);
|
|
CC_SAFE_RELEASE(_effect);
|
|
stopSchedule();
|
|
}
|
|
|
|
void SkeletonCacheAnimation::update(float dt) {
|
|
if (_paused) return;
|
|
|
|
auto gTimeScale = SkeletonAnimation::GlobalTimeScale;
|
|
dt *= _timeScale * gTimeScale;
|
|
|
|
if (_isAniComplete) {
|
|
if (_animationQueue.empty() && !_headAnimation) {
|
|
if (_animationData && !_animationData->isComplete()) {
|
|
_skeletonCache->updateToFrame(_animationName);
|
|
}
|
|
return;
|
|
}
|
|
if (!_headAnimation) {
|
|
_headAnimation = _animationQueue.front();
|
|
_animationQueue.pop();
|
|
}
|
|
if (!_headAnimation) {
|
|
return;
|
|
}
|
|
_accTime += dt;
|
|
if (_accTime > _headAnimation->delay) {
|
|
std::string name = _headAnimation->animationName;
|
|
bool loop = _headAnimation->loop;
|
|
delete _headAnimation;
|
|
_headAnimation = nullptr;
|
|
setAnimation(name, loop);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!_animationData) return;
|
|
|
|
if (_accTime <= 0.00001 && _playCount == 0) {
|
|
if (_startListener) {
|
|
_startListener(_animationName);
|
|
}
|
|
}
|
|
|
|
_accTime += dt;
|
|
int frameIdx = floor(_accTime / SkeletonCache::FrameTime);
|
|
if (!_animationData->isComplete()) {
|
|
_skeletonCache->updateToFrame(_animationName, frameIdx);
|
|
}
|
|
|
|
int finalFrameIndex = (int)_animationData->getFrameCount() - 1;
|
|
if (_animationData->isComplete() && frameIdx >= finalFrameIndex) {
|
|
_playCount++;
|
|
_accTime = 0.0f;
|
|
if (_playTimes > 0 && _playCount >= _playTimes) {
|
|
frameIdx = finalFrameIndex;
|
|
_playCount = 0;
|
|
_isAniComplete = true;
|
|
} else {
|
|
frameIdx = 0;
|
|
}
|
|
if (_endListener) {
|
|
_endListener(_animationName);
|
|
}
|
|
if (_completeListener) {
|
|
_completeListener(_animationName);
|
|
}
|
|
}
|
|
_curFrameIndex = frameIdx;
|
|
}
|
|
|
|
void SkeletonCacheAnimation::render(float dt) {
|
|
|
|
if (_nodeProxy == nullptr) {
|
|
return;
|
|
}
|
|
|
|
CustomAssembler* assembler = (CustomAssembler*)_nodeProxy->getAssembler();
|
|
if (assembler == nullptr) {
|
|
return;
|
|
}
|
|
assembler->reset();
|
|
assembler->setUseModel(!_batch);
|
|
|
|
if (!_animationData) return;
|
|
SkeletonCache::FrameData* frameData = _animationData->getFrameData(_curFrameIndex);
|
|
if (!frameData) return;
|
|
|
|
auto& segments = frameData->getSegments();
|
|
auto& colors = frameData->getColors();
|
|
if (segments.size() == 0 || colors.size() == 0) return;
|
|
|
|
auto mgr = MiddlewareManager::getInstance();
|
|
if (!mgr->isRendering) return;
|
|
|
|
_nodeColor.a = _nodeProxy->getRealOpacity() / (float)255;
|
|
|
|
middleware::MeshBuffer* mb = mgr->getMeshBuffer(VF_XYUVCC);
|
|
middleware::IOBuffer& vb = mb->getVB();
|
|
middleware::IOBuffer& ib = mb->getIB();
|
|
const auto& srcVB = frameData->vb;
|
|
const auto& srcIB = frameData->ib;
|
|
|
|
const cocos2d::Mat4& nodeWorldMat = _nodeProxy->getWorldMatrix();
|
|
|
|
int colorOffset = 0;
|
|
SkeletonCache::ColorData* nowColor = colors[colorOffset++];
|
|
auto maxVFOffset = nowColor->vertexFloatOffset;
|
|
|
|
Color4B finalColor;
|
|
Color4B darkColor;
|
|
float tempR = 0.0f, tempG = 0.0f, tempB = 0.0f, tempA = 0.0f;
|
|
float multiplier = 1.0f;
|
|
int srcVertexBytesOffset = 0;
|
|
int vertexBytes = 0;
|
|
int srcIndexBytesOffset = 0;
|
|
int indexBytes = 0;
|
|
GLuint textureHandle = 0;
|
|
double effectHash = 0;
|
|
int blendMode = 0;
|
|
int dstVertexOffset = 0;
|
|
float* dstVertexBuffer = nullptr;
|
|
unsigned int* dstColorBuffer = nullptr;
|
|
unsigned short* dstIndexBuffer = nullptr;
|
|
bool needColor = false;
|
|
BlendFactor curBlendSrc = BlendFactor::ONE;
|
|
BlendFactor curBlendDst = BlendFactor::ZERO;
|
|
|
|
if (abs(_nodeColor.r - 1.0f) > 0.0001f ||
|
|
abs(_nodeColor.g - 1.0f) > 0.0001f ||
|
|
abs(_nodeColor.b - 1.0f) > 0.0001f ||
|
|
abs(_nodeColor.a - 1.0f) > 0.0001f ||
|
|
_premultipliedAlpha) {
|
|
needColor = true;
|
|
}
|
|
|
|
auto handleColor = [&](SkeletonCache::ColorData* colorData){
|
|
tempA = colorData->finalColor.a * _nodeColor.a;
|
|
multiplier = _premultipliedAlpha ? tempA / 255 : 1;
|
|
tempR = _nodeColor.r * multiplier;
|
|
tempG = _nodeColor.g * multiplier;
|
|
tempB = _nodeColor.b * multiplier;
|
|
|
|
finalColor.a = (GLubyte)tempA;
|
|
finalColor.r = (GLubyte)(colorData->finalColor.r * tempR);
|
|
finalColor.g = (GLubyte)(colorData->finalColor.g * tempG);
|
|
finalColor.b = (GLubyte)(colorData->finalColor.b * tempB);
|
|
|
|
darkColor.r = (GLubyte)(colorData->darkColor.r * tempR);
|
|
darkColor.g = (GLubyte)(colorData->darkColor.g * tempG);
|
|
darkColor.b = (GLubyte)(colorData->darkColor.b * tempB);
|
|
darkColor.a = _premultipliedAlpha ? 255 : 0;
|
|
};
|
|
|
|
handleColor(nowColor);
|
|
|
|
for (std::size_t segIndex = 0, segLen = segments.size(); segIndex < segLen; segIndex++) {
|
|
auto segment = segments[segIndex];
|
|
vertexBytes = segment->vertexFloatCount * sizeof(float);
|
|
|
|
// fill vertex buffer
|
|
vb.checkSpace(vertexBytes, true);
|
|
dstVertexOffset = (int)vb.getCurPos() / sizeof(V2F_T2F_C4B_C4B);
|
|
dstVertexBuffer = (float*)vb.getCurBuffer();
|
|
dstColorBuffer = (unsigned int*)vb.getCurBuffer();
|
|
vb.writeBytes((char*)srcVB.getBuffer() + srcVertexBytesOffset, vertexBytes);
|
|
|
|
// batch handle
|
|
if (_batch) {
|
|
cocos2d::Vec3* point = nullptr;
|
|
float tempZ = 0.0f;
|
|
for (auto posIndex = 0; posIndex < segment->vertexFloatCount; posIndex += 6)
|
|
{
|
|
point = (cocos2d::Vec3*)(dstVertexBuffer + posIndex);
|
|
tempZ = point->z;
|
|
point->z = 0;
|
|
nodeWorldMat.transformPoint(point);
|
|
point->z = tempZ;
|
|
}
|
|
}
|
|
|
|
// handle vertex color
|
|
if (needColor) {
|
|
int frameFloatOffset = srcVertexBytesOffset / sizeof(float);
|
|
for (auto colorIndex = 0; colorIndex < segment->vertexFloatCount; colorIndex += 6, frameFloatOffset += 6)
|
|
{
|
|
if (frameFloatOffset >= maxVFOffset) {
|
|
nowColor = colors[colorOffset++];
|
|
handleColor(nowColor);
|
|
maxVFOffset = nowColor->vertexFloatOffset;
|
|
}
|
|
memcpy(dstColorBuffer + colorIndex + 4, &finalColor, sizeof(finalColor));
|
|
memcpy(dstColorBuffer + colorIndex + 5, &darkColor, sizeof(darkColor));
|
|
}
|
|
}
|
|
|
|
// move src vertex buffer offset
|
|
srcVertexBytesOffset += vertexBytes;
|
|
|
|
// fill index buffer
|
|
indexBytes = segment->indexCount * sizeof(unsigned short);
|
|
ib.checkSpace(indexBytes, true);
|
|
assembler->updateIARange(segIndex, (int)ib.getCurPos() / sizeof(unsigned short), segment->indexCount);
|
|
dstIndexBuffer = (unsigned short*)ib.getCurBuffer();
|
|
ib.writeBytes((char*)srcIB.getBuffer() + srcIndexBytesOffset, indexBytes);
|
|
for (auto indexPos = 0; indexPos < segment->indexCount; indexPos ++) {
|
|
dstIndexBuffer[indexPos] += dstVertexOffset;
|
|
}
|
|
srcIndexBytesOffset += indexBytes;
|
|
|
|
// set assembler glvb and glib
|
|
assembler->updateIABuffer(segIndex, mb->getGLVB(), mb->getGLIB());
|
|
|
|
// handle material
|
|
textureHandle = segment->getTexture()->getNativeTexture()->getHandle();
|
|
blendMode = segment->blendMode;
|
|
effectHash = textureHandle + (blendMode << 16) + (1/*_useTint*/ << 24) + ((int)_batch << 25);
|
|
Effect* renderEffect = assembler->getEffect(segIndex);
|
|
Technique::Parameter* param = nullptr;
|
|
Pass* pass = nullptr;
|
|
|
|
if (renderEffect) {
|
|
double renderHash = renderEffect->getHash();
|
|
if (abs(renderHash - effectHash) >= 0.01) {
|
|
param = (Technique::Parameter*)&(renderEffect->getProperty(textureKey));
|
|
Technique* tech = renderEffect->getTechnique(techStage);
|
|
cocos2d::Vector<Pass*>& passes = (cocos2d::Vector<Pass*>&)tech->getPasses();
|
|
pass = *(passes.begin());
|
|
}
|
|
}
|
|
else {
|
|
if (_effect == nullptr) {
|
|
cocos2d::log("SkeletonCacheAnimation:update get effect failed");
|
|
assembler->reset();
|
|
return;
|
|
}
|
|
auto effect = new cocos2d::renderer::Effect();
|
|
effect->autorelease();
|
|
effect->copy(_effect);
|
|
|
|
Technique* tech = effect->getTechnique(techStage);
|
|
cocos2d::Vector<Pass*>& passes = (cocos2d::Vector<Pass*>&)tech->getPasses();
|
|
pass = *(passes.begin());
|
|
|
|
assembler->updateEffect(segIndex, effect);
|
|
renderEffect = effect;
|
|
param = (Technique::Parameter*)&(renderEffect->getProperty(textureKey));
|
|
}
|
|
|
|
if (param) {
|
|
param->setTexture(segment->getTexture()->getNativeTexture());
|
|
}
|
|
|
|
switch (blendMode) {
|
|
case BlendMode_Additive:
|
|
curBlendSrc = _premultipliedAlpha ? BlendFactor::ONE : BlendFactor::SRC_ALPHA;
|
|
curBlendDst = BlendFactor::ONE;
|
|
break;
|
|
case BlendMode_Multiply:
|
|
curBlendSrc = BlendFactor::DST_COLOR;
|
|
curBlendDst = BlendFactor::ONE_MINUS_SRC_ALPHA;
|
|
break;
|
|
case BlendMode_Screen:
|
|
curBlendSrc = BlendFactor::ONE;
|
|
curBlendDst = BlendFactor::ONE_MINUS_SRC_COLOR;
|
|
break;
|
|
default:
|
|
curBlendSrc = _premultipliedAlpha ? BlendFactor::ONE : BlendFactor::SRC_ALPHA;
|
|
curBlendDst = BlendFactor::ONE_MINUS_SRC_ALPHA;
|
|
}
|
|
|
|
if (pass) {
|
|
pass->setBlend(BlendOp::ADD, curBlendSrc, curBlendDst,
|
|
BlendOp::ADD, curBlendSrc, curBlendDst);
|
|
}
|
|
|
|
renderEffect->updateHash(effectHash);
|
|
}
|
|
}
|
|
|
|
Skeleton* SkeletonCacheAnimation::getSkeleton() const {
|
|
return _skeletonCache->getSkeleton();
|
|
}
|
|
|
|
void SkeletonCacheAnimation::setTimeScale (float scale) {
|
|
_timeScale = scale;
|
|
}
|
|
|
|
float SkeletonCacheAnimation::getTimeScale () const {
|
|
return _timeScale;
|
|
}
|
|
|
|
void SkeletonCacheAnimation::paused (bool value) {
|
|
_paused = value;
|
|
}
|
|
|
|
Bone* SkeletonCacheAnimation::findBone (const std::string& boneName) const {
|
|
return _skeletonCache->findBone(boneName);
|
|
}
|
|
|
|
Slot* SkeletonCacheAnimation::findSlot (const std::string& slotName) const {
|
|
return _skeletonCache->findSlot(slotName);
|
|
}
|
|
|
|
void SkeletonCacheAnimation::setSkin (const std::string& skinName) {
|
|
_skeletonCache->setSkin(skinName);
|
|
_skeletonCache->setToSetupPose();
|
|
_skeletonCache->resetAllAnimationData();
|
|
}
|
|
|
|
void SkeletonCacheAnimation::setSkin (const char* skinName) {
|
|
_skeletonCache->setSkin(skinName);
|
|
_skeletonCache->setToSetupPose();
|
|
_skeletonCache->resetAllAnimationData();
|
|
}
|
|
|
|
Attachment* SkeletonCacheAnimation::getAttachment (const std::string& slotName, const std::string& attachmentName) const {
|
|
return _skeletonCache->getAttachment(slotName, attachmentName);
|
|
}
|
|
|
|
bool SkeletonCacheAnimation::setAttachment (const std::string& slotName, const std::string& attachmentName) {
|
|
auto ret = _skeletonCache->setAttachment(slotName, attachmentName);
|
|
_skeletonCache->resetAllAnimationData();
|
|
return ret;
|
|
}
|
|
|
|
bool SkeletonCacheAnimation::setAttachment (const std::string& slotName, const char* attachmentName) {
|
|
auto ret = _skeletonCache->setAttachment(slotName, attachmentName);
|
|
_skeletonCache->resetAllAnimationData();
|
|
return ret;
|
|
}
|
|
|
|
void SkeletonCacheAnimation::setColor (cocos2d::Color4B& color) {
|
|
_nodeColor.r = color.r / 255.0f;
|
|
_nodeColor.g = color.g / 255.0f;
|
|
_nodeColor.b = color.b / 255.0f;
|
|
_nodeColor.a = color.a / 255.0f;
|
|
}
|
|
|
|
void SkeletonCacheAnimation::setBatchEnabled (bool enabled) {
|
|
_batch = enabled;
|
|
}
|
|
|
|
void SkeletonCacheAnimation::setOpacityModifyRGB (bool value) {
|
|
_premultipliedAlpha = value;
|
|
}
|
|
|
|
bool SkeletonCacheAnimation::isOpacityModifyRGB () const {
|
|
return _premultipliedAlpha;
|
|
}
|
|
|
|
void SkeletonCacheAnimation::beginSchedule() {
|
|
MiddlewareManager::getInstance()->addTimer(this);
|
|
}
|
|
|
|
void SkeletonCacheAnimation::stopSchedule() {
|
|
MiddlewareManager::getInstance()->removeTimer(this);
|
|
}
|
|
|
|
void SkeletonCacheAnimation::onEnable() {
|
|
beginSchedule();
|
|
}
|
|
|
|
void SkeletonCacheAnimation::onDisable() {
|
|
stopSchedule();
|
|
}
|
|
|
|
void SkeletonCacheAnimation::setAnimation (const std::string& name, bool loop) {
|
|
_playTimes = loop ? 0 : 1;
|
|
_animationName = name;
|
|
_animationData = _skeletonCache->buildAnimationData(_animationName);
|
|
_isAniComplete = false;
|
|
_accTime = 0.0f;
|
|
_playCount = 0;
|
|
_curFrameIndex = 0;
|
|
}
|
|
|
|
void SkeletonCacheAnimation::addAnimation (const std::string& name, bool loop, float delay) {
|
|
auto aniInfo = new AniQueueData();
|
|
aniInfo->animationName = name;
|
|
aniInfo->loop = loop;
|
|
aniInfo->delay = delay;
|
|
_animationQueue.push(aniInfo);
|
|
}
|
|
|
|
Animation* SkeletonCacheAnimation::findAnimation(const std::string& name) const {
|
|
return _skeletonCache->findAnimation(name);
|
|
}
|
|
|
|
void SkeletonCacheAnimation::setStartListener (const CacheFrameEvent& listener) {
|
|
_startListener = listener;
|
|
}
|
|
|
|
void SkeletonCacheAnimation::setEndListener (const CacheFrameEvent& listener) {
|
|
_endListener = listener;
|
|
}
|
|
|
|
void SkeletonCacheAnimation::setCompleteListener (const CacheFrameEvent& listener) {
|
|
_completeListener = listener;
|
|
}
|
|
|
|
void SkeletonCacheAnimation::updateAnimationCache (const std::string& animationName) {
|
|
_skeletonCache->resetAnimationData(animationName);
|
|
}
|
|
|
|
void SkeletonCacheAnimation::updateAllAnimationCache () {
|
|
_skeletonCache->resetAllAnimationData();
|
|
}
|
|
}
|