blob: dcd9e3b1dda9a443f36020381f03bbf0253da01f [file] [log] [blame]
/*
* Copyright 2021 Google LLC.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/gpu/ganesh/ops/PathStencilCoverOp.h"
#include "src/gpu/ganesh/GrEagerVertexAllocator.h"
#include "src/gpu/ganesh/GrGpu.h"
#include "src/gpu/ganesh/GrOpFlushState.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "src/gpu/ganesh/GrResourceProvider.h"
#include "src/gpu/ganesh/glsl/GrGLSLFragmentShaderBuilder.h"
#include "src/gpu/ganesh/glsl/GrGLSLVarying.h"
#include "src/gpu/ganesh/glsl/GrGLSLVertexGeoBuilder.h"
#include "src/gpu/ganesh/ops/GrSimpleMeshDrawOpHelper.h"
#include "src/gpu/ganesh/tessellate/GrPathTessellationShader.h"
#include "src/gpu/tessellate/AffineMatrix.h"
#include "src/gpu/tessellate/FixedCountBufferUtils.h"
#include "src/gpu/tessellate/MiddleOutPolygonTriangulator.h"
#include "src/gpu/tessellate/Tessellation.h"
namespace {
// Fills a path's bounding box, with subpixel outset to avoid possible T-junctions with extreme
// edges of the path.
// NOTE: The emitted geometry may not be axis-aligned, depending on the view matrix.
class BoundingBoxShader : public GrGeometryProcessor {
public:
BoundingBoxShader(SkPMColor4f color, const GrShaderCaps& shaderCaps)
: GrGeometryProcessor(kTessellate_BoundingBoxShader_ClassID)
, fColor(color) {
if (!shaderCaps.fVertexIDSupport) {
constexpr static Attribute kUnitCoordAttrib("unitCoord", kFloat2_GrVertexAttribType,
SkSLType::kFloat2);
this->setVertexAttributesWithImplicitOffsets(&kUnitCoordAttrib, 1);
}
constexpr static Attribute kInstanceAttribs[] = {
{"matrix2d", kFloat4_GrVertexAttribType, SkSLType::kFloat4},
{"translate", kFloat2_GrVertexAttribType, SkSLType::kFloat2},
{"pathBounds", kFloat4_GrVertexAttribType, SkSLType::kFloat4}
};
this->setInstanceAttributesWithImplicitOffsets(kInstanceAttribs,
std::size(kInstanceAttribs));
}
private:
const char* name() const final { return "tessellate_BoundingBoxShader"; }
void addToKey(const GrShaderCaps&, skgpu::KeyBuilder*) const final {}
std::unique_ptr<ProgramImpl> makeProgramImpl(const GrShaderCaps&) const final;
const SkPMColor4f fColor;
};
std::unique_ptr<GrGeometryProcessor::ProgramImpl> BoundingBoxShader::makeProgramImpl(
const GrShaderCaps&) const {
class Impl : public ProgramImpl {
public:
void setData(const GrGLSLProgramDataManager& pdman,
const GrShaderCaps&,
const GrGeometryProcessor& gp) override {
const SkPMColor4f& color = gp.cast<BoundingBoxShader>().fColor;
pdman.set4f(fColorUniform, color.fR, color.fG, color.fB, color.fA);
}
private:
void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) final {
args.fVaryingHandler->emitAttributes(args.fGeomProc);
// Vertex shader.
if (args.fShaderCaps->fVertexIDSupport) {
// If we don't have sk_VertexID support then "unitCoord" already came in as a vertex
// attrib.
args.fVertBuilder->codeAppend(
"float2 unitCoord = float2(sk_VertexID & 1, sk_VertexID >> 1);");
}
args.fVertBuilder->codeAppend(
// Bloat the bounding box by 1/4px to be certain we will reset every stencil value.
"float2x2 M_ = inverse(float2x2(matrix2d.xy, matrix2d.zw));"
"float2 bloat = float2(abs(M_[0]) + abs(M_[1])) * .25;"
// Find the vertex position.
"float2 localcoord = mix(pathBounds.xy - bloat, pathBounds.zw + bloat, unitCoord);"
"float2 vertexpos = float2x2(matrix2d.xy, matrix2d.zw) * localcoord + translate;"
);
gpArgs->fLocalCoordVar.set(SkSLType::kFloat2, "localcoord");
gpArgs->fPositionVar.set(SkSLType::kFloat2, "vertexpos");
// Fragment shader.
const char* color;
fColorUniform = args.fUniformHandler->addUniform(nullptr, kFragment_GrShaderFlag,
SkSLType::kHalf4, "color", &color);
args.fFragBuilder->codeAppendf("half4 %s = %s;", args.fOutputColor, color);
args.fFragBuilder->codeAppendf("const half4 %s = half4(1);", args.fOutputCoverage);
}
GrGLSLUniformHandler::UniformHandle fColorUniform;
};
return std::make_unique<Impl>();
}
} // anonymous namespace
namespace skgpu::ganesh {
void PathStencilCoverOp::visitProxies(const GrVisitProxyFunc& func) const {
if (fCoverBBoxProgram) {
fCoverBBoxProgram->pipeline().visitProxies(func);
} else {
fProcessors.visitProxies(func);
}
}
GrDrawOp::FixedFunctionFlags PathStencilCoverOp::fixedFunctionFlags() const {
auto flags = FixedFunctionFlags::kUsesStencil;
if (fAAType != GrAAType::kNone) {
flags |= FixedFunctionFlags::kUsesHWAA;
}
return flags;
}
GrProcessorSet::Analysis PathStencilCoverOp::finalize(const GrCaps& caps,
const GrAppliedClip* clip,
GrClampType clampType) {
return fProcessors.finalize(fColor, GrProcessorAnalysisCoverage::kNone, clip, nullptr, caps,
clampType, &fColor);
}
void PathStencilCoverOp::prePreparePrograms(const GrTessellationShader::ProgramArgs& args,
GrAppliedClip&& appliedClip) {
SkASSERT(!fTessellator);
SkASSERT(!fStencilFanProgram);
SkASSERT(!fStencilPathProgram);
SkASSERT(!fCoverBBoxProgram);
// We transform paths on the CPU. This allows for better batching.
const SkMatrix& shaderMatrix = SkMatrix::I();
auto pipelineFlags = (fPathFlags & FillPathFlags::kWireframe)
? GrPipeline::InputFlags::kWireframe
: GrPipeline::InputFlags::kNone;
const GrPipeline* stencilPipeline = GrPathTessellationShader::MakeStencilOnlyPipeline(
args, fAAType, appliedClip.hardClip(), pipelineFlags);
const GrUserStencilSettings* stencilSettings = GrPathTessellationShader::StencilPathSettings(
GrFillRuleForPathFillType(this->pathFillType()));
if (fTotalCombinedPathVerbCnt > 50 &&
this->bounds().height() * this->bounds().width() > 256 * 256) {
// Large complex paths do better with a dedicated triangle shader for the inner fan.
// This takes less PCI bus bandwidth (6 floats per triangle instead of 8) and allows us
// to make sure it has an efficient middle-out topology.
auto shader = GrPathTessellationShader::MakeSimpleTriangleShader(args.fArena,
shaderMatrix,
SK_PMColor4fTRANSPARENT);
fStencilFanProgram = GrTessellationShader::MakeProgram(args,
shader,
stencilPipeline,
stencilSettings);
fTessellator = PathCurveTessellator::Make(args.fArena,
args.fCaps->shaderCaps()->fInfinitySupport);
} else {
fTessellator = PathWedgeTessellator::Make(args.fArena,
args.fCaps->shaderCaps()->fInfinitySupport);
}
auto* tessShader = GrPathTessellationShader::Make(*args.fCaps->shaderCaps(),
args.fArena,
shaderMatrix,
SK_PMColor4fTRANSPARENT,
fTessellator->patchAttribs());
fStencilPathProgram = GrTessellationShader::MakeProgram(args,
tessShader,
stencilPipeline,
stencilSettings);
if (!(fPathFlags & FillPathFlags::kStencilOnly)) {
// Create a program that draws a bounding box over the path and fills its stencil coverage
// into the color buffer.
auto* bboxShader = args.fArena->make<BoundingBoxShader>(fColor, *args.fCaps->shaderCaps());
auto* bboxPipeline = GrTessellationShader::MakePipeline(args, fAAType,
std::move(appliedClip),
std::move(fProcessors));
auto* bboxStencil = GrPathTessellationShader::TestAndResetStencilSettings(
SkPathFillType_IsInverse(this->pathFillType()));
fCoverBBoxProgram = GrSimpleMeshDrawOpHelper::CreateProgramInfo(
args.fCaps,
args.fArena,
bboxPipeline,
args.fWriteView,
args.fUsesMSAASurface,
bboxShader,
GrPrimitiveType::kTriangleStrip,
args.fXferBarrierFlags,
args.fColorLoadOp,
bboxStencil);
}
}
void PathStencilCoverOp::onPrePrepare(GrRecordingContext* context,
const GrSurfaceProxyView& writeView, GrAppliedClip* clip,
const GrDstProxyView& dstProxyView,
GrXferBarrierFlags renderPassXferBarriers,
GrLoadOp colorLoadOp) {
// DMSAA is not supported on DDL.
bool usesMSAASurface = writeView.asRenderTargetProxy()->numSamples() > 1;
this->prePreparePrograms({context->priv().recordTimeAllocator(), writeView, usesMSAASurface,
&dstProxyView, renderPassXferBarriers, colorLoadOp,
context->priv().caps()},
(clip) ? std::move(*clip) : GrAppliedClip::Disabled());
if (fStencilFanProgram) {
context->priv().recordProgramInfo(fStencilFanProgram);
}
if (fStencilPathProgram) {
context->priv().recordProgramInfo(fStencilPathProgram);
}
if (fCoverBBoxProgram) {
context->priv().recordProgramInfo(fCoverBBoxProgram);
}
}
SKGPU_DECLARE_STATIC_UNIQUE_KEY(gUnitQuadBufferKey);
void PathStencilCoverOp::onPrepare(GrOpFlushState* flushState) {
if (!fTessellator) {
this->prePreparePrograms({flushState->allocator(), flushState->writeView(),
flushState->usesMSAASurface(), &flushState->dstProxyView(),
flushState->renderPassBarriers(), flushState->colorLoadOp(),
&flushState->caps()}, flushState->detachAppliedClip());
if (!fTessellator) {
return;
}
}
if (fStencilFanProgram) {
// The inner fan isn't built into the tessellator. Generate a standard Redbook fan with a
// middle-out topology.
GrEagerDynamicVertexAllocator vertexAlloc(flushState, &fFanBuffer, &fFanBaseVertex);
// Path fans might have an extra edge from an implicit kClose at the end, but they also
// always begin with kMove. So the max possible number of edges in a single path is equal to
// the number of verbs. Therefore, the max number of combined fan edges in a path list is
// the number of combined verbs from the paths in the list.
// A single n-sided polygon is fanned by n-2 triangles. Multiple polygons with a combined
// edge count of n are fanned by strictly fewer triangles.
int maxTrianglesInFans = std::max(fTotalCombinedPathVerbCnt - 2, 0);
int fanTriangleCount = 0;
if (VertexWriter triangleVertexWriter =
vertexAlloc.lockWriter(sizeof(SkPoint), maxTrianglesInFans * 3)) {
for (auto [pathMatrix, path, color] : *fPathDrawList) {
tess::AffineMatrix m(pathMatrix);
for (tess::PathMiddleOutFanIter it(path); !it.done();) {
for (auto [p0, p1, p2] : it.nextStack()) {
triangleVertexWriter << m.map2Points(p0, p1) << m.mapPoint(p2);
++fanTriangleCount;
}
}
}
SkASSERT(fanTriangleCount <= maxTrianglesInFans);
fFanVertexCount = fanTriangleCount * 3;
vertexAlloc.unlock(fFanVertexCount);
}
}
auto tessShader = &fStencilPathProgram->geomProc().cast<GrPathTessellationShader>();
fTessellator->prepare(flushState,
tessShader->viewMatrix(),
*fPathDrawList,
fTotalCombinedPathVerbCnt);
if (fCoverBBoxProgram) {
size_t instanceStride = fCoverBBoxProgram->geomProc().instanceStride();
VertexWriter vertexWriter = flushState->makeVertexWriter(instanceStride,
fPathCount,
&fBBoxBuffer,
&fBBoxBaseInstance);
SkDEBUGCODE(int pathCount = 0;)
for (auto [pathMatrix, path, color] : *fPathDrawList) {
SkDEBUGCODE(auto end = vertexWriter.mark(instanceStride));
vertexWriter << pathMatrix.getScaleX()
<< pathMatrix.getSkewY()
<< pathMatrix.getSkewX()
<< pathMatrix.getScaleY()
<< pathMatrix.getTranslateX()
<< pathMatrix.getTranslateY();
if (path.isInverseFillType()) {
// Fill the entire backing store to make sure we clear every stencil value back to
// 0. If there is a scissor it will have already clipped the stencil draw.
auto rtBounds =
flushState->writeView().asRenderTargetProxy()->backingStoreBoundsRect();
SkASSERT(rtBounds == fOriginalDrawBounds);
SkRect pathSpaceRTBounds;
if (SkMatrixPriv::InverseMapRect(pathMatrix, &pathSpaceRTBounds, rtBounds)) {
vertexWriter << pathSpaceRTBounds;
} else {
vertexWriter << path.getBounds();
}
} else {
vertexWriter << path.getBounds();
}
SkASSERT(vertexWriter.mark() == end);
SkDEBUGCODE(++pathCount;)
}
SkASSERT(pathCount == fPathCount);
}
if (!flushState->caps().shaderCaps()->fVertexIDSupport) {
constexpr static SkPoint kUnitQuad[4] = {{0,0}, {0,1}, {1,0}, {1,1}};
SKGPU_DEFINE_STATIC_UNIQUE_KEY(gUnitQuadBufferKey);
fBBoxVertexBufferIfNoIDSupport = flushState->resourceProvider()->findOrMakeStaticBuffer(
GrGpuBufferType::kVertex, sizeof(kUnitQuad), kUnitQuad, gUnitQuadBufferKey);
}
}
void PathStencilCoverOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
if (!fTessellator) {
return;
}
if (fCoverBBoxProgram &&
fCoverBBoxProgram->geomProc().hasVertexAttributes() &&
!fBBoxVertexBufferIfNoIDSupport) {
return;
}
// Stencil the inner fan, if any.
if (fFanVertexCount > 0) {
SkASSERT(fStencilFanProgram);
SkASSERT(fFanBuffer);
flushState->bindPipelineAndScissorClip(*fStencilFanProgram, this->bounds());
flushState->bindBuffers(nullptr, nullptr, fFanBuffer);
flushState->draw(fFanVertexCount, fFanBaseVertex);
}
// Stencil the rest of the path.
SkASSERT(fStencilPathProgram);
flushState->bindPipelineAndScissorClip(*fStencilPathProgram, this->bounds());
fTessellator->draw(flushState);
// Fill in the bounding box (if not in stencil-only mode).
if (fCoverBBoxProgram) {
flushState->bindPipelineAndScissorClip(*fCoverBBoxProgram, this->bounds());
flushState->bindTextures(fCoverBBoxProgram->geomProc(), nullptr,
fCoverBBoxProgram->pipeline());
flushState->bindBuffers(nullptr, fBBoxBuffer, fBBoxVertexBufferIfNoIDSupport);
flushState->drawInstanced(fPathCount, fBBoxBaseInstance, 4, 0);
}
}
} // namespace skgpu::ganesh