gal_modern.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program 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
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef GAL_MODERN_H
#define GAL_MODERN_H
 
#include <gal/graphics_abstraction_layer.h>
#include <gal/definitions.h>
#include <rhi/rhi_handle.h>
#include <rhi/rhi_instance.h>
#include <rhi/frame_packet.h>
 
#include <array>
#include <map>
#include <memory>
#include <optional>
#include <unordered_map>
#include <vector>
 
class SHAPE_ELLIPSE;
 
namespace KIGFX
{
 
class RENDER_THREAD;
class RHI_DEVICE_PROXY;

class GAL_API GAL_MODERN : public GAL
{
public:
    GAL_MODERN( GAL_DISPLAY_OPTIONS& aOptions, RHI_DEVICE_PROXY& aDeviceProxy );
    ~GAL_MODERN() override;
 
    bool IsInitialized() const override { return m_rhiInitialized; }
    bool IsDrawingMode() const override { return m_isDrawing; }
    bool HasStaticRebuildPending() const override { return m_staticDirty; }
    bool HasRetainedScene() const override { return true; }
    bool RefillsNonCachedTargets() const override { return !m_persistentTargets; }
    bool SupportsTypedPads() const override { return true; }
    bool UsesPolygonTriangulationCache() const override { return true; }
 
    void BeginDrawing() override;
    void EndDrawing() override;
 
    void ResizeScreen( int aWidth, int aHeight ) override;
    void Flush() override;
    void ClearScreen() override;
 
    void           SetTarget( RENDER_TARGET aTarget ) override;
    RENDER_TARGET  GetTarget() const override;
    void           ClearTarget( RENDER_TARGET aTarget ) override;
 
    void StartDiffLayer() override;
    void EndDiffLayer() override;
    void StartNegativesLayer() override;
    void EndNegativesLayer() override;
    void SetNegativeDrawMode( bool aSetting ) override;
    void SetScreenSpaceMode( bool aEnabled ) override { m_screenSpaceMode = aEnabled; }
 
    bool SupportsStrokePixelPad() const override { return true; }
 
    bool SupportsStrokeLengthPad() const override { return true; }
 
    void SetStrokeLengthPad( double aPixels ) override { m_strokeLengthPad = static_cast<float>( aPixels ); }
 
    void SetStrokePixelPad( double aPixels ) override
    {
        m_strokePixelPad = static_cast<uint16_t>( std::clamp( std::lround( aPixels * 16.0 ), 0L, 65535L ) );
    }
 
    bool SupportsStrokeLevelOfDetail() const override { return true; }
 
    void SetStrokeLevelOfDetail( double aLod ) override { m_strokeLod = aLod; }
 
    void BitmapText( const wxString& aText, const VECTOR2I& aPosition, const EDA_ANGLE& aAngle ) override;

    void SetBitmapGlyphs( bool aEnable ) { m_bitmapGlyphs = aEnable; }
 
    void DrawGrid() override;
    void DrawCursor( const VECTOR2D& aCursorPosition ) override;
 
    int  BeginGroup() override;
    void EndGroup() override;
    std::array<uint64_t, 2> GroupContentFingerprint( int aGroupNumber ) const override;
    void DrawGroup( int aGroupNumber ) override;
    void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) override;
    void ChangeGroupDepth( int aGroupNumber, int aDepth ) override;
    void ChangeGroupUndimmed( int aGroupNumber, bool aUndimmed ) override;
    void DeleteGroup( int aGroupNumber ) override;
    void ClearCache() override;
 
    void SetSceneLayerState( int aLayer, int aOrder, bool aVisible, bool aHasNegatives ) override;
    void SetSceneLayerDim( int aLayer, const COLOR4D& aToward, double aKeep ) override;
    void SetSceneLayerOverlayAlpha( int aLayer ) override;
    void SetSceneDrawOrdered( bool aOrdered ) override;
    void BeginSceneLayer( int aLayer ) override;
    void SetGroupPlacement( int aGroup, int aLayer, double aLodScale, bool aShown,
                            const RETAINED_GROUP_ORDER& aOrder ) override;
    void SetSceneScale( double aScale ) override;

