1/* 2 * Copyright (C) 2016 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 <BakedOpDispatcher.h> 20#include <BakedOpRenderer.h> 21#include <FrameBuilder.h> 22#include <LayerUpdateQueue.h> 23#include <hwui/Paint.h> 24#include <RecordedOp.h> 25#include <tests/common/TestUtils.h> 26#include <utils/Color.h> 27 28#include <SkBlurDrawLooper.h> 29#include <SkDashPathEffect.h> 30 31using namespace android::uirenderer; 32 33static BakedOpRenderer::LightInfo sLightInfo; 34const FrameBuilder::LightGeometry sLightGeometry = { {100, 100, 100}, 50}; 35 36class ValidatingBakedOpRenderer : public BakedOpRenderer { 37public: 38 ValidatingBakedOpRenderer(RenderState& renderState, std::function<void(const Glop& glop)> validator) 39 : BakedOpRenderer(Caches::getInstance(), renderState, true, sLightInfo) 40 , mValidator(validator) { 41 mGlopReceiver = ValidatingGlopReceiver; 42 } 43private: 44 static void ValidatingGlopReceiver(BakedOpRenderer& renderer, const Rect* dirtyBounds, 45 const ClipBase* clip, const Glop& glop) { 46 47 auto vbor = reinterpret_cast<ValidatingBakedOpRenderer*>(&renderer); 48 vbor->mValidator(glop); 49 } 50 std::function<void(const Glop& glop)> mValidator; 51}; 52 53typedef void (*TestBakedOpReceiver)(BakedOpRenderer&, const BakedOpState&); 54 55static void testUnmergedGlopDispatch(renderthread::RenderThread& renderThread, RecordedOp* op, 56 std::function<void(const Glop& glop)> glopVerifier, int expectedGlopCount = 1) { 57 // Create op, and wrap with basic state. 58 LinearAllocator allocator; 59 auto snapshot = TestUtils::makeSnapshot(Matrix4::identity(), Rect(100, 100)); 60 auto state = BakedOpState::tryConstruct(allocator, *snapshot, *op); 61 ASSERT_NE(nullptr, state); 62 63 int glopCount = 0; 64 auto glopReceiver = [&glopVerifier, &glopCount, &expectedGlopCount] (const Glop& glop) { 65 ASSERT_LE(glopCount++, expectedGlopCount) << expectedGlopCount << "glop(s) expected"; 66 glopVerifier(glop); 67 }; 68 ValidatingBakedOpRenderer renderer(renderThread.renderState(), glopReceiver); 69 70 // Dispatch based on op type created, similar to Frame/LayerBuilder dispatch behavior 71#define X(Type) \ 72 [](BakedOpRenderer& renderer, const BakedOpState& state) { \ 73 BakedOpDispatcher::on##Type(renderer, static_cast<const Type&>(*(state.op)), state); \ 74 }, 75 static TestBakedOpReceiver unmergedReceivers[] = BUILD_RENDERABLE_OP_LUT(X); 76#undef X 77 unmergedReceivers[op->opId](renderer, *state); 78 ASSERT_EQ(expectedGlopCount, glopCount) << "Exactly " << expectedGlopCount 79 << "Glop(s) expected"; 80} 81 82RENDERTHREAD_TEST(BakedOpDispatcher, pathTexture_positionOvalArc) { 83 SkPaint strokePaint; 84 strokePaint.setStyle(SkPaint::kStroke_Style); 85 strokePaint.setStrokeWidth(4); 86 87 float intervals[] = {1.0f, 1.0f}; 88 auto dashEffect = SkDashPathEffect::Create(intervals, 2, 0); 89 strokePaint.setPathEffect(dashEffect); 90 dashEffect->unref(); 91 92 auto textureGlopVerifier = [] (const Glop& glop) { 93 // validate glop produced by renderPathTexture (so texture, unit quad) 94 auto texture = glop.fill.texture.texture; 95 ASSERT_NE(nullptr, texture); 96 float expectedOffset = floor(4 * 1.5f + 0.5f); 97 EXPECT_EQ(expectedOffset, reinterpret_cast<PathTexture*>(texture)->offset) 98 << "Should see conservative offset from PathCache::computeBounds"; 99 Rect expectedBounds(10, 15, 20, 25); 100 expectedBounds.outset(expectedOffset); 101 102 Matrix4 expectedModelView; 103 expectedModelView.loadTranslate(10 - expectedOffset, 15 - expectedOffset, 0); 104 expectedModelView.scale(10 + 2 * expectedOffset, 10 + 2 * expectedOffset, 1); 105 EXPECT_EQ(expectedModelView, glop.transform.modelView) 106 << "X and Y offsets, and scale both applied to model view"; 107 }; 108 109 // Arc and Oval will render functionally the same glop, differing only in texture content 110 ArcOp arcOp(Rect(10, 15, 20, 25), Matrix4::identity(), nullptr, &strokePaint, 0, 270, true); 111 testUnmergedGlopDispatch(renderThread, &arcOp, textureGlopVerifier); 112 113 OvalOp ovalOp(Rect(10, 15, 20, 25), Matrix4::identity(), nullptr, &strokePaint); 114 testUnmergedGlopDispatch(renderThread, &ovalOp, textureGlopVerifier); 115} 116 117RENDERTHREAD_TEST(BakedOpDispatcher, onLayerOp_bufferless) { 118 SkPaint layerPaint; 119 layerPaint.setAlpha(128); 120 OffscreenBuffer* buffer = nullptr; // no providing a buffer, should hit rect fallback case 121 LayerOp op(Rect(10, 10), Matrix4::identity(), nullptr, &layerPaint, &buffer); 122 testUnmergedGlopDispatch(renderThread, &op, [&renderThread] (const Glop& glop) { 123 ADD_FAILURE() << "Nothing should happen"; 124 }, 0); 125} 126 127static int getGlopTransformFlags(renderthread::RenderThread& renderThread, RecordedOp* op) { 128 int result = 0; 129 testUnmergedGlopDispatch(renderThread, op, [&result] (const Glop& glop) { 130 result = glop.transform.transformFlags; 131 }); 132 return result; 133} 134 135RENDERTHREAD_TEST(BakedOpDispatcher, offsetFlags) { 136 Rect bounds(10, 15, 20, 25); 137 SkPaint paint; 138 SkPaint aaPaint; 139 aaPaint.setAntiAlias(true); 140 141 RoundRectOp roundRectOp(bounds, Matrix4::identity(), nullptr, &paint, 0, 270); 142 EXPECT_EQ(TransformFlags::None, getGlopTransformFlags(renderThread, &roundRectOp)) 143 << "Expect no offset for round rect op."; 144 145 const float points[4] = {0.5, 0.5, 1.0, 1.0}; 146 PointsOp antiAliasedPointsOp(bounds, Matrix4::identity(), nullptr, &aaPaint, points, 4); 147 EXPECT_EQ(TransformFlags::None, getGlopTransformFlags(renderThread, &antiAliasedPointsOp)) 148 << "Expect no offset for AA points."; 149 PointsOp pointsOp(bounds, Matrix4::identity(), nullptr, &paint, points, 4); 150 EXPECT_EQ(TransformFlags::OffsetByFudgeFactor, getGlopTransformFlags(renderThread, &pointsOp)) 151 << "Expect an offset for non-AA points."; 152 153 LinesOp antiAliasedLinesOp(bounds, Matrix4::identity(), nullptr, &aaPaint, points, 4); 154 EXPECT_EQ(TransformFlags::None, getGlopTransformFlags(renderThread, &antiAliasedLinesOp)) 155 << "Expect no offset for AA lines."; 156 LinesOp linesOp(bounds, Matrix4::identity(), nullptr, &paint, points, 4); 157 EXPECT_EQ(TransformFlags::OffsetByFudgeFactor, getGlopTransformFlags(renderThread, &linesOp)) 158 << "Expect an offset for non-AA lines."; 159} 160 161RENDERTHREAD_TEST(BakedOpDispatcher, renderTextWithShadow) { 162 auto node = TestUtils::createNode(0, 0, 100, 100, 163 [](RenderProperties& props, TestCanvas& canvas) { 164 165 android::Paint shadowPaint; 166 shadowPaint.setColor(SK_ColorRED); 167 168 SkScalar sigma = Blur::convertRadiusToSigma(5); 169 shadowPaint.setLooper(SkBlurDrawLooper::Create(SK_ColorWHITE, sigma, 3, 3))->unref(); 170 171 TestUtils::drawUtf8ToCanvas(&canvas, "A", shadowPaint, 25, 25); 172 TestUtils::drawUtf8ToCanvas(&canvas, "B", shadowPaint, 50, 50); 173 }); 174 175 int glopCount = 0; 176 auto glopReceiver = [&glopCount] (const Glop& glop) { 177 if (glopCount < 2) { 178 // two white shadows 179 EXPECT_EQ(FloatColor({1, 1, 1, 1}), glop.fill.color); 180 } else { 181 // two text draws merged into one, drawn after both shadows 182 EXPECT_EQ(FloatColor({1, 0, 0, 1}), glop.fill.color); 183 } 184 glopCount++; 185 }; 186 187 ValidatingBakedOpRenderer renderer(renderThread.renderState(), glopReceiver); 188 189 FrameBuilder frameBuilder(SkRect::MakeWH(100, 100), 100, 100, 190 sLightGeometry, Caches::getInstance()); 191 frameBuilder.deferRenderNode(*TestUtils::getSyncedNode(node)); 192 193 frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer); 194 ASSERT_EQ(3, glopCount) << "Exactly three glops expected"; 195} 196 197static void validateLayerDraw(renderthread::RenderThread& renderThread, 198 std::function<void(const Glop& glop)> validator) { 199 auto node = TestUtils::createNode(0, 0, 100, 100, 200 [](RenderProperties& props, TestCanvas& canvas) { 201 props.mutateLayerProperties().setType(LayerType::RenderLayer); 202 203 // provide different blend mode, so decoration draws contrast 204 props.mutateLayerProperties().setXferMode(SkXfermode::Mode::kSrc_Mode); 205 canvas.drawColor(Color::Black, SkXfermode::Mode::kSrcOver_Mode); 206 }); 207 OffscreenBuffer** layerHandle = node->getLayerHandle(); 208 209 auto syncedNode = TestUtils::getSyncedNode(node); 210 211 // create RenderNode's layer here in same way prepareTree would 212 OffscreenBuffer layer(renderThread.renderState(), Caches::getInstance(), 100, 100); 213 *layerHandle = &layer; 214 { 215 LayerUpdateQueue layerUpdateQueue; // Note: enqueue damage post-sync, so bounds are valid 216 layerUpdateQueue.enqueueLayerWithDamage(node.get(), Rect(0, 0, 100, 100)); 217 218 ValidatingBakedOpRenderer renderer(renderThread.renderState(), validator); 219 FrameBuilder frameBuilder(SkRect::MakeWH(100, 100), 100, 100, 220 sLightGeometry, Caches::getInstance()); 221 frameBuilder.deferLayers(layerUpdateQueue); 222 frameBuilder.deferRenderNode(*syncedNode); 223 frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer); 224 } 225 226 // clean up layer pointer, so we can safely destruct RenderNode 227 *layerHandle = nullptr; 228} 229 230static FloatColor makeFloatColor(uint32_t color) { 231 FloatColor c; 232 c.set(color); 233 return c; 234} 235 236RENDERTHREAD_TEST(BakedOpDispatcher, layerUpdateProperties) { 237 for (bool debugOverdraw : { false, true }) { 238 for (bool debugLayersUpdates : { false, true }) { 239 ScopedProperty<bool> ovdProp(Properties::debugOverdraw, debugOverdraw); 240 ScopedProperty<bool> lupProp(Properties::debugLayersUpdates, debugLayersUpdates); 241 242 int glopCount = 0; 243 validateLayerDraw(renderThread, [&glopCount, &debugLayersUpdates](const Glop& glop) { 244 if (glopCount == 0) { 245 // 0 - Black layer fill 246 EXPECT_TRUE(glop.fill.colorEnabled); 247 EXPECT_EQ(makeFloatColor(Color::Black), glop.fill.color); 248 } else if (glopCount == 1) { 249 // 1 - Uncolored (textured) layer draw 250 EXPECT_FALSE(glop.fill.colorEnabled); 251 } else if (glopCount == 2) { 252 // 2 - layer overlay, if present 253 EXPECT_TRUE(glop.fill.colorEnabled); 254 // blend srcover, different from that of layer 255 EXPECT_EQ(GLenum(GL_ONE), glop.blend.src); 256 EXPECT_EQ(GLenum(GL_ONE_MINUS_SRC_ALPHA), glop.blend.dst); 257 EXPECT_EQ(makeFloatColor(debugLayersUpdates ? 0x7f00ff00 : 0), 258 glop.fill.color) << "Should be transparent green if debugLayersUpdates"; 259 } else if (glopCount < 7) { 260 // 3 - 6 - overdraw indicator overlays, if present 261 EXPECT_TRUE(glop.fill.colorEnabled); 262 uint32_t expectedColor = Caches::getInstance().getOverdrawColor(glopCount - 2); 263 ASSERT_EQ(makeFloatColor(expectedColor), glop.fill.color); 264 } else { 265 ADD_FAILURE() << "Too many glops observed"; 266 } 267 glopCount++; 268 }); 269 int expectedCount = 2; 270 if (debugLayersUpdates || debugOverdraw) expectedCount++; 271 if (debugOverdraw) expectedCount += 4; 272 EXPECT_EQ(expectedCount, glopCount); 273 } 274 } 275} 276