libs/hwui/RecordedOp.h

   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 #pragma once
  18
  19 #include "font/FontUtil.h"
  20 #include "GlLayer.h"
  21 #include "Matrix.h"
  22 #include "Rect.h"
  23 #include "RenderNode.h"
  24 #include "TessellationCache.h"
  25 #include "utils/LinearAllocator.h"
  26 #include "utils/PaintUtils.h"
  27 #include "Vector.h"
  28
  29 #include <androidfw/ResourceTypes.h>
  30
  31 class SkBitmap;
  32 class SkPaint;
  33
  34 namespace android {
  35 namespace uirenderer {
  36
  37 struct ClipBase;
  38 class OffscreenBuffer;
  39 class RenderNode;
  40 class DeferredLayerUpdater;
  41
  42 struct Vertex;
  43
  44 namespace VectorDrawable {
  45 class Tree;
  46 }
  47
  48 /**
  49  * Authoritative op list, used for generating the op ID enum, ID based LUTS, and
  50  * the functions to which they dispatch. Parameter macros are executed for each op,
  51  * in order, based on the op's type.
  52  *
  53  * There are 4 types of op, which defines dispatch/LUT capability:
  54  *
  55  *              | DisplayList |   Render    |    Merge    |
  56  * -------------|-------------|-------------|-------------|
  57  * PRE RENDER   |     Yes     |             |             |
  58  * RENDER ONLY  |             |     Yes     |             |
  59  * UNMERGEABLE  |     Yes     |     Yes     |             |
  60  * MERGEABLE    |     Yes     |     Yes     |     Yes     |
  61  *
  62  * PRE RENDER - These ops are recorded into DisplayLists, but can't be directly rendered. This
  63  *      may be because they need to be transformed into other op types (e.g. CirclePropsOp),
  64  *      be traversed to access multiple renderable ops within (e.g. RenderNodeOp), or because they
  65  *      modify renderbuffer lifecycle, instead of directly rendering content (the various LayerOps).
  66  *
  67  * RENDER ONLY - These ops cannot be recorded into DisplayLists, and are instead implicitly
  68  *      constructed from other commands/RenderNode properties. They cannot be merged.
  69  *
  70  * UNMERGEABLE - These ops can be recorded into DisplayLists and rendered directly, but do not
  71  *      support merged rendering.
  72  *
  73  * MERGEABLE - These ops can be recorded into DisplayLists and rendered individually, or merged
  74  *      under certain circumstances.
  75  */
  76 #define MAP_OPS_BASED_ON_TYPE(PRE_RENDER_OP_FN, RENDER_ONLY_OP_FN, UNMERGEABLE_OP_FN, MERGEABLE_OP_FN) \
  77         PRE_RENDER_OP_FN(RenderNodeOp) \
  78         PRE_RENDER_OP_FN(CirclePropsOp) \
  79         PRE_RENDER_OP_FN(RoundRectPropsOp) \
  80         PRE_RENDER_OP_FN(BeginLayerOp) \
  81         PRE_RENDER_OP_FN(EndLayerOp) \
  82         PRE_RENDER_OP_FN(BeginUnclippedLayerOp) \
  83         PRE_RENDER_OP_FN(EndUnclippedLayerOp) \
  84         PRE_RENDER_OP_FN(VectorDrawableOp) \
  85         \
  86         RENDER_ONLY_OP_FN(ShadowOp) \
  87         RENDER_ONLY_OP_FN(LayerOp) \
  88         RENDER_ONLY_OP_FN(CopyToLayerOp) \
  89         RENDER_ONLY_OP_FN(CopyFromLayerOp) \
  90         \
  91         UNMERGEABLE_OP_FN(ArcOp) \
  92         UNMERGEABLE_OP_FN(BitmapMeshOp) \
  93         UNMERGEABLE_OP_FN(BitmapRectOp) \
  94         UNMERGEABLE_OP_FN(ColorOp) \
  95         UNMERGEABLE_OP_FN(FunctorOp) \
  96         UNMERGEABLE_OP_FN(LinesOp) \
  97         UNMERGEABLE_OP_FN(OvalOp) \
  98         UNMERGEABLE_OP_FN(PathOp) \
  99         UNMERGEABLE_OP_FN(PointsOp) \
 100         UNMERGEABLE_OP_FN(RectOp) \
 101         UNMERGEABLE_OP_FN(RoundRectOp) \
 102         UNMERGEABLE_OP_FN(SimpleRectsOp) \
 103         UNMERGEABLE_OP_FN(TextOnPathOp) \
 104         UNMERGEABLE_OP_FN(TextureLayerOp) \
 105         \
 106         MERGEABLE_OP_FN(BitmapOp) \
 107         MERGEABLE_OP_FN(PatchOp) \
 108         MERGEABLE_OP_FN(TextOp)
 109
 110 /**
 111  * LUT generators, which will insert nullptr for unsupported ops
 112  */
 113 #define NULLPTR_OP_FN(Type) nullptr,
 114
 115 #define BUILD_DEFERRABLE_OP_LUT(OP_FN) \
 116         { MAP_OPS_BASED_ON_TYPE(OP_FN, NULLPTR_OP_FN, OP_FN, OP_FN) }
 117
 118 #define BUILD_MERGEABLE_OP_LUT(OP_FN) \
 119         { MAP_OPS_BASED_ON_TYPE(NULLPTR_OP_FN, NULLPTR_OP_FN, NULLPTR_OP_FN, OP_FN) }
 120
 121 #define BUILD_RENDERABLE_OP_LUT(OP_FN) \
 122         { MAP_OPS_BASED_ON_TYPE(NULLPTR_OP_FN, OP_FN, OP_FN, OP_FN) }
 123
 124 #define BUILD_FULL_OP_LUT(OP_FN) \
 125         { MAP_OPS_BASED_ON_TYPE(OP_FN, OP_FN, OP_FN, OP_FN) }
 126
 127 /**
 128  * Op mapping functions, which skip unsupported ops.
 129  *
 130  * Note: Do not use for LUTS, since these do not preserve ID order.
 131  */
 132 #define NULL_OP_FN(Type)
 133
 134 #define MAP_DEFERRABLE_OPS(OP_FN) \
 135         MAP_OPS_BASED_ON_TYPE(OP_FN, NULL_OP_FN, OP_FN, OP_FN)
 136
 137 #define MAP_MERGEABLE_OPS(OP_FN) \
 138         MAP_OPS_BASED_ON_TYPE(NULL_OP_FN, NULL_OP_FN, NULL_OP_FN, OP_FN)
 139
 140 #define MAP_RENDERABLE_OPS(OP_FN) \
 141         MAP_OPS_BASED_ON_TYPE(NULL_OP_FN, OP_FN, OP_FN, OP_FN)
 142
 143 // Generate OpId enum
 144 #define IDENTITY_FN(Type) Type,
 145 namespace RecordedOpId {
 146     enum {
 147         MAP_OPS_BASED_ON_TYPE(IDENTITY_FN, IDENTITY_FN, IDENTITY_FN, IDENTITY_FN)
 148         Count,
 149     };
 150 }
 151 static_assert(RecordedOpId::RenderNodeOp == 0,
 152         "First index must be zero for LUTs to work");
 153
 154 #define BASE_PARAMS const Rect& unmappedBounds, const Matrix4& localMatrix, const ClipBase* localClip, const SkPaint* paint
 155 #define BASE_PARAMS_PAINTLESS const Rect& unmappedBounds, const Matrix4& localMatrix, const ClipBase* localClip
 156 #define SUPER(Type) RecordedOp(RecordedOpId::Type, unmappedBounds, localMatrix, localClip, paint)
 157 #define SUPER_PAINTLESS(Type) RecordedOp(RecordedOpId::Type, unmappedBounds, localMatrix, localClip, nullptr)
 158
 159 struct RecordedOp {
 160     /* ID from RecordedOpId - generally used for jumping into function tables */
 161     const int opId;
 162
 163     /* bounds in *local* space, without accounting for DisplayList transformation, or stroke */
 164     const Rect unmappedBounds;
 165
 166     /* transform in recording space (vs DisplayList origin) */
 167     const Matrix4 localMatrix;
 168
 169     /* clip in recording space - nullptr if not clipped */
 170     const ClipBase* localClip;
 171
 172     /* optional paint, stored in base object to simplify merging logic */
 173     const SkPaint* paint;
 174 protected:
 175     RecordedOp(unsigned int opId, BASE_PARAMS)
 176             : opId(opId)
 177             , unmappedBounds(unmappedBounds)
 178             , localMatrix(localMatrix)
 179             , localClip(localClip)
 180             , paint(paint) {}
 181 };
 182
 183 struct RenderNodeOp : RecordedOp {
 184     RenderNodeOp(BASE_PARAMS_PAINTLESS, RenderNode* renderNode)
 185             : SUPER_PAINTLESS(RenderNodeOp)
 186             , renderNode(renderNode) {}
 187     RenderNode * renderNode; // not const, since drawing modifies it
 188
 189     /**
 190      * Holds the transformation between the projection surface ViewGroup and this RenderNode
 191      * drawing instance. Represents any translations / transformations done within the drawing of
 192      * the compositing ancestor ViewGroup's draw, before the draw of the View represented by this
 193      * DisplayList draw instance.
 194      *
 195      * Note: doesn't include transformation within the RenderNode, or its properties.
 196      */
 197     Matrix4 transformFromCompositingAncestor;
 198     bool skipInOrderDraw = false;
 199 };
 200
 201 ////////////////////////////////////////////////////////////////////////////////////////////////////
 202 // Standard Ops
 203 ////////////////////////////////////////////////////////////////////////////////////////////////////
 204
 205 struct ArcOp : RecordedOp {
 206     ArcOp(BASE_PARAMS, float startAngle, float sweepAngle, bool useCenter)
 207             : SUPER(ArcOp)
 208             , startAngle(startAngle)
 209             , sweepAngle(sweepAngle)
 210             , useCenter(useCenter) {}
 211     const float startAngle;
 212     const float sweepAngle;
 213     const bool useCenter;
 214 };
 215
 216 struct BitmapOp : RecordedOp {
 217     BitmapOp(BASE_PARAMS, Bitmap* bitmap)
 218             : SUPER(BitmapOp)
 219             , bitmap(bitmap) {}
 220     Bitmap* bitmap;
 221 };
 222
 223 struct BitmapMeshOp : RecordedOp {
 224     BitmapMeshOp(BASE_PARAMS, Bitmap* bitmap, int meshWidth, int meshHeight,
 225             const float* vertices, const int* colors)
 226             : SUPER(BitmapMeshOp)
 227             , bitmap(bitmap)
 228             , meshWidth(meshWidth)
 229             , meshHeight(meshHeight)
 230             , vertices(vertices)
 231             , colors(colors) {}
 232     Bitmap* bitmap;
 233     const int meshWidth;
 234     const int meshHeight;
 235     const float* vertices;
 236     const int* colors;
 237 };
 238
 239 struct BitmapRectOp : RecordedOp {
 240     BitmapRectOp(BASE_PARAMS, Bitmap* bitmap, const Rect& src)
 241             : SUPER(BitmapRectOp)
 242             , bitmap(bitmap)
 243             , src(src) {}
 244     Bitmap* bitmap;
 245     const Rect src;
 246 };
 247
 248 struct CirclePropsOp : RecordedOp {
 249     CirclePropsOp(const Matrix4& localMatrix, const ClipBase* localClip, const SkPaint* paint,
 250             float* x, float* y, float* radius)
 251             : RecordedOp(RecordedOpId::CirclePropsOp, Rect(), localMatrix, localClip, paint)
 252             , x(x)
 253             , y(y)
 254             , radius(radius) {}
 255     const float* x;
 256     const float* y;
 257     const float* radius;
 258 };
 259
 260 struct ColorOp : RecordedOp {
 261     // Note: unbounded op that will fillclip, so no bounds/matrix needed
 262     ColorOp(const ClipBase* localClip, int color, SkBlendMode mode)
 263             : RecordedOp(RecordedOpId::ColorOp, Rect(), Matrix4::identity(), localClip, nullptr)
 264             , color(color)
 265             , mode(mode) {}
 266     const int color;
 267     const SkBlendMode mode;
 268 };
 269
 270 struct FunctorOp : RecordedOp {
 271     // Note: undefined record-time bounds, since this op fills the clip
 272     // TODO: explicitly define bounds
 273     FunctorOp(const Matrix4& localMatrix, const ClipBase* localClip, Functor* functor)
 274             : RecordedOp(RecordedOpId::FunctorOp, Rect(), localMatrix, localClip, nullptr)
 275             , functor(functor) {}
 276     Functor* functor;
 277 };
 278
 279 struct LinesOp : RecordedOp {
 280     LinesOp(BASE_PARAMS, const float* points, const int floatCount)
 281             : SUPER(LinesOp)
 282             , points(points)
 283             , floatCount(floatCount) {}
 284     const float* points;
 285     const int floatCount;
 286 };
 287
 288 struct OvalOp : RecordedOp {
 289     OvalOp(BASE_PARAMS)
 290             : SUPER(OvalOp) {}
 291 };
 292
 293 struct PatchOp : RecordedOp {
 294     PatchOp(BASE_PARAMS, Bitmap* bitmap, const Res_png_9patch* patch)
 295             : SUPER(PatchOp)
 296             , bitmap(bitmap)
 297             , patch(patch) {}
 298     Bitmap* bitmap;
 299     const Res_png_9patch* patch;
 300 };
 301
 302 struct PathOp : RecordedOp {
 303     PathOp(BASE_PARAMS, const SkPath* path)
 304             : SUPER(PathOp)
 305             , path(path) {}
 306     const SkPath* path;
 307 };
 308
 309 struct PointsOp : RecordedOp {
 310     PointsOp(BASE_PARAMS, const float* points, const int floatCount)
 311             : SUPER(PointsOp)
 312             , points(points)
 313             , floatCount(floatCount) {}
 314     const float* points;
 315     const int floatCount;
 316 };
 317
 318 struct RectOp : RecordedOp {
 319     RectOp(BASE_PARAMS)
 320             : SUPER(RectOp) {}
 321 };
 322
 323 struct RoundRectOp : RecordedOp {
 324     RoundRectOp(BASE_PARAMS, float rx, float ry)
 325             : SUPER(RoundRectOp)
 326             , rx(rx)
 327             , ry(ry) {}
 328     const float rx;
 329     const float ry;
 330 };
 331
 332 struct RoundRectPropsOp : RecordedOp {
 333     RoundRectPropsOp(const Matrix4& localMatrix, const ClipBase* localClip, const SkPaint* paint,
 334             float* left, float* top, float* right, float* bottom, float *rx, float *ry)
 335             : RecordedOp(RecordedOpId::RoundRectPropsOp, Rect(), localMatrix, localClip, paint)
 336             , left(left)
 337             , top(top)
 338             , right(right)
 339             , bottom(bottom)
 340             , rx(rx)
 341             , ry(ry) {}
 342     const float* left;
 343     const float* top;
 344     const float* right;
 345     const float* bottom;
 346     const float* rx;
 347     const float* ry;
 348 };
 349
 350 struct VectorDrawableOp : RecordedOp {
 351     VectorDrawableOp(VectorDrawable::Tree* tree, BASE_PARAMS_PAINTLESS)
 352             : SUPER_PAINTLESS(VectorDrawableOp)
 353             , vectorDrawable(tree) {}
 354     VectorDrawable::Tree* vectorDrawable;
 355 };
 356
 357 /**
 358  * Real-time, dynamic-lit shadow.
 359  *
 360  * Uses invalid/empty bounds and matrix since ShadowOp bounds aren't known at defer time,
 361  * and are resolved dynamically, and transform isn't needed.
 362  *
 363  * State construction handles these properties specially, ignoring matrix/bounds.
 364  */
 365 struct ShadowOp : RecordedOp {
 366     ShadowOp(sp<TessellationCache::ShadowTask>& shadowTask, float casterAlpha)
 367             : RecordedOp(RecordedOpId::ShadowOp, Rect(), Matrix4::identity(), nullptr, nullptr)
 368             , shadowTask(shadowTask)
 369             , casterAlpha(casterAlpha) {
 370     };
 371     sp<TessellationCache::ShadowTask> shadowTask;
 372     const float casterAlpha;
 373 };
 374
 375 struct SimpleRectsOp : RecordedOp { // Filled, no AA (TODO: better name?)
 376     SimpleRectsOp(BASE_PARAMS, Vertex* vertices, size_t vertexCount)
 377             : SUPER(SimpleRectsOp)
 378             , vertices(vertices)
 379             , vertexCount(vertexCount) {}
 380     Vertex* vertices;
 381     const size_t vertexCount;
 382 };
 383
 384 struct TextOp : RecordedOp {
 385     TextOp(BASE_PARAMS, const glyph_t* glyphs, const float* positions, int glyphCount,
 386             float x, float y)
 387             : SUPER(TextOp)
 388             , glyphs(glyphs)
 389             , positions(positions)
 390             , glyphCount(glyphCount)
 391             , x(x)
 392             , y(y) {}
 393     const glyph_t* glyphs;
 394     const float* positions;
 395     const int glyphCount;
 396     const float x;
 397     const float y;
 398 };
 399
 400 struct TextOnPathOp : RecordedOp {
 401     // TODO: explicitly define bounds
 402     TextOnPathOp(const Matrix4& localMatrix, const ClipBase* localClip, const SkPaint* paint,
 403             const glyph_t* glyphs, int glyphCount, const SkPath* path, float hOffset, float vOffset)
 404             : RecordedOp(RecordedOpId::TextOnPathOp, Rect(), localMatrix, localClip, paint)
 405             , glyphs(glyphs)
 406             , glyphCount(glyphCount)
 407             , path(path)
 408             , hOffset(hOffset)
 409             , vOffset(vOffset) {}
 410     const glyph_t* glyphs;
 411     const int glyphCount;
 412
 413     const SkPath* path;
 414     const float hOffset;
 415     const float vOffset;
 416 };
 417
 418 struct TextureLayerOp : RecordedOp {
 419     TextureLayerOp(BASE_PARAMS_PAINTLESS, DeferredLayerUpdater* layer)
 420             : SUPER_PAINTLESS(TextureLayerOp)
 421             , layerHandle(layer) {}
 422
 423     // Copy an existing TextureLayerOp, replacing the underlying matrix
 424     TextureLayerOp(const TextureLayerOp& op, const Matrix4& replacementMatrix)
 425             : RecordedOp(RecordedOpId::TextureLayerOp, op.unmappedBounds, replacementMatrix,
 426                     op.localClip, op.paint)
 427             , layerHandle(op.layerHandle) {
 428
 429     }
 430     DeferredLayerUpdater* layerHandle;
 431 };
 432
 433 ////////////////////////////////////////////////////////////////////////////////////////////////////
 434 // Layers
 435 ////////////////////////////////////////////////////////////////////////////////////////////////////
 436
 437 /**
 438  * Stateful operation! denotes the creation of an off-screen layer,
 439  * and that commands following will render into it.
 440  */
 441 struct BeginLayerOp : RecordedOp {
 442     BeginLayerOp(BASE_PARAMS)
 443             : SUPER(BeginLayerOp) {}
 444 };
 445
 446 /**
 447  * Stateful operation! Denotes end of off-screen layer, and that
 448  * commands since last BeginLayerOp should be drawn into parent FBO.
 449  *
 450  * State in this op is empty, it just serves to signal that a layer has been finished.
 451  */
 452 struct EndLayerOp : RecordedOp {
 453     EndLayerOp()
 454             : RecordedOp(RecordedOpId::EndLayerOp, Rect(), Matrix4::identity(), nullptr, nullptr) {}
 455 };
 456
 457 struct BeginUnclippedLayerOp : RecordedOp {
 458     BeginUnclippedLayerOp(BASE_PARAMS)
 459             : SUPER(BeginUnclippedLayerOp) {}
 460 };
 461
 462 struct EndUnclippedLayerOp : RecordedOp {
 463     EndUnclippedLayerOp()
 464             : RecordedOp(RecordedOpId::EndUnclippedLayerOp, Rect(), Matrix4::identity(), nullptr, nullptr) {}
 465 };
 466
 467 struct CopyToLayerOp : RecordedOp {
 468     CopyToLayerOp(const RecordedOp& op, OffscreenBuffer** layerHandle)
 469             : RecordedOp(RecordedOpId::CopyToLayerOp,
 470                     op.unmappedBounds,
 471                     op.localMatrix,
 472                     nullptr, // clip intentionally ignored
 473                     op.paint)
 474             , layerHandle(layerHandle) {}
 475
 476     // Records a handle to the Layer object, since the Layer itself won't be
 477     // constructed until after this operation is constructed.
 478     OffscreenBuffer** layerHandle;
 479 };
 480
 481
 482 // draw the parameter layer underneath
 483 struct CopyFromLayerOp : RecordedOp {
 484     CopyFromLayerOp(const RecordedOp& op, OffscreenBuffer** layerHandle)
 485             : RecordedOp(RecordedOpId::CopyFromLayerOp,
 486                     op.unmappedBounds,
 487                     op.localMatrix,
 488                     nullptr, // clip intentionally ignored
 489                     op.paint)
 490             , layerHandle(layerHandle) {}
 491
 492     // Records a handle to the Layer object, since the Layer itself won't be
 493     // constructed until after this operation is constructed.
 494     OffscreenBuffer** layerHandle;
 495 };
 496
 497 /**
 498  * Draws an OffscreenBuffer.
 499  *
 500  * Alpha, mode, and colorfilter are embedded, since LayerOps are always dynamically generated,
 501  * when creating/tracking a SkPaint* during defer isn't worth the bother.
 502  */
 503 struct LayerOp : RecordedOp {
 504     // Records a one-use (saveLayer) layer for drawing.
 505     LayerOp(BASE_PARAMS, OffscreenBuffer** layerHandle)
 506             : SUPER_PAINTLESS(LayerOp)
 507             , layerHandle(layerHandle)
 508             , alpha(paint ? paint->getAlpha() / 255.0f : 1.0f)
 509             , mode(PaintUtils::getBlendModeDirect(paint))
 510             , colorFilter(paint ? paint->getColorFilter() : nullptr) {}
 511
 512     explicit LayerOp(RenderNode& node)
 513             : RecordedOp(RecordedOpId::LayerOp, Rect(node.getWidth(), node.getHeight()), Matrix4::identity(), nullptr, nullptr)
 514             , layerHandle(node.getLayerHandle())
 515             , alpha(node.properties().layerProperties().alpha() / 255.0f)
 516             , mode(node.properties().layerProperties().xferMode())
 517             , colorFilter(node.properties().layerProperties().colorFilter()) {}
 518
 519     // Records a handle to the Layer object, since the Layer itself won't be
 520     // constructed until after this operation is constructed.
 521     OffscreenBuffer** layerHandle;
 522     const float alpha;
 523     const SkBlendMode mode;
 524
 525     // pointer to object owned by either LayerProperties, or a recorded Paint object in a
 526     // BeginLayerOp. Lives longer than LayerOp in either case, so no skia ref counting is used.
 527     SkColorFilter* colorFilter;
 528 };
 529
 530 }; // namespace uirenderer
 531 }; // namespace android