axmol/extensions/DragonBones/armature/Slot.cpp

#include "Slot.h"
#include "../model/DragonBonesData.h"
#include "../model/UserData.h"
#include "../model/SkinData.h"
#include "../model/DisplayData.h"
#include "../model/BoundingBoxData.h"
#include "../model/TextureAtlasData.h"
#include "Armature.h"
#include "Bone.h"
#include "DeformVertices.h"
#include "../animation/Animation.h"
#include "../event/EventObject.h"

DRAGONBONES_NAMESPACE_BEGIN

void Slot::_onClear()
{
    TransformObject::_onClear();

    std::vector<std::pair<void*, DisplayType>> disposeDisplayList;
    for (const auto& pair : this->_displayList)
    {
        if (pair.first != nullptr && pair.first != _rawDisplay && pair.first != _meshDisplay &&
            std::find(disposeDisplayList.cbegin(), disposeDisplayList.cend(), pair) == disposeDisplayList.cend())
        {
            disposeDisplayList.push_back(pair);
        }
    }

    for (const auto& pair : disposeDisplayList)
    {
        if (pair.second == DisplayType::Armature)
        {
            static_cast<Armature*>(pair.first)->returnToPool();
        }
        else
        {
            _disposeDisplay(pair.first, true);
        }
    }

    if (_deformVertices != nullptr)
    {
        _deformVertices->returnToPool();
    }

    if (_meshDisplay && _meshDisplay != _rawDisplay)
    {
        _disposeDisplay(_meshDisplay, false);
    }

    if (_rawDisplay)
    {
        _disposeDisplay(_rawDisplay, false);
    }

    displayController = "";

    _displayDirty          = false;
    _zOrderDirty           = false;
    _blendModeDirty        = false;
    _colorDirty            = false;
    _transformDirty        = false;
    _visible               = true;
    _blendMode             = BlendMode::Normal;
    _displayIndex          = -1;
    _animationDisplayIndex = -1;
    _zOrder                = 0;
    _cachedFrameIndex      = -1;
    _pivotX                = 0.0f;
    _pivotY                = 0.0f;
    _localMatrix.identity();
    _colorTransform.identity();
    _displayList.clear();
    _displayDatas.clear();
    _slotData           = nullptr;
    _rawDisplayDatas    = nullptr;  //
    _displayData        = nullptr;
    _boundingBoxData    = nullptr;
    _textureData        = nullptr;
    _deformVertices     = nullptr;
    _rawDisplay         = nullptr;
    _meshDisplay        = nullptr;
    _display            = nullptr;
    _childArmature      = nullptr;
    _parent             = nullptr;
    _cachedFrameIndices = nullptr;
}

DisplayData* Slot::_getDefaultRawDisplayData(unsigned displayIndex) const
{
    const auto defaultSkin = _armature->_armatureData->defaultSkin;
    if (defaultSkin != nullptr)
    {
        const auto defaultRawDisplayDatas = defaultSkin->getDisplays(_slotData->name);
        if (defaultRawDisplayDatas != nullptr)
        {
            return displayIndex < defaultRawDisplayDatas->size() ? (*defaultRawDisplayDatas)[displayIndex] : nullptr;
        }
    }

    return nullptr;
}

