AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
63ec9d4045
skia2/tests/TriangulatingPathRendererTests.cpp

1314 lines
68 KiB
C++
Raw Normal View History

Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
rewrite includes to not need so much -Ifoo Current strategy: everything from the top Things to look at first are the manual changes: - added tools/rewrite_includes.py - removed -Idirectives from BUILD.gn - various compile.sh simplifications - tweak tools/embed_resources.py - update gn/find_headers.py to write paths from the top - update gn/gn_to_bp.py SkUserConfig.h layout so that #include "include/config/SkUserConfig.h" always gets the header we want. No-Presubmit: true Change-Id: I73a4b181654e0e38d229bc456c0d0854bae3363e Reviewed-on: https://skia-review.googlesource.com/c/skia/+/209706 Commit-Queue: Mike Klein <mtklein@google.com> Reviewed-by: Hal Canary <halcanary@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Reviewed-by: Florin Malita <fmalita@chromium.org>
2019-04-23 17:05:21 +00:00
#include "tests/Test.h"
Remove GrTestTarget Change-Id: I4d2e1aa54732ff75b44a197255035c0e04548219 Reviewed-on: https://skia-review.googlesource.com/7327 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Brian Salomon <bsalomon@google.com>
2017-01-20 14:11:37 +00:00
rewrite includes to not need so much -Ifoo Current strategy: everything from the top Things to look at first are the manual changes: - added tools/rewrite_includes.py - removed -Idirectives from BUILD.gn - various compile.sh simplifications - tweak tools/embed_resources.py - update gn/find_headers.py to write paths from the top - update gn/gn_to_bp.py SkUserConfig.h layout so that #include "include/config/SkUserConfig.h" always gets the header we want. No-Presubmit: true Change-Id: I73a4b181654e0e38d229bc456c0d0854bae3363e Reviewed-on: https://skia-review.googlesource.com/c/skia/+/209706 Commit-Queue: Mike Klein <mtklein@google.com> Reviewed-by: Hal Canary <halcanary@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Reviewed-by: Florin Malita <fmalita@chromium.org>
2019-04-23 17:05:21 +00:00
#include "include/core/SkPath.h"
Allow the Triangulator to fail Bug: 1262444 Change-Id: I951c1809c031c1c8e71d8c3ce1be3506bbfa3d2c Reviewed-on: https://skia-review.googlesource.com/c/skia/+/469904 Reviewed-by: Chris Dalton <csmartdalton@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-11-18 16:54:02 +00:00
#include "include/core/SkRect.h"
rewrite includes to not need so much -Ifoo Current strategy: everything from the top Things to look at first are the manual changes: - added tools/rewrite_includes.py - removed -Idirectives from BUILD.gn - various compile.sh simplifications - tweak tools/embed_resources.py - update gn/find_headers.py to write paths from the top - update gn/gn_to_bp.py SkUserConfig.h layout so that #include "include/config/SkUserConfig.h" always gets the header we want. No-Presubmit: true Change-Id: I73a4b181654e0e38d229bc456c0d0854bae3363e Reviewed-on: https://skia-review.googlesource.com/c/skia/+/209706 Commit-Queue: Mike Klein <mtklein@google.com> Reviewed-by: Hal Canary <halcanary@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Reviewed-by: Florin Malita <fmalita@chromium.org>
2019-04-23 17:05:21 +00:00
#include "include/effects/SkGradientShader.h"
Update unit tests to accept GrDirectContext This CL makes it explicit that the unit tests always get a direct context. It is mainly a mechanical CL. Change-Id: I49e0628851d9c81eb47386ef978edf905c6469d8 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/299866 Reviewed-by: Adlai Holler <adlai@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2020-07-06 14:56:46 +00:00
#include "include/gpu/GrDirectContext.h"
Rename GrContextPriv to GrDirectContextPriv Change-Id: I3fccadd8a2860dbee73f93f995738146373f8a39 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/326196 Commit-Queue: Adlai Holler <adlai@google.com> Auto-Submit: Adlai Holler <adlai@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
2020-10-14 15:23:11 +00:00
#include "src/gpu/GrDirectContextPriv.h"
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
#include "src/gpu/GrEagerVertexAllocator.h"
rewrite includes to not need so much -Ifoo Current strategy: everything from the top Things to look at first are the manual changes: - added tools/rewrite_includes.py - removed -Idirectives from BUILD.gn - various compile.sh simplifications - tweak tools/embed_resources.py - update gn/find_headers.py to write paths from the top - update gn/gn_to_bp.py SkUserConfig.h layout so that #include "include/config/SkUserConfig.h" always gets the header we want. No-Presubmit: true Change-Id: I73a4b181654e0e38d229bc456c0d0854bae3363e Reviewed-on: https://skia-review.googlesource.com/c/skia/+/209706 Commit-Queue: Mike Klein <mtklein@google.com> Reviewed-by: Hal Canary <halcanary@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Reviewed-by: Florin Malita <fmalita@chromium.org>
2019-04-23 17:05:21 +00:00
#include "src/gpu/GrStyle.h"
Reland "[fuzzer] Remove GL from (now-Vulkan) build" This is a reland of 805acda3f3aa3d9fc85c84bac5aa52c472ec3bb1 It fixes the #if SK_GL which was causing the Android roll to fail. This disables unit tests on Test-Ubuntu18-Clang-Golo-GPU-QuadroP400-x86_64-Release-All-TSAN_Vulkan which were consistently crashing with OOM. Original change's description: > [fuzzer] Remove GL from (now-Vulkan) build > > The fuzzer runs against the Vulkan version of Swiftshader. > There are no libGL.so (etc) on the fuzz runtime, so we > want to avoid linking against those. > > The GL code that is #ifdef'd out is still necessary to > avoid timeouts on TSAN with our NVIDIA jobs. > https://skia-review.googlesource.com/c/skia/+/502638 > > Procedure for testing this locally (and iterating): > 1. In oss-fuzz checkout, run > `python infra/helper.py shell skia` > to pull up local interactive version of Docker > fuzzer build image. > 2. Run `compile` in fuzzer shell. Stop after > the swiftshader compiles and is copied into /out > with Ctrl + C. > 3. Comment out the swiftshader compilation part [1] > (no need to re-do this when modifying Skia code). > `apt-get install nano -y` > `nano ../build.sh` > 4. Make change to Skia repo using normal methods. > 5. Run the following in the Skia repo > `git diff origin main > foo.patch` > Copy the patch into the Docker shell using Ctrl+C > and nano. > 6. Apply the patch inside the Docker shell > `git apply foo.patch` > and re-compile (which should skip right to > building the fuzzer libs) > `compile` > 7. Repeat 4-7 or make small changes directly in > the Docker shell via nano. > 8. When compilation and link succeeds, run > `ldd /out/api_mock_gpu_canvas` > to verify GL and friends were not dynamically linked. > > [1] https://github.com/google/oss-fuzz/pull/7214/files#diff-76f13875e33875cdd372f1f0933206be599cd87952f1bd1eaa57ca928ee9e3e1R49-R53 > > Change-Id: Idf569820527c1304b0e5a68fd36295be89dfa2a0 > Bug: oss-fuzz:44132 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/503016 > Reviewed-by: Brian Osman <brianosman@google.com> > Commit-Queue: Kevin Lubick <kjlubick@google.com> Bug: oss-fuzz:44132, skia:12900 Change-Id: Ia2eff9403b0035e7f86098f296d7d9b1bbfd4876 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/503716 Reviewed-by: John Stiles <johnstiles@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2022-02-03 15:54:07 +00:00
#include "src/gpu/GrUserStencilSettings.h"
rewrite includes to not need so much -Ifoo Current strategy: everything from the top Things to look at first are the manual changes: - added tools/rewrite_includes.py - removed -Idirectives from BUILD.gn - various compile.sh simplifications - tweak tools/embed_resources.py - update gn/find_headers.py to write paths from the top - update gn/gn_to_bp.py SkUserConfig.h layout so that #include "include/config/SkUserConfig.h" always gets the header we want. No-Presubmit: true Change-Id: I73a4b181654e0e38d229bc456c0d0854bae3363e Reviewed-on: https://skia-review.googlesource.com/c/skia/+/209706 Commit-Queue: Mike Klein <mtklein@google.com> Reviewed-by: Hal Canary <halcanary@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Reviewed-by: Florin Malita <fmalita@chromium.org>
2019-04-23 17:05:21 +00:00
#include "src/gpu/effects/GrPorterDuffXferProcessor.h"
Allow the Triangulator to fail Bug: 1262444 Change-Id: I951c1809c031c1c8e71d8c3ce1be3506bbfa3d2c Reviewed-on: https://skia-review.googlesource.com/c/skia/+/469904 Reviewed-by: Chris Dalton <csmartdalton@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-11-18 16:54:02 +00:00
#include "src/gpu/geometry/GrAATriangulator.h"
Move triangulators and tessellators into gpu/geometry This is the other half of making everything in gpu/ops be v1-only. Bug: skia:11837 Change-Id: I5d77a499ef02eba69208d5bd634650433d02f6fb Reviewed-on: https://skia-review.googlesource.com/c/skia/+/440216 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-08-17 18:17:23 +00:00
#include "src/gpu/geometry/GrInnerFanTriangulator.h"
Reland "Rename GrShape to GrStyledShape" This reverts commit 73b86c1ade1c002cfa4da66c33c25514737e2416. Reason for revert: wasn't the problem, relanding Original change's description: > Revert "Rename GrShape to GrStyledShape" > > This reverts commit f3f08af010eebdb9c1501bdf1b3d8e715298b05f. > > Reason for revert: maybe this is breaking the ios perf bot; it is the first CL that caused the bot to fail, but I can't really say why this would break them. > > Original change's description: > > Rename GrShape to GrStyledShape > > > > Change-Id: Ic457e634b4b95356f5615cff3fce1ca7d7677c26 > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/284036 > > Reviewed-by: Robert Phillips <robertphillips@google.com> > > Commit-Queue: Michael Ludwig <michaelludwig@google.com> > > TBR=bsalomon@google.com,robertphillips@google.com,michaelludwig@google.com > > # Not skipping CQ checks because original CL landed > 1 day ago. > > Change-Id: I2e5adbfc820811fbbde9cb57af28f86a7ba40bd9 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/284231 > Reviewed-by: Michael Ludwig <michaelludwig@google.com> > Commit-Queue: Michael Ludwig <michaelludwig@google.com> TBR=bsalomon@google.com,robertphillips@google.com,michaelludwig@google.com Change-Id: Ifdd52f8bacb5d66a7bf58efd328675c4c443ac8a No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/284376 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Michael Ludwig <michaelludwig@google.com>
2020-04-17 20:21:37 +00:00
#include "src/gpu/geometry/GrStyledShape.h"
rewrite includes to not need so much -Ifoo Current strategy: everything from the top Things to look at first are the manual changes: - added tools/rewrite_includes.py - removed -Idirectives from BUILD.gn - various compile.sh simplifications - tweak tools/embed_resources.py - update gn/find_headers.py to write paths from the top - update gn/gn_to_bp.py SkUserConfig.h layout so that #include "include/config/SkUserConfig.h" always gets the header we want. No-Presubmit: true Change-Id: I73a4b181654e0e38d229bc456c0d0854bae3363e Reviewed-on: https://skia-review.googlesource.com/c/skia/+/209706 Commit-Queue: Mike Klein <mtklein@google.com> Reviewed-by: Hal Canary <halcanary@google.com> Reviewed-by: Brian Osman <brianosman@google.com> Reviewed-by: Florin Malita <fmalita@chromium.org>
2019-04-23 17:05:21 +00:00
#include "src/shaders/SkShaderBase.h"
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
#include "tools/ToolUtils.h"
#include <map>
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
/*
* These tests pass by not crashing, hanging or asserting in Debug.
*/
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
using CreatePathFn = SkPath(*)();
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
CreatePathFn kNonEdgeAAPaths[] = {
// Tests active edges made inactive by splitting.
// Also tests active edge list forced into an invalid ordering by
// splitting (mopped up in cleanup_active_edges()).
[]() -> SkPath {
SkPath path;
path.moveTo(229.127044677734375f, 67.34100341796875f);
path.lineTo(187.8097381591796875f, -6.7729740142822265625f);
path.lineTo(171.411407470703125f, 50.94266510009765625f);
path.lineTo(245.5253753662109375f, 9.6253643035888671875f);
path.moveTo(208.4683990478515625f, 30.284009933471679688f);
path.lineTo(171.411407470703125f, 50.94266510009765625f);
path.lineTo(187.8097381591796875f, -6.7729740142822265625f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// Intersections which fall exactly on the current vertex, and require
// a restart of the intersection checking.
[]() -> SkPath {
SkPath path;
path.moveTo(314.483551025390625f, 486.246002197265625f);
path.lineTo(385.41949462890625f, 532.8087158203125f);
path.lineTo(373.232879638671875f, 474.05938720703125f);
path.lineTo(326.670166015625f, 544.995361328125f);
path.moveTo(349.951507568359375f, 509.52734375f);
path.lineTo(373.232879638671875f, 474.05938720703125f);
path.lineTo(385.41949462890625f, 532.8087158203125f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// Tests active edges which are removed by splitting.
[]() -> SkPath {
SkPath path;
path.moveTo(343.107391357421875f, 613.62176513671875f);
path.lineTo(426.632415771484375f, 628.5740966796875f);
path.lineTo(392.3460693359375f, 579.33544921875f);
path.lineTo(377.39373779296875f, 662.86041259765625f);
path.moveTo(384.869873046875f, 621.097900390625f);
path.lineTo(392.3460693359375f, 579.33544921875f);
path.lineTo(426.632415771484375f, 628.5740966796875f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// Collinear edges merged in set_top().
// Also, an intersection between left and right enclosing edges which
// falls above the current vertex.
[]() -> SkPath {
SkPath path;
path.moveTo(545.95751953125f, 791.69854736328125f);
path.lineTo(612.05816650390625f, 738.494140625f);
path.lineTo(552.4056396484375f, 732.0460205078125f);
path.lineTo(605.61004638671875f, 798.14666748046875f);
path.moveTo(579.00787353515625f, 765.0963134765625f);
path.lineTo(552.4056396484375f, 732.0460205078125f);
path.lineTo(612.05816650390625f, 738.494140625f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// Tests active edges which are made inactive by set_top().
[]() -> SkPath {
SkPath path;
path.moveTo(819.2725830078125f, 751.77447509765625f);
path.lineTo(820.70904541015625f, 666.933837890625f);
path.lineTo(777.57049560546875f, 708.63592529296875f);
path.lineTo(862.4111328125f, 710.0723876953125f);
path.moveTo(819.99078369140625f, 709.3541259765625f);
path.lineTo(777.57049560546875f, 708.63592529296875f);
path.lineTo(820.70904541015625f, 666.933837890625f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
[]() -> SkPath {
SkPath path;
path.moveTo(823.33209228515625f, 749.052734375f);
path.lineTo(823.494873046875f, 664.20013427734375f);
path.lineTo(780.9871826171875f, 706.5450439453125f);
path.lineTo(865.8397216796875f, 706.70782470703125f);
path.moveTo(823.4134521484375f, 706.6263427734375f);
path.lineTo(780.9871826171875f, 706.5450439453125f);
path.lineTo(823.494873046875f, 664.20013427734375f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
[]() -> SkPath {
SkPath path;
path.moveTo(954.862548828125f, 562.8349609375f);
path.lineTo(899.32818603515625f, 498.679443359375f);
path.lineTo(895.017578125f, 558.52435302734375f);
path.lineTo(959.17315673828125f, 502.990081787109375f);
path.moveTo(927.0953369140625f, 530.7572021484375f);
path.lineTo(895.017578125f, 558.52435302734375f);
path.lineTo(899.32818603515625f, 498.679443359375f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
[]() -> SkPath {
SkPath path;
path.moveTo(958.5330810546875f, 547.35516357421875f);
path.lineTo(899.93109130859375f, 485.989013671875f);
path.lineTo(898.54901123046875f, 545.97308349609375f);
path.lineTo(959.9151611328125f, 487.37109375f);
path.moveTo(929.2320556640625f, 516.67205810546875f);
path.lineTo(898.54901123046875f, 545.97308349609375f);
path.lineTo(899.93109130859375f, 485.989013671875f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
[]() -> SkPath {
SkPath path;
path.moveTo(389.8609619140625f, 369.326873779296875f);
path.lineTo(470.6290283203125f, 395.33697509765625f);
path.lineTo(443.250030517578125f, 341.9478759765625f);
path.lineTo(417.239959716796875f, 422.7159423828125f);
path.moveTo(430.244964599609375f, 382.3319091796875f);
path.lineTo(443.250030517578125f, 341.9478759765625f);
path.lineTo(470.6290283203125f, 395.33697509765625f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
[]() -> SkPath {
SkPath path;
path.moveTo(20, 20);
path.lineTo(50, 80);
path.lineTo(20, 80);
path.moveTo(80, 50);
path.lineTo(50, 50);
path.lineTo(20, 50);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
[]() -> SkPath {
SkPath path;
path.moveTo(257.19439697265625f, 320.876617431640625f);
path.lineTo(190.113037109375f, 320.58978271484375f);
path.lineTo(203.64404296875f, 293.8145751953125f);
path.moveTo(203.357177734375f, 360.896026611328125f);
path.lineTo(216.88824462890625f, 334.120819091796875f);
path.lineTo(230.41925048828125f, 307.345611572265625f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// A degenerate segments case, where both upper and lower segments of
// a split edge must remain active.
[]() -> SkPath {
SkPath path;
path.moveTo(231.9331207275390625f, 306.2012939453125f);
path.lineTo(191.4859161376953125f, 306.04547119140625f);
path.lineTo(231.0659332275390625f, 300.2642822265625f);
path.moveTo(189.946807861328125f, 302.072265625f);
path.lineTo(179.79705810546875f, 294.859771728515625f);
path.lineTo(191.0016021728515625f, 296.165679931640625f);
path.moveTo(150.8942108154296875f, 304.900146484375f);
path.lineTo(179.708892822265625f, 297.849029541015625f);
path.lineTo(190.4742279052734375f, 299.11895751953125f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// Handle the case where edge.dist(edge.fTop) != 0.0.
[]() -> SkPath {
SkPath path;
path.moveTo( 0.0f, 400.0f);
path.lineTo( 138.0f, 202.0f);
path.lineTo( 0.0f, 202.0f);
path.moveTo( 12.62693023681640625f, 250.57464599609375f);
path.lineTo( 8.13896942138671875f, 254.556884765625f);
path.lineTo(-18.15641021728515625f, 220.40203857421875f);
path.lineTo(-15.986493110656738281f, 219.6513519287109375f);
path.moveTo( 36.931194305419921875f, 282.485504150390625f);
path.lineTo( 15.617521286010742188f, 261.2901611328125f);
path.lineTo( 10.3829498291015625f, 252.565765380859375f);
path.lineTo(-16.165292739868164062f, 222.646026611328125f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// A degenerate segments case which exercises inactive edges being
// made active by splitting.
[]() -> SkPath {
SkPath path;
path.moveTo(690.62127685546875f, 509.25555419921875f);
path.lineTo(99.336181640625f, 511.71405029296875f);
path.lineTo(708.362548828125f, 512.4349365234375f);
path.lineTo(729.9940185546875f, 516.3114013671875f);
path.lineTo(738.708984375f, 518.76995849609375f);
path.lineTo(678.3463134765625f, 510.0819091796875f);
path.lineTo(681.21795654296875f, 504.81378173828125f);
path.moveTo(758.52764892578125f, 521.55963134765625f);
path.lineTo(719.1549072265625f, 514.50372314453125f);
path.lineTo(689.59063720703125f, 512.0628662109375f);
path.lineTo(679.78216552734375f, 507.447845458984375f);
return path;
},
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// Tests vertices which become "orphaned" (ie., no connected edges)
// after simplification.
[]() -> SkPath {
SkPath path;
path.moveTo(217.326019287109375f, 166.4752960205078125f);
path.lineTo(226.279266357421875f, 170.929473876953125f);
path.lineTo(234.3973388671875f, 177.0623626708984375f);
path.lineTo(262.0921630859375f, 188.746124267578125f);
path.moveTo(196.23638916015625f, 174.0722198486328125f);
path.lineTo(416.15277099609375f, 180.138214111328125f);
path.lineTo(192.651947021484375f, 304.0228271484375f);
return path;
},
Fix for out-of-bounds intersection (found by fuzzer). Sometimes, the intersection returned by check_intersection() is out-of-bounds for both edges (above both tops or below both bottoms) due to floating-point inaccuracy. This causes split_edge() to create a tiny negative-length edge on one side (which would then assert). Although we could safely remove this assert and allow the negative length edge to be removed, it's faster/safer to simply avoid its creation in the first place by adjusting one edge to the other edge's endpoint. Added a new unit test to exercise this case. Review URL: https://codereview.chromium.org/968993002
2015-03-02 17:34:13 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
[]() -> SkPath {
SkPath path;
path.moveTo( 0.0f, 0.0f);
path.lineTo(10000.0f, 0.0f);
path.lineTo( 0.0f, -1.0f);
path.lineTo(10000.0f, 0.000001f);
path.lineTo( 0.0f, -30.0f);
return path;
},
// Reduction of Nebraska-StateSeal.svg. Floating point error causes the
// same edge to be added to more than one poly on the same side.
[]() -> SkPath {
SkPath path;
path.moveTo(170.8199920654296875, 491.86700439453125);
path.lineTo(173.7649993896484375, 489.7340087890625);
path.lineTo(174.1450958251953125, 498.545989990234375);
path.lineTo( 171.998992919921875, 500.88201904296875);
path.moveTo(168.2922515869140625, 498.66265869140625);
path.lineTo(169.8589935302734375, 497.94500732421875);
path.lineTo( 172, 500.88299560546875);
path.moveTo( 169.555267333984375, 490.70111083984375);
path.lineTo(173.7649993896484375, 489.7340087890625);
path.lineTo( 170.82000732421875, 491.86700439453125);
return path;
},
// A shape with a vertex collinear to the right hand edge.
// This messes up find_enclosing_edges.
[]() -> SkPath {
SkPath path;
path.moveTo(80, 20);
path.lineTo(80, 60);
path.lineTo(20, 60);
path.moveTo(80, 50);
path.lineTo(80, 80);
path.lineTo(20, 80);
return path;
},
// Exercises the case where an edge becomes collinear with *two* of its
// adjacent neighbour edges after splitting.
// This is a reduction from
// http://mooooo.ooo/chebyshev-sine-approximation/horner_ulp.svg
[]() -> SkPath {
SkPath path;
path.moveTo( 351.99298095703125, 348.23046875);
path.lineTo( 351.91876220703125, 347.33984375);
path.lineTo( 351.91876220703125, 346.1953125);
path.lineTo( 351.90313720703125, 347.734375);
path.lineTo( 351.90313720703125, 346.1328125);
path.lineTo( 351.87579345703125, 347.93359375);
path.lineTo( 351.87579345703125, 345.484375);
path.lineTo( 351.86407470703125, 347.7890625);
path.lineTo( 351.86407470703125, 346.2109375);
path.lineTo( 351.84844970703125, 347.63763427734375);
path.lineTo( 351.84454345703125, 344.19232177734375);
path.lineTo( 351.78204345703125, 346.9483642578125);
path.lineTo( 351.758636474609375, 347.18310546875);
path.lineTo( 351.75469970703125, 346.75);
path.lineTo( 351.75469970703125, 345.46875);
path.lineTo( 352.5546875, 345.46875);
path.lineTo( 352.55078125, 347.01953125);
path.lineTo( 351.75079345703125, 347.02313232421875);
path.lineTo( 351.74688720703125, 346.15203857421875);
path.lineTo( 351.74688720703125, 347.646148681640625);
path.lineTo( 352.5390625, 346.94140625);
path.lineTo( 351.73907470703125, 346.94268798828125);
path.lineTo( 351.73516845703125, 344.48565673828125);
path.lineTo( 352.484375, 346.73828125);
path.lineTo( 351.68438720703125, 346.7401123046875);
path.lineTo( 352.4765625, 346.546875);
path.lineTo( 351.67657470703125, 346.54937744140625);
path.lineTo( 352.47265625, 346.75390625);
path.lineTo( 351.67266845703125, 346.756622314453125);
path.lineTo( 351.66876220703125, 345.612091064453125);
return path;
},
// A path which contains out-of-range colinear intersections.
[]() -> SkPath {
SkPath path;
path.moveTo( 0, 63.39080047607421875);
path.lineTo(-0.70804601907730102539, 63.14350128173828125);
path.lineTo(-7.8608899287380243391e-17, 64.14080047607421875);
path.moveTo( 0, 64.14080047607421875);
path.lineTo(44.285900115966796875, 64.14080047607421875);
path.lineTo( 0, 62.64080047607421875);
path.moveTo(21.434900283813476562, -0.24732701480388641357);
path.lineTo(-0.70804601907730102539, 63.14350128173828125);
path.lineTo(0.70804601907730102539, 63.6381988525390625);
return path;
},
// A path which results in infs and nans when conics are converted to quads.
[]() -> SkPath {
SkPath path;
path.moveTo(-2.20883e+37f, -1.02892e+37f);
path.conicTo(-2.00958e+38f, -9.36107e+37f, -1.7887e+38f, -8.33215e+37f, 0.707107f);
path.conicTo(-1.56782e+38f, -7.30323e+37f, 2.20883e+37f, 1.02892e+37f, 0.707107f);
path.conicTo(2.00958e+38f, 9.36107e+37f, 1.7887e+38f, 8.33215e+37f, 0.707107f);
path.conicTo(1.56782e+38f, 7.30323e+37f, -2.20883e+37f, -1.02892e+37f, 0.707107f);
return path;
},
// A quad which generates a huge number of points (>2B) when uniformly
// linearized. This should not hang or OOM.
[]() -> SkPath {
SkPath path;
path.moveTo(10, 0);
path.lineTo(0, 0);
path.quadTo(10, 0, 0, 8315084722602508288);
return path;
},
// A path which hangs during simplification. It produces an edge which is
// to the left of its own endpoints, which causes an infinite loop in the
// right-enclosing-edge splitting.
[]() -> SkPath {
SkPath path;
path.moveTo(0.75001740455627441406, 23.051967620849609375);
path.lineTo(5.8471612930297851562, 22.731662750244140625);
path.lineTo(10.749670028686523438, 22.253145217895507812);
path.lineTo(13.115868568420410156, 22.180681228637695312);
path.lineTo(15.418928146362304688, 22.340015411376953125);
path.lineTo( 17.654022216796875, 22.82159423828125);
path.lineTo(19.81632232666015625, 23.715869903564453125);
path.lineTo(40, 0);
path.lineTo(5.5635203441547955577e-15, 0);
path.lineTo(5.5635203441547955577e-15, 47);
path.lineTo(-1.4210854715202003717e-14, 21.713298797607421875);
path.lineTo(0.75001740455627441406, 21.694292068481445312);
path.lineTo(0.75001740455627441406, 23.051967620849609375);
return path;
},
// Reduction from skbug.com/7911 that causes a crash due to splitting a
// zombie edge.
[]() -> SkPath {
SkPath path;
path.moveTo( 0, 1.0927740941146660348e+24);
path.lineTo(2.9333931225865729333e+32, 16476101);
path.lineTo(1.0927731573659435417e+24, 1.0927740941146660348e+24);
path.lineTo(1.0927740941146660348e+24, 3.7616281094287041715e-37);
path.lineTo(1.0927740941146660348e+24, 1.0927740941146660348e+24);
path.lineTo(1.3061803026169399536e-33, 1.0927740941146660348e+24);
path.lineTo(4.7195362919941370727e-16, -8.4247545146051822591e+32);
return path;
},
// From crbug.com/844873. Crashes trying to merge a zombie edge.
[]() -> SkPath {
SkPath path;
path.moveTo( 316.000579833984375, -4338355948977389568);
path.lineTo(1.5069369808623501312e+20, 75180972320904708096.0);
path.lineTo(1.5069369808623501312e+20, 75180972320904708096.0);
path.lineTo( 771.21014404296875, -4338355948977389568.0);
path.lineTo( 316.000579833984375, -4338355948977389568.0);
path.moveTo( 354.208984375, -4338355948977389568.0);
path.lineTo( 773.00177001953125, -4338355948977389568.0);
path.lineTo(1.5069369808623501312e+20, 75180972320904708096.0);
path.lineTo(1.5069369808623501312e+20, 75180972320904708096.0);
path.lineTo( 354.208984375, -4338355948977389568.0);
return path;
},
// From crbug.com/844873. Hangs repeatedly splitting alternate vertices.
[]() -> SkPath {
SkPath path;
path.moveTo(10, -1e+20f);
path.lineTo(11, 25000);
path.lineTo(10, 25000);
path.lineTo(11, 25010);
return path;
},
// Reduction from circular_arcs_stroke_and_fill_round GM which
// repeatedly splits on the opposite edge from case 34 above.
[]() -> SkPath {
SkPath path;
path.moveTo( 16.25, 26.495191574096679688);
path.lineTo(32.420825958251953125, 37.377376556396484375);
path.lineTo(25.176382064819335938, 39.31851959228515625);
path.moveTo( 20, 20);
path.lineTo(28.847436904907226562, 37.940830230712890625);
path.lineTo(25.17638397216796875, 39.31851959228515625);
return path;
},
// Reduction from crbug.com/843135 where an intersection is found
// below the bottom of both intersected edges.
[]() -> SkPath {
SkPath path;
path.moveTo(-2791476679359332352, 2608107002026524672);
path.lineTo( 0, 11.95427703857421875);
path.lineTo(-2781824066779086848, 2599088532777598976);
path.lineTo( -7772.6875, 7274);
return path;
},
// Reduction from crbug.com/843135. Exercises a case where an intersection is missed.
// This causes bad ordering in the active edge list.
[]() -> SkPath {
SkPath path;
path.moveTo(-1.0662557646016024569e+23, 9.9621425197286319718e+22);
path.lineTo( -121806400, 113805032);
path.lineTo( -120098872, 112209680);
path.lineTo( 6.2832999862817380468e-36, 2.9885697364807128906);
return path;
},
// Reduction from crbug.com/851409. Exercises collinear last vertex.
[]() -> SkPath {
SkPath path;
path.moveTo(2072553216, 0);
path.lineTo(2072553216, 1);
path.lineTo(2072553472, -13.5);
path.lineTo(2072553216, 0);
path.lineTo(2072553472, -6.5);
return path;
},
// Another reduction from crbug.com/851409. Exercises two sequential collinear edges.
[]() -> SkPath {
SkPath path;
path.moveTo(2072553216, 0);
path.lineTo(2072553216, 1);
path.lineTo(2072553472, -13);
path.lineTo(2072553216, 0);
path.lineTo(2072553472, -6);
path.lineTo(2072553472, -13);
return path;
},
// Reduction from crbug.com/860655. Cause is three collinear edges discovered during
// sanitize_contours pass, before the vertices have been found coincident.
[]() -> SkPath {
SkPath path;
path.moveTo( 32572426382475264, -3053391034974208);
path.lineTo( 521289856, -48865776);
path.lineTo( 130322464, -12215873);
path.moveTo( 32572426382475264, -3053391034974208);
path.lineTo( 521289856, -48865776);
path.lineTo( 130322464, -12215873);
path.moveTo( 32572426382475264, -3053391034974208);
path.lineTo( 32114477642022912, -3010462031544320);
path.lineTo( 32111784697528320, -3010209702215680);
return path;
},
};
Fix assert caused by floating point error in tessellating path renderer. In rare cases, floating point error causes the tesselator to add the same Vertex to more than one Poly on the same side. This was not a big problem when we were allocating new vertices when constructing Polys, but after https://codereview.chromium.org/2029243002 it causes more serious issues, since each Edge can only belong to two Polys, and violating this condition messes up the linked list of Edges used for left & right Polys and the associated estimated vertex count. The fix is to simply let the first Poly win, and skip that vertex for subsequent Polys. Since this only occurs in cases where vertices are very close to each other, it should have little visual effect. This is also exercised by Nebraska-StateSeal.svg. BUG=skia:5636 GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2259493002 Review-Url: https://codereview.chromium.org/2259493002
2016-08-17 21:56:22 +00:00
Change architecture #defines to be SK_GPU_V1 and SK_GPU_V2 A strictly mechanical CL Bug: skia:11837 Change-Id: Id794d1fefe261d685b19e5d4d599cdab5e021cf7 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/424038 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-07-01 17:21:37 +00:00
#if SK_GPU_V1
Move 2 path renderers to skgpu::v1 namespace Bug: skia:11837 Change-Id: I71c8e5b7221e0eb84400e0ddc1a8126d820d24bb Reviewed-on: https://skia-review.googlesource.com/c/skia/+/440538 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Greg Daniel <egdaniel@google.com>
2021-08-19 15:12:48 +00:00
#include "src/gpu/ops/TriangulatingPathRenderer.h"
Update tests for a V1-only skgpu::v1::SurfaceDrawContext Bug: skia:11837 Change-Id: If8dd864d6cd8bc5ab9569fbab40866e1810dbc27 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/434162 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-07-29 15:23:48 +00:00
#include "src/gpu/v1/SurfaceDrawContext_v1.h"
Make GrPathRenderer and all derived class be OGA-only Bug: skia:11837 Change-Id: I92aacf8b412d0158036a5f27aa767590e426bd5c Reviewed-on: https://skia-review.googlesource.com/c/skia/+/417657 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-06-16 16:05:54 +00:00
GrTessellator (AA): null GrGeometryProcessor crash fix. Add a null-check on geometry processor creation. Add a test which exercises it: AA tessellator, with a non-invertible matrix and a fragment processor which needs local coords (e.g., linear gradient). BUG=691902 Change-Id: I005b893aed58d3ad2500c41501045ac94b0b4b95 Reviewed-on: https://skia-review.googlesource.com/8462 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-02-15 16:45:16 +00:00
// A simple concave path. Test this with a non-invertible matrix.
static SkPath create_path_17() {
SkPath path;
path.moveTo(20, 20);
path.lineTo(80, 20);
path.lineTo(30, 30);
path.lineTo(20, 80);
return path;
}
GrTessellator: fix logging; fix test comment. Change-Id: Iaded9025a1518d8c69dbe366deb1035e0bd4295b Reviewed-on: https://skia-review.googlesource.com/19289 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-06-09 14:06:26 +00:00
// An intersection above the first vertex in the mesh.
// Reduction from http://crbug.com/730687
GrTessellator: fix intersection above the first vertex. Handle the case where the an intersection falls not only above both edge endpoints, but above the first vertex in the mesh. This requires passing the mesh into check_for_intersection(), in order to modify the head. We also need to rewind the mesh after insertion, since we need to rewind to the newly-inserted vertex. This also cleans up vertex ID computation a little (for logging), so that vertices before the first vertex or after the last have a reasonable ID. It also cleans up the intersection-on-endpoint special cases by refactoring the calls to split_edge(). BUG=730687 Change-Id: Idea736eca7b7c3c5d8a470b1373a16ad8e649e80 Reviewed-on: https://skia-review.googlesource.com/19069 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-06-08 18:41:01 +00:00
static SkPath create_path_20() {
SkPath path;
path.moveTo( 2822128.5, 235.026336669921875);
path.lineTo( 2819349.25, 235.3623504638671875);
path.lineTo( -340558688, 23.83478546142578125);
path.lineTo( -340558752, 25.510419845581054688);
path.lineTo( -340558720, 27.18605804443359375);
return path;
}
GrTessellator: fix two NaN issues. If a point in the path rounds to +inf/-inf, the intersection code can produce NaN, which is unsortable. Fix: ignore non-finite intersections. Quadratic interpolation can sometimes produce NaN, which will never satisfy the flatness criterion. Abort if any of the interpolated points are non-finite. Bug:732023 Change-Id: If5881796e589c75b8f74459f42d00918619713a2 Reviewed-on: https://skia-review.googlesource.com/19467 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-06-12 15:43:18 +00:00
// An intersection whose result is NaN (due to rounded-to-inf endpoint).
static SkPath create_path_21() {
SkPath path;
path.moveTo(1.7889142061167663539e+38, 39338463358011572224.0);
path.lineTo( 1647.4193115234375, -522.603515625);
path.lineTo( 1677.74560546875, -529.0028076171875);
path.lineTo( 1678.29541015625, -528.7847900390625);
path.lineTo( 1637.5167236328125, -519.79266357421875);
path.lineTo( 1647.4193115234375, -522.603515625);
return path;
}
GrTessellator: implement straight skeleton, phase 2. This CL implements two major changes to the AA tessellating path renderer: 1) Fix inverted edges after stroke and simplify. Instead of detecting and fixing edges which invert on stroking during the stroking pass, we run the full simplify pass on both inner and outer contours, then create edge collapse events for the overlap regions. We then process the edge events in a priority queue and process them in order of decreasing alpha (this is the "edge event" part of the straight skeleton algorithm). By doing it after simplification, we ensure that there's a full-alpha intersection vertex to join the collapse edge to (which may have <1 alpha), so no spurious gradients appear in the rendered path. 2) "Pointy" vertices (defined as those which meet at an acute angle less than 14 degrees) are now properly bevelled off during stroking. This removes antialiasing artifacts which extend beyond the path boundary. Some ancillary changes: The extracted boundaries which are input to stroking have their line equations pre-normalized, and multiplied by winding. This simplifies a lot of code which was performing this computation on the fly. The workaround for the "intruding vertex" problem was removed, since the straight skeleton now moves the intruding vertex before it can cause problems. Bug: 756823 Change-Id: I271ed32be6847da55273b387e8c04bbf9b512b70 Reviewed-on: https://skia-review.googlesource.com/87341 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-12-19 23:09:54 +00:00
// An edge collapse event which also collapses a neighbour, requiring
// its event to be removed.
static SkPath create_path_25() {
SkPath path;
path.moveTo( 43.44110107421875, 148.15106201171875);
path.lineTo( 44.64471435546875, 148.16748046875);
path.lineTo( 46.35009765625, 147.403076171875);
path.lineTo( 46.45404052734375, 148.34906005859375);
path.lineTo( 45.0400390625, 148.54205322265625);
path.lineTo( 44.624053955078125, 148.9810791015625);
path.lineTo( 44.59405517578125, 149.16107177734375);
path.lineTo( 44.877044677734375, 149.62005615234375);
path.lineTo(144.373016357421875, 68.8070068359375);
return path;
}
// An edge collapse event causes an edge to become collinear, requiring
// its event to be removed.
static SkPath create_path_26() {
SkPath path;
path.moveTo( 43.44110107421875, 148.15106201171875);
path.lineTo( 44.64471435546875, 148.16748046875);
path.lineTo( 46.35009765625, 147.403076171875);
path.lineTo( 46.45404052734375, 148.34906005859375);
path.lineTo( 45.0400390625, 148.54205322265625);
path.lineTo( 44.624053955078125, 148.9810791015625);
path.lineTo( 44.59405517578125, 149.16107177734375);
path.lineTo( 44.877044677734375, 149.62005615234375);
path.lineTo(144.373016357421875, 68.8070068359375);
return path;
}
GrTessellator: fix for points which become non-finite on AA stroking. If input points are near-infinite, they may become inf or NaN when stroked. Before converting the results of intersection from double to float, clamp them to the [-FLT_MAX/FLT_MAX] range. BUG=798679 Change-Id: I7d61130dd26147a9b7cfd38aa96567e3867b5c3e Reviewed-on: https://skia-review.googlesource.com/90983 Commit-Queue: Stephen White <senorblanco@chromium.org> Reviewed-by: Brian Osman <brianosman@google.com>
2018-01-04 19:01:10 +00:00
// A path which results in non-finite points when stroked and bevelled for AA.
static SkPath create_path_27() {
SkPath path;
path.moveTo(8.5027233009104409507e+37, 1.7503381025241130639e+37);
path.lineTo(7.0923661737711584874e+37, 1.4600074517285415699e+37);
path.lineTo(7.0848733446033294691e+37, 1.4584649744781838604e+37);
path.lineTo(-2.0473916115129349496e+37, -4.2146796450364162012e+36);
path.lineTo(2.0473912312177548811e+37, 4.2146815465123165435e+36);
return path;
}
GrTessellator: fix for assert on bevelling. With some large values, intersection for bevelling will fail. These should just skip the point, not assert. BUG=798912 Change-Id: Ie5c8cc3c9387055e1e31480321a231f0e6ff153b Reviewed-on: https://skia-review.googlesource.com/91141 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-01-04 21:45:51 +00:00
// AA stroking this path produces intersection failures on bevelling.
// This should skip the point, but not assert.
static SkPath create_path_28() {
SkPath path;
path.moveTo(-7.5952312625177475154e+21, -2.6819185100266674911e+24);
path.lineTo( 1260.3787841796875, 1727.7947998046875);
path.lineTo( 1260.5567626953125, 1728.0386962890625);
path.lineTo(1.1482511310557754163e+21, 4.054538502765980051e+23);
path.lineTo(-7.5952312625177475154e+21, -2.6819185100266674911e+24);
return path;
}
GrTessellator: set a cap on quadratic linearization. Some pathological cases don't converge to a reasonable number of points when using uniform linearization of quadratic points. Cap them to the maximum which GrPathUtils supports. Add reduced test case from crbug-762369. BUG=762369 Change-Id: Icc744018e5c01a0e0fe2ec00613bdb25e49614e9 Reviewed-on: https://skia-review.googlesource.com/92721 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-01-09 16:49:08 +00:00
GrTessellator: fix for points that become infinite on stroking. stroke -> Inf -> NaN -> assert. BUG=skia:7775 Change-Id: I086883bce90d1d473cff87f67e954718ea3181f6 Reviewed-on: https://skia-review.googlesource.com/118145 Commit-Queue: Stephen White <senorblanco@chromium.org> Reviewed-by: Robert Phillips <robertphillips@google.com>
2018-04-03 15:28:15 +00:00
// A path with vertices which become infinite on AA stroking. Should not crash or assert.
static SkPath create_path_31() {
SkPath path;
path.moveTo(2.0257809259190991347e+36, -1244080640);
path.conicTo(2.0257809259190991347e+36, -1244080640,
2.0257809259190991347e+36, 0.10976474732160568237, 0.70710676908493041992);
path.lineTo(-10036566016, -1954718402215936);
path.conicTo(-1.1375507718551896064e+20, -1954721086570496,
10036566016, -1954721086570496, 0.70710676908493041992);
return path;
}
GrTessellator: avoid split with zero primary and out-of-range secondary. Sometimes the intersector will return an intersection which is on the same primary sort criterion (eg., Y coordinate), but out-of-range on the secondary. We shouldn't do splits in this case. The only case we really care about is if it's less than one epsilon and greater than zero, and thus numerically unsplittable. Bug: 851914 Change-Id: Ia772763b6a66a14ca159cf409a832835244e83bc Reviewed-on: https://skia-review.googlesource.com/136803 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-06-22 14:19:20 +00:00
// Reduction from crbug.com/851914.
static SkPath create_path_38() {
SkPath path;
path.moveTo(14.400531768798828125, 17.711114883422851562);
path.lineTo(14.621990203857421875, 171563104293879808);
path.lineTo(14.027951240539550781, 872585759381520384);
path.lineTo( 14.0216827392578125, 872665817571917824);
path.lineTo(7.699314117431640625, -3417320793833472);
path.moveTo(11.606547355651855469, 17.40966796875);
path.lineTo( 7642114886926860288, 21.08358001708984375);
path.lineTo(11.606547355651855469, 21.08358001708984375);
return path;
}
GrTessellator: missing intersection rewind fix. Some "missing" intersections (see https://skia.googlesource.com/skia/+/89042d5f13a56d6b663657aa58f17593123a344e) cause the active edge list to go out of order. In that case, we need to rewind the active list, just as we do before edge splitting for regular intersections. BUG=860453 Change-Id: I1f7b32157a73b427a4fd94c14c1eb440f26c0743 Reviewed-on: https://skia-review.googlesource.com/141038 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-07-12 19:54:05 +00:00
// Reduction from crbug.com/860453. Tests a case where a "missing" intersection
// requires the active edge list to go out-of-order.
static SkPath create_path_41() {
SkPath path;
path.moveTo(72154931603311689728.0, 330.95965576171875);
path.lineTo(24053266013925408768.0, 78.11376953125);
path.lineTo(1.2031099003292404941e+20, 387.168731689453125);
path.lineTo(68859835992355373056.0, 346.55047607421875);
path.lineTo(76451708695451009024.0, 337.780029296875);
path.moveTo(-20815817797613387776.0, 18065700622522384384.0);
path.lineTo(-72144121204987396096.0, 142.855804443359375);
path.lineTo(72144121204987396096.0, 325.184783935546875);
path.lineTo(1.2347242901040791552e+20, 18065700622522384384.0);
return path;
}
GrTessellator: fix for collinear edge merging. In some cases, two edges can be collinear when tested on one side (e.g., left top vs right edge), but non-collinear when tested on the other (e.g., right top vs left edge). We were actually merging based on one criterion, but assserting based on the other. The safest fix is to merge if either condition is true, and then assert that both conditions are false. Bug: 866319 Change-Id: Ia1be330caf62f6d7961746752f73993ca098d0a3 Reviewed-on: https://skia-review.googlesource.com/143501 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-07-26 14:02:27 +00:00
// Reduction from crbug.com/866319. Cause is edges that are collinear when tested from
// one side, but non-collinear when tested from the other.
static SkPath create_path_43() {
SkPath path;
path.moveTo( 307316821852160, -28808363114496);
path.lineTo( 307165222928384, -28794154909696);
path.lineTo( 307013691113472, -28779948802048);
path.lineTo( 306862159298560, -28765744791552);
path.lineTo( 306870313025536, -28766508154880);
path.lineTo( 307049695019008, -28783327313920);
path.lineTo( 307408660332544, -28816974020608);
return path;
}
GrTessellator: fix event creation for dead boundary edges. In some cases, an overlap boundary edge can be nulled out by the creation of a skeleton edge. In that case, we should avoid trying to create parallel edge events from that dead edge. This required making the tessellator verb maximum verb count modifiable at runtime for testing, since the test case has more than 10 vertices. Also added more logging. BUG: 966696 Change-Id: I429735999f6297655311485bc68d732b1c48bfce Reviewed-on: https://skia-review.googlesource.com/c/skia/+/216284 Commit-Queue: Stephen White <senorblanco@chromium.org> Reviewed-by: Robert Phillips <robertphillips@google.com>
2019-05-29 15:26:16 +00:00
// Reduction from crbug.com/966696
static SkPath create_path_44() {
SkPath path;
path.moveTo(114.4606170654296875, 186.443878173828125);
path.lineTo( 91.5394744873046875, 185.4189453125);
path.lineTo(306.45538330078125, 3203.986083984375);
path.moveTo(16276206965409972224.0, 815.59393310546875);
path.lineTo(-3.541605062372533207e+20, 487.7236328125);
path.lineTo(-3.541605062372533207e+20, 168.204071044921875);
path.lineTo(16276206965409972224.0, 496.07427978515625);
path.moveTo(-3.541605062372533207e+20, 167.00958251953125);
path.lineTo(-3.541605062372533207e+20, 488.32086181640625);
path.lineTo(16276206965409972224.0, 816.78839111328125);
path.lineTo(16276206965409972224.0, 495.47705078125);
return path;
}
GrTessellator: always rewind to edge top when splitting. In some cases, a split edge may go out-of-order with a neighbouring edge which has already been removed from the active edge list. The only way to be sure is to always rewind to the edge top. This may have performance implications for paths with many (hundreds) of self-intersections. We'll have to watch the bots carefully. Bug: 966274, 966364. Change-Id: I5a1b7abe9baa7fc279cbf7d1dfa258dcdaa35f11 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/217637 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2019-06-01 17:07:27 +00:00
// Reduction from crbug.com/966274.
static SkPath create_path_45() {
SkPath path;
path.moveTo( 706471854080, 379003666432);
path.lineTo( 706503180288, 379020443648);
path.lineTo( 706595717120, 379070087168);
path.lineTo( 706626060288, 379086372864);
path.lineTo( 706656141312, 379102527488);
path.lineTo( 706774171648, 379165835264);
path.lineTo( 706803073024, 379181334528);
path.lineTo( 706831712256, 379196702720);
path.lineTo( 706860154880, 379211939840);
path.lineTo( 706888335360, 379227078656);
path.lineTo( 706916253696, 379242053632);
path.lineTo( 706956820480, 379263811584);
path.lineTo( 706929098752, 379248934912);
path.lineTo( 706901114880, 379233927168);
path.lineTo( 706872934400, 379218821120);
path.lineTo( 706844491776, 379203551232);
path.lineTo( 706815787008, 379188183040);
path.lineTo( 706786885632, 379172651008);
path.lineTo( 706757722112, 379156987904);
path.lineTo( 706728296448, 379141226496);
path.lineTo( 706698608640, 379125301248);
path.lineTo( 706668724224, 379109244928);
path.lineTo( 706638577664, 379093090304);
path.lineTo( 706608168960, 379076771840);
path.lineTo( 706484174848, 379010252800);
return path;
}
GrTessellator: fix for intersections returning non-finite points. If the line/line intersection code returns Inf, it can easily turn into a NaN in subsequent operations, which leads to an assert or hang. The fix is to ignore intersections which are non-finite. Bug: 969359 Change-Id: I9e9a5ce5d617aa75b91215a5bbae91ce6f234b7b Reviewed-on: https://skia-review.googlesource.com/c/skia/+/219696 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2019-06-08 12:56:58 +00:00
// Reduction from crbug.com/969359. Inf generated by intersections
// causes NaN in subsequent intersections, leading to assert or hang.
static SkPath create_path_46() {
SkPath path;
path.moveTo(1.0321827899075254821e+37, -5.1199920965387697886e+37);
path.lineTo(-1.0321827899075254821e+37, 5.1199920965387697886e+37);
path.lineTo(-1.0425214946728668754e+37, 4.5731834042267216669e+37);
path.moveTo(-9.5077331762291841872e+36, 8.1304868292377430302e+37);
path.lineTo(9.5077331762291841872e+36, -8.1304868292377430302e+37);
path.lineTo(1.0795449417808426232e+37, 1.2246856113744539311e+37);
path.moveTo(-165.8018341064453125, -44.859375);
path.lineTo(-9.558702871563160835e+36, -7.9814405281448285475e+37);
path.lineTo(-9.4147814283168490381e+36, -8.3935116522790983488e+37);
return path;
}
Rewind farther on topology intersect mismatch Also fixes recursion end point update in recursive_edge_intersect, which was causing us to search in the wrong area of the lines and falsely report no intersection when there should have been one (which is then detected by the topology check in intersectEdgePair() and more less accurately corrected for). Bug: chromium:1245359 Change-Id: I1d21c934a23c9b99c3767849ee19bc2f6c551d3f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/482456 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Michael Ludwig <michaelludwig@google.com>
2021-12-09 21:50:50 +00:00
// Reduction from crbug.com/1245359
static SkPath create_path_47() {
SkPath path;
path.setFillType(SkPathFillType::kWinding);
path.moveTo(SkBits2Float(0xdfb80000), SkBits2Float(0x4cb9b4a5)); // -2.65172e+19f, 9.73632e+07f
path.lineTo(SkBits2Float(0xdfb80000), SkBits2Float(0xe396b530)); // -2.65172e+19f, -5.56014e+21f
path.lineTo(SkBits2Float(0x5fb80000), SkBits2Float(0xe396b530)); // 2.65172e+19f, -5.56014e+21f
path.lineTo(SkBits2Float(0x5fb80000), SkBits2Float(0x6396b530)); // 2.65172e+19f, 5.56014e+21f
path.lineTo(SkBits2Float(0x4cc07742), SkBits2Float(0x6396b530)); // 1.00908e+08f, 5.56014e+21f
path.lineTo(SkBits2Float(0xdfb80000), SkBits2Float(0x6396b530)); // -2.65172e+19f, 5.56014e+21f
path.lineTo(SkBits2Float(0xdfb80000), SkBits2Float(0xe396b530)); // -2.65172e+19f, -5.56014e+21f
path.lineTo(SkBits2Float(0x4cc07742), SkBits2Float(0xe396b530)); // 1.00908e+08f, -5.56014e+21f
path.lineTo(SkBits2Float(0x4cc079c8), SkBits2Float(0xe396b530)); // 1.00913e+08f, -5.56014e+21f
path.lineTo(SkBits2Float(0x4cc079c8), SkBits2Float(0x4cb9b4a5)); // 1.00913e+08f, 9.73632e+07f
path.lineTo(SkBits2Float(0xdfb80000), SkBits2Float(0x4cb9b4a5)); // -2.65172e+19f, 9.73632e+07f
path.lineTo(SkBits2Float(0xdfb80000), SkBits2Float(0x4cb74d74)); // -2.65172e+19f, 9.61033e+07f
path.lineTo(SkBits2Float(0x4cc079c8), SkBits2Float(0x4cb74d74)); // 1.00913e+08f, 9.61033e+07f
path.lineTo(SkBits2Float(0x4cc079c8), SkBits2Float(0x6396b530)); // 1.00913e+08f, 5.56014e+21f
path.lineTo(SkBits2Float(0x4cc07742), SkBits2Float(0x6396b530)); // 1.00908e+08f, 5.56014e+21f
path.lineTo(SkBits2Float(0x4cc07742), SkBits2Float(0x4cb74d74)); // 1.00908e+08f, 9.61033e+07f
path.lineTo(SkBits2Float(0x5fb80000), SkBits2Float(0x4cb74d74)); // 2.65172e+19f, 9.61033e+07f
path.lineTo(SkBits2Float(0x5fb80000), SkBits2Float(0x6396b530)); // 2.65172e+19f, 5.56014e+21f
path.lineTo(SkBits2Float(0xdfb80000), SkBits2Float(0x6396b530)); // -2.65172e+19f, 5.56014e+21f
path.lineTo(SkBits2Float(0xdfb80000), SkBits2Float(0x4cb9b4a5)); // -2.65172e+19f, 9.73632e+07f
path.close();
path.moveTo(SkBits2Float(0xdfb39e51), SkBits2Float(0xe282c5bd)); // -2.58857e+19f, -1.20616e+21f
path.lineTo(SkBits2Float(0xdf8a47ec), SkBits2Float(0xe3b90de5)); // -1.99284e+19f, -6.8273e+21f
path.lineTo(SkBits2Float(0x5eb8b548), SkBits2Float(0xe391e278)); // 6.65481e+18f, -5.38219e+21f
path.quadTo(SkBits2Float(0x5eaa9855), SkBits2Float(0xe392a246), // 6.14633e+18f, -5.40984e+21f
SkBits2Float(0x5e9c5925), SkBits2Float(0xe39344a0)); // 5.63304e+18f, -5.43323e+21f
path.quadTo(SkBits2Float(0x5e89eefd), SkBits2Float(0xe3941678), // 4.96958e+18f, -5.46347e+21f
SkBits2Float(0x5e6ead5a), SkBits2Float(0xe394b6a4)); // 4.29963e+18f, -5.48656e+21f
path.quadTo(SkBits2Float(0x5e6c0307), SkBits2Float(0xe394c21f), // 4.25161e+18f, -5.48821e+21f
SkBits2Float(0x5e694ef2), SkBits2Float(0xe394cd7f)); // 4.20291e+18f, -5.48985e+21f
path.quadTo(SkBits2Float(0x5e67eeaa), SkBits2Float(0xe394d349), // 4.17812e+18f, -5.49069e+21f
SkBits2Float(0x5e669614), SkBits2Float(0xe394d8e2)); // 4.15387e+18f, -5.49149e+21f
path.quadTo(SkBits2Float(0x5e6534d4), SkBits2Float(0xe394de9e), // 4.12901e+18f, -5.49232e+21f
SkBits2Float(0x5e63d6a7), SkBits2Float(0xe394e43c)); // 4.10437e+18f, -5.49313e+21f
path.quadTo(SkBits2Float(0x5e610d59), SkBits2Float(0xe394efad), // 4.05418e+18f, -5.49478e+21f
SkBits2Float(0x5e5e43cb), SkBits2Float(0xe394fad6)); // 4.00397e+18f, -5.49639e+21f
path.quadTo(SkBits2Float(0x5e5b6ac0), SkBits2Float(0xe395063d), // 3.95267e+18f, -5.49803e+21f
SkBits2Float(0x5e5895ab), SkBits2Float(0xe3951148)); // 3.90164e+18f, -5.49962e+21f
path.quadTo(SkBits2Float(0x5e55b52e), SkBits2Float(0xe3951c7f), // 3.84982e+18f, -5.50124e+21f
SkBits2Float(0x5e52cb8e), SkBits2Float(0xe395278b)); // 3.79735e+18f, -5.50283e+21f
path.quadTo(SkBits2Float(0x5e514f61), SkBits2Float(0xe3952d2d), // 3.7706e+18f, -5.50364e+21f
SkBits2Float(0x5e4fdbc5), SkBits2Float(0xe395329a)); // 3.74445e+18f, -5.50442e+21f
path.lineTo(SkBits2Float(0x5e4fdbc5), SkBits2Float(0xe395329a)); // 3.74445e+18f, -5.50442e+21f
path.lineTo(SkBits2Float(0x5e4fdbc5), SkBits2Float(0xe395329a)); // 3.74445e+18f, -5.50442e+21f
path.lineTo(SkBits2Float(0x5e4fdbc5), SkBits2Float(0xe395329a)); // 3.74445e+18f, -5.50442e+21f
path.lineTo(SkBits2Float(0x5e4fdbc5), SkBits2Float(0xe395329a)); // 3.74445e+18f, -5.50442e+21f
path.lineTo(SkBits2Float(0x5e4fdbc5), SkBits2Float(0xe395329a)); // 3.74445e+18f, -5.50442e+21f
path.lineTo(SkBits2Float(0x5e4fdbc5), SkBits2Float(0xe395329a)); // 3.74445e+18f, -5.50442e+21f
path.lineTo(SkBits2Float(0x5e4fdbc5), SkBits2Float(0xe395329a)); // 3.74445e+18f, -5.50442e+21f
path.lineTo(SkBits2Float(0x5e4fdbc5), SkBits2Float(0xe395329a)); // 3.74445e+18f, -5.50442e+21f
path.lineTo(SkBits2Float(0x5e4fdbc5), SkBits2Float(0xe395329a)); // 3.74445e+18f, -5.50442e+21f
path.lineTo(SkBits2Float(0xdfb80000), SkBits2Float(0xe396b530)); // -2.65172e+19f, -5.56014e+21f
path.lineTo(SkBits2Float(0x5fb80000), SkBits2Float(0xe396b530)); // 2.65172e+19f, -5.56014e+21f
path.lineTo(SkBits2Float(0x5fb80000), SkBits2Float(0x4cc8d35d)); // 2.65172e+19f, 1.0529e+08f
path.lineTo(SkBits2Float(0xdfe2ba48), SkBits2Float(0x63512f2f)); // -3.26749e+19f, 3.85877e+21f
path.lineTo(SkBits2Float(0xdf7f64f6), SkBits2Float(0xe3b9b457)); // -1.84031e+19f, -6.85129e+21f
path.lineTo(SkBits2Float(0xdfb80000), SkBits2Float(0x4cc8d35d)); // -2.65172e+19f, 1.0529e+08f
path.lineTo(SkBits2Float(0xdfb80000), SkBits2Float(0x4cbbf2a2)); // -2.65172e+19f, 9.85388e+07f
path.lineTo(SkBits2Float(0x4cc079c8), SkBits2Float(0x4cbbf2a2)); // 1.00913e+08f, 9.85388e+07f
path.lineTo(SkBits2Float(0x4cc079c8), SkBits2Float(0x6396b530)); // 1.00913e+08f, 5.56014e+21f
path.lineTo(SkBits2Float(0x4cc07742), SkBits2Float(0x6396b530)); // 1.00908e+08f, 5.56014e+21f
path.lineTo(SkBits2Float(0x4cc07742), SkBits2Float(0x4cbbf2a2)); // 1.00908e+08f, 9.85388e+07f
path.lineTo(SkBits2Float(0x5fb80000), SkBits2Float(0x4cbbf2a2)); // 2.65172e+19f, 9.85388e+07f
path.lineTo(SkBits2Float(0xdeb8b548), SkBits2Float(0x6391e278)); // -6.65481e+18f, 5.38219e+21f
path.lineTo(SkBits2Float(0x4cc07488), SkBits2Float(0x4ccb2302)); // 1.00902e+08f, 1.06502e+08f
path.lineTo(SkBits2Float(0x5fb39e51), SkBits2Float(0x6282c5bd)); // 2.58857e+19f, 1.20616e+21f
path.lineTo(SkBits2Float(0x5fb39e51), SkBits2Float(0x6282c5bd)); // 2.58857e+19f, 1.20616e+21f
path.lineTo(SkBits2Float(0x5f8bb406), SkBits2Float(0x63b3cfe4)); // 2.01334e+19f, 6.63389e+21f
path.lineTo(SkBits2Float(0xdfdb889b), SkBits2Float(0x6364da0b)); // -3.16381e+19f, 4.22157e+21f
path.lineTo(SkBits2Float(0xdfb39e51), SkBits2Float(0xe282c5bd)); // -2.58857e+19f, -1.20616e+21f
path.close();
return path;
}
Update more tests to use the GrDirectContext/GrRecordingContext pair Change-Id: I66011fef006398a95c9f54af97c5c1092b8b7415 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/305497 Reviewed-by: Adlai Holler <adlai@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2020-07-23 13:41:57 +00:00
static std::unique_ptr<GrFragmentProcessor> create_linear_gradient_processor(
GrRecordingContext* rContext) {
GrTessellator: implement straight skeleton, phase 2. This CL implements two major changes to the AA tessellating path renderer: 1) Fix inverted edges after stroke and simplify. Instead of detecting and fixing edges which invert on stroking during the stroking pass, we run the full simplify pass on both inner and outer contours, then create edge collapse events for the overlap regions. We then process the edge events in a priority queue and process them in order of decreasing alpha (this is the "edge event" part of the straight skeleton algorithm). By doing it after simplification, we ensure that there's a full-alpha intersection vertex to join the collapse edge to (which may have <1 alpha), so no spurious gradients appear in the rendered path. 2) "Pointy" vertices (defined as those which meet at an acute angle less than 14 degrees) are now properly bevelled off during stroking. This removes antialiasing artifacts which extend beyond the path boundary. Some ancillary changes: The extracted boundaries which are input to stroking have their line equations pre-normalized, and multiplied by winding. This simplifies a lot of code which was performing this computation on the fly. The workaround for the "intruding vertex" problem was removed, since the straight skeleton now moves the intruding vertex before it can cause problems. Bug: 756823 Change-Id: I271ed32be6847da55273b387e8c04bbf9b512b70 Reviewed-on: https://skia-review.googlesource.com/87341 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-12-19 23:09:54 +00:00
GrTessellator (AA): null GrGeometryProcessor crash fix. Add a null-check on geometry processor creation. Add a test which exercises it: AA tessellator, with a non-invertible matrix and a fragment processor which needs local coords (e.g., linear gradient). BUG=691902 Change-Id: I005b893aed58d3ad2500c41501045ac94b0b4b95 Reviewed-on: https://skia-review.googlesource.com/8462 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-02-15 16:45:16 +00:00
SkPoint pts[2] = { {0, 0}, {1, 1} };
SkColor colors[2] = { SK_ColorGREEN, SK_ColorBLUE };
sk_sp<SkShader> shader = SkGradientShader::MakeLinear(
Use SkTileMode instead of nested enum Add guard to transition clients Change-Id: Ia7a3e8f95722f91e84af262168dadf89a78707da Reviewed-on: https://skia-review.googlesource.com/c/skia/+/205720 Reviewed-by: Mike Reed <reed@google.com> Commit-Queue: Mike Reed <reed@google.com> Auto-Submit: Mike Reed <reed@google.com>
2019-04-03 14:27:45 +00:00
pts, colors, nullptr, SK_ARRAY_COUNT(colors), SkTileMode::kClamp);
Rename GrColorSpaceInfo -> GrColorInfo Add version SkImageInfo::Make() that takes SkISize instead of separate width and height. Change-Id: I42aa79d23b19e22f5405631728c245b04bce0559 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/245172 Commit-Queue: Brian Salomon <bsalomon@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2019-09-30 19:12:27 +00:00
GrColorInfo colorInfo(GrColorType::kRGBA_8888, kPremul_SkAlphaType, nullptr);
Refactor SkMatrixProvider slightly There was only one virtual method, so switch that to a bool stored in the base class. The derived types exist as hints for the reader, and an easy way to adjust how the new localToDevice is constructed. With this change, we don't need SkSimpleMatrixProvider. SkMatrixProvider is concrete, so we can use it directly. SkOverrideDeviceMatrixProvider no longer needs the original provider for anything, so remove that parameter. It now exists solely to inhibit the hitsPixelCenters flag. Fix a few spots (SkParticleBinding, some sites in SkRuntimeEffect) where we used SkSimpleMatrixProvider, even though the local coordinates being passed did not obey the hits-pixel-centers constraints. Most importantly, document how localToDeviceHitsPixelCenters works. Change-Id: Ibe9060bac0822d0edf52a507d390bd198d8e6dbd Reviewed-on: https://skia-review.googlesource.com/c/skia/+/482176 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: Brian Osman <brianosman@google.com>
2021-12-09 17:55:27 +00:00
SkMatrixProvider matrixProvider(SkMatrix::I());
GrFPArgs no longer needs sampling Change-Id: I20fc4b4c3d6997f3ebc1d6d0049447b348f8a110 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/387416 Reviewed-by: John Stiles <johnstiles@google.com> Commit-Queue: Mike Reed <reed@google.com>
2021-03-20 14:49:02 +00:00
return as_SB(shader)->asFragmentProcessor({rContext, matrixProvider, &colorInfo});
GrTessellator (AA): null GrGeometryProcessor crash fix. Add a null-check on geometry processor creation. Add a test which exercises it: AA tessellator, with a non-invertible matrix and a fragment processor which needs local coords (e.g., linear gradient). BUG=691902 Change-Id: I005b893aed58d3ad2500c41501045ac94b0b4b95 Reviewed-on: https://skia-review.googlesource.com/8462 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-02-15 16:45:16 +00:00
}
Update more tests to use the GrDirectContext/GrRecordingContext pair Change-Id: I66011fef006398a95c9f54af97c5c1092b8b7415 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/305497 Reviewed-by: Adlai Holler <adlai@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2020-07-23 13:41:57 +00:00
static void test_path(GrRecordingContext* rContext,
Rename GrSurfaceDrawContext to skgpu::v1::SurfaceDrawContext This CL is mostly mechanical. It: replaces "src/gpu/GrSurfaceDrawContext.h" #includes with "src/gpu/v1/SurfaceDrawContext_v1.h" and reorders replaces "class GrSurfaceDrawContext;" with "namespace skgpu { namespace v1 { class SurfaceDrawContext; }}" replaces "GrSurfaceDrawContext*" with "auto" where possible replaces "rtc" with "sdc" replaces "surfaceDrawContext" with "sdc" replaces GrSurfaceDrawContext with skgpu::v1::SurfaceDrawContext reflows parameters as needed This CL does not try to: make skgpu::v1::SurfaceDrawContext V1-only minimize the skgpu and/or skgpu::v1 prefixes Those two tasks will be accomplished in follow up CLs. This CL is just trying to get the bulk of the mechanical changes comprehensibly landed. Bug: skia:11837 Change-Id: I6fe59080249d585df8f5d27c6b67569cdc35842f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/433156 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
2021-07-28 19:13:20 +00:00
skgpu::v1::SurfaceDrawContext* sdc,
GrTessellator (AA): null GrGeometryProcessor crash fix. Add a null-check on geometry processor creation. Add a test which exercises it: AA tessellator, with a non-invertible matrix and a fragment processor which needs local coords (e.g., linear gradient). BUG=691902 Change-Id: I005b893aed58d3ad2500c41501045ac94b0b4b95 Reviewed-on: https://skia-review.googlesource.com/8462 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-02-15 16:45:16 +00:00
const SkPath& path,
const SkMatrix& matrix = SkMatrix::I(),
Eliminate mixed samples as an FBO type or AA type From now on, sample counts always refer to the number of actual color samples, and render targets don't have separate color and stencil sample counts. If mixed samples support is available when making a "GrAAType::kCoverage" draw, then an op may attach and use a mixed sampled stencil buffer internally. But this will all be invisible to the client. After this CL, we temporarily won't have a mode to use nvpr with mixed samples. That will soon be fixed by a follow-on CL that enables nvpr with mixed samples in the normal "gl" and "gles" configs. Bug: skia: Change-Id: I1cb8277f0d2d0d371f24bb9f39cd473ed5c5c83b Reviewed-on: https://skia-review.googlesource.com/c/skia/+/221878 Commit-Queue: Chris Dalton <csmartdalton@google.com> Reviewed-by: Brian Salomon <bsalomon@google.com>
2019-06-24 00:07:38 +00:00
GrAAType aaType = GrAAType::kNone,
Make GrFragmentProcessor be non-refcounted and use std::unique_ptr. Change-Id: I985e54a071338e99292a5aa2f42c92bc115b4008 Reviewed-on: https://skia-review.googlesource.com/32760 Commit-Queue: Brian Salomon <bsalomon@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2017-08-11 13:40:37 +00:00
std::unique_ptr<GrFragmentProcessor> fp = nullptr) {
Move 2 path renderers to skgpu::v1 namespace Bug: skia:11837 Change-Id: I71c8e5b7221e0eb84400e0ddc1a8126d820d24bb Reviewed-on: https://skia-review.googlesource.com/c/skia/+/440538 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Greg Daniel <egdaniel@google.com>
2021-08-19 15:12:48 +00:00
skgpu::v1::TriangulatingPathRenderer pr;
Rename CPU tessellation to "triangulation" Ambiguity has come up re: what "tessellation" means in Ganesh. I believe that, in the context of a graphics library, "tessellation" should refer to the hardware pipeline feature of submitting patches and tessellating them on the GPU. This CL therefore renames classes that triangulate things on the CPU to call it "triangulation". Change-Id: Ic8515ea6a33000f1b638a852d5122bc9bd6b38f2 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/279236 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2020-03-25 22:18:16 +00:00
pr.setMaxVerbCount(100);
Make GrClipMaskManager stateless and push GrPipelineBuilder construction downstack This will be followed up with a CL to remove the GrRenderTarget from the GrPipelineBuilder. Split out of: https://codereview.chromium.org/1988923002/ (Declassify GrClipMaskManager and Remove GrRenderTarget and GrDrawTarget from GrPipelineBuilder) GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2035823002 Review-Url: https://codereview.chromium.org/2035823002
2016-06-03 17:59:20 +00:00
GrPaint paint;
Revert "Revert "Removing ref counting from GrXPFactory."" This reverts commit 003312a211e65f35e402d6fe80a32e23d4c94ac4. Change-Id: Ib41065e5c356d1dd99e70fa10611ac6756c2b79d Reviewed-on: https://skia-review.googlesource.com/6803 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Brian Salomon <bsalomon@google.com>
2017-01-09 16:46:10 +00:00
paint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc));
GrTessellator (AA): null GrGeometryProcessor crash fix. Add a null-check on geometry processor creation. Add a test which exercises it: AA tessellator, with a non-invertible matrix and a fragment processor which needs local coords (e.g., linear gradient). BUG=691902 Change-Id: I005b893aed58d3ad2500c41501045ac94b0b4b95 Reviewed-on: https://skia-review.googlesource.com/8462 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-02-15 16:45:16 +00:00
if (fp) {
Update GrPaint APIs to reflect lack of multiple color processors. Change-Id: Ic7799b3c5f4294cba9ff72f8c11a2ad285ab189f Bug: skia:10217 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/304738 Commit-Queue: John Stiles <johnstiles@google.com> Reviewed-by: Brian Salomon <bsalomon@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2020-07-21 16:28:35 +00:00
paint.setColorFragmentProcessor(std::move(fp));
GrTessellator (AA): null GrGeometryProcessor crash fix. Add a null-check on geometry processor creation. Add a test which exercises it: AA tessellator, with a non-invertible matrix and a fragment processor which needs local coords (e.g., linear gradient). BUG=691902 Change-Id: I005b893aed58d3ad2500c41501045ac94b0b4b95 Reviewed-on: https://skia-review.googlesource.com/8462 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-02-15 16:45:16 +00:00
}
Make GrClipMaskManager stateless and push GrPipelineBuilder construction downstack This will be followed up with a CL to remove the GrRenderTarget from the GrPipelineBuilder. Split out of: https://codereview.chromium.org/1988923002/ (Declassify GrClipMaskManager and Remove GrRenderTarget and GrDrawTarget from GrPipelineBuilder) GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2035823002 Review-Url: https://codereview.chromium.org/2035823002
2016-06-03 17:59:20 +00:00
Rename GrSurfaceDrawContext to skgpu::v1::SurfaceDrawContext This CL is mostly mechanical. It: replaces "src/gpu/GrSurfaceDrawContext.h" #includes with "src/gpu/v1/SurfaceDrawContext_v1.h" and reorders replaces "class GrSurfaceDrawContext;" with "namespace skgpu { namespace v1 { class SurfaceDrawContext; }}" replaces "GrSurfaceDrawContext*" with "auto" where possible replaces "rtc" with "sdc" replaces "surfaceDrawContext" with "sdc" replaces GrSurfaceDrawContext with skgpu::v1::SurfaceDrawContext reflows parameters as needed This CL does not try to: make skgpu::v1::SurfaceDrawContext V1-only minimize the skgpu and/or skgpu::v1 prefixes Those two tasks will be accomplished in follow up CLs. This CL is just trying to get the bulk of the mechanical changes comprehensibly landed. Bug: skia:11837 Change-Id: I6fe59080249d585df8f5d27c6b67569cdc35842f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/433156 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
2021-07-28 19:13:20 +00:00
SkIRect clipConservativeBounds = SkIRect::MakeWH(sdc->width(), sdc->height());
Replace GrStrokeInfo with GrStyle. A side effect is that arbitrary path effects can no be pushed deeper into the Ganesh flow for paths. They may be applied by path renderers. GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1957363002 Committed: https://skia.googlesource.com/skia/+/33595bdf4b64a745f6340338d307e806e96c587f Review-Url: https://codereview.chromium.org/1957363002
2016-05-10 16:14:17 +00:00
GrStyle style(SkStrokeRec::kFill_InitStyle);
Reland "Rename GrShape to GrStyledShape" This reverts commit 73b86c1ade1c002cfa4da66c33c25514737e2416. Reason for revert: wasn't the problem, relanding Original change's description: > Revert "Rename GrShape to GrStyledShape" > > This reverts commit f3f08af010eebdb9c1501bdf1b3d8e715298b05f. > > Reason for revert: maybe this is breaking the ios perf bot; it is the first CL that caused the bot to fail, but I can't really say why this would break them. > > Original change's description: > > Rename GrShape to GrStyledShape > > > > Change-Id: Ic457e634b4b95356f5615cff3fce1ca7d7677c26 > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/284036 > > Reviewed-by: Robert Phillips <robertphillips@google.com> > > Commit-Queue: Michael Ludwig <michaelludwig@google.com> > > TBR=bsalomon@google.com,robertphillips@google.com,michaelludwig@google.com > > # Not skipping CQ checks because original CL landed > 1 day ago. > > Change-Id: I2e5adbfc820811fbbde9cb57af28f86a7ba40bd9 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/284231 > Reviewed-by: Michael Ludwig <michaelludwig@google.com> > Commit-Queue: Michael Ludwig <michaelludwig@google.com> TBR=bsalomon@google.com,robertphillips@google.com,michaelludwig@google.com Change-Id: Ifdd52f8bacb5d66a7bf58efd328675c4c443ac8a No-Presubmit: true No-Tree-Checks: true No-Try: true Reviewed-on: https://skia-review.googlesource.com/c/skia/+/284376 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Michael Ludwig <michaelludwig@google.com>
2020-04-17 20:21:37 +00:00
GrStyledShape shape(path, style);
Move GrPathRenderer and GrPathRendererChain to skgpu::v1 namespace Bug: skia:11837 Change-Id: I42abcd3724ac1e2c71d3bd13ff6295a4683af5e0 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/440261 Reviewed-by: Greg Daniel <egdaniel@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-08-19 16:30:12 +00:00
skgpu::v1::PathRenderer::DrawPathArgs args{rContext,
std::move(paint),
&GrUserStencilSettings::kUnused,
sdc,
nullptr,
&clipConservativeBounds,
&matrix,
&shape,
aaType,
false};
Rename CPU tessellation to "triangulation" Ambiguity has come up re: what "tessellation" means in Ganesh. I believe that, in the context of a graphics library, "tessellation" should refer to the hardware pipeline feature of submitting patches and tessellating them on the GPU. This CL therefore renames classes that triangulate things on the CPU to call it "triangulation". Change-Id: Ic8515ea6a33000f1b638a852d5122bc9bd6b38f2 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/279236 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2020-03-25 22:18:16 +00:00
pr.drawPath(args);
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
}
Rename CPU tessellation to "triangulation" Ambiguity has come up re: what "tessellation" means in Ganesh. I believe that, in the context of a graphics library, "tessellation" should refer to the hardware pipeline feature of submitting patches and tessellating them on the GPU. This CL therefore renames classes that triangulate things on the CPU to call it "triangulation". Change-Id: Ic8515ea6a33000f1b638a852d5122bc9bd6b38f2 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/279236 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2020-03-25 22:18:16 +00:00
DEF_GPUTEST_FOR_ALL_CONTEXTS(TriangulatingPathRendererTests, reporter, ctxInfo) {
Update unit tests to accept GrDirectContext This CL makes it explicit that the unit tests always get a direct context. It is mainly a mechanical CL. Change-Id: I49e0628851d9c81eb47386ef978edf905c6469d8 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/299866 Reviewed-by: Adlai Holler <adlai@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2020-07-06 14:56:46 +00:00
auto ctx = ctxInfo.directContext();
Rename GrSurfaceDrawContext to skgpu::v1::SurfaceDrawContext This CL is mostly mechanical. It: replaces "src/gpu/GrSurfaceDrawContext.h" #includes with "src/gpu/v1/SurfaceDrawContext_v1.h" and reorders replaces "class GrSurfaceDrawContext;" with "namespace skgpu { namespace v1 { class SurfaceDrawContext; }}" replaces "GrSurfaceDrawContext*" with "auto" where possible replaces "rtc" with "sdc" replaces "surfaceDrawContext" with "sdc" replaces GrSurfaceDrawContext with skgpu::v1::SurfaceDrawContext reflows parameters as needed This CL does not try to: make skgpu::v1::SurfaceDrawContext V1-only minimize the skgpu and/or skgpu::v1 prefixes Those two tasks will be accomplished in follow up CLs. This CL is just trying to get the bulk of the mechanical changes comprehensibly landed. Bug: skia:11837 Change-Id: I6fe59080249d585df8f5d27c6b67569cdc35842f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/433156 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
2021-07-28 19:13:20 +00:00
auto sdc = skgpu::v1::SurfaceDrawContext::Make(
Make SkSurfaceProps non-optional for SDCs and SkSpecialImages This ensures we don't lose the original SkSurfaceProps when creating image filters, etc. Bug: skia:11396 Change-Id: I6b412361c1005138278a1396faa7f7e069ec7eb2 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/397291 Commit-Queue: Chris Dalton <csmartdalton@google.com> Reviewed-by: Brian Salomon <bsalomon@google.com> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
2021-04-19 23:27:09 +00:00
ctx, GrColorType::kRGBA_8888, nullptr, SkBackingFit::kApprox, {800, 800},
SkSurfaceProps(), 1, GrMipmapped::kNo, GrProtected::kNo, kTopLeft_GrSurfaceOrigin);
Rename GrSurfaceDrawContext to skgpu::v1::SurfaceDrawContext This CL is mostly mechanical. It: replaces "src/gpu/GrSurfaceDrawContext.h" #includes with "src/gpu/v1/SurfaceDrawContext_v1.h" and reorders replaces "class GrSurfaceDrawContext;" with "namespace skgpu { namespace v1 { class SurfaceDrawContext; }}" replaces "GrSurfaceDrawContext*" with "auto" where possible replaces "rtc" with "sdc" replaces "surfaceDrawContext" with "sdc" replaces GrSurfaceDrawContext with skgpu::v1::SurfaceDrawContext reflows parameters as needed This CL does not try to: make skgpu::v1::SurfaceDrawContext V1-only minimize the skgpu and/or skgpu::v1 prefixes Those two tasks will be accomplished in follow up CLs. This CL is just trying to get the bulk of the mechanical changes comprehensibly landed. Bug: skia:11837 Change-Id: I6fe59080249d585df8f5d27c6b67569cdc35842f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/433156 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
2021-07-28 19:13:20 +00:00
if (!sdc) {
Retract GrRenderTarget from GrTestTarget Split out of: https://codereview.chromium.org/1988923002/ (Declassify GrClipMaskManager and Remove GrRenderTarget and GrDrawTarget from GrPipelineBuilder) GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=2004433002 Review-Url: https://codereview.chromium.org/2004433002
2016-05-20 18:14:33 +00:00
return;
}
Update internal skia uses to use flushAndSubmit and submit calls. Bug: skia:10118 Change-Id: Ieb7c0eece56d3d9df56ecb52e00e76c01f038de8 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/289888 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Greg Daniel <egdaniel@google.com>
2020-05-14 19:45:44 +00:00
ctx->flushAndSubmit();
Fix unit tests that were causes vulkan unitialized memory warnings in validation Bug: skia: Change-Id: Id9df92b76c9f948f41f4108bcecdb2687233f841 Reviewed-on: https://skia-review.googlesource.com/110761 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Greg Daniel <egdaniel@google.com>
2018-02-27 19:26:32 +00:00
// Adding discard to appease vulkan validation warning about loading uninitialized data on draw
Rename GrSurfaceDrawContext to skgpu::v1::SurfaceDrawContext This CL is mostly mechanical. It: replaces "src/gpu/GrSurfaceDrawContext.h" #includes with "src/gpu/v1/SurfaceDrawContext_v1.h" and reorders replaces "class GrSurfaceDrawContext;" with "namespace skgpu { namespace v1 { class SurfaceDrawContext; }}" replaces "GrSurfaceDrawContext*" with "auto" where possible replaces "rtc" with "sdc" replaces "surfaceDrawContext" with "sdc" replaces GrSurfaceDrawContext with skgpu::v1::SurfaceDrawContext reflows parameters as needed This CL does not try to: make skgpu::v1::SurfaceDrawContext V1-only minimize the skgpu and/or skgpu::v1 prefixes Those two tasks will be accomplished in follow up CLs. This CL is just trying to get the bulk of the mechanical changes comprehensibly landed. Bug: skia:11837 Change-Id: I6fe59080249d585df8f5d27c6b67569cdc35842f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/433156 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
2021-07-28 19:13:20 +00:00
sdc->discard();
Fix unit tests that were causes vulkan unitialized memory warnings in validation Bug: skia: Change-Id: Id9df92b76c9f948f41f4108bcecdb2687233f841 Reviewed-on: https://skia-review.googlesource.com/110761 Reviewed-by: Brian Osman <brianosman@google.com> Commit-Queue: Greg Daniel <egdaniel@google.com>
2018-02-27 19:26:32 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
for (CreatePathFn createPath : kNonEdgeAAPaths) {
Rename GrSurfaceDrawContext to skgpu::v1::SurfaceDrawContext This CL is mostly mechanical. It: replaces "src/gpu/GrSurfaceDrawContext.h" #includes with "src/gpu/v1/SurfaceDrawContext_v1.h" and reorders replaces "class GrSurfaceDrawContext;" with "namespace skgpu { namespace v1 { class SurfaceDrawContext; }}" replaces "GrSurfaceDrawContext*" with "auto" where possible replaces "rtc" with "sdc" replaces "surfaceDrawContext" with "sdc" replaces GrSurfaceDrawContext with skgpu::v1::SurfaceDrawContext reflows parameters as needed This CL does not try to: make skgpu::v1::SurfaceDrawContext V1-only minimize the skgpu and/or skgpu::v1 prefixes Those two tasks will be accomplished in follow up CLs. This CL is just trying to get the bulk of the mechanical changes comprehensibly landed. Bug: skia:11837 Change-Id: I6fe59080249d585df8f5d27c6b67569cdc35842f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/433156 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
2021-07-28 19:13:20 +00:00
test_path(ctx, sdc.get(), createPath());
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
}
Revert "Revert "move onto new factories for SkMatrix"" This reverts commit c80ee456adf664c4a62fa2ccaeaf157c723ed656. fix: update flutter's gn file to add guard Change-Id: Iac5171c8475d9a862d06255dab1c6f38f10de2f2 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/291361 Reviewed-by: Mike Reed <reed@google.com> Commit-Queue: Mike Reed <reed@google.com>
2020-05-21 16:11:27 +00:00
SkMatrix nonInvertibleMatrix = SkMatrix::Scale(0, 0);
Make GrFragmentProcessor be non-refcounted and use std::unique_ptr. Change-Id: I985e54a071338e99292a5aa2f42c92bc115b4008 Reviewed-on: https://skia-review.googlesource.com/32760 Commit-Queue: Brian Salomon <bsalomon@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2017-08-11 13:40:37 +00:00
std::unique_ptr<GrFragmentProcessor> fp(create_linear_gradient_processor(ctx));
Rename GrSurfaceDrawContext to skgpu::v1::SurfaceDrawContext This CL is mostly mechanical. It: replaces "src/gpu/GrSurfaceDrawContext.h" #includes with "src/gpu/v1/SurfaceDrawContext_v1.h" and reorders replaces "class GrSurfaceDrawContext;" with "namespace skgpu { namespace v1 { class SurfaceDrawContext; }}" replaces "GrSurfaceDrawContext*" with "auto" where possible replaces "rtc" with "sdc" replaces "surfaceDrawContext" with "sdc" replaces GrSurfaceDrawContext with skgpu::v1::SurfaceDrawContext reflows parameters as needed This CL does not try to: make skgpu::v1::SurfaceDrawContext V1-only minimize the skgpu and/or skgpu::v1 prefixes Those two tasks will be accomplished in follow up CLs. This CL is just trying to get the bulk of the mechanical changes comprehensibly landed. Bug: skia:11837 Change-Id: I6fe59080249d585df8f5d27c6b67569cdc35842f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/433156 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
2021-07-28 19:13:20 +00:00
test_path(ctx, sdc.get(), create_path_17(), nonInvertibleMatrix, GrAAType::kCoverage,
Make GrFragmentProcessor be non-refcounted and use std::unique_ptr. Change-Id: I985e54a071338e99292a5aa2f42c92bc115b4008 Reviewed-on: https://skia-review.googlesource.com/32760 Commit-Queue: Brian Salomon <bsalomon@google.com> Reviewed-by: Brian Osman <brianosman@google.com>
2017-08-11 13:40:37 +00:00
std::move(fp));
Rename GrSurfaceDrawContext to skgpu::v1::SurfaceDrawContext This CL is mostly mechanical. It: replaces "src/gpu/GrSurfaceDrawContext.h" #includes with "src/gpu/v1/SurfaceDrawContext_v1.h" and reorders replaces "class GrSurfaceDrawContext;" with "namespace skgpu { namespace v1 { class SurfaceDrawContext; }}" replaces "GrSurfaceDrawContext*" with "auto" where possible replaces "rtc" with "sdc" replaces "surfaceDrawContext" with "sdc" replaces GrSurfaceDrawContext with skgpu::v1::SurfaceDrawContext reflows parameters as needed This CL does not try to: make skgpu::v1::SurfaceDrawContext V1-only minimize the skgpu and/or skgpu::v1 prefixes Those two tasks will be accomplished in follow up CLs. This CL is just trying to get the bulk of the mechanical changes comprehensibly landed. Bug: skia:11837 Change-Id: I6fe59080249d585df8f5d27c6b67569cdc35842f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/433156 Commit-Queue: Robert Phillips <robertphillips@google.com> Reviewed-by: Michael Ludwig <michaelludwig@google.com>
2021-07-28 19:13:20 +00:00
test_path(ctx, sdc.get(), create_path_20(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_21(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_25(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_26(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_27(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_28(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_31(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_38(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_41(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_43(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_44(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_45(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, sdc.get(), create_path_46(), SkMatrix(), GrAAType::kCoverage);
Rewind farther on topology intersect mismatch Also fixes recursion end point update in recursive_edge_intersect, which was causing us to search in the wrong area of the lines and falsely report no intersection when there should have been one (which is then detected by the topology check in intersectEdgePair() and more less accurately corrected for). Bug: chromium:1245359 Change-Id: I1d21c934a23c9b99c3767849ee19bc2f6c551d3f Reviewed-on: https://skia-review.googlesource.com/c/skia/+/482456 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Michael Ludwig <michaelludwig@google.com>
2021-12-09 21:50:50 +00:00
test_path(ctx, sdc.get(), create_path_47(), SkMatrix(), GrAAType::kCoverage);
Tessellating GPU path renderer. This path renderer converts paths to linear contours, resolves intersections via Bentley-Ottman, implements a trapezoidal decomposition a la Fournier and Montuno to produce triangles, and renders those with a single draw call. It does not currently do antialiasing, so it must be used in conjunction with multisampling. A fair amount of the code is to handle floating point edge cases in intersections. Rather than perform exact computations (which would require arbitrary precision arithmetic), we reconnect the mesh to reflect the intersection points. For example, intersections can occur above the current vertex, and force edges to be merged into the current vertex, requiring a restart of the intersections. Splitting edges for intersections can also force them to merge with formerly-distinct edges in the same polygon, or to violate the ordering of the active edge list, or the active edge state of split edges. BUG=skia: Review URL: https://codereview.chromium.org/855513004
2015-02-26 14:58:17 +00:00
}
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
Change architecture #defines to be SK_GPU_V1 and SK_GPU_V2 A strictly mechanical CL Bug: skia:11837 Change-Id: Id794d1fefe261d685b19e5d4d599cdab5e021cf7 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/424038 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-07-01 17:21:37 +00:00
#endif // SK_GPU_V1
Make GrPathRenderer and all derived class be OGA-only Bug: skia:11837 Change-Id: I92aacf8b412d0158036a5f27aa767590e426bd5c Reviewed-on: https://skia-review.googlesource.com/c/skia/+/417657 Reviewed-by: Michael Ludwig <michaelludwig@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-06-16 16:05:54 +00:00
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
namespace {
class SimpleVertexAllocator : public GrEagerVertexAllocator {
public:
void* lock(size_t stride, int eagerCount) override {
SkASSERT(!fPoints);
SkASSERT(stride == sizeof(SkPoint));
fPoints.reset(eagerCount);
return fPoints;
}
void unlock(int actualCount) override {}
SkPoint operator[](int idx) const { return fPoints[idx]; }
SkAutoTMalloc<SkPoint> fPoints;
};
Allow the Triangulator to fail Bug: 1262444 Change-Id: I951c1809c031c1c8e71d8c3ce1be3506bbfa3d2c Reviewed-on: https://skia-review.googlesource.com/c/skia/+/469904 Reviewed-by: Chris Dalton <csmartdalton@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-11-18 16:54:02 +00:00
class SimplerVertexAllocator : public GrEagerVertexAllocator {
public:
void* lock(size_t stride, int eagerCount) override {
size_t allocSize = eagerCount * stride;
if (allocSize > fVertexAllocSize) {
fVertexData.reset(allocSize);
}
return fVertexData;
}
void unlock(int) override {}
SkAutoTMalloc<char> fVertexData;
size_t fVertexAllocSize = 0;
};
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
} // namespace
struct Edge {
Edge reverse() const { return {fP1, fP0}; }
SkPoint fP0, fP1;
};
static bool operator<(const Edge& a, const Edge& b) {
if (a.fP0.fX != b.fP0.fX) {
return a.fP0.fX < b.fP0.fX;
}
if (a.fP0.fY != b.fP0.fY) {
return a.fP0.fY < b.fP0.fY;
}
if (a.fP1.fX != b.fP1.fX) {
return a.fP1.fX < b.fP1.fX;
}
if (a.fP1.fY != b.fP1.fY) {
return a.fP1.fY < b.fP1.fY;
}
return false;
}
using EdgeMap = std::map<Edge, int>;
static void add_edge(EdgeMap& edgeMap, SkPoint p0, SkPoint p1) {
Edge edge{p0, p1};
// First check if this edge already exists in reverse.
auto reverseIter = edgeMap.find(edge.reverse());
if (reverseIter != edgeMap.end()) {
--reverseIter->second;
} else {
++edgeMap[edge];
}
}
static void add_tri_edges(skiatest::Reporter* r, EdgeMap& edgeMap, const SkPoint pts[3]) {
for (int i = 0; i < 3; ++i) {
SkPoint p0=pts[i], p1=pts[(i+1)%3];
// The triangulator shouldn't output degenerate triangles.
REPORTER_ASSERT(r, p0 != p1);
add_edge(edgeMap, p0, p1);
}
}
static EdgeMap simplify(const EdgeMap& edges, SkPathFillType fillType) {
// Prune out the edges whose count went to zero, and reverse the edges whose count is negative.
EdgeMap simplifiedEdges;
for (auto [edge, count] : edges) {
// We should only have one ordering of any given edge.
SkASSERT(edges.find(edge.reverse()) == edges.end());
if (fillType == SkPathFillType::kEvenOdd) {
count = abs(count) & 1;
}
if (count > 0) {
simplifiedEdges[edge] = count;
} else if (count < 0) {
simplifiedEdges[edge.reverse()] = -count;
}
}
return simplifiedEdges;
}
static void verify_simple_inner_polygons(skiatest::Reporter* r, const char* shapeName,
SkPath path) {
for (auto fillType : {SkPathFillType::kWinding}) {
path.setFillType(fillType);
Make GrTriangulator immutable Marks its methods const and lifts the breadcrumb list out into function arguments. This is one more step toward the final vision where GrTriangulator just has an allocator and control knobs, and everything else is functional. Bug: skia:10419 Change-Id: I77341c045d481da49ebfee06de5dfc7a2a8a07be Reviewed-on: https://skia-review.googlesource.com/c/skia/+/360956 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-28 01:24:48 +00:00
SkArenaAlloc arena(GrTriangulator::kArenaDefaultChunkSize);
GrInnerFanTriangulator::BreadcrumbTriangleList breadcrumbs;
Update GrInnerFanTriangulator to use an existing SkArenaAlloc For the tessellation op this allows it to use either the record-time or flush-time allocator instead of making its own. Bug: skia:10419 Change-Id: Ida13283feffda1976bd8fd221d5be0013a5de990 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/356516 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-22 05:09:26 +00:00
SimpleVertexAllocator vertexAlloc;
int vertexCount;
{
bool isLinear;
Make GrTriangulator immutable Marks its methods const and lifts the breadcrumb list out into function arguments. This is one more step toward the final vision where GrTriangulator just has an allocator and control knobs, and everything else is functional. Bug: skia:10419 Change-Id: I77341c045d481da49ebfee06de5dfc7a2a8a07be Reviewed-on: https://skia-review.googlesource.com/c/skia/+/360956 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-28 01:24:48 +00:00
GrInnerFanTriangulator triangulator(path, &arena);
vertexCount = triangulator.pathToTriangles(&vertexAlloc, &breadcrumbs, &isLinear);
Update GrInnerFanTriangulator to use an existing SkArenaAlloc For the tessellation op this allows it to use either the record-time or flush-time allocator instead of making its own. Bug: skia:10419 Change-Id: Ida13283feffda1976bd8fd221d5be0013a5de990 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/356516 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-22 05:09:26 +00:00
}
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// Count up all the triangulated edges.
EdgeMap trianglePlusBreadcrumbEdges;
Update GrInnerFanTriangulator to use an existing SkArenaAlloc For the tessellation op this allows it to use either the record-time or flush-time allocator instead of making its own. Bug: skia:10419 Change-Id: Ida13283feffda1976bd8fd221d5be0013a5de990 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/356516 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-22 05:09:26 +00:00
for (int i = 0; i < vertexCount; i += 3) {
add_tri_edges(r, trianglePlusBreadcrumbEdges, vertexAlloc.fPoints.data() + i);
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
}
// Count up all the breadcrumb edges.
Make GrTriangulator immutable Marks its methods const and lifts the breadcrumb list out into function arguments. This is one more step toward the final vision where GrTriangulator just has an allocator and control knobs, and everything else is functional. Bug: skia:10419 Change-Id: I77341c045d481da49ebfee06de5dfc7a2a8a07be Reviewed-on: https://skia-review.googlesource.com/c/skia/+/360956 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-28 01:24:48 +00:00
int breadcrumbCount = 0;
for (const auto* node = breadcrumbs.head(); node; node = node->fNext) {
add_tri_edges(r, trianglePlusBreadcrumbEdges, node->fPts);
++breadcrumbCount;
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
}
Make GrTriangulator immutable Marks its methods const and lifts the breadcrumb list out into function arguments. This is one more step toward the final vision where GrTriangulator just has an allocator and control knobs, and everything else is functional. Bug: skia:10419 Change-Id: I77341c045d481da49ebfee06de5dfc7a2a8a07be Reviewed-on: https://skia-review.googlesource.com/c/skia/+/360956 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-28 01:24:48 +00:00
REPORTER_ASSERT(r, breadcrumbCount == breadcrumbs.count());
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// The triangulated + breadcrumb edges should cancel out to the inner polygon edges.
trianglePlusBreadcrumbEdges = simplify(trianglePlusBreadcrumbEdges, path.getFillType());
// Build the inner polygon edges.
Remove the offthread triangulation from GrPathTessellateOp Rather than copying these triangles twice, we can run "pathToPolys" during onPrePrepare and "polysToTriangles" during onPrepare. Also adds a benchmark for normal and inner-fan triangulation. Bug: skia:10419 Change-Id: Id301afde5de11d93ae026e75e42ac03a50867687 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/355177 Commit-Queue: Chris Dalton <csmartdalton@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
2021-01-22 01:31:28 +00:00
EdgeMap innerFanEdges;
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
SkPoint startPoint{}, lastPoint{};
for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
switch (verb) {
case SkPathVerb::kMove:
if (lastPoint != startPoint) {
Remove the offthread triangulation from GrPathTessellateOp Rather than copying these triangles twice, we can run "pathToPolys" during onPrePrepare and "polysToTriangles" during onPrepare. Also adds a benchmark for normal and inner-fan triangulation. Bug: skia:10419 Change-Id: Id301afde5de11d93ae026e75e42ac03a50867687 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/355177 Commit-Queue: Chris Dalton <csmartdalton@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
2021-01-22 01:31:28 +00:00
add_edge(innerFanEdges, lastPoint, startPoint);
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
}
lastPoint = startPoint = pts[0];
continue;
case SkPathVerb::kClose:
lastPoint = startPoint;
break;
case SkPathVerb::kLine:
lastPoint = pts[1];
break;
case SkPathVerb::kQuad:
case SkPathVerb::kConic:
lastPoint = pts[2];
break;
case SkPathVerb::kCubic:
lastPoint = pts[3];
break;
}
if (pts[0] != lastPoint) {
Remove the offthread triangulation from GrPathTessellateOp Rather than copying these triangles twice, we can run "pathToPolys" during onPrePrepare and "polysToTriangles" during onPrepare. Also adds a benchmark for normal and inner-fan triangulation. Bug: skia:10419 Change-Id: Id301afde5de11d93ae026e75e42ac03a50867687 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/355177 Commit-Queue: Chris Dalton <csmartdalton@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
2021-01-22 01:31:28 +00:00
add_edge(innerFanEdges, pts[0], lastPoint);
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
}
}
if (lastPoint != startPoint) {
Remove the offthread triangulation from GrPathTessellateOp Rather than copying these triangles twice, we can run "pathToPolys" during onPrePrepare and "polysToTriangles" during onPrepare. Also adds a benchmark for normal and inner-fan triangulation. Bug: skia:10419 Change-Id: Id301afde5de11d93ae026e75e42ac03a50867687 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/355177 Commit-Queue: Chris Dalton <csmartdalton@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
2021-01-22 01:31:28 +00:00
add_edge(innerFanEdges, lastPoint, startPoint);
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
}
Remove the offthread triangulation from GrPathTessellateOp Rather than copying these triangles twice, we can run "pathToPolys" during onPrePrepare and "polysToTriangles" during onPrepare. Also adds a benchmark for normal and inner-fan triangulation. Bug: skia:10419 Change-Id: Id301afde5de11d93ae026e75e42ac03a50867687 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/355177 Commit-Queue: Chris Dalton <csmartdalton@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
2021-01-22 01:31:28 +00:00
innerFanEdges = simplify(innerFanEdges, path.getFillType());
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
// The triangulated + breadcrumb edges should cancel out to the inner polygon edges. First
// verify that every inner polygon edge can be found in the triangulation.
Remove the offthread triangulation from GrPathTessellateOp Rather than copying these triangles twice, we can run "pathToPolys" during onPrePrepare and "polysToTriangles" during onPrepare. Also adds a benchmark for normal and inner-fan triangulation. Bug: skia:10419 Change-Id: Id301afde5de11d93ae026e75e42ac03a50867687 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/355177 Commit-Queue: Chris Dalton <csmartdalton@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
2021-01-22 01:31:28 +00:00
for (auto [edge, count] : innerFanEdges) {
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
auto it = trianglePlusBreadcrumbEdges.find(edge);
if (it != trianglePlusBreadcrumbEdges.end()) {
it->second -= count;
if (it->second == 0) {
trianglePlusBreadcrumbEdges.erase(it);
}
continue;
}
it = trianglePlusBreadcrumbEdges.find(edge.reverse());
if (it != trianglePlusBreadcrumbEdges.end()) {
it->second += count;
if (it->second == 0) {
trianglePlusBreadcrumbEdges.erase(it);
}
continue;
}
ERRORF(r, "error: %s: edge [%g,%g]:[%g,%g] not found in triangulation.",
shapeName, edge.fP0.fX, edge.fP0.fY, edge.fP1.fX, edge.fP1.fY);
return;
}
// Now verify that there are no spurious edges in the triangulation.
//
// NOTE: The triangulator's definition of wind isn't always correct for edges that run
// exactly parallel to the sweep (either vertical or horizontal edges). This doesn't
// actually matter though because T-junction artifacts don't happen on axis-aligned edges.
// Tolerate spurious edges that (1) come in pairs of 2, and (2) are either exactly
// horizontal or exactly vertical exclusively.
bool hasSpuriousHorz=false, hasSpuriousVert=false;
for (auto [edge, count] : trianglePlusBreadcrumbEdges) {
if (count % 2 == 0) {
if (edge.fP0.fX == edge.fP1.fX && !hasSpuriousVert) {
hasSpuriousHorz = true;
continue;
}
if (edge.fP0.fY == edge.fP1.fY && !hasSpuriousHorz) {
hasSpuriousVert = true;
continue;
}
}
ERRORF(r, "error: %s: spurious edge [%g,%g]:[%g,%g] found in triangulation.",
shapeName, edge.fP0.fX, edge.fP0.fY, edge.fP1.fX, edge.fP1.fY);
return;
}
}
}
Remove the offthread triangulation from GrPathTessellateOp Rather than copying these triangles twice, we can run "pathToPolys" during onPrePrepare and "polysToTriangles" during onPrepare. Also adds a benchmark for normal and inner-fan triangulation. Bug: skia:10419 Change-Id: Id301afde5de11d93ae026e75e42ac03a50867687 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/355177 Commit-Queue: Chris Dalton <csmartdalton@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
2021-01-22 01:31:28 +00:00
DEF_TEST(GrInnerFanTriangulator, r) {
Add GrTriangulator::TriangulateInnerPolygons Unlike TriangulateSimpleInnerPolygons, this new method *always* succeeds. It works by introducing a concept of "breadcrumb" triangles. The breadcrumb triangles serve as a glue that erases T-junctions between the outer curves and inner polygon triangulation. This CL also introduces a test to verify the breadcrumb triangles actually guarantee to eliminate T-junctions. It works by cancelling out shared edges in the combined breadcrumb triangles and inner triangulation, and then verifying that the resulting edge list is bit-for-bit identical to the outer edges from the original polygon(s). Bug: skia:10419 Change-Id: Iea8ee2ca3701697246309dceb90e63279aabdfe4 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/353536 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2021-01-14 17:48:02 +00:00
verify_simple_inner_polygons(r, "simple triangle", SkPath().lineTo(1,0).lineTo(0,1));
verify_simple_inner_polygons(r, "simple square", SkPath().lineTo(1,0).lineTo(1,1).lineTo(0,1));
verify_simple_inner_polygons(r, "concave polygon", SkPath()
.lineTo(1,0).lineTo(.5f,.5f).lineTo(1,1).lineTo(0,1));
verify_simple_inner_polygons(r, "double wound triangle", SkPath()
.lineTo(1,0).lineTo(0,1).lineTo(0,0).lineTo(1,0).lineTo(0,1));
verify_simple_inner_polygons(r, "self-intersecting bowtie", SkPath()
.lineTo(1,0).lineTo(0,1).lineTo(1,1));
verify_simple_inner_polygons(r, "asymmetrical bowtie", SkPath()
.lineTo(1,0).lineTo(0,1).lineTo(.1f,-.1f));
verify_simple_inner_polygons(r, "bowtie with extremely small section", SkPath()
.lineTo(1,0).lineTo(0,1).lineTo(1e-6f,-1e-6f));
verify_simple_inner_polygons(r, "intersecting squares", SkPath()
.lineTo(1,0).lineTo(1,1).lineTo(0,1)
.moveTo(.5f,.5f).lineTo(1.5f,.5f).lineTo(1.5f,1.5f).lineTo(.5f,1.5f).close());
verify_simple_inner_polygons(r, "6-point \"Star of David\"", SkPath()
.moveTo(cosf(-SK_ScalarPI/3), sinf(-SK_ScalarPI/3))
.lineTo(cosf(SK_ScalarPI/3), sinf(SK_ScalarPI/3))
.lineTo(cosf(SK_ScalarPI), sinf(SK_ScalarPI))
.moveTo(cosf(0), sinf(0))
.lineTo(cosf(2*SK_ScalarPI/3), sinf(2*SK_ScalarPI/3))
.lineTo(cosf(-2*SK_ScalarPI/3), sinf(-2*SK_ScalarPI/3)));
verify_simple_inner_polygons(r, "double wound \"Star of David\"", SkPath()
.moveTo(cosf(-SK_ScalarPI/3), sinf(-SK_ScalarPI/3))
.lineTo(cosf(SK_ScalarPI/3), sinf(SK_ScalarPI/3))
.lineTo(cosf(SK_ScalarPI), sinf(SK_ScalarPI))
.lineTo(cosf(-SK_ScalarPI/3), sinf(-SK_ScalarPI/3))
.lineTo(cosf(SK_ScalarPI/3), sinf(SK_ScalarPI/3))
.lineTo(cosf(SK_ScalarPI), sinf(SK_ScalarPI))
.moveTo(cosf(0), sinf(0))
.lineTo(cosf(2*SK_ScalarPI/3), sinf(2*SK_ScalarPI/3))
.lineTo(cosf(-2*SK_ScalarPI/3), sinf(-2*SK_ScalarPI/3)));
verify_simple_inner_polygons(r, "5-point star", ToolUtils::make_star(SkRect::MakeWH(100, 200)));
verify_simple_inner_polygons(r, "\"pointy\" intersecting triangles", SkPath()
.moveTo(0,-100).lineTo(-1e-6f,100).lineTo(1e-6f,100)
.moveTo(-100,0).lineTo(100,1e-6f).lineTo(100,-1e-6f));
verify_simple_inner_polygons(r, "overlapping rects with vertical collinear edges", SkPath()
.moveTo(0,0).lineTo(0,2).lineTo(1,2).lineTo(1,0)
.moveTo(0,1).lineTo(0,3).lineTo(1,3).lineTo(1,1));
verify_simple_inner_polygons(r, "overlapping rects with horizontal collinear edges", SkPath()
.lineTo(2,0).lineTo(2,1).lineTo(0,1)
.moveTo(1,0).lineTo(3,0).lineTo(3,1).lineTo(1,1).close());
for (int i = 0; i < (int)SK_ARRAY_COUNT(kNonEdgeAAPaths); ++i) {
verify_simple_inner_polygons(r, SkStringPrintf("kNonEdgeAAPaths[%i]", i).c_str(),
kNonEdgeAAPaths[i]());
}
SkRandom rand;
for (int i = 0; i < 50; ++i) {
auto randomPath = SkPath().moveTo(rand.nextF(), rand.nextF());
for (int j = 0; j < i; ++j) {
randomPath.lineTo(rand.nextF(), rand.nextF());
}
verify_simple_inner_polygons(r, SkStringPrintf("random_path_%i", i).c_str(), randomPath);
}
}
Allow the Triangulator to fail Bug: 1262444 Change-Id: I951c1809c031c1c8e71d8c3ce1be3506bbfa3d2c Reviewed-on: https://skia-review.googlesource.com/c/skia/+/469904 Reviewed-by: Chris Dalton <csmartdalton@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2021-11-18 16:54:02 +00:00
static void test_crbug_1262444(skiatest::Reporter* r) {
SkPath path;
path.setFillType(SkPathFillType::kWinding);
path.moveTo(SkBits2Float(0x3fe0633f), SkBits2Float(0x3d04a60d)); // 1.75303f, 0.0323849f
path.cubicTo(SkBits2Float(0x3fe27540), SkBits2Float(0x3dff593f), SkBits2Float(0x3fe45241),
SkBits2Float(0x3e5e2fbb), SkBits2Float(0x3fe55b41), SkBits2Float(
0x3e9e596d)); // 1.7692f, 0.124682f, 1.78376f, 0.216979f, 1.79185f, 0.309276f
path.cubicTo(SkBits2Float(0x3fe5fa41), SkBits2Float(0x3eb3e79c), SkBits2Float(0x3fe62f41),
SkBits2Float(0x3ec975cb), SkBits2Float(0x3fe69941), SkBits2Float(
0x3edfd837)); // 1.7967f, 0.351376f, 1.79832f, 0.393477f, 1.80155f, 0.437196f
path.cubicTo(SkBits2Float(0x3fe70341), SkBits2Float(0x3f064e87), SkBits2Float(0x3fe6ce41),
SkBits2Float(0x3f1cb0f2), SkBits2Float(0x3fe59041), SkBits2Float(
0x3f33135e)); // 1.80479f, 0.524636f, 1.80317f, 0.612075f, 1.79346f, 0.699514f
path.cubicTo(SkBits2Float(0x3fe48740), SkBits2Float(0x3f468ef5), SkBits2Float(0x3fe2df40),
SkBits2Float(0x3f59a06d), SkBits2Float(0x3fe02e3f), SkBits2Float(
0x3f6cb1e6)); // 1.78538f, 0.775619f, 1.77244f, 0.850104f, 1.75141f, 0.92459f
path.cubicTo(SkBits2Float(0x3fde863f), SkBits2Float(0x3f78b759), SkBits2Float(0x3fdc743e),
SkBits2Float(0x3f822957), SkBits2Float(0x3fd9c33e), SkBits2Float(
0x3f87f701)); // 1.73847f, 0.971548f, 1.7223f, 1.01689f, 1.70127f, 1.06223f
path.cubicTo(SkBits2Float(0x3fd98e3e), SkBits2Float(0x3f88611f), SkBits2Float(0x3fd9593e),
SkBits2Float(0x3f88cb3e), SkBits2Float(0x3fd9243d), SkBits2Float(
0x3f896a6b)); // 1.69965f, 1.06546f, 1.69804f, 1.0687f, 1.69642f, 1.07356f
path.cubicTo(SkBits2Float(0x3fd63e3c), SkBits2Float(0x3f8fa234), SkBits2Float(0x3fd2ee3b),
SkBits2Float(0x3f95d9fd), SkBits2Float(0x3fd2ee3b), SkBits2Float(
0x3f9ce602)); // 1.67377f, 1.12214f, 1.6479f, 1.17071f, 1.6479f, 1.22577f
path.cubicTo(SkBits2Float(0x3fd3233b), SkBits2Float(0x3f9cb0f3), SkBits2Float(0x3fd3583b),
SkBits2Float(0x3f9cb0f3), SkBits2Float(0x3fd3c23c), SkBits2Float(
0x3f9c7be4)); // 1.64951f, 1.22415f, 1.65113f, 1.22415f, 1.65437f, 1.22253f
path.cubicTo(SkBits2Float(0x3fd3c23c), SkBits2Float(0x3f9cb0f3), SkBits2Float(0x3fd3c23c),
SkBits2Float(0x3f9cb0f3), SkBits2Float(0x3fd3c23c), SkBits2Float(
0x3f9ce602)); // 1.65437f, 1.22415f, 1.65437f, 1.22415f, 1.65437f, 1.22577f
path.cubicTo(SkBits2Float(0x3fd5353c), SkBits2Float(0x3f9c46d4), SkBits2Float(0x3fd6dd3d),
SkBits2Float(0x3f9bdcb6), SkBits2Float(0x3fd7b13d), SkBits2Float(
0x3f9ad36a)); // 1.66569f, 1.22091f, 1.67863f, 1.21767f, 1.6851f, 1.20958f
path.cubicTo(SkBits2Float(0x3fda623e), SkBits2Float(0x3f96ae3a), SkBits2Float(0x3fdca93f),
SkBits2Float(0x3f921eeb), SkBits2Float(0x3fdf253f), SkBits2Float(
0x3f8dc4ab)); // 1.70612f, 1.17719f, 1.72391f, 1.14157f, 1.74332f, 1.10756f
path.cubicTo(SkBits2Float(0x3fe0983f), SkBits2Float(0x3f8b12e5), SkBits2Float(0x3fe1d640),
SkBits2Float(0x3f87f700), SkBits2Float(0x3fe3b340), SkBits2Float(
0x3f857a4a)); // 1.75465f, 1.08651f, 1.76435f, 1.06223f, 1.77891f, 1.04279f
path.cubicTo(SkBits2Float(0x3fe48740), SkBits2Float(0x3f8470fe), SkBits2Float(0x3fe62f40),
SkBits2Float(0x3f8470fe), SkBits2Float(0x3fe7d741), SkBits2Float(
0x3f843bef)); // 1.78538f, 1.0347f, 1.79832f, 1.0347f, 1.81126f, 1.03308f
path.cubicTo(SkBits2Float(0x3fe2aa40), SkBits2Float(0x3f943182), SkBits2Float(0x3fda623d),
SkBits2Float(0x3fa2498e), SkBits2Float(0x3fceff3a), SkBits2Float(
0x3fae4f01)); // 1.77082f, 1.15776f, 1.70612f, 1.26787f, 1.61716f, 1.36179f
path.cubicTo(SkBits2Float(0x3fce6039), SkBits2Float(0x3faf233e), SkBits2Float(0x3fcd2239),
SkBits2Float(0x3faf584d), SkBits2Float(0x3fcc1939), SkBits2Float(
0x3fafc26b)); // 1.61231f, 1.36826f, 1.60261f, 1.36988f, 1.59452f, 1.37312f
path.cubicTo(SkBits2Float(0x3fcc1939), SkBits2Float(0x3faff77a), SkBits2Float(0x3fcc1939),
SkBits2Float(0x3faff77a), SkBits2Float(0x3fcc4e39), SkBits2Float(
0x3fb02c89)); // 1.59452f, 1.37474f, 1.59452f, 1.37474f, 1.59614f, 1.37636f
path.cubicTo(SkBits2Float(0x3fcc1939), SkBits2Float(0x3fb02c89), SkBits2Float(0x3fcc1939),
SkBits2Float(0x3fb02c89), SkBits2Float(0x3fcbe439), SkBits2Float(
0x3fb02c89)); // 1.59452f, 1.37636f, 1.59452f, 1.37636f, 1.5929f, 1.37636f
path.cubicTo(SkBits2Float(0x3fcbe439), SkBits2Float(0x3fb20a12), SkBits2Float(0x3fcb4539),
SkBits2Float(0x3fb37d7d), SkBits2Float(0x3fc99d39), SkBits2Float(
0x3fb3b28c)); // 1.5929f, 1.39093f, 1.58805f, 1.40227f, 1.57511f, 1.40389f
path.cubicTo(SkBits2Float(0x3fc93339), SkBits2Float(0x3fb3e79b), SkBits2Float(0x3fc8c938),
SkBits2Float(0x3fb41caa), SkBits2Float(0x3fc7f538), SkBits2Float(
0x3fb41caa)); // 1.57188f, 1.40551f, 1.56864f, 1.40712f, 1.56217f, 1.40712f
path.cubicTo(SkBits2Float(0x3fc7f538), SkBits2Float(0x3fb3e79b), SkBits2Float(0x3fc7f538),
SkBits2Float(0x3fb3e79b), SkBits2Float(0x3fc7f538), SkBits2Float(
0x3fb3b28c)); // 1.56217f, 1.40551f, 1.56217f, 1.40551f, 1.56217f, 1.40389f
path.lineTo(SkBits2Float(0x3fc7c038), SkBits2Float(0x3fb3b28c)); // 1.56055f, 1.40389f
path.cubicTo(SkBits2Float(0x3fc7c038), SkBits2Float(0x3fb4f0e7), SkBits2Float(0x3fc7f538),
SkBits2Float(0x3fb66452), SkBits2Float(0x3fc78b38), SkBits2Float(
0x3fb76d9e)); // 1.56055f, 1.4136f, 1.56217f, 1.42494f, 1.55894f, 1.43303f
path.cubicTo(SkBits2Float(0x3fc3d137), SkBits2Float(0x3fbe4495), SkBits2Float(0x3fbf4336),
SkBits2Float(0x3fc4123e), SkBits2Float(0x3fb80434), SkBits2Float(
0x3fc76331)); // 1.52982f, 1.48647f, 1.49424f, 1.53181f, 1.43763f, 1.55771f
path.cubicTo(SkBits2Float(0x3fb47f33), SkBits2Float(0x3fc90bac), SkBits2Float(0x3fb19932),
SkBits2Float(0x3fcb5353), SkBits2Float(0x3faf1d31), SkBits2Float(
0x3fce6f37)); // 1.41013f, 1.57067f, 1.38749f, 1.58848f, 1.36808f, 1.61277f
path.cubicTo(SkBits2Float(0x3fa4592e), SkBits2Float(0x3fdb13d7), SkBits2Float(0x3f974e2a),
SkBits2Float(0x3fe53bc1), SkBits2Float(0x3f896f25), SkBits2Float(
0x3fee5a5f)); // 1.28397f, 1.71154f, 1.18207f, 1.79089f, 1.0737f, 1.86213f
path.cubicTo(SkBits2Float(0x3f6b883f), SkBits2Float(0x3ffb691f), SkBits2Float(0x3f42f434),
SkBits2Float(0x400367b2), SkBits2Float(0x3f184e28), SkBits2Float(
0x4008611f)); // 0.920048f, 1.96415f, 0.761539f, 2.0532f, 0.594943f, 2.13093f
path.cubicTo(SkBits2Float(0x3f184e28), SkBits2Float(0x4008611f), SkBits2Float(0x3f17e428),
SkBits2Float(0x4008611f), SkBits2Float(0x3f17e428), SkBits2Float(
0x40087ba7)); // 0.594943f, 2.13093f, 0.593325f, 2.13093f, 0.593325f, 2.13255f
path.cubicTo(SkBits2Float(0x3effc044), SkBits2Float(0x400b47f5), SkBits2Float(0x3ed08c36),
SkBits2Float(0x400e2eca), SkBits2Float(0x3e9edc28), SkBits2Float(
0x401090f9)); // 0.499514f, 2.17627f, 0.40732f, 2.22161f, 0.310273f, 2.25885f
path.cubicTo(SkBits2Float(0x3e5a5832), SkBits2Float(0x4012f328), SkBits2Float(0x3de40030),
SkBits2Float(0x4014811a), SkBits2Float(0x3c1a7f9e), SkBits2Float(
0x40158a66)); // 0.213227f, 2.29609f, 0.111328f, 2.32038f, 0.00942984f, 2.33657f
path.lineTo(SkBits2Float(0x3c1a7f9e), SkBits2Float(0x401bf73d)); // 0.00942984f, 2.43697f
path.cubicTo(SkBits2Float(0x3dc98028), SkBits2Float(0x401b580f), SkBits2Float(0x3e3fd82e),
SkBits2Float(0x401a694b), SkBits2Float(0x3e8ca424), SkBits2Float(
0x40191068)); // 0.098389f, 2.42725f, 0.187348f, 2.41268f, 0.27469f, 2.39163f
path.cubicTo(SkBits2Float(0x3e94ec27), SkBits2Float(0x4018db59), SkBits2Float(0x3e9d3429),
SkBits2Float(0x40188bc2), SkBits2Float(0x3ea4a82b), SkBits2Float(
0x401856b3)); // 0.290864f, 2.38839f, 0.307039f, 2.38353f, 0.321596f, 2.38029f
path.cubicTo(SkBits2Float(0x3eae982e), SkBits2Float(0x4018071c), SkBits2Float(0x3eb95c31),
SkBits2Float(0x40179cfe), SkBits2Float(0x3ec34c34), SkBits2Float(
0x40174d67)); // 0.341005f, 2.37543f, 0.362031f, 2.36896f, 0.381441f, 2.3641f
path.cubicTo(SkBits2Float(0x3ec9ec36), SkBits2Float(0x40171858), SkBits2Float(0x3ed08c38),
SkBits2Float(0x4016c8c1), SkBits2Float(0x3ed8003a), SkBits2Float(
0x401693b2)); // 0.39438f, 2.36086f, 0.40732f, 2.356f, 0.421877f, 2.35276f
path.cubicTo(SkBits2Float(0x3eda7c3a), SkBits2Float(0x4016792a), SkBits2Float(0x3eddcc3c),
SkBits2Float(0x40165ea3), SkBits2Float(0x3ee0483c), SkBits2Float(
0x4016441b)); // 0.426729f, 2.35115f, 0.433199f, 2.34953f, 0.438051f, 2.34791f
path.cubicTo(SkBits2Float(0x3ee2c43d), SkBits2Float(0x40162993), SkBits2Float(0x3ee5403e),
SkBits2Float(0x40160f0c), SkBits2Float(0x3ee8903f), SkBits2Float(
0x4015f484)); // 0.442903f, 2.34629f, 0.447756f, 2.34467f, 0.454226f, 2.34305f
path.cubicTo(SkBits2Float(0x3f1c082a), SkBits2Float(0x4012be17), SkBits2Float(0x3f422036),
SkBits2Float(0x400e63d8), SkBits2Float(0x3f66fa40), SkBits2Float(
0x40096a6a)); // 0.6095f, 2.29285f, 0.758304f, 2.22484f, 0.902256f, 2.14712f
path.cubicTo(SkBits2Float(0x3f6a4a41), SkBits2Float(0x4009004c), SkBits2Float(0x3f6d3042),
SkBits2Float(0x4008962d), SkBits2Float(0x3f708043), SkBits2Float(
0x40081187)); // 0.915196f, 2.14064f, 0.926518f, 2.13417f, 0.939457f, 2.12607f
path.cubicTo(SkBits2Float(0x3f7efe47), SkBits2Float(0x4005feef), SkBits2Float(0x3f868925),
SkBits2Float(0x4003b748), SkBits2Float(0x3f8d5e28), SkBits2Float(
0x40015519)); // 0.996067f, 2.09368f, 1.05106f, 2.05806f, 1.10444f, 2.02082f
path.cubicTo(SkBits2Float(0x3f97b82b), SkBits2Float(0x3ffb691d), SkBits2Float(0x3fa1a82e),
SkBits2Float(0x3ff388da), SkBits2Float(0x3fab9830), SkBits2Float(
0x3feb7389)); // 1.18531f, 1.96415f, 1.26294f, 1.90261f, 1.34058f, 1.83946f
path.cubicTo(SkBits2Float(0x3fb20332), SkBits2Float(0x3fe6450c), SkBits2Float(0x3fb80434),
SkBits2Float(0x3fe0e181), SkBits2Float(0x3fbd6635), SkBits2Float(
0x3fda3f99)); // 1.39072f, 1.79898f, 1.43763f, 1.75688f, 1.47968f, 1.70507f
path.cubicTo(SkBits2Float(0x3fbf4336), SkBits2Float(0x3fd7f7f2), SkBits2Float(0x3fc12037),
SkBits2Float(0x3fd5b04b), SkBits2Float(0x3fc2fd36), SkBits2Float(
0x3fd33394)); // 1.49424f, 1.68725f, 1.5088f, 1.66944f, 1.52335f, 1.65001f
path.cubicTo(SkBits2Float(0x3fc5e337), SkBits2Float(0x3fcf7881), SkBits2Float(0x3fc8c938),
SkBits2Float(0x3fcbbd70), SkBits2Float(0x3fcbaf38), SkBits2Float(
0x3fc8025d)); // 1.546f, 1.62086f, 1.56864f, 1.59172f, 1.59128f, 1.56257f
path.cubicTo(SkBits2Float(0x3fceff39), SkBits2Float(0x3fc3a81e), SkBits2Float(0x3fd2843b),
SkBits2Float(0x3fbf18cf), SkBits2Float(0x3fd5d43b), SkBits2Float(
0x3fbabe8f)); // 1.61716f, 1.52857f, 1.64466f, 1.49294f, 1.67054f, 1.45894f
path.cubicTo(SkBits2Float(0x3fd8503c), SkBits2Float(0x3fb7a2ab), SkBits2Float(0x3fda973d),
SkBits2Float(0x3fb486c7), SkBits2Float(0x3fdca93e), SkBits2Float(
0x3fb135d3)); // 1.68995f, 1.43465f, 1.70774f, 1.41036f, 1.72391f, 1.38446f
path.cubicTo(SkBits2Float(0x3fe5c541), SkBits2Float(0x3fa2b3aa), SkBits2Float(0x3feb5c42),
SkBits2Float(0x3f92be16), SkBits2Float(0x3ff15d44), SkBits2Float(
0x3f82c882)); // 1.79508f, 1.27111f, 1.83875f, 1.14643f, 1.88566f, 1.02174f
path.cubicTo(SkBits2Float(0x3ff1fc44), SkBits2Float(0x3f812008), SkBits2Float(0x3ff23144),
SkBits2Float(0x3f7e1adf), SkBits2Float(0x3ff29b44), SkBits2Float(
0x3f7a5fcc)); // 1.89051f, 1.00879f, 1.89213f, 0.992598f, 1.89536f, 0.978024f
path.cubicTo(SkBits2Float(0x3ff47845), SkBits2Float(0x3f5fd830), SkBits2Float(0x3ff65545),
SkBits2Float(0x3f455094), SkBits2Float(0x3ff6bf45), SkBits2Float(
0x3f2a5ed9)); // 1.90992f, 0.874393f, 1.92448f, 0.770761f, 1.92771f, 0.66551f
path.cubicTo(SkBits2Float(0x3ff33a44), SkBits2Float(0x3f0d5a87), SkBits2Float(0x3ff08943),
SkBits2Float(0x3edf03ee), SkBits2Float(0x3fee7743), SkBits2Float(
0x3ea352cf)); // 1.90022f, 0.552163f, 1.87919f, 0.435577f, 1.86301f, 0.318991f
path.cubicTo(SkBits2Float(0x3feccf42), SkBits2Float(0x3e5c872d), SkBits2Float(0x3feb9142),
SkBits2Float(0x3de4d179), SkBits2Float(0x3feaf242), SkBits2Float(
0x3c04a4ae)); // 1.85008f, 0.215359f, 1.84037f, 0.111728f, 1.83552f, 0.0080959f
path.lineTo(SkBits2Float(0x3fe02e3f), SkBits2Float(0x3c04a4ae)); // 1.75141f, 0.0080959f
path.cubicTo(SkBits2Float(0x3fdff93f), SkBits2Float(0x3c6ec47e), SkBits2Float(0x3fe02e3f),
SkBits2Float(0x3cb9b545), SkBits2Float(0x3fe0633f), SkBits2Float(
0x3d04a60d)); // 1.74979f, 0.0145732f, 1.75141f, 0.0226694f, 1.75303f, 0.0323849f
path.close();
path.moveTo(SkBits2Float(0x3fe97f42), SkBits2Float(0x3f7b9e2e)); // 1.8242f, 0.982882f
path.cubicTo(SkBits2Float(0x3fe91542), SkBits2Float(0x3f7eef21), SkBits2Float(0x3fe87642),
SkBits2Float(0x3f81551a), SkBits2Float(0x3fe7d741), SkBits2Float(
0x3f82fd94)); // 1.82096f, 0.995836f, 1.81611f, 1.01041f, 1.81126f, 1.02336f
path.cubicTo(SkBits2Float(0x3fe6ce41), SkBits2Float(0x3f81bf39), SkBits2Float(0x3fe66441),
SkBits2Float(0x3f8080dd), SkBits2Float(0x3fe66441), SkBits2Float(
0x3f7e1ae4)); // 1.80317f, 1.01365f, 1.79993f, 1.00393f, 1.79993f, 0.992598f
path.cubicTo(SkBits2Float(0x3fe66441), SkBits2Float(0x3f7c726a), SkBits2Float(0x3fe69941),
SkBits2Float(0x3f7b340e), SkBits2Float(0x3fe6ce41), SkBits2Float(
0x3f798b95)); // 1.79993f, 0.986121f, 1.80155f, 0.981263f, 1.80317f, 0.974786f
path.cubicTo(SkBits2Float(0x3fe70341), SkBits2Float(0x3f78b758), SkBits2Float(0x3fe76d41),
SkBits2Float(0x3f770edf), SkBits2Float(0x3fe7d741), SkBits2Float(
0x3f770edf)); // 1.80479f, 0.971548f, 1.80802f, 0.965071f, 1.81126f, 0.965071f
path.cubicTo(SkBits2Float(0x3fe84141), SkBits2Float(0x3f770edf), SkBits2Float(0x3fe8ab42),
SkBits2Float(0x3f770edf), SkBits2Float(0x3fe8e041), SkBits2Float(
0x3f7778fd)); // 1.81449f, 0.965071f, 1.81773f, 0.965071f, 1.81934f, 0.96669f
path.cubicTo(SkBits2Float(0x3fe97f42), SkBits2Float(0x3f77e31b), SkBits2Float(0x3fe9e942),
SkBits2Float(0x3f798b95), SkBits2Float(0x3fe97f42), SkBits2Float(
0x3f7b9e2e)); // 1.8242f, 0.968309f, 1.82743f, 0.974786f, 1.8242f, 0.982882f
path.close();
float kTol = 0.25f;
SkRect clipBounds = SkRect::MakeLTRB(0, 0, 14, 14);
SimplerVertexAllocator alloc;
int vertexCount = GrAATriangulator::PathToAATriangles(path, kTol, clipBounds, &alloc);
REPORTER_ASSERT(r, vertexCount == 0);
}
DEF_TEST(TriangulatorBugs, r) {
test_crbug_1262444(r);
}
Reference in New Issue Copy Permalink