AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
16033c9cc1
skia2/tests/TessellatingPathRendererTests.cpp

797 lines
34 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"
#include "include/effects/SkGradientShader.h"
#include "include/gpu/GrContext.h"
#include "src/gpu/GrClip.h"
#include "src/gpu/GrContextPriv.h"
#include "src/gpu/GrStyle.h"
#include "src/gpu/effects/GrPorterDuffXferProcessor.h"
Move GrPathUtils, GrRect, and GrShape into src/gpu/geometry/ Change-Id: I864d3c2452f3affdc744bf8b11ed3b3e37d6d922 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/216602 Commit-Queue: Michael Ludwig <michaelludwig@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
2019-06-03 20:46:19 +00:00
#include "src/gpu/geometry/GrShape.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/ops/GrTessellatingPathRenderer.h"
#include "src/shaders/SkShaderBase.h"
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.
*/
// 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()).
static SkPath create_path_0() {
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;
}
// Intersections which fall exactly on the current vertex, and require
// a restart of the intersection checking.
static SkPath create_path_1() {
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;
}
// Tests active edges which are removed by splitting.
static SkPath create_path_2() {
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;
}
// Collinear edges merged in set_top().
// Also, an intersection between left and right enclosing edges which
// falls above the current vertex.
static SkPath create_path_3() {
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;
}
// Tests active edges which are made inactive by set_top().
static SkPath create_path_4() {
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;
}
static SkPath create_path_5() {
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;
}
static SkPath create_path_6() {
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;
}
static SkPath create_path_7() {
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;
}
static SkPath create_path_8() {
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;
}
static SkPath create_path_9() {
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;
}
static SkPath create_path_10() {
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;
}
// A degenerate segments case, where both upper and lower segments of
// a split edge must remain active.
static SkPath create_path_11() {
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;
}
// Handle the case where edge.dist(edge.fTop) != 0.0.
static SkPath create_path_12() {
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;
}
// A degenerate segments case which exercises inactive edges being
// made active by splitting.
static SkPath create_path_13() {
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;
}
// Tests vertices which become "orphaned" (ie., no connected edges)
// after simplification.
static SkPath create_path_14() {
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
static SkPath create_path_15() {
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;
}
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
// Reduction of Nebraska-StateSeal.svg. Floating point error causes the
// same edge to be added to more than one poly on the same side.
static SkPath create_path_16() {
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;
}
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 for vertex coincident with enclosing edge. If a previously-enclosing edge coincides exactly with the current vertex, there are no two adjacent edges which enclose the vertex. Since find_enclosing_edges() ensures that the left enclosing edge is to the left of the vertex, the fix is to split the right enclosing edge on the current vertex and restart intersection tests. Bug: 716720 Change-Id: Id26c5b92a6d6139f348e99554638cded37e81a8e Reviewed-on: https://skia-review.googlesource.com/15261 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-05-03 20:00:38 +00:00
// A shape with a vertex collinear to the right hand edge.
// This messes up find_enclosing_edges.
static SkPath create_path_18() {
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;
}
GrTessellator: fix for three edges becoming collinear after splitting. In rare cases, a single edge can become collinear with two adjacent neighbour edges after it's split. The solution is to continue to merge until no collinear edges are found. BUG=722000 Change-Id: Ia5dd212b7acfb40ed1d6c74ebfa9e4a4746fe40a Reviewed-on: https://skia-review.googlesource.com/17963 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-05-25 18:47:11 +00:00
// 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
static SkPath create_path_19() {
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;
}
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: fix for collinear out-of-range intersections. Change 3b5a3fa8b1c11d4bd4499b040311f4c3553ebf8c introduced support for out-of-range intersections, which is necessary when the top and bottom vertices of an edge differ by only one ULP in the primary sort order and can't be split in-order. However, some out-of-range intersections produce edges which cancel each other out on splitting, in particular when the intersection is collinear with the newly-computed edge. This undoes the effect of the split. The tessellator then rewinds, re-detects the intersection, resplits, an infinite loop. The fix is to check for out-of-range intersections which are also collinear, and ignore them. This is ok, because these are not the cases we care about it change 3b5a3f above, which are never collinear. Bug: 753867 Change-Id: I590231e0e6f19c98f1ccf46cb7acc8a63ba35a9d Reviewed-on: https://skia-review.googlesource.com/34925 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-08-15 21:01:15 +00:00
// A path which contains out-of-range colinear intersections.
static SkPath create_path_23() {
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;
}
GrTessellator: when sanitizing contours, remove non-finite points. NaNs can't be correctly sorted. Don't run the unit test on VK backend, since it requires large (>64K bytes) vertex buffer uploads. Bug: 757650 Change-Id: I667693f135a090a5d9076bb7a2ec6879fc06d645 Reviewed-on: https://skia-review.googlesource.com/37484 Commit-Queue: Stephen White <senorblanco@chromium.org> Reviewed-by: Greg Daniel <egdaniel@google.com>
2017-08-23 17:56:07 +00:00
// A path which results in infs and nans when conics are converted to quads.
static SkPath create_path_24() {
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;
}
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
// A quad which generates a huge number of points (>2B) when uniformly
// linearized. This should not hang or OOM.
static SkPath create_path_29() {
SkPath path;
path.moveTo(10, 0);
path.lineTo(0, 0);
path.quadTo(10, 0, 0, 8315084722602508288);
return path;
}
Reland "GrTessellator: hang fix." This is a reland of 050c86768a2c24c62655f53ef9b685d40477eccb Original change's description: > GrTessellator: hang fix. > > Some edges are not coincident with their own endpoints (because floating > point). If this happens for an edge which is a right-enclosing-edge > during the Bentley-Ottman simplify() pass, we end up an infinite loop > attempting to split the edge, since the edge is never to the right of its > endpoint. > > The easiest fix is to simply remove the right-enclosing-edge splitting > code. This code was originally added before we had proper > active-edge-list rewinding, and should no longer be necessary. > > BUG=802896 > > Change-Id: Id9f2942b73f01152af8c0088e8c6b1389891d827 > Reviewed-on: https://skia-review.googlesource.com/116920 > Reviewed-by: Robert Phillips <robertphillips@google.com> > Commit-Queue: Stephen White <senorblanco@chromium.org> Bug: 802896 Change-Id: I3e48346a8a358ae7d481299a586003e817a519ca Reviewed-on: https://skia-review.googlesource.com/117121 Reviewed-by: Mike Klein <mtklein@chromium.org> Commit-Queue: Mike Klein <mtklein@chromium.org>
2018-03-28 18:41:22 +00:00
// A path which hangs during simplification. It produces an edge which is
// to the left of its own endpoints, which causes an infinte loop in the
// right-enclosing-edge splitting.
static SkPath create_path_30() {
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;
}
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: fix for zombie edge fuzzer crash. While splitting one edge, merge_collinear_edges() may in rare cases merge the other edge of the intersection out of existence. split_edge() then brings these dead edges partially back to life, leaving the mesh in an inconsistent state. The fix is to null out the top and bottom pointers of dead edges to mark them as dead, and only split living edges. Bug: skia:7911 Change-Id: I1c0b59581acfcd0b8191f2d129b33f7d0d1a2516 Reviewed-on: https://skia-review.googlesource.com/129181 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-05-18 15:49:21 +00:00
// Reduction from skbug.com/7911 that causes a crash due to splitting a
// zombie edge.
static SkPath create_path_32() {
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;
}
GrTessellator: fix crash on merging a dead edge. When merging coincident vertices, sometimes merging an edge will cause the next edge in the list to die. But since merge_vertices() retrieves the next edge before merging the current one, we then try to merge its lifeless corpse, bringing it back as a zombie. The fix is to leave dead edges, dead. This was revealed by ec79c39a770205910f0abd762de7e19a96c986ca, but was likely a real bug that was being mishandled before that. Bug: 844873 Bug: skia:7982 Change-Id: I752c45f7551df4278fa4cb4587e7ead48cd16a21 Reviewed-on: https://skia-review.googlesource.com/129524 Commit-Queue: Stephen White <senorblanco@chromium.org> Reviewed-by: Robert Phillips <robertphillips@google.com>
2018-05-22 15:51:32 +00:00
// From crbug.com/844873. Crashes trying to merge a zombie edge.
static SkPath create_path_33() {
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;
}
GrTessellator: fix for ping-pong split fuzzer hang. When support for out-of-range intersections was added in 3b5a3fa8b1c11d4bd4499b040311f4c3553ebf8c, it was intended to support splitting edges that are almost flat, where merging with the top or bottom vertex would cause visual artifacts. However, it triggers too often for other, non-nearly-flat cases, causing simplify() to loop infinitely. The fix is to support out-of-range intersections only if they differ by 1/2 machine epsilon. This also generalizes the out_of_range_and_collinear() check, so it was removed. Bug: 838978 Change-Id: I238f2b90e4b7ad647ecf072427ee38726e549581 Reviewed-on: https://skia-review.googlesource.com/130458 Reviewed-by: Stephen White <senorblanco@chromium.org>
2018-05-31 02:47:46 +00:00
// From crbug.com/844873. Hangs repeatedly splitting alternate vertices.
static SkPath create_path_34() {
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.
static SkPath create_path_35() {
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;
}
GrTessellator: yet another out-of-range splitting fix. It's actually possible for an intersection to be out-of-range on both the intersected edges (e.g., below both bottom points), because floating point. So we need to clamp against both edges. Bug: 846014 Change-Id: I9fe25a1fcd3b5242af7b1ee36b17f1e968aeb836 Reviewed-on: https://skia-review.googlesource.com/132323 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-06-05 22:45:07 +00:00
// Reduction from crbug.com/843135 where an intersection is found
// below the bottom of both intersected edges.
static SkPath create_path_36() {
SkPath path;
path.moveTo(-2791476679359332352, 2608107002026524672);
path.lineTo( 0, 11.95427703857421875);
path.lineTo(-2781824066779086848, 2599088532777598976);
path.lineTo( -7772.6875, 7274);
return path;
}
GrTessellator: catch missing intersections. Sometimes the intersection check will miss an intersection (because floating point). This can leave the active edge list in an invalid state, where an edge pair is incorrectly ordered. The fix is to test for edge crossings after testing for intersections, and split the edges manually. This extra check may result in a performance hit, so we'll have to watch the perf bots carefully. Bug: 843135 Change-Id: If50320413026be503cdb2d33e6c97f620e4d51a9 Reviewed-on: https://skia-review.googlesource.com/133400 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-06-08 16:18:22 +00:00
// Reduction from crbug.com/843135. Exercises a case where an intersection is missed.
// This causes bad ordering in the active edge list.
static SkPath create_path_37() {
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;
}
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: handle three consecutive collinear edges. In some cases, splitting may produce three consecutive edges which are collinear. The first one was being merged out, causing the third one to be missed. The fix is to switch the arguments to merge_edges_*, ensuring that the second parameter (the destination edge) is never merged out. Bug: 851409 Change-Id: I65be2e8222846c99f7bc8d17ea61ddead617cc31 Reviewed-on: https://skia-review.googlesource.com/138700 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-06-29 21:02:21 +00:00
// Reduction from crbug.com/851409. Exercises collinear last vertex.
GrTessellator: handle collinear final vertex. If the last vertex in a contour is collinear with its neighbours, remove it (this edge case was missing). Otherwise, the simplify step may try to split it indefinitely. Bug: 851409 Change-Id: I7efa4e616cdc1508a73c7a9f3de9d3f571569af8 Reviewed-on: https://skia-review.googlesource.com/138106 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-06-28 13:36:49 +00:00
static SkPath create_path_39() {
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;
}
GrTessellator: handle three consecutive collinear edges. In some cases, splitting may produce three consecutive edges which are collinear. The first one was being merged out, causing the third one to be missed. The fix is to switch the arguments to merge_edges_*, ensuring that the second parameter (the destination edge) is never merged out. Bug: 851409 Change-Id: I65be2e8222846c99f7bc8d17ea61ddead617cc31 Reviewed-on: https://skia-review.googlesource.com/138700 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-06-29 21:02:21 +00:00
// Another reduction from crbug.com/851409. Exercises two sequential collinear edges.
static SkPath create_path_40() {
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;
}
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: collinear edges during sanitize. When three collinear edges occur during the sanitize_contours() pass, their vertices may not yet have been discovered to be coincident. So we must do the vertex comparison by point, rather than by pointer. Bug: 860655 Change-Id: I89dc7526905bb5473206661348fee431371731a0 Reviewed-on: https://skia-review.googlesource.com/141523 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-07-16 17:31:16 +00:00
// Reduction from crbug.com/860655. Cause is three collinear edges discovered during
// sanitize_contours pass, before the vertices have been found coincident.
static SkPath create_path_42() {
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;
}
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;
}
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
static std::unique_ptr<GrFragmentProcessor> create_linear_gradient_processor(GrContext* ctx) {
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);
GrFPArgs args(ctx, &SkMatrix::I(), SkFilterQuality::kLow_SkFilterQuality, &colorInfo);
Reland of SkShaderBase Introduce a private base class (SkShaderBase), to hide implementation details from the public interface (SkShader). Change-Id: Ib1d76cde880bd51868b97408710f8bb38128e536 Reviewed-on: https://skia-review.googlesource.com/17925 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2017-05-25 14:38:07 +00:00
return as_SB(shader)->asFragmentProcessor(args);
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
}
Remove atlas creation from GrResourceProvider This is pulled out of: https://skia-review.googlesource.com/c/6680/ (Make SkImage_Gpu be deferred) and is only tangentially related to the goal of that CL. Change-Id: I6b6db4869597070f85ab3b9fea178fc88c104f87 Reviewed-on: https://skia-review.googlesource.com/9106 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2017-03-01 19:32:46 +00:00
static void test_path(GrContext* ctx,
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
GrRenderTargetContext* renderTargetContext,
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) {
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
GrTessellatingPathRenderer tess;
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
tess.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) {
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
paint.addColorFragmentProcessor(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
Convert GrClip to an abstract base class Converts GrClip to an abstract base class and adds a "GrFixedClip" implementation. GrFixedClip denotes a clip implemented with fixed- function hardware. GrFixedClip allows us to remove the stateful "fClipMode" member from GrClipMaskManager, and in the future will be able to nicely encapsulate window rectangles. After this change GrClipMaskManager is just a wrapper around GrDrawTarget. We may want to consider removing it altogether. BUG=skia: GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1971343002 Review-Url: https://codereview.chromium.org/1971343002
2016-05-13 17:25:00 +00:00
GrNoClip noClip;
Improve heuristics for when to use ccpr Gives the convex and tessellating renderers first claim on larger paths, and the distance field renderer first claim on complex, non-volatile paths. This also requires plumbing the clip bounds through GrPathRenderer::CanDrawPathArgs. Bug: skia: Change-Id: I16e1d35ad5ee63251e33f113b1579cbba60456da Reviewed-on: https://skia-review.googlesource.com/42224 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2017-09-08 22:25:08 +00:00
SkIRect clipConservativeBounds = SkIRect::MakeWH(renderTargetContext->width(),
renderTargetContext->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);
Use GrShape in GrPathRenderer. GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2081383006 Review-Url: https://codereview.chromium.org/2081383006
2016-06-24 17:42:16 +00:00
GrShape shape(path, style);
Remove atlas creation from GrResourceProvider This is pulled out of: https://skia-review.googlesource.com/c/6680/ (Make SkImage_Gpu be deferred) and is only tangentially related to the goal of that CL. Change-Id: I6b6db4869597070f85ab3b9fea178fc88c104f87 Reviewed-on: https://skia-review.googlesource.com/9106 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2017-03-01 19:32:46 +00:00
GrPathRenderer::DrawPathArgs args{ctx,
Make GrPaints move their GrProcessor ownership into GrPipelineBuilder. This makes GrPaints usable only once. In some places we must make copies in order to issue draws with the same paint state. Change-Id: Ie816e5185ce93a064111cad64c6880e1e21184c2 Reviewed-on: https://skia-review.googlesource.com/6844 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Brian Salomon <bsalomon@google.com>
2017-01-11 18:42:54 +00:00
std::move(paint),
&GrUserStencilSettings::kUnused,
renderTargetContext,
&noClip,
Improve heuristics for when to use ccpr Gives the convex and tessellating renderers first claim on larger paths, and the distance field renderer first claim on complex, non-volatile paths. This also requires plumbing the clip bounds through GrPathRenderer::CanDrawPathArgs. Bug: skia: Change-Id: I16e1d35ad5ee63251e33f113b1579cbba60456da Reviewed-on: https://skia-review.googlesource.com/42224 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Chris Dalton <csmartdalton@google.com>
2017-09-08 22:25:08 +00:00
&clipConservativeBounds,
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
&matrix,
Make GrPaints move their GrProcessor ownership into GrPipelineBuilder. This makes GrPaints usable only once. In some places we must make copies in order to issue draws with the same paint state. Change-Id: Ie816e5185ce93a064111cad64c6880e1e21184c2 Reviewed-on: https://skia-review.googlesource.com/6844 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Brian Salomon <bsalomon@google.com>
2017-01-11 18:42:54 +00:00
&shape,
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
aaType,
Make GrPaints move their GrProcessor ownership into GrPipelineBuilder. This makes GrPaints usable only once. In some places we must make copies in order to issue draws with the same paint state. Change-Id: Ie816e5185ce93a064111cad64c6880e1e21184c2 Reviewed-on: https://skia-review.googlesource.com/6844 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Brian Salomon <bsalomon@google.com>
2017-01-11 18:42:54 +00:00
false};
Also provides the ResourceProvider to onDrawPath which allows the DF PR to no longer require access to GrContext. Review URL: https://codereview.chromium.org/1265763002
2015-07-31 13:48:27 +00:00
tess.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
}
Convert some unit tests from running on GL contexts to running on all contexts GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1873313002 Review URL: https://codereview.chromium.org/1873313002
2016-04-11 21:40:50 +00:00
DEF_GPUTEST_FOR_ALL_CONTEXTS(TessellatingPathRendererTests, reporter, ctxInfo) {
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
GrContext* ctx = ctxInfo.grContext();
Reland "Move makeDeferredRenderTargetContext calls to factory on RTC." This reverts commit a4f207eb67d56e22b25213239efbef776f64d177. Reason for revert: Landing with fix Original change's description: > Revert "Move makeDeferredRenderTargetContext calls to factory on RTC." > > This reverts commit 1c16b430333c6384a8835d4e3671d2fb056ab45b. > > Reason for revert: Red on tree > Original change's description: > > Move makeDeferredRenderTargetContext calls to factory on RTC. > > > > Change-Id: Iaa8f5829d9f8650ff27a60f75fb2216f016ab85e > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/262058 > > Commit-Queue: Greg Daniel <egdaniel@google.com> > > Reviewed-by: Brian Salomon <bsalomon@google.com> > > TBR=egdaniel@google.com,bsalomon@google.com > > Change-Id: I9e3c9d13c66b5437c87ad7136d283fa4ac81df1f > No-Presubmit: true > No-Tree-Checks: true > No-Try: true > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/263019 > Reviewed-by: Jim Van Verth <jvanverth@google.com> > Commit-Queue: Jim Van Verth <jvanverth@google.com> TBR=egdaniel@google.com,jvanverth@google.com,bsalomon@google.com Change-Id: If4ec8316a952fb482471c22273f4724f9b30a998 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/263022 Reviewed-by: Greg Daniel <egdaniel@google.com> Commit-Queue: Greg Daniel <egdaniel@google.com>
2020-01-08 16:52:34 +00:00
auto rtc = GrRenderTargetContext::Make(
ctx, GrColorType::kRGBA_8888, nullptr, SkBackingFit::kApprox, {800, 800}, 1,
GrMipMapped::kNo, GrProtected::kNo, kTopLeft_GrSurfaceOrigin);
Rename GrDrawContext to GrRenderTargetContext This is in preparation for GrTextureContext and GrSurfaceContext BUG=skia: GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=4030 Change-Id: Ie58c93052e68f3f1f5fe8d15d63760de274a6fbd Reviewed-on: https://skia-review.googlesource.com/4030 Commit-Queue: Brian Osman <brianosman@google.com> Reviewed-by: Brian Salomon <bsalomon@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
2016-10-27 18:47:55 +00:00
if (!rtc) {
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;
}
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
ctx->flush();
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
rtc->discard();
Remove atlas creation from GrResourceProvider This is pulled out of: https://skia-review.googlesource.com/c/6680/ (Make SkImage_Gpu be deferred) and is only tangentially related to the goal of that CL. Change-Id: I6b6db4869597070f85ab3b9fea178fc88c104f87 Reviewed-on: https://skia-review.googlesource.com/9106 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Robert Phillips <robertphillips@google.com>
2017-03-01 19:32:46 +00:00
test_path(ctx, rtc.get(), create_path_0());
test_path(ctx, rtc.get(), create_path_1());
test_path(ctx, rtc.get(), create_path_2());
test_path(ctx, rtc.get(), create_path_3());
test_path(ctx, rtc.get(), create_path_4());
test_path(ctx, rtc.get(), create_path_5());
test_path(ctx, rtc.get(), create_path_6());
test_path(ctx, rtc.get(), create_path_7());
test_path(ctx, rtc.get(), create_path_8());
test_path(ctx, rtc.get(), create_path_9());
test_path(ctx, rtc.get(), create_path_10());
test_path(ctx, rtc.get(), create_path_11());
test_path(ctx, rtc.get(), create_path_12());
test_path(ctx, rtc.get(), create_path_13());
test_path(ctx, rtc.get(), create_path_14());
test_path(ctx, rtc.get(), create_path_15());
test_path(ctx, rtc.get(), create_path_16());
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
SkMatrix nonInvertibleMatrix = SkMatrix::MakeScale(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));
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
test_path(ctx, rtc.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));
GrTessellator: fix for vertex coincident with enclosing edge. If a previously-enclosing edge coincides exactly with the current vertex, there are no two adjacent edges which enclose the vertex. Since find_enclosing_edges() ensures that the left enclosing edge is to the left of the vertex, the fix is to split the right enclosing edge on the current vertex and restart intersection tests. Bug: 716720 Change-Id: Id26c5b92a6d6139f348e99554638cded37e81a8e Reviewed-on: https://skia-review.googlesource.com/15261 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-05-03 20:00:38 +00:00
test_path(ctx, rtc.get(), create_path_18());
GrTessellator: fix for three edges becoming collinear after splitting. In rare cases, a single edge can become collinear with two adjacent neighbour edges after it's split. The solution is to continue to merge until no collinear edges are found. BUG=722000 Change-Id: Ia5dd212b7acfb40ed1d6c74ebfa9e4a4746fe40a Reviewed-on: https://skia-review.googlesource.com/17963 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-05-25 18:47:11 +00:00
test_path(ctx, rtc.get(), create_path_19());
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
test_path(ctx, rtc.get(), create_path_20(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, rtc.get(), create_path_21(), SkMatrix(), GrAAType::kCoverage);
GrTessellator: fix for collinear out-of-range intersections. Change 3b5a3fa8b1c11d4bd4499b040311f4c3553ebf8c introduced support for out-of-range intersections, which is necessary when the top and bottom vertices of an edge differ by only one ULP in the primary sort order and can't be split in-order. However, some out-of-range intersections produce edges which cancel each other out on splitting, in particular when the intersection is collinear with the newly-computed edge. This undoes the effect of the split. The tessellator then rewinds, re-detects the intersection, resplits, an infinite loop. The fix is to check for out-of-range intersections which are also collinear, and ignore them. This is ok, because these are not the cases we care about it change 3b5a3f above, which are never collinear. Bug: 753867 Change-Id: I590231e0e6f19c98f1ccf46cb7acc8a63ba35a9d Reviewed-on: https://skia-review.googlesource.com/34925 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2017-08-15 21:01:15 +00:00
test_path(ctx, rtc.get(), create_path_23());
Add support for vkCmdCopyBuffer This is then used when need to update GPU only buffers with data of size greater than 65536. We create a temporary transfer buffer and then copy that buffer into our GPU buffer. Bug: skia: Change-Id: I4bb9cb660f2ac1ccbbd1b508bb4ca6876342136f Reviewed-on: https://skia-review.googlesource.com/38725 Reviewed-by: Jim Van Verth <jvanverth@google.com> Commit-Queue: Greg Daniel <egdaniel@google.com>
2017-08-25 15:55:50 +00:00
test_path(ctx, rtc.get(), create_path_24());
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
test_path(ctx, rtc.get(), create_path_25(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, rtc.get(), create_path_26(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, rtc.get(), create_path_27(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, rtc.get(), create_path_28(), SkMatrix(), GrAAType::kCoverage);
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
test_path(ctx, rtc.get(), create_path_29());
Reland "GrTessellator: hang fix." This is a reland of 050c86768a2c24c62655f53ef9b685d40477eccb Original change's description: > GrTessellator: hang fix. > > Some edges are not coincident with their own endpoints (because floating > point). If this happens for an edge which is a right-enclosing-edge > during the Bentley-Ottman simplify() pass, we end up an infinite loop > attempting to split the edge, since the edge is never to the right of its > endpoint. > > The easiest fix is to simply remove the right-enclosing-edge splitting > code. This code was originally added before we had proper > active-edge-list rewinding, and should no longer be necessary. > > BUG=802896 > > Change-Id: Id9f2942b73f01152af8c0088e8c6b1389891d827 > Reviewed-on: https://skia-review.googlesource.com/116920 > Reviewed-by: Robert Phillips <robertphillips@google.com> > Commit-Queue: Stephen White <senorblanco@chromium.org> Bug: 802896 Change-Id: I3e48346a8a358ae7d481299a586003e817a519ca Reviewed-on: https://skia-review.googlesource.com/117121 Reviewed-by: Mike Klein <mtklein@chromium.org> Commit-Queue: Mike Klein <mtklein@chromium.org>
2018-03-28 18:41:22 +00:00
test_path(ctx, rtc.get(), create_path_30());
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
test_path(ctx, rtc.get(), create_path_31(), SkMatrix(), GrAAType::kCoverage);
GrTessellator: fix for zombie edge fuzzer crash. While splitting one edge, merge_collinear_edges() may in rare cases merge the other edge of the intersection out of existence. split_edge() then brings these dead edges partially back to life, leaving the mesh in an inconsistent state. The fix is to null out the top and bottom pointers of dead edges to mark them as dead, and only split living edges. Bug: skia:7911 Change-Id: I1c0b59581acfcd0b8191f2d129b33f7d0d1a2516 Reviewed-on: https://skia-review.googlesource.com/129181 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-05-18 15:49:21 +00:00
test_path(ctx, rtc.get(), create_path_32());
GrTessellator: fix crash on merging a dead edge. When merging coincident vertices, sometimes merging an edge will cause the next edge in the list to die. But since merge_vertices() retrieves the next edge before merging the current one, we then try to merge its lifeless corpse, bringing it back as a zombie. The fix is to leave dead edges, dead. This was revealed by ec79c39a770205910f0abd762de7e19a96c986ca, but was likely a real bug that was being mishandled before that. Bug: 844873 Bug: skia:7982 Change-Id: I752c45f7551df4278fa4cb4587e7ead48cd16a21 Reviewed-on: https://skia-review.googlesource.com/129524 Commit-Queue: Stephen White <senorblanco@chromium.org> Reviewed-by: Robert Phillips <robertphillips@google.com>
2018-05-22 15:51:32 +00:00
test_path(ctx, rtc.get(), create_path_33());
GrTessellator: fix for ping-pong split fuzzer hang. When support for out-of-range intersections was added in 3b5a3fa8b1c11d4bd4499b040311f4c3553ebf8c, it was intended to support splitting edges that are almost flat, where merging with the top or bottom vertex would cause visual artifacts. However, it triggers too often for other, non-nearly-flat cases, causing simplify() to loop infinitely. The fix is to support out-of-range intersections only if they differ by 1/2 machine epsilon. This also generalizes the out_of_range_and_collinear() check, so it was removed. Bug: 838978 Change-Id: I238f2b90e4b7ad647ecf072427ee38726e549581 Reviewed-on: https://skia-review.googlesource.com/130458 Reviewed-by: Stephen White <senorblanco@chromium.org>
2018-05-31 02:47:46 +00:00
test_path(ctx, rtc.get(), create_path_34());
test_path(ctx, rtc.get(), create_path_35());
GrTessellator: yet another out-of-range splitting fix. It's actually possible for an intersection to be out-of-range on both the intersected edges (e.g., below both bottom points), because floating point. So we need to clamp against both edges. Bug: 846014 Change-Id: I9fe25a1fcd3b5242af7b1ee36b17f1e968aeb836 Reviewed-on: https://skia-review.googlesource.com/132323 Reviewed-by: Brian Salomon <bsalomon@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-06-05 22:45:07 +00:00
test_path(ctx, rtc.get(), create_path_36());
GrTessellator: catch missing intersections. Sometimes the intersection check will miss an intersection (because floating point). This can leave the active edge list in an invalid state, where an edge pair is incorrectly ordered. The fix is to test for edge crossings after testing for intersections, and split the edges manually. This extra check may result in a performance hit, so we'll have to watch the perf bots carefully. Bug: 843135 Change-Id: If50320413026be503cdb2d33e6c97f620e4d51a9 Reviewed-on: https://skia-review.googlesource.com/133400 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-06-08 16:18:22 +00:00
test_path(ctx, rtc.get(), create_path_37());
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
test_path(ctx, rtc.get(), create_path_38(), SkMatrix(), GrAAType::kCoverage);
GrTessellator: handle collinear final vertex. If the last vertex in a contour is collinear with its neighbours, remove it (this edge case was missing). Otherwise, the simplify step may try to split it indefinitely. Bug: 851409 Change-Id: I7efa4e616cdc1508a73c7a9f3de9d3f571569af8 Reviewed-on: https://skia-review.googlesource.com/138106 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-06-28 13:36:49 +00:00
test_path(ctx, rtc.get(), create_path_39());
GrTessellator: handle three consecutive collinear edges. In some cases, splitting may produce three consecutive edges which are collinear. The first one was being merged out, causing the third one to be missed. The fix is to switch the arguments to merge_edges_*, ensuring that the second parameter (the destination edge) is never merged out. Bug: 851409 Change-Id: I65be2e8222846c99f7bc8d17ea61ddead617cc31 Reviewed-on: https://skia-review.googlesource.com/138700 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-06-29 21:02:21 +00:00
test_path(ctx, rtc.get(), create_path_40());
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
test_path(ctx, rtc.get(), create_path_41(), SkMatrix(), GrAAType::kCoverage);
GrTessellator: collinear edges during sanitize. When three collinear edges occur during the sanitize_contours() pass, their vertices may not yet have been discovered to be coincident. So we must do the vertex comparison by point, rather than by pointer. Bug: 860655 Change-Id: I89dc7526905bb5473206661348fee431371731a0 Reviewed-on: https://skia-review.googlesource.com/141523 Reviewed-by: Robert Phillips <robertphillips@google.com> Commit-Queue: Stephen White <senorblanco@chromium.org>
2018-07-16 17:31:16 +00:00
test_path(ctx, rtc.get(), create_path_42());
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
test_path(ctx, rtc.get(), create_path_43(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, rtc.get(), create_path_44(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, rtc.get(), create_path_45(), SkMatrix(), GrAAType::kCoverage);
test_path(ctx, rtc.get(), create_path_46(), 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
}
Reference in New Issue Copy Permalink