    bool SyncScene();
 
    void Save() override;
    void Restore() override;
    void Transform( const MATRIX3x3D& aTransformation ) override;
    void Rotate( double aAngle ) override;
    void Translate( const VECTOR2D& aTranslation ) override;
    void Scale( const VECTOR2D& aScale ) override;
 
    void SetLayerDepth( double aLayerDepth ) override;
 
    int  GetSwapInterval() const override;

    void SetRenderThread( RENDER_THREAD* aThread ) { m_renderThread = aThread; }

    void SetDpiScale( float aScale ) { m_dpiScale = aScale; }

    void SetCentringPad( int aPad ) { m_centringPad = aPad; }
 
    VECTOR2I GetLayoutPixelSize() const override
    {
        return m_screenSize + VECTOR2I( m_centringPad, m_centringPad );
    }

    static std::shared_ptr<RENDER_THREAD> AcquireRenderThread( bool aEnableValidation );

    static uint32_t AllocateWindowId();

    void DestroyBuffers();

    void ReleaseBuffers()
    {
        auto release = []( GEOMETRY_BUFFER_SET& bs )
        {
            bs.buffer.fill( {} );
            bs.capacity.fill( 0 );
 
            for( auto& bq : bs.bitmapQuads )
            {
                bq.texture      = {};
                bq.vertexBuffer = {};
            }
        };
 
        for( auto& bs : m_bufferSets )
            release( bs );
 
        for( auto& bs : m_overlaySets )
            release( bs );
 
        release( m_staticPool );
        release( m_gridPool );
 
        for( auto& [id, layer] : m_sceneLayers )
        {
            for( SCENE_ARENA<RHI_INSTANCE>& arena : layer.instances )
            {
                arena.buffer   = {};
                arena.capacity = 0;
            }
 
            layer.polygons.buffer   = {};
            layer.polygons.capacity = 0;
        }
 
        m_retiredBuffers.clear();
        m_retiredTextures.clear();
        m_bitmapTextureCache.clear();
    }
 
