gui_custom_draw_context.h

Go to the documentation of this file.

#pragma once
 
// The contexts passed to callbacks registered with ElementStorage: CustomDrawContext for
// drawing, PostLayoutContext for after layout.
 
#include <gui_core/gui_base_types.h>
#include <gui_core/elements/gui_element.h>            // ElementRef (member by value)
#include <gui_core/graphics/gui_image.h>              // ImageIndex (default args)
#include <gui_core/graphics/gui_renderer.h>           // TriangleEdges (default args)
 
#include <span>
 
namespace tachyon
{
 
    class GUIRenderer;
    class ElementStorage;
    class ITextSystem;
    enum class VisualBoxStyleIndex : uint16_t;
    enum class VisualColorStyleIndex : uint16_t;
    enum class ElementState : uint8_t;
    enum class TextID : uint32_t;
    struct LineStyle;

    enum class DrawSpace : uint8_t
    {
        Local,  
        Screen, 
    };

    class CustomDrawContext
    {
    public:
        CustomDrawContext(GUIRenderer& renderer, ElementStorage& storage,
                          ElementRef elementRef,
                          IntRect elementRectLayout, IntRect innerRectLayout,
                          IntRect clipRectScreen,
                          float3x2 renderTransform, int2 windowOffset,
                          ITextSystem* textSystem = nullptr,
                          float4 ownerPixelRect = {}, IntRect ownerSnappedRect = {}) noexcept
            : m_renderer(&renderer), m_storage(&storage),
              m_elementRef(elementRef),
              m_elementRect(elementRectLayout), m_innerRect(innerRectLayout),
              m_clipRect(clipRectScreen),
              m_renderTransform(renderTransform),
              m_currentTransform(renderTransform),
              m_windowOffset(windowOffset),
              m_textSystem(textSystem),
              m_ownerPixelRect(ownerPixelRect), m_ownerSnappedRect(ownerSnappedRect) {}

        inline ElementRef Ref() const noexcept { return m_elementRef; }

        inline IntRect ElementRect() const noexcept { return ToCurrentSpace(m_elementRect); }

        inline IntRect ElementInnerRect() const noexcept { return ToCurrentSpace(m_innerRect); }

        inline IntRect ClipRect() const noexcept { return m_clipRect; }

        void SetSpace(DrawSpace space);

        void SetSpaceRaw(float3x2 spaceToWindowLocal);

        inline float3x2 CurrentTransform() const noexcept { return m_currentTransform; }

        int2 ScreenToCurrent(int2 screenPoint) const;

        IntRect    GetElementRect(const ElementRef& ref) const noexcept;
        IntRect    GetInnerRect(const ElementRef& ref) const noexcept;
        ElementRef GetParentRef(const ElementRef& ref)      const noexcept;
        ElementRef GetNextSiblingRef(const ElementRef& ref) const noexcept;
        int2       GetContentSize(const ElementRef& ref) const noexcept;
        int2       GetInnerSize(const ElementRef& ref) const noexcept;
 
        // Drawing primitives. Input coords are in the current space; clipped to ClipRect().

        void RenderBox(IntRect rect, VisualBoxStyleIndex styleIndex, ElementState state,
                       VisualColorStyleIndex colorStyleIndex = {},
                       ImageIndex textureIndex = ImageIndex::Invalid) const;
 
        void RenderBox(IntRect rect, VisualBoxStyleIndex styleIndex,
                       VisualColorStyleIndex colorStyleIndex = {},
                       ImageIndex textureIndex = ImageIndex::Invalid) const;

        void RenderBox(IntRect rect, VisualBoxStyleIndex styleIndex,
                       ElementState fromState, ElementState toState, float t) const;

        void RenderBox(IntRect rect, IntRect subClip,
                       VisualBoxStyleIndex styleIndex, ElementState state,
                       VisualColorStyleIndex colorStyleIndex = {},
                       ImageIndex textureIndex = ImageIndex::Invalid) const;
 
