AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
d40dc3f81b
skia2/modules/sksg/tests/SGTest.cpp

350 lines
12 KiB
C++
Raw Normal View History

[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
Revert "Revert "SkTypes: extract SkTo"" This reverts commit fdcfb8b7c23fbf18f872d2c31d27978235033876. > Original change's description: > > SkTypes: extract SkTo > > > > Change-Id: I8de790d5013db2105ad885fa2683303d7c250b09 > > Reviewed-on: https://skia-review.googlesource.com/133620 > > Reviewed-by: Mike Klein <mtklein@google.com> Change-Id: Ida74fbc5c21248a724a5edbf9fae18a33bcb23aa Reviewed-on: https://skia-review.googlesource.com/134506 Reviewed-by: Mike Klein <mtklein@google.com> Commit-Queue: Hal Canary <halcanary@google.com>
2018-06-13 13:59:02 +00:00
#include "SkTypes.h"
Disable SkSG unit test for G3 Speculative fix for G3 rolls. TBR= Change-Id: I937d3b432cdf0c0d654f0976fd683acba39470ef Reviewed-on: https://skia-review.googlesource.com/90405 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-04 04:53:37 +00:00
#if !defined(SK_BUILD_FOR_GOOGLE3)
Revert "Revert "SkTypes: extract SkTo"" This reverts commit fdcfb8b7c23fbf18f872d2c31d27978235033876. > Original change's description: > > SkTypes: extract SkTo > > > > Change-Id: I8de790d5013db2105ad885fa2683303d7c250b09 > > Reviewed-on: https://skia-review.googlesource.com/133620 > > Reviewed-by: Mike Klein <mtklein@google.com> Change-Id: Ida74fbc5c21248a724a5edbf9fae18a33bcb23aa Reviewed-on: https://skia-review.googlesource.com/134506 Reviewed-by: Mike Klein <mtklein@google.com> Commit-Queue: Hal Canary <halcanary@google.com>
2018-06-13 13:59:02 +00:00
#include "SkRect.h"
#include "SkRectPriv.h"
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
#include "SkSGColor.h"
#include "SkSGDraw.h"
#include "SkSGGroup.h"
#include "SkSGInvalidationController.h"
#include "SkSGRect.h"
[sksg] Fix image filter content inval rect tracking Image filters cannot let descendent damage pass through, as they may transform their inputs arbitrarily. Introduce the notion of "damage override" SG nodes (nodes which block descendent damage and replace it with their own), and update ImageFilterEffect to opt in for this behavior. Also make InvalidationController damage dispatch optional (such that we don't accumulate inval rects unnecessarily). TBR= Change-Id: Ie9f7d32ecdcc77dbe6ea009aed9ce269b3649a04 Reviewed-on: https://skia-review.googlesource.com/c/191005 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2019-02-10 17:54:20 +00:00
#include "SkSGRenderEffect.h"
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
#include "SkSGTransform.h"
Revert "Revert "SkTypes: extract SkTo"" This reverts commit fdcfb8b7c23fbf18f872d2c31d27978235033876. > Original change's description: > > SkTypes: extract SkTo > > > > Change-Id: I8de790d5013db2105ad885fa2683303d7c250b09 > > Reviewed-on: https://skia-review.googlesource.com/133620 > > Reviewed-by: Mike Klein <mtklein@google.com> Change-Id: Ida74fbc5c21248a724a5edbf9fae18a33bcb23aa Reviewed-on: https://skia-review.googlesource.com/134506 Reviewed-by: Mike Klein <mtklein@google.com> Commit-Queue: Hal Canary <halcanary@google.com>
2018-06-13 13:59:02 +00:00
#include "SkTo.h"
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
#include "Test.h"
#include <vector>
static void check_inval(skiatest::Reporter* reporter, const sk_sp<sksg::Node>& root,
const SkRect& expected_bounds,
const SkRect& expected_inval_bounds,
const std::vector<SkRect>* expected_damage) {
sksg::InvalidationController ic;
const auto bbox = root->revalidate(&ic, SkMatrix::I());
if (0) {
Build fix post c75e2401a82640c35b0b5f80a5684d0892904530 TBR= Change-Id: I3a13fe015bc88029471930d51c741f99f38f0daa Reviewed-on: https://skia-review.googlesource.com/90404 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-04 01:13:34 +00:00
SkDebugf("** bbox: [%f %f %f %f], ibbox: [%f %f %f %f]\n",
bbox.fLeft, bbox.fTop, bbox.fRight, bbox.fBottom,
ic.bounds().left(), ic.bounds().top(), ic.bounds().right(), ic.bounds().bottom());
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
}
REPORTER_ASSERT(reporter, bbox == expected_bounds);
REPORTER_ASSERT(reporter, ic.bounds() == expected_inval_bounds);
if (expected_damage) {
[sksg] More inval fixes Backpedal on node/reval-time-determined damage: nodes cannot control the invalidation order, and shared descendants may be revalidated before a particular ancestor gets to query their state - thus making any decisions based on that invalid. Instead, apply damage suppression at invalidation time, based on node type/traits. Node types which don't generate direct damage are marked as such, and the invalidation logic bubbles damage past them, until it finds a valid damage receiver. Nodes which currently suppress damage: - PaintNode (and subclasses) - GeometryNode (and subclasses) - Matrix TBR= Change-Id: I843e683e64cb6253d8c26d8397c44d02a7d6026f Reviewed-on: https://skia-review.googlesource.com/91421 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 16:32:31 +00:00
const auto damage_count = SkTo<size_t>(ic.end() - ic.begin());
REPORTER_ASSERT(reporter, expected_damage->size() == damage_count);
for (size_t i = 0; i < std::min(expected_damage->size(), damage_count); ++i) {
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
const auto r1 = (*expected_damage)[i],
r2 = ic.begin()[i];
if (0) {
Build fix post c75e2401a82640c35b0b5f80a5684d0892904530 TBR= Change-Id: I3a13fe015bc88029471930d51c741f99f38f0daa Reviewed-on: https://skia-review.googlesource.com/90404 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-04 01:13:34 +00:00
SkDebugf("*** expected inval: [%f %f %f %f], actual: [%f %f %f %f]\n",
r1.left(), r1.top(), r1.right(), r1.bottom(),
r2.left(), r2.top(), r2.right(), r2.bottom());
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
}
REPORTER_ASSERT(reporter, r1 == r2);
}
}
}
[sksg] Hit-testing API Introduce RenderNode::nodeAt(const SkPoint&) as the entry point for the hit-testing API. This is backed by a onNodeAt() virtual, which gets dispatched throughout the render DAG, and normally stops at the first leaf Draw node in encounters. To support the implementation, introduce a GeometryNode::contains(const SkPoint&) API. This is backed by a onContains() virtual, overridden in each concrete geometry class. Expose nodeAt() on sksg::Scene, and add some basic unit tests. Change-Id: I0c8abd9d1e51ecf2d8b4dd699f325cd636e21084 Reviewed-on: https://skia-review.googlesource.com/c/191296 Commit-Queue: Florin Malita <fmalita@chromium.org> Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 14:33:21 +00:00
struct HitTest {
const SkPoint pt;
sk_sp<sksg::RenderNode> node;
};
static void check_hittest(skiatest::Reporter* reporter, const sk_sp<sksg::RenderNode>& root,
const std::vector<HitTest>& tests) {
for (const auto& tst : tests) {
const auto* node = root->nodeAt(tst.pt);
if (node != tst.node.get()) {
SkDebugf("*** nodeAt(%f, %f) - expected %p, got %p\n",
tst.pt.x(), tst.pt.y(), tst.node.get(), node);
}
REPORTER_ASSERT(reporter, tst.node.get() == node);
}
}
[sksg] More inval fixes Backpedal on node/reval-time-determined damage: nodes cannot control the invalidation order, and shared descendants may be revalidated before a particular ancestor gets to query their state - thus making any decisions based on that invalid. Instead, apply damage suppression at invalidation time, based on node type/traits. Node types which don't generate direct damage are marked as such, and the invalidation logic bubbles damage past them, until it finds a valid damage receiver. Nodes which currently suppress damage: - PaintNode (and subclasses) - GeometryNode (and subclasses) - Matrix TBR= Change-Id: I843e683e64cb6253d8c26d8397c44d02a7d6026f Reviewed-on: https://skia-review.googlesource.com/91421 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 16:32:31 +00:00
static void inval_test1(skiatest::Reporter* reporter) {
[skotty, sksg] Add layer transform inheritance support Split the matrix component of sksg::Transform into its own, free-floating, chainable node. Update the composite transform animator to target matrix nodes instead of transform nodes. Update the layer transform attachment logic to follow "parent" references, and build matrix inheritance chains on the fly. TBR= Change-Id: I017e5e462274c2cc210730e057b3ea2e7de5c0cb Reviewed-on: https://skia-review.googlesource.com/90803 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 02:11:55 +00:00
auto color = sksg::Color::Make(0xff000000);
auto r1 = sksg::Rect::Make(SkRect::MakeWH(100, 100)),
r2 = sksg::Rect::Make(SkRect::MakeWH(100, 100));
auto grp = sksg::Group::Make();
[sksg] Consolidate Matrix node implementations Matrix and Matrix44 look almost identical -- consolidate as a template class. TBR= Change-Id: I8f299a6138f190eb18de2e67b051307cf6a33383 Reviewed-on: https://skia-review.googlesource.com/c/182973 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2019-01-10 20:24:15 +00:00
auto matrix = sksg::Matrix<SkMatrix>::Make(SkMatrix::I());
[sksg] 4x4 matrix support Refactor the scene graph transform hierarchy to support 4x4 matrices: * rename current Transform to TransformEffect (operates as a render tree effect) * introduce a new Transform abstract base class, to replace current Matrix * refactor existing Matrix as a Transform specialization * introduce a new Matrix44 Transform specialization * refactor the existing composition helper (ComposedMatrix) as Concat, a Transform specialization (using composition instead of Matrix inheritance) Change-Id: Ic3c1b499e10a0a229a7a76d4bef3dbc6a8b49194 Reviewed-on: https://skia-review.googlesource.com/c/182666 Reviewed-by: Mike Reed <reed@google.com> Commit-Queue: Florin Malita <fmalita@chromium.org>
2019-01-09 20:37:57 +00:00
auto root = sksg::TransformEffect::Make(grp, matrix);
[sksg] Hit-testing API Introduce RenderNode::nodeAt(const SkPoint&) as the entry point for the hit-testing API. This is backed by a onNodeAt() virtual, which gets dispatched throughout the render DAG, and normally stops at the first leaf Draw node in encounters. To support the implementation, introduce a GeometryNode::contains(const SkPoint&) API. This is backed by a onContains() virtual, overridden in each concrete geometry class. Expose nodeAt() on sksg::Scene, and add some basic unit tests. Change-Id: I0c8abd9d1e51ecf2d8b4dd699f325cd636e21084 Reviewed-on: https://skia-review.googlesource.com/c/191296 Commit-Queue: Florin Malita <fmalita@chromium.org> Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 14:33:21 +00:00
auto d1 = sksg::Draw::Make(r1, color),
d2 = sksg::Draw::Make(r2, color);
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
[sksg] Hit-testing API Introduce RenderNode::nodeAt(const SkPoint&) as the entry point for the hit-testing API. This is backed by a onNodeAt() virtual, which gets dispatched throughout the render DAG, and normally stops at the first leaf Draw node in encounters. To support the implementation, introduce a GeometryNode::contains(const SkPoint&) API. This is backed by a onContains() virtual, overridden in each concrete geometry class. Expose nodeAt() on sksg::Scene, and add some basic unit tests. Change-Id: I0c8abd9d1e51ecf2d8b4dd699f325cd636e21084 Reviewed-on: https://skia-review.googlesource.com/c/191296 Commit-Queue: Florin Malita <fmalita@chromium.org> Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 14:33:21 +00:00
grp->addChild(d1);
grp->addChild(d2);
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
{
// Initial revalidation.
[skotty, sksg] Add layer transform inheritance support Split the matrix component of sksg::Transform into its own, free-floating, chainable node. Update the composite transform animator to target matrix nodes instead of transform nodes. Update the layer transform attachment logic to follow "parent" references, and build matrix inheritance chains on the fly. TBR= Change-Id: I017e5e462274c2cc210730e057b3ea2e7de5c0cb Reviewed-on: https://skia-review.googlesource.com/90803 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 02:11:55 +00:00
check_inval(reporter, root,
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
SkRect::MakeWH(100, 100),
handle large rects, rename helper To fix gm/bigrect, needed to do adjust "largest" rect so it doesn't become empty when round-tripping with SkRect/SkIRect. I renamed it after this. Bug: skia: Change-Id: I747782c8456da603cf298275d2300ea1996e7629 Reviewed-on: https://skia-review.googlesource.com/95563 Commit-Queue: Mike Reed <reed@google.com> Reviewed-by: Yuqian Li <liyuqian@google.com>
2018-01-17 17:20:04 +00:00
SkRectPriv::MakeLargeS32(),
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
nullptr);
[sksg] Hit-testing API Introduce RenderNode::nodeAt(const SkPoint&) as the entry point for the hit-testing API. This is backed by a onNodeAt() virtual, which gets dispatched throughout the render DAG, and normally stops at the first leaf Draw node in encounters. To support the implementation, introduce a GeometryNode::contains(const SkPoint&) API. This is backed by a onContains() virtual, overridden in each concrete geometry class. Expose nodeAt() on sksg::Scene, and add some basic unit tests. Change-Id: I0c8abd9d1e51ecf2d8b4dd699f325cd636e21084 Reviewed-on: https://skia-review.googlesource.com/c/191296 Commit-Queue: Florin Malita <fmalita@chromium.org> Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 14:33:21 +00:00
check_hittest(reporter, root, {
{{ -1, 0 }, nullptr },
{{ 0, -1 }, nullptr },
{{ 100, 0 }, nullptr },
{{ 0, 100 }, nullptr },
[sksg] Fix group hit-testing order Change-Id: Idc25109a598caabf01e3ab61dc97f984ff453d40 Reviewed-on: https://skia-review.googlesource.com/c/191664 Commit-Queue: Mike Reed <reed@google.com> Auto-Submit: Florin Malita <fmalita@chromium.org> Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 20:41:39 +00:00
{{ 0, 0 }, d2 },
{{ 99, 99 }, d2 },
[sksg] Hit-testing API Introduce RenderNode::nodeAt(const SkPoint&) as the entry point for the hit-testing API. This is backed by a onNodeAt() virtual, which gets dispatched throughout the render DAG, and normally stops at the first leaf Draw node in encounters. To support the implementation, introduce a GeometryNode::contains(const SkPoint&) API. This is backed by a onContains() virtual, overridden in each concrete geometry class. Expose nodeAt() on sksg::Scene, and add some basic unit tests. Change-Id: I0c8abd9d1e51ecf2d8b4dd699f325cd636e21084 Reviewed-on: https://skia-review.googlesource.com/c/191296 Commit-Queue: Florin Malita <fmalita@chromium.org> Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 14:33:21 +00:00
});
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
}
{
// Move r2 to (200 100).
r2->setL(200); r2->setT(100); r2->setR(300); r2->setB(200);
std::vector<SkRect> damage = { {0, 0, 100, 100}, { 200, 100, 300, 200} };
[skotty, sksg] Add layer transform inheritance support Split the matrix component of sksg::Transform into its own, free-floating, chainable node. Update the composite transform animator to target matrix nodes instead of transform nodes. Update the layer transform attachment logic to follow "parent" references, and build matrix inheritance chains on the fly. TBR= Change-Id: I017e5e462274c2cc210730e057b3ea2e7de5c0cb Reviewed-on: https://skia-review.googlesource.com/90803 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 02:11:55 +00:00
check_inval(reporter, root,
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
SkRect::MakeWH(300, 200),
SkRect::MakeWH(300, 200),
&damage);
[sksg] Hit-testing API Introduce RenderNode::nodeAt(const SkPoint&) as the entry point for the hit-testing API. This is backed by a onNodeAt() virtual, which gets dispatched throughout the render DAG, and normally stops at the first leaf Draw node in encounters. To support the implementation, introduce a GeometryNode::contains(const SkPoint&) API. This is backed by a onContains() virtual, overridden in each concrete geometry class. Expose nodeAt() on sksg::Scene, and add some basic unit tests. Change-Id: I0c8abd9d1e51ecf2d8b4dd699f325cd636e21084 Reviewed-on: https://skia-review.googlesource.com/c/191296 Commit-Queue: Florin Malita <fmalita@chromium.org> Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 14:33:21 +00:00
check_hittest(reporter, root, {
{{ -1, 0 }, nullptr },
{{ 0, -1 }, nullptr },
{{ 100, 0 }, nullptr },
{{ 0, 100 }, nullptr },
{{ 0, 0 }, d1 },
{{ 99, 99 }, d1 },
{{ 199, 100 }, nullptr },
{{ 200, 99 }, nullptr },
{{ 300, 100 }, nullptr },
{{ 200, 200 }, nullptr },
{{ 200, 100 }, d2 },
{{ 299, 199 }, d2 },
});
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
}
{
// Update the common color.
[sksg] More inval fiddling Node subclasses can now control whether their bounds (changes) contribute to damage. Tristate: * Default: The node bounds contribute to damage if the node itself was invalidated, observing hasSelfInval(). This is the default behavior. * ForceSelf: The node bounds contribute to damage, regardless of hasSelfInval(). Used for domain-boundary nodes (e.g. Draw), which gate blocked fragments (e.g. geometry, paint nodes). * BlockSelf: The node bounds do not contribute to damage, regardless of hasSelfInval(). Used for nodes which do not contribute damage directly (e.g. paints, geometry). TBR= Change-Id: I7c941c7ea12e14b008d846ec13108e66e34dbc73 Reviewed-on: https://skia-review.googlesource.com/91104 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 00:21:58 +00:00
color->setColor(0xffff0000);
std::vector<SkRect> damage = { {0, 0, 100, 100}, { 200, 100, 300, 200} };
[skotty, sksg] Add layer transform inheritance support Split the matrix component of sksg::Transform into its own, free-floating, chainable node. Update the composite transform animator to target matrix nodes instead of transform nodes. Update the layer transform attachment logic to follow "parent" references, and build matrix inheritance chains on the fly. TBR= Change-Id: I017e5e462274c2cc210730e057b3ea2e7de5c0cb Reviewed-on: https://skia-review.googlesource.com/90803 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 02:11:55 +00:00
check_inval(reporter, root,
[sksg] More inval fiddling Node subclasses can now control whether their bounds (changes) contribute to damage. Tristate: * Default: The node bounds contribute to damage if the node itself was invalidated, observing hasSelfInval(). This is the default behavior. * ForceSelf: The node bounds contribute to damage, regardless of hasSelfInval(). Used for domain-boundary nodes (e.g. Draw), which gate blocked fragments (e.g. geometry, paint nodes). * BlockSelf: The node bounds do not contribute to damage, regardless of hasSelfInval(). Used for nodes which do not contribute damage directly (e.g. paints, geometry). TBR= Change-Id: I7c941c7ea12e14b008d846ec13108e66e34dbc73 Reviewed-on: https://skia-review.googlesource.com/91104 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 00:21:58 +00:00
SkRect::MakeWH(300, 200),
SkRect::MakeWH(300, 200),
&damage);
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
}
{
// Shrink r1.
r1->setR(50);
std::vector<SkRect> damage = { {0, 0, 100, 100}, { 0, 0, 50, 100} };
[skotty, sksg] Add layer transform inheritance support Split the matrix component of sksg::Transform into its own, free-floating, chainable node. Update the composite transform animator to target matrix nodes instead of transform nodes. Update the layer transform attachment logic to follow "parent" references, and build matrix inheritance chains on the fly. TBR= Change-Id: I017e5e462274c2cc210730e057b3ea2e7de5c0cb Reviewed-on: https://skia-review.googlesource.com/90803 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 02:11:55 +00:00
check_inval(reporter, root,
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
SkRect::MakeWH(300, 200),
SkRect::MakeWH(100, 100),
&damage);
[sksg] Hit-testing API Introduce RenderNode::nodeAt(const SkPoint&) as the entry point for the hit-testing API. This is backed by a onNodeAt() virtual, which gets dispatched throughout the render DAG, and normally stops at the first leaf Draw node in encounters. To support the implementation, introduce a GeometryNode::contains(const SkPoint&) API. This is backed by a onContains() virtual, overridden in each concrete geometry class. Expose nodeAt() on sksg::Scene, and add some basic unit tests. Change-Id: I0c8abd9d1e51ecf2d8b4dd699f325cd636e21084 Reviewed-on: https://skia-review.googlesource.com/c/191296 Commit-Queue: Florin Malita <fmalita@chromium.org> Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 14:33:21 +00:00
check_hittest(reporter, root, {
{{ -1, 0 }, nullptr },
{{ 0, -1 }, nullptr },
{{ 50, 0 }, nullptr },
{{ 0, 100 }, nullptr },
{{ 0, 0 }, d1 },
{{ 49, 99 }, d1 },
{{ 199, 100 }, nullptr },
{{ 200, 99 }, nullptr },
{{ 300, 100 }, nullptr },
{{ 200, 200 }, nullptr },
{{ 200, 100 }, d2 },
{{ 299, 199 }, d2 },
});
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
}
{
// Update transform.
[skotty, sksg] Add layer transform inheritance support Split the matrix component of sksg::Transform into its own, free-floating, chainable node. Update the composite transform animator to target matrix nodes instead of transform nodes. Update the layer transform attachment logic to follow "parent" references, and build matrix inheritance chains on the fly. TBR= Change-Id: I017e5e462274c2cc210730e057b3ea2e7de5c0cb Reviewed-on: https://skia-review.googlesource.com/90803 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 02:11:55 +00:00
matrix->setMatrix(SkMatrix::MakeScale(2, 2));
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
std::vector<SkRect> damage = { {0, 0, 300, 200}, { 0, 0, 600, 400} };
[skotty, sksg] Add layer transform inheritance support Split the matrix component of sksg::Transform into its own, free-floating, chainable node. Update the composite transform animator to target matrix nodes instead of transform nodes. Update the layer transform attachment logic to follow "parent" references, and build matrix inheritance chains on the fly. TBR= Change-Id: I017e5e462274c2cc210730e057b3ea2e7de5c0cb Reviewed-on: https://skia-review.googlesource.com/90803 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 02:11:55 +00:00
check_inval(reporter, root,
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
SkRect::MakeWH(600, 400),
SkRect::MakeWH(600, 400),
&damage);
[sksg] Hit-testing API Introduce RenderNode::nodeAt(const SkPoint&) as the entry point for the hit-testing API. This is backed by a onNodeAt() virtual, which gets dispatched throughout the render DAG, and normally stops at the first leaf Draw node in encounters. To support the implementation, introduce a GeometryNode::contains(const SkPoint&) API. This is backed by a onContains() virtual, overridden in each concrete geometry class. Expose nodeAt() on sksg::Scene, and add some basic unit tests. Change-Id: I0c8abd9d1e51ecf2d8b4dd699f325cd636e21084 Reviewed-on: https://skia-review.googlesource.com/c/191296 Commit-Queue: Florin Malita <fmalita@chromium.org> Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 14:33:21 +00:00
check_hittest(reporter, root, {
{{ -1, 0 }, nullptr },
{{ 0, -1 }, nullptr },
{{ 25, 0 }, nullptr },
{{ 0, 50 }, nullptr },
{{ 0, 0 }, d1 },
{{ 24, 49 }, d1 },
{{ 99, 50 }, nullptr },
{{ 100, 49 }, nullptr },
{{ 150, 50 }, nullptr },
{{ 100, 100 }, nullptr },
{{ 100, 50 }, d2 },
{{ 149, 99 }, d2 },
});
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
}
{
// Shrink r2 under transform.
r2->setR(250);
std::vector<SkRect> damage = { {400, 200, 600, 400}, { 400, 200, 500, 400} };
[skotty, sksg] Add layer transform inheritance support Split the matrix component of sksg::Transform into its own, free-floating, chainable node. Update the composite transform animator to target matrix nodes instead of transform nodes. Update the layer transform attachment logic to follow "parent" references, and build matrix inheritance chains on the fly. TBR= Change-Id: I017e5e462274c2cc210730e057b3ea2e7de5c0cb Reviewed-on: https://skia-review.googlesource.com/90803 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 02:11:55 +00:00
check_inval(reporter, root,
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
SkRect::MakeWH(500, 400),
SkRect::MakeLTRB(400, 200, 600, 400),
&damage);
[sksg] Hit-testing API Introduce RenderNode::nodeAt(const SkPoint&) as the entry point for the hit-testing API. This is backed by a onNodeAt() virtual, which gets dispatched throughout the render DAG, and normally stops at the first leaf Draw node in encounters. To support the implementation, introduce a GeometryNode::contains(const SkPoint&) API. This is backed by a onContains() virtual, overridden in each concrete geometry class. Expose nodeAt() on sksg::Scene, and add some basic unit tests. Change-Id: I0c8abd9d1e51ecf2d8b4dd699f325cd636e21084 Reviewed-on: https://skia-review.googlesource.com/c/191296 Commit-Queue: Florin Malita <fmalita@chromium.org> Reviewed-by: Mike Reed <reed@google.com>
2019-02-12 14:33:21 +00:00
check_hittest(reporter, root, {
{{ -1, 0 }, nullptr },
{{ 0, -1 }, nullptr },
{{ 25, 0 }, nullptr },
{{ 0, 50 }, nullptr },
{{ 0, 0 }, d1 },
{{ 24, 49 }, d1 },
{{ 99, 50 }, nullptr },
{{ 100, 49 }, nullptr },
{{ 125, 50 }, nullptr },
{{ 100, 100 }, nullptr },
{{ 100, 50 }, d2 },
{{ 124, 99 }, d2 },
});
[sksg] Refine invalidation logic We need to discriminate between nodes whose bounds updates contribute to the dirty region, and nodes whose bounds changes do not. E.g. animated shape in a group: the animated shape node bounds should yield damage, but the ancestor group bounds should not. To accomplish this, we refine the invalidation state: 1) self invalidation == the node itself was invalidated, and its bounds updates yield damage. 2) descendant invalidation == the node has some (self-)invalidated descendant, but its own bounds are not contributing damage. Also: * hoist the bounding box invalidation logic into the base class (Node::revalidate) and update to respect the states described above. * remove (now-redundant) GeometryNode bbox logic. * update revalidation methods to return the node bbox instead of void TBR= Change-Id: I8023d1793fb501c945a53f2dc2d2983e5b620ade Reviewed-on: https://skia-review.googlesource.com/90581 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-03 21:17:29 +00:00
}
}
Disable SkSG unit test for G3 Speculative fix for G3 rolls. TBR= Change-Id: I937d3b432cdf0c0d654f0976fd683acba39470ef Reviewed-on: https://skia-review.googlesource.com/90405 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-04 04:53:37 +00:00
[sksg] More inval fixes Backpedal on node/reval-time-determined damage: nodes cannot control the invalidation order, and shared descendants may be revalidated before a particular ancestor gets to query their state - thus making any decisions based on that invalid. Instead, apply damage suppression at invalidation time, based on node type/traits. Node types which don't generate direct damage are marked as such, and the invalidation logic bubbles damage past them, until it finds a valid damage receiver. Nodes which currently suppress damage: - PaintNode (and subclasses) - GeometryNode (and subclasses) - Matrix TBR= Change-Id: I843e683e64cb6253d8c26d8397c44d02a7d6026f Reviewed-on: https://skia-review.googlesource.com/91421 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 16:32:31 +00:00
static void inval_test2(skiatest::Reporter* reporter) {
auto color = sksg::Color::Make(0xff000000);
auto rect = sksg::Rect::Make(SkRect::MakeWH(100, 100));
[sksg] Consolidate Matrix node implementations Matrix and Matrix44 look almost identical -- consolidate as a template class. TBR= Change-Id: I8f299a6138f190eb18de2e67b051307cf6a33383 Reviewed-on: https://skia-review.googlesource.com/c/182973 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2019-01-10 20:24:15 +00:00
auto m1 = sksg::Matrix<SkMatrix>::Make(SkMatrix::I()),
m2 = sksg::Matrix<SkMatrix>::Make(SkMatrix::I());
[sksg] 4x4 matrix support Refactor the scene graph transform hierarchy to support 4x4 matrices: * rename current Transform to TransformEffect (operates as a render tree effect) * introduce a new Transform abstract base class, to replace current Matrix * refactor existing Matrix as a Transform specialization * introduce a new Matrix44 Transform specialization * refactor the existing composition helper (ComposedMatrix) as Concat, a Transform specialization (using composition instead of Matrix inheritance) Change-Id: Ic3c1b499e10a0a229a7a76d4bef3dbc6a8b49194 Reviewed-on: https://skia-review.googlesource.com/c/182666 Reviewed-by: Mike Reed <reed@google.com> Commit-Queue: Florin Malita <fmalita@chromium.org>
2019-01-09 20:37:57 +00:00
auto t1 = sksg::TransformEffect::Make(sksg::Draw::Make(rect, color),
sksg::Transform::MakeConcat(m1, m2)),
t2 = sksg::TransformEffect::Make(sksg::Draw::Make(rect, color), m1);
[sksg] More inval fixes Backpedal on node/reval-time-determined damage: nodes cannot control the invalidation order, and shared descendants may be revalidated before a particular ancestor gets to query their state - thus making any decisions based on that invalid. Instead, apply damage suppression at invalidation time, based on node type/traits. Node types which don't generate direct damage are marked as such, and the invalidation logic bubbles damage past them, until it finds a valid damage receiver. Nodes which currently suppress damage: - PaintNode (and subclasses) - GeometryNode (and subclasses) - Matrix TBR= Change-Id: I843e683e64cb6253d8c26d8397c44d02a7d6026f Reviewed-on: https://skia-review.googlesource.com/91421 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 16:32:31 +00:00
auto root = sksg::Group::Make();
root->addChild(t1);
root->addChild(t2);
{
// Initial revalidation.
check_inval(reporter, root,
SkRect::MakeWH(100, 100),
handle large rects, rename helper To fix gm/bigrect, needed to do adjust "largest" rect so it doesn't become empty when round-tripping with SkRect/SkIRect. I renamed it after this. Bug: skia: Change-Id: I747782c8456da603cf298275d2300ea1996e7629 Reviewed-on: https://skia-review.googlesource.com/95563 Commit-Queue: Mike Reed <reed@google.com> Reviewed-by: Yuqian Li <liyuqian@google.com>
2018-01-17 17:20:04 +00:00
SkRectPriv::MakeLargeS32(),
[sksg] More inval fixes Backpedal on node/reval-time-determined damage: nodes cannot control the invalidation order, and shared descendants may be revalidated before a particular ancestor gets to query their state - thus making any decisions based on that invalid. Instead, apply damage suppression at invalidation time, based on node type/traits. Node types which don't generate direct damage are marked as such, and the invalidation logic bubbles damage past them, until it finds a valid damage receiver. Nodes which currently suppress damage: - PaintNode (and subclasses) - GeometryNode (and subclasses) - Matrix TBR= Change-Id: I843e683e64cb6253d8c26d8397c44d02a7d6026f Reviewed-on: https://skia-review.googlesource.com/91421 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 16:32:31 +00:00
nullptr);
}
{
// Update the shared color.
color->setColor(0xffff0000);
std::vector<SkRect> damage = { {0, 0, 100, 100}, { 0, 0, 100, 100} };
check_inval(reporter, root,
SkRect::MakeWH(100, 100),
SkRect::MakeWH(100, 100),
&damage);
}
{
// Update m2.
m2->setMatrix(SkMatrix::MakeScale(2, 2));
std::vector<SkRect> damage = { {0, 0, 100, 100}, { 0, 0, 200, 200} };
check_inval(reporter, root,
SkRect::MakeWH(200, 200),
SkRect::MakeWH(200, 200),
&damage);
}
{
// Update shared m1.
m1->setMatrix(SkMatrix::MakeTrans(100, 100));
std::vector<SkRect> damage = { { 0, 0, 200, 200}, // draw1 prev bounds
{ 100, 100, 300, 300}, // draw1 new bounds
{ 0, 0, 100, 100}, // draw2 prev bounds
{ 100, 100, 200, 200} }; // draw2 new bounds
check_inval(reporter, root,
SkRect::MakeLTRB(100, 100, 300, 300),
SkRect::MakeLTRB( 0, 0, 300, 300),
&damage);
}
{
// Update shared rect.
rect->setR(50);
std::vector<SkRect> damage = { { 100, 100, 300, 300}, // draw1 prev bounds
{ 100, 100, 200, 300}, // draw1 new bounds
{ 100, 100, 200, 200}, // draw2 prev bounds
{ 100, 100, 150, 200} }; // draw2 new bounds
check_inval(reporter, root,
SkRect::MakeLTRB(100, 100, 200, 300),
SkRect::MakeLTRB(100, 100, 300, 300),
&damage);
}
}
[sksg] Fix image filter content inval rect tracking Image filters cannot let descendent damage pass through, as they may transform their inputs arbitrarily. Introduce the notion of "damage override" SG nodes (nodes which block descendent damage and replace it with their own), and update ImageFilterEffect to opt in for this behavior. Also make InvalidationController damage dispatch optional (such that we don't accumulate inval rects unnecessarily). TBR= Change-Id: Ie9f7d32ecdcc77dbe6ea009aed9ce269b3649a04 Reviewed-on: https://skia-review.googlesource.com/c/191005 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2019-02-10 17:54:20 +00:00
static void inval_test3(skiatest::Reporter* reporter) {
auto color1 = sksg::Color::Make(0xff000000),
color2 = sksg::Color::Make(0xff000000);
auto group = sksg::Group::Make();
group->addChild(sksg::Draw::Make(sksg::Rect::Make(SkRect::MakeWH(100, 100)),
color1));
group->addChild(sksg::Draw::Make(sksg::Rect::Make(SkRect::MakeXYWH(200, 0, 100, 100)),
color2));
auto filter = sksg::DropShadowImageFilter::Make();
filter->setOffset({50, 75});
auto root = sksg::ImageFilterEffect::Make(group, filter);
{
// Initial revalidation.
check_inval(reporter, root,
SkRect::MakeXYWH(0, 0, 350, 175),
SkRectPriv::MakeLargeS32(),
nullptr);
}
{
// Shadow-only.
filter->setMode(sksg::DropShadowImageFilter::Mode::kShadowOnly);
std::vector<SkRect> damage = { {0, 0, 350, 175}, { 50, 75, 350, 175} };
check_inval(reporter, root,
SkRect::MakeLTRB(50, 75, 350, 175),
SkRect::MakeLTRB(0, 0, 350, 175),
&damage);
}
{
// Content change -> single/full filter bounds inval.
color1->setColor(0xffff0000);
std::vector<SkRect> damage = { { 50, 75, 350, 175} };
check_inval(reporter, root,
SkRect::MakeLTRB(50, 75, 350, 175),
SkRect::MakeLTRB(50, 75, 350, 175),
&damage);
}
}
[sksg] Fix inval tracking in Group::removeChild() TBR= Change-Id: If3536f8be9d379402cde18c0482108fcf5ae01bb Reviewed-on: https://skia-review.googlesource.com/158822 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-10-02 17:05:39 +00:00
static void inval_group_remove(skiatest::Reporter* reporter) {
auto draw = sksg::Draw::Make(sksg::Rect::Make(SkRect::MakeWH(100, 100)),
sksg::Color::Make(SK_ColorBLACK));
auto grp = sksg::Group::Make();
// Readding the child should not trigger asserts.
grp->addChild(draw);
grp->removeChild(draw);
grp->addChild(draw);
}
[sksg] More inval fixes Backpedal on node/reval-time-determined damage: nodes cannot control the invalidation order, and shared descendants may be revalidated before a particular ancestor gets to query their state - thus making any decisions based on that invalid. Instead, apply damage suppression at invalidation time, based on node type/traits. Node types which don't generate direct damage are marked as such, and the invalidation logic bubbles damage past them, until it finds a valid damage receiver. Nodes which currently suppress damage: - PaintNode (and subclasses) - GeometryNode (and subclasses) - Matrix TBR= Change-Id: I843e683e64cb6253d8c26d8397c44d02a7d6026f Reviewed-on: https://skia-review.googlesource.com/91421 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 16:32:31 +00:00
DEF_TEST(SGInvalidation, reporter) {
inval_test1(reporter);
inval_test2(reporter);
[sksg] Fix image filter content inval rect tracking Image filters cannot let descendent damage pass through, as they may transform their inputs arbitrarily. Introduce the notion of "damage override" SG nodes (nodes which block descendent damage and replace it with their own), and update ImageFilterEffect to opt in for this behavior. Also make InvalidationController damage dispatch optional (such that we don't accumulate inval rects unnecessarily). TBR= Change-Id: Ie9f7d32ecdcc77dbe6ea009aed9ce269b3649a04 Reviewed-on: https://skia-review.googlesource.com/c/191005 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2019-02-10 17:54:20 +00:00
inval_test3(reporter);
[sksg] Fix inval tracking in Group::removeChild() TBR= Change-Id: If3536f8be9d379402cde18c0482108fcf5ae01bb Reviewed-on: https://skia-review.googlesource.com/158822 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-10-02 17:05:39 +00:00
inval_group_remove(reporter);
[sksg] More inval fixes Backpedal on node/reval-time-determined damage: nodes cannot control the invalidation order, and shared descendants may be revalidated before a particular ancestor gets to query their state - thus making any decisions based on that invalid. Instead, apply damage suppression at invalidation time, based on node type/traits. Node types which don't generate direct damage are marked as such, and the invalidation logic bubbles damage past them, until it finds a valid damage receiver. Nodes which currently suppress damage: - PaintNode (and subclasses) - GeometryNode (and subclasses) - Matrix TBR= Change-Id: I843e683e64cb6253d8c26d8397c44d02a7d6026f Reviewed-on: https://skia-review.googlesource.com/91421 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-05 16:32:31 +00:00
}
Disable SkSG unit test for G3 Speculative fix for G3 rolls. TBR= Change-Id: I937d3b432cdf0c0d654f0976fd683acba39470ef Reviewed-on: https://skia-review.googlesource.com/90405 Reviewed-by: Florin Malita <fmalita@chromium.org> Commit-Queue: Florin Malita <fmalita@chromium.org>
2018-01-04 04:53:37 +00:00
#endif // !defined(SK_BUILD_FOR_GOOGLE3)
Reference in New Issue Copy Permalink