    void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;
    void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint,
                      double aWidth ) override;
    void DrawTrack( const VECTOR2D& aStart, const VECTOR2D& aEnd,
                    double aWidth, const COLOR4D& aColor ) override;
    void DrawPad( const VECTOR2D& aCenter, double aHalfWidth, double aHalfHeight,
                  double aCornerRadius, float aShapeType, double aRotation,
                  const COLOR4D& aColor ) override;
    void DrawSegmentChain( const std::vector<VECTOR2D>& aPointList, double aWidth ) override;
    void DrawSegmentChain( const SHAPE_LINE_CHAIN& aLineChain, double aWidth ) override;
 
    void DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
                  const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle ) override;
    void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
                         const EDA_ANGLE& aStartAngle, const EDA_ANGLE& aAngle,
                         double aWidth, double aMaxError ) override;
 
    void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) override;
    void DrawEllipse( const VECTOR2D& aCenterPoint, double aMajorRadius, double aMinorRadius,
                      const EDA_ANGLE& aRotation ) override;
    void DrawEllipseArc( const VECTOR2D& aCenterPoint, double aMajorRadius, double aMinorRadius,
                         const EDA_ANGLE& aRotation, const EDA_ANGLE& aStartAngle,
                         const EDA_ANGLE& aEndAngle ) override;
    void DrawHoleWall( const VECTOR2D& aCenterPoint, double aHoleRadius,
                       double aWallWidth ) override;
    void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;
    void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) override;
    void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) override;
    void DrawPolygon( const SHAPE_POLY_SET& aPolySet, bool aStrokeTriangulation = false ) override;
    void DrawPolygon( const SHAPE_LINE_CHAIN& aPolySet ) override;
 
    void DrawCurve( const VECTOR2D& aStartPoint, const VECTOR2D& aControlPointA,
                    const VECTOR2D& aControlPointB, const VECTOR2D& aEndPoint,
                    double aFilterValue = 0.0 ) override;
 
    void DrawBitmap( const BITMAP_BASE& aBitmap, double alphaBlend = 1.0 ) override;
 
    void DrawPolyline( const std::deque<VECTOR2D>& aPointList ) override;
    void DrawPolyline( const std::vector<VECTOR2D>& aPointList ) override;
    void DrawPolyline( const VECTOR2D aPointList[], int aListSize ) override;
    void DrawPolyline( const SHAPE_LINE_CHAIN& aLineChain ) override;
    void DrawPolylines( const std::vector<std::vector<VECTOR2D>>& aPointLists ) override;
 
    void DrawGlyph( const KIFONT::GLYPH& aGlyph, int aNth = 0, int aTotal = 1 ) override;
 
    struct BITMAP_QUAD
    {
        RHI_VERTEX        vertices[6];
        float             alpha = 1.0f;
        RHI_TextureHandle texture;
        RHI_BufferHandle  vertexBuffer;
        bool              ownsResources = true; 
        bool              ownsTexture   = true; 
        std::array<uint64_t, 2> contentHash{};
    };

    using SHAPE_INSTANCES = std::array<std::vector<RHI_INSTANCE>, RHI_INSTANCED_SHAPES>;

    static constexpr int ARENA_INSTANCE_COUNT = 2 * RHI_INSTANCED_SHAPES;
    static constexpr int ARENA_POLYGON = ARENA_INSTANCE_COUNT;
    static constexpr int ARENA_COUNT = ARENA_POLYGON + 1;
 
    static constexpr int arenaOf( int aShape, bool aNegative ) { return 2 * aShape + ( aNegative ? 1 : 0 ); }
 
    struct GAL_GROUP
    {
        SHAPE_INSTANCES          instances;
        std::vector<RHI_VERTEX>  polygonVertices;
        std::vector<BITMAP_QUAD> bitmapQuads;
        mutable std::array<uint64_t, 2> contentFingerprint{};
        mutable bool                    contentFingerprintValid = false;

        bool     negative   = false;

        bool     undimmed   = false;

        uint64_t placeSeq   = 0;

        float    baseDepth  = 0.0f;

        int      sceneLayer = -1;
        double   lodScale   = 0.0;
        bool     shown      = false;
        RETAINED_GROUP_ORDER order;
        std::optional<std::multimap<double, int>::iterator> lodEntry;

        bool     resident      = false;
        uint32_t residentIndex = 0;
        uint32_t slotStart[ARENA_COUNT] = {};
        uint32_t slotCount[ARENA_COUNT] = {};
    };

    void ReleaseRetiredBuffers( uint64_t aConsumedGeneration );

    KIGFX::FRAME_DRAW_DESC GetDrawDesc() const;

    void PopulateCursorUBO( KIGFX::FRAME_DRAW_DESC& aDesc ) const;

    void SetPersistentTargets( bool aPersistent ) { m_persistentTargets = aPersistent; }

    void MarkStaticDirty() override { m_staticDirty = true; }

    KIGFX::FRAME_DRAW_DESC GetStaticDrawDesc() const;

    KIGFX::FRAME_DRAW_DESC GetDynamicDrawDesc() const;

    bool TakeStaticChanged()
    {
        bool v = m_staticRebuiltThisFlush;
        m_staticRebuiltThisFlush = false;
        return v;
    }

    void PopulateCameraUBOs( KIGFX::FRAME_DRAW_DESC& aDesc ) const;
 
protected:
    void beginUpdate() override;
    void endUpdate() override;
 
