gui_primitive_renderer.h

Go to the documentation of this file.

#pragma once
 
// API-neutral GUI primitive renderer: per-window targets accumulate per-kind
// primitive streams, then Render() uploads each stream and replays the pass
// list through the RHI. No graphics-API types appear here - a backend
// supplies a RenderCommandList with a fence-protected transient upload arena
// and the pipeline set built from kPrimitiveSpecs.
 
#include <gui_core/gui_id.h>
#include <gui_core/graphics/gui_renderer.h>
#include <gui_core/graphics/gui_render_primitives.h>
#include <gui_core/graphics/gui_rhi.h>
 
#include <array>
#include <cassert>
#include <cstddef>
#include <type_traits>
#include <unordered_map>
#include <vector>
 
namespace tachyon
{
 
    using PipelineSet = std::array<RHI::GpuPipeline, kPrimitiveKindCount>;

    struct PrimitiveRenderPass
    {
        int           firstPrimitive;
        int           primitiveCount;
        PrimitiveKind kind;
        int           replay = -1; 
    };
 
    struct PrimitiveRenderTarget
    {
    public:
        struct Stream
        {
            std::vector<std::byte> cpu;
            int                    passStart = 0; 
        };
        std::array<Stream, kPrimitiveKindCount> streams;
 
        std::vector<PrimitiveRenderPass> renderPasses;
        int           currentKind = -1; 
        tachyon::float3x2 currentTransform;
        float             currentOpacity = 1.0f; 

        struct ScopeReplay { tachyon::ID scope; tachyon::int2 delta; uint32_t baseOrder = 0; };
        std::vector<ScopeReplay> replays;
 
    public:
        void FinishRenderPass();
        void StartRenderPass(PrimitiveKind kind);

        void AppendCaptured(const PrimitiveRenderTarget& src, tachyon::int2 delta);
        void AddReplay(tachyon::ID scope, tachyon::int2 delta, uint32_t primitiveCount);
 
    public:
        size_t Render(RHI::RenderCommandList& cmdList, const PipelineSet& pipelines,
                      GPUDrawPushConstants& push_constants);
        void Reset();
 
        void SetTransform(tachyon::float3x2 transform);
        void SetOpacity(float opacity) { currentOpacity = opacity; }
        void RenderBox(tachyon::IntRect rect, tachyon::IntRect clipRect, uint32_t fromStyleIndex, uint32_t toStyleIndex, float blendT, tachyon::VisualColorStyleIndex colorStyleIndex = {}, tachyon::ImageIndex textureIndex = tachyon::ImageIndex::Invalid, tachyon::IntRect snappedPx = {});
        void RenderGlyph(tachyon::float2 pos, tachyon::float2 size, tachyon::float2 uvMin, tachyon::float2 uvMax, float scale, int bpp, int mode, tachyon::VisualColorStyleIndex textColorIndex, tachyon::IntRect clipRect, tachyon::ImageIndex textureIndex = tachyon::ImageIndex::Invalid, float shadowBlur = -1.0f);
        void RenderLine(tachyon::int2 p0, tachyon::int2 p1, tachyon::int2 p2, tachyon::int2 p3, tachyon::IntRect clipRect, const tachyon::LineStyle& lineStyle);
        void RenderCircle(tachyon::float2 center, float radius, tachyon::IntRect clipRect, const tachyon::LineStyle& lineStyle);
        void RenderDot(tachyon::float2 pos, tachyon::IntRect clipRect, float size, tachyon::color4f color);
        void RenderTriangle(tachyon::float2 p0, tachyon::float2 p1, tachyon::float2 p2, tachyon::IntRect clipRect, tachyon::VisualColorStyleIndex colorStyleIndex, tachyon::ImageIndex textureIndex = tachyon::ImageIndex::Invalid, TriangleEdges hardEdges = TriangleEdges::None);
        void RenderQuad(tachyon::IntRect rect, tachyon::IntRect clipRect, tachyon::VisualColorStyleIndex colorStyleIndex, float cornerRadius = 0.0f, tachyon::ImageIndex textureIndex = tachyon::ImageIndex::Invalid);
        void RenderShadow(tachyon::IntRect rect, tachyon::IntRect clipRect, tachyon::VisualColorStyleIndex colorStyleIndex, float cornerRadius, int blur);
        void RenderOccluder(tachyon::IntRect rect, tachyon::IntRect clipRect);

        uint32_t nextOrder = 0;
 
    private:
        template <typename T>
        void Append(PrimitiveKind kind, const T& primitive)
        {
            static_assert(std::is_trivially_copyable_v<T>);
            assert(sizeof(T) == kPrimitiveSpecs[size_t(kind)].stride);
            StartRenderPass(kind);
            auto& cpu = streams[size_t(kind)].cpu;
            T ordered = primitive;
            ordered.transform0.w = float(nextOrder++);
            ordered.transform1.w = 1.0f - currentOpacity;   // transparency: 0 is opaque
            const auto* bytes = reinterpret_cast<const std::byte*>(&ordered);
            cpu.insert(cpu.end(), bytes, bytes + sizeof(T));
        }
    };
 
