Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include <gtest/gtest.h> |
| 18 | |
| 19 | #include <BakedOpState.h> |
Chris Craik | d2dfd8f | 2015-12-16 14:27:20 -0800 | [diff] [blame] | 20 | #include <DeferredLayerUpdater.h> |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 21 | #include <LayerUpdateQueue.h> |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 22 | #include <OpReorderer.h> |
| 23 | #include <RecordedOp.h> |
| 24 | #include <RecordingCanvas.h> |
Chris Craik | 8160f20 | 2015-12-02 14:50:25 -0800 | [diff] [blame] | 25 | #include <tests/common/TestUtils.h> |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 26 | |
| 27 | #include <unordered_map> |
| 28 | |
| 29 | namespace android { |
| 30 | namespace uirenderer { |
| 31 | |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 32 | const LayerUpdateQueue sEmptyLayerUpdateQueue; |
| 33 | const Vector3 sLightCenter = {100, 100, 100}; |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 34 | |
| 35 | static std::vector<sp<RenderNode>> createSyncedNodeList(sp<RenderNode>& node) { |
| 36 | TestUtils::syncHierarchyPropertiesAndDisplayList(node); |
| 37 | std::vector<sp<RenderNode>> vec; |
| 38 | vec.emplace_back(node); |
| 39 | return vec; |
| 40 | } |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 41 | |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 42 | /** |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 43 | * Virtual class implemented by each test to redirect static operation / state transitions to |
| 44 | * virtual methods. |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 45 | * |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 46 | * Virtual dispatch allows for default behaviors to be specified (very common case in below tests), |
| 47 | * and allows Renderer vs Dispatching behavior to be merged. |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 48 | * |
| 49 | * onXXXOp methods fail by default - tests should override ops they expect |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 50 | * startRepaintLayer fails by default - tests should override if expected |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 51 | * startFrame/endFrame do nothing by default - tests should override to intercept |
| 52 | */ |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 53 | class TestRendererBase { |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 54 | public: |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 55 | virtual ~TestRendererBase() {} |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 56 | virtual OffscreenBuffer* startTemporaryLayer(uint32_t, uint32_t) { |
Chris Craik | a6ac95e | 2015-11-02 18:06:59 -0800 | [diff] [blame] | 57 | ADD_FAILURE() << "Layer creation not expected in this test"; |
| 58 | return nullptr; |
| 59 | } |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 60 | virtual void startRepaintLayer(OffscreenBuffer*, const Rect& repaintRect) { |
Chris Craik | a6ac95e | 2015-11-02 18:06:59 -0800 | [diff] [blame] | 61 | ADD_FAILURE() << "Layer repaint not expected in this test"; |
| 62 | } |
| 63 | virtual void endLayer() { |
| 64 | ADD_FAILURE() << "Layer updates not expected in this test"; |
| 65 | } |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 66 | virtual void startFrame(uint32_t width, uint32_t height, const Rect& repaintRect) {} |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 67 | virtual void endFrame(const Rect& repaintRect) {} |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 68 | |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 69 | // define virtual defaults for single draw methods |
| 70 | #define X(Type) \ |
Chris Craik | a6ac95e | 2015-11-02 18:06:59 -0800 | [diff] [blame] | 71 | virtual void on##Type(const Type&, const BakedOpState&) { \ |
| 72 | ADD_FAILURE() << #Type " not expected in this test"; \ |
| 73 | } |
Chris Craik | 7cbf63d | 2016-01-06 13:46:52 -0800 | [diff] [blame] | 74 | MAP_RENDERABLE_OPS(X) |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 75 | #undef X |
| 76 | |
| 77 | // define virtual defaults for merged draw methods |
| 78 | #define X(Type) \ |
| 79 | virtual void onMerged##Type##s(const MergedBakedOpList& opList) { \ |
| 80 | ADD_FAILURE() << "Merged " #Type "s not expected in this test"; \ |
| 81 | } |
Chris Craik | 7cbf63d | 2016-01-06 13:46:52 -0800 | [diff] [blame] | 82 | MAP_MERGEABLE_OPS(X) |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 83 | #undef X |
| 84 | |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 85 | int getIndex() { return mIndex; } |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 86 | |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 87 | protected: |
| 88 | int mIndex = 0; |
| 89 | }; |
| 90 | |
| 91 | /** |
| 92 | * Dispatches all static methods to similar formed methods on renderer, which fail by default but |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 93 | * are overridden by subclasses per test. |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 94 | */ |
| 95 | class TestDispatcher { |
| 96 | public: |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 97 | // define single op methods, which redirect to TestRendererBase |
| 98 | #define X(Type) \ |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 99 | static void on##Type(TestRendererBase& renderer, const Type& op, const BakedOpState& state) { \ |
| 100 | renderer.on##Type(op, state); \ |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 101 | } |
Chris Craik | 7cbf63d | 2016-01-06 13:46:52 -0800 | [diff] [blame] | 102 | MAP_RENDERABLE_OPS(X); |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 103 | #undef X |
| 104 | |
| 105 | // define merged op methods, which redirect to TestRendererBase |
| 106 | #define X(Type) \ |
| 107 | static void onMerged##Type##s(TestRendererBase& renderer, const MergedBakedOpList& opList) { \ |
| 108 | renderer.onMerged##Type##s(opList); \ |
| 109 | } |
Chris Craik | 7cbf63d | 2016-01-06 13:46:52 -0800 | [diff] [blame] | 110 | MAP_MERGEABLE_OPS(X); |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 111 | #undef X |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 112 | }; |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 113 | |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 114 | class FailRenderer : public TestRendererBase {}; |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 115 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 116 | TEST(OpReorderer, simple) { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 117 | class SimpleTestRenderer : public TestRendererBase { |
| 118 | public: |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 119 | void startFrame(uint32_t width, uint32_t height, const Rect& repaintRect) override { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 120 | EXPECT_EQ(0, mIndex++); |
| 121 | EXPECT_EQ(100u, width); |
| 122 | EXPECT_EQ(200u, height); |
| 123 | } |
| 124 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 125 | EXPECT_EQ(1, mIndex++); |
| 126 | } |
| 127 | void onBitmapOp(const BitmapOp& op, const BakedOpState& state) override { |
| 128 | EXPECT_EQ(2, mIndex++); |
| 129 | } |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 130 | void endFrame(const Rect& repaintRect) override { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 131 | EXPECT_EQ(3, mIndex++); |
| 132 | } |
| 133 | }; |
| 134 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 135 | auto node = TestUtils::createNode(0, 0, 100, 200, |
| 136 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 137 | SkBitmap bitmap = TestUtils::createSkBitmap(25, 25); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 138 | canvas.drawRect(0, 0, 100, 200, SkPaint()); |
| 139 | canvas.drawBitmap(bitmap, 10, 10, nullptr); |
| 140 | }); |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 141 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 200), 100, 200, |
| 142 | createSyncedNodeList(node), sLightCenter); |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 143 | SimpleTestRenderer renderer; |
| 144 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 145 | EXPECT_EQ(4, renderer.getIndex()); // 2 ops + start + end |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 146 | } |
| 147 | |
Chris Craik | 386aa03 | 2015-12-07 17:08:25 -0800 | [diff] [blame] | 148 | TEST(OpReorderer, simpleStroke) { |
| 149 | class SimpleStrokeTestRenderer : public TestRendererBase { |
| 150 | public: |
| 151 | void onPointsOp(const PointsOp& op, const BakedOpState& state) override { |
| 152 | EXPECT_EQ(0, mIndex++); |
| 153 | // even though initial bounds are empty... |
| 154 | EXPECT_TRUE(op.unmappedBounds.isEmpty()) |
| 155 | << "initial bounds should be empty, since they're unstroked"; |
| 156 | EXPECT_EQ(Rect(45, 45, 55, 55), state.computedState.clippedBounds) |
| 157 | << "final bounds should account for stroke"; |
| 158 | } |
| 159 | }; |
| 160 | |
| 161 | auto node = TestUtils::createNode(0, 0, 100, 200, |
| 162 | [](RenderProperties& props, RecordingCanvas& canvas) { |
| 163 | SkPaint strokedPaint; |
| 164 | strokedPaint.setStrokeWidth(10); |
| 165 | canvas.drawPoint(50, 50, strokedPaint); |
| 166 | }); |
| 167 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 200), 100, 200, |
| 168 | createSyncedNodeList(node), sLightCenter); |
| 169 | SimpleStrokeTestRenderer renderer; |
| 170 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 171 | EXPECT_EQ(1, renderer.getIndex()); |
| 172 | } |
| 173 | |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 174 | TEST(OpReorderer, simpleRejection) { |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 175 | auto node = TestUtils::createNode(0, 0, 200, 200, |
| 176 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 177 | canvas.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); |
| 178 | canvas.clipRect(200, 200, 400, 400, SkRegion::kIntersect_Op); // intersection should be empty |
| 179 | canvas.drawRect(0, 0, 400, 400, SkPaint()); |
| 180 | canvas.restore(); |
| 181 | }); |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 182 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 183 | createSyncedNodeList(node), sLightCenter); |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 184 | |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 185 | FailRenderer renderer; |
| 186 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 187 | } |
| 188 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 189 | TEST(OpReorderer, simpleBatching) { |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 190 | const int LOOPS = 5; |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 191 | class SimpleBatchingTestRenderer : public TestRendererBase { |
| 192 | public: |
| 193 | void onBitmapOp(const BitmapOp& op, const BakedOpState& state) override { |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 194 | EXPECT_TRUE(mIndex++ >= LOOPS) << "Bitmaps should be above all rects"; |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 195 | } |
| 196 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 197 | EXPECT_TRUE(mIndex++ < LOOPS) << "Rects should be below all bitmaps"; |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 198 | } |
| 199 | }; |
| 200 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 201 | auto node = TestUtils::createNode(0, 0, 200, 200, |
| 202 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 203 | SkBitmap bitmap = TestUtils::createSkBitmap(10, 10, |
| 204 | kAlpha_8_SkColorType); // Disable merging by using alpha 8 bitmap |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 205 | |
| 206 | // Alternate between drawing rects and bitmaps, with bitmaps overlapping rects. |
| 207 | // Rects don't overlap bitmaps, so bitmaps should be brought to front as a group. |
| 208 | canvas.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 209 | for (int i = 0; i < LOOPS; i++) { |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 210 | canvas.translate(0, 10); |
| 211 | canvas.drawRect(0, 0, 10, 10, SkPaint()); |
| 212 | canvas.drawBitmap(bitmap, 5, 0, nullptr); |
| 213 | } |
| 214 | canvas.restore(); |
| 215 | }); |
| 216 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 217 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 218 | createSyncedNodeList(node), sLightCenter); |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 219 | SimpleBatchingTestRenderer renderer; |
| 220 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 221 | EXPECT_EQ(2 * LOOPS, renderer.getIndex()) |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 222 | << "Expect number of ops = 2 * loop count"; |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 223 | } |
| 224 | |
Chris Craik | 93e53e0 | 2015-12-17 18:42:44 -0800 | [diff] [blame] | 225 | TEST(OpReorderer, clippedMerging) { |
| 226 | class ClippedMergingTestRenderer : public TestRendererBase { |
| 227 | public: |
| 228 | void onMergedBitmapOps(const MergedBakedOpList& opList) override { |
| 229 | EXPECT_EQ(0, mIndex); |
| 230 | mIndex += opList.count; |
| 231 | EXPECT_EQ(4u, opList.count); |
| 232 | EXPECT_EQ(Rect(10, 10, 90, 90), opList.clip); |
| 233 | EXPECT_EQ(OpClipSideFlags::Left | OpClipSideFlags::Top | OpClipSideFlags::Right, |
| 234 | opList.clipSideFlags); |
| 235 | } |
| 236 | }; |
| 237 | auto node = TestUtils::createNode(0, 0, 100, 100, |
| 238 | [](RenderProperties& props, TestCanvas& canvas) { |
| 239 | SkBitmap bitmap = TestUtils::createSkBitmap(20, 20); |
| 240 | |
| 241 | // left side clipped (to inset left half) |
| 242 | canvas.clipRect(10, 0, 50, 100, SkRegion::kReplace_Op); |
| 243 | canvas.drawBitmap(bitmap, 0, 40, nullptr); |
| 244 | |
| 245 | // top side clipped (to inset top half) |
| 246 | canvas.clipRect(0, 10, 100, 50, SkRegion::kReplace_Op); |
| 247 | canvas.drawBitmap(bitmap, 40, 0, nullptr); |
| 248 | |
| 249 | // right side clipped (to inset right half) |
| 250 | canvas.clipRect(50, 0, 90, 100, SkRegion::kReplace_Op); |
| 251 | canvas.drawBitmap(bitmap, 80, 40, nullptr); |
| 252 | |
| 253 | // bottom not clipped, just abutting (inset bottom half) |
| 254 | canvas.clipRect(0, 50, 100, 90, SkRegion::kReplace_Op); |
| 255 | canvas.drawBitmap(bitmap, 40, 70, nullptr); |
| 256 | }); |
| 257 | |
| 258 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 100, 100, |
| 259 | createSyncedNodeList(node), sLightCenter); |
| 260 | ClippedMergingTestRenderer renderer; |
| 261 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 262 | EXPECT_EQ(4, renderer.getIndex()); |
| 263 | } |
| 264 | |
Chris Craik | d7448e6 | 2015-12-15 10:34:36 -0800 | [diff] [blame] | 265 | TEST(OpReorderer, textMerging) { |
| 266 | class TextMergingTestRenderer : public TestRendererBase { |
| 267 | public: |
| 268 | void onMergedTextOps(const MergedBakedOpList& opList) override { |
| 269 | EXPECT_EQ(0, mIndex); |
| 270 | mIndex += opList.count; |
| 271 | EXPECT_EQ(2u, opList.count); |
| 272 | EXPECT_EQ(OpClipSideFlags::Top, opList.clipSideFlags); |
| 273 | EXPECT_EQ(OpClipSideFlags::Top, opList.states[0]->computedState.clipSideFlags); |
| 274 | EXPECT_EQ(OpClipSideFlags::None, opList.states[1]->computedState.clipSideFlags); |
| 275 | } |
| 276 | }; |
| 277 | auto node = TestUtils::createNode(0, 0, 400, 400, |
| 278 | [](RenderProperties& props, TestCanvas& canvas) { |
| 279 | SkPaint paint; |
| 280 | paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); |
| 281 | paint.setAntiAlias(true); |
| 282 | paint.setTextSize(50); |
| 283 | TestUtils::drawTextToCanvas(&canvas, "Test string1", paint, 100, 0); // will be top clipped |
| 284 | TestUtils::drawTextToCanvas(&canvas, "Test string1", paint, 100, 100); // not clipped |
| 285 | }); |
| 286 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(400, 400), 400, 400, |
| 287 | createSyncedNodeList(node), sLightCenter); |
| 288 | TextMergingTestRenderer renderer; |
| 289 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 290 | EXPECT_EQ(2, renderer.getIndex()) << "Expect 2 ops"; |
| 291 | } |
| 292 | |
| 293 | TEST(OpReorderer, textStrikethrough) { |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 294 | const int LOOPS = 5; |
| 295 | class TextStrikethroughTestRenderer : public TestRendererBase { |
| 296 | public: |
| 297 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 298 | EXPECT_TRUE(mIndex++ >= LOOPS) << "Strikethrough rects should be above all text"; |
| 299 | } |
Chris Craik | 15c3f19 | 2015-12-03 12:16:56 -0800 | [diff] [blame] | 300 | void onMergedTextOps(const MergedBakedOpList& opList) override { |
| 301 | EXPECT_EQ(0, mIndex); |
| 302 | mIndex += opList.count; |
| 303 | EXPECT_EQ(5u, opList.count); |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 304 | } |
| 305 | }; |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 306 | auto node = TestUtils::createNode(0, 0, 200, 2000, |
| 307 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 308 | SkPaint textPaint; |
| 309 | textPaint.setAntiAlias(true); |
| 310 | textPaint.setTextSize(20); |
| 311 | textPaint.setStrikeThruText(true); |
Chris Craik | 42a5407 | 2015-11-24 11:41:54 -0800 | [diff] [blame] | 312 | textPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 313 | for (int i = 0; i < LOOPS; i++) { |
| 314 | TestUtils::drawTextToCanvas(&canvas, "test text", textPaint, 10, 100 * (i + 1)); |
| 315 | } |
| 316 | }); |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 317 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 2000), 200, 2000, |
| 318 | createSyncedNodeList(node), sLightCenter); |
Chris Craik | a171727 | 2015-11-19 13:02:43 -0800 | [diff] [blame] | 319 | TextStrikethroughTestRenderer renderer; |
| 320 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 321 | EXPECT_EQ(2 * LOOPS, renderer.getIndex()) |
Chris Craik | d7448e6 | 2015-12-15 10:34:36 -0800 | [diff] [blame] | 322 | << "Expect number of ops = 2 * loop count"; |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 323 | } |
| 324 | |
Chris Craik | d2dfd8f | 2015-12-16 14:27:20 -0800 | [diff] [blame] | 325 | RENDERTHREAD_TEST(OpReorderer, textureLayer) { |
| 326 | class TextureLayerTestRenderer : public TestRendererBase { |
| 327 | public: |
| 328 | void onTextureLayerOp(const TextureLayerOp& op, const BakedOpState& state) override { |
| 329 | EXPECT_EQ(0, mIndex++); |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 330 | EXPECT_EQ(Rect(50, 50, 150, 150), state.computedState.clipRect()); |
Chris Craik | d2dfd8f | 2015-12-16 14:27:20 -0800 | [diff] [blame] | 331 | EXPECT_EQ(Rect(50, 50, 105, 105), state.computedState.clippedBounds); |
| 332 | |
| 333 | Matrix4 expected; |
| 334 | expected.loadTranslate(5, 5, 0); |
| 335 | EXPECT_MATRIX_APPROX_EQ(expected, state.computedState.transform); |
| 336 | } |
| 337 | }; |
| 338 | |
| 339 | auto layerUpdater = TestUtils::createTextureLayerUpdater(renderThread, 100, 100, |
| 340 | [](Matrix4* transform) { |
| 341 | transform->loadTranslate(5, 5, 0); |
| 342 | }); |
| 343 | |
| 344 | auto node = TestUtils::createNode(0, 0, 200, 200, |
| 345 | [&layerUpdater](RenderProperties& props, RecordingCanvas& canvas) { |
| 346 | canvas.save(SkCanvas::kMatrixClip_SaveFlag); |
| 347 | canvas.clipRect(50, 50, 150, 150, SkRegion::kIntersect_Op); |
| 348 | canvas.drawLayer(layerUpdater.get()); |
| 349 | canvas.restore(); |
| 350 | }); |
| 351 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 352 | createSyncedNodeList(node), sLightCenter); |
| 353 | TextureLayerTestRenderer renderer; |
| 354 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 355 | EXPECT_EQ(1, renderer.getIndex()); |
| 356 | } |
| 357 | |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 358 | TEST(OpReorderer, renderNode) { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 359 | class RenderNodeTestRenderer : public TestRendererBase { |
| 360 | public: |
| 361 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 362 | switch(mIndex++) { |
| 363 | case 0: |
Chris Craik | 5430ab2 | 2015-12-10 16:28:16 -0800 | [diff] [blame] | 364 | EXPECT_EQ(Rect(200, 200), state.computedState.clippedBounds); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 365 | EXPECT_EQ(SK_ColorDKGRAY, op.paint->getColor()); |
| 366 | break; |
| 367 | case 1: |
| 368 | EXPECT_EQ(Rect(50, 50, 150, 150), state.computedState.clippedBounds); |
| 369 | EXPECT_EQ(SK_ColorWHITE, op.paint->getColor()); |
| 370 | break; |
| 371 | default: |
| 372 | ADD_FAILURE(); |
| 373 | } |
| 374 | } |
| 375 | }; |
| 376 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 377 | auto child = TestUtils::createNode(10, 10, 110, 110, |
| 378 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 379 | SkPaint paint; |
| 380 | paint.setColor(SK_ColorWHITE); |
| 381 | canvas.drawRect(0, 0, 100, 100, paint); |
| 382 | }); |
| 383 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 384 | auto parent = TestUtils::createNode(0, 0, 200, 200, |
Chris Craik | d2dfd8f | 2015-12-16 14:27:20 -0800 | [diff] [blame] | 385 | [&child](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 386 | SkPaint paint; |
| 387 | paint.setColor(SK_ColorDKGRAY); |
| 388 | canvas.drawRect(0, 0, 200, 200, paint); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 389 | |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 390 | canvas.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); |
| 391 | canvas.translate(40, 40); |
Chris Craik | d2dfd8f | 2015-12-16 14:27:20 -0800 | [diff] [blame] | 392 | canvas.drawRenderNode(child.get()); |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 393 | canvas.restore(); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 394 | }); |
| 395 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 396 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 397 | createSyncedNodeList(parent), sLightCenter); |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 398 | RenderNodeTestRenderer renderer; |
| 399 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 400 | } |
| 401 | |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 402 | TEST(OpReorderer, clipped) { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 403 | class ClippedTestRenderer : public TestRendererBase { |
| 404 | public: |
| 405 | void onBitmapOp(const BitmapOp& op, const BakedOpState& state) override { |
| 406 | EXPECT_EQ(0, mIndex++); |
| 407 | EXPECT_EQ(Rect(10, 20, 30, 40), state.computedState.clippedBounds); |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 408 | EXPECT_EQ(Rect(10, 20, 30, 40), state.computedState.clipRect()); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 409 | EXPECT_TRUE(state.computedState.transform.isIdentity()); |
| 410 | } |
| 411 | }; |
| 412 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 413 | auto node = TestUtils::createNode(0, 0, 200, 200, |
| 414 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 415 | SkBitmap bitmap = TestUtils::createSkBitmap(200, 200); |
| 416 | canvas.drawBitmap(bitmap, 0, 0, nullptr); |
| 417 | }); |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 418 | |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 419 | OpReorderer reorderer(sEmptyLayerUpdateQueue, |
| 420 | SkRect::MakeLTRB(10, 20, 30, 40), // clip to small area, should see in receiver |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 421 | 200, 200, createSyncedNodeList(node), sLightCenter); |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 422 | ClippedTestRenderer renderer; |
| 423 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
Chris Craik | ddf2215 | 2015-10-14 17:42:47 -0700 | [diff] [blame] | 424 | } |
| 425 | |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 426 | TEST(OpReorderer, saveLayerSimple) { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 427 | class SaveLayerSimpleTestRenderer : public TestRendererBase { |
| 428 | public: |
| 429 | OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height) override { |
| 430 | EXPECT_EQ(0, mIndex++); |
| 431 | EXPECT_EQ(180u, width); |
| 432 | EXPECT_EQ(180u, height); |
| 433 | return nullptr; |
| 434 | } |
| 435 | void endLayer() override { |
| 436 | EXPECT_EQ(2, mIndex++); |
| 437 | } |
| 438 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 439 | EXPECT_EQ(1, mIndex++); |
| 440 | EXPECT_EQ(Rect(10, 10, 190, 190), op.unmappedBounds); |
Chris Craik | 5430ab2 | 2015-12-10 16:28:16 -0800 | [diff] [blame] | 441 | EXPECT_EQ(Rect(180, 180), state.computedState.clippedBounds); |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 442 | EXPECT_EQ(Rect(180, 180), state.computedState.clipRect()); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 443 | |
| 444 | Matrix4 expectedTransform; |
| 445 | expectedTransform.loadTranslate(-10, -10, 0); |
| 446 | EXPECT_MATRIX_APPROX_EQ(expectedTransform, state.computedState.transform); |
| 447 | } |
| 448 | void onLayerOp(const LayerOp& op, const BakedOpState& state) override { |
| 449 | EXPECT_EQ(3, mIndex++); |
| 450 | EXPECT_EQ(Rect(10, 10, 190, 190), state.computedState.clippedBounds); |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 451 | EXPECT_EQ(Rect(200, 200), state.computedState.clipRect()); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 452 | EXPECT_TRUE(state.computedState.transform.isIdentity()); |
| 453 | } |
| 454 | }; |
| 455 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 456 | auto node = TestUtils::createNode(0, 0, 200, 200, |
| 457 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 458 | canvas.saveLayerAlpha(10, 10, 190, 190, 128, SkCanvas::kClipToLayer_SaveFlag); |
| 459 | canvas.drawRect(10, 10, 190, 190, SkPaint()); |
| 460 | canvas.restore(); |
| 461 | }); |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 462 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 463 | createSyncedNodeList(node), sLightCenter); |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 464 | SaveLayerSimpleTestRenderer renderer; |
| 465 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 466 | EXPECT_EQ(4, renderer.getIndex()); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 467 | } |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 468 | |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 469 | TEST(OpReorderer, saveLayerNested) { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 470 | /* saveLayer1 { rect1, saveLayer2 { rect2 } } will play back as: |
| 471 | * - startTemporaryLayer2, rect2 endLayer2 |
| 472 | * - startTemporaryLayer1, rect1, drawLayer2, endLayer1 |
| 473 | * - startFrame, layerOp1, endFrame |
| 474 | */ |
| 475 | class SaveLayerNestedTestRenderer : public TestRendererBase { |
| 476 | public: |
| 477 | OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height) override { |
| 478 | const int index = mIndex++; |
| 479 | if (index == 0) { |
| 480 | EXPECT_EQ(400u, width); |
| 481 | EXPECT_EQ(400u, height); |
| 482 | return (OffscreenBuffer*) 0x400; |
| 483 | } else if (index == 3) { |
| 484 | EXPECT_EQ(800u, width); |
| 485 | EXPECT_EQ(800u, height); |
| 486 | return (OffscreenBuffer*) 0x800; |
| 487 | } else { ADD_FAILURE(); } |
| 488 | return (OffscreenBuffer*) nullptr; |
| 489 | } |
| 490 | void endLayer() override { |
| 491 | int index = mIndex++; |
| 492 | EXPECT_TRUE(index == 2 || index == 6); |
| 493 | } |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 494 | void startFrame(uint32_t width, uint32_t height, const Rect& repaintRect) override { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 495 | EXPECT_EQ(7, mIndex++); |
| 496 | } |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 497 | void endFrame(const Rect& repaintRect) override { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 498 | EXPECT_EQ(9, mIndex++); |
| 499 | } |
| 500 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 501 | const int index = mIndex++; |
| 502 | if (index == 1) { |
Chris Craik | 5430ab2 | 2015-12-10 16:28:16 -0800 | [diff] [blame] | 503 | EXPECT_EQ(Rect(400, 400), op.unmappedBounds); // inner rect |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 504 | } else if (index == 4) { |
Chris Craik | 5430ab2 | 2015-12-10 16:28:16 -0800 | [diff] [blame] | 505 | EXPECT_EQ(Rect(800, 800), op.unmappedBounds); // outer rect |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 506 | } else { ADD_FAILURE(); } |
| 507 | } |
| 508 | void onLayerOp(const LayerOp& op, const BakedOpState& state) override { |
| 509 | const int index = mIndex++; |
| 510 | if (index == 5) { |
| 511 | EXPECT_EQ((OffscreenBuffer*)0x400, *op.layerHandle); |
Chris Craik | 5430ab2 | 2015-12-10 16:28:16 -0800 | [diff] [blame] | 512 | EXPECT_EQ(Rect(400, 400), op.unmappedBounds); // inner layer |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 513 | } else if (index == 8) { |
| 514 | EXPECT_EQ((OffscreenBuffer*)0x800, *op.layerHandle); |
Chris Craik | 5430ab2 | 2015-12-10 16:28:16 -0800 | [diff] [blame] | 515 | EXPECT_EQ(Rect(800, 800), op.unmappedBounds); // outer layer |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 516 | } else { ADD_FAILURE(); } |
| 517 | } |
| 518 | }; |
| 519 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 520 | auto node = TestUtils::createNode(0, 0, 800, 800, |
| 521 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 522 | canvas.saveLayerAlpha(0, 0, 800, 800, 128, SkCanvas::kClipToLayer_SaveFlag); |
| 523 | { |
| 524 | canvas.drawRect(0, 0, 800, 800, SkPaint()); |
| 525 | canvas.saveLayerAlpha(0, 0, 400, 400, 128, SkCanvas::kClipToLayer_SaveFlag); |
| 526 | { |
| 527 | canvas.drawRect(0, 0, 400, 400, SkPaint()); |
| 528 | } |
| 529 | canvas.restore(); |
| 530 | } |
| 531 | canvas.restore(); |
| 532 | }); |
| 533 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 534 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(800, 800), 800, 800, |
| 535 | createSyncedNodeList(node), sLightCenter); |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 536 | SaveLayerNestedTestRenderer renderer; |
| 537 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 538 | EXPECT_EQ(10, renderer.getIndex()); |
Chris Craik | b565df1 | 2015-10-05 13:00:52 -0700 | [diff] [blame] | 539 | } |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 540 | |
| 541 | TEST(OpReorderer, saveLayerContentRejection) { |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 542 | auto node = TestUtils::createNode(0, 0, 200, 200, |
| 543 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 544 | canvas.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); |
| 545 | canvas.clipRect(200, 200, 400, 400, SkRegion::kIntersect_Op); |
| 546 | canvas.saveLayerAlpha(200, 200, 400, 400, 128, SkCanvas::kClipToLayer_SaveFlag); |
| 547 | |
| 548 | // draw within save layer may still be recorded, but shouldn't be drawn |
| 549 | canvas.drawRect(200, 200, 400, 400, SkPaint()); |
| 550 | |
| 551 | canvas.restore(); |
| 552 | canvas.restore(); |
| 553 | }); |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 554 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 555 | createSyncedNodeList(node), sLightCenter); |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 556 | |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 557 | FailRenderer renderer; |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 558 | // should see no ops, even within the layer, since the layer should be rejected |
Chris Craik | 5854b34 | 2015-10-26 15:49:56 -0700 | [diff] [blame] | 559 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 560 | } |
| 561 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 562 | RENDERTHREAD_TEST(OpReorderer, hwLayerSimple) { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 563 | class HwLayerSimpleTestRenderer : public TestRendererBase { |
| 564 | public: |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 565 | void startRepaintLayer(OffscreenBuffer* offscreenBuffer, const Rect& repaintRect) override { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 566 | EXPECT_EQ(0, mIndex++); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 567 | EXPECT_EQ(100u, offscreenBuffer->viewportWidth); |
| 568 | EXPECT_EQ(100u, offscreenBuffer->viewportHeight); |
| 569 | EXPECT_EQ(Rect(25, 25, 75, 75), repaintRect); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 570 | } |
| 571 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 572 | EXPECT_EQ(1, mIndex++); |
| 573 | |
| 574 | EXPECT_TRUE(state.computedState.transform.isIdentity()) |
| 575 | << "Transform should be reset within layer"; |
| 576 | |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 577 | EXPECT_EQ(Rect(25, 25, 75, 75), state.computedState.clipRect()) |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 578 | << "Damage rect should be used to clip layer content"; |
| 579 | } |
| 580 | void endLayer() override { |
| 581 | EXPECT_EQ(2, mIndex++); |
| 582 | } |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 583 | void startFrame(uint32_t width, uint32_t height, const Rect& repaintRect) override { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 584 | EXPECT_EQ(3, mIndex++); |
| 585 | } |
| 586 | void onLayerOp(const LayerOp& op, const BakedOpState& state) override { |
| 587 | EXPECT_EQ(4, mIndex++); |
| 588 | } |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 589 | void endFrame(const Rect& repaintRect) override { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 590 | EXPECT_EQ(5, mIndex++); |
| 591 | } |
| 592 | }; |
| 593 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 594 | auto node = TestUtils::createNode(10, 10, 110, 110, |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 595 | [](RenderProperties& props, RecordingCanvas& canvas) { |
| 596 | props.mutateLayerProperties().setType(LayerType::RenderLayer); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 597 | SkPaint paint; |
| 598 | paint.setColor(SK_ColorWHITE); |
| 599 | canvas.drawRect(0, 0, 100, 100, paint); |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 600 | }); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 601 | OffscreenBuffer** layerHandle = node->getLayerHandle(); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 602 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 603 | // create RenderNode's layer here in same way prepareTree would |
| 604 | OffscreenBuffer layer(renderThread.renderState(), Caches::getInstance(), 100, 100); |
| 605 | *layerHandle = &layer; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 606 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 607 | auto syncedNodeList = createSyncedNodeList(node); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 608 | |
| 609 | // only enqueue partial damage |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 610 | LayerUpdateQueue layerUpdateQueue; // Note: enqueue damage post-sync, so bounds are valid |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 611 | layerUpdateQueue.enqueueLayerWithDamage(node.get(), Rect(25, 25, 75, 75)); |
| 612 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 613 | OpReorderer reorderer(layerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 614 | syncedNodeList, sLightCenter); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 615 | HwLayerSimpleTestRenderer renderer; |
| 616 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 617 | EXPECT_EQ(6, renderer.getIndex()); |
| 618 | |
| 619 | // clean up layer pointer, so we can safely destruct RenderNode |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 620 | *layerHandle = nullptr; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 621 | } |
| 622 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 623 | RENDERTHREAD_TEST(OpReorderer, hwLayerComplex) { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 624 | /* parentLayer { greyRect, saveLayer { childLayer { whiteRect } } } will play back as: |
| 625 | * - startRepaintLayer(child), rect(grey), endLayer |
| 626 | * - startTemporaryLayer, drawLayer(child), endLayer |
| 627 | * - startRepaintLayer(parent), rect(white), drawLayer(saveLayer), endLayer |
| 628 | * - startFrame, drawLayer(parent), endLayerb |
| 629 | */ |
| 630 | class HwLayerComplexTestRenderer : public TestRendererBase { |
| 631 | public: |
| 632 | OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height) { |
| 633 | EXPECT_EQ(3, mIndex++); // savelayer first |
| 634 | return (OffscreenBuffer*)0xabcd; |
| 635 | } |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 636 | void startRepaintLayer(OffscreenBuffer* offscreenBuffer, const Rect& repaintRect) override { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 637 | int index = mIndex++; |
| 638 | if (index == 0) { |
| 639 | // starting inner layer |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 640 | EXPECT_EQ(100u, offscreenBuffer->viewportWidth); |
| 641 | EXPECT_EQ(100u, offscreenBuffer->viewportHeight); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 642 | } else if (index == 6) { |
| 643 | // starting outer layer |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 644 | EXPECT_EQ(200u, offscreenBuffer->viewportWidth); |
| 645 | EXPECT_EQ(200u, offscreenBuffer->viewportHeight); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 646 | } else { ADD_FAILURE(); } |
| 647 | } |
| 648 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 649 | int index = mIndex++; |
| 650 | if (index == 1) { |
| 651 | // inner layer's rect (white) |
| 652 | EXPECT_EQ(SK_ColorWHITE, op.paint->getColor()); |
| 653 | } else if (index == 7) { |
| 654 | // outer layer's rect (grey) |
| 655 | EXPECT_EQ(SK_ColorDKGRAY, op.paint->getColor()); |
| 656 | } else { ADD_FAILURE(); } |
| 657 | } |
| 658 | void endLayer() override { |
| 659 | int index = mIndex++; |
| 660 | EXPECT_TRUE(index == 2 || index == 5 || index == 9); |
| 661 | } |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 662 | void startFrame(uint32_t width, uint32_t height, const Rect& repaintRect) override { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 663 | EXPECT_EQ(10, mIndex++); |
| 664 | } |
| 665 | void onLayerOp(const LayerOp& op, const BakedOpState& state) override { |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 666 | OffscreenBuffer* layer = *op.layerHandle; |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 667 | int index = mIndex++; |
| 668 | if (index == 4) { |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 669 | EXPECT_EQ(100u, layer->viewportWidth); |
| 670 | EXPECT_EQ(100u, layer->viewportHeight); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 671 | } else if (index == 8) { |
| 672 | EXPECT_EQ((OffscreenBuffer*)0xabcd, *op.layerHandle); |
| 673 | } else if (index == 11) { |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 674 | EXPECT_EQ(200u, layer->viewportWidth); |
| 675 | EXPECT_EQ(200u, layer->viewportHeight); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 676 | } else { ADD_FAILURE(); } |
| 677 | } |
Chris Craik | e4db79d | 2015-12-22 16:32:23 -0800 | [diff] [blame] | 678 | void endFrame(const Rect& repaintRect) override { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 679 | EXPECT_EQ(12, mIndex++); |
| 680 | } |
| 681 | }; |
| 682 | |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 683 | auto child = TestUtils::createNode(50, 50, 150, 150, |
| 684 | [](RenderProperties& props, RecordingCanvas& canvas) { |
| 685 | props.mutateLayerProperties().setType(LayerType::RenderLayer); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 686 | SkPaint paint; |
| 687 | paint.setColor(SK_ColorWHITE); |
| 688 | canvas.drawRect(0, 0, 100, 100, paint); |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 689 | }); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 690 | OffscreenBuffer childLayer(renderThread.renderState(), Caches::getInstance(), 100, 100); |
| 691 | *(child->getLayerHandle()) = &childLayer; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 692 | |
| 693 | RenderNode* childPtr = child.get(); |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 694 | auto parent = TestUtils::createNode(0, 0, 200, 200, |
| 695 | [childPtr](RenderProperties& props, RecordingCanvas& canvas) { |
| 696 | props.mutateLayerProperties().setType(LayerType::RenderLayer); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 697 | SkPaint paint; |
| 698 | paint.setColor(SK_ColorDKGRAY); |
| 699 | canvas.drawRect(0, 0, 200, 200, paint); |
| 700 | |
| 701 | canvas.saveLayerAlpha(50, 50, 150, 150, 128, SkCanvas::kClipToLayer_SaveFlag); |
| 702 | canvas.drawRenderNode(childPtr); |
| 703 | canvas.restore(); |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 704 | }); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 705 | OffscreenBuffer parentLayer(renderThread.renderState(), Caches::getInstance(), 200, 200); |
| 706 | *(parent->getLayerHandle()) = &parentLayer; |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 707 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 708 | auto syncedList = createSyncedNodeList(parent); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 709 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 710 | LayerUpdateQueue layerUpdateQueue; // Note: enqueue damage post-sync, so bounds are valid |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 711 | layerUpdateQueue.enqueueLayerWithDamage(child.get(), Rect(100, 100)); |
| 712 | layerUpdateQueue.enqueueLayerWithDamage(parent.get(), Rect(200, 200)); |
| 713 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 714 | OpReorderer reorderer(layerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 715 | syncedList, sLightCenter); |
Chris Craik | 0b7e824 | 2015-10-28 16:50:44 -0700 | [diff] [blame] | 716 | HwLayerComplexTestRenderer renderer; |
| 717 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 718 | EXPECT_EQ(13, renderer.getIndex()); |
| 719 | |
| 720 | // clean up layer pointers, so we can safely destruct RenderNodes |
| 721 | *(child->getLayerHandle()) = nullptr; |
| 722 | *(parent->getLayerHandle()) = nullptr; |
| 723 | } |
| 724 | |
Chris Craik | 161f54b | 2015-11-05 11:08:52 -0800 | [diff] [blame] | 725 | static void drawOrderedRect(RecordingCanvas* canvas, uint8_t expectedDrawOrder) { |
| 726 | SkPaint paint; |
| 727 | paint.setColor(SkColorSetARGB(256, 0, 0, expectedDrawOrder)); // order put in blue channel |
| 728 | canvas->drawRect(0, 0, 100, 100, paint); |
| 729 | } |
| 730 | static void drawOrderedNode(RecordingCanvas* canvas, uint8_t expectedDrawOrder, float z) { |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 731 | auto node = TestUtils::createNode(0, 0, 100, 100, |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 732 | [expectedDrawOrder](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | 161f54b | 2015-11-05 11:08:52 -0800 | [diff] [blame] | 733 | drawOrderedRect(&canvas, expectedDrawOrder); |
| 734 | }); |
| 735 | node->mutateStagingProperties().setTranslationZ(z); |
| 736 | node->setPropertyFieldsDirty(RenderNode::TRANSLATION_Z); |
| 737 | canvas->drawRenderNode(node.get()); // canvas takes reference/sole ownership |
| 738 | } |
| 739 | TEST(OpReorderer, zReorder) { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 740 | class ZReorderTestRenderer : public TestRendererBase { |
| 741 | public: |
| 742 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 743 | int expectedOrder = SkColorGetB(op.paint->getColor()); // extract order from blue channel |
| 744 | EXPECT_EQ(expectedOrder, mIndex++) << "An op was drawn out of order"; |
| 745 | } |
| 746 | }; |
| 747 | |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 748 | auto parent = TestUtils::createNode(0, 0, 100, 100, |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 749 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | 161f54b | 2015-11-05 11:08:52 -0800 | [diff] [blame] | 750 | drawOrderedNode(&canvas, 0, 10.0f); // in reorder=false at this point, so played inorder |
| 751 | drawOrderedRect(&canvas, 1); |
| 752 | canvas.insertReorderBarrier(true); |
| 753 | drawOrderedNode(&canvas, 6, 2.0f); |
| 754 | drawOrderedRect(&canvas, 3); |
| 755 | drawOrderedNode(&canvas, 4, 0.0f); |
| 756 | drawOrderedRect(&canvas, 5); |
| 757 | drawOrderedNode(&canvas, 2, -2.0f); |
| 758 | drawOrderedNode(&canvas, 7, 2.0f); |
| 759 | canvas.insertReorderBarrier(false); |
| 760 | drawOrderedRect(&canvas, 8); |
| 761 | drawOrderedNode(&canvas, 9, -10.0f); // in reorder=false at this point, so played inorder |
| 762 | }); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 763 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 100, 100, |
| 764 | createSyncedNodeList(parent), sLightCenter); |
Chris Craik | 161f54b | 2015-11-05 11:08:52 -0800 | [diff] [blame] | 765 | ZReorderTestRenderer renderer; |
| 766 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 767 | EXPECT_EQ(10, renderer.getIndex()); |
| 768 | }; |
| 769 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 770 | TEST(OpReorderer, projectionReorder) { |
| 771 | static const int scrollX = 5; |
| 772 | static const int scrollY = 10; |
| 773 | class ProjectionReorderTestRenderer : public TestRendererBase { |
| 774 | public: |
| 775 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 776 | const int index = mIndex++; |
| 777 | |
| 778 | Matrix4 expectedMatrix; |
| 779 | switch (index) { |
| 780 | case 0: |
| 781 | EXPECT_EQ(Rect(100, 100), op.unmappedBounds); |
| 782 | EXPECT_EQ(SK_ColorWHITE, op.paint->getColor()); |
| 783 | expectedMatrix.loadIdentity(); |
| 784 | break; |
| 785 | case 1: |
| 786 | EXPECT_EQ(Rect(-10, -10, 60, 60), op.unmappedBounds); |
| 787 | EXPECT_EQ(SK_ColorDKGRAY, op.paint->getColor()); |
| 788 | expectedMatrix.loadTranslate(50, 50, 0); // TODO: should scroll be respected here? |
| 789 | break; |
| 790 | case 2: |
| 791 | EXPECT_EQ(Rect(100, 50), op.unmappedBounds); |
| 792 | EXPECT_EQ(SK_ColorBLUE, op.paint->getColor()); |
| 793 | expectedMatrix.loadTranslate(-scrollX, 50 - scrollY, 0); |
| 794 | break; |
| 795 | default: |
| 796 | ADD_FAILURE(); |
| 797 | } |
| 798 | EXPECT_MATRIX_APPROX_EQ(expectedMatrix, state.computedState.transform); |
| 799 | } |
| 800 | }; |
| 801 | |
| 802 | /** |
| 803 | * Construct a tree of nodes, where the root (A) has a receiver background (B), and a child (C) |
| 804 | * with a projecting child (P) of its own. P would normally draw between B and C's "background" |
| 805 | * draw, but because it is projected backwards, it's drawn in between B and C. |
| 806 | * |
| 807 | * The parent is scrolled by scrollX/scrollY, but this does not affect the background |
| 808 | * (which isn't affected by scroll). |
| 809 | */ |
| 810 | auto receiverBackground = TestUtils::createNode(0, 0, 100, 100, |
| 811 | [](RenderProperties& properties, RecordingCanvas& canvas) { |
| 812 | properties.setProjectionReceiver(true); |
| 813 | // scroll doesn't apply to background, so undone via translationX/Y |
| 814 | // NOTE: translationX/Y only! no other transform properties may be set for a proj receiver! |
| 815 | properties.setTranslationX(scrollX); |
| 816 | properties.setTranslationY(scrollY); |
| 817 | |
| 818 | SkPaint paint; |
| 819 | paint.setColor(SK_ColorWHITE); |
| 820 | canvas.drawRect(0, 0, 100, 100, paint); |
| 821 | }); |
| 822 | auto projectingRipple = TestUtils::createNode(50, 0, 100, 50, |
| 823 | [](RenderProperties& properties, RecordingCanvas& canvas) { |
| 824 | properties.setProjectBackwards(true); |
| 825 | properties.setClipToBounds(false); |
| 826 | SkPaint paint; |
| 827 | paint.setColor(SK_ColorDKGRAY); |
| 828 | canvas.drawRect(-10, -10, 60, 60, paint); |
| 829 | }); |
| 830 | auto child = TestUtils::createNode(0, 50, 100, 100, |
| 831 | [&projectingRipple](RenderProperties& properties, RecordingCanvas& canvas) { |
| 832 | SkPaint paint; |
| 833 | paint.setColor(SK_ColorBLUE); |
| 834 | canvas.drawRect(0, 0, 100, 50, paint); |
| 835 | canvas.drawRenderNode(projectingRipple.get()); |
| 836 | }); |
| 837 | auto parent = TestUtils::createNode(0, 0, 100, 100, |
| 838 | [&receiverBackground, &child](RenderProperties& properties, RecordingCanvas& canvas) { |
| 839 | canvas.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); |
| 840 | canvas.translate(-scrollX, -scrollY); // Apply scroll (note: bg undoes this internally) |
| 841 | canvas.drawRenderNode(receiverBackground.get()); |
| 842 | canvas.drawRenderNode(child.get()); |
| 843 | canvas.restore(); |
| 844 | }); |
| 845 | |
| 846 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 100, 100, |
| 847 | createSyncedNodeList(parent), sLightCenter); |
| 848 | ProjectionReorderTestRenderer renderer; |
| 849 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 850 | EXPECT_EQ(3, renderer.getIndex()); |
| 851 | } |
| 852 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 853 | // creates a 100x100 shadow casting node with provided translationZ |
| 854 | static sp<RenderNode> createWhiteRectShadowCaster(float translationZ) { |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 855 | return TestUtils::createNode(0, 0, 100, 100, |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 856 | [translationZ](RenderProperties& properties, RecordingCanvas& canvas) { |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 857 | properties.setTranslationZ(translationZ); |
| 858 | properties.mutableOutline().setRoundRect(0, 0, 100, 100, 0.0f, 1.0f); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 859 | SkPaint paint; |
| 860 | paint.setColor(SK_ColorWHITE); |
| 861 | canvas.drawRect(0, 0, 100, 100, paint); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 862 | }); |
| 863 | } |
| 864 | |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 865 | TEST(OpReorderer, shadow) { |
| 866 | class ShadowTestRenderer : public TestRendererBase { |
| 867 | public: |
| 868 | void onShadowOp(const ShadowOp& op, const BakedOpState& state) override { |
| 869 | EXPECT_EQ(0, mIndex++); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 870 | EXPECT_FLOAT_EQ(1.0f, op.casterAlpha); |
| 871 | EXPECT_TRUE(op.casterPath->isRect(nullptr)); |
| 872 | EXPECT_MATRIX_APPROX_EQ(Matrix4::identity(), op.shadowMatrixXY); |
| 873 | |
| 874 | Matrix4 expectedZ; |
| 875 | expectedZ.loadTranslate(0, 0, 5); |
| 876 | EXPECT_MATRIX_APPROX_EQ(expectedZ, op.shadowMatrixZ); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 877 | } |
| 878 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 879 | EXPECT_EQ(1, mIndex++); |
| 880 | } |
| 881 | }; |
Chris Craik | 161f54b | 2015-11-05 11:08:52 -0800 | [diff] [blame] | 882 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 883 | auto parent = TestUtils::createNode(0, 0, 200, 200, |
| 884 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 885 | canvas.insertReorderBarrier(true); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 886 | canvas.drawRenderNode(createWhiteRectShadowCaster(5.0f).get()); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 887 | }); |
| 888 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 889 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 890 | createSyncedNodeList(parent), sLightCenter); |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 891 | ShadowTestRenderer renderer; |
| 892 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 893 | EXPECT_EQ(2, renderer.getIndex()); |
| 894 | } |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 895 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 896 | TEST(OpReorderer, shadowSaveLayer) { |
| 897 | class ShadowSaveLayerTestRenderer : public TestRendererBase { |
| 898 | public: |
| 899 | OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height) override { |
| 900 | EXPECT_EQ(0, mIndex++); |
| 901 | return nullptr; |
| 902 | } |
| 903 | void onShadowOp(const ShadowOp& op, const BakedOpState& state) override { |
| 904 | EXPECT_EQ(1, mIndex++); |
| 905 | EXPECT_FLOAT_EQ(50, op.lightCenter.x); |
| 906 | EXPECT_FLOAT_EQ(40, op.lightCenter.y); |
| 907 | } |
| 908 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 909 | EXPECT_EQ(2, mIndex++); |
| 910 | } |
| 911 | void endLayer() override { |
| 912 | EXPECT_EQ(3, mIndex++); |
| 913 | } |
| 914 | void onLayerOp(const LayerOp& op, const BakedOpState& state) override { |
| 915 | EXPECT_EQ(4, mIndex++); |
| 916 | } |
| 917 | }; |
| 918 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 919 | auto parent = TestUtils::createNode(0, 0, 200, 200, |
| 920 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 921 | // save/restore outside of reorderBarrier, so they don't get moved out of place |
| 922 | canvas.translate(20, 10); |
| 923 | int count = canvas.saveLayerAlpha(30, 50, 130, 150, 128, SkCanvas::kClipToLayer_SaveFlag); |
| 924 | canvas.insertReorderBarrier(true); |
| 925 | canvas.drawRenderNode(createWhiteRectShadowCaster(5.0f).get()); |
| 926 | canvas.insertReorderBarrier(false); |
| 927 | canvas.restoreToCount(count); |
| 928 | }); |
| 929 | |
| 930 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 931 | createSyncedNodeList(parent), (Vector3) { 100, 100, 100 }); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 932 | ShadowSaveLayerTestRenderer renderer; |
| 933 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 934 | EXPECT_EQ(5, renderer.getIndex()); |
| 935 | } |
| 936 | |
| 937 | RENDERTHREAD_TEST(OpReorderer, shadowHwLayer) { |
| 938 | class ShadowHwLayerTestRenderer : public TestRendererBase { |
| 939 | public: |
| 940 | void startRepaintLayer(OffscreenBuffer* offscreenBuffer, const Rect& repaintRect) override { |
| 941 | EXPECT_EQ(0, mIndex++); |
| 942 | } |
| 943 | void onShadowOp(const ShadowOp& op, const BakedOpState& state) override { |
| 944 | EXPECT_EQ(1, mIndex++); |
| 945 | EXPECT_FLOAT_EQ(50, op.lightCenter.x); |
| 946 | EXPECT_FLOAT_EQ(40, op.lightCenter.y); |
| 947 | } |
| 948 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 949 | EXPECT_EQ(2, mIndex++); |
| 950 | } |
| 951 | void endLayer() override { |
| 952 | EXPECT_EQ(3, mIndex++); |
| 953 | } |
| 954 | void onLayerOp(const LayerOp& op, const BakedOpState& state) override { |
| 955 | EXPECT_EQ(4, mIndex++); |
| 956 | } |
| 957 | }; |
| 958 | |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 959 | auto parent = TestUtils::createNode(50, 60, 150, 160, |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 960 | [](RenderProperties& props, RecordingCanvas& canvas) { |
| 961 | props.mutateLayerProperties().setType(LayerType::RenderLayer); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 962 | canvas.insertReorderBarrier(true); |
| 963 | canvas.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag); |
| 964 | canvas.translate(20, 10); |
| 965 | canvas.drawRenderNode(createWhiteRectShadowCaster(5.0f).get()); |
| 966 | canvas.restore(); |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 967 | }); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 968 | OffscreenBuffer** layerHandle = parent->getLayerHandle(); |
| 969 | |
| 970 | // create RenderNode's layer here in same way prepareTree would, setting windowTransform |
| 971 | OffscreenBuffer layer(renderThread.renderState(), Caches::getInstance(), 100, 100); |
| 972 | Matrix4 windowTransform; |
| 973 | windowTransform.loadTranslate(50, 60, 0); // total transform of layer's origin |
| 974 | layer.setWindowTransform(windowTransform); |
| 975 | *layerHandle = &layer; |
| 976 | |
| 977 | auto syncedList = createSyncedNodeList(parent); |
| 978 | LayerUpdateQueue layerUpdateQueue; // Note: enqueue damage post-sync, so bounds are valid |
| 979 | layerUpdateQueue.enqueueLayerWithDamage(parent.get(), Rect(100, 100)); |
| 980 | OpReorderer reorderer(layerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 981 | syncedList, (Vector3) { 100, 100, 100 }); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 982 | ShadowHwLayerTestRenderer renderer; |
| 983 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 984 | EXPECT_EQ(5, renderer.getIndex()); |
| 985 | |
| 986 | // clean up layer pointer, so we can safely destruct RenderNode |
| 987 | *layerHandle = nullptr; |
| 988 | } |
| 989 | |
| 990 | TEST(OpReorderer, shadowLayering) { |
| 991 | class ShadowLayeringTestRenderer : public TestRendererBase { |
| 992 | public: |
| 993 | void onShadowOp(const ShadowOp& op, const BakedOpState& state) override { |
| 994 | int index = mIndex++; |
| 995 | EXPECT_TRUE(index == 0 || index == 1); |
| 996 | } |
| 997 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 998 | int index = mIndex++; |
| 999 | EXPECT_TRUE(index == 2 || index == 3); |
| 1000 | } |
| 1001 | }; |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 1002 | auto parent = TestUtils::createNode(0, 0, 200, 200, |
| 1003 | [](RenderProperties& props, RecordingCanvas& canvas) { |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 1004 | canvas.insertReorderBarrier(true); |
| 1005 | canvas.drawRenderNode(createWhiteRectShadowCaster(5.0f).get()); |
| 1006 | canvas.drawRenderNode(createWhiteRectShadowCaster(5.0001f).get()); |
| 1007 | }); |
| 1008 | |
| 1009 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, |
| 1010 | createSyncedNodeList(parent), sLightCenter); |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 1011 | ShadowLayeringTestRenderer renderer; |
| 1012 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 1013 | EXPECT_EQ(4, renderer.getIndex()); |
| 1014 | } |
| 1015 | |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 1016 | static void testProperty(std::function<void(RenderProperties&)> propSetupCallback, |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 1017 | std::function<void(const RectOp&, const BakedOpState&)> opValidateCallback) { |
Chris Craik | d3daa31 | 2015-11-06 10:59:56 -0800 | [diff] [blame] | 1018 | class PropertyTestRenderer : public TestRendererBase { |
| 1019 | public: |
| 1020 | PropertyTestRenderer(std::function<void(const RectOp&, const BakedOpState&)> callback) |
| 1021 | : mCallback(callback) {} |
| 1022 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 1023 | EXPECT_EQ(mIndex++, 0); |
| 1024 | mCallback(op, state); |
| 1025 | } |
| 1026 | std::function<void(const RectOp&, const BakedOpState&)> mCallback; |
| 1027 | }; |
| 1028 | |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 1029 | auto node = TestUtils::createNode(0, 0, 100, 100, |
| 1030 | [propSetupCallback](RenderProperties& props, RecordingCanvas& canvas) { |
| 1031 | propSetupCallback(props); |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 1032 | SkPaint paint; |
| 1033 | paint.setColor(SK_ColorWHITE); |
| 1034 | canvas.drawRect(0, 0, 100, 100, paint); |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 1035 | }); |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 1036 | |
Chris Craik | 98787e6 | 2015-11-13 10:55:30 -0800 | [diff] [blame] | 1037 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 200, 200, |
| 1038 | createSyncedNodeList(node), sLightCenter); |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 1039 | PropertyTestRenderer renderer(opValidateCallback); |
| 1040 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 1041 | EXPECT_EQ(1, renderer.getIndex()) << "Should have seen one op"; |
| 1042 | } |
| 1043 | |
| 1044 | TEST(OpReorderer, renderPropOverlappingRenderingAlpha) { |
| 1045 | testProperty([](RenderProperties& properties) { |
| 1046 | properties.setAlpha(0.5f); |
| 1047 | properties.setHasOverlappingRendering(false); |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 1048 | }, [](const RectOp& op, const BakedOpState& state) { |
| 1049 | EXPECT_EQ(0.5f, state.alpha) << "Alpha should be applied directly to op"; |
| 1050 | }); |
| 1051 | } |
| 1052 | |
| 1053 | TEST(OpReorderer, renderPropClipping) { |
| 1054 | testProperty([](RenderProperties& properties) { |
| 1055 | properties.setClipToBounds(true); |
| 1056 | properties.setClipBounds(Rect(10, 20, 300, 400)); |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 1057 | }, [](const RectOp& op, const BakedOpState& state) { |
| 1058 | EXPECT_EQ(Rect(10, 20, 100, 100), state.computedState.clippedBounds) |
| 1059 | << "Clip rect should be intersection of node bounds and clip bounds"; |
| 1060 | }); |
| 1061 | } |
| 1062 | |
| 1063 | TEST(OpReorderer, renderPropRevealClip) { |
| 1064 | testProperty([](RenderProperties& properties) { |
| 1065 | properties.mutableRevealClip().set(true, 50, 50, 25); |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 1066 | }, [](const RectOp& op, const BakedOpState& state) { |
| 1067 | ASSERT_NE(nullptr, state.roundRectClipState); |
| 1068 | EXPECT_TRUE(state.roundRectClipState->highPriority); |
| 1069 | EXPECT_EQ(25, state.roundRectClipState->radius); |
| 1070 | EXPECT_EQ(Rect(50, 50, 50, 50), state.roundRectClipState->innerRect); |
| 1071 | }); |
| 1072 | } |
| 1073 | |
| 1074 | TEST(OpReorderer, renderPropOutlineClip) { |
| 1075 | testProperty([](RenderProperties& properties) { |
| 1076 | properties.mutableOutline().setShouldClip(true); |
| 1077 | properties.mutableOutline().setRoundRect(10, 20, 30, 40, 5.0f, 0.5f); |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 1078 | }, [](const RectOp& op, const BakedOpState& state) { |
| 1079 | ASSERT_NE(nullptr, state.roundRectClipState); |
| 1080 | EXPECT_FALSE(state.roundRectClipState->highPriority); |
| 1081 | EXPECT_EQ(5, state.roundRectClipState->radius); |
| 1082 | EXPECT_EQ(Rect(15, 25, 25, 35), state.roundRectClipState->innerRect); |
| 1083 | }); |
| 1084 | } |
| 1085 | |
| 1086 | TEST(OpReorderer, renderPropTransform) { |
| 1087 | testProperty([](RenderProperties& properties) { |
| 1088 | properties.setLeftTopRightBottom(10, 10, 110, 110); |
| 1089 | |
| 1090 | SkMatrix staticMatrix = SkMatrix::MakeScale(1.2f, 1.2f); |
| 1091 | properties.setStaticMatrix(&staticMatrix); |
| 1092 | |
| 1093 | // ignored, since static overrides animation |
| 1094 | SkMatrix animationMatrix = SkMatrix::MakeTrans(15, 15); |
| 1095 | properties.setAnimationMatrix(&animationMatrix); |
| 1096 | |
| 1097 | properties.setTranslationX(10); |
| 1098 | properties.setTranslationY(20); |
| 1099 | properties.setScaleX(0.5f); |
| 1100 | properties.setScaleY(0.7f); |
Chris Craik | 76caecf | 2015-11-02 19:17:45 -0800 | [diff] [blame] | 1101 | }, [](const RectOp& op, const BakedOpState& state) { |
| 1102 | Matrix4 matrix; |
| 1103 | matrix.loadTranslate(10, 10, 0); // left, top |
| 1104 | matrix.scale(1.2f, 1.2f, 1); // static matrix |
| 1105 | // ignore animation matrix, since static overrides it |
| 1106 | |
| 1107 | // translation xy |
| 1108 | matrix.translate(10, 20); |
| 1109 | |
| 1110 | // scale xy (from default pivot - center) |
| 1111 | matrix.translate(50, 50); |
| 1112 | matrix.scale(0.5f, 0.7f, 1); |
| 1113 | matrix.translate(-50, -50); |
| 1114 | EXPECT_MATRIX_APPROX_EQ(matrix, state.computedState.transform) |
| 1115 | << "Op draw matrix must match expected combination of transformation properties"; |
| 1116 | }); |
| 1117 | } |
Chris Craik | 161f54b | 2015-11-05 11:08:52 -0800 | [diff] [blame] | 1118 | |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1119 | struct SaveLayerAlphaData { |
| 1120 | uint32_t layerWidth = 0; |
| 1121 | uint32_t layerHeight = 0; |
| 1122 | Rect rectClippedBounds; |
| 1123 | Matrix4 rectMatrix; |
| 1124 | }; |
| 1125 | /** |
| 1126 | * Constructs a view to hit the temporary layer alpha property implementation: |
| 1127 | * a) 0 < alpha < 1 |
| 1128 | * b) too big for layer (larger than maxTextureSize) |
| 1129 | * c) overlapping rendering content |
| 1130 | * returning observed data about layer size and content clip/transform. |
| 1131 | * |
| 1132 | * Used to validate clipping behavior of temporary layer, where requested layer size is reduced |
| 1133 | * (for efficiency, and to fit in layer size constraints) based on parent clip. |
| 1134 | */ |
| 1135 | void testSaveLayerAlphaClip(SaveLayerAlphaData* outObservedData, |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 1136 | std::function<void(RenderProperties&)> propSetupCallback) { |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1137 | class SaveLayerAlphaClipTestRenderer : public TestRendererBase { |
| 1138 | public: |
| 1139 | SaveLayerAlphaClipTestRenderer(SaveLayerAlphaData* outData) |
| 1140 | : mOutData(outData) {} |
| 1141 | |
| 1142 | OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height) override { |
| 1143 | EXPECT_EQ(0, mIndex++); |
| 1144 | mOutData->layerWidth = width; |
| 1145 | mOutData->layerHeight = height; |
| 1146 | return nullptr; |
| 1147 | } |
| 1148 | void onRectOp(const RectOp& op, const BakedOpState& state) override { |
| 1149 | EXPECT_EQ(1, mIndex++); |
| 1150 | |
| 1151 | mOutData->rectClippedBounds = state.computedState.clippedBounds; |
| 1152 | mOutData->rectMatrix = state.computedState.transform; |
| 1153 | } |
| 1154 | void endLayer() override { |
| 1155 | EXPECT_EQ(2, mIndex++); |
| 1156 | } |
| 1157 | void onLayerOp(const LayerOp& op, const BakedOpState& state) override { |
| 1158 | EXPECT_EQ(3, mIndex++); |
| 1159 | } |
| 1160 | private: |
| 1161 | SaveLayerAlphaData* mOutData; |
| 1162 | }; |
| 1163 | |
| 1164 | ASSERT_GT(10000, DeviceInfo::get()->maxTextureSize()) |
| 1165 | << "Node must be bigger than max texture size to exercise saveLayer codepath"; |
John Reck | 16c9d6a | 2015-11-17 15:51:08 -0800 | [diff] [blame] | 1166 | auto node = TestUtils::createNode(0, 0, 10000, 10000, |
| 1167 | [&propSetupCallback](RenderProperties& properties, RecordingCanvas& canvas) { |
| 1168 | properties.setHasOverlappingRendering(true); |
| 1169 | properties.setAlpha(0.5f); // force saveLayer, since too big for HW layer |
| 1170 | // apply other properties |
| 1171 | propSetupCallback(properties); |
| 1172 | |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1173 | SkPaint paint; |
| 1174 | paint.setColor(SK_ColorWHITE); |
| 1175 | canvas.drawRect(0, 0, 10000, 10000, paint); |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1176 | }); |
| 1177 | auto nodes = createSyncedNodeList(node); // sync before querying height |
| 1178 | |
| 1179 | OpReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, nodes, sLightCenter); |
| 1180 | SaveLayerAlphaClipTestRenderer renderer(outObservedData); |
| 1181 | reorderer.replayBakedOps<TestDispatcher>(renderer); |
| 1182 | |
| 1183 | // assert, since output won't be valid if we haven't seen a save layer triggered |
| 1184 | ASSERT_EQ(4, renderer.getIndex()) << "Test must trigger saveLayer alpha behavior."; |
| 1185 | } |
| 1186 | |
| 1187 | TEST(OpReorderer, renderPropSaveLayerAlphaClipBig) { |
| 1188 | SaveLayerAlphaData observedData; |
| 1189 | testSaveLayerAlphaClip(&observedData, [](RenderProperties& properties) { |
| 1190 | properties.setTranslationX(10); // offset rendering content |
| 1191 | properties.setTranslationY(-2000); // offset rendering content |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1192 | }); |
| 1193 | EXPECT_EQ(190u, observedData.layerWidth); |
| 1194 | EXPECT_EQ(200u, observedData.layerHeight); |
Chris Craik | 5430ab2 | 2015-12-10 16:28:16 -0800 | [diff] [blame] | 1195 | EXPECT_EQ(Rect(190, 200), observedData.rectClippedBounds) |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1196 | << "expect content to be clipped to screen area"; |
| 1197 | Matrix4 expected; |
| 1198 | expected.loadTranslate(0, -2000, 0); |
| 1199 | EXPECT_MATRIX_APPROX_EQ(expected, observedData.rectMatrix) |
| 1200 | << "expect content to be translated as part of being clipped"; |
| 1201 | } |
| 1202 | |
| 1203 | TEST(OpReorderer, renderPropSaveLayerAlphaRotate) { |
| 1204 | SaveLayerAlphaData observedData; |
| 1205 | testSaveLayerAlphaClip(&observedData, [](RenderProperties& properties) { |
| 1206 | // Translate and rotate the view so that the only visible part is the top left corner of |
Chris Craik | 8d1f212 | 2015-11-24 16:40:09 -0800 | [diff] [blame] | 1207 | // the view. It will form an isosceles right triangle with a long side length of 200 at the |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1208 | // bottom of the viewport. |
| 1209 | properties.setTranslationX(100); |
| 1210 | properties.setTranslationY(100); |
| 1211 | properties.setPivotX(0); |
| 1212 | properties.setPivotY(0); |
| 1213 | properties.setRotation(45); |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1214 | }); |
| 1215 | // ceil(sqrt(2) / 2 * 200) = 142 |
| 1216 | EXPECT_EQ(142u, observedData.layerWidth); |
| 1217 | EXPECT_EQ(142u, observedData.layerHeight); |
Chris Craik | 5430ab2 | 2015-12-10 16:28:16 -0800 | [diff] [blame] | 1218 | EXPECT_EQ(Rect(142, 142), observedData.rectClippedBounds); |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1219 | EXPECT_MATRIX_APPROX_EQ(Matrix4::identity(), observedData.rectMatrix); |
| 1220 | } |
| 1221 | |
| 1222 | TEST(OpReorderer, renderPropSaveLayerAlphaScale) { |
| 1223 | SaveLayerAlphaData observedData; |
| 1224 | testSaveLayerAlphaClip(&observedData, [](RenderProperties& properties) { |
| 1225 | properties.setPivotX(0); |
| 1226 | properties.setPivotY(0); |
| 1227 | properties.setScaleX(2); |
| 1228 | properties.setScaleY(0.5f); |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1229 | }); |
| 1230 | EXPECT_EQ(100u, observedData.layerWidth); |
| 1231 | EXPECT_EQ(400u, observedData.layerHeight); |
Chris Craik | 5430ab2 | 2015-12-10 16:28:16 -0800 | [diff] [blame] | 1232 | EXPECT_EQ(Rect(100, 400), observedData.rectClippedBounds); |
Chris Craik | 8ecf41c | 2015-11-16 10:27:59 -0800 | [diff] [blame] | 1233 | EXPECT_MATRIX_APPROX_EQ(Matrix4::identity(), observedData.rectMatrix); |
| 1234 | } |
| 1235 | |
Chris Craik | 6fe991e5 | 2015-10-20 09:39:42 -0700 | [diff] [blame] | 1236 | } // namespace uirenderer |
| 1237 | } // namespace android |