#include "rive/shapes/cubic_vertex.hpp"
#include "rive/bones/cubic_weight.hpp"
using namespace rive;

const Vec2D& CubicVertex::renderIn()
{
    if (hasWeight())
    {
        return weight<CubicWeight>()->inTranslation();
    }
    else
    {
        return inPoint();
    }
}

const Vec2D& CubicVertex::renderOut()
{
    if (hasWeight())
    {
        return weight<CubicWeight>()->outTranslation();
    }
    else
    {
        return outPoint();
    }
}

const Vec2D& CubicVertex::inPoint()
{
    if (!m_InValid)
    {
        computeIn();
        m_InValid = true;
    }
    return m_InPoint;
}

const Vec2D& CubicVertex::outPoint()
{
    if (!m_OutValid)
    {
        computeOut();
        m_OutValid = true;
    }
    return m_OutPoint;
}

void CubicVertex::outPoint(const Vec2D& value)
{
    Vec2D::copy(m_OutPoint, value);
    m_OutValid = true;
}

void CubicVertex::inPoint(const Vec2D& value)
{
    Vec2D::copy(m_InPoint, value);
    m_InValid = true;
}

void CubicVertex::xChanged()
{
    Super::xChanged();
    m_InValid = m_OutValid = false;
}
void CubicVertex::yChanged()
{
    Super::yChanged();
    m_InValid = m_OutValid = false;
}

void CubicVertex::deform(Mat2D& worldTransform, float* boneTransforms)
{
    Super::deform(worldTransform, boneTransforms);

    auto cubicWeight = weight<CubicWeight>();

    auto inp = inPoint();
    Weight::deform(inp[0],
                   inp[1],
                   cubicWeight->inIndices(),
                   cubicWeight->inValues(),
                   worldTransform,
                   boneTransforms,
                   cubicWeight->inTranslation());

    auto outp = outPoint();
    Weight::deform(outp[0],
                   outp[1],
                   cubicWeight->outIndices(),
                   cubicWeight->outValues(),
                   worldTransform,
                   boneTransforms,
                   cubicWeight->outTranslation());
}