    class PrimitiveRenderer : public GUIRenderer
    {
    public:
        std::unordered_map<tachyon::ID, PrimitiveRenderTarget> idTargets;
        PrimitiveRenderTarget* currentTarget{ nullptr };
        PrimitiveRenderTarget* resizingTarget{ nullptr };
 
    public:
        void Reset() override;
        void SetTransform(tachyon::float3x2 transform) override;
        void SetOpacity(float opacity) override;
        void RenderBox(tachyon::IntRect rect, tachyon::IntRect clipRect, uint32_t fromStyleIndex, uint32_t toStyleIndex, float blendT, tachyon::VisualColorStyleIndex colorStyleIndex = {}, tachyon::ImageIndex textureIndex = tachyon::ImageIndex::Invalid, tachyon::IntRect snappedPx = {}) override;
        void RenderGlyph(tachyon::float2 pos, tachyon::float2 size, tachyon::float2 uvMin, tachyon::float2 uvMax, float scale, int bpp, int mode, tachyon::VisualColorStyleIndex textColorIndex, tachyon::IntRect clipRect, tachyon::ImageIndex textureIndex = tachyon::ImageIndex::Invalid, float shadowBlur = -1.0f) override;
        void RenderLine(tachyon::int2 p0, tachyon::int2 p1, tachyon::int2 p2, tachyon::int2 p3, tachyon::IntRect clipRect, const tachyon::LineStyle& lineStyle) override;
        void RenderCircle(tachyon::float2 center, float radius, tachyon::IntRect clipRect, const tachyon::LineStyle& lineStyle) override;
        void RenderDot(tachyon::float2 pos, tachyon::IntRect clipRect, float size, tachyon::color4f color) override;
        void RenderTriangle(tachyon::float2 p0, tachyon::float2 p1, tachyon::float2 p2, tachyon::IntRect clipRect, tachyon::VisualColorStyleIndex colorStyleIndex, tachyon::ImageIndex textureIndex = tachyon::ImageIndex::Invalid, TriangleEdges hardEdges = TriangleEdges::None) override;
        void RenderQuad(tachyon::IntRect rect, tachyon::IntRect clipRect, tachyon::VisualColorStyleIndex colorStyleIndex, float cornerRadius = 0.0f, tachyon::ImageIndex textureIndex = tachyon::ImageIndex::Invalid) override;
        void RenderShadow(tachyon::IntRect rect, tachyon::IntRect clipRect, tachyon::VisualColorStyleIndex colorStyleIndex, float cornerRadius, int blur) override;
        void RenderOccluder(tachyon::IntRect rect, tachyon::IntRect clipRect) override;
 
    public:
        PrimitiveRenderTarget& GetTarget(tachyon::ID id)
        {
            auto target = idTargets.find(id);
            if (target == idTargets.end())
            {
                idTargets[id] = PrimitiveRenderTarget();
                return idTargets[id];
            }
            return target->second;
        }

        void ReleaseTarget(tachyon::ID id);
        void ReleaseAllTargets();
 
        bool StartResizing(tachyon::ID id) override
        {
            assert(resizingTarget == nullptr);
            auto target = idTargets.find(id);
            if (target == idTargets.end())
            {
                resizingTarget = nullptr;
            } else
                resizingTarget = &target->second;
            return resizingTarget != nullptr;
        }
 
        void StopResizing() override
        {
            assert(resizingTarget != nullptr);
            resizingTarget = nullptr;
        }
 
        bool BeginWindow(tachyon::ID id) override;
        void EndWindow() override;
 
        // Draw caching. A capture's primitives go to the GPU once and are drawn from there,
        // moved by the world matrix, each time it is replayed; until their copy is on the GPU
        // they are uploaded with the frame.
        void BeginScopeCapture(tachyon::ID scopeId) override;
        void EndScopeCapture(tachyon::ID scopeId) override;
        bool ReplayScopeCapture(tachyon::ID scopeId, tachyon::int2 delta) override;
        bool HasScopeCapture(tachyon::ID scopeId) const override;
        void InvalidateScopeCapture(tachyon::ID scopeId) override;
        void ClearScopeCaptures() override;
 
        void Render(tachyon::ID id, RHI::RenderCommandList& cmdList, const PipelineSet& pipelines,
                    GPUDrawPushConstants& push_constants);

        size_t LastFrameUploadBytes() const { return m_lastUploadBytes; }
        size_t ResidentScopeCount() const;

        static constexpr uint64_t kEvictAfterFrames = 240;
 
    private:
        struct ScopeCapture
        {
            PrimitiveRenderTarget target;
            RHI::ResidentBufferId resident = 0;
            std::array<DeviceAddress, kPrimitiveKindCount> addresses{}; 
            uint64_t lastUsedFrame = 0;
        };

        std::array<DeviceAddress, kPrimitiveKindCount> CaptureAddresses(ScopeCapture& capture, RHI::RenderCommandList& cmdList);
        void ReleaseResident(ScopeCapture& capture);

        std::unordered_map<tachyon::ID, ScopeCapture> scopeCaptures;
        std::vector<RHI::ResidentBufferId> m_releasedResidents;
        PrimitiveRenderTarget* m_captureSaved = nullptr;
        uint64_t m_frame = 0;
        size_t   m_lastUploadBytes = 0;
    };

}