blob: f4418eb7b6969736d06feaea3049b2e1c227bd05 [file] [log] [blame]
/*
* Copyright 2023 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/graphite/render/CoverageMaskRenderStep.h"
#include "src/gpu/graphite/ContextUtils.h"
#include "src/gpu/graphite/DrawParams.h"
#include "src/gpu/graphite/DrawWriter.h"
#include "src/gpu/graphite/PathAtlas.h"
#include "src/gpu/graphite/geom/CoverageMaskShape.h"
#include "src/gpu/graphite/render/CommonDepthStencilSettings.h"
namespace skgpu::graphite {
// The device origin is applied *before* the maskToDeviceRemainder matrix so that it can be
// combined with the mask atlas origin. This is necessary so that the mask bounds can be inset or
// outset for clamping w/o affecting the alignment of the mask sampling.
static skvx::float2 get_device_translation(const SkM44& localToDevice) {
float m00 = localToDevice.rc(0,0), m01 = localToDevice.rc(0,1);
float m10 = localToDevice.rc(1,0), m11 = localToDevice.rc(1,1);
float det = m00*m11 - m01*m10;
if (SkScalarNearlyZero(det)) {
// We can't extract any pre-translation, since the upper 2x2 is not invertible. Return (0,0)
// so that the maskToDeviceRemainder matrix remains the full transform.
return {0.f, 0.f};
}
// Calculate inv([[m00,m01][m10,m11]])*[[m30][m31]] to get the pre-remainder device translation.
float tx = localToDevice.rc(0,3), ty = localToDevice.rc(1,3);
skvx::float4 invT = skvx::float4{m11, -m10, -m01, m00} * skvx::float4{tx,tx,ty,ty};
return (invT.xy() + invT.zw()) / det;
}
CoverageMaskRenderStep::CoverageMaskRenderStep()
: RenderStep("CoverageMaskRenderStep",
"",
// The mask will have AA outsets baked in, but the original bounds for clipping
// still require the outset for analytic coverage.
Flags::kPerformsShading | Flags::kHasTextures | Flags::kEmitsCoverage |
Flags::kOutsetBoundsForAA,
/*uniforms=*/{{"maskToDeviceRemainder", SkSLType::kFloat3x3}},
PrimitiveType::kTriangleStrip,
kDirectDepthGreaterPass,
/*vertexAttrs=*/{},
/*instanceAttrs=*/
// Draw bounds and mask bounds are in normalized relative to the mask texture,
// but 'drawBounds' is stored in float since the coords may map outside of
// [0,1] for inverse-filled masks. 'drawBounds' is relative to the logical mask
// entry's origin, while 'maskBoundsIn' is atlas-relative. Inverse fills swap
// the order in 'maskBoundsIn' to be RBLT.
{{"drawBounds", VertexAttribType::kFloat4 , SkSLType::kFloat4}, // ltrb
{"maskBoundsIn", VertexAttribType::kUShort4_norm, SkSLType::kFloat4},
// Remaining translation extracted from actual 'maskToDevice' transform.
{"deviceOrigin", VertexAttribType::kFloat2, SkSLType::kFloat2},
{"depth" , VertexAttribType::kFloat, SkSLType::kFloat},
{"ssboIndices", VertexAttribType::kUShort2, SkSLType::kUShort2},
// deviceToLocal matrix for producing local coords for shader evaluation
{"mat0", VertexAttribType::kFloat3, SkSLType::kFloat3},
{"mat1", VertexAttribType::kFloat3, SkSLType::kFloat3},
{"mat2", VertexAttribType::kFloat3, SkSLType::kFloat3}},
/*varyings=*/
{// `maskBounds` are the atlas-relative, sorted bounds of the coverage mask.
// `textureCoords` are the atlas-relative UV coordinates of the draw, which
// can spill beyond `maskBounds` for inverse fills.
// TODO: maskBounds is constant for all fragments for a given instance,
// could we store them in the draw's SSBO?
{"maskBounds" , SkSLType::kFloat4},
{"textureCoords", SkSLType::kFloat2},
// 'invert' is set to 0 use unmodified coverage, and set to 1 for "1-c".
{"invert", SkSLType::kHalf}}) {}
std::string CoverageMaskRenderStep::vertexSkSL() const {
// Returns the body of a vertex function, which must define a float4 devPosition variable and
// must write to an already-defined float2 stepLocalCoords variable.
return "float4 devPosition = coverage_mask_vertex_fn("
"float2(sk_VertexID >> 1, sk_VertexID & 1), "
"maskToDeviceRemainder, drawBounds, maskBoundsIn, deviceOrigin, "
"depth, float3x3(mat0, mat1, mat2), "
"maskBounds, textureCoords, invert, stepLocalCoords);\n";
}
std::string CoverageMaskRenderStep::texturesAndSamplersSkSL(
const ResourceBindingRequirements& bindingReqs, int* nextBindingIndex) const {
return EmitSamplerLayout(bindingReqs, nextBindingIndex) + " sampler2D pathAtlas;";
}
const char* CoverageMaskRenderStep::fragmentCoverageSkSL() const {
return R"(
half c = sample(pathAtlas, clamp(textureCoords, maskBounds.LT, maskBounds.RB)).r;
outputCoverage = half4(mix(c, 1 - c, invert));
)";
}
void CoverageMaskRenderStep::writeVertices(DrawWriter* dw,
const DrawParams& params,
skvx::ushort2 ssboIndices) const {
const CoverageMaskShape& coverageMask = params.geometry().coverageMaskShape();
const TextureProxy* proxy = coverageMask.textureProxy();
SkASSERT(proxy);
// A quad is a 4-vertex instance. The coordinates are derived from the vertex IDs.
DrawWriter::Instances instances(*dw, {}, {}, 4);
// The device origin is the translation extracted from the mask-to-device matrix so
// that the remaining matrix uniform has less variance between draws.
const auto& maskToDevice = params.transform().matrix();
skvx::float2 deviceOrigin = get_device_translation(maskToDevice);
// Relative to mask space (device origin and mask-to-device remainder must be applied in shader)
skvx::float4 maskBounds = coverageMask.bounds().ltrb();
skvx::float4 drawBounds;
if (coverageMask.inverted()) {
// Only mask filters trigger complex transforms, and they are never inverse filled. Since
// we know this is an inverted mask, then we can exactly map the draw's clip bounds to mask
// space so that the clip is still fully covered without branching in the vertex shader.
SkASSERT(maskToDevice == SkM44::Translate(deviceOrigin.x(), deviceOrigin.y()));
drawBounds = params.clip().drawBounds().makeOffset(-deviceOrigin).ltrb();
// If the mask is fully clipped out, then the shape's mask info should be (0,0,0,0).
// If it's not fully clipped out, then the mask info should be non-empty.
SkASSERT(!params.clip().transformedShapeBounds().isEmptyNegativeOrNaN() ^
all(maskBounds == 0.f));
if (params.clip().transformedShapeBounds().isEmptyNegativeOrNaN()) {
// The inversion check is strict inequality, so (0,0,0,0) would not be detected. Adjust
// to (0,0,1/2,1/2) to restrict sampling to the top-left quarter of the top-left pixel,
// which should have a value of 0 regardless of filtering mode.
maskBounds = skvx::float4{0.f, 0.f, 0.5f, 0.5f};
} else {
// Add 1/2px outset to the mask bounds so that clamped coordinates sample the texel
// center of the padding around the atlas entry.
maskBounds += skvx::float4{-0.5f, -0.5f, 0.5f, 0.5f};
}
// and store RBLT so that the 'maskBoundsIn' attribute has xy > zw to detect inverse fill.
maskBounds = skvx::shuffle<2,3,0,1>(maskBounds);
} else {
// If we aren't inverted, then the originally assigned values don't need to be adjusted, but
// also ensure the mask isn't empty (otherwise the draw should have been skipped earlier).
SkASSERT(!coverageMask.bounds().isEmptyNegativeOrNaN());
SkASSERT(all(maskBounds.xy() < maskBounds.zw()));
// Since the mask bounds and draw bounds are 1-to-1 with each other, the clamping of texture
// coords is mostly a formality. We inset the mask bounds by 1/2px so that we clamp to the
// texel center of the outer row/column of the mask. This should be a no-op for nearest
// sampling but prevents any linear sampling from incorporating adjacent data; for atlases
// this would just be 0 but for non-atlas coverage masks that might not have padding this
// avoids filtering unknown values in an approx-fit texture.
drawBounds = maskBounds;
maskBounds -= skvx::float4{-0.5f, -0.5f, 0.5f, 0.5f};
}
// Move 'drawBounds' and 'maskBounds' into the atlas coordinate space, then adjust the
// device translation to undo the atlas origin automatically in the vertex shader.
skvx::float2 textureOrigin = skvx::cast<float>(coverageMask.textureOrigin());
maskBounds += textureOrigin.xyxy();
drawBounds += textureOrigin.xyxy();
deviceOrigin -= textureOrigin;
// Normalize drawBounds and maskBounds after possibly correcting drawBounds for inverse fills.
// The maskToDevice matrix uniform will handle de-normalizing drawBounds for vertex positions.
auto atlasSizeInv = skvx::float2{1.f / proxy->dimensions().width(),
1.f / proxy->dimensions().height()};
drawBounds *= atlasSizeInv.xyxy();
maskBounds *= atlasSizeInv.xyxy();
deviceOrigin *= atlasSizeInv;
// Since the mask bounds define normalized texels of the texture, we can encode them as
// ushort_norm without losing precision to save space.
SkASSERT(all((maskBounds >= 0.f) & (maskBounds <= 1.f)));
maskBounds = 65535.f * maskBounds + 0.5f;
const SkM44& m = coverageMask.deviceToLocal();
instances.append(1) << drawBounds << skvx::cast<uint16_t>(maskBounds) << deviceOrigin
<< params.order().depthAsFloat() << ssboIndices
<< m.rc(0,0) << m.rc(1,0) << m.rc(3,0) // mat0
<< m.rc(0,1) << m.rc(1,1) << m.rc(3,1) // mat1
<< m.rc(0,3) << m.rc(1,3) << m.rc(3,3); // mat2
}
void CoverageMaskRenderStep::writeUniformsAndTextures(const DrawParams& params,
PipelineDataGatherer* gatherer) const {
SkDEBUGCODE(UniformExpectationsValidator uev(gatherer, this->uniforms());)
const CoverageMaskShape& coverageMask = params.geometry().coverageMaskShape();
const TextureProxy* proxy = coverageMask.textureProxy();
SkASSERT(proxy);
// Most coverage masks are aligned with the device pixels, so the params' transform is an
// integer translation matrix. This translation is extracted as an instance attribute so that
// the remaining transform has a much lower frequency of changing (only complex-transformed
// mask filters).
skvx::float2 deviceOrigin = get_device_translation(params.transform().matrix());
SkMatrix maskToDevice = params.transform().matrix().asM33();
maskToDevice.preTranslate(-deviceOrigin.x(), -deviceOrigin.y());
// The mask coordinates in the vertex shader will be normalized, so scale by the proxy size
// to get back to Skia's texel-based coords.
maskToDevice.preScale(proxy->dimensions().width(), proxy->dimensions().height());
// Write uniforms:
gatherer->write(maskToDevice);
// Write textures and samplers:
const bool pixelAligned =
params.transform().type() <= Transform::Type::kSimpleRectStaysRect &&
params.transform().maxScaleFactor() == 1.f &&
all(deviceOrigin == floor(deviceOrigin + SK_ScalarNearlyZero));
constexpr SkTileMode kTileModes[2] = {SkTileMode::kClamp, SkTileMode::kClamp};
gatherer->add(pixelAligned ? SkFilterMode::kNearest : SkFilterMode::kLinear,
kTileModes, sk_ref_sp(proxy));
}
} // namespace skgpu::graphite