1/*
2 * Copyright 2020 Google Inc.
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/text/GrSDFTOptions.h"
9
10#include "include/core/SkFont.h"
11#include "include/core/SkMatrix.h"
12#include "include/core/SkPaint.h"
13#include "include/core/SkScalar.h"
14#include "include/core/SkSurfaceProps.h"
15
16#include <tuple>
17
18// DF sizes and thresholds for usage of the small and medium sizes. For example, above
19// kSmallDFFontLimit we will use the medium size. The large size is used up until the size at
20// which we switch over to drawing as paths as controlled by Options.
21static const int kSmallDFFontSize = 32;
22static const int kSmallDFFontLimit = 32;
23static const int kMediumDFFontSize = 72;
24static const int kMediumDFFontLimit = 72;
25static const int kLargeDFFontSize = 162;
26#ifdef SK_BUILD_FOR_MAC
27static const int kLargeDFFontLimit = 162;
28static const int kExtraLargeDFFontSize = 256;
29#endif
30
31GrSDFTOptions::GrSDFTOptions(SkScalar min, SkScalar max)
32 : fMinDistanceFieldFontSize{min}
33 , fMaxDistanceFieldFontSize{max} {
34 SkASSERT_RELEASE(min > 0 && max >= min);
35}
36
37bool GrSDFTOptions::canDrawAsDistanceFields(const SkPaint& paint, const SkFont& font,
38 const SkMatrix& viewMatrix,
39 const SkSurfaceProps& props,
40 bool contextSupportsDistanceFieldText) const {
41 // mask filters modify alpha, which doesn't translate well to distance
42 if (paint.getMaskFilter() || !contextSupportsDistanceFieldText) {
43 return false;
44 }
45
46 // TODO: add some stroking support
47 if (paint.getStyle() != SkPaint::kFill_Style) {
48 return false;
49 }
50
51 if (viewMatrix.hasPerspective()) {
52 // Don't use SDF for perspective. Paths look better.
53 return false;
54 } else {
55 SkScalar maxScale = viewMatrix.getMaxScale();
56 SkScalar scaledTextSize = maxScale * font.getSize();
57 // Hinted text looks far better at small resolutions
58 // Scaling up beyond 2x yields undesirable artifacts
59 if (scaledTextSize < fMinDistanceFieldFontSize ||
60 scaledTextSize > fMaxDistanceFieldFontSize) {
61 return false;
62 }
63
64 bool useDFT = props.isUseDeviceIndependentFonts();
65#if SK_FORCE_DISTANCE_FIELD_TEXT
66 useDFT = true;
67#endif
68
69 if (!useDFT && scaledTextSize < kLargeDFFontSize) {
70 return false;
71 }
72 }
73
74 return true;
75}
76
77SkScalar scaled_text_size(const SkScalar textSize, const SkMatrix& viewMatrix) {
78 SkScalar scaledTextSize = textSize;
79
80 if (viewMatrix.hasPerspective()) {
81 // for perspective, we simply force to the medium size
82 // TODO: compute a size based on approximate screen area
83 scaledTextSize = kMediumDFFontLimit;
84 } else {
85 SkScalar maxScale = viewMatrix.getMaxScale();
86 // if we have non-unity scale, we need to choose our base text size
87 // based on the SkPaint's text size multiplied by the max scale factor
88 // TODO: do we need to do this if we're scaling down (i.e. maxScale < 1)?
89 if (maxScale > 0 && !SkScalarNearlyEqual(maxScale, SK_Scalar1)) {
90 scaledTextSize *= maxScale;
91 }
92 }
93
94 return scaledTextSize;
95}
96
97SkFont GrSDFTOptions::getSDFFont(const SkFont& font,
98 const SkMatrix& viewMatrix,
99 SkScalar* textRatio) const {
100 SkScalar textSize = font.getSize();
101 SkScalar scaledTextSize = scaled_text_size(textSize, viewMatrix);
102
103 SkFont dfFont{font};
104
105 if (scaledTextSize <= kSmallDFFontLimit) {
106 *textRatio = textSize / kSmallDFFontSize;
107 dfFont.setSize(SkIntToScalar(kSmallDFFontSize));
108 } else if (scaledTextSize <= kMediumDFFontLimit) {
109 *textRatio = textSize / kMediumDFFontSize;
110 dfFont.setSize(SkIntToScalar(kMediumDFFontSize));
111#ifdef SK_BUILD_FOR_MAC
112 } else if (scaledTextSize <= kLargeDFFontLimit) {
113 *textRatio = textSize / kLargeDFFontSize;
114 dfFont.setSize(SkIntToScalar(kLargeDFFontSize));
115 } else {
116 *textRatio = textSize / kExtraLargeDFFontSize;
117 dfFont.setSize(SkIntToScalar(kExtraLargeDFFontSize));
118 }
119#else
120 } else {
121 *textRatio = textSize / kLargeDFFontSize;
122 dfFont.setSize(SkIntToScalar(kLargeDFFontSize));
123 }
124#endif
125
126 dfFont.setEdging(SkFont::Edging::kAntiAlias);
127 dfFont.setForceAutoHinting(false);
128 dfFont.setHinting(SkFontHinting::kNormal);
129
130 // The sub-pixel position will always happen when transforming to the screen.
131 dfFont.setSubpixel(false);
132 return dfFont;
133}
134
135std::pair<SkScalar, SkScalar> GrSDFTOptions::computeSDFMinMaxScale(
136 SkScalar textSize, const SkMatrix& viewMatrix) const {
137
138 SkScalar scaledTextSize = scaled_text_size(textSize, viewMatrix);
139
140 // We have three sizes of distance field text, and within each size 'bucket' there is a floor
141 // and ceiling. A scale outside of this range would require regenerating the distance fields
142 SkScalar dfMaskScaleFloor;
143 SkScalar dfMaskScaleCeil;
144 if (scaledTextSize <= kSmallDFFontLimit) {
145 dfMaskScaleFloor = fMinDistanceFieldFontSize;
146 dfMaskScaleCeil = kSmallDFFontLimit;
147 } else if (scaledTextSize <= kMediumDFFontLimit) {
148 dfMaskScaleFloor = kSmallDFFontLimit;
149 dfMaskScaleCeil = kMediumDFFontLimit;
150 } else {
151 dfMaskScaleFloor = kMediumDFFontLimit;
152 dfMaskScaleCeil = fMaxDistanceFieldFontSize;
153 }
154
155 // Because there can be multiple runs in the blob, we want the overall maxMinScale, and
156 // minMaxScale to make regeneration decisions. Specifically, we want the maximum minimum scale
157 // we can tolerate before we'd drop to a lower mip size, and the minimum maximum scale we can
158 // tolerate before we'd have to move to a large mip size. When we actually test these values
159 // we look at the delta in scale between the new viewmatrix and the old viewmatrix, and test
160 // against these values to decide if we can reuse or not(ie, will a given scale change our mip
161 // level)
162 SkASSERT(dfMaskScaleFloor <= scaledTextSize && scaledTextSize <= dfMaskScaleCeil);
163
164 return std::make_pair(dfMaskScaleFloor / scaledTextSize, dfMaskScaleCeil / scaledTextSize);
165}
166
167
168