include/rive/generated/shapes/paint/stroke_base.hpp

#ifndef _RIVE_STROKE_BASE_HPP_
#define _RIVE_STROKE_BASE_HPP_
#include "rive/core/field_types/core_bool_type.hpp"
#include "rive/core/field_types/core_double_type.hpp"
#include "rive/core/field_types/core_uint_type.hpp"
#include "rive/shapes/paint/shape_paint.hpp"
namespace rive
{
class StrokeBase : public ShapePaint
{
protected:
    typedef ShapePaint Super;

public:
    static const uint16_t typeKey = 24;

    /// Helper to quickly determine if a core object extends another without RTTI
    /// at runtime.
    bool isTypeOf(uint16_t typeKey) const override
    {
        switch (typeKey)
        {
            case StrokeBase::typeKey:
            case ShapePaintBase::typeKey:
            case ContainerComponentBase::typeKey:
            case ComponentBase::typeKey:
                return true;
            default:
                return false;
        }
    }

    uint16_t coreType() const override { return typeKey; }

    static const uint16_t thicknessPropertyKey = 47;
    static const uint16_t capPropertyKey = 48;
    static const uint16_t joinPropertyKey = 49;
    static const uint16_t transformAffectsStrokePropertyKey = 50;

private:
    float m_Thickness = 1.0f;
    uint32_t m_Cap = 0;
    uint32_t m_Join = 0;
    bool m_TransformAffectsStroke = true;

public:
    inline float thickness() const { return m_Thickness; }
    void thickness(float value)
    {
        if (m_Thickness == value)
        {
            return;
        }
        m_Thickness = value;
        thicknessChanged();
    }

    inline uint32_t cap() const { return m_Cap; }
    void cap(uint32_t value)
    {
        if (m_Cap == value)
        {
            return;
        }
        m_Cap = value;
        capChanged();
    }

    inline uint32_t join() const { return m_Join; }
    void join(uint32_t value)
    {
        if (m_Join == value)
        {
            return;
        }
        m_Join = value;
        joinChanged();
    }

    inline bool transformAffectsStroke() const { return m_TransformAffectsStroke; }
    void transformAffectsStroke(bool value)
    {
        if (m_TransformAffectsStroke == value)
        {
            return;
        }
        m_TransformAffectsStroke = value;
        transformAffectsStrokeChanged();
    }

    Core* clone() const override;
    void copy(const StrokeBase& object)
    {
        m_Thickness = object.m_Thickness;
        m_Cap = object.m_Cap;
        m_Join = object.m_Join;
        m_TransformAffectsStroke = object.m_TransformAffectsStroke;
        ShapePaint::copy(object);
    }

    bool deserialize(uint16_t propertyKey, BinaryReader& reader) override
    {
        switch (propertyKey)
        {
            case thicknessPropertyKey:
                m_Thickness = CoreDoubleType::deserialize(reader);
                return true;
            case capPropertyKey:
                m_Cap = CoreUintType::deserialize(reader);
                return true;
            case joinPropertyKey:
                m_Join = CoreUintType::deserialize(reader);
                return true;
            case transformAffectsStrokePropertyKey:
                m_TransformAffectsStroke = CoreBoolType::deserialize(reader);
                return true;
        }
        return ShapePaint::deserialize(propertyKey, reader);
    }

protected:
    virtual void thicknessChanged() {}
    virtual void capChanged() {}
    virtual void joinChanged() {}
    virtual void transformAffectsStrokeChanged() {}
};
} // namespace rive

#endif