1 /*
2 * Copyright 2024 Google LLC
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "src/gpu/graphite/render/SDFTextLCDRenderStep.h"
9
10 #include "include/core/SkM44.h"
11 #include "include/gpu/graphite/Recorder.h"
12 #include "include/private/base/SkCPUTypes.h"
13 #include "src/core/SkMaskGamma.h"
14 #include "src/gpu/graphite/AtlasProvider.h"
15 #include "src/gpu/graphite/ContextUtils.h"
16 #include "src/gpu/graphite/DrawParams.h"
17 #include "src/gpu/graphite/DrawWriter.h"
18 #include "src/gpu/graphite/PipelineData.h"
19 #include "src/gpu/graphite/RecorderPriv.h"
20 #include "src/gpu/graphite/render/CommonDepthStencilSettings.h"
21 #include "src/gpu/graphite/text/TextAtlasManager.h"
22 #include "src/sksl/SkSLString.h"
23 #include "src/text/gpu/DistanceFieldAdjustTable.h"
24 #include "src/text/gpu/SubRunContainer.h"
25 #include "src/text/gpu/VertexFiller.h"
26
27 namespace skgpu::graphite {
28
29 namespace {
30
31 // We are expecting to sample from up to 4 textures
32 constexpr int kNumSDFAtlasTextures = 4;
33
34 } // namespace
35
SDFTextLCDRenderStep()36 SDFTextLCDRenderStep::SDFTextLCDRenderStep()
37 : RenderStep("SDFTextLCDRenderStep",
38 "",
39 Flags::kPerformsShading | Flags::kHasTextures | Flags::kEmitsCoverage |
40 Flags::kLCDCoverage,
41 /*uniforms=*/{{"subRunDeviceMatrix", SkSLType::kFloat4x4},
42 {"deviceToLocal", SkSLType::kFloat4x4},
43 {"atlasSizeInv", SkSLType::kFloat2},
44 {"pixelGeometryDelta", SkSLType::kHalf2},
45 {"gammaParams", SkSLType::kHalf4}},
46 PrimitiveType::kTriangleStrip,
47 kDirectDepthGEqualPass,
48 /*vertexAttrs=*/ {},
49 /*instanceAttrs=*/
50 {{"size", VertexAttribType::kUShort2, SkSLType::kUShort2},
51 {"uvPos", VertexAttribType::kUShort2, SkSLType::kUShort2},
52 {"xyPos", VertexAttribType::kFloat2, SkSLType::kFloat2},
53 {"indexAndFlags", VertexAttribType::kUShort2, SkSLType::kUShort2},
54 {"strikeToSourceScale", VertexAttribType::kFloat, SkSLType::kFloat},
55 {"depth", VertexAttribType::kFloat, SkSLType::kFloat},
56 {"ssboIndices", VertexAttribType::kUShort2, SkSLType::kUShort2}},
57 /*varyings=*/
58 {{"unormTexCoords", SkSLType::kFloat2},
59 {"textureCoords", SkSLType::kFloat2},
60 {"texIndex", SkSLType::kFloat}}) {}
61
~SDFTextLCDRenderStep()62 SDFTextLCDRenderStep::~SDFTextLCDRenderStep() {}
63
vertexSkSL() const64 std::string SDFTextLCDRenderStep::vertexSkSL() const {
65 // Returns the body of a vertex function, which must define a float4 devPosition variable and
66 // must write to an already-defined float2 stepLocalCoords variable.
67 return "texIndex = half(indexAndFlags.x);"
68 "float4 devPosition = text_vertex_fn(float2(sk_VertexID >> 1, sk_VertexID & 1), "
69 "subRunDeviceMatrix, "
70 "deviceToLocal, "
71 "atlasSizeInv, "
72 "float2(size), "
73 "float2(uvPos), "
74 "xyPos, "
75 "strikeToSourceScale, "
76 "depth, "
77 "textureCoords, "
78 "unormTexCoords, "
79 "stepLocalCoords);";
80 }
81
texturesAndSamplersSkSL(const ResourceBindingRequirements & bindingReqs,int * nextBindingIndex) const82 std::string SDFTextLCDRenderStep::texturesAndSamplersSkSL(
83 const ResourceBindingRequirements& bindingReqs, int* nextBindingIndex) const {
84 std::string result;
85
86 for (unsigned int i = 0; i < kNumSDFAtlasTextures; ++i) {
87 result += EmitSamplerLayout(bindingReqs, nextBindingIndex);
88 SkSL::String::appendf(&result, " sampler2D sdf_atlas_%u;\n", i);
89 }
90
91 return result;
92 }
93
fragmentCoverageSkSL() const94 const char* SDFTextLCDRenderStep::fragmentCoverageSkSL() const {
95 // The returned SkSL must write its coverage into a 'half4 outputCoverage' variable (defined in
96 // the calling code) with the actual coverage splatted out into all four channels.
97
98 // TODO: To minimize the number of shaders generated this is the full affine shader.
99 // For best performance it may be worth creating the uniform scale shader as well,
100 // as that's the most common case.
101 // TODO: Need to add 565 support.
102 // TODO: Need aliased and possibly sRGB support.
103 static_assert(kNumSDFAtlasTextures == 4);
104 return "outputCoverage = sdf_text_lcd_coverage_fn(textureCoords, "
105 "pixelGeometryDelta, "
106 "gammaParams, "
107 "unormTexCoords, "
108 "texIndex, "
109 "sdf_atlas_0, "
110 "sdf_atlas_1, "
111 "sdf_atlas_2, "
112 "sdf_atlas_3);";
113 }
114
writeVertices(DrawWriter * dw,const DrawParams & params,skvx::ushort2 ssboIndices) const115 void SDFTextLCDRenderStep::writeVertices(DrawWriter* dw,
116 const DrawParams& params,
117 skvx::ushort2 ssboIndices) const {
118 const SubRunData& subRunData = params.geometry().subRunData();
119 subRunData.subRun()->vertexFiller().fillInstanceData(dw,
120 subRunData.startGlyphIndex(),
121 subRunData.glyphCount(),
122 subRunData.subRun()->instanceFlags(),
123 ssboIndices,
124 subRunData.subRun()->glyphs(),
125 params.order().depthAsFloat());
126 }
127
writeUniformsAndTextures(const DrawParams & params,PipelineDataGatherer * gatherer) const128 void SDFTextLCDRenderStep::writeUniformsAndTextures(const DrawParams& params,
129 PipelineDataGatherer* gatherer) const {
130 SkDEBUGCODE(UniformExpectationsValidator uev(gatherer, this->uniforms());)
131
132 const SubRunData& subRunData = params.geometry().subRunData();
133 unsigned int numProxies;
134 Recorder* recorder = subRunData.recorder();
135 const sk_sp<TextureProxy>* proxies =
136 recorder->priv().atlasProvider()->textAtlasManager()->getProxies(
137 subRunData.subRun()->maskFormat(), &numProxies);
138 SkASSERT(proxies && numProxies > 0);
139
140 // write uniforms
141 gatherer->write(params.transform().matrix()); // subRunDeviceMatrix
142 gatherer->write(subRunData.deviceToLocal());
143 SkV2 atlasDimensionsInverse = {1.f/proxies[0]->dimensions().width(),
144 1.f/proxies[0]->dimensions().height()};
145 gatherer->write(atlasDimensionsInverse);
146
147 // compute and write pixelGeometry vector
148 SkV2 pixelGeometryDelta = {0, 0};
149 if (SkPixelGeometryIsH(subRunData.pixelGeometry())) {
150 pixelGeometryDelta = {1.f/(3*proxies[0]->dimensions().width()), 0};
151 } else if (SkPixelGeometryIsV(subRunData.pixelGeometry())) {
152 pixelGeometryDelta = {0, 1.f/(3*proxies[0]->dimensions().height())};
153 }
154 if (SkPixelGeometryIsBGR(subRunData.pixelGeometry())) {
155 pixelGeometryDelta = -pixelGeometryDelta;
156 }
157 gatherer->writeHalf(pixelGeometryDelta);
158
159 // compute and write gamma adjustment
160 auto dfAdjustTable = sktext::gpu::DistanceFieldAdjustTable::Get();
161 float redCorrection = dfAdjustTable->getAdjustment(SkColorGetR(subRunData.luminanceColor()),
162 subRunData.useGammaCorrectDistanceTable());
163 float greenCorrection = dfAdjustTable->getAdjustment(SkColorGetG(subRunData.luminanceColor()),
164 subRunData.useGammaCorrectDistanceTable());
165 float blueCorrection = dfAdjustTable->getAdjustment(SkColorGetB(subRunData.luminanceColor()),
166 subRunData.useGammaCorrectDistanceTable());
167 SkV4 gammaParams = {redCorrection, greenCorrection, blueCorrection,
168 subRunData.useGammaCorrectDistanceTable() ? 1.f : 0.f};
169 gatherer->writeHalf(gammaParams);
170
171 // write textures and samplers
172 const SkSamplingOptions kSamplingOptions(SkFilterMode::kLinear);
173 constexpr SkTileMode kTileModes[2] = { SkTileMode::kClamp, SkTileMode::kClamp };
174 for (unsigned int i = 0; i < numProxies; ++i) {
175 gatherer->add(kSamplingOptions, kTileModes, proxies[i]);
176 }
177 // If the atlas has less than 4 active proxies we still need to set up samplers for the shader.
178 for (unsigned int i = numProxies; i < kNumSDFAtlasTextures; ++i) {
179 gatherer->add(kSamplingOptions, kTileModes, proxies[0]);
180 }
181 }
182
183 } // namespace skgpu::graphite
184