Crafter.Graphics/interfaces/Crafter.Graphics-RenderingElement2DBase.cppm

/*
Crafter®.Graphics
Copyright (C) 2026 Catcrafts®
catcrafts.net

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License version 3.0 as published by the Free Software Foundation;

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
*/

export module Crafter.Graphics:RenderingElement2DBase;
import Crafter.Asset;
import Crafter.Math;
import std;
import :Transform2D;

export namespace Crafter {
    enum class TextAlignment {
        Left,
        Center,
        Right
    };

    enum class TextOverflowMode {
        Clip,
        Wrap
    };

    enum class TextScaleMode {
        None,
        Font, 
        Element,
        Buffer
    };

    template<std::uint8_t Alignment = 0>
    struct RenderElement2DScalingOwning {
        std::vector<Vector<std::uint8_t, 4, Alignment>> scalingBuffer;
        std::uint32_t bufferWidth;
        std::uint32_t bufferHeight;
        RenderElement2DScalingOwning() = default;
        RenderElement2DScalingOwning(std::uint32_t bufferWidth, std::uint32_t bufferHeight) : scalingBuffer(bufferWidth*bufferHeight), bufferWidth(bufferWidth), bufferHeight(bufferHeight) {
            
        }
    };

    template<std::uint8_t Alignment = 0>
    struct RenderElement2DScalingNonOwning {
        Vector<std::uint8_t, 4, Alignment>* scalingBuffer;
        std::uint32_t bufferWidth;
        std::uint32_t bufferHeight;
        RenderElement2DScalingNonOwning() = default;
        RenderElement2DScalingNonOwning(Vector<std::uint8_t, 4, Alignment>* scalingBuffer, std::uint32_t bufferWidth, std::uint32_t bufferHeight) : scalingBuffer(scalingBuffer), bufferWidth(bufferWidth), bufferHeight(bufferHeight) {
            
        }
    };

    struct RenderElement2DRotating {
        float rotation;
        RenderElement2DRotating() = default;
        RenderElement2DRotating(float rotation) : rotation(rotation) {

        }
    };


    struct EmptyScalingBase {};
    struct EmptyRotatingBase {};

    template<bool Scaling, bool Owning, std::uint8_t Alignment = 0>
    using ScalingBase =
        std::conditional_t<
            Scaling,
            std::conditional_t<Owning,
                RenderElement2DScalingOwning<Alignment>,
                RenderElement2DScalingNonOwning<Alignment>>,
            EmptyScalingBase
        >;

    template<bool Rotating>
    using RotatingBase =
        std::conditional_t<
            Rotating,
            RenderElement2DRotating,
            EmptyRotatingBase
        >;

    template<std::uint8_t Frames = 1>
    struct RenderingElement2DBase : Transform2D  {
        ScaleData2D oldScale[Frames];
        bool redraw[Frames];
        std::vector<Vector<std::uint8_t, 4>> buffer;
        OpaqueType opaque;
        RenderingElement2DBase(Anchor2D anchor) : Transform2D(anchor) {
            for(std::uint8_t i = 0; i < Frames; i++) {
                this->scaled.size.x = 0;
            }
        }
        RenderingElement2DBase(Anchor2D anchor, OpaqueType opaque) : Transform2D(anchor), opaque(opaque) {
            for(std::uint8_t i = 0; i < Frames; i++) {
                this->scaled.size.x = 0;
            }
        }
        void Redraw() {
            for(std::uint8_t i = 0; i < Frames; i++) {
                redraw[i] = true;
            }
        }
    };
}