frame_packet.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 RHI_FRAME_PACKET_H
#define RHI_FRAME_PACKET_H
 
#include <rhi/rhi_handle.h>
#include <gal/definitions.h>
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <vector>
 
 
namespace KIGFX
{
 
enum class RHI_LINE_PIPELINE_KIND : uint8_t
{
    PCB_TRACKS,
    SCH_WIRES
};

enum RHI_SHAPE : uint8_t
{
    RHI_SHAPE_TRACK,
    RHI_SHAPE_ARC,
    RHI_SHAPE_PAD,
    RHI_SHAPE_POLYGON
};
 
constexpr int RHI_INSTANCED_SHAPES = RHI_SHAPE_POLYGON;
constexpr int RHI_SHAPES = RHI_SHAPE_POLYGON + 1;

using RHI_SHAPE_COUNTS = std::array<uint32_t, RHI_SHAPES>;

struct alignas( 16 ) GRID_UBO_DATA
{
    float invProjection[16] = {};
    float viewport[2]       = {};
    float gridOrigin[2]     = {};
    float gridSpacing[2]    = {};   
    float gridAngle         = 0.0f;
    int   gridStyle         = 0;    
    float gridColor[4]      = {};
    float axisColorX[4]     = {};
    float axisColorY[4]     = {};
    float minorLineWidth    = 1.0f; 
    float majorLineWorld    = 2.0f; 
    int   gridTick          = 10;   
    float renderScale       = 1.0f; 
    float worldPixelSize    = 1.0f; 
    float _pad0[3]          = {};
 
    bool operator==( const GRID_UBO_DATA& aOther ) const = default;
};
 

struct alignas( 16 ) CURSOR_UBO_DATA
{
    float cursorPos[2]      = {};   
    float viewport[2]       = {};
    float crosshairColor[4] = {};
    float snapColor[4]      = {};
    float crosshairWidth    = 1.0f;
    float snapRadius        = 5.0f;
    int   showSnap          = 0;
    int   cursorType        = 1;    
    float cursorSize        = 80.0f; 
    float _pad0[3]          = {};
};
 

struct alignas( 16 ) FRAME_UBO_DATA
{
    float projection[16] = {};   
    float viewport[2]    = {};
    float viewScale      = 0.0f; 
    float renderScale    = 1.0f; 
 
    bool operator==( const FRAME_UBO_DATA& aOther ) const = default;
};
 

struct BITMAP_DRAW_DESC
{
    RHI_BufferHandle  vertexBuffer;
    RHI_TextureHandle texture;
    uint32_t          vertexCount = 6;
};
 

struct POLARITY_RUN
{
    bool             negative = false;
    RHI_SHAPE_COUNTS start{};
    RHI_SHAPE_COUNTS count{};
 
    bool Empty() const
    {
        return std::ranges::all_of( count, []( uint32_t aCount ) { return aCount == 0; } );
    }
};
 

struct RHI_LAYER_DIM
{
    float toward[3] = { 0.0f, 0.0f, 0.0f };
    float keep      = 1.0f;     
 
    bool operator==( const RHI_LAYER_DIM& aOther ) const = default;
};
 
static_assert( sizeof( RHI_LAYER_DIM ) == 16, "RHI_LAYER_DIM is one vec4 of push constants" );
 
 
struct RHI_RUN_TABLE;
 

struct LAYER_RANGE
{
    float    depth = 0.0f;

    float    alpha = 1.0f;

    bool     hasNegatives = false;

    RENDER_TARGET target = TARGET_CACHED;

    RHI_SHAPE_COUNTS start{};
    RHI_SHAPE_COUNTS count{};
    RHI_SHAPE_COUNTS negStart{};
    RHI_SHAPE_COUNTS negCount{};
 
    uint32_t bitmapStart = 0;
    uint32_t bitmapCount = 0;

    std::array<RHI_BufferHandle, RHI_SHAPES> buffer;
    std::array<RHI_BufferHandle, RHI_SHAPES> negBuffer;

    float depthNear = 0.0f;
    float depthFar  = 1.0f;

    bool singleCoverage = false;
    bool depthKnockout  = false;

    bool overlayAlpha = false;

    bool difference = false;
 
    RHI_LAYER_DIM dim;

    uint32_t runStart = 0;
    uint32_t runCount = 0;

    std::shared_ptr<const RHI_RUN_TABLE> cullRuns;
 
    bool NeedsTempFBO() const { return alpha < 1.0f || ( hasNegatives && !depthKnockout ) || difference; }
 
    bool HasGeometry() const
    {
        for( int shape = 0; shape < RHI_SHAPES; ++shape )
        {
            if( count[shape] > 0 || negCount[shape] > 0 )
                return true;
        }
 
        return bitmapCount > 0;
    }
};
 

struct FRAME_DRAW_DESC
{
    RHI_LINE_PIPELINE_KIND linePipelineKind = RHI_LINE_PIPELINE_KIND::PCB_TRACKS;

    std::array<RHI_BufferHandle, RHI_SHAPES> buffer;
    RHI_SHAPE_COUNTS                         count{};
    RHI_SHAPE_COUNTS                         negCount{};
 
    std::vector<BITMAP_DRAW_DESC> bitmapDraws;
    std::vector<LAYER_RANGE>      layerRanges;
    std::vector<POLARITY_RUN>     polarityRuns;
 
    bool drawGrid        = false;
    bool drawCursor      = false;
    bool reuseStaticFBO  = false;
    bool reuseDynamicFBO = false;

    bool gridFirst = false;

    bool relativeDepth = false;

    bool testAgainstStatic = false;

    static constexpr float RELATIVE_DEPTH_RANGE = 16.0f;

    uint32_t supersampleFactor = 1;

    uint64_t bufferGeneration = 0;
 
    float backgroundColor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
 
    FRAME_UBO_DATA  frameUBO;
    GRID_UBO_DATA   gridUBO;
    CURSOR_UBO_DATA cursorUBO;
 
    bool HasGeometry() const
    {
        return std::ranges::any_of( count, []( uint32_t aCount ) { return aCount > 0; } ) || !bitmapDraws.empty();
    }
};
 

struct FRAME_PACKET
{
    FRAME_DRAW_DESC drawDesc;

    FRAME_DRAW_DESC staticDrawDesc;
    FRAME_DRAW_DESC dynamicDrawDesc;
    bool            staticChanged  = true;
    bool            dynamicChanged = true;

    uint64_t staticEpoch  = 0;
    uint64_t dynamicEpoch = 0;

    uint64_t bufferGeneration = 0;

    uint64_t inputSerial = 0;
};
 
 
} // namespace KIGFX
 
 
#endif // RHI_FRAME_PACKET_H