Create an skgpu::tess namespace
This is just a bunch of renaming, and for now the tessellate/shaders
directory remains untouched. The next steps will be to clean up and
remove all Ganesh v1 dependencies from tessellation.
Bug: skia:12524
Change-Id: I8cc166c0c78f9fb160de807131fa53fcc0765818
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/458876
Commit-Queue: Chris Dalton <csmartdalton@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
diff --git a/bench/TessellateBench.cpp b/bench/TessellateBench.cpp
index 7681d90..f83a98f 100644
--- a/bench/TessellateBench.cpp
+++ b/bench/TessellateBench.cpp
@@ -12,11 +12,11 @@
#include "src/gpu/GrDirectContextPriv.h"
#include "src/gpu/geometry/GrWangsFormula.h"
#include "src/gpu/mock/GrMockOpTarget.h"
-#include "src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h"
-#include "src/gpu/tessellate/GrPathCurveTessellator.h"
-#include "src/gpu/tessellate/GrPathWedgeTessellator.h"
-#include "src/gpu/tessellate/GrStrokeFixedCountTessellator.h"
-#include "src/gpu/tessellate/GrStrokeHardwareTessellator.h"
+#include "src/gpu/tessellate/MiddleOutPolygonTriangulator.h"
+#include "src/gpu/tessellate/PathCurveTessellator.h"
+#include "src/gpu/tessellate/PathWedgeTessellator.h"
+#include "src/gpu/tessellate/StrokeFixedCountTessellator.h"
+#include "src/gpu/tessellate/StrokeHardwareTessellator.h"
#include "tools/ToolUtils.h"
#include <vector>
@@ -119,10 +119,14 @@
SkArenaAlloc arena(1024);
GrPipeline noVaryingsPipeline(GrScissorTest::kDisabled, SkBlendMode::kSrcOver,
GrSwizzle::RGBA());
- auto tess = GrPathCurveTessellator::Make(&arena, fMatrix, SK_PMColor4fTRANSPARENT,
- GrPathCurveTessellator::DrawInnerFan::kNo,
- fTarget->caps().minPathVerbsForHwTessellation(),
- noVaryingsPipeline, fTarget->caps());
+ auto tess = skgpu::tess::PathCurveTessellator::Make(
+ &arena,
+ fMatrix,
+ SK_PMColor4fTRANSPARENT,
+ skgpu::tess::PathCurveTessellator::DrawInnerFan::kNo,
+ fTarget->caps().minPathVerbsForHwTessellation(),
+ noVaryingsPipeline,
+ fTarget->caps());
tess->prepare(fTarget.get(), SkRectPriv::MakeLargest(), {gAlmostIdentity, fPath},
fPath.countVerbs());
}
@@ -131,16 +135,20 @@
SkArenaAlloc arena(1024);
GrPipeline noVaryingsPipeline(GrScissorTest::kDisabled, SkBlendMode::kSrcOver,
GrSwizzle::RGBA());
- auto tess = GrPathWedgeTessellator::Make(&arena, fMatrix, SK_PMColor4fTRANSPARENT,
- fTarget->caps().minPathVerbsForHwTessellation(),
- noVaryingsPipeline, fTarget->caps());
+ auto tess = skgpu::tess::PathWedgeTessellator::Make(
+ &arena,
+ fMatrix,
+ SK_PMColor4fTRANSPARENT,
+ fTarget->caps().minPathVerbsForHwTessellation(),
+ noVaryingsPipeline,
+ fTarget->caps());
tess->prepare(fTarget.get(), SkRectPriv::MakeLargest(), {gAlmostIdentity, fPath},
fPath.countVerbs());
}
static void benchmark_wangs_formula_cubic_log2(const SkMatrix& matrix, const SkPath& path) {
int sum = 0;
- GrVectorXform xform(matrix);
+ skgpu::tess::VectorXform xform(matrix);
for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
if (verb == SkPathVerb::kCubic) {
sum += GrWangsFormula::cubic_log2(4, pts, xform);
@@ -168,7 +176,7 @@
static void benchmark_wangs_formula_conic(const SkMatrix& matrix, const SkPath& path) {
int sum = 0;
- GrVectorXform xform(matrix);
+ skgpu::tess::VectorXform xform(matrix);
for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
if (verb == SkPathVerb::kConic) {
sum += GrWangsFormula::conic(4, pts, *w, xform);
@@ -182,7 +190,7 @@
static void benchmark_wangs_formula_conic_log2(const SkMatrix& matrix, const SkPath& path) {
int sum = 0;
- GrVectorXform xform(matrix);
+ skgpu::tess::VectorXform xform(matrix);
for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
if (verb == SkPathVerb::kConic) {
sum += GrWangsFormula::conic_log2(4, pts, *w, xform);
@@ -210,32 +218,40 @@
GrVertexWriter vertexWriter = static_cast<SkPoint*>(fTarget->makeVertexSpace(
sizeof(SkPoint), kNumCubicsInChalkboard, &buffer, &baseVertex));
int numTrianglesWritten;
- GrMiddleOutPolygonTriangulator::WritePathInnerFan(std::move(vertexWriter), 0, 0,
- gAlmostIdentity, fPath, &numTrianglesWritten);
+ skgpu::tess::MiddleOutPolygonTriangulator::WritePathInnerFan(std::move(vertexWriter),
+ 0,
+ 0,
+ gAlmostIdentity,
+ fPath,
+ &numTrianglesWritten);
}
-using PathStrokeList = GrStrokeTessellator::PathStrokeList;
-using MakeTessellatorFn = std::unique_ptr<GrStrokeTessellator>(*)(ShaderFlags, const GrShaderCaps&,
- const SkMatrix&, PathStrokeList*,
- std::array<float, 2>, const
- SkRect&);
+using PathStrokeList = skgpu::tess::StrokeTessellator::PathStrokeList;
+using MakeTessellatorFn = std::unique_ptr<skgpu::tess::StrokeTessellator>(*)(ShaderFlags,
+ const GrShaderCaps&,
+ const SkMatrix&,
+ PathStrokeList*,
+ std::array<float, 2>,
+ const SkRect&);
-static std::unique_ptr<GrStrokeTessellator> make_hw_tessellator(
+static std::unique_ptr<skgpu::tess::StrokeTessellator> make_hw_tessellator(
ShaderFlags shaderFlags, const GrShaderCaps& shaderCaps, const SkMatrix& viewMatrix,
PathStrokeList* pathStrokeList, std::array<float, 2> matrixMinMaxScales,
const SkRect& strokeCullBounds) {
- return std::make_unique<GrStrokeHardwareTessellator>(shaderCaps, shaderFlags, viewMatrix,
- pathStrokeList, matrixMinMaxScales,
- strokeCullBounds);
+ return std::make_unique<skgpu::tess::StrokeHardwareTessellator>(shaderCaps, shaderFlags,
+ viewMatrix, pathStrokeList,
+ matrixMinMaxScales,
+ strokeCullBounds);
}
-static std::unique_ptr<GrStrokeTessellator> make_fixed_count_tessellator(
+static std::unique_ptr<skgpu::tess::StrokeTessellator> make_fixed_count_tessellator(
ShaderFlags shaderFlags, const GrShaderCaps& shaderCaps, const SkMatrix& viewMatrix,
PathStrokeList* pathStrokeList, std::array<float, 2> matrixMinMaxScales,
const SkRect& strokeCullBounds) {
- return std::make_unique<GrStrokeFixedCountTessellator>(shaderCaps, shaderFlags, viewMatrix,
- pathStrokeList, matrixMinMaxScales,
- strokeCullBounds);
+ return std::make_unique<skgpu::tess::StrokeFixedCountTessellator>(shaderCaps, shaderFlags,
+ viewMatrix, pathStrokeList,
+ matrixMinMaxScales,
+ strokeCullBounds);
}
using MakePathStrokesFn = std::vector<PathStrokeList>(*)();
@@ -355,7 +371,7 @@
float fMatrixScale;
std::unique_ptr<GrMockOpTarget> fTarget;
std::vector<PathStrokeList> fPathStrokes;
- std::unique_ptr<GrStrokeTessellator> fTessellator;
+ std::unique_ptr<skgpu::tess::StrokeTessellator> fTessellator;
SkArenaAlloc fPersistentArena{1024};
int fTotalVerbCount = 0;
};
diff --git a/gn/gpu.gni b/gn/gpu.gni
index 8745221..7a46b8e 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -325,22 +325,22 @@
"$_src/gpu/gradients/GrGradientShader.h",
# tessellate
- "$_src/gpu/tessellate/GrCullTest.h",
- "$_src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h",
- "$_src/gpu/tessellate/GrPathCurveTessellator.cpp",
- "$_src/gpu/tessellate/GrPathCurveTessellator.h",
- "$_src/gpu/tessellate/GrPathTessellator.h",
- "$_src/gpu/tessellate/GrPathWedgeTessellator.cpp",
- "$_src/gpu/tessellate/GrPathWedgeTessellator.h",
- "$_src/gpu/tessellate/GrPathXform.h",
- "$_src/gpu/tessellate/GrStrokeFixedCountTessellator.cpp",
- "$_src/gpu/tessellate/GrStrokeFixedCountTessellator.h",
- "$_src/gpu/tessellate/GrStrokeHardwareTessellator.cpp",
- "$_src/gpu/tessellate/GrStrokeHardwareTessellator.h",
- "$_src/gpu/tessellate/GrStrokeIterator.h",
- "$_src/gpu/tessellate/GrStrokeTessellator.h",
- "$_src/gpu/tessellate/GrTessTypes.h",
- "$_src/gpu/tessellate/GrVectorXform.h",
+ "$_src/gpu/tessellate/CullTest.h",
+ "$_src/gpu/tessellate/MiddleOutPolygonTriangulator.h",
+ "$_src/gpu/tessellate/PathCurveTessellator.cpp",
+ "$_src/gpu/tessellate/PathCurveTessellator.h",
+ "$_src/gpu/tessellate/PathTessellator.h",
+ "$_src/gpu/tessellate/PathWedgeTessellator.cpp",
+ "$_src/gpu/tessellate/PathWedgeTessellator.h",
+ "$_src/gpu/tessellate/PathXform.h",
+ "$_src/gpu/tessellate/StrokeFixedCountTessellator.cpp",
+ "$_src/gpu/tessellate/StrokeFixedCountTessellator.h",
+ "$_src/gpu/tessellate/StrokeHardwareTessellator.cpp",
+ "$_src/gpu/tessellate/StrokeHardwareTessellator.h",
+ "$_src/gpu/tessellate/StrokeIterator.h",
+ "$_src/gpu/tessellate/StrokeTessellator.h",
+ "$_src/gpu/tessellate/TessTypes.h",
+ "$_src/gpu/tessellate/VectorXform.h",
# tessellate/shaders
"$_src/gpu/tessellate/shaders/GrPathTessellationShader.cpp",
diff --git a/samplecode/SamplePathTessellators.cpp b/samplecode/SamplePathTessellators.cpp
index 109e84c..a147887 100644
--- a/samplecode/SamplePathTessellators.cpp
+++ b/samplecode/SamplePathTessellators.cpp
@@ -17,8 +17,8 @@
#include "src/gpu/ops/GrDrawOp.h"
#include "src/gpu/ops/GrSimpleMeshDrawOpHelper.h"
#include "src/gpu/ops/TessellationPathRenderer.h"
-#include "src/gpu/tessellate/GrPathCurveTessellator.h"
-#include "src/gpu/tessellate/GrPathWedgeTessellator.h"
+#include "src/gpu/tessellate/PathCurveTessellator.h"
+#include "src/gpu/tessellate/PathWedgeTessellator.h"
#include "src/gpu/tessellate/shaders/GrPathTessellationShader.h"
#include "src/gpu/v1/SurfaceDrawContext_v1.h"
@@ -83,28 +83,41 @@
auto pipeline = GrSimpleMeshDrawOpHelper::CreatePipeline(flushState, std::move(fProcessors),
fPipelineFlags);
switch (fMode) {
- using DrawInnerFan = GrPathCurveTessellator::DrawInnerFan;
+ using DrawInnerFan = skgpu::tess::PathCurveTessellator::DrawInnerFan;
case Mode::kWedgeMiddleOut:
- fTessellator = GrPathWedgeTessellator::Make(alloc, shaderMatrix, kCyan,
- numVerbsToGetMiddleOut, *pipeline,
- caps);
+ fTessellator = skgpu::tess::PathWedgeTessellator::Make(alloc,
+ shaderMatrix,
+ kCyan,
+ numVerbsToGetMiddleOut,
+ *pipeline,
+
+ caps);
break;
case Mode::kCurveMiddleOut:
- fTessellator = GrPathCurveTessellator::Make(alloc, shaderMatrix, kCyan,
- DrawInnerFan::kYes,
- numVerbsToGetMiddleOut, *pipeline,
- caps);
+ fTessellator = skgpu::tess::PathCurveTessellator::Make(alloc,
+ shaderMatrix,
+ kCyan,
+ DrawInnerFan::kYes,
+ numVerbsToGetMiddleOut,
+ *pipeline,
+ caps);
break;
case Mode::kWedgeTessellate:
- fTessellator = GrPathWedgeTessellator::Make(alloc, shaderMatrix, kCyan,
- numVerbsToGetTessellation, *pipeline,
- caps);
+ fTessellator = skgpu::tess::PathWedgeTessellator::Make(alloc,
+ shaderMatrix,
+ kCyan,
+ numVerbsToGetTessellation,
+ *pipeline,
+ caps);
break;
case Mode::kCurveTessellate:
- fTessellator = GrPathCurveTessellator::Make(alloc, shaderMatrix, kCyan,
- DrawInnerFan::kYes,
- numVerbsToGetTessellation, *pipeline,
- caps);
+ fTessellator = skgpu::tess::PathCurveTessellator::Make(alloc,
+ shaderMatrix,
+ kCyan,
+ DrawInnerFan::kYes,
+ numVerbsToGetTessellation,
+ *pipeline,
+ caps);
break;
}
fTessellator->prepare(flushState, this->bounds(), {pathMatrix, fPath}, fPath.countVerbs());
@@ -125,7 +138,7 @@
const SkMatrix fMatrix;
const GrPipeline::InputFlags fPipelineFlags;
const Mode fMode;
- GrPathTessellator* fTessellator = nullptr;
+ skgpu::tess::PathTessellator* fTessellator = nullptr;
GrProgramInfo* fProgram;
GrProcessorSet fProcessors{SkBlendMode::kSrcOver};
diff --git a/src/gpu/geometry/GrWangsFormula.h b/src/gpu/geometry/GrWangsFormula.h
index d2e3862..797a6d6 100644
--- a/src/gpu/geometry/GrWangsFormula.h
+++ b/src/gpu/geometry/GrWangsFormula.h
@@ -12,7 +12,7 @@
#include "include/core/SkString.h"
#include "include/private/SkFloatingPoint.h"
#include "src/gpu/GrVx.h"
-#include "src/gpu/tessellate/GrVectorXform.h"
+#include "src/gpu/tessellate/VectorXform.h"
// Wang's formula gives the minimum number of evenly spaced (in the parametric sense) line segments
// that a bezier curve must be chopped into in order to guarantee all lines stay within a distance
@@ -26,6 +26,8 @@
// to Curves and Surfaces for Geometric Modeling". Morgan Kaufmann Publishers.)
namespace GrWangsFormula {
+using skgpu::tess::VectorXform;
+
// Returns the value by which to multiply length in Wang's formula. (See above.)
template<int Degree> constexpr float length_term(float precision) {
return (Degree * (Degree - 1) / 8.f) * precision;
@@ -56,7 +58,7 @@
// Returns Wang's formula, raised to the 4th power, specialized for a quadratic curve.
SK_ALWAYS_INLINE static float quadratic_pow4(float precision, const SkPoint pts[],
- const GrVectorXform& vectorXform = GrVectorXform()) {
+ const VectorXform& vectorXform = VectorXform()) {
using grvx::float2, skvx::bit_pun;
float2 p0 = bit_pun<float2>(pts[0]);
float2 p1 = bit_pun<float2>(pts[1]);
@@ -69,21 +71,21 @@
// Returns Wang's formula specialized for a quadratic curve.
SK_ALWAYS_INLINE static float quadratic(float precision, const SkPoint pts[],
- const GrVectorXform& vectorXform = GrVectorXform()) {
+ const VectorXform& vectorXform = VectorXform()) {
return root4(quadratic_pow4(precision, pts, vectorXform));
}
// Returns the log2 value of Wang's formula specialized for a quadratic curve, rounded up to the
// next int.
SK_ALWAYS_INLINE static int quadratic_log2(float precision, const SkPoint pts[],
- const GrVectorXform& vectorXform = GrVectorXform()) {
+ const VectorXform& vectorXform = VectorXform()) {
// nextlog16(x) == ceil(log2(sqrt(sqrt(x))))
return nextlog16(quadratic_pow4(precision, pts, vectorXform));
}
// Returns Wang's formula, raised to the 4th power, specialized for a cubic curve.
SK_ALWAYS_INLINE static float cubic_pow4(float precision, const SkPoint pts[],
- const GrVectorXform& vectorXform = GrVectorXform()) {
+ const VectorXform& vectorXform = VectorXform()) {
using grvx::float4;
float4 p01 = float4::Load(pts);
float4 p12 = float4::Load(pts + 1);
@@ -96,14 +98,14 @@
// Returns Wang's formula specialized for a cubic curve.
SK_ALWAYS_INLINE static float cubic(float precision, const SkPoint pts[],
- const GrVectorXform& vectorXform = GrVectorXform()) {
+ const VectorXform& vectorXform = VectorXform()) {
return root4(cubic_pow4(precision, pts, vectorXform));
}
// Returns the log2 value of Wang's formula specialized for a cubic curve, rounded up to the next
// int.
SK_ALWAYS_INLINE static int cubic_log2(float precision, const SkPoint pts[],
- const GrVectorXform& vectorXform = GrVectorXform()) {
+ const VectorXform& vectorXform = VectorXform()) {
// nextlog16(x) == ceil(log2(sqrt(sqrt(x))))
return nextlog16(cubic_pow4(precision, pts, vectorXform));
}
@@ -132,7 +134,7 @@
// J. Zheng, T. Sederberg. "Estimating Tessellation Parameter Intervals for
// Rational Curves and Surfaces." ACM Transactions on Graphics 19(1). 2000.
SK_ALWAYS_INLINE static float conic_pow2(float precision, const SkPoint pts[], float w,
- const GrVectorXform& vectorXform = GrVectorXform()) {
+ const VectorXform& vectorXform = VectorXform()) {
using grvx::dot, grvx::float2, grvx::float4, skvx::bit_pun;
float2 p0 = vectorXform(bit_pun<float2>(pts[0]));
float2 p1 = vectorXform(bit_pun<float2>(pts[1]));
@@ -168,14 +170,14 @@
// Returns the value of Wang's formula specialized for a conic curve.
SK_ALWAYS_INLINE static float conic(float tolerance, const SkPoint pts[], float w,
- const GrVectorXform& vectorXform = GrVectorXform()) {
+ const VectorXform& vectorXform = VectorXform()) {
return sqrtf(conic_pow2(tolerance, pts, w, vectorXform));
}
// Returns the log2 value of Wang's formula specialized for a conic curve, rounded up to the next
// int.
SK_ALWAYS_INLINE static int conic_log2(float tolerance, const SkPoint pts[], float w,
- const GrVectorXform& vectorXform = GrVectorXform()) {
+ const VectorXform& vectorXform = VectorXform()) {
// nextlog4(x) == ceil(log2(sqrt(x)))
return nextlog4(conic_pow2(tolerance, pts, w, vectorXform));
}
diff --git a/src/gpu/ops/AtlasRenderTask.cpp b/src/gpu/ops/AtlasRenderTask.cpp
index e05908e..4e82d40 100644
--- a/src/gpu/ops/AtlasRenderTask.cpp
+++ b/src/gpu/ops/AtlasRenderTask.cpp
@@ -101,7 +101,7 @@
pathList->pathCount(),
GrPaint(),
GrAAType::kMSAA,
- GrTessellationPathFlags::kStencilOnly,
+ skgpu::tess::TessellationPathFlags::kStencilOnly,
drawRect);
this->addAtlasDrawOp(std::move(op), caps);
}
diff --git a/src/gpu/ops/AtlasRenderTask.h b/src/gpu/ops/AtlasRenderTask.h
index 7846966..f08a7e2 100644
--- a/src/gpu/ops/AtlasRenderTask.h
+++ b/src/gpu/ops/AtlasRenderTask.h
@@ -12,7 +12,7 @@
#include "src/core/SkTBlockList.h"
#include "src/gpu/GrDynamicAtlas.h"
#include "src/gpu/ops/OpsTask.h"
-#include "src/gpu/tessellate/GrPathTessellator.h"
+#include "src/gpu/tessellate/PathTessellator.h"
struct SkIPoint16;
@@ -61,7 +61,8 @@
const std::unique_ptr<GrDynamicAtlas> fDynamicAtlas;
// Allocate enough inline entries for 16 atlas path draws, then spill to the heap.
- using PathDrawAllocator = SkTBlockList<GrPathTessellator::PathDrawList, 16>;
+ using PathDrawList = skgpu::tess::PathTessellator::PathDrawList;
+ using PathDrawAllocator = SkTBlockList<PathDrawList, 16>;
PathDrawAllocator fPathDrawAllocator{64, SkBlockAllocator::GrowthPolicy::kFibonacci};
class AtlasPathList : SkNoncopyable {
@@ -75,12 +76,12 @@
fTotalCombinedPathVerbCnt += path.countVerbs();
++fPathCount;
}
- const GrPathTessellator::PathDrawList* pathDrawList() const { return fPathDrawList; }
+ const PathDrawList* pathDrawList() const { return fPathDrawList; }
int totalCombinedPathVerbCnt() const { return fTotalCombinedPathVerbCnt; }
int pathCount() const { return fPathCount; }
private:
- GrPathTessellator::PathDrawList* fPathDrawList = nullptr;
+ PathDrawList* fPathDrawList = nullptr;
int fTotalCombinedPathVerbCnt = 0;
int fPathCount = 0;
};
diff --git a/src/gpu/ops/PathInnerTriangulateOp.cpp b/src/gpu/ops/PathInnerTriangulateOp.cpp
index 9e8d1b8..759a882 100644
--- a/src/gpu/ops/PathInnerTriangulateOp.cpp
+++ b/src/gpu/ops/PathInnerTriangulateOp.cpp
@@ -13,10 +13,10 @@
#include "src/gpu/GrRecordingContextPriv.h"
#include "src/gpu/GrResourceProvider.h"
#include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"
-#include "src/gpu/tessellate/GrPathCurveTessellator.h"
+#include "src/gpu/tessellate/PathCurveTessellator.h"
#include "src/gpu/tessellate/shaders/GrPathTessellationShader.h"
-using PathFlags = GrTessellationPathFlags;
+using PathFlags = skgpu::tess::TessellationPathFlags;
namespace {
@@ -242,11 +242,14 @@
// Pass 1: Tessellate the outer curves into the stencil buffer.
if (!isLinear) {
- fTessellator = GrPathCurveTessellator::Make(args.fArena, fViewMatrix,
- SK_PMColor4fTRANSPARENT,
- GrPathCurveTessellator::DrawInnerFan::kNo,
- fPath.countVerbs(), *pipelineForStencils,
- *args.fCaps);
+ fTessellator = skgpu::tess::PathCurveTessellator::Make(
+ args.fArena,
+ fViewMatrix,
+ SK_PMColor4fTRANSPARENT,
+ skgpu::tess::PathCurveTessellator::DrawInnerFan::kNo,
+ fPath.countVerbs(),
+ *pipelineForStencils,
+ *args.fCaps);
const GrUserStencilSettings* stencilPathSettings =
GrPathTessellationShader::StencilPathSettings(GrFillRuleForSkPath(fPath));
fStencilCurvesProgram = GrTessellationShader::MakeProgram(args, fTessellator->shader(),
diff --git a/src/gpu/ops/PathInnerTriangulateOp.h b/src/gpu/ops/PathInnerTriangulateOp.h
index 6a7c45e..5380ae0 100644
--- a/src/gpu/ops/PathInnerTriangulateOp.h
+++ b/src/gpu/ops/PathInnerTriangulateOp.h
@@ -10,10 +10,14 @@
#include "src/gpu/geometry/GrInnerFanTriangulator.h"
#include "src/gpu/ops/GrDrawOp.h"
-#include "src/gpu/tessellate/GrTessTypes.h"
+#include "src/gpu/tessellate/TessTypes.h"
#include "src/gpu/tessellate/shaders/GrTessellationShader.h"
-class GrPathCurveTessellator;
+namespace skgpu::tess {
+
+class PathCurveTessellator;
+
+};
namespace skgpu::v1 {
@@ -29,8 +33,11 @@
private:
DEFINE_OP_CLASS_ID
- PathInnerTriangulateOp(const SkMatrix& viewMatrix, const SkPath& path, GrPaint&& paint,
- GrAAType aaType, GrTessellationPathFlags pathFlags,
+ PathInnerTriangulateOp(const SkMatrix& viewMatrix,
+ const SkPath& path,
+ GrPaint&& paint,
+ GrAAType aaType,
+ skgpu::tess::TessellationPathFlags pathFlags,
const SkRect& drawBounds)
: GrDrawOp(ClassID())
, fPathFlags(pathFlags)
@@ -59,7 +66,7 @@
void onPrepare(GrOpFlushState*) override;
void onExecute(GrOpFlushState*, const SkRect& chainBounds) override;
- const GrTessellationPathFlags fPathFlags;
+ const skgpu::tess::TessellationPathFlags fPathFlags;
const SkMatrix fViewMatrix;
const SkPath fPath;
const GrAAType fAAType;
@@ -75,7 +82,7 @@
const GrPipeline* fPipelineForFills = nullptr;
// Tessellates the outer curves.
- GrPathCurveTessellator* fTessellator = nullptr;
+ skgpu::tess::PathCurveTessellator* fTessellator = nullptr;
// Pass 1: Tessellate the outer curves into the stencil buffer.
const GrProgramInfo* fStencilCurvesProgram = nullptr;
diff --git a/src/gpu/ops/PathStencilCoverOp.cpp b/src/gpu/ops/PathStencilCoverOp.cpp
index 15cd7f8..e279e07 100644
--- a/src/gpu/ops/PathStencilCoverOp.cpp
+++ b/src/gpu/ops/PathStencilCoverOp.cpp
@@ -16,12 +16,12 @@
#include "src/gpu/glsl/GrGLSLVarying.h"
#include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"
#include "src/gpu/ops/GrSimpleMeshDrawOpHelper.h"
-#include "src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h"
-#include "src/gpu/tessellate/GrPathCurveTessellator.h"
-#include "src/gpu/tessellate/GrPathWedgeTessellator.h"
+#include "src/gpu/tessellate/MiddleOutPolygonTriangulator.h"
+#include "src/gpu/tessellate/PathCurveTessellator.h"
+#include "src/gpu/tessellate/PathWedgeTessellator.h"
#include "src/gpu/tessellate/shaders/GrPathTessellationShader.h"
-using PathFlags = GrTessellationPathFlags;
+using PathFlags = skgpu::tess::TessellationPathFlags;
namespace {
@@ -154,20 +154,21 @@
shader,
stencilPipeline,
stencilSettings);
- fTessellator = GrPathCurveTessellator::Make(args.fArena,
- shaderMatrix,
- SK_PMColor4fTRANSPARENT,
- GrPathCurveTessellator::DrawInnerFan::kNo,
- fTotalCombinedPathVerbCnt,
- *stencilPipeline,
- *args.fCaps);
+ fTessellator = skgpu::tess::PathCurveTessellator::Make(
+ args.fArena,
+ shaderMatrix,
+ SK_PMColor4fTRANSPARENT,
+ skgpu::tess::PathCurveTessellator::DrawInnerFan::kNo,
+ fTotalCombinedPathVerbCnt,
+ *stencilPipeline,
+ *args.fCaps);
} else {
- fTessellator = GrPathWedgeTessellator::Make(args.fArena,
- shaderMatrix,
- SK_PMColor4fTRANSPARENT,
- fTotalCombinedPathVerbCnt,
- *stencilPipeline,
- *args.fCaps);
+ fTessellator = skgpu::tess::PathWedgeTessellator::Make(args.fArena,
+ shaderMatrix,
+ SK_PMColor4fTRANSPARENT,
+ fTotalCombinedPathVerbCnt,
+ *stencilPipeline,
+ *args.fCaps);
}
fStencilPathProgram = GrTessellationShader::MakeProgram(args,
fTessellator->shader(),
@@ -236,8 +237,8 @@
// The inner fan isn't built into the tessellator. Generate a standard Redbook fan with a
// middle-out topology.
GrEagerDynamicVertexAllocator vertexAlloc(flushState, &fFanBuffer, &fFanBaseVertex);
- int maxCombinedFanEdges =
- GrPathTessellator::MaxCombinedFanEdgesInPathDrawList(fTotalCombinedPathVerbCnt);
+ int maxCombinedFanEdges = skgpu::tess::PathTessellator::MaxCombinedFanEdgesInPathDrawList(
+ fTotalCombinedPathVerbCnt);
// A single n-sided polygon is fanned by n-2 triangles. Multiple polygons with a combined
// edge count of n are fanned by strictly fewer triangles.
int maxTrianglesInFans = std::max(maxCombinedFanEdges - 2, 0);
@@ -245,7 +246,7 @@
int fanTriangleCount = 0;
for (auto [pathMatrix, path] : *fPathDrawList) {
int numTrianglesWritten;
- triangleVertexWriter = GrMiddleOutPolygonTriangulator::WritePathInnerFan(
+ triangleVertexWriter = skgpu::tess::MiddleOutPolygonTriangulator::WritePathInnerFan(
std::move(triangleVertexWriter),
0,
0,
diff --git a/src/gpu/ops/PathStencilCoverOp.h b/src/gpu/ops/PathStencilCoverOp.h
index 6a45298..45a82be 100644
--- a/src/gpu/ops/PathStencilCoverOp.h
+++ b/src/gpu/ops/PathStencilCoverOp.h
@@ -9,8 +9,8 @@
#define PathStencilCoverOp_DEFINED
#include "src/gpu/ops/GrDrawOp.h"
-#include "src/gpu/tessellate/GrPathTessellator.h"
-#include "src/gpu/tessellate/GrTessTypes.h"
+#include "src/gpu/tessellate/PathTessellator.h"
+#include "src/gpu/tessellate/TessTypes.h"
#include "src/gpu/tessellate/shaders/GrTessellationShader.h"
namespace skgpu::v1 {
@@ -22,7 +22,7 @@
private:
DEFINE_OP_CLASS_ID
- using PathDrawList = GrPathTessellator::PathDrawList;
+ using PathDrawList = skgpu::tess::PathTessellator::PathDrawList;
// If the path is inverse filled, drawBounds must be the entire backing store dimensions of the
// render target.
@@ -31,7 +31,7 @@
const SkPath& path,
GrPaint&& paint,
GrAAType aaType,
- GrTessellationPathFlags pathFlags,
+ skgpu::tess::TessellationPathFlags pathFlags,
const SkRect& drawBounds)
: GrDrawOp(ClassID())
, fPathDrawList(arena->make<PathDrawList>(viewMatrix, path))
@@ -47,13 +47,13 @@
// Constructs a PathStencilCoverOp from an existing draw list.
// FIXME: The only user of this method is the atlas. We should move the GrProgramInfos into
- // GrPathTessellator so the atlas can use that directly instead of going through this class.
+ // PathTessellator so the atlas can use that directly instead of going through this class.
PathStencilCoverOp(const PathDrawList* pathDrawList,
int totalCombinedVerbCnt,
int pathCount,
GrPaint&& paint,
GrAAType aaType,
- GrTessellationPathFlags pathFlags,
+ skgpu::tess::TessellationPathFlags pathFlags,
const SkRect& drawBounds)
: GrDrawOp(ClassID())
, fPathDrawList(pathDrawList)
@@ -89,14 +89,14 @@
const PathDrawList* fPathDrawList;
const int fTotalCombinedPathVerbCnt;
const int fPathCount;
- const GrTessellationPathFlags fPathFlags;
+ const skgpu::tess::TessellationPathFlags fPathFlags;
const GrAAType fAAType;
SkPMColor4f fColor;
GrProcessorSet fProcessors;
SkDEBUGCODE(SkRect fOriginalDrawBounds;)
// Decided during prePreparePrograms.
- GrPathTessellator* fTessellator = nullptr;
+ skgpu::tess::PathTessellator* fTessellator = nullptr;
const GrProgramInfo* fStencilFanProgram = nullptr;
const GrProgramInfo* fStencilPathProgram = nullptr;
const GrProgramInfo* fCoverBBoxProgram = nullptr;
diff --git a/src/gpu/ops/PathTessellateOp.cpp b/src/gpu/ops/PathTessellateOp.cpp
index 6249a22..402efe2 100644
--- a/src/gpu/ops/PathTessellateOp.cpp
+++ b/src/gpu/ops/PathTessellateOp.cpp
@@ -9,7 +9,7 @@
#include "src/gpu/GrAppliedClip.h"
#include "src/gpu/GrOpFlushState.h"
-#include "src/gpu/tessellate/GrPathWedgeTessellator.h"
+#include "src/gpu/tessellate/PathWedgeTessellator.h"
#include "src/gpu/tessellate/shaders/GrPathTessellationShader.h"
namespace skgpu::v1 {
@@ -35,8 +35,9 @@
SkASSERT(!fTessellationProgram);
auto* pipeline = GrTessellationShader::MakePipeline(args, fAAType, std::move(appliedClip),
std::move(fProcessors));
- fTessellator = GrPathWedgeTessellator::Make(args.fArena, fViewMatrix, fColor,
- fPath.countVerbs(), *pipeline, *args.fCaps);
+ fTessellator = skgpu::tess::PathWedgeTessellator::Make(args.fArena, fViewMatrix, fColor,
+ fPath.countVerbs(), *pipeline,
+ *args.fCaps);
fTessellationProgram = GrTessellationShader::MakeProgram(args, fTessellator->shader(), pipeline,
fStencil);
}
diff --git a/src/gpu/ops/PathTessellateOp.h b/src/gpu/ops/PathTessellateOp.h
index d265ac2..905ffd7 100644
--- a/src/gpu/ops/PathTessellateOp.h
+++ b/src/gpu/ops/PathTessellateOp.h
@@ -11,7 +11,11 @@
#include "src/gpu/ops/GrDrawOp.h"
#include "src/gpu/tessellate/shaders/GrTessellationShader.h"
-class GrPathTessellator;
+namespace skgpu::tess {
+
+class PathTessellator;
+
+};
namespace skgpu::v1 {
@@ -56,7 +60,7 @@
GrProcessorSet fProcessors;
// Decided during prepareTessellator.
- GrPathTessellator* fTessellator = nullptr;
+ skgpu::tess::PathTessellator* fTessellator = nullptr;
const GrProgramInfo* fTessellationProgram = nullptr;
friend class GrOp; // For ctor.
diff --git a/src/gpu/ops/StrokeTessellateOp.cpp b/src/gpu/ops/StrokeTessellateOp.cpp
index a755802..aff5ee6 100644
--- a/src/gpu/ops/StrokeTessellateOp.cpp
+++ b/src/gpu/ops/StrokeTessellateOp.cpp
@@ -11,8 +11,8 @@
#include "src/gpu/GrAppliedClip.h"
#include "src/gpu/GrOpFlushState.h"
#include "src/gpu/GrRecordingContextPriv.h"
-#include "src/gpu/tessellate/GrStrokeFixedCountTessellator.h"
-#include "src/gpu/tessellate/GrStrokeHardwareTessellator.h"
+#include "src/gpu/tessellate/StrokeFixedCountTessellator.h"
+#include "src/gpu/tessellate/StrokeHardwareTessellator.h"
#include "src/gpu/tessellate/shaders/GrTessellationShader.h"
using DynamicStroke = GrStrokeTessellationShader::DynamicStroke;
@@ -199,15 +199,19 @@
if (can_use_hardware_tessellation(fTotalCombinedVerbCnt, *pipeline, caps)) {
// Only use hardware tessellation if we're drawing a somewhat large number of verbs.
// Otherwise we seem to be better off using instanced draws.
- fTessellator = arena->make<GrStrokeHardwareTessellator>(*caps.shaderCaps(), fShaderFlags,
- fViewMatrix, &fPathStrokeList,
- matrixMinMaxScales,
- strokeCullBounds);
+ fTessellator = arena->make<skgpu::tess::StrokeHardwareTessellator>(*caps.shaderCaps(),
+ fShaderFlags,
+ fViewMatrix,
+ &fPathStrokeList,
+ matrixMinMaxScales,
+ strokeCullBounds);
} else {
- fTessellator = arena->make<GrStrokeFixedCountTessellator>(*caps.shaderCaps(), fShaderFlags,
- fViewMatrix, &fPathStrokeList,
- matrixMinMaxScales,
- strokeCullBounds);
+ fTessellator = arena->make<skgpu::tess::StrokeFixedCountTessellator>(*caps.shaderCaps(),
+ fShaderFlags,
+ fViewMatrix,
+ &fPathStrokeList,
+ matrixMinMaxScales,
+ strokeCullBounds);
}
auto fillStencil = &GrUserStencilSettings::kUnused;
diff --git a/src/gpu/ops/StrokeTessellateOp.h b/src/gpu/ops/StrokeTessellateOp.h
index 73b5784..9bb2bb1 100644
--- a/src/gpu/ops/StrokeTessellateOp.h
+++ b/src/gpu/ops/StrokeTessellateOp.h
@@ -10,7 +10,7 @@
#include "include/core/SkStrokeRec.h"
#include "src/gpu/ops/GrDrawOp.h"
-#include "src/gpu/tessellate/GrStrokeTessellator.h"
+#include "src/gpu/tessellate/StrokeTessellator.h"
#include "src/gpu/tessellate/shaders/GrTessellationShader.h"
class GrRecordingContext;
@@ -25,7 +25,7 @@
private:
using ShaderFlags = GrStrokeTessellationShader::ShaderFlags;
- using PathStrokeList = GrStrokeTessellator::PathStrokeList;
+ using PathStrokeList = skgpu::tess::StrokeTessellator::PathStrokeList;
DEFINE_OP_CLASS_ID
SkStrokeRec& headStroke() { return fPathStrokeList.fStroke; }
@@ -74,7 +74,7 @@
GrProcessorSet fProcessors;
bool fNeedsStencil;
- GrStrokeTessellator* fTessellator = nullptr;
+ skgpu::tess::StrokeTessellator* fTessellator = nullptr;
const GrProgramInfo* fStencilProgram = nullptr; // Only used if the stroke has transparency.
const GrProgramInfo* fFillProgram = nullptr;
};
diff --git a/src/gpu/ops/TessellationPathRenderer.cpp b/src/gpu/ops/TessellationPathRenderer.cpp
index b7beb93..90ff692 100644
--- a/src/gpu/ops/TessellationPathRenderer.cpp
+++ b/src/gpu/ops/TessellationPathRenderer.cpp
@@ -25,7 +25,7 @@
GrOp::Owner make_non_convex_fill_op(GrRecordingContext* rContext,
SkArenaAlloc* arena,
- GrTessellationPathFlags pathFlags,
+ skgpu::tess::TessellationPathFlags pathFlags,
GrAAType aaType,
const SkRect& drawBounds,
const SkMatrix& viewMatrix,
@@ -150,7 +150,7 @@
: pathDevBounds;
auto op = make_non_convex_fill_op(args.fContext,
args.fSurfaceDrawContext->arenaAlloc(),
- GrTessellationPathFlags::kNone,
+ skgpu::tess::TessellationPathFlags::kNone,
args.fAAType,
drawBounds,
*args.fViewMatrix,
@@ -194,7 +194,7 @@
auto op = make_non_convex_fill_op(args.fContext,
args.fSurfaceDrawContext->arenaAlloc(),
- GrTessellationPathFlags::kStencilOnly,
+ skgpu::tess::TessellationPathFlags::kStencilOnly,
aaType,
pathDevBounds,
*args.fViewMatrix,
diff --git a/src/gpu/tessellate/GrCullTest.h b/src/gpu/tessellate/CullTest.h
similarity index 93%
rename from src/gpu/tessellate/GrCullTest.h
rename to src/gpu/tessellate/CullTest.h
index 768f1cb..77e3726 100644
--- a/src/gpu/tessellate/GrCullTest.h
+++ b/src/gpu/tessellate/CullTest.h
@@ -5,13 +5,15 @@
* found in the LICENSE file.
*/
-#ifndef GrCullTest_DEFINED
-#define GrCullTest_DEFINED
+#ifndef tessellate_CullTest_DEFINED
+#define tessellate_CullTest_DEFINED
#include "include/core/SkMatrix.h"
#include "include/private/SkVx.h"
#include "src/gpu/GrVx.h"
+namespace skgpu::tess {
+
// This class determines whether the given local-space points will be contained in the cull bounds
// post transform. For the versions that take >1 point, it returns whether any region of their
// device-space bounding box will be in the cull bounds.
@@ -19,11 +21,11 @@
// NOTE: Our view matrix is not a normal matrix. M*p maps to the float4 [x, y, -x, -y] in device
// space. We do this to aid in quick bounds calculations. The matrix also does not have a
// translation element. Instead we unapply the translation to the cull bounds ahead of time.
-class GrCullTest {
+class CullTest {
public:
- GrCullTest() = default;
+ CullTest() = default;
- GrCullTest(const SkRect& devCullBounds, const SkMatrix& m) {
+ CullTest(const SkRect& devCullBounds, const SkMatrix& m) {
this->set(devCullBounds, m);
}
@@ -101,4 +103,6 @@
grvx::float4 fCullBounds; // [l, t, -r, -b]
};
-#endif
+} // namespace skgpu::tess
+
+#endif // tessellate_CullTest_DEFINED
diff --git a/src/gpu/tessellate/GrStrokeFixedCountTessellator.h b/src/gpu/tessellate/GrStrokeFixedCountTessellator.h
deleted file mode 100644
index 8b67dc0..0000000
--- a/src/gpu/tessellate/GrStrokeFixedCountTessellator.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright 2021 Google LLC.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrStrokeFixedCountTessellator_DEFINED
-#define GrStrokeFixedCountTessellator_DEFINED
-
-#include "src/gpu/GrVertexChunkArray.h"
-#include "src/gpu/tessellate/GrStrokeTessellator.h"
-
-// Renders strokes as fixed-count triangle strip instances. Any extra triangles not needed by the
-// instance are emitted as degenerate triangles.
-class GrStrokeFixedCountTessellator : public GrStrokeTessellator {
-public:
- GrStrokeFixedCountTessellator(const GrShaderCaps&, ShaderFlags, const SkMatrix&,
- PathStrokeList*, std::array<float, 2> matrixMinMaxScales,
- const SkRect& strokeCullBounds);
-
- void prepare(GrMeshDrawTarget*, int totalCombinedVerbCnt) override;
-#if SK_GPU_V1
- void draw(GrOpFlushState*) const override;
-#endif
-
-private:
- GrVertexChunkArray fInstanceChunks;
- int fFixedVertexCount = 0;
-
- // Only used if sk_VertexID is not supported.
- sk_sp<const GrGpuBuffer> fVertexBufferIfNoIDSupport;
-};
-
-#endif
diff --git a/src/gpu/tessellate/GrStrokeHardwareTessellator.h b/src/gpu/tessellate/GrStrokeHardwareTessellator.h
deleted file mode 100644
index 45eb84c..0000000
--- a/src/gpu/tessellate/GrStrokeHardwareTessellator.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright 2020 Google LLC.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrStrokeHardwareTessellator_DEFINED
-#define GrStrokeHardwareTessellator_DEFINED
-
-#include "src/gpu/GrVertexChunkArray.h"
-#include "src/gpu/tessellate/GrStrokeTessellator.h"
-
-// Renders opaque, constant-color strokes by decomposing them into standalone tessellation patches.
-// Each patch is either a "cubic" (single stroked bezier curve with butt caps) or a "join". Requires
-// MSAA if antialiasing is desired.
-class GrStrokeHardwareTessellator : public GrStrokeTessellator {
-public:
- GrStrokeHardwareTessellator(const GrShaderCaps& shaderCaps, ShaderFlags shaderFlags,
- const SkMatrix& viewMatrix, PathStrokeList* pathStrokeList,
- std::array<float,2> matrixMinMaxScales,
- const SkRect& strokeCullBounds);
-
- void prepare(GrMeshDrawTarget*, int totalCombinedVerbCnt) override;
-#if SK_GPU_V1
- void draw(GrOpFlushState*) const override;
-#endif
-
-private:
- GrVertexChunkArray fPatchChunks;
-};
-
-#endif
diff --git a/src/gpu/tessellate/GrTessTypes.h b/src/gpu/tessellate/GrTessTypes.h
deleted file mode 100644
index e14e79c..0000000
--- a/src/gpu/tessellate/GrTessTypes.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright 2021 Google LLC
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrTessTypes_DEFINED
-#define GrTessTypes_DEFINED
-
-#include "include/gpu/GrTypes.h"
-
-// We send these flags to the internal path filling Ops to control how a path gets rendered.
-enum class GrTessellationPathFlags {
- kNone = 0,
- kStencilOnly = (1 << 0),
- kWireframe = (1 << 1)
-};
-
-GR_MAKE_BITFIELD_CLASS_OPS(GrTessellationPathFlags)
-
-#endif
diff --git a/src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h b/src/gpu/tessellate/MiddleOutPolygonTriangulator.h
similarity index 93%
rename from src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h
rename to src/gpu/tessellate/MiddleOutPolygonTriangulator.h
index 2fc1806..a05f9c2 100644
--- a/src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h
+++ b/src/gpu/tessellate/MiddleOutPolygonTriangulator.h
@@ -5,8 +5,8 @@
* found in the LICENSE file.
*/
-#ifndef GrMiddleOutPolygonTriangulator_DEFINED
-#define GrMiddleOutPolygonTriangulator_DEFINED
+#ifndef tessellate_MiddleOutPolygonTriangulator_DEFINED
+#define tessellate_MiddleOutPolygonTriangulator_DEFINED
#include "include/core/SkPath.h"
#include "include/core/SkPoint.h"
@@ -14,7 +14,9 @@
#include "src/core/SkMathPriv.h"
#include "src/core/SkPathPriv.h"
#include "src/gpu/GrVertexWriter.h"
-#include "src/gpu/tessellate/GrPathXform.h"
+#include "src/gpu/tessellate/PathXform.h"
+
+namespace skgpu::tess {
// This class emits a polygon triangulation with a "middle-out" topology. Conceptually, middle-out
// emits one large triangle with vertices on both endpoints and a middle point, then recurses on
@@ -42,13 +44,13 @@
// This class is designed to not know or store all the vertices in the polygon at once. The caller
// pushes each vertex in linear order (perhaps while parsing a path), then rather than relying on
// recursion, we manipulate an O(log N) stack to determine the correct middle-out triangulation.
-class GrMiddleOutPolygonTriangulator {
+class MiddleOutPolygonTriangulator {
public:
// Writes out 3 SkPoints per triangle to "vertexWriter". Additionally writes out "pad32Count"
// repetitions of "pad32Value" after each triangle. Set pad32Count to 0 if the triangles are
// to be tightly packed.
- GrMiddleOutPolygonTriangulator(GrVertexWriter&& vertexWriter, int pad32Count,
- uint32_t pad32Value, int maxPushVertexCalls)
+ MiddleOutPolygonTriangulator(GrVertexWriter&& vertexWriter, int pad32Count,
+ uint32_t pad32Value, int maxPushVertexCalls)
: fVertexWriter(std::move(vertexWriter))
, fPad32Count(pad32Count)
, fPad32Value(pad32Value) {
@@ -128,10 +130,10 @@
static GrVertexWriter WritePathInnerFan(GrVertexWriter&& vertexWriter,
int pad32Count,
uint32_t pad32Value,
- const GrPathXform& pathXform,
+ const PathXform& pathXform,
const SkPath& path,
int* numTrianglesWritten) {
- GrMiddleOutPolygonTriangulator middleOut(std::move(vertexWriter),
+ MiddleOutPolygonTriangulator middleOut(std::move(vertexWriter),
pad32Count,
pad32Value,
path.countVerbs());
@@ -197,4 +199,6 @@
int fTotalClosedTriangleCount = 0;
};
-#endif
+} // namespace skgpu::tess
+
+#endif // tessellate_MiddleOutPolygonTriangulator_DEFINED
diff --git a/src/gpu/tessellate/GrPathCurveTessellator.cpp b/src/gpu/tessellate/PathCurveTessellator.cpp
similarity index 90%
rename from src/gpu/tessellate/GrPathCurveTessellator.cpp
rename to src/gpu/tessellate/PathCurveTessellator.cpp
index 0d8da9c..1bcd4c0 100644
--- a/src/gpu/tessellate/GrPathCurveTessellator.cpp
+++ b/src/gpu/tessellate/PathCurveTessellator.cpp
@@ -5,18 +5,24 @@
* found in the LICENSE file.
*/
-#include "src/gpu/tessellate/GrPathCurveTessellator.h"
+#include "src/gpu/tessellate/PathCurveTessellator.h"
#include "src/core/SkUtils.h"
#include "src/gpu/GrMeshDrawTarget.h"
#include "src/gpu/GrResourceProvider.h"
#include "src/gpu/geometry/GrPathUtils.h"
#include "src/gpu/geometry/GrWangsFormula.h"
-#include "src/gpu/tessellate/GrCullTest.h"
-#include "src/gpu/tessellate/GrMiddleOutPolygonTriangulator.h"
-#include "src/gpu/tessellate/GrPathXform.h"
+#include "src/gpu/tessellate/CullTest.h"
+#include "src/gpu/tessellate/MiddleOutPolygonTriangulator.h"
+#include "src/gpu/tessellate/PathXform.h"
#include "src/gpu/tessellate/shaders/GrPathTessellationShader.h"
+#if SK_GPU_V1
+#include "src/gpu/GrOpFlushState.h"
+#endif
+
+namespace skgpu::tess {
+
namespace {
constexpr static float kPrecision = GrTessellationShader::kLinearizationPrecision;
@@ -151,9 +157,9 @@
}
}
- GrCullTest fCullTest;
- GrVectorXform fTotalVectorXform;
- GrPathXform fPathXform;
+ CullTest fCullTest;
+ VectorXform fTotalVectorXform;
+ PathXform fPathXform;
const float fMaxSegments_pow2;
const float fMaxSegments_pow4;
@@ -165,12 +171,13 @@
} // namespace
-GrPathCurveTessellator* GrPathCurveTessellator::Make(SkArenaAlloc* arena,
- const SkMatrix& viewMatrix,
- const SkPMColor4f& color,
- DrawInnerFan drawInnerFan, int numPathVerbs,
- const GrPipeline& pipeline,
- const GrCaps& caps) {
+PathCurveTessellator* PathCurveTessellator::Make(SkArenaAlloc* arena,
+ const SkMatrix& viewMatrix,
+ const SkPMColor4f& color,
+ DrawInnerFan drawInnerFan,
+ int numPathVerbs,
+ const GrPipeline& pipeline,
+ const GrCaps& caps) {
using PatchType = GrPathTessellationShader::PatchType;
GrPathTessellationShader* shader;
if (caps.shaderCaps()->tessellationSupport() &&
@@ -185,18 +192,18 @@
PatchType::kCurves);
}
return arena->make([=](void* objStart) {
- return new(objStart) GrPathCurveTessellator(shader, drawInnerFan);
+ return new(objStart) PathCurveTessellator(shader, drawInnerFan);
});
}
GR_DECLARE_STATIC_UNIQUE_KEY(gFixedCountVertexBufferKey);
GR_DECLARE_STATIC_UNIQUE_KEY(gFixedCountIndexBufferKey);
-void GrPathCurveTessellator::prepare(GrMeshDrawTarget* target,
- const SkRect& cullBounds,
- const PathDrawList& pathDrawList,
- int totalCombinedPathVerbCnt,
- const BreadcrumbTriangleList* breadcrumbTriangleList) {
+void PathCurveTessellator::prepare(GrMeshDrawTarget* target,
+ const SkRect& cullBounds,
+ const PathDrawList& pathDrawList,
+ int totalCombinedPathVerbCnt,
+ const BreadcrumbTriangleList* breadcrumbTriangleList) {
SkASSERT(fVertexChunkArray.empty());
const GrShaderCaps& shaderCaps = *target->caps().shaderCaps();
@@ -240,7 +247,7 @@
: sk_bit_cast<uint32_t>(GrTessellationShader::kTriangularConicCurveType);
for (auto [pathMatrix, path] : pathDrawList) {
int numTrianglesWritten;
- vertexWriter = GrMiddleOutPolygonTriangulator::WritePathInnerFan(
+ vertexWriter = MiddleOutPolygonTriangulator::WritePathInnerFan(
std::move(vertexWriter),
pad32Count,
pad32Value,
@@ -344,9 +351,7 @@
}
#if SK_GPU_V1
-#include "src/gpu/GrOpFlushState.h"
-
-void GrPathCurveTessellator::draw(GrOpFlushState* flushState) const {
+void PathCurveTessellator::draw(GrOpFlushState* flushState) const {
if (fShader->willUseTessellationShaders()) {
for (const GrVertexChunk& chunk : fVertexChunkArray) {
flushState->bindBuffers(nullptr, nullptr, chunk.fBuffer);
@@ -361,11 +366,13 @@
}
}
-void GrPathCurveTessellator::drawHullInstances(
- GrOpFlushState* flushState, sk_sp<const GrGpuBuffer> vertexBufferIfNeeded) const {
+void PathCurveTessellator::drawHullInstances(GrOpFlushState* flushState,
+ sk_sp<const GrGpuBuffer> vertexBufferIfNeeded) const {
for (const GrVertexChunk& chunk : fVertexChunkArray) {
flushState->bindBuffers(nullptr, chunk.fBuffer, vertexBufferIfNeeded);
flushState->drawInstanced(chunk.fCount, chunk.fBase, 4, 0);
}
}
#endif
+
+} // namespace skgpu::tess
diff --git a/src/gpu/tessellate/GrPathCurveTessellator.h b/src/gpu/tessellate/PathCurveTessellator.h
similarity index 72%
rename from src/gpu/tessellate/GrPathCurveTessellator.h
rename to src/gpu/tessellate/PathCurveTessellator.h
index 97a960c..504877e 100644
--- a/src/gpu/tessellate/GrPathCurveTessellator.h
+++ b/src/gpu/tessellate/PathCurveTessellator.h
@@ -5,20 +5,22 @@
* found in the LICENSE file.
*/
-#ifndef GrPathCurveTessellator_DEFINED
-#define GrPathCurveTessellator_DEFINED
+#ifndef tessellate_PathCurveTessellator_DEFINED
+#define tessellate_PathCurveTessellator_DEFINED
#include "src/gpu/GrVertexChunkArray.h"
-#include "src/gpu/tessellate/GrPathTessellator.h"
+#include "src/gpu/tessellate/PathTessellator.h"
class GrCaps;
class GrGpuBuffer;
class GrPipeline;
+namespace skgpu::tess {
+
// Draws an array of "outer curve" patches and, optionally, inner fan triangles for
// GrCubicTessellateShader. Each patch is an independent 4-point curve, representing either a cubic
// or a conic. Quadratics are converted to cubics and triangles are converted to conics with w=Inf.
-class GrPathCurveTessellator : public GrPathTessellator {
+class PathCurveTessellator : public PathTessellator {
public:
// If DrawInnerFan is kNo, this class only emits the path's outer curves. In that case the
// caller is responsible to handle the path's inner fan.
@@ -28,9 +30,13 @@
};
// Creates a curve tessellator with the shader type best suited for the given path description.
- static GrPathCurveTessellator* Make(SkArenaAlloc*, const SkMatrix& viewMatrix,
- const SkPMColor4f&, DrawInnerFan, int numPathVerbs,
- const GrPipeline&, const GrCaps&);
+ static PathCurveTessellator* Make(SkArenaAlloc*,
+ const SkMatrix& viewMatrix,
+ const SkPMColor4f&,
+ DrawInnerFan,
+ int numPathVerbs,
+ const GrPipeline&,
+ const GrCaps&);
void prepare(GrMeshDrawTarget* target,
const SkRect& cullBounds,
@@ -39,7 +45,7 @@
this->prepare(target, cullBounds, pathDrawList, totalCombinedPathVerbCnt, nullptr);
}
- // Implements GrPathTessellator::prepare(), also sending an additional list of breadcrumb
+ // Implements PathTessellator::prepare(), also sending an additional list of breadcrumb
// triangles to the GPU. The breadcrumb triangles are implemented as conics with w=Infinity.
//
// ALSO NOTE: The breadcrumb triangles do not have a matrix. These need to be pre-transformed by
@@ -60,8 +66,8 @@
#endif
private:
- GrPathCurveTessellator(GrPathTessellationShader* shader, DrawInnerFan drawInnerFan)
- : GrPathTessellator(shader)
+ PathCurveTessellator(GrPathTessellationShader* shader, DrawInnerFan drawInnerFan)
+ : PathTessellator(shader)
, fDrawInnerFan(drawInnerFan == DrawInnerFan::kYes) {}
const bool fDrawInnerFan;
@@ -73,4 +79,6 @@
sk_sp<const GrGpuBuffer> fFixedCountIndexBuffer;
};
-#endif
+} // namespace skgpu::tess
+
+#endif // tessellate_PathCurveTessellator_DEFINED
diff --git a/src/gpu/tessellate/GrPathTessellator.h b/src/gpu/tessellate/PathTessellator.h
similarity index 90%
rename from src/gpu/tessellate/GrPathTessellator.h
rename to src/gpu/tessellate/PathTessellator.h
index 4be0f61..1637606 100644
--- a/src/gpu/tessellate/GrPathTessellator.h
+++ b/src/gpu/tessellate/PathTessellator.h
@@ -5,8 +5,8 @@
* found in the LICENSE file.
*/
-#ifndef GrPathTessellator_DEFINED
-#define GrPathTessellator_DEFINED
+#ifndef tessellate_PathTessellator_DEFINED
+#define tessellate_PathTessellator_DEFINED
#include "src/core/SkPathPriv.h"
#include "src/gpu/GrVertexWriter.h"
@@ -19,9 +19,11 @@
class GrOpFlushState;
class GrPathTessellationShader;
+namespace skgpu::tess {
+
// Prepares GPU data for, and then draws a path's tessellated geometry. Depending on the subclass,
// the caller may or may not be required to draw the path's inner fan separately.
-class GrPathTessellator {
+class PathTessellator {
public:
using BreadcrumbTriangleList = GrInnerFanTriangulator::BreadcrumbTriangleList;
@@ -45,7 +47,7 @@
Iter end() const { return {nullptr}; }
};
- virtual ~GrPathTessellator() {}
+ virtual ~PathTessellator() {}
const GrPathTessellationShader* shader() const { return fShader; }
@@ -75,9 +77,11 @@
}
protected:
- GrPathTessellator(GrPathTessellationShader* shader) : fShader(shader) {}
+ PathTessellator(GrPathTessellationShader* shader) : fShader(shader) {}
GrPathTessellationShader* fShader;
};
-#endif
+} // namespace skgpu::tess
+
+#endif // tessellate_PathTessellator_DEFINED
diff --git a/src/gpu/tessellate/GrPathWedgeTessellator.cpp b/src/gpu/tessellate/PathWedgeTessellator.cpp
similarity index 92%
rename from src/gpu/tessellate/GrPathWedgeTessellator.cpp
rename to src/gpu/tessellate/PathWedgeTessellator.cpp
index 778750f..5652191 100644
--- a/src/gpu/tessellate/GrPathWedgeTessellator.cpp
+++ b/src/gpu/tessellate/PathWedgeTessellator.cpp
@@ -5,16 +5,22 @@
* found in the LICENSE file.
*/
-#include "src/gpu/tessellate/GrPathWedgeTessellator.h"
+#include "src/gpu/tessellate/PathWedgeTessellator.h"
#include "src/gpu/GrMeshDrawTarget.h"
#include "src/gpu/GrResourceProvider.h"
#include "src/gpu/geometry/GrPathUtils.h"
#include "src/gpu/geometry/GrWangsFormula.h"
-#include "src/gpu/tessellate/GrCullTest.h"
-#include "src/gpu/tessellate/GrPathXform.h"
+#include "src/gpu/tessellate/CullTest.h"
+#include "src/gpu/tessellate/PathXform.h"
#include "src/gpu/tessellate/shaders/GrPathTessellationShader.h"
+#if SK_GPU_V1
+#include "src/gpu/GrOpFlushState.h"
+#endif
+
+namespace skgpu::tess {
+
namespace {
constexpr static float kPrecision = GrTessellationShader::kLinearizationPrecision;
@@ -108,6 +114,9 @@
int fMidpointWeight;
};
+} // namespace
+
+
// Writes out wedge patches, chopping as necessary so none require more segments than are supported
// by the hardware.
class WedgeWriter {
@@ -132,7 +141,7 @@
fPathXform = pathMatrix;
}
- const GrPathXform& pathXform() const { return fPathXform; }
+ const PathXform& pathXform() const { return fPathXform; }
SK_ALWAYS_INLINE void writeFlatWedge(const GrShaderCaps& shaderCaps,
SkPoint p0,
@@ -249,9 +258,9 @@
}
GrVertexChunkBuilder fChunker;
- GrCullTest fCullTest;
- GrVectorXform fTotalVectorXform;
- GrPathXform fPathXform;
+ CullTest fCullTest;
+ VectorXform fTotalVectorXform;
+ PathXform fPathXform;
const float fMaxSegments_pow2;
const float fMaxSegments_pow4;
@@ -259,12 +268,12 @@
float fNumFixedSegments_pow4 = 1;
};
-} // namespace
-
-
-GrPathTessellator* GrPathWedgeTessellator::Make(SkArenaAlloc* arena, const SkMatrix& viewMatrix,
- const SkPMColor4f& color, int numPathVerbs,
- const GrPipeline& pipeline, const GrCaps& caps) {
+PathTessellator* PathWedgeTessellator::Make(SkArenaAlloc* arena,
+ const SkMatrix& viewMatrix,
+ const SkPMColor4f& color,
+ int numPathVerbs,
+ const GrPipeline& pipeline,
+ const GrCaps& caps) {
using PatchType = GrPathTessellationShader::PatchType;
GrPathTessellationShader* shader;
if (caps.shaderCaps()->tessellationSupport() &&
@@ -279,17 +288,17 @@
PatchType::kWedges);
}
return arena->make([=](void* objStart) {
- return new(objStart) GrPathWedgeTessellator(shader);
+ return new(objStart) PathWedgeTessellator(shader);
});
}
GR_DECLARE_STATIC_UNIQUE_KEY(gFixedCountVertexBufferKey);
GR_DECLARE_STATIC_UNIQUE_KEY(gFixedCountIndexBufferKey);
-void GrPathWedgeTessellator::prepare(GrMeshDrawTarget* target,
- const SkRect& cullBounds,
- const PathDrawList& pathDrawList,
- int totalCombinedPathVerbCnt) {
+void PathWedgeTessellator::prepare(GrMeshDrawTarget* target,
+ const SkRect& cullBounds,
+ const PathDrawList& pathDrawList,
+ int totalCombinedPathVerbCnt) {
SkASSERT(fVertexChunkArray.empty());
const GrShaderCaps& shaderCaps = *target->caps().shaderCaps();
@@ -376,9 +385,7 @@
}
#if SK_GPU_V1
-#include "src/gpu/GrOpFlushState.h"
-
-void GrPathWedgeTessellator::draw(GrOpFlushState* flushState) const {
+void PathWedgeTessellator::draw(GrOpFlushState* flushState) const {
if (fShader->willUseTessellationShaders()) {
for (const GrVertexChunk& chunk : fVertexChunkArray) {
flushState->bindBuffers(nullptr, nullptr, chunk.fBuffer);
@@ -393,3 +400,5 @@
}
}
#endif
+
+} // namespace skgpu::tess
diff --git a/src/gpu/tessellate/GrPathWedgeTessellator.h b/src/gpu/tessellate/PathWedgeTessellator.h
similarity index 64%
rename from src/gpu/tessellate/GrPathWedgeTessellator.h
rename to src/gpu/tessellate/PathWedgeTessellator.h
index 2912388..afe16a7 100644
--- a/src/gpu/tessellate/GrPathWedgeTessellator.h
+++ b/src/gpu/tessellate/PathWedgeTessellator.h
@@ -5,25 +5,31 @@
* found in the LICENSE file.
*/
-#ifndef GrPathWedgeTessellator_DEFINED
-#define GrPathWedgeTessellator_DEFINED
+#ifndef tessellate_PathWedgeTessellator_DEFINED
+#define tessellate_PathWedgeTessellator_DEFINED
#include "src/gpu/GrVertexChunkArray.h"
-#include "src/gpu/tessellate/GrPathTessellator.h"
+#include "src/gpu/tessellate/PathTessellator.h"
class GrCaps;
class GrGpuBuffer;
class GrPipeline;
+namespace skgpu::tess {
+
// Prepares an array of "wedge" patches for GrWedgeTessellateShader. A wedge is an independent,
// 5-point closed contour consisting of 4 control points plus an anchor point fanning from the
// center of the curve's resident contour. A wedge can be either a cubic or a conic. Quadratics and
// lines are converted to cubics. Once stencilled, these wedges alone define the complete path.
-class GrPathWedgeTessellator : public GrPathTessellator {
+class PathWedgeTessellator : public PathTessellator {
public:
// Creates a wedge tessellator with the shader type best suited for the given path description.
- static GrPathTessellator* Make(SkArenaAlloc*, const SkMatrix& viewMatrix, const SkPMColor4f&,
- int numPathVerbs, const GrPipeline&, const GrCaps&);
+ static PathTessellator* Make(SkArenaAlloc*,
+ const SkMatrix& viewMatrix,
+ const SkPMColor4f&,
+ int numPathVerbs,
+ const GrPipeline&,
+ const GrCaps&);
void prepare(GrMeshDrawTarget*,
const SkRect& cullBounds,
@@ -36,8 +42,7 @@
#endif
private:
- GrPathWedgeTessellator(GrPathTessellationShader* shader)
- : GrPathTessellator(shader) {}
+ PathWedgeTessellator(GrPathTessellationShader* shader) : PathTessellator(shader) {}
GrVertexChunkArray fVertexChunkArray;
@@ -47,4 +52,6 @@
sk_sp<const GrGpuBuffer> fFixedCountIndexBuffer;
};
-#endif
+} // namespace skgpu::tess
+
+#endif // tessellate_PathWedgeTessellator_DEFINED
diff --git a/src/gpu/tessellate/GrPathXform.h b/src/gpu/tessellate/PathXform.h
similarity index 91%
rename from src/gpu/tessellate/GrPathXform.h
rename to src/gpu/tessellate/PathXform.h
index c4f3aac..c877aae 100644
--- a/src/gpu/tessellate/GrPathXform.h
+++ b/src/gpu/tessellate/PathXform.h
@@ -5,28 +5,30 @@
* found in the LICENSE file.
*/
-#ifndef GrPathXform_DEFINED
-#define GrPathXform_DEFINED
+#ifndef tessellate_PathXform_DEFINED
+#define tessellate_PathXform_DEFINED
#include "include/core/SkMatrix.h"
#include "src/gpu/GrVertexWriter.h"
#include "src/gpu/GrVx.h"
+namespace skgpu::tess {
+
// Applies an affine 2d transformation to points and path components. Converts path components to
// tessellation patches. Uses SIMD, but takes care to map points identically, regardless of which
// method is called.
//
// This class stores redundant data, so it is best used only as a stack-allocated object at the
// point of use.
-class GrPathXform {
+class PathXform {
using float2 = grvx::float2;
using float4 = grvx::float4;
public:
- GrPathXform() = default;
- GrPathXform(const SkMatrix& m) { *this = m; }
+ PathXform() = default;
+ PathXform(const SkMatrix& m) { *this = m; }
- GrPathXform& operator=(const SkMatrix& m) {
+ PathXform& operator=(const SkMatrix& m) {
SkASSERT(!m.hasPerspective());
// Duplicate the matrix in float4.lo and float4.hi so we can map two points at once.
fScale = {m.getScaleX(), m.getScaleY(), m.getScaleX(), m.getScaleY()};
@@ -92,4 +94,6 @@
float4 fTrans;
};
-#endif
+} // namespace skgpu::tess
+
+#endif // tessellate_PathXform_DEFINED
diff --git a/src/gpu/tessellate/GrStrokeFixedCountTessellator.cpp b/src/gpu/tessellate/StrokeFixedCountTessellator.cpp
similarity index 91%
rename from src/gpu/tessellate/GrStrokeFixedCountTessellator.cpp
rename to src/gpu/tessellate/StrokeFixedCountTessellator.cpp
index d517726..2bd3370 100644
--- a/src/gpu/tessellate/GrStrokeFixedCountTessellator.cpp
+++ b/src/gpu/tessellate/StrokeFixedCountTessellator.cpp
@@ -5,15 +5,21 @@
* found in the LICENSE file.
*/
-#include "src/gpu/tessellate/GrStrokeFixedCountTessellator.h"
+#include "src/gpu/tessellate/StrokeFixedCountTessellator.h"
#include "src/core/SkGeometry.h"
#include "src/gpu/GrMeshDrawTarget.h"
#include "src/gpu/GrResourceProvider.h"
#include "src/gpu/geometry/GrPathUtils.h"
#include "src/gpu/geometry/GrWangsFormula.h"
-#include "src/gpu/tessellate/GrCullTest.h"
-#include "src/gpu/tessellate/GrStrokeIterator.h"
+#include "src/gpu/tessellate/CullTest.h"
+#include "src/gpu/tessellate/StrokeIterator.h"
+
+#if SK_GPU_V1
+#include "src/gpu/GrOpFlushState.h"
+#endif
+
+namespace skgpu::tess {
namespace {
@@ -25,7 +31,7 @@
// will just add enough additional segments to handle a worst-case 180 degree stroke.)
class InstanceWriter {
public:
- using ShaderFlags = GrStrokeTessellator::ShaderFlags;
+ using ShaderFlags = StrokeTessellator::ShaderFlags;
InstanceWriter(const GrShaderCaps* shaderCaps, ShaderFlags shaderFlags,
GrMeshDrawTarget* target, float matrixMaxScale, const SkRect& strokeCullBounds,
@@ -35,7 +41,7 @@
, fShaderFlags(shaderFlags)
, fCullTest(strokeCullBounds, viewMatrix)
, fChunkBuilder(target, patchChunks, instanceStride, minInstancesPerChunk)
- , fParametricPrecision(GrStrokeTolerances::CalcParametricPrecision(matrixMaxScale)) {
+ , fParametricPrecision(StrokeTolerances::CalcParametricPrecision(matrixMaxScale)) {
}
float parametricPrecision() const { return fParametricPrecision; }
@@ -217,7 +223,7 @@
const GrShaderCaps* fShaderCaps;
const ShaderFlags fShaderFlags;
- const GrCullTest fCullTest;
+ const CullTest fCullTest;
GrVertexChunkBuilder fChunkBuilder;
const float fParametricPrecision;
float fMaxParametricSegments_pow4 = 1;
@@ -235,7 +241,7 @@
};
// Returns the worst-case number of edges we will need in order to draw a join of the given type.
-static int worst_case_edges_in_join(SkPaint::Join joinType, float numRadialSegmentsPerRadian) {
+int worst_case_edges_in_join(SkPaint::Join joinType, float numRadialSegmentsPerRadian) {
int numEdges = GrStrokeTessellationShader::NumFixedEdgesInJoin(joinType);
if (joinType == SkPaint::kRound_Join) {
// For round joins we need to count the radial edges on our own. Account for a worst-case
@@ -247,21 +253,21 @@
} // namespace
-GrStrokeFixedCountTessellator::GrStrokeFixedCountTessellator(const GrShaderCaps& shaderCaps,
- ShaderFlags shaderFlags,
- const SkMatrix& viewMatrix,
- PathStrokeList* pathStrokeList,
- std::array<float,2> matrixMinMaxScales,
- const SkRect& strokeCullBounds)
- : GrStrokeTessellator(shaderCaps, GrStrokeTessellationShader::Mode::kFixedCount,
- shaderFlags, kMaxParametricSegments_log2, viewMatrix,
- pathStrokeList, matrixMinMaxScales, strokeCullBounds) {
+
+StrokeFixedCountTessellator::StrokeFixedCountTessellator(const GrShaderCaps& shaderCaps,
+ ShaderFlags shaderFlags,
+ const SkMatrix& viewMatrix,
+ PathStrokeList* pathStrokeList,
+ std::array<float,2> matrixMinMaxScales,
+ const SkRect& strokeCullBounds)
+ : StrokeTessellator(shaderCaps, GrStrokeTessellationShader::Mode::kFixedCount, shaderFlags,
+ kMaxParametricSegments_log2, viewMatrix, pathStrokeList,
+ matrixMinMaxScales, strokeCullBounds) {
}
GR_DECLARE_STATIC_UNIQUE_KEY(gVertexIDFallbackBufferKey);
-void GrStrokeFixedCountTessellator::prepare(GrMeshDrawTarget* target,
- int totalCombinedVerbCnt) {
+void StrokeFixedCountTessellator::prepare(GrMeshDrawTarget* target, int totalCombinedVerbCnt) {
int maxEdgesInJoin = 0;
float maxRadialSegmentsPerRadian = 0;
@@ -278,9 +284,9 @@
if (!fShader.hasDynamicStroke()) {
// Strokes are static. Calculate tolerances once.
const SkStrokeRec& stroke = fPathStrokeList->fStroke;
- float localStrokeWidth = GrStrokeTolerances::GetLocalStrokeWidth(fMatrixMinMaxScales.data(),
- stroke.getWidth());
- float numRadialSegmentsPerRadian = GrStrokeTolerances::CalcNumRadialSegmentsPerRadian(
+ float localStrokeWidth = StrokeTolerances::GetLocalStrokeWidth(fMatrixMinMaxScales.data(),
+ stroke.getWidth());
+ float numRadialSegmentsPerRadian = StrokeTolerances::CalcNumRadialSegmentsPerRadian(
instanceWriter.parametricPrecision(), localStrokeWidth);
maxEdgesInJoin = worst_case_edges_in_join(stroke.getJoin(), numRadialSegmentsPerRadian);
maxRadialSegmentsPerRadian = numRadialSegmentsPerRadian;
@@ -288,7 +294,7 @@
// Fast SIMD queue that buffers up values for "numRadialSegmentsPerRadian". Only used when we
// have dynamic stroke.
- GrStrokeToleranceBuffer toleranceBuffer(instanceWriter.parametricPrecision());
+ StrokeToleranceBuffer toleranceBuffer(instanceWriter.parametricPrecision());
for (PathStrokeList* pathStroke = fPathStrokeList; pathStroke; pathStroke = pathStroke->fNext) {
const SkStrokeRec& stroke = pathStroke->fStroke;
@@ -306,11 +312,11 @@
if (fShader.hasDynamicColor()) {
instanceWriter.updateDynamicColor(pathStroke->fColor);
}
- GrStrokeIterator strokeIter(pathStroke->fPath, &pathStroke->fStroke, &fShader.viewMatrix());
+ StrokeIterator strokeIter(pathStroke->fPath, &pathStroke->fStroke, &fShader.viewMatrix());
while (strokeIter.next()) {
const SkPoint* p = strokeIter.pts();
switch (strokeIter.verb()) {
- using Verb = GrStrokeIterator::Verb;
+ using Verb = StrokeIterator::Verb;
int numChops;
case Verb::kContourFinished:
instanceWriter.finishContour();
@@ -445,9 +451,7 @@
}
#if SK_GPU_V1
-#include "src/gpu/GrOpFlushState.h"
-
-void GrStrokeFixedCountTessellator::draw(GrOpFlushState* flushState) const {
+void StrokeFixedCountTessellator::draw(GrOpFlushState* flushState) const {
if (fInstanceChunks.empty() || fFixedVertexCount <= 0) {
return;
}
@@ -457,3 +461,5 @@
}
}
#endif
+
+} // namespace skgpu::tess
diff --git a/src/gpu/tessellate/StrokeFixedCountTessellator.h b/src/gpu/tessellate/StrokeFixedCountTessellator.h
new file mode 100644
index 0000000..45eb42f
--- /dev/null
+++ b/src/gpu/tessellate/StrokeFixedCountTessellator.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2021 Google LLC.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef tessellate_StrokeFixedCountTessellator_DEFINED
+#define tessellate_StrokeFixedCountTessellator_DEFINED
+
+#include "src/gpu/GrVertexChunkArray.h"
+#include "src/gpu/tessellate/StrokeTessellator.h"
+
+namespace skgpu::tess {
+
+// Renders strokes as fixed-count triangle strip instances. Any extra triangles not needed by the
+// instance are emitted as degenerate triangles.
+class StrokeFixedCountTessellator : public StrokeTessellator {
+public:
+ StrokeFixedCountTessellator(const GrShaderCaps&,
+ ShaderFlags,
+ const SkMatrix&,
+ PathStrokeList*,
+ std::array<float, 2> matrixMinMaxScales,
+ const SkRect& strokeCullBounds);
+
+ void prepare(GrMeshDrawTarget*, int totalCombinedVerbCnt) override;
+#if SK_GPU_V1
+ void draw(GrOpFlushState*) const override;
+#endif
+
+private:
+ GrVertexChunkArray fInstanceChunks;
+ int fFixedVertexCount = 0;
+
+ // Only used if sk_VertexID is not supported.
+ sk_sp<const GrGpuBuffer> fVertexBufferIfNoIDSupport;
+};
+
+} // namespace skgpu::tess
+
+#endif // tessellate_StrokeFixedCountTessellator_DEFINED
diff --git a/src/gpu/tessellate/GrStrokeHardwareTessellator.cpp b/src/gpu/tessellate/StrokeHardwareTessellator.cpp
similarity index 96%
rename from src/gpu/tessellate/GrStrokeHardwareTessellator.cpp
rename to src/gpu/tessellate/StrokeHardwareTessellator.cpp
index d0a1469..ba90943 100644
--- a/src/gpu/tessellate/GrStrokeHardwareTessellator.cpp
+++ b/src/gpu/tessellate/StrokeHardwareTessellator.cpp
@@ -5,7 +5,7 @@
* found in the LICENSE file.
*/
-#include "src/gpu/tessellate/GrStrokeHardwareTessellator.h"
+#include "src/gpu/tessellate/StrokeHardwareTessellator.h"
#include "src/core/SkMathPriv.h"
#include "src/core/SkPathPriv.h"
@@ -14,11 +14,17 @@
#include "src/gpu/GrVx.h"
#include "src/gpu/geometry/GrPathUtils.h"
#include "src/gpu/geometry/GrWangsFormula.h"
-#include "src/gpu/tessellate/GrCullTest.h"
+#include "src/gpu/tessellate/CullTest.h"
+
+#if SK_GPU_V1
+#include "src/gpu/GrOpFlushState.h"
+#endif
+
+namespace skgpu::tess {
namespace {
-static float num_combined_segments(float numParametricSegments, float numRadialSegments) {
+float num_combined_segments(float numParametricSegments, float numRadialSegments) {
// The first and last edges are shared by both the parametric and radial sets of edges, so
// the total number of edges is:
//
@@ -37,14 +43,14 @@
return numParametricSegments + numRadialSegments - 1;
}
-static grvx::float2 pow4(grvx::float2 x) {
+grvx::float2 pow4(grvx::float2 x) {
auto xx = x*x;
return xx*xx;
}
class PatchWriter {
public:
- using ShaderFlags = GrStrokeTessellator::ShaderFlags;
+ using ShaderFlags = StrokeTessellator::ShaderFlags;
enum class JoinType {
kMiter = SkPaint::kMiter_Join,
@@ -62,7 +68,7 @@
// Subtract 2 because the tessellation shader chops every cubic at two locations, and
// each chop has the potential to introduce an extra segment.
, fMaxTessellationSegments(target->caps().shaderCaps()->maxTessellationSegments() - 2)
- , fParametricPrecision(GrStrokeTolerances::CalcParametricPrecision(matrixMaxScale)) {
+ , fParametricPrecision(StrokeTolerances::CalcParametricPrecision(matrixMaxScale)) {
}
// This is the precision value, adjusted for the view matrix, to use with Wang's formulas when
@@ -626,7 +632,7 @@
}
const ShaderFlags fShaderFlags;
- const GrCullTest fCullTest;
+ const CullTest fCullTest;
GrVertexChunkBuilder fChunkBuilder;
// The maximum number of tessellation segments the hardware can emit for a single patch.
@@ -668,7 +674,7 @@
GrVertexColor fDynamicColor;
};
-SK_ALWAYS_INLINE static bool cubic_has_cusp(const SkPoint p[4]) {
+SK_ALWAYS_INLINE bool cubic_has_cusp(const SkPoint p[4]) {
using grvx::float2;
float2 p0 = skvx::bit_pun<float2>(p[0]);
@@ -704,18 +710,19 @@
} // namespace
-GrStrokeHardwareTessellator::GrStrokeHardwareTessellator(const GrShaderCaps& shaderCaps,
- ShaderFlags shaderFlags,
- const SkMatrix& viewMatrix,
- PathStrokeList* pathStrokeList,
- std::array<float,2> matrixMinMaxScales,
- const SkRect& strokeCullBounds)
- : GrStrokeTessellator(shaderCaps, GrStrokeTessellationShader::Mode::kHardwareTessellation,
- shaderFlags, SkNextLog2(shaderCaps.maxTessellationSegments()),
- viewMatrix, pathStrokeList, matrixMinMaxScales, strokeCullBounds) {
+
+StrokeHardwareTessellator::StrokeHardwareTessellator(const GrShaderCaps& shaderCaps,
+ ShaderFlags shaderFlags,
+ const SkMatrix& viewMatrix,
+ PathStrokeList* pathStrokeList,
+ std::array<float,2> matrixMinMaxScales,
+ const SkRect& strokeCullBounds)
+ : StrokeTessellator(shaderCaps, GrStrokeTessellationShader::Mode::kHardwareTessellation,
+ shaderFlags, SkNextLog2(shaderCaps.maxTessellationSegments()),
+ viewMatrix, pathStrokeList, matrixMinMaxScales, strokeCullBounds) {
}
-void GrStrokeHardwareTessellator::prepare(GrMeshDrawTarget* target, int totalCombinedVerbCnt) {
+void StrokeHardwareTessellator::prepare(GrMeshDrawTarget* target, int totalCombinedVerbCnt) {
using JoinType = PatchWriter::JoinType;
// Over-allocate enough patches for 1 in 4 strokes to chop and for 8 extra caps.
@@ -729,16 +736,16 @@
if (!fShader.hasDynamicStroke()) {
// Strokes are static. Calculate tolerances once.
const SkStrokeRec& stroke = fPathStrokeList->fStroke;
- float localStrokeWidth = GrStrokeTolerances::GetLocalStrokeWidth(fMatrixMinMaxScales.data(),
- stroke.getWidth());
- float numRadialSegmentsPerRadian = GrStrokeTolerances::CalcNumRadialSegmentsPerRadian(
+ float localStrokeWidth = StrokeTolerances::GetLocalStrokeWidth(fMatrixMinMaxScales.data(),
+ stroke.getWidth());
+ float numRadialSegmentsPerRadian = StrokeTolerances::CalcNumRadialSegmentsPerRadian(
patchWriter.parametricPrecision(), localStrokeWidth);
patchWriter.updateTolerances(numRadialSegmentsPerRadian, stroke.getJoin());
}
// Fast SIMD queue that buffers up values for "numRadialSegmentsPerRadian". Only used when we
// have dynamic strokes.
- GrStrokeToleranceBuffer toleranceBuffer(patchWriter.parametricPrecision());
+ StrokeToleranceBuffer toleranceBuffer(patchWriter.parametricPrecision());
for (PathStrokeList* pathStroke = fPathStrokeList; pathStroke; pathStroke = pathStroke->fNext) {
const SkStrokeRec& stroke = pathStroke->fStroke;
@@ -898,13 +905,12 @@
}
#if SK_GPU_V1
-#include "src/gpu/GrOpFlushState.h"
-
-void GrStrokeHardwareTessellator::draw(GrOpFlushState* flushState) const {
+void StrokeHardwareTessellator::draw(GrOpFlushState* flushState) const {
for (const auto& vertexChunk : fPatchChunks) {
flushState->bindBuffers(nullptr, nullptr, vertexChunk.fBuffer);
flushState->draw(vertexChunk.fCount, vertexChunk.fBase);
}
}
-
#endif
+
+} // namespace skgpu::tess
diff --git a/src/gpu/tessellate/StrokeHardwareTessellator.h b/src/gpu/tessellate/StrokeHardwareTessellator.h
new file mode 100644
index 0000000..563d210
--- /dev/null
+++ b/src/gpu/tessellate/StrokeHardwareTessellator.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2020 Google LLC.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef tessellate_StrokeHardwareTessellator_DEFINED
+#define tessellate_StrokeHardwareTessellator_DEFINED
+
+#include "src/gpu/GrVertexChunkArray.h"
+#include "src/gpu/tessellate/StrokeTessellator.h"
+
+namespace skgpu::tess {
+
+// Renders opaque, constant-color strokes by decomposing them into standalone tessellation patches.
+// Each patch is either a "cubic" (single stroked bezier curve with butt caps) or a "join". Requires
+// MSAA if antialiasing is desired.
+class StrokeHardwareTessellator : public StrokeTessellator {
+public:
+ StrokeHardwareTessellator(const GrShaderCaps& shaderCaps,
+ ShaderFlags shaderFlags,
+ const SkMatrix& viewMatrix,
+ PathStrokeList* pathStrokeList,
+ std::array<float,2> matrixMinMaxScales,
+ const SkRect& strokeCullBounds);
+
+ void prepare(GrMeshDrawTarget*, int totalCombinedVerbCnt) override;
+#if SK_GPU_V1
+ void draw(GrOpFlushState*) const override;
+#endif
+
+private:
+ GrVertexChunkArray fPatchChunks;
+};
+
+} // namespace skgpu::tess
+
+#endif // tessellate_StrokeHardwareTessellator_DEFINED
diff --git a/src/gpu/tessellate/GrStrokeIterator.h b/src/gpu/tessellate/StrokeIterator.h
similarity index 97%
rename from src/gpu/tessellate/GrStrokeIterator.h
rename to src/gpu/tessellate/StrokeIterator.h
index a4c86dc..ee3e46d 100644
--- a/src/gpu/tessellate/GrStrokeIterator.h
+++ b/src/gpu/tessellate/StrokeIterator.h
@@ -5,20 +5,22 @@
* found in the LICENSE file.
*/
-#ifndef GrStrokeIterator_DEFINED
-#define GrStrokeIterator_DEFINED
+#ifndef tessellate_StrokeIterator_DEFINED
+#define tessellate_StrokeIterator_DEFINED
#include "include/core/SkPaint.h"
#include "include/core/SkStrokeRec.h"
#include "src/core/SkPathPriv.h"
#include <array>
+namespace skgpu::tess {
+
// This class iterates over the stroke geometry defined by a path and stroke. It automatically
// converts closes and square caps to lines, and round caps to circles so the user doesn't have to
// worry about it. At each location it provides a verb and "prevVerb" so there is context about the
// preceding join. Usage:
//
-// GrStrokeIterator iter(path, stroke);
+// StrokeIterator iter(path, stroke);
// while (iter.next()) { // Call next() first.
// iter.verb();
// iter.pts();
@@ -27,9 +29,9 @@
// iter.prevPts();
// }
//
-class GrStrokeIterator {
+class StrokeIterator {
public:
- GrStrokeIterator(const SkPath& path, const SkStrokeRec* stroke, const SkMatrix* viewMatrix)
+ StrokeIterator(const SkPath& path, const SkStrokeRec* stroke, const SkMatrix* viewMatrix)
: fViewMatrix(viewMatrix), fStroke(stroke) {
SkPathPriv::Iterate it(path);
fIter = it.begin();
@@ -364,4 +366,8 @@
std::array<SkPoint, 2> fBeginningCapPts;
};
-#endif
+} // namespace skgpu::tess
+
+#endif // tessellate_StrokeIterator_DEFINED
+
+
diff --git a/src/gpu/tessellate/GrStrokeTessellator.h b/src/gpu/tessellate/StrokeTessellator.h
similarity index 83%
rename from src/gpu/tessellate/GrStrokeTessellator.h
rename to src/gpu/tessellate/StrokeTessellator.h
index 0a4b865..ff108a2 100644
--- a/src/gpu/tessellate/GrStrokeTessellator.h
+++ b/src/gpu/tessellate/StrokeTessellator.h
@@ -5,8 +5,8 @@
* found in the LICENSE file.
*/
-#ifndef GrStrokeTessellator_DEFINED
-#define GrStrokeTessellator_DEFINED
+#ifndef tessellate_StrokeTessellator_DEFINED
+#define tessellate_StrokeTessellator_DEFINED
#include "src/gpu/GrVx.h"
#include "src/gpu/tessellate/shaders/GrStrokeTessellationShader.h"
@@ -14,8 +14,10 @@
class GrMeshDrawTarget;
class GrOpFlushState;
+namespace skgpu::tess {
+
// Prepares GPU data for, and then draws a stroke's tessellated geometry.
-class GrStrokeTessellator {
+class StrokeTessellator {
public:
using ShaderFlags = GrStrokeTessellationShader::ShaderFlags;
@@ -28,10 +30,14 @@
PathStrokeList* fNext = nullptr;
};
- GrStrokeTessellator(const GrShaderCaps& shaderCaps, GrStrokeTessellationShader::Mode shaderMode,
- ShaderFlags shaderFlags, int8_t maxParametricSegments_log2,
- const SkMatrix& viewMatrix, PathStrokeList* pathStrokeList,
- std::array<float, 2> matrixMinMaxScales, const SkRect& strokeCullBounds)
+ StrokeTessellator(const GrShaderCaps& shaderCaps,
+ GrStrokeTessellationShader::Mode shaderMode,
+ ShaderFlags shaderFlags,
+ int8_t maxParametricSegments_log2,
+ const SkMatrix& viewMatrix,
+ PathStrokeList* pathStrokeList,
+ std::array<float, 2> matrixMinMaxScales,
+ const SkRect& strokeCullBounds)
: fShader(shaderCaps, shaderMode, shaderFlags, viewMatrix, pathStrokeList->fStroke,
pathStrokeList->fColor, maxParametricSegments_log2)
, fPathStrokeList(pathStrokeList)
@@ -50,7 +56,7 @@
virtual void draw(GrOpFlushState*) const = 0;
#endif
- virtual ~GrStrokeTessellator() {}
+ virtual ~StrokeTessellator() {}
protected:
GrStrokeTessellationShader fShader;
@@ -61,7 +67,7 @@
// These tolerances decide the number of parametric and radial segments the tessellator will
// linearize strokes into. These decisions are made in (pre-viewMatrix) local path space.
-struct GrStrokeTolerances {
+struct StrokeTolerances {
// Decides the number of parametric segments the tessellator adds for each curve. (Uniform
// steps in parametric space.) The tessellator will add enough parametric segments so that,
// once transformed into device space, they never deviate by more than
@@ -109,11 +115,11 @@
}
return localStrokeWidth;
}
- static GrStrokeTolerances Make(const float matrixMinMaxScales[2], float strokeWidth) {
+ static StrokeTolerances Make(const float matrixMinMaxScales[2], float strokeWidth) {
return MakeNonHairline(matrixMinMaxScales[1],
GetLocalStrokeWidth(matrixMinMaxScales, strokeWidth));
}
- static GrStrokeTolerances MakeNonHairline(float matrixMaxScale, float strokeWidth) {
+ static StrokeTolerances MakeNonHairline(float matrixMaxScale, float strokeWidth) {
SkASSERT(strokeWidth > 0);
float parametricPrecision = CalcParametricPrecision(matrixMaxScale);
return {parametricPrecision,
@@ -124,17 +130,15 @@
};
// Calculates and buffers up future values for "numRadialSegmentsPerRadian" using SIMD.
-class alignas(sizeof(float) * 4) GrStrokeToleranceBuffer {
+class alignas(sizeof(float) * 4) StrokeToleranceBuffer {
public:
- using PathStrokeList = GrStrokeTessellator::PathStrokeList;
+ using PathStrokeList = StrokeTessellator::PathStrokeList;
- GrStrokeToleranceBuffer(float parametricPrecision)
- : fParametricPrecision(parametricPrecision) {
- }
+ StrokeToleranceBuffer(float parametricPrecision) : fParametricPrecision(parametricPrecision) {}
float fetchRadialSegmentsPerRadian(PathStrokeList* head) {
// StrokeTessellateOp::onCombineIfPossible does not allow hairlines to become dynamic. If
- // this changes, we will need to call GrStrokeTolerances::GetLocalStrokeWidth() for each
+ // this changes, we will need to call StrokeTolerances::GetLocalStrokeWidth() for each
// stroke.
SkASSERT(!head->fStroke.isHairlineStyle());
if (fBufferIdx == 4) {
@@ -144,8 +148,8 @@
do {
fStrokeWidths[i++] = peekAhead->fStroke.getWidth();
} while ((peekAhead = peekAhead->fNext) && i < 4);
- auto tol = GrStrokeTolerances::ApproxNumRadialSegmentsPerRadian(fParametricPrecision,
- fStrokeWidths);
+ auto tol = StrokeTolerances::ApproxNumRadialSegmentsPerRadian(fParametricPrecision,
+ fStrokeWidths);
tol.store(fNumRadialSegmentsPerRadian);
fBufferIdx = 0;
}
@@ -161,4 +165,6 @@
int fBufferIdx = 4; // Initialize the buffer as "empty";
};
-#endif
+} // namespace skgpu::tess
+
+#endif // tessellate_StrokeTessellator_DEFINED
diff --git a/src/gpu/tessellate/TessTypes.h b/src/gpu/tessellate/TessTypes.h
new file mode 100644
index 0000000..56c1734
--- /dev/null
+++ b/src/gpu/tessellate/TessTypes.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef tessellate_TessTypes_DEFINED
+#define tessellate_TessTypes_DEFINED
+
+#include "include/gpu/GrTypes.h"
+
+namespace skgpu::tess {
+
+// We send these flags to the internal path filling Ops to control how a path gets rendered.
+enum class TessellationPathFlags {
+ kNone = 0,
+ kStencilOnly = (1 << 0),
+ kWireframe = (1 << 1)
+};
+
+GR_MAKE_BITFIELD_CLASS_OPS(TessellationPathFlags)
+
+} // namespace skgpu::tess
+
+#endif // tessellate_TessTypes_DEFINED
diff --git a/src/gpu/tessellate/GrVectorXform.h b/src/gpu/tessellate/VectorXform.h
similarity index 86%
rename from src/gpu/tessellate/GrVectorXform.h
rename to src/gpu/tessellate/VectorXform.h
index d80f28e..c093730 100644
--- a/src/gpu/tessellate/GrVectorXform.h
+++ b/src/gpu/tessellate/VectorXform.h
@@ -5,23 +5,25 @@
* found in the LICENSE file.
*/
-#ifndef GrVectorXform_DEFINED
-#define GrVectorXform_DEFINED
+#ifndef tessellate_VectorXform_DEFINED
+#define tessellate_VectorXform_DEFINED
#include "include/core/SkMatrix.h"
#include "include/private/SkVx.h"
+namespace skgpu::tess {
+
// Represents the upper-left 2x2 matrix of an affine transform for applying to vectors:
//
// VectorXform(p1 - p0) == M * float3(p1, 1) - M * float3(p0, 1)
//
-class GrVectorXform {
+class VectorXform {
public:
using float2 = skvx::Vec<2, float>;
using float4 = skvx::Vec<4, float>;
- explicit GrVectorXform() : fType(Type::kIdentity) {}
- explicit GrVectorXform(const SkMatrix& m) { *this = m; }
- GrVectorXform& operator=(const SkMatrix& m) {
+ explicit VectorXform() : fType(Type::kIdentity) {}
+ explicit VectorXform(const SkMatrix& m) { *this = m; }
+ VectorXform& operator=(const SkMatrix& m) {
SkASSERT(!m.hasPerspective());
if (m.getType() & SkMatrix::kAffine_Mask) {
fType = Type::kAffine;
@@ -69,4 +71,6 @@
float4 fSkewXYXY;
};
-#endif
+} // namespace skgpu::tess
+
+#endif // tessellate_VectorXform_DEFINED
diff --git a/src/gpu/tessellate/shaders/GrPathTessellationShader.cpp b/src/gpu/tessellate/shaders/GrPathTessellationShader.cpp
index e310c87..12c86b6 100644
--- a/src/gpu/tessellate/shaders/GrPathTessellationShader.cpp
+++ b/src/gpu/tessellate/shaders/GrPathTessellationShader.cpp
@@ -56,9 +56,9 @@
const GrPipeline* GrPathTessellationShader::MakeStencilOnlyPipeline(
const ProgramArgs& args,
GrAAType aaType,
- GrTessellationPathFlags pathFlags,
+ skgpu::tess::TessellationPathFlags pathFlags,
const GrAppliedHardClip& hardClip) {
- using PathFlags = GrTessellationPathFlags;
+ using PathFlags = skgpu::tess::TessellationPathFlags;
GrPipeline::InitArgs pipelineArgs;
if (args.fCaps->wireframeSupport() && (pathFlags & PathFlags::kWireframe)) {
pipelineArgs.fInputFlags |= GrPipeline::InputFlags::kWireframe;
diff --git a/src/gpu/tessellate/shaders/GrPathTessellationShader.h b/src/gpu/tessellate/shaders/GrPathTessellationShader.h
index 66aa922..f08368b 100644
--- a/src/gpu/tessellate/shaders/GrPathTessellationShader.h
+++ b/src/gpu/tessellate/shaders/GrPathTessellationShader.h
@@ -8,7 +8,7 @@
#ifndef GrPathTessellationShader_DEFINED
#define GrPathTessellationShader_DEFINED
-#include "src/gpu/tessellate/GrTessTypes.h"
+#include "src/gpu/tessellate/TessTypes.h"
#include "src/gpu/tessellate/shaders/GrTessellationShader.h"
// This is the base class for shaders in the GPU tessellator that fill paths.
@@ -154,7 +154,7 @@
// Creates a pipeline that does not write to the color buffer.
static const GrPipeline* MakeStencilOnlyPipeline(const ProgramArgs&,
GrAAType,
- GrTessellationPathFlags,
+ skgpu::tess::TessellationPathFlags,
const GrAppliedHardClip&);
protected:
diff --git a/src/gpu/tessellate/shaders/GrStrokeTessellationShader.cpp b/src/gpu/tessellate/shaders/GrStrokeTessellationShader.cpp
index 20dc354..335574d 100644
--- a/src/gpu/tessellate/shaders/GrStrokeTessellationShader.cpp
+++ b/src/gpu/tessellate/shaders/GrStrokeTessellationShader.cpp
@@ -10,7 +10,7 @@
#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
#include "src/gpu/glsl/GrGLSLVarying.h"
#include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"
-#include "src/gpu/tessellate/GrStrokeTessellator.h"
+#include "src/gpu/tessellate/StrokeTessellator.h"
GrStrokeTessellationShader::GrStrokeTessellationShader(const GrShaderCaps& shaderCaps, Mode mode,
ShaderFlags shaderFlags,
@@ -349,14 +349,14 @@
if (!shader.hasDynamicStroke()) {
// Set up the tessellation control uniforms.
- GrStrokeTolerances tolerances;
+ skgpu::tess::StrokeTolerances tolerances;
if (!stroke.isHairlineStyle()) {
- tolerances = GrStrokeTolerances::MakeNonHairline(shader.viewMatrix().getMaxScale(),
- stroke.getWidth());
+ tolerances = skgpu::tess::StrokeTolerances::MakeNonHairline(
+ shader.viewMatrix().getMaxScale(), stroke.getWidth());
} else {
// In the hairline case we transform prior to tessellation. Set up tolerances for an
// identity viewMatrix and a strokeWidth of 1.
- tolerances = GrStrokeTolerances::MakeNonHairline(1, 1);
+ tolerances = skgpu::tess::StrokeTolerances::MakeNonHairline(1, 1);
}
float strokeRadius = (stroke.isHairlineStyle()) ? .5f : stroke.getWidth() * .5;
pdman.set4f(fTessControlArgsUniform,
@@ -368,7 +368,7 @@
SkASSERT(!stroke.isHairlineStyle());
float maxScale = shader.viewMatrix().getMaxScale();
pdman.set1f(fTessControlArgsUniform,
- GrStrokeTolerances::CalcParametricPrecision(maxScale));
+ skgpu::tess::StrokeTolerances::CalcParametricPrecision(maxScale));
}
if (shader.mode() == GrStrokeTessellationShader::Mode::kFixedCount) {
diff --git a/tests/CullTestTest.cpp b/tests/CullTestTest.cpp
index 5657e3a..b737463 100644
--- a/tests/CullTestTest.cpp
+++ b/tests/CullTestTest.cpp
@@ -8,7 +8,9 @@
#include "tests/Test.h"
#include "include/utils/SkRandom.h"
-#include "src/gpu/tessellate/GrCullTest.h"
+#include "src/gpu/tessellate/CullTest.h"
+
+namespace skgpu::tess {
const SkMatrix gMatrices[] = {
SkMatrix::I(),
@@ -34,7 +36,7 @@
float valuesR[4] = {r+20, r+10, r-10, r-20};
float valuesB[4] = {b+20, b+10, b-10, b-20};
for (SkMatrix m : gMatrices) {
- GrCullTest cullTest(viewportRect, m);
+ CullTest cullTest(viewportRect, m);
SkMatrix inverse;
SkAssertResult(m.invert(&inverse));
for (const float* y : {valuesT, valuesB}) {
@@ -75,3 +77,5 @@
}}}
}
}
+
+} // namespace skgpu::tess
diff --git a/tests/WangsFormulaTest.cpp b/tests/WangsFormulaTest.cpp
index a9f978b..6d1a363 100644
--- a/tests/WangsFormulaTest.cpp
+++ b/tests/WangsFormulaTest.cpp
@@ -280,7 +280,7 @@
SkPoint ptsXformed[4];
m.mapPoints(ptsXformed, pts, 4);
int expected = GrWangsFormula::cubic_log2(kPrecision, ptsXformed);
- int actual = GrWangsFormula::cubic_log2(kPrecision, pts, GrVectorXform(m));
+ int actual = GrWangsFormula::cubic_log2(kPrecision, pts, skgpu::tess::VectorXform(m));
REPORTER_ASSERT(r, actual == expected);
};
@@ -288,7 +288,7 @@
SkPoint ptsXformed[3];
m.mapPoints(ptsXformed, pts, 3);
int expected = GrWangsFormula::quadratic_log2(kPrecision, ptsXformed);
- int actual = GrWangsFormula::quadratic_log2(kPrecision, pts, GrVectorXform(m));
+ int actual = GrWangsFormula::quadratic_log2(kPrecision, pts, skgpu::tess::VectorXform(m));
REPORTER_ASSERT(r, actual == expected);
};
@@ -494,7 +494,7 @@
SkPoint ptsXformed[3];
m.mapPoints(ptsXformed, pts, 3);
float expected = GrWangsFormula::conic(kPrecision, ptsXformed, w);
- float actual = GrWangsFormula::conic(kPrecision, pts, w, GrVectorXform(m));
+ float actual = GrWangsFormula::conic(kPrecision, pts, w, skgpu::tess::VectorXform(m));
REPORTER_ASSERT(r, SkScalarNearlyEqual(actual, expected));
};
