use SkPoint, creating an alias for GrPoint
http://codereview.appspot.com/4498041/
git-svn-id: http://skia.googlecode.com/svn/trunk@1268 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/gpu/include/GrPathIter.h b/gpu/include/GrPathIter.h
index 5261f0f..2c84145 100644
--- a/gpu/include/GrPathIter.h
+++ b/gpu/include/GrPathIter.h
@@ -18,9 +18,8 @@
#ifndef GrPathIter_DEFINED
#define GrPathIter_DEFINED
-#include "GrTypes.h"
+#include "GrPoint.h"
-struct GrPoint;
struct GrRect;
/**
diff --git a/gpu/include/GrPoint.h b/gpu/include/GrPoint.h
index 8c540f0..332ec1e 100644
--- a/gpu/include/GrPoint.h
+++ b/gpu/include/GrPoint.h
@@ -20,7 +20,21 @@
#include "GrTypes.h"
#include "GrScalar.h"
+#include "SkPoint.h"
+#define GrPoint SkPoint
+#define GrVec SkVector
+
+struct GrIPoint16 {
+ int16_t fX, fY;
+
+ void set(intptr_t x, intptr_t y) {
+ fX = GrToS16(x);
+ fY = GrToS16(y);
+ }
+};
+
+#if 0
/**
* 2D Point struct
*/
@@ -336,7 +350,7 @@
// TODO: fixed point sqrt
return GrFloatToScalar(sqrtf(GrScalarToFloat(distanceToLineSegmentBetweenSqd(a,b))));
}
-
+#endif
#endif
diff --git a/gpu/include/GrScalar.h b/gpu/include/GrScalar.h
index 8a7f1bd..a26b67c 100644
--- a/gpu/include/GrScalar.h
+++ b/gpu/include/GrScalar.h
@@ -36,6 +36,7 @@
#define GR_ScalarMin SK_ScalarMin
#define GR_ScalarMax SK_ScalarMax
+#define GrIntToScalar(a) SkIntToScalar(a)
#define GrScalarHalf(a) SkScalarHalf(a)
#define GrScalarAve(a,b) SkScalarAve(a,b)
#define GrMul(a,b) SkScalarMul(a,b)
diff --git a/gpu/src/GrGpu.cpp b/gpu/src/GrGpu.cpp
index e18c4a4..66105db 100644
--- a/gpu/src/GrGpu.cpp
+++ b/gpu/src/GrGpu.cpp
@@ -238,10 +238,16 @@
if (NULL == fUnitSquareVertexBuffer) {
static const GrPoint DATA[] = {
+ { 0, 0 },
+ { GR_Scalar1, 0 },
+ { GR_Scalar1, GR_Scalar1 },
+ { 0, GR_Scalar1 }
+#if 0
GrPoint(0, 0),
GrPoint(GR_Scalar1,0),
GrPoint(GR_Scalar1,GR_Scalar1),
GrPoint(0, GR_Scalar1)
+#endif
};
static const size_t SIZE = sizeof(DATA);
diff --git a/gpu/src/GrMatrix.cpp b/gpu/src/GrMatrix.cpp
index 92a38ee..b169d19 100644
--- a/gpu/src/GrMatrix.cpp
+++ b/gpu/src/GrMatrix.cpp
@@ -631,7 +631,7 @@
if (maxStretch > 0) {
maxStretch = GrMul(GR_Scalar1 + GR_Scalar1 / 100, maxStretch);
}
- GrPoint origin = a.mapPoint(GrPoint(0,0));
+ GrPoint origin = a.mapPoint(GrPoint::Make(0,0));
for (int j = 0; j < 9; ++j) {
int mask, origMask = a.fTypeMask;
@@ -668,8 +668,8 @@
a.mapPerspective(&t2, &pt, 1); // full mult
GrAssert(t0 == t1 && t1 == t2);
if (maxStretch >= 0.f) {
- GrVec vec;
- vec.setBetween(t0, origin);
+ GrVec vec = origin - t0;
+// vec.setBetween(t0, origin);
GrScalar stretch = vec.length() / pt.distanceToOrigin();
GrAssert(stretch <= maxStretch);
}
diff --git a/gpu/src/GrPath.cpp b/gpu/src/GrPath.cpp
index 17ecd5d..3687b80 100644
--- a/gpu/src/GrPath.cpp
+++ b/gpu/src/GrPath.cpp
@@ -163,13 +163,13 @@
fConvexHint = iter->convexHint();
// first point of the subpath
- GrPoint firstPt(0,0);
+ GrPoint firstPt = { 0, 0 };
// first edge of the subpath
- GrVec firstVec(0,0);
+ GrVec firstVec = { 0, 0 };
// vec of most recently processed edge, that wasn't degenerate
- GrVec previousVec(0,0);
+ GrVec previousVec = { 0, 0 };
// most recently processed point
- GrPoint previousPt(0,0);
+ GrPoint previousPt = { 0, 0 };
// sign indicates whether we're bending left or right
GrScalar turnDir = 0;
@@ -239,8 +239,8 @@
if (numSubPaths < 2 && kNone_ConvexHint == fConvexHint) {
while (consumed < n) {
GrAssert(pts[consumed-1] == previousPt);
- GrVec vec;
- vec.setBetween(previousPt, pts[consumed]);
+ GrVec vec = pts[consumed] - previousPt;
+// vec.setBetween(previousPt, pts[consumed]);
if (vec.fX || vec.fY) {
if (subPathPts >= 2) {
if (0 == turnDir) {
@@ -269,8 +269,8 @@
(!subPathClosed && kEnd_PathCmd == cmd ))) {
// if an additional vector is needed to close the loop check
// that it validates against the previous vector.
- GrVec vec;
- vec.setBetween(previousPt, firstPt);
+ GrVec vec = firstPt - previousPt;
+// vec.setBetween(previousPt, firstPt);
if (vec.fX || vec.fY) {
if (!check_two_vecs(previousVec, vec, turnDir,
&xDir, &yDir, &flipX, &flipY)) {
diff --git a/gpu/src/GrPathUtils.cpp b/gpu/src/GrPathUtils.cpp
index 274dc49..115b0f6 100644
--- a/gpu/src/GrPathUtils.cpp
+++ b/gpu/src/GrPathUtils.cpp
@@ -52,10 +52,10 @@
}
GrPoint q[] = {
- GrPoint(GrScalarAve(p0.fX, p1.fX), GrScalarAve(p0.fY, p1.fY)),
- GrPoint(GrScalarAve(p1.fX, p2.fX), GrScalarAve(p1.fY, p2.fY)),
+ { GrScalarAve(p0.fX, p1.fX), GrScalarAve(p0.fY, p1.fY) },
+ { GrScalarAve(p1.fX, p2.fX), GrScalarAve(p1.fY, p2.fY) },
};
- GrPoint r(GrScalarAve(q[0].fX, q[1].fX), GrScalarAve(q[0].fY, q[1].fY));
+ GrPoint r = { GrScalarAve(q[0].fX, q[1].fX), GrScalarAve(q[0].fY, q[1].fY) };
pointsLeft >>= 1;
uint32_t a = generateQuadraticPoints(p0, q[0], r, tolSqd, points, pointsLeft);
@@ -91,15 +91,15 @@
return 1;
}
GrPoint q[] = {
- GrPoint(GrScalarAve(p0.fX, p1.fX), GrScalarAve(p0.fY, p1.fY)),
- GrPoint(GrScalarAve(p1.fX, p2.fX), GrScalarAve(p1.fY, p2.fY)),
- GrPoint(GrScalarAve(p2.fX, p3.fX), GrScalarAve(p2.fY, p3.fY))
+ { GrScalarAve(p0.fX, p1.fX), GrScalarAve(p0.fY, p1.fY) },
+ { GrScalarAve(p1.fX, p2.fX), GrScalarAve(p1.fY, p2.fY) },
+ { GrScalarAve(p2.fX, p3.fX), GrScalarAve(p2.fY, p3.fY) }
};
GrPoint r[] = {
- GrPoint(GrScalarAve(q[0].fX, q[1].fX), GrScalarAve(q[0].fY, q[1].fY)),
- GrPoint(GrScalarAve(q[1].fX, q[2].fX), GrScalarAve(q[1].fY, q[2].fY))
+ { GrScalarAve(q[0].fX, q[1].fX), GrScalarAve(q[0].fY, q[1].fY) },
+ { GrScalarAve(q[1].fX, q[2].fX), GrScalarAve(q[1].fY, q[2].fY) }
};
- GrPoint s(GrScalarAve(r[0].fX, r[1].fX), GrScalarAve(r[0].fY, r[1].fY));
+ GrPoint s = { GrScalarAve(r[0].fX, r[1].fX), GrScalarAve(r[0].fY, r[1].fY) };
pointsLeft >>= 1;
uint32_t a = generateCubicPoints(p0, q[0], r[0], s, tolSqd, points, pointsLeft);
uint32_t b = generateCubicPoints(s, r[1], q[2], p3, tolSqd, points, pointsLeft);
diff --git a/gpu/src/GrPathUtils.h b/gpu/src/GrPathUtils.h
index 97841dd..af05682 100644
--- a/gpu/src/GrPathUtils.h
+++ b/gpu/src/GrPathUtils.h
@@ -18,10 +18,9 @@
#define GrPathUtils_DEFINED
#include "GrNoncopyable.h"
-#include "GrScalar.h"
+#include "GrPoint.h"
class GrPathIter;
-struct GrPoint;
/**
* Utilities for evaluating paths.
diff --git a/include/core/SkPoint.h b/include/core/SkPoint.h
index 52dbd51..d74435e 100644
--- a/include/core/SkPoint.h
+++ b/include/core/SkPoint.h
@@ -171,9 +171,40 @@
fY = SkIntToScalar(p.fY);
}
+ void setAbs(const SkPoint& pt) {
+ fX = SkScalarAbs(pt.fX);
+ fY = SkScalarAbs(pt.fY);
+ }
+
+ // counter-clockwise fan
+ void setIRectFan(int l, int t, int r, int b) {
+ SkPoint* v = this;
+ v[0].set(SkIntToScalar(l), SkIntToScalar(t));
+ v[1].set(SkIntToScalar(l), SkIntToScalar(b));
+ v[2].set(SkIntToScalar(r), SkIntToScalar(b));
+ v[3].set(SkIntToScalar(r), SkIntToScalar(t));
+ }
+ void setIRectFan(int l, int t, int r, int b, size_t stride);
+
+ // counter-clockwise fan
+ void setRectFan(SkScalar l, SkScalar t, SkScalar r, SkScalar b) {
+ SkPoint* v = this;
+ v[0].set(l, t);
+ v[1].set(l, b);
+ v[2].set(r, b);
+ v[3].set(r, t);
+ }
+ void setRectFan(SkScalar l, SkScalar t, SkScalar r, SkScalar b, size_t stride);
+
+ void offset(SkScalar dx, SkScalar dy) {
+ fX += dx;
+ fY += dy;
+ }
+
/** Return the euclidian distance from (0,0) to the point
*/
SkScalar length() const { return SkPoint::Length(fX, fY); }
+ SkScalar distanceToOrigin() const { return this->length(); }
/** Set the point (vector) to be unit-length in the same direction as it
currently is, and return its old length. If the old length is
@@ -315,6 +346,32 @@
static SkScalar CrossProduct(const SkPoint& a, const SkPoint& b) {
return SkScalarMul(a.fX, b.fY) - SkScalarMul(a.fY, b.fX);
}
+
+ SkScalar cross(const SkPoint& vec) const {
+ return CrossProduct(*this, vec);
+ }
+
+ SkScalar dot(const SkPoint& vec) const {
+ return DotProduct(*this, vec);
+ }
+
+ SkScalar lengthSqd() const {
+ return DotProduct(*this, *this);
+ }
+
+ SkScalar distanceToSqd(const SkPoint& pt) const {
+ SkScalar dx = fX - pt.fX;
+ SkScalar dy = fY - pt.fY;
+ return SkScalarMul(dx, dx) + SkScalarMul(dy, dy);
+ }
+
+ SkScalar distanceToLineSegmentBetweenSqd(const SkPoint& a,
+ const SkPoint& b) const;
+
+ SkScalar distanceToLineSegmentBetween(const SkPoint& a,
+ const SkPoint& b) const {
+ return SkScalarSqrt(this->distanceToLineSegmentBetweenSqd(a, b));
+ }
};
typedef SkPoint SkVector;
diff --git a/src/core/SkPoint.cpp b/src/core/SkPoint.cpp
index feca12f..b5941d5 100644
--- a/src/core/SkPoint.cpp
+++ b/src/core/SkPoint.cpp
@@ -36,6 +36,29 @@
///////////////////////////////////////////////////////////////////////////////
+void SkPoint::setIRectFan(int l, int t, int r, int b, size_t stride) {
+ SkASSERT(stride >= sizeof(SkPoint));
+
+ ((SkPoint*)((intptr_t)this + 0 * stride))->set(SkIntToScalar(l),
+ SkIntToScalar(t));
+ ((SkPoint*)((intptr_t)this + 1 * stride))->set(SkIntToScalar(l),
+ SkIntToScalar(b));
+ ((SkPoint*)((intptr_t)this + 2 * stride))->set(SkIntToScalar(r),
+ SkIntToScalar(b));
+ ((SkPoint*)((intptr_t)this + 3 * stride))->set(SkIntToScalar(r),
+ SkIntToScalar(t));
+}
+
+void SkPoint::setRectFan(SkScalar l, SkScalar t, SkScalar r, SkScalar b,
+ size_t stride) {
+ SkASSERT(stride >= sizeof(SkPoint));
+
+ ((SkPoint*)((intptr_t)this + 0 * stride))->set(l, t);
+ ((SkPoint*)((intptr_t)this + 1 * stride))->set(l, b);
+ ((SkPoint*)((intptr_t)this + 2 * stride))->set(r, b);
+ ((SkPoint*)((intptr_t)this + 3 * stride))->set(r, t);
+}
+
void SkPoint::rotateCW(SkPoint* dst) const {
SkASSERT(dst);
@@ -343,3 +366,39 @@
#endif
+///////////////////////////////////////////////////////////////////////////////
+
+SkScalar SkPoint::distanceToLineSegmentBetweenSqd(const SkPoint& a,
+ const SkPoint& b) const {
+ // See comments to distanceToLineBetweenSqd. If the projection of c onto
+ // u is between a and b then this returns the same result as that
+ // function. Otherwise, it returns the distance to the closer of a and
+ // b. Let the projection of v onto u be v'. There are three cases:
+ // 1. v' points opposite to u. c is not between a and b and is closer
+ // to a than b.
+ // 2. v' points along u and has magnitude less than y. c is between
+ // a and b and the distance to the segment is the same as distance
+ // to the line ab.
+ // 3. v' points along u and has greater magnitude than u. c is not
+ // not between a and b and is closer to b than a.
+ // v' = (u dot v) * u / |u|. So if (u dot v)/|u| is less than zero we're
+ // in case 1. If (u dot v)/|u| is > |u| we are in case 3. Otherwise
+ // we're in case 2. We actually compare (u dot v) to 0 and |u|^2 to
+ // avoid a sqrt to compute |u|.
+
+ SkVector u = b - a;
+ SkVector v = *this - a;
+
+ SkScalar uLengthSqd = u.lengthSqd();
+ SkScalar uDotV = SkPoint::DotProduct(u, v);
+
+ if (uDotV <= 0) {
+ return v.lengthSqd();
+ } else if (uDotV > uLengthSqd) {
+ return b.distanceToSqd(*this);
+ } else {
+ SkScalar det = u.cross(v);
+ return SkScalarMulDiv(det, det, uLengthSqd);
+ }
+}
+