void Slot::_updateDisplayData()
{
    const auto prevDisplayData  = _displayData;
    const auto prevVerticesData = _deformVertices != nullptr ? _deformVertices->verticesData : nullptr;
    const auto prevTextureData  = _textureData;

    DisplayData* rawDisplayData       = nullptr;
    VerticesData* currentVerticesData = nullptr;

    _displayData     = nullptr;
    _boundingBoxData = nullptr;
    _textureData     = nullptr;

    if (_displayIndex >= 0)
    {
        if (_rawDisplayDatas != nullptr)
        {
            rawDisplayData =
                (unsigned)_displayIndex < _rawDisplayDatas->size() ? (*_rawDisplayDatas)[_displayIndex] : nullptr;
        }

        if (rawDisplayData == nullptr)
        {
            rawDisplayData = _getDefaultRawDisplayData(_displayIndex);
        }

        if ((unsigned)_displayIndex < _displayDatas.size())
        {
            _displayData = _displayDatas[_displayIndex];
        }
    }

    // Update texture and mesh data.
    if (_displayData != nullptr)
    {
        if (_displayData->type == DisplayType::Mesh)
        {
            currentVerticesData = &static_cast<MeshDisplayData*>(_displayData)->vertices;
        }
        else if (_displayData->type == DisplayType::Path)
        {
            // TODO
        }
        else if (rawDisplayData != nullptr)
        {
            if (rawDisplayData->type == DisplayType::Mesh)
            {
                currentVerticesData = &static_cast<MeshDisplayData*>(rawDisplayData)->vertices;
            }
            else if (rawDisplayData->type == DisplayType::Path)
            {
                // TODO
            }
        }

        if (_displayData->type == DisplayType::BoundingBox)
        {
            _boundingBoxData = static_cast<BoundingBoxDisplayData*>(_displayData)->boundingBox;
        }
        else if (rawDisplayData != nullptr)
        {
            if (rawDisplayData->type == DisplayType::BoundingBox)
            {
                _boundingBoxData = static_cast<BoundingBoxDisplayData*>(rawDisplayData)->boundingBox;
            }
        }

        if (_displayData->type == DisplayType::Image)
        {
            _textureData = static_cast<ImageDisplayData*>(_displayData)->texture;
        }
        else if (_displayData->type == DisplayType::Mesh)
        {
            _textureData = static_cast<MeshDisplayData*>(_displayData)->texture;
        }
    }

    // Update bounding box data.
    if (_displayData != nullptr && _displayData->type == DisplayType::BoundingBox)
    {
        _boundingBoxData = static_cast<BoundingBoxDisplayData*>(_displayData)->boundingBox;
    }
    else if (rawDisplayData != nullptr && rawDisplayData->type == DisplayType::BoundingBox)
    {
        _boundingBoxData = static_cast<BoundingBoxDisplayData*>(rawDisplayData)->boundingBox;
    }
    else
    {
        _boundingBoxData = nullptr;
    }

    if (_displayData != prevDisplayData || currentVerticesData != prevVerticesData || _textureData != prevTextureData)
    {
        if (currentVerticesData == nullptr && _textureData != nullptr)
        {
            const auto imageDisplayData = static_cast<ImageDisplayData*>(_displayData);
            const auto scale            = _textureData->parent->scale * _armature->_armatureData->scale;
            const auto frame            = _textureData->frame;

            _pivotX = imageDisplayData->pivot.x;
            _pivotY = imageDisplayData->pivot.y;

            const auto& rect = frame != nullptr ? *frame : _textureData->region;
            float width      = rect.width;
            float height     = rect.height;

            if (_textureData->rotated && frame == nullptr)
            {
                width  = rect.height;
                height = rect.width;
            }

            _pivotX *= width * scale;
            _pivotY *= height * scale;

            if (frame != nullptr)
            {
                _pivotX += frame->x * scale;
                _pivotY += frame->y * scale;
            }

            // Update replace pivot.
            if (_displayData != nullptr && rawDisplayData != nullptr && _displayData != rawDisplayData)
            {
                rawDisplayData->transform.toMatrix(_helpMatrix);
                _helpMatrix.invert();
                _helpMatrix.transformPoint(0.0f, 0.0f, _helpPoint);
                _pivotX -= _helpPoint.x;
                _pivotY -= _helpPoint.y;

                _displayData->transform.toMatrix(_helpMatrix);
                _helpMatrix.invert();
                _helpMatrix.transformPoint(0.0f, 0.0f, _helpPoint);
                _pivotX += _helpPoint.x;
                _pivotY += _helpPoint.y;
            }

            if (!DragonBones::yDown)
            {
                _pivotY = (_textureData->rotated ? _textureData->region.width : _textureData->region.height) * scale -
                          _pivotY;
            }
        }
        else
        {
            _pivotX = 0.0f;
            _pivotY = 0.0f;
        }

        // Update original transform.
        if (rawDisplayData != nullptr)
        {
            origin = &rawDisplayData->transform;
        }
        else if (_displayData != nullptr)
        {
            origin = &_displayData->transform;
        }
        else
        {
            origin = nullptr;
        }

        // Update vertices.
        if (currentVerticesData != prevVerticesData)
        {
            if (_deformVertices == nullptr)
            {
                _deformVertices = BaseObject::borrowObject<DeformVertices>();
            }

            _deformVertices->init(currentVerticesData, _armature);
        }
        else if (_deformVertices != nullptr && _textureData != prevTextureData)  // Update mesh after update frame.
        {
            _deformVertices->verticesDirty = true;
        }

        _displayDirty   = true;
        _transformDirty = true;
    }
}