        void RenderBox(IntRect rect, IntRect subClip,
                       VisualBoxStyleIndex styleIndex,
                       VisualColorStyleIndex colorStyleIndex = {},
                       ImageIndex textureIndex = ImageIndex::Invalid) const;

        void RenderQuad(IntRect rect, VisualColorStyleIndex colorStyleIndex,
                        float cornerRadius = 0.0f,
                        ImageIndex textureIndex = ImageIndex::Invalid) const;

        void RenderQuad(IntRect rect, IntRect subClip,
                        VisualColorStyleIndex colorStyleIndex,
                        float cornerRadius = 0.0f,
                        ImageIndex textureIndex = ImageIndex::Invalid) const;

        void RenderLine(int2 p0, int2 p1, const LineStyle& style) const;
        void RenderLine(int2 p0, int2 p1, int2 p2, int2 p3, const LineStyle& style) const;

        void RenderDot(float2 pos, float size, color4f color) const;

        void RenderTriangle(float2 p0, float2 p1, float2 p2,
                            VisualColorStyleIndex colorStyleIndex,
                            ImageIndex textureIndex = ImageIndex::Invalid,
                            TriangleEdges hardEdges = TriangleEdges::None) const;

        void RenderCircle(float2 center, float radius, const LineStyle& style) const;
        void RenderCircle(int2 center, float radius, const LineStyle& style) const; 
        void RenderDisc(int2 center, float radius, VisualColorStyleIndex colorStyleIndex) const;

        void RenderFilledPolygon(std::span<const float2> points,
                                 VisualColorStyleIndex colorStyleIndex,
                                 ImageIndex textureIndex = ImageIndex::Invalid) const;

        void RenderPolyline(std::span<const int2> points, bool closed,
                            const LineStyle& style, float cornerRadius = 0.0f) const;

        void RenderText(TextID textId, IntRect rect, float extraScale = 1.0f) const;
 
    private:
        inline IntRect ToCurrentSpace(IntRect rectAbs) const noexcept
        {
            return m_currentSpaceIsLocal ? (rectAbs - m_innerRect.position) : rectAbs;
        }
 
        GUIRenderer*    m_renderer;
        ElementStorage* m_storage;
        ElementRef      m_elementRef;
        IntRect         m_elementRect;
        IntRect         m_innerRect;
        IntRect         m_clipRect;
        float3x2        m_renderTransform;   
        float3x2        m_currentTransform;  
        int2            m_windowOffset{};
        ITextSystem*    m_textSystem = nullptr;
        float4          m_ownerPixelRect {};
        IntRect         m_ownerSnappedRect {};
        IntRect         SnappedPixelRect(IntRect rect) const;
        bool            m_currentSpaceIsLocal = true;
    };

    class PostLayoutContext
    {
    public:
        PostLayoutContext(ElementStorage& storage, ElementRef ref,
                          IntRect elementRectLayout, IntRect innerRectLayout,
                          float3x2 contentTransform) noexcept
            : m_storage(&storage), m_elementRef(ref),
              m_elementRect(elementRectLayout), m_innerRect(innerRectLayout),
              m_contentTransform(contentTransform) {}

        inline ElementRef Ref()              const noexcept { return m_elementRef; }
        inline IntRect    ElementRect()      const noexcept { return m_elementRect; }
        inline IntRect    ElementInnerRect() const noexcept { return m_innerRect; }
        inline float3x2   ContentTransform() const noexcept { return m_contentTransform; }

        IntRect    GetElementRect(const ElementRef& ref) const noexcept;
        IntRect    GetInnerRect(const ElementRef& ref) const noexcept;
        ElementRef GetParentRef(const ElementRef& ref)      const noexcept;
        ElementRef GetNextSiblingRef(const ElementRef& ref) const noexcept;
        int2       GetContentSize(const ElementRef& ref) const noexcept;
        int2       GetInnerSize(const ElementRef& ref) const noexcept;
 
    private:
        ElementStorage* m_storage;
        ElementRef      m_elementRef;
        IntRect         m_elementRect;
        IntRect         m_innerRect;
        float3x2        m_contentTransform;
    };

} // namespace tachyon