aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/gpu/ops
diff options
context:
space:
mode:
Diffstat (limited to 'src/gpu/ops')
-rw-r--r--src/gpu/ops/GrAAConvexPathRenderer.cpp20
-rw-r--r--src/gpu/ops/GrAAConvexTessellator.cpp28
-rw-r--r--src/gpu/ops/GrAAConvexTessellator.h8
-rw-r--r--src/gpu/ops/GrAAHairLinePathRenderer.cpp15
-rw-r--r--src/gpu/ops/GrDashOp.cpp3
5 files changed, 40 insertions, 34 deletions
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 0e37238389..3c84b32df7 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -19,6 +19,7 @@
#include "GrSimpleMeshDrawOpHelper.h"
#include "SkGeometry.h"
#include "SkPathPriv.h"
+#include "SkPointPriv.h"
#include "SkString.h"
#include "SkTraceEvent.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
@@ -122,11 +123,11 @@ static void compute_vectors(SegmentArray* segments,
int count = segments->count();
// Make the normals point towards the outside
- SkPoint::Side normSide;
+ SkPointPriv::Side normSide;
if (dir == SkPathPriv::kCCW_FirstDirection) {
- normSide = SkPoint::kRight_Side;
+ normSide = SkPointPriv::kRight_Side;
} else {
- normSide = SkPoint::kLeft_Side;
+ normSide = SkPointPriv::kLeft_Side;
}
*vCount = 0;
@@ -142,7 +143,7 @@ static void compute_vectors(SegmentArray* segments,
for (int p = 0; p < n; ++p) {
segb.fNorms[p] = segb.fPts[p] - *prevPt;
segb.fNorms[p].normalize();
- segb.fNorms[p].setOrthog(segb.fNorms[p], normSide);
+ SkPointPriv::SetOrthog(&segb.fNorms[p], segb.fNorms[p], normSide);
prevPt = &segb.fPts[p];
}
if (Segment::kLine == segb.fType) {
@@ -192,10 +193,10 @@ static void update_degenerate_test(DegenerateTestData* data, const SkPoint& pt)
data->fStage = DegenerateTestData::kPoint;
break;
case DegenerateTestData::kPoint:
- if (pt.distanceToSqd(data->fFirstPoint) > kCloseSqd) {
+ if (SkPointPriv::DistanceToSqd(pt, data->fFirstPoint) > kCloseSqd) {
data->fLineNormal = pt - data->fFirstPoint;
data->fLineNormal.normalize();
- data->fLineNormal.setOrthog(data->fLineNormal);
+ SkPointPriv::SetOrthog(&data->fLineNormal, data->fLineNormal);
data->fLineC = -data->fLineNormal.dot(data->fFirstPoint);
data->fStage = DegenerateTestData::kLine;
}
@@ -235,7 +236,8 @@ static inline void add_line_to_segment(const SkPoint& pt,
static inline void add_quad_segment(const SkPoint pts[3],
SegmentArray* segments) {
- if (pts[0].distanceToSqd(pts[1]) < kCloseSqd || pts[1].distanceToSqd(pts[2]) < kCloseSqd) {
+ if (SkPointPriv::DistanceToSqd(pts[0], pts[1]) < kCloseSqd ||
+ SkPointPriv::DistanceToSqd(pts[1], pts[2]) < kCloseSqd) {
if (pts[0] != pts[2]) {
add_line_to_segment(pts[2], segments);
}
@@ -425,8 +427,8 @@ static void create_vertices(const SegmentArray& segments,
// we draw the line edge as a degenerate quad (u is 0, v is the
// signed distance to the edge)
- SkScalar dist = fanPt.distanceToLineBetween(verts[*v + 1].fPos,
- verts[*v + 2].fPos);
+ SkScalar dist = SkPointPriv::DistanceToLineBetween(fanPt, verts[*v + 1].fPos,
+ verts[*v + 2].fPos);
verts[*v + 0].fUV.set(0, dist);
verts[*v + 1].fUV.set(0, 0);
verts[*v + 2].fUV.set(0, 0);
diff --git a/src/gpu/ops/GrAAConvexTessellator.cpp b/src/gpu/ops/GrAAConvexTessellator.cpp
index 6c0125a576..9927d98b11 100644
--- a/src/gpu/ops/GrAAConvexTessellator.cpp
+++ b/src/gpu/ops/GrAAConvexTessellator.cpp
@@ -55,7 +55,7 @@ static SkScalar perp_intersect(const SkPoint& p0, const SkPoint& n0,
}
static bool duplicate_pt(const SkPoint& p0, const SkPoint& p1) {
- SkScalar distSq = p0.distanceToSqd(p1);
+ SkScalar distSq = SkPointPriv::DistanceToSqd(p0, p1);
return distSq < kCloseSqd;
}
@@ -149,10 +149,10 @@ void GrAAConvexTessellator::computeBisectors() {
for (int cur = 0; cur < fBisectors.count(); prev = cur, ++cur) {
fBisectors[cur] = fNorms[cur] + fNorms[prev];
if (!fBisectors[cur].normalize()) {
- SkASSERT(SkPoint::kLeft_Side == fSide || SkPoint::kRight_Side == fSide);
- fBisectors[cur].setOrthog(fNorms[cur], (SkPoint::Side)-fSide);
+ SkASSERT(SkPointPriv::kLeft_Side == fSide || SkPointPriv::kRight_Side == fSide);
+ SkPointPriv::SetOrthog(&fBisectors[cur], fNorms[cur], (SkPointPriv::Side)-fSide);
SkVector other;
- other.setOrthog(fNorms[prev], fSide);
+ SkPointPriv::SetOrthog(&other, fNorms[prev], fSide);
fBisectors[cur] += other;
SkAssertResult(fBisectors[cur].normalize());
} else {
@@ -424,14 +424,14 @@ bool GrAAConvexTessellator::extractFromPath(const SkMatrix& m, const SkPath& pat
// Check the cross product of the final trio
SkScalar cross = SkPoint::CrossProduct(fNorms[0], fNorms.top());
if (cross > 0.0f) {
- fSide = SkPoint::kRight_Side;
+ fSide = SkPointPriv::kRight_Side;
} else {
- fSide = SkPoint::kLeft_Side;
+ fSide = SkPointPriv::kLeft_Side;
}
// Make all the normals face outwards rather than along the edge
for (int cur = 0; cur < fNorms.count(); ++cur) {
- fNorms[cur].setOrthog(fNorms[cur], fSide);
+ SkPointPriv::SetOrthog(&fNorms[cur], fNorms[cur], fSide);
SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[cur].length()));
}
@@ -443,11 +443,11 @@ bool GrAAConvexTessellator::extractFromPath(const SkMatrix& m, const SkPath& pat
return false;
}
// For stroking, we still need to process the degenerate path, so fix it up
- fSide = SkPoint::kLeft_Side;
+ fSide = SkPointPriv::kLeft_Side;
// Make all the normals face outwards rather than along the edge
for (int cur = 0; cur < fNorms.count(); ++cur) {
- fNorms[cur].setOrthog(fNorms[cur], fSide);
+ SkPointPriv::SetOrthog(&fNorms[cur], fNorms[cur], fSide);
SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[cur].length()));
}
@@ -839,7 +839,7 @@ void GrAAConvexTessellator::Ring::computeNormals(const GrAAConvexTessellator& te
fPts[cur].fNorm = tess.point(fPts[next].fIndex) - tess.point(fPts[cur].fIndex);
SkPoint::Normalize(&fPts[cur].fNorm);
- fPts[cur].fNorm.setOrthog(fPts[cur].fNorm, tess.side());
+ SkPointPriv::SetOrthog(&fPts[cur].fNorm, fPts[cur].fNorm, tess.side());
}
}
@@ -848,10 +848,12 @@ void GrAAConvexTessellator::Ring::computeBisectors(const GrAAConvexTessellator&
for (int cur = 0; cur < fPts.count(); prev = cur, ++cur) {
fPts[cur].fBisector = fPts[cur].fNorm + fPts[prev].fNorm;
if (!fPts[cur].fBisector.normalize()) {
- SkASSERT(SkPoint::kLeft_Side == tess.side() || SkPoint::kRight_Side == tess.side());
- fPts[cur].fBisector.setOrthog(fPts[cur].fNorm, (SkPoint::Side)-tess.side());
+ SkASSERT(SkPointPriv::kLeft_Side == tess.side() ||
+ SkPointPriv::kRight_Side == tess.side());
+ SkPointPriv::SetOrthog(&fPts[cur].fBisector, fPts[cur].fNorm,
+ (SkPointPriv::Side)-tess.side());
SkVector other;
- other.setOrthog(fPts[prev].fNorm, tess.side());
+ SkPointPriv::SetOrthog(&other, fPts[prev].fNorm, tess.side());
fPts[cur].fBisector += other;
SkAssertResult(fPts[cur].fBisector.normalize());
} else {
diff --git a/src/gpu/ops/GrAAConvexTessellator.h b/src/gpu/ops/GrAAConvexTessellator.h
index ee91128bfb..caf4905939 100644
--- a/src/gpu/ops/GrAAConvexTessellator.h
+++ b/src/gpu/ops/GrAAConvexTessellator.h
@@ -10,7 +10,7 @@
#include "SkColor.h"
#include "SkPaint.h"
-#include "SkPoint.h"
+#include "SkPointPriv.h"
#include "SkScalar.h"
#include "SkStrokeRec.h"
#include "SkTDArray.h"
@@ -36,14 +36,14 @@ public:
SkScalar strokeWidth = -1.0f,
SkPaint::Join join = SkPaint::Join::kBevel_Join,
SkScalar miterLimit = 0.0f)
- : fSide(SkPoint::kOn_Side)
+ : fSide(SkPointPriv::kOn_Side)
, fStrokeWidth(strokeWidth)
, fStyle(style)
, fJoin(join)
, fMiterLimit(miterLimit) {
}
- SkPoint::Side side() const { return fSide; }
+ SkPointPriv::Side side() const { return fSide; }
bool tessellate(const SkMatrix& m, const SkPath& path);
@@ -262,7 +262,7 @@ private:
// needed for exterior ring creation and then handed off to the initial ring.
SkTDArray<SkVector> fBisectors;
- SkPoint::Side fSide; // winding of the original polygon
+ SkPointPriv::Side fSide; // winding of the original polygon
// The triangulation of the points
SkTDArray<int> fIndices;
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index 6dd5dc08c1..efab0d708d 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -19,6 +19,7 @@
#include "GrSimpleMeshDrawOpHelper.h"
#include "SkGeometry.h"
#include "SkPoint3.h"
+#include "SkPointPriv.h"
#include "SkStroke.h"
#include "SkTemplates.h"
#include "effects/GrBezierEffect.h"
@@ -176,17 +177,17 @@ static int is_degen_quad_or_conic(const SkPoint p[3], SkScalar* dsqd) {
static const SkScalar gDegenerateToLineTolSqd =
gDegenerateToLineTol * gDegenerateToLineTol;
- if (p[0].distanceToSqd(p[1]) < gDegenerateToLineTolSqd ||
- p[1].distanceToSqd(p[2]) < gDegenerateToLineTolSqd) {
+ if (SkPointPriv::DistanceToSqd(p[0], p[1]) < gDegenerateToLineTolSqd ||
+ SkPointPriv::DistanceToSqd(p[1], p[2]) < gDegenerateToLineTolSqd) {
return 1;
}
- *dsqd = p[1].distanceToLineBetweenSqd(p[0], p[2]);
+ *dsqd = SkPointPriv::DistanceToLineBetweenSqd(p[1], p[0], p[2]);
if (*dsqd < gDegenerateToLineTolSqd) {
return 1;
}
- if (p[2].distanceToLineBetweenSqd(p[1], p[0]) < gDegenerateToLineTolSqd) {
+ if (SkPointPriv::DistanceToLineBetweenSqd(p[2], p[1], p[0]) < gDegenerateToLineTolSqd) {
return 1;
}
return 0;
@@ -555,14 +556,14 @@ static void bloat_quad(const SkPoint qpts[3], const SkMatrix* toDevice,
ab.normalize();
SkVector abN;
- abN.setOrthog(ab, SkVector::kLeft_Side);
+ SkPointPriv::SetOrthog(&abN, ab, SkPointPriv::kLeft_Side);
if (abN.dot(ac) > 0) {
abN.negate();
}
cb.normalize();
SkVector cbN;
- cbN.setOrthog(cb, SkVector::kLeft_Side);
+ SkPointPriv::SetOrthog(&cbN, cb, SkPointPriv::kLeft_Side);
if (cbN.dot(ac) < 0) {
cbN.negate();
}
@@ -641,7 +642,7 @@ static void add_line(const SkPoint p[2],
SkVector ortho, vec = b;
vec -= a;
- SkScalar lengthSqd = vec.lengthSqd();
+ SkScalar lengthSqd = SkPointPriv::LengthSqd(vec);
if (vec.setLength(SK_ScalarHalf)) {
// Create a vector orthogonal to 'vec' and of unit length
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 82b2012587..e87a335af0 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -17,6 +17,7 @@
#include "GrProcessor.h"
#include "GrStyle.h"
#include "SkGr.h"
+#include "SkPointPriv.h"
#include "glsl/GrGLSLFragmentShaderBuilder.h"
#include "glsl/GrGLSLGeometryProcessor.h"
#include "glsl/GrGLSLProgramDataManager.h"
@@ -92,7 +93,7 @@ static void calc_dash_scaling(SkScalar* parallelScale, SkScalar* perpScale,
vecSrc.scale(invSrc);
SkVector vecSrcPerp;
- vecSrc.rotateCW(&vecSrcPerp);
+ SkPointPriv::RotateCW(vecSrc, &vecSrcPerp);
viewMatrix.mapVectors(&vecSrc, 1);
viewMatrix.mapVectors(&vecSrcPerp, 1);
generated by cgit v1.2.3 (git 2.39.1) at 2025-02-01 21:53:57 +0000