*/
#include "SkShadowTessellator.h"
+#include "SkColorPriv.h"
#include "SkGeometry.h"
#include "SkPath.h"
SkTDArray<SkColor> fColors;
SkTDArray<uint16_t> fIndices;
- int fPrevInnerIndex;
+ int fPrevUmbraIndex;
SkVector fPrevNormal;
int fFirstVertex;
SkVector fFirstNormal;
, fUmbraColor(umbraColor)
, fPenumbraColor(penumbraColor)
, fTransparent(transparent)
- , fPrevInnerIndex(-1) {
+ , fPrevUmbraIndex(-1) {
// Outer ring: 3*numPts
// Middle ring: numPts
}
SkVector normal;
- if (compute_normal(fPositions[fPrevInnerIndex], fPositions[fFirstVertex], fRadius, fDirection,
+ if (compute_normal(fPositions[fPrevUmbraIndex], fPositions[fFirstVertex], fRadius, fDirection,
&normal)) {
this->addArc(normal);
// close out previous arc
- *fPositions.push() = fPositions[fPrevInnerIndex] + normal;
+ *fPositions.push() = fPositions[fPrevUmbraIndex] + normal;
*fColors.push() = fPenumbraColor;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fPositions.count() - 2;
*fIndices.push() = fPositions.count() - 1;
*fPositions.push() = fPositions[fFirstVertex] + normal;
*fColors.push() = fPenumbraColor;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fPositions.count() - 2;
*fIndices.push() = fFirstVertex;
fPositions[0] *= SkScalarFastInvert(fCentroidCount);
*fIndices.push() = 0;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fFirstVertex;
}
// final fan
if (fPositions.count() >= 3) {
- fPrevInnerIndex = fFirstVertex;
+ fPrevUmbraIndex = fFirstVertex;
fPrevNormal = normal;
this->addArc(fFirstNormal);
fFirstVertex = fPositions.count();
fPrevNormal = fFirstNormal;
- fPrevInnerIndex = fFirstVertex;
+ fPrevUmbraIndex = fFirstVertex;
*fPositions.push() = fInitPoints[0];
*fColors.push() = fUmbraColor;
}
SkVector normal;
- if (compute_normal(fPositions[fPrevInnerIndex], p, fRadius, fDirection, &normal)) {
+ if (compute_normal(fPositions[fPrevUmbraIndex], p, fRadius, fDirection, &normal)) {
this->addArc(normal);
this->finishArcAndAddEdge(p, normal);
}
SkVector nextNormal;
nextNormal.fX = prevNormal.fX*rotCos - prevNormal.fY*rotSin;
nextNormal.fY = prevNormal.fY*rotCos + prevNormal.fX*rotSin;
- *fPositions.push() = fPositions[fPrevInnerIndex] + nextNormal;
+ *fPositions.push() = fPositions[fPrevUmbraIndex] + nextNormal;
*fColors.push() = fPenumbraColor;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fPositions.count() - 2;
*fIndices.push() = fPositions.count() - 1;
void SkAmbientShadowTessellator::finishArcAndAddEdge(const SkPoint& nextPoint,
const SkVector& nextNormal) {
// close out previous arc
- *fPositions.push() = fPositions[fPrevInnerIndex] + nextNormal;
+ *fPositions.push() = fPositions[fPrevUmbraIndex] + nextNormal;
*fColors.push() = fPenumbraColor;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fPositions.count() - 2;
*fIndices.push() = fPositions.count() - 1;
*fPositions.push() = nextPoint + nextNormal;
*fColors.push() = fPenumbraColor;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fPositions.count() - 3;
*fIndices.push() = fPositions.count() - 2;
++fCentroidCount;
*fIndices.push() = 0;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fPositions.count() - 2;
}
- fPrevInnerIndex = fPositions.count() - 2;
+ fPrevUmbraIndex = fPositions.count() - 2;
fPrevNormal = nextNormal;
}
private:
void computeClipBounds(const SkPath& path);
+ void checkUmbraAndTransformCentroid(SkScalar scale, const SkVector& xlate,
+ bool useDistanceToPoint);
+ bool clipUmbraPoint(const SkPoint& umbraPoint, const SkPoint& centroid, SkPoint* clipPoint);
void handleLine(const SkPoint& p);
void handleLine(SkScalar scale, const SkVector& xlate, SkPoint p);
void handleConic(SkScalar scale, const SkVector& xlate, SkPoint pts[3], SkScalar w);
void mapPoints(SkScalar scale, const SkVector& xlate, SkPoint* pts, int count);
- void addInnerPoint(const SkPoint& pathPoint, SkColor umbraColor, SkScalar radiusSqd);
+ void addInnerPoint(const SkPoint& pathPoint);
void addArc(const SkVector& nextNormal);
void finishArcAndAddEdge(const SkVector& nextPoint, const SkVector& nextNormal);
void addEdge(const SkVector& nextPoint, const SkVector& nextNormal);
SkScalar fRadius;
SkColor fUmbraColor;
SkColor fPenumbraColor;
+ bool fTransparent;
+ bool fValidUmbra;
SkTDArray<SkPoint> fPositions;
SkTDArray<SkColor> fColors;
SkTDArray<uint16_t> fIndices;
- int fPrevInnerIndex;
+ int fPrevUmbraIndex;
SkPoint fPrevPoint;
SkVector fPrevNormal;
int fFirstVertex;
SkPoint fCentroid;
SkTDArray<SkPoint> fClipPolygon;
+ SkTDArray<SkVector> fClipVectors;
+ int fCurrPolyPoint;
+ bool fPrevUmbraOutside;
+ bool fFirstUmbraOutside;
// first three points
SkTDArray<SkPoint> fInitPoints;
SkTDArray<SkPoint> fPointBuffer;
};
+
+
SkSpotShadowTessellator::SkSpotShadowTessellator(const SkPath& path,
SkScalar scale, const SkVector& translate,
SkScalar radius,
SkColor umbraColor, SkColor penumbraColor,
- bool /* transparent */)
+ bool transparent)
: fRadius(radius)
, fUmbraColor(umbraColor)
, fPenumbraColor(penumbraColor)
- , fPrevInnerIndex(-1) {
+ , fTransparent(transparent)
+ , fPrevUmbraIndex(-1) {
// TODO: calculate these better
- // Outer ring: 3*numPts
+ // Penumbra ring: 3*numPts
+ // Umbra ring: numPts
// Inner ring: numPts
- fPositions.setReserve(4 * path.countPoints());
- fColors.setReserve(4 * path.countPoints());
- // Outer ring: 12*numPts
- // Inner ring: 0
- fIndices.setReserve(12 * path.countPoints());
+ fPositions.setReserve(5 * path.countPoints());
+ fColors.setReserve(5 * path.countPoints());
+ // Penumbra ring: 12*numPts
+ // Umbra ring: 3*numPts
+ fIndices.setReserve(15 * path.countPoints());
fInitPoints.setReserve(3);
fClipPolygon.setReserve(path.countPoints());
+ // compute rough clip bounds for umbra, plus centroid
this->computeClipBounds(path);
+ if (fClipPolygon.count() < 3) {
+ return;
+ }
// We are going to apply 'scale' and 'xlate' (in that order) to each computed path point. We
// want the effect to be to scale the points relative to the path centroid and then translate
// them by the 'translate' param we were passed.
SkVector xlate = fCentroid * (1.f - scale) + translate;
- // Also translate the centroid by the global translate.
- fCentroid += translate;
+
+ // check to see if we have a valid umbra at all
+ bool usePointCheck = path.isRRect(nullptr) || path.isRect(nullptr) || path.isOval(nullptr);
+ this->checkUmbraAndTransformCentroid(scale, translate, usePointCheck);
+ fPrevUmbraOutside = false;
// walk around the path, tessellate and generate inner and outer rings
SkPath::Iter iter(path, true);
SkPoint pts[4];
SkPath::Verb verb;
- *fPositions.push() = fCentroid;
- *fColors.push() = fUmbraColor;
+ if (fTransparent) {
+ *fPositions.push() = fCentroid;
+ *fColors.push() = fUmbraColor;
+ }
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
switch (verb) {
case SkPath::kLine_Verb:
// close out previous arc
*fPositions.push() = fPrevPoint + normal;
*fColors.push() = fPenumbraColor;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fPositions.count() - 2;
*fIndices.push() = fPositions.count() - 1;
+ // add to center fan
+ if (fTransparent) {
+ *fIndices.push() = 0;
+ *fIndices.push() = fPrevUmbraIndex;
+ *fIndices.push() = fFirstVertex;
+ // or to clip ring
+ } else {
+ if (fFirstUmbraOutside) {
+ *fIndices.push() = fPrevUmbraIndex;
+ *fIndices.push() = fFirstVertex;
+ *fIndices.push() = fFirstVertex + 1;
+ if (fPrevUmbraOutside) {
+ // fill out quad
+ *fIndices.push() = fPrevUmbraIndex;
+ *fIndices.push() = fFirstVertex + 1;
+ *fIndices.push() = fPrevUmbraIndex + 1;
+ }
+ } else if (fPrevUmbraOutside) {
+ // add tri
+ *fIndices.push() = fPrevUmbraIndex;
+ *fIndices.push() = fFirstVertex;
+ *fIndices.push() = fPrevUmbraIndex + 1;
+ }
+ }
+
// add final edge
*fPositions.push() = fFirstPoint + normal;
*fColors.push() = fPenumbraColor;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fPositions.count() - 2;
*fIndices.push() = fFirstVertex;
*fIndices.push() = fPositions.count() - 2;
*fIndices.push() = fPositions.count() - 1;
*fIndices.push() = fFirstVertex;
-
- // add to center fan
- *fIndices.push() = 0;
- *fIndices.push() = fPrevInnerIndex;
- *fIndices.push() = fFirstVertex;
}
// final fan
if (fPositions.count() >= 3) {
- fPrevInnerIndex = fFirstVertex;
+ fPrevUmbraIndex = fFirstVertex;
fPrevPoint = fFirstPoint;
fPrevNormal = normal;
this->addArc(fFirstNormal);
*fIndices.push() = fFirstVertex;
*fIndices.push() = fPositions.count() - 1;
- *fIndices.push() = fFirstVertex + 1;
+ if (fFirstUmbraOutside) {
+ *fIndices.push() = fFirstVertex + 2;
+ } else {
+ *fIndices.push() = fFirstVertex + 1;
+ }
}
}
void SkSpotShadowTessellator::computeClipBounds(const SkPath& path) {
// walk around the path and compute clip polygon
// if original path is transparent, will accumulate sum of points for centroid
+ // for Bezier curves, we compute additional interior points on curve
SkPath::Iter iter(path, true);
SkPoint pts[4];
SkPath::Verb verb;
int centroidCount = 0;
fClipPolygon.reset();
+ // coefficients to compute cubic Bezier at t = 5/16
+ const SkScalar kA = 0.32495117187f;
+ const SkScalar kB = 0.44311523437f;
+ const SkScalar kC = 0.20141601562f;
+ const SkScalar kD = 0.03051757812f;
+
+ SkPoint curvePoint;
+ SkScalar w;
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
switch (verb) {
case SkPath::kMove_Verb:
*fClipPolygon.push() = pts[1];
break;
case SkPath::kQuad_Verb:
- fCentroid += pts[1];
+ // point at t = 1/2
+ curvePoint.fX = 0.25f*pts[0].fX + 0.5f*pts[1].fX + 0.25f*pts[2].fX;
+ curvePoint.fY = 0.25f*pts[0].fY + 0.5f*pts[1].fY + 0.25f*pts[2].fY;
+ *fClipPolygon.push() = curvePoint;
+ fCentroid += curvePoint;
+ *fClipPolygon.push() = pts[2];
fCentroid += pts[2];
centroidCount += 2;
- *fClipPolygon.push() = pts[2];
break;
case SkPath::kConic_Verb:
- fCentroid += pts[1];
+ // point at t = 1/2
+ w = iter.conicWeight();
+ curvePoint.fX = 0.25f*pts[0].fX + w*0.5f*pts[1].fX + 0.25f*pts[2].fX;
+ curvePoint.fY = 0.25f*pts[0].fY + w*0.5f*pts[1].fY + 0.25f*pts[2].fY;
+ curvePoint *= SkScalarInvert(0.5f + 0.5f*w);
+ *fClipPolygon.push() = curvePoint;
+ fCentroid += curvePoint;
+ *fClipPolygon.push() = pts[2];
fCentroid += pts[2];
centroidCount += 2;
- *fClipPolygon.push() = pts[2];
break;
case SkPath::kCubic_Verb:
- fCentroid += pts[1];
- fCentroid += pts[2];
+ // point at t = 5/16
+ curvePoint.fX = kA*pts[0].fX + kB*pts[1].fX + kC*pts[2].fX + kD*pts[3].fX;
+ curvePoint.fY = kA*pts[0].fY + kB*pts[1].fY + kC*pts[2].fY + kD*pts[3].fY;
+ *fClipPolygon.push() = curvePoint;
+ fCentroid += curvePoint;
+ // point at t = 11/16
+ curvePoint.fX = kD*pts[0].fX + kC*pts[1].fX + kB*pts[2].fX + kA*pts[3].fX;
+ curvePoint.fY = kD*pts[0].fY + kC*pts[1].fY + kB*pts[2].fY + kA*pts[3].fY;
+ *fClipPolygon.push() = curvePoint;
+ fCentroid += curvePoint;
+ *fClipPolygon.push() = pts[3];
fCentroid += pts[3];
centroidCount += 3;
- *fClipPolygon.push() = pts[3];
break;
case SkPath::kClose_Verb:
break;
}
fCentroid *= SkScalarInvert(centroidCount);
+ fCurrPolyPoint = fClipPolygon.count() - 1;
+}
+
+void SkSpotShadowTessellator::checkUmbraAndTransformCentroid(SkScalar scale,
+ const SkVector& xlate,
+ bool useDistanceToPoint) {
+ SkASSERT(fClipPolygon.count() >= 3);
+ SkPoint transformedCentroid = fCentroid;
+ transformedCentroid += xlate;
+
+ SkScalar localRadius = fRadius / scale;
+ localRadius *= localRadius;
+
+ // init umbra check
+ SkVector w = fCentroid - fClipPolygon[0];
+ SkVector v0 = fClipPolygon[1] - fClipPolygon[0];
+ *fClipVectors.push() = v0;
+ bool validUmbra;
+ SkScalar minDistance;
+ // check distance against line segment
+ if (useDistanceToPoint) {
+ minDistance = w.lengthSqd();
+ } else {
+ SkScalar vSq = v0.dot(v0);
+ SkScalar wDotV = w.dot(v0);
+ minDistance = w.dot(w) - wDotV*wDotV/vSq;
+ }
+ validUmbra = (minDistance >= localRadius);
+
+ // init centroid check
+ bool hiddenCentroid = true;
+ SkVector v1 = transformedCentroid - fClipPolygon[0];
+ SkScalar initCross = v0.cross(v1);
+
+ for (int p = 1; p < fClipPolygon.count(); ++p) {
+ // Determine whether we have a real umbra by insetting clipPolygon by radius/scale
+ // and see if it extends past centroid.
+ // TODO: adjust this later for more accurate umbra calcs
+ w = fCentroid - fClipPolygon[p];
+ v0 = fClipPolygon[(p + 1) % fClipPolygon.count()] - fClipPolygon[p];
+ *fClipVectors.push() = v0;
+ // check distance against line segment
+ SkScalar distance;
+ if (useDistanceToPoint) {
+ distance = w.lengthSqd();
+ } else {
+ SkScalar vSq = v0.dot(v0);
+ SkScalar wDotV = w.dot(v0);
+ distance = w.dot(w) - wDotV*wDotV/vSq;
+ }
+ if (distance < localRadius) {
+ validUmbra = false;
+ }
+ if (distance < minDistance) {
+ minDistance = distance;
+ }
+ // Determine if transformed centroid is inside clipPolygon.
+ v1 = transformedCentroid - fClipPolygon[p];
+ if (initCross*v0.cross(v1) <= 0) {
+ hiddenCentroid = false;
+ }
+ }
+ SkASSERT(fClipVectors.count() == fClipPolygon.count());
+
+ if (!validUmbra) {
+ SkScalar ratio = 256 * SkScalarSqrt(minDistance / localRadius);
+ // they aren't PMColors, but the interpolation algorithm is the same
+ fUmbraColor = SkPMLerp(fUmbraColor, fPenumbraColor, (unsigned)ratio);
+ }
+
+ fTransparent = fTransparent || !hiddenCentroid || !validUmbra;
+ fValidUmbra = validUmbra;
+ fCentroid = transformedCentroid;
+}
+
+bool SkSpotShadowTessellator::clipUmbraPoint(const SkPoint& umbraPoint, const SkPoint& centroid,
+ SkPoint* clipPoint) {
+ SkVector segmentVector = centroid - umbraPoint;
+
+ int startPolyPoint = fCurrPolyPoint;
+ do {
+ SkVector dp = umbraPoint - fClipPolygon[fCurrPolyPoint];
+ SkScalar denom = fClipVectors[fCurrPolyPoint].cross(segmentVector);
+ SkScalar t_num = dp.cross(segmentVector);
+ // if line segments are nearly parallel
+ if (SkScalarNearlyZero(denom)) {
+ // and collinear
+ if (SkScalarNearlyZero(t_num)) {
+ return false;
+ }
+ // otherwise are separate, will try the next poly segment
+ // else if crossing lies within poly segment
+ } else if (t_num >= 0 && t_num <= denom) {
+ SkScalar s_num = dp.cross(fClipVectors[fCurrPolyPoint]);
+ // if umbra point is inside the clip polygon
+ if (s_num < 0) {
+ return false;
+ } else {
+ segmentVector *= s_num/denom;
+ *clipPoint = umbraPoint + segmentVector;
+ return true;
+ }
+ }
+ fCurrPolyPoint = (fCurrPolyPoint + 1) % fClipPolygon.count();
+ } while (fCurrPolyPoint != startPolyPoint);
+
+ return false;
}
void SkSpotShadowTessellator::mapPoints(SkScalar scale, const SkVector& xlate,
fFirstVertex = fPositions.count();
fPrevNormal = fFirstNormal;
fPrevPoint = fFirstPoint;
- fPrevInnerIndex = fFirstVertex;
+ fPrevUmbraIndex = fFirstVertex;
+
+ this->addInnerPoint(fFirstPoint);
+
+ if (!fTransparent) {
+ SkPoint clipPoint;
+ bool isOutside = this->clipUmbraPoint(fPositions[fFirstVertex], fCentroid, &clipPoint);
+ if (isOutside) {
+ *fPositions.push() = clipPoint;
+ *fColors.push() = fUmbraColor;
+ }
+ fPrevUmbraOutside = isOutside;
+ fFirstUmbraOutside = isOutside;
+ }
- this->addInnerPoint(fFirstPoint, fUmbraColor, fRadius);
SkPoint newPoint = fFirstPoint + fFirstNormal;
*fPositions.push() = newPoint;
*fColors.push() = fPenumbraColor;
}
}
-void SkSpotShadowTessellator::addInnerPoint(const SkPoint& pathPoint, SkColor umbraColor,
- SkScalar radius) {
+void SkSpotShadowTessellator::addInnerPoint(const SkPoint& pathPoint) {
SkVector v = fCentroid - pathPoint;
SkScalar distance = v.length();
- if (distance < radius) {
- *fPositions.push() = fCentroid;
- *fColors.push() = umbraColor; // fix this
- // TODO: deal with fanning from centroid
+ SkScalar t;
+ if (fValidUmbra) {
+ SkASSERT(distance >= fRadius);
+ t = fRadius / distance;
} else {
- SkScalar t = radius / distance;
- v *= t;
- SkPoint innerPoint = pathPoint + v;
- *fPositions.push() = innerPoint;
- *fColors.push() = umbraColor;
+ t = 0.95f;
}
+ v *= t;
+ SkPoint umbraPoint = pathPoint + v;
+ *fPositions.push() = umbraPoint;
+ *fColors.push() = fUmbraColor;
+
fPrevPoint = pathPoint;
}
nextNormal.fY = prevNormal.fY*rotCos + prevNormal.fX*rotSin;
*fPositions.push() = fPrevPoint + nextNormal;
*fColors.push() = fPenumbraColor;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fPositions.count() - 2;
*fIndices.push() = fPositions.count() - 1;
SkPoint newPoint = fPrevPoint + nextNormal;
*fPositions.push() = newPoint;
*fColors.push() = fPenumbraColor;
- *fIndices.push() = fPrevInnerIndex;
+ *fIndices.push() = fPrevUmbraIndex;
*fIndices.push() = fPositions.count() - 2;
*fIndices.push() = fPositions.count() - 1;
}
void SkSpotShadowTessellator::addEdge(const SkPoint& nextPoint, const SkVector& nextNormal) {
- // add next quad
- this->addInnerPoint(nextPoint, fUmbraColor, fRadius);
+ // add next umbra point
+ this->addInnerPoint(nextPoint);
+ int prevPenumbraIndex = fPositions.count() - 2;
+ int currUmbraIndex = fPositions.count() - 1;
+
+ // add to center fan if transparent or centroid showing
+ if (fTransparent) {
+ *fIndices.push() = 0;
+ *fIndices.push() = fPrevUmbraIndex;
+ *fIndices.push() = currUmbraIndex;
+ // otherwise add to clip ring
+ } else {
+ if (!fTransparent) {
+ SkPoint clipPoint;
+ bool isOutside = clipUmbraPoint(fPositions[currUmbraIndex], fCentroid, &clipPoint);
+ if (isOutside) {
+ *fPositions.push() = clipPoint;
+ *fColors.push() = fUmbraColor;
+
+ *fIndices.push() = fPrevUmbraIndex;
+ *fIndices.push() = currUmbraIndex;
+ *fIndices.push() = currUmbraIndex + 1;
+ if (fPrevUmbraOutside) {
+ // fill out quad
+ *fIndices.push() = fPrevUmbraIndex;
+ *fIndices.push() = currUmbraIndex + 1;
+ *fIndices.push() = fPrevUmbraIndex + 1;
+ }
+ } else if (fPrevUmbraOutside) {
+ // add tri
+ *fIndices.push() = fPrevUmbraIndex;
+ *fIndices.push() = currUmbraIndex;
+ *fIndices.push() = fPrevUmbraIndex + 1;
+ }
+ fPrevUmbraOutside = isOutside;
+ }
+ }
+
+ // add next penumbra point and quad
SkPoint newPoint = nextPoint + nextNormal;
*fPositions.push() = newPoint;
*fColors.push() = fPenumbraColor;
- *fIndices.push() = fPrevInnerIndex;
- *fIndices.push() = fPositions.count() - 3;
- *fIndices.push() = fPositions.count() - 2;
+ *fIndices.push() = fPrevUmbraIndex;
+ *fIndices.push() = prevPenumbraIndex;
+ *fIndices.push() = currUmbraIndex;
- *fIndices.push() = fPositions.count() - 3;
+ *fIndices.push() = prevPenumbraIndex;
*fIndices.push() = fPositions.count() - 1;
- *fIndices.push() = fPositions.count() - 2;
-
- // add to center fan
- *fIndices.push() = 0;
- *fIndices.push() = fPrevInnerIndex;
- *fIndices.push() = fPositions.count() - 2;
+ *fIndices.push() = currUmbraIndex;
- fPrevInnerIndex = fPositions.count() - 2;
+ fPrevUmbraIndex = currUmbraIndex;
fPrevNormal = nextNormal;
}
projects / platform / upstream / libSkiaSharp.git / commitdiff