rhi_gal_pipelines.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_GAL_PIPELINES_H
#define RHI_GAL_PIPELINES_H
 
#include <rhi/rhi_handle.h>
#include <rhi/rhi_bind_group.h>
#include <rhi/layer_draw_plan.h>
 
#include <array>
 
class RHI_DEVICE;
struct RHI_SHADER_BLOB;
 

class RHI_GAL_PIPELINES
{
public:
    explicit RHI_GAL_PIPELINES( RHI_DEVICE& aDevice );
    ~RHI_GAL_PIPELINES();
 
    RHI_GAL_PIPELINES( const RHI_GAL_PIPELINES& ) = delete;
    RHI_GAL_PIPELINES& operator=( const RHI_GAL_PIPELINES& ) = delete;

    bool Initialize();

    void Destroy();
 
    bool IsInitialized() const { return m_initialized; }

    RHI_PipelineHandle GetShapePipeline( KIGFX::RHI_SHAPE aShape, KIGFX::LAYER_DRAW_MODE aMode ) const
    {
        return m_shapePipelines[aShape][static_cast<int>( aMode )];
    }
 
    RHI_PipelineHandle GetWirePipeline() const { return m_wirePipeline; }
    RHI_PipelineHandle GetWireOncePipeline() const { return m_wireOncePipeline; }
    RHI_PipelineHandle GetGridPipeline() const { return m_gridPipeline; }

    RHI_PipelineHandle GetCursorCompositePipeline() const { return m_cursorCompositePipeline; }
    RHI_PipelineHandle GetCompositorPipeline() const { return m_compositorPipeline; }
    RHI_PipelineHandle GetInlineCompositorPipeline() const { return m_inlineCompositorPipeline; }

    RHI_PipelineHandle        GetDifferencePipeline() const { return m_differencePipeline; }
    RHI_BindGroupLayoutHandle GetDifferenceLayout() const { return m_differenceLayout; }
 
    RHI_PipelineHandle GetBitmapPipeline() const { return m_bitmapPipeline; }

    RHI_PipelineHandle GetOverlayVariant( RHI_PipelineHandle aPipeline ) const;

    RHI_PipelineHandle GetPremultipliedVariant( RHI_PipelineHandle aPipeline ) const;

    RHI_BindGroupLayoutHandle GetGlyphLayout() const { return m_glyphLayout; }

    bool UsesGlyphAtlas( RHI_PipelineHandle aPipeline ) const;
 
    RHI_BindGroupLayoutHandle GetFrameUBOLayout() const { return m_frameUBOLayout; }
    RHI_BindGroupLayoutHandle GetFullscreenUBOLayout() const { return m_fullscreenUBOLayout; }
    RHI_BindGroupLayoutHandle GetTextureSamplerLayout() const { return m_textureSamplerLayout; }
 
private:
    struct ShaderPair
    {
        RHI_ShaderHandle vert;
        RHI_ShaderHandle frag;
    };
 
    ShaderPair loadShaderPair( const RHI_SHADER_BLOB& aVert, const RHI_SHADER_BLOB& aFrag );

    RHI_PipelineHandle createInstancedPipeline( const ShaderPair& aShaders,
                                                bool aNegativeBlend = false,
                                                bool aHasInstanceBinding = true,
                                                bool aSingleCoverage = false,
                                                bool aKnockoutMark = false,
                                                bool aSquareAlpha = false,
                                                bool aPremultiplied = false );
    RHI_PipelineHandle createFullscreenPipeline(
        const ShaderPair& aShaders, bool aBlendEnabled,
        const std::vector<RHI_BIND_GROUP_LAYOUT_DESC>& aBindGroupLayouts = {},
        bool aPremultipliedAlpha = false,
        bool aRenderPassHasDepthStencil = false,
        bool aSquareAlpha = false );
 
    RHI_DEVICE& m_device;
    bool        m_initialized = false;
 
    RHI_BindGroupLayoutHandle  m_frameUBOLayout;
    RHI_BIND_GROUP_LAYOUT_DESC m_frameUBOLayoutDesc;
 
    RHI_BindGroupLayoutHandle  m_glyphLayout;
    RHI_BIND_GROUP_LAYOUT_DESC m_glyphLayoutDesc;
    std::vector<RHI_PipelineHandle> m_glyphPipelines;
 
    RHI_BindGroupLayoutHandle  m_fullscreenUBOLayout;
    RHI_BindGroupLayoutHandle  m_textureSamplerLayout;
    RHI_BindGroupLayoutHandle  m_differenceLayout;
 
    static constexpr int DRAW_MODES = static_cast<int>( KIGFX::LAYER_DRAW_MODE::MARK ) + 1;
 
    std::array<std::array<RHI_PipelineHandle, DRAW_MODES>, KIGFX::RHI_SHAPES> m_shapePipelines;
 
    RHI_PipelineHandle m_wirePipeline;
    RHI_PipelineHandle m_wireOncePipeline;
    RHI_PipelineHandle m_gridPipeline;
    RHI_PipelineHandle m_cursorCompositePipeline;
    RHI_PipelineHandle m_compositorPipeline;
    RHI_PipelineHandle m_inlineCompositorPipeline;
    RHI_PipelineHandle m_differencePipeline;
    RHI_PipelineHandle m_bitmapPipeline;

    std::vector<ShaderPair> m_shaderPairs;

    std::vector<std::pair<RHI_PipelineHandle, RHI_PipelineHandle>> m_overlayVariants;
    std::vector<std::pair<RHI_PipelineHandle, RHI_PipelineHandle>> m_premultipliedVariants;
};
 
 
#endif // RHI_GAL_PIPELINES_H