blob: e87b696e71766187941a9a6e0acf66530bf7d079 [file] [log] [blame]
/*
* Copyright 2022 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef skgpu_graphite_RendererProvider_DEFINED
#define skgpu_graphite_RendererProvider_DEFINED
#include "include/core/SkPathTypes.h"
#include "include/core/SkVertices.h"
#include "src/gpu/graphite/Renderer.h"
#include <vector>
namespace skgpu::graphite {
class Caps;
class StaticBufferManager;
#ifdef SK_ENABLE_VELLO_SHADERS
class VelloRenderer;
#endif
/**
* Graphite defines a limited set of renderers in order to increase the likelihood of batching
* across draw calls, and reducing the number of shader permutations required. These Renderers are
* stateless singletons and remain alive for the life of the Context and its Recorders.
*
* Because Renderers are immutable and the defined Renderers are created at context initialization,
* RendererProvider is trivially thread-safe.
*/
class RendererProvider {
public:
static bool IsVelloRendererSupported(const Caps*);
~RendererProvider();
// TODO: Add configuration options to disable "optimization" renderers in favor of the more
// general case, or renderers that won't be used by the application. When that's added, these
// functions could return null.
// Path rendering for fills and strokes
const Renderer* stencilTessellatedCurvesAndTris(SkPathFillType type) const {
return &fStencilTessellatedCurves[(int) type];
}
const Renderer* stencilTessellatedWedges(SkPathFillType type) const {
return &fStencilTessellatedWedges[(int) type];
}
const Renderer* convexTessellatedWedges() const { return &fConvexTessellatedWedges; }
const Renderer* tessellatedStrokes() const { return &fTessellatedStrokes; }
// Coverage mask rendering
const Renderer* coverageMask() const { return &fCoverageMask; }
// Atlas'ed text rendering
const Renderer* bitmapText(bool useLCDText) const { return &fBitmapText[useLCDText]; }
const Renderer* sdfText(bool useLCDText) const { return &fSDFText[useLCDText]; }
// Mesh rendering
const Renderer* vertices(SkVertices::VertexMode mode, bool hasColors, bool hasTexCoords) const {
SkASSERT(mode != SkVertices::kTriangleFan_VertexMode); // Should be converted to kTriangles
bool triStrip = mode == SkVertices::kTriangleStrip_VertexMode;
return &fVertices[4*triStrip + 2*hasColors + hasTexCoords];
}
// Filled and stroked [r]rects
const Renderer* analyticRRect() const { return &fAnalyticRRect; }
// Per-edge AA quadrilaterals
const Renderer* perEdgeAAQuad() const { return &fPerEdgeAAQuad; }
const Renderer* analyticBlur() const { return &fAnalyticBlur; }
// TODO: May need to add support for inverse filled strokes (need to check SVG spec if this is a
// real thing).
// Iterate over all available Renderers to combine with specified paint combinations when
// pre-compiling pipelines.
SkSpan<const Renderer* const> renderers() const {
return {fRenderers.data(), fRenderers.size()};
}
const RenderStep* lookup(uint32_t uniqueID) const;
#ifdef SK_ENABLE_VELLO_SHADERS
// Compute shader-based path renderer and compositor.
const VelloRenderer* velloRenderer() const { return fVelloRenderer.get(); }
#endif
private:
static constexpr int kPathTypeCount = 4;
static constexpr int kVerticesCount = 8; // 2 modes * 2 color configs * 2 tex coord configs
friend class Context; // for ctor
// TODO: Take in caps that determines which Renderers to use for each category
RendererProvider(const Caps*, StaticBufferManager* bufferManager);
// Cannot be moved or copied
RendererProvider(const RendererProvider&) = delete;
RendererProvider(RendererProvider&&) = delete;
// Renderers are composed of 1+ steps, and some steps can be shared by multiple Renderers.
// Renderers don't keep their RenderSteps alive so RendererProvider holds them here.
std::vector<std::unique_ptr<RenderStep>> fRenderSteps;
// NOTE: Keep all Renderers dense to support automatically completing 'fRenderers'.
Renderer fStencilTessellatedCurves[kPathTypeCount];
Renderer fStencilTessellatedWedges[kPathTypeCount];
Renderer fConvexTessellatedWedges;
Renderer fTessellatedStrokes;
Renderer fCoverageMask;
Renderer fBitmapText[2]; // bool isLCD
Renderer fSDFText[2]; // bool isLCD
Renderer fAnalyticRRect;
Renderer fPerEdgeAAQuad;
Renderer fAnalyticBlur;
Renderer fVertices[kVerticesCount];
// Aggregate of all enabled Renderers for convenient iteration when pre-compiling
std::vector<const Renderer*> fRenderers;
#ifdef SK_ENABLE_VELLO_SHADERS
std::unique_ptr<VelloRenderer> fVelloRenderer;
#endif
};
} // namespace skgpu::graphite
#endif // skgpu_graphite_RendererProvider_DEFINED