private:
    RHI_DEVICE_PROXY& m_deviceProxy;
    RENDER_THREAD*    m_renderThread = nullptr;
 
    bool          m_rhiInitialized = false;
    bool          m_isDrawing      = false;
    bool          m_isUpdating     = false;
    RENDER_TARGET m_currentTarget  = TARGET_CACHED;
 
    int   m_screenWidth  = 0;
    int   m_screenHeight = 0;
    float m_dpiScale     = 1.0f;   
    int   m_centringPad  = 0;      
 
    bool m_negativeMode      = false;
    bool m_screenSpaceMode   = false;
    uint16_t m_strokePixelPad = 0;      
    float    m_strokeLengthPad = 0.0f;  
    double   m_strokeLod = 0.0;         
    double m_bitmapTextHeight = 0.0;    
    bool   m_bitmapGlyphs = false;      
    bool m_diffLayerActive = false;
    bool m_drawGrid        = false;
    bool m_drawCursor      = false;

    bool m_transformIsIdentity = true;

    void recomputeTransformIdentity()
    {
        const auto& m = m_currentTransform.m_data;
        m_transformIsIdentity = m[0][0] == 1.0 && m[0][1] == 0.0 && m[0][2] == 0.0
                                && m[1][0] == 0.0 && m[1][1] == 1.0 && m[1][2] == 0.0
                                && m[2][0] == 0.0 && m[2][1] == 0.0 && m[2][2] == 1.0;
    }
 
    VECTOR2D xform( const VECTOR2D& aPt ) const
    {
        return m_transformIsIdentity ? aPt : VECTOR2D( m_currentTransform * aPt );
    }
 
    double xformScale() const
    {
        return m_transformIsIdentity ? 1.0
                                     : std::sqrt( std::abs( m_currentTransform.Determinant() ) );
    }
 
    double xformAngle() const
    {
        return m_transformIsIdentity ? 0.0 : std::atan2( m_currentTransform.m_data[1][0],
                                                         m_currentTransform.m_data[0][0] );
    }

    RHI_INSTANCE makeInstance( const COLOR4D& aColor );

    void emitInstance( RHI_SHAPE aShape, const RHI_INSTANCE& aInstance )
    {
        poolForCurrentTarget().instances[aShape].push_back( aInstance );
    }

    void releaseBitmapQuads( std::vector<BITMAP_QUAD>& aQuads, bool aOwnedOnly );

    bool drawBitmapGlyphs( const wxString& aText, const VECTOR2I& aPosition, const EDA_ANGLE& aAngle );
 
    void addCapsuleInstance( const VECTOR2D& aStart, const VECTOR2D& aEnd,
                             double aWidth, const COLOR4D& aColor );

    RHI_INSTANCE& addArcInstance( const VECTOR2D& aCenter, double aRadius, double aStartAngle,
                                  double aSweepAngle, double aWidth, const COLOR4D& aColor );
 
    RHI_INSTANCE& addPadInstance( const VECTOR2D& aCenter, double aHalfWidth, double aHalfHeight,
                                  double aCornerRadius, float aShapeType, double aRotation,
                                  const COLOR4D& aColor );

    void drawEllipseShape( const SHAPE_ELLIPSE& aEllipse );

    void fillOutline( SHAPE_LINE_CHAIN aOutline, const COLOR4D& aColor );
 
    void emitTriangulatedPolygon( const SHAPE_POLY_SET& aPolySet, const COLOR4D& aColor );

    RHI_VERTEX fillVertex( const COLOR4D& aColor );

    void emitTriangle( const VECTOR2D& aA, const VECTOR2D& aB, const VECTOR2D& aC, const RHI_VERTEX& aFill );

    void strokeLineChain( const SHAPE_LINE_CHAIN& aChain );

    bool ensureBuffer( RHI_BufferHandle& aBuffer, size_t& aCapacity,
                       size_t aNeeded, size_t aStride );
 
    static constexpr int BUFFER_RING_SIZE = 2;

    struct POLARITY_MARK
    {
        bool             negative;
        int              range;     
        RHI_SHAPE_COUNTS at;        
    };
 
    struct GEOMETRY_BUFFER_SET
    {
        SHAPE_INSTANCES          instances;
        std::vector<RHI_VERTEX>  polygonVertices;
        std::vector<BITMAP_QUAD> bitmapQuads;
 
        std::vector<POLARITY_MARK> polarityMarks;
        std::vector<POLARITY_RUN>  polarityRuns;            
        bool                       drawsNegative = false;   
 
        RHI_SHAPE_COUNTS Sizes() const
        {
            RHI_SHAPE_COUNTS sizes;
 
            for( int shape = 0; shape < RHI_INSTANCED_SHAPES; ++shape )
                sizes[shape] = static_cast<uint32_t>( instances[shape].size() );
 
            sizes[RHI_SHAPE_POLYGON] = static_cast<uint32_t>( polygonVertices.size() );
            return sizes;
        }
 
        bool Empty() const
        {
            return std::ranges::all_of( Sizes(), []( uint32_t aSize ) { return aSize == 0; } )
                   && bitmapQuads.empty();
        }
 
        void ClearGeometry()
        {
            for( std::vector<RHI_INSTANCE>& shape : instances )
                shape.clear();
 
            polygonVertices.clear();
            polarityMarks.clear();
            polarityRuns.clear();
            drawsNegative = false;
            lastCount = {};
            lastNegCount = {};
        }
 
        std::array<RHI_BufferHandle, RHI_SHAPES> buffer;
        std::array<size_t, RHI_SHAPES>           capacity{};

        RHI_SHAPE_COUNTS lastCount{};
        RHI_SHAPE_COUNTS lastNegCount{};

        std::shared_ptr<const RHI_RUN_TABLE> cullRuns;
    };

    GEOMETRY_BUFFER_SET m_bufferSets[BUFFER_RING_SIZE];
    int                 m_currentBufferSet = 0;
 
    GEOMETRY_BUFFER_SET m_overlaySets[BUFFER_RING_SIZE];
    int                 m_currentOverlaySet = 0;
 
    bool m_persistentTargets = false;
    bool m_nonCachedRefilled = false;   
    bool m_overlayRefilled   = false;

    void refillDynamicTarget( RENDER_TARGET aTarget );

    bool currentTargetOpen() const
    {
        if( !m_persistentTargets || m_currentTarget == TARGET_CACHED || m_drawingGridSources )
            return true;
 
        return m_currentTarget == TARGET_OVERLAY ? m_overlayRefilled : m_nonCachedRefilled;
    }

    GEOMETRY_BUFFER_SET m_staticPool;
    bool                m_staticDirty = true;

    GEOMETRY_BUFFER_SET      m_gridPool;
    std::vector<LAYER_RANGE> m_gridLayerRanges;
    bool                     m_gridPoolRefilled = false;
    bool                     m_drawingGridSources = false;   
    std::array<uint64_t, 2>  m_gridPoolHash{};                

    void drawGridSources();
    void drawGridSource( const GRID_SOURCE& aSrc );

    double screenPixelSize() const;

    bool m_staticRebuiltThisFlush = false;

    uint64_t m_bufferGeneration = 1;
 
    std::vector<std::pair<uint64_t, RHI_BufferHandle>>  m_retiredBuffers;
    std::vector<std::pair<uint64_t, RHI_TextureHandle>> m_retiredTextures;
 
    void retireBuffer( RHI_BufferHandle aBuffer );
    void retireTexture( RHI_TextureHandle aTexture );

    struct STATIC_GROUP_SLOT
    {
        RHI_SHAPE_COUNTS start{};
        RHI_SHAPE_COUNTS count{};
    };

    std::unordered_map<int, std::vector<STATIC_GROUP_SLOT>> m_staticGroupSlots;

    struct PATCH_SPAN
    {
        uint32_t begin = UINT32_MAX;
        uint32_t end   = 0;
 
        void add( uint32_t aStart, uint32_t aCount )
        {
            if( aCount == 0 )
                return;
 
            begin = std::min( begin, aStart );
            end   = std::max( end, aStart + aCount );
        }
 
        bool empty() const { return end <= begin; }
        void clear() { begin = UINT32_MAX; end = 0; }
    };

    template <typename T>
    void submitSpan( const std::vector<T>& aElements, RHI_BufferHandle aBuffer, const PATCH_SPAN& aSpan );
 
    std::array<PATCH_SPAN, RHI_SHAPES> m_staticPatches;

    void clearStaticSlots()
    {
        m_staticGroupSlots.clear();
 
        for( PATCH_SPAN& span : m_staticPatches )
            span.clear();
    }

    template <typename INSTANCE_FN, typename VERTEX_FN>
    bool patchStaticGroup( int aGroup, INSTANCE_FN aInstance, VERTEX_FN aVertex );

    void rewriteResidentGroup( int aGroupNumber, GAL_GROUP& aGroup );

    template <typename T>
    struct SCENE_ARENA
    {
        std::vector<T>   elements;      
        RHI_BufferHandle buffer;
        size_t           capacity = 0;  
        uint32_t         dead     = 0;  

        std::unordered_map<uint32_t, std::vector<uint32_t>> freeSlots;
 
        std::vector<PATCH_SPAN> dirty;  
        bool                    uploadAll = false;
    };
 
    struct SCENE_LAYER
    {
        float depth        = 0.0f;
        bool  hasNegatives = false;
        bool  inOrder      = false;     
        bool  visible      = true;      
 
        RHI_LAYER_DIM dim;
        bool          overlayAlpha = false;   
 
        SCENE_ARENA<RHI_INSTANCE> instances[ARENA_INSTANCE_COUNT];
        SCENE_ARENA<RHI_VERTEX>   polygons;
 
        std::vector<int> residents;         
        std::vector<int> bitmapResidents;   
        std::optional<std::unordered_multimap<size_t, int>> retainedPrefixIndex;

        uint32_t alphaCount[256] = {};
        int      bakedAlpha      = -1;      
        bool     alphaStale      = false;
        bool     translucent     = false;   

        std::vector<POLARITY_RUN> runs;
        bool                      runsStale = false;
        uint32_t                  knockoutGroups = 0;   

        std::shared_ptr<const RHI_RUN_TABLE> cullRuns;

        size_t cullCounted[ARENA_COUNT] = {};
    };

    static std::shared_ptr<const RHI_RUN_TABLE> updateSceneCullRuns( SCENE_LAYER& aLayer );

    void buildSceneRuns( SCENE_LAYER& aLayer );
 
    bool gridShown() const { return m_gridVisibility && m_gridSize.x != 0 && m_gridSize.y != 0; }

    static bool sceneLayerComposited( const SCENE_LAYER& aLayer ) { return !aLayer.runs.empty(); }
 
    uint64_t m_placeSeq = 0;
    bool     m_sceneDrawOrdered = false;
 
    std::unordered_map<int, SCENE_LAYER> m_sceneLayers;      
    std::vector<int>                     m_sceneOrder;       
    std::multimap<double, int>           m_lodGroups;        
    SCENE_LAYER*                         m_openSceneLayer = nullptr;
    int                                  m_openSceneLayerId = -1;
    double                               m_sceneScale     = 1.0;
    bool                                 m_sceneChanged   = false;
    bool                                 m_sceneOrderStale = false;

    void sortSceneOrder();
    bool                                 m_negativesLayer = false;
 
    template <typename T>
    uint32_t allocSceneSlot( SCENE_ARENA<T>& aArena, uint32_t aCount );
 
    template <typename T>
    void freeSceneSlot( SCENE_ARENA<T>& aArena, uint32_t aStart, uint32_t aCount );
 
    template <typename T>
    void compactSceneArena( SCENE_LAYER& aLayer, SCENE_ARENA<T>& aArena, int aArenaId );

    template <typename T>
    bool uploadSceneArena( SCENE_ARENA<T>& aArena );
 
    void placeGroupInScene( int aGroupId, GAL_GROUP& aGroup, SCENE_LAYER& aLayer );
    void removeGroupFromScene( int aGroupId, GAL_GROUP& aGroup );

    void trackGroupLod( int aGroupId, GAL_GROUP& aGroup, bool aTrack );

    void writeGroupToScene( const GAL_GROUP& aGroup, SCENE_LAYER& aLayer );
    bool retainedTieOrderChanged( int aGroupId, GAL_GROUP& aGroup, SCENE_LAYER& aLayer );
    static std::array<uint64_t, 2> computeGroupFingerprint( const GAL_GROUP& aGroup );
 
    void countGroupAlpha( const GAL_GROUP& aGroup, SCENE_LAYER& aLayer, int aDelta );

    static void countGroupArenas( const GAL_GROUP& aGroup, uint32_t* aCounts );

    void resetScene();

    bool flushScene();
 
    void appendSceneRanges( FRAME_DRAW_DESC& aDesc ) const;
 
    GEOMETRY_BUFFER_SET&       buf()       { return m_bufferSets[m_currentBufferSet]; }
    const GEOMETRY_BUFFER_SET& buf() const { return m_bufferSets[m_currentBufferSet]; }
 
    GEOMETRY_BUFFER_SET&       obuf()       { return m_overlaySets[m_currentOverlaySet]; }
    const GEOMETRY_BUFFER_SET& obuf() const { return m_overlaySets[m_currentOverlaySet]; }

    GEOMETRY_BUFFER_SET& poolForCurrentTarget()
    {
        if( m_isDrawing && m_groupDepth == 0 && !currentTargetOpen() )
            refillDynamicTarget( m_currentTarget );
 
        if( m_drawingGridSources )
            return m_gridPool;
 
        if( m_currentTarget == TARGET_CACHED )
            return m_staticPool;
 
        return m_currentTarget == TARGET_OVERLAY ? obuf() : buf();
    }
 
    const GEOMETRY_BUFFER_SET& poolForCurrentTarget() const
    {
        if( m_drawingGridSources )
            return m_gridPool;
 
        if( m_currentTarget == TARGET_CACHED )
            return m_staticPool;
 
        return m_currentTarget == TARGET_OVERLAY ? obuf() : buf();
    }

    struct BITMAP_CACHE_ENTRY
    {
        RHI_TextureHandle texture;
        size_t            bytes   = 0; 
        uint64_t          lastUse = 0; 
        uint32_t          groupRefs = 0; 
        std::array<uint64_t, 2> contentHash{};
    };

    void countBitmapRefs( const GAL_GROUP& aGroup, int aDelta );

    bool assignSlicesByOrder( std::vector<LAYER_RANGE>& aRanges, size_t aFirst ) const;

    bool keepsRelativeDepth( const GEOMETRY_BUFFER_SET& aPool ) const
    {
        return m_persistentTargets && &aPool != &m_staticPool && &aPool != &m_gridPool;
    }

    void notePolarity( bool aNegative );
 
    bool m_groupNegative = false;   
 
    static constexpr size_t BITMAP_CACHE_MAX_ENTRIES = 64;
 
    std::unordered_map<KIID, BITMAP_CACHE_ENTRY> m_bitmapTextureCache;
    uint64_t m_bitmapUseCounter    = 0; 
    uint64_t m_bitmapFrameStartSeq = 0; 

    void evictBitmapCacheEntries();
 
    std::unordered_map<int, GAL_GROUP> m_groups;
    int   m_groupCounter   = 0;
    int   m_currentGroupId = -1;
    int   m_groupDepth     = 0;

    SHAPE_INSTANCES          m_groupScratchInstances;
    std::vector<RHI_VERTEX>  m_groupScratchPolygonVertices;
    std::vector<BITMAP_QUAD> m_groupScratchBitmapQuads;
 
    MATRIX3x3D              m_currentTransform;
    std::vector<MATRIX3x3D> m_transformStack;

    std::vector<LAYER_RANGE> m_staticLayerRanges;
    std::vector<LAYER_RANGE> m_dynamicLayerRanges;
    std::vector<LAYER_RANGE> m_overlayLayerRanges;
 
    std::vector<LAYER_RANGE>& layerRangesForCurrentTarget()
    {
        if( m_drawingGridSources )
            return m_gridLayerRanges;
 
        if( m_currentTarget == TARGET_CACHED )
            return m_staticLayerRanges;
 
        return m_currentTarget == TARGET_OVERLAY ? m_overlayLayerRanges : m_dynamicLayerRanges;
    }
 
    const std::vector<LAYER_RANGE>& layerRangesForCurrentTarget() const
    {
        if( m_drawingGridSources )
            return m_gridLayerRanges;
 
        if( m_currentTarget == TARGET_CACHED )
            return m_staticLayerRanges;
 
        return m_currentTarget == TARGET_OVERLAY ? m_overlayLayerRanges : m_dynamicLayerRanges;
    }
 
    void beginLayerRange( float aDepth );
};
 
 
} // namespace KIGFX
 
#endif // GAL_MODERN_H