void Slot::_updateDisplay()
{
    const auto prevDisplay       = _display != nullptr ? _display : _rawDisplay;
    const auto prevChildArmature = _childArmature;

    // Update display and child armature.
    if (_displayIndex >= 0 && (std::size_t)_displayIndex < _displayList.size())
    {
        const auto& displayPair = _displayList[_displayIndex];
        _display                = displayPair.first;
        if (_display != nullptr && displayPair.second == DisplayType::Armature)
        {
            _childArmature = static_cast<Armature*>(displayPair.first);
            _display       = _childArmature->getDisplay();
        }
        else
        {
            _childArmature = nullptr;
        }
    }
    else
    {
        _display       = nullptr;
        _childArmature = nullptr;
    }

    const auto currentDisplay = _display != nullptr ? _display : _rawDisplay;
    if (currentDisplay != prevDisplay)
    {
        _onUpdateDisplay();
        _replaceDisplay(prevDisplay, prevChildArmature != nullptr);

        _transformDirty = true;
        _visibleDirty   = true;
        _blendModeDirty = true;
        _colorDirty     = true;
    }

    // Update frame.
    if (currentDisplay == _rawDisplay || currentDisplay == _meshDisplay)
    {
        _updateFrame();
    }

    // Update child armature.
    if (_childArmature != prevChildArmature)
    {
        if (prevChildArmature != nullptr)
        {
            prevChildArmature->_parent = nullptr;  // Update child armature parent.
            prevChildArmature->setClock(nullptr);
            if (prevChildArmature->inheritAnimation)
            {
                prevChildArmature->getAnimation()->reset();
            }
        }

        if (_childArmature != nullptr)
        {
            _childArmature->_parent = this;  // Update child armature parent.
            _childArmature->setClock(_armature->getClock());
            if (_childArmature->inheritAnimation)  // Set child armature cache frameRate.
            {
                if (_childArmature->getCacheFrameRate() == 0)
                {
                    const auto chacheFrameRate = this->_armature->getCacheFrameRate();
                    if (chacheFrameRate != 0)
                    {
                        _childArmature->setCacheFrameRate(chacheFrameRate);
                    }
                }

                // Child armature action.
                std::vector<ActionData*>* actions = nullptr;
                if (_displayData != nullptr && _displayData->type == DisplayType::Armature)
                {
                    actions = &(static_cast<ArmatureDisplayData*>(_displayData)->actions);
                }
                else if (_displayIndex >= 0 && _rawDisplayDatas != nullptr)
                {
                    auto rawDisplayData = (unsigned)_displayIndex < _rawDisplayDatas->size()
                                              ? (*_rawDisplayDatas)[_displayIndex]
                                              : nullptr;

                    if (rawDisplayData == nullptr)
                    {
                        rawDisplayData = _getDefaultRawDisplayData(_displayIndex);
                    }

                    if (rawDisplayData != nullptr && rawDisplayData->type == DisplayType::Armature)
                    {
                        actions = &(static_cast<ArmatureDisplayData*>(rawDisplayData)->actions);
                    }
                }

                if (actions != nullptr && !actions->empty())
                {
                    for (const auto action : *actions)
                    {
                        const auto eventObject = BaseObject::borrowObject<EventObject>();
                        EventObject::actionDataToInstance(action, eventObject, _armature);
                        eventObject->slot = this;
                        _armature->_bufferAction(eventObject, false);
                    }
                }
                else
                {
                    _childArmature->getAnimation()->play();
                }
            }
        }
    }
}

void Slot::_updateGlobalTransformMatrix(bool isCache)
{
    const auto& parentMatrix = _parent->globalTransformMatrix;
    globalTransformMatrix    = _localMatrix;  // Copy.
    globalTransformMatrix.concat(parentMatrix);

    if (isCache)
    {
        global.fromMatrix(globalTransformMatrix);
    }
    else
    {
        _globalDirty = true;
    }
}

bool Slot::_setDisplayIndex(int value, bool isAnimation)
{
    if (isAnimation)
    {
        if (_animationDisplayIndex == value)
        {
            return false;
        }

        _animationDisplayIndex = value;
    }

    if (_displayIndex == value)
    {
        return false;
    }

    _displayIndex = value;
    _displayDirty = true;

    _updateDisplayData();

    return _displayDirty;
}

bool Slot::_setZorder(int value)
{
    if (_zOrder == value)
    {
        // return false;
    }

    _zOrder      = value;
    _zOrderDirty = true;

    return _zOrderDirty;
}

bool Slot::_setColor(const ColorTransform& value)
{
    _colorTransform = value;  // copy
    _colorDirty     = true;

    return true;
}

bool Slot::_setDisplayList(const std::vector<std::pair<void*, DisplayType>>& value)
{
    if (!value.empty())
    {
        if (_displayList.size() != value.size())
        {
            _displayList.resize(value.size());
        }

        for (std::size_t i = 0, l = value.size(); i < l; ++i)
        {
            const auto& eachPair = value[i];
            if (eachPair.first != nullptr && eachPair.first != _rawDisplay && eachPair.first != _meshDisplay &&
                eachPair.second != DisplayType::Armature &&
                std::find(_displayList.cbegin(), _displayList.cend(), eachPair) == _displayList.cend())
            {
                _initDisplay(eachPair.first, true);
            }

            _displayList[i].first  = eachPair.first;
            _displayList[i].second = eachPair.second;
        }
    }
    else if (!_displayList.empty())
    {
        _displayList.clear();
    }

    if (_displayIndex >= 0 && (std::size_t)_displayIndex < _displayList.size())
    {
        _displayDirty = _display != _displayList[_displayIndex].first;
    }
    else
    {
        _displayDirty = _display != nullptr;
    }

    _updateDisplayData();

    return _displayDirty;
}

void Slot::init(const SlotData* slotData, Armature* armatureValue, void* rawDisplay, void* meshDisplay)
{
    if (_slotData != nullptr)
    {
        return;
    }

    _slotData = slotData;
    //
    _visibleDirty   = true;
    _blendModeDirty = true;
    _colorDirty     = true;
    _blendMode      = _slotData->blendMode;
    _zOrder         = _slotData->zOrder;
    _colorTransform = *(_slotData->color);
    _rawDisplay     = rawDisplay;
    _meshDisplay    = meshDisplay;
    //
    _armature = armatureValue;
    //
    const auto slotParent = _armature->getBone(_slotData->parent->name);
    if (slotParent != nullptr)
    {
        _parent = slotParent;
    }
    else
    {
        // Never;
    }

    _armature->_addSlot(this);
    //
    _initDisplay(_rawDisplay, false);
    if (_rawDisplay != _meshDisplay)
    {
        _initDisplay(_meshDisplay, false);
    }

    _onUpdateDisplay();
    _addDisplay();
}

void Slot::update(int cacheFrameIndex)
{
    if (_displayDirty)
    {
        _displayDirty = false;
        _updateDisplay();

        // TODO remove slot offset.
        if (_transformDirty)  // Update local matrix. (Only updated when both display and transform are dirty.)
        {
            if (origin != nullptr)
            {
                global = *origin;  // Copy.
                global.add(offset).toMatrix(_localMatrix);
            }
            else
            {
                global = offset;  // Copy.
                global.toMatrix(_localMatrix);
            }
        }
    }

    if (_zOrderDirty)
    {
        _zOrderDirty = false;
        _updateZOrder();
    }

    if (cacheFrameIndex >= 0 && _cachedFrameIndices != nullptr)
    {
        const auto cachedFrameIndex = (*_cachedFrameIndices)[cacheFrameIndex];
        if (cachedFrameIndex >= 0 && _cachedFrameIndex == cachedFrameIndex)  // Same cache.
        {
            _transformDirty = false;
        }
        else if (cachedFrameIndex >= 0)  // Has been Cached.
        {
            _transformDirty   = true;
            _cachedFrameIndex = cachedFrameIndex;
        }
        else if (_transformDirty || _parent->_childrenTransformDirty)  // Dirty.
        {
            _transformDirty   = true;
            _cachedFrameIndex = -1;
        }
        else if (_cachedFrameIndex >= 0)  // Same cache, but not set index yet.
        {
            _transformDirty                         = false;
            (*_cachedFrameIndices)[cacheFrameIndex] = _cachedFrameIndex;
        }
        else  // Dirty.
        {
            _transformDirty   = true;
            _cachedFrameIndex = -1;
        }
    }
    else if (_transformDirty || this->_parent->_childrenTransformDirty)
    {
        cacheFrameIndex   = -1;
        _transformDirty   = true;
        _cachedFrameIndex = -1;
    }

    if (_display == nullptr)
    {
        return;
    }

    if (_visibleDirty)
    {
        _visibleDirty = false;
        _updateVisible();
    }

    if (_blendModeDirty)
    {
        _blendModeDirty = false;
        _updateBlendMode();
    }

    if (_colorDirty)
    {
        _colorDirty = false;
        _updateColor();
    }

    if (_deformVertices != nullptr && _deformVertices->verticesData != nullptr && _display == _meshDisplay)
    {
        const auto isSkinned = _deformVertices->verticesData->weight != nullptr;

        if (_deformVertices->verticesDirty || (isSkinned && _deformVertices->isBonesUpdate()))
        {
            _deformVertices->verticesDirty = false;
            _updateMesh();
        }

        if (isSkinned)  // Compatible.
        {
            return;
        }
    }

    if (_transformDirty)
    {
        _transformDirty = false;

        if (_cachedFrameIndex < 0)
        {
            const auto isCache = cacheFrameIndex >= 0;
            _updateGlobalTransformMatrix(isCache);

            if (isCache && _cachedFrameIndices != nullptr)
            {
                _cachedFrameIndex = (*_cachedFrameIndices)[cacheFrameIndex] =
                    _armature->_armatureData->setCacheFrame(globalTransformMatrix, global);
            }
        }
        else
        {
            _armature->_armatureData->getCacheFrame(globalTransformMatrix, global, _cachedFrameIndex);
        }

        _updateTransform();
    }
}

void Slot::updateTransformAndMatrix()
{
    if (_transformDirty)
    {
        _transformDirty = false;
        _updateGlobalTransformMatrix(false);
    }
}

void Slot::replaceDisplayData(DisplayData* displayData, int displayIndex)
{
    if (displayIndex < 0)
    {
        if (_displayIndex < 0)
        {
            displayIndex = 0;
        }
        else
        {
            displayIndex = _displayIndex;
        }
    }

    if (_displayDatas.size() <= (unsigned)displayIndex)
    {
        _displayDatas.resize(displayIndex + 1, nullptr);
    }

    _displayDatas[displayIndex] = displayData;
}

bool Slot::containsPoint(float x, float y)
{
    if (_boundingBoxData == nullptr)
    {
        return false;
    }

    updateTransformAndMatrix();

    _helpMatrix = globalTransformMatrix;  // Copy.
    _helpMatrix.invert();
    _helpMatrix.transformPoint(x, y, _helpPoint);

    return _boundingBoxData->containsPoint(_helpPoint.x, _helpPoint.y);
}

int Slot::intersectsSegment(float xA,
                            float yA,
                            float xB,
                            float yB,
                            Point* intersectionPointA,
                            Point* intersectionPointB,
                            Point* normalRadians)
{
    if (_boundingBoxData == nullptr)
    {
        return 0;
    }

    updateTransformAndMatrix();
    _helpMatrix = globalTransformMatrix;
    _helpMatrix.invert();
    _helpMatrix.transformPoint(xA, yA, _helpPoint);
    xA = _helpPoint.x;
    yA = _helpPoint.y;
    _helpMatrix.transformPoint(xB, yB, _helpPoint);
    xB = _helpPoint.x;
    yB = _helpPoint.y;

    const auto intersectionCount =
        _boundingBoxData->intersectsSegment(xA, yA, xB, yB, intersectionPointA, intersectionPointB, normalRadians);
    if (intersectionCount > 0)
    {
        if (intersectionCount == 1 || intersectionCount == 2)
        {
            if (intersectionPointA != nullptr)
            {
                globalTransformMatrix.transformPoint(intersectionPointA->x, intersectionPointA->y, *intersectionPointA);
                if (intersectionPointB != nullptr)
                {
                    intersectionPointB->x = intersectionPointA->x;
                    intersectionPointB->y = intersectionPointA->y;
                }
            }
            else if (intersectionPointB != nullptr)
            {
                globalTransformMatrix.transformPoint(intersectionPointB->x, intersectionPointB->y, *intersectionPointB);
            }
        }
        else
        {
            if (intersectionPointA != nullptr)
            {
                globalTransformMatrix.transformPoint(intersectionPointA->x, intersectionPointA->y, *intersectionPointA);
            }

            if (intersectionPointB != nullptr)
            {
                globalTransformMatrix.transformPoint(intersectionPointB->x, intersectionPointB->y, *intersectionPointB);
            }
        }

        if (normalRadians != nullptr)
        {
            globalTransformMatrix.transformPoint(cos(normalRadians->x), sin(normalRadians->x), _helpPoint, true);
            normalRadians->x = atan2(_helpPoint.y, _helpPoint.x);

            globalTransformMatrix.transformPoint(cos(normalRadians->y), sin(normalRadians->y), _helpPoint, true);
            normalRadians->y = atan2(_helpPoint.y, _helpPoint.x);
        }
    }

    return intersectionCount;
}

void Slot::setVisible(bool value)
{
    if (_visible == value)
    {
        return;
    }

    _visible = value;
    _updateVisible();
}

void Slot::setDisplayIndex(int value)
{
    if (_setDisplayIndex(value))
    {
        update(-1);
    }
}

// TODO lsc check
void Slot::setDisplayList(const std::vector<std::pair<void*, DisplayType>>& value)
{
    const auto backupDisplayList = _displayList;       // copy
    auto disposeDisplayList      = backupDisplayList;  // copy
    disposeDisplayList.clear();

    if (_setDisplayList(value))
    {
        update(-1);
    }

    for (const auto& pair : backupDisplayList)
    {
        if (pair.first != nullptr && pair.first != _rawDisplay && pair.first != _meshDisplay &&
            std::find(_displayList.cbegin(), _displayList.cend(), pair) == _displayList.cend() &&
            std::find(disposeDisplayList.cbegin(), disposeDisplayList.cend(), pair) == disposeDisplayList.cend())
        {
            disposeDisplayList.push_back(pair);
        }
    }

    for (const auto& pair : disposeDisplayList)
    {
        if (pair.second == DisplayType::Armature)
        {
            static_cast<Armature*>(pair.first)->returnToPool();
        }
        else
        {
            _disposeDisplay(pair.first, true);
        }
    }
}

void Slot::setRawDisplayDatas(const std::vector<DisplayData*>* value)
{
    if (_rawDisplayDatas == value)
    {
        return;
    }

    _displayDirty    = true;
    _rawDisplayDatas = value;

    if (_rawDisplayDatas != nullptr)
    {
        _displayDatas.resize(_rawDisplayDatas->size());

        for (std::size_t i = 0, l = _displayDatas.size(); i < l; ++i)
        {
            auto rawDisplayData = (*_rawDisplayDatas)[i];

            if (rawDisplayData == nullptr)
            {
                rawDisplayData = _getDefaultRawDisplayData(i);
            }

            _displayDatas[i] = rawDisplayData;
        }
    }
    else
    {
        _displayDatas.clear();
    }
}

void Slot::setDisplay(void* value, DisplayType displayType)
{
    if (_display == value)
    {
        return;
    }

    const auto displayListLength = _displayList.size();
    if (_displayIndex < 0 && displayListLength == 0)  // Emprty
    {
        _displayIndex = 0;
    }

    if (_displayIndex < 0)
    {
        return;
    }
    else
    {
        auto relpaceDisplayList = _displayList;  // copy
        if (displayListLength <= (std::size_t)_displayIndex)
        {
            relpaceDisplayList.resize(_displayIndex + 1);
        }

        relpaceDisplayList[_displayIndex].first  = value;
        relpaceDisplayList[_displayIndex].second = displayType;

        setDisplayList(relpaceDisplayList);
    }
}

void Slot::setChildArmature(Armature* value)
{
    if (_childArmature == value)
    {
        return;
    }

    setDisplay(value, DisplayType::Armature);
}

DRAGONBONES_NAMESPACE_END