Merge "Delete a bunch of code"
diff --git a/libs/hwui/Android.bp b/libs/hwui/Android.bp
index d716844..1ad40ec 100644
--- a/libs/hwui/Android.bp
+++ b/libs/hwui/Android.bp
@@ -210,8 +210,6 @@
"DamageAccumulator.cpp",
"DeferredLayerUpdater.cpp",
"DeviceInfo.cpp",
- "DisplayList.cpp",
- "FrameBuilder.cpp",
"FrameInfo.cpp",
"FrameInfoVisualizer.cpp",
"GlLayer.cpp",
@@ -237,7 +235,6 @@
"Properties.cpp",
"PropertyValuesAnimatorSet.cpp",
"PropertyValuesHolder.cpp",
- "RecordingCanvas.cpp",
"RenderNode.cpp",
"RenderProperties.cpp",
"ResourceCache.cpp",
@@ -399,7 +396,6 @@
srcs: [
"tests/microbench/main.cpp",
"tests/microbench/DisplayListCanvasBench.cpp",
- "tests/microbench/FrameBuilderBench.cpp",
"tests/microbench/LinearAllocatorBench.cpp",
"tests/microbench/PathParserBench.cpp",
"tests/microbench/RenderNodeBench.cpp",
diff --git a/libs/hwui/Animator.h b/libs/hwui/Animator.h
index 42f4cf8..ed7b6eb 100644
--- a/libs/hwui/Animator.h
+++ b/libs/hwui/Animator.h
@@ -16,6 +16,8 @@
#ifndef ANIMATOR_H
#define ANIMATOR_H
+#include "CanvasProperty.h"
+
#include <cutils/compiler.h>
#include <utils/RefBase.h>
#include <utils/StrongPointer.h>
@@ -31,8 +33,6 @@
class AnimationContext;
class BaseRenderNodeAnimator;
-class CanvasPropertyPrimitive;
-class CanvasPropertyPaint;
class Interpolator;
class RenderNode;
class RenderProperties;
diff --git a/libs/hwui/BakedOpRenderer.h b/libs/hwui/BakedOpRenderer.h
index ae8928e..72c9365 100644
--- a/libs/hwui/BakedOpRenderer.h
+++ b/libs/hwui/BakedOpRenderer.h
@@ -17,6 +17,7 @@
#pragma once
#include "BakedOpState.h"
+#include "Lighting.h"
#include "Matrix.h"
#include "utils/Macros.h"
@@ -42,16 +43,6 @@
class BakedOpRenderer {
public:
typedef void (*GlopReceiver)(BakedOpRenderer&, const Rect*, const ClipBase*, const Glop&);
- /**
- * Position agnostic shadow lighting info. Used with all shadow ops in scene.
- */
- struct LightInfo {
- LightInfo() : LightInfo(0, 0) {}
- LightInfo(uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha)
- : ambientShadowAlpha(ambientShadowAlpha), spotShadowAlpha(spotShadowAlpha) {}
- uint8_t ambientShadowAlpha;
- uint8_t spotShadowAlpha;
- };
BakedOpRenderer(Caches& caches, RenderState& renderState, bool opaque, bool wideColorGamut,
const LightInfo& lightInfo)
diff --git a/libs/hwui/DisplayList.cpp b/libs/hwui/DisplayList.cpp
deleted file mode 100644
index f1f0d2d..0000000
--- a/libs/hwui/DisplayList.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <SkCanvas.h>
-#include <algorithm>
-
-#include <utils/Trace.h>
-
-#include "DamageAccumulator.h"
-#include "Debug.h"
-#include "DisplayList.h"
-#include "OpDumper.h"
-#include "RecordedOp.h"
-#include "RenderNode.h"
-#include "VectorDrawable.h"
-#include "renderthread/CanvasContext.h"
-
-namespace android {
-namespace uirenderer {
-
-DisplayList::DisplayList()
- : projectionReceiveIndex(-1)
- , stdAllocator(allocator)
- , chunks(stdAllocator)
- , ops(stdAllocator)
- , children(stdAllocator)
- , bitmapResources(stdAllocator)
- , pathResources(stdAllocator)
- , patchResources(stdAllocator)
- , paints(stdAllocator)
- , regions(stdAllocator)
- , referenceHolders(stdAllocator)
- , functors(stdAllocator)
- , vectorDrawables(stdAllocator) {}
-
-DisplayList::~DisplayList() {
- cleanupResources();
-}
-
-void DisplayList::cleanupResources() {
- if (CC_UNLIKELY(patchResources.size())) {
- ResourceCache& resourceCache = ResourceCache::getInstance();
- resourceCache.lock();
-
- for (size_t i = 0; i < patchResources.size(); i++) {
- resourceCache.decrementRefcountLocked(patchResources[i]);
- }
-
- resourceCache.unlock();
- }
-
- for (size_t i = 0; i < pathResources.size(); i++) {
- const SkPath* path = pathResources[i];
- delete path;
- }
-
- for (auto& iter : functors) {
- if (iter.listener) {
- iter.listener->onGlFunctorReleased(iter.functor);
- }
- }
-
- patchResources.clear();
- pathResources.clear();
- paints.clear();
- regions.clear();
-}
-
-size_t DisplayList::addChild(NodeOpType* op) {
- referenceHolders.push_back(op->renderNode);
- size_t index = children.size();
- children.push_back(op);
- return index;
-}
-
-void DisplayList::syncContents() {
- for (auto& iter : functors) {
- (*iter.functor)(DrawGlInfo::kModeSync, nullptr);
- }
- for (auto& vectorDrawable : vectorDrawables) {
- vectorDrawable->syncProperties();
- }
-}
-
-void DisplayList::updateChildren(std::function<void(RenderNode*)> updateFn) {
- for (auto&& child : children) {
- updateFn(child->renderNode);
- }
-}
-
-bool DisplayList::prepareListAndChildren(
- TreeObserver& observer, TreeInfo& info, bool functorsNeedLayer,
- std::function<void(RenderNode*, TreeObserver&, TreeInfo&, bool)> childFn) {
- info.prepareTextures = info.canvasContext.pinImages(bitmapResources);
-
- for (auto&& op : children) {
- RenderNode* childNode = op->renderNode;
- info.damageAccumulator->pushTransform(&op->localMatrix);
- bool childFunctorsNeedLayer =
- functorsNeedLayer; // TODO! || op->mRecordedWithPotentialStencilClip;
- childFn(childNode, observer, info, childFunctorsNeedLayer);
- info.damageAccumulator->popTransform();
- }
-
- bool isDirty = false;
- for (auto& vectorDrawable : vectorDrawables) {
- // If any vector drawable in the display list needs update, damage the node.
- if (vectorDrawable->isDirty()) {
- isDirty = true;
- }
- vectorDrawable->setPropertyChangeWillBeConsumed(true);
- }
- return isDirty;
-}
-
-void DisplayList::output(std::ostream& output, uint32_t level) {
- for (auto&& op : getOps()) {
- OpDumper::dump(*op, output, level + 1);
- if (op->opId == RecordedOpId::RenderNodeOp) {
- auto rnOp = reinterpret_cast<const RenderNodeOp*>(op);
- rnOp->renderNode->output(output, level + 1);
- } else {
- output << std::endl;
- }
- }
-}
-
-}; // namespace uirenderer
-}; // namespace android
diff --git a/libs/hwui/DisplayList.h b/libs/hwui/DisplayList.h
index 7a9c65d..a952cc2 100644
--- a/libs/hwui/DisplayList.h
+++ b/libs/hwui/DisplayList.h
@@ -16,149 +16,20 @@
#pragma once
-#include <SkCamera.h>
-#include <SkDrawable.h>
-#include <SkMatrix.h>
-
-#include <private/hwui/DrawGlInfo.h>
-
-#include <utils/KeyedVector.h>
-#include <utils/LinearAllocator.h>
-#include <utils/RefBase.h>
-#include <utils/SortedVector.h>
-#include <utils/String8.h>
-
-#include <cutils/compiler.h>
-
-#include <androidfw/ResourceTypes.h>
-
-#include "CanvasProperty.h"
-#include "Debug.h"
-#include "GlFunctorLifecycleListener.h"
-#include "Matrix.h"
-#include "RenderProperties.h"
-#include "TreeInfo.h"
-#include "hwui/Bitmap.h"
-
-#include <vector>
-
-class SkBitmap;
-class SkPaint;
-class SkPath;
-class SkRegion;
+#include "pipeline/skia/SkiaDisplayList.h"
namespace android {
namespace uirenderer {
-struct ClipBase;
-class Rect;
-class Layer;
-
-struct RecordedOp;
-struct RenderNodeOp;
-
-typedef RecordedOp BaseOpType;
-typedef RenderNodeOp NodeOpType;
-
namespace VectorDrawable {
class Tree;
};
typedef uirenderer::VectorDrawable::Tree VectorDrawableRoot;
-struct FunctorContainer {
- Functor* functor;
- GlFunctorLifecycleListener* listener;
-};
-
/**
* Data structure that holds the list of commands used in display list stream
*/
-class DisplayList {
- friend class RecordingCanvas;
-
-public:
- struct Chunk {
- // range of included ops in DisplayList::ops()
- size_t beginOpIndex;
- size_t endOpIndex;
-
- // range of included children in DisplayList::children()
- size_t beginChildIndex;
- size_t endChildIndex;
-
- // whether children with non-zero Z in the chunk should be reordered
- bool reorderChildren;
-
- // clip at the beginning of a reorder section, applied to reordered children
- const ClipBase* reorderClip;
- };
-
- DisplayList();
- virtual ~DisplayList();
-
- // index of DisplayListOp restore, after which projected descendants should be drawn
- int projectionReceiveIndex;
-
- const LsaVector<Chunk>& getChunks() const { return chunks; }
- const LsaVector<BaseOpType*>& getOps() const { return ops; }
-
- const LsaVector<NodeOpType*>& getChildren() const { return children; }
-
- const LsaVector<sk_sp<Bitmap>>& getBitmapResources() const { return bitmapResources; }
-
- size_t addChild(NodeOpType* childOp);
-
- void ref(VirtualLightRefBase* prop) { referenceHolders.push_back(prop); }
-
- size_t getUsedSize() { return allocator.usedSize(); }
-
- virtual bool isEmpty() const { return ops.empty(); }
- virtual bool hasFunctor() const { return !functors.empty(); }
- virtual bool hasVectorDrawables() const { return !vectorDrawables.empty(); }
- virtual bool isSkiaDL() const { return false; }
- virtual bool reuseDisplayList(RenderNode* node, renderthread::CanvasContext* context) {
- return false;
- }
-
- virtual void syncContents();
- virtual void updateChildren(std::function<void(RenderNode*)> updateFn);
- virtual bool prepareListAndChildren(
- TreeObserver& observer, TreeInfo& info, bool functorsNeedLayer,
- std::function<void(RenderNode*, TreeObserver&, TreeInfo&, bool)> childFn);
-
- virtual void output(std::ostream& output, uint32_t level);
-
-protected:
- // allocator into which all ops and LsaVector arrays allocated
- LinearAllocator allocator;
- LinearStdAllocator<void*> stdAllocator;
-
-private:
- LsaVector<Chunk> chunks;
- LsaVector<BaseOpType*> ops;
-
- // list of Ops referring to RenderNode children for quick, non-drawing traversal
- LsaVector<NodeOpType*> children;
-
- // Resources - Skia objects + 9 patches referred to by this DisplayList
- LsaVector<sk_sp<Bitmap>> bitmapResources;
- LsaVector<const SkPath*> pathResources;
- LsaVector<const Res_png_9patch*> patchResources;
- LsaVector<std::unique_ptr<const SkPaint>> paints;
- LsaVector<std::unique_ptr<const SkRegion>> regions;
- LsaVector<sp<VirtualLightRefBase>> referenceHolders;
-
- // List of functors
- LsaVector<FunctorContainer> functors;
-
- // List of VectorDrawables that need to be notified of pushStaging. Note that this list gets
- // nothing
- // but a callback during sync DisplayList, unlike the list of functors defined above, which
- // gets special treatment exclusive for webview.
- LsaVector<VectorDrawableRoot*> vectorDrawables;
-
- void cleanupResources();
-};
+using DisplayList = skiapipeline::SkiaDisplayList;
}; // namespace uirenderer
}; // namespace android
diff --git a/libs/hwui/FrameBuilder.cpp b/libs/hwui/FrameBuilder.cpp
deleted file mode 100644
index 575aea5..0000000
--- a/libs/hwui/FrameBuilder.cpp
+++ /dev/null
@@ -1,867 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "FrameBuilder.h"
-
-#include "DeferredLayerUpdater.h"
-#include "LayerUpdateQueue.h"
-#include "RenderNode.h"
-#include "VectorDrawable.h"
-#include "hwui/Canvas.h"
-#include "renderstate/OffscreenBufferPool.h"
-#include "utils/FatVector.h"
-#include "utils/PaintUtils.h"
-#include "utils/TraceUtils.h"
-
-#include <SkPathOps.h>
-#include <utils/TypeHelpers.h>
-
-namespace android {
-namespace uirenderer {
-
-FrameBuilder::FrameBuilder(const SkRect& clip, uint32_t viewportWidth, uint32_t viewportHeight,
- const LightGeometry& lightGeometry, Caches& caches)
- : mStdAllocator(mAllocator)
- , mLayerBuilders(mStdAllocator)
- , mLayerStack(mStdAllocator)
- , mCanvasState(*this)
- , mCaches(caches)
- , mLightRadius(lightGeometry.radius)
- , mDrawFbo0(true) {
- // Prepare to defer Fbo0
- auto fbo0 = mAllocator.create<LayerBuilder>(viewportWidth, viewportHeight, Rect(clip));
- mLayerBuilders.push_back(fbo0);
- mLayerStack.push_back(0);
- mCanvasState.initializeSaveStack(viewportWidth, viewportHeight, clip.fLeft, clip.fTop,
- clip.fRight, clip.fBottom, lightGeometry.center);
-}
-
-FrameBuilder::FrameBuilder(const LayerUpdateQueue& layers, const LightGeometry& lightGeometry,
- Caches& caches)
- : mStdAllocator(mAllocator)
- , mLayerBuilders(mStdAllocator)
- , mLayerStack(mStdAllocator)
- , mCanvasState(*this)
- , mCaches(caches)
- , mLightRadius(lightGeometry.radius)
- , mDrawFbo0(false) {
- // TODO: remove, with each layer on its own save stack
-
- // Prepare to defer Fbo0 (which will be empty)
- auto fbo0 = mAllocator.create<LayerBuilder>(1, 1, Rect(1, 1));
- mLayerBuilders.push_back(fbo0);
- mLayerStack.push_back(0);
- mCanvasState.initializeSaveStack(1, 1, 0, 0, 1, 1, lightGeometry.center);
-
- deferLayers(layers);
-}
-
-void FrameBuilder::deferLayers(const LayerUpdateQueue& layers) {
- // Render all layers to be updated, in order. Defer in reverse order, so that they'll be
- // updated in the order they're passed in (mLayerBuilders are issued to Renderer in reverse)
- for (int i = layers.entries().size() - 1; i >= 0; i--) {
- RenderNode* layerNode = layers.entries()[i].renderNode.get();
- // only schedule repaint if node still on layer - possible it may have been
- // removed during a dropped frame, but layers may still remain scheduled so
- // as not to lose info on what portion is damaged
- OffscreenBuffer* layer = layerNode->getLayer();
- if (CC_LIKELY(layer)) {
- ATRACE_FORMAT("Optimize HW Layer DisplayList %s %ux%u", layerNode->getName(),
- layerNode->getWidth(), layerNode->getHeight());
-
- Rect layerDamage = layers.entries()[i].damage;
- // TODO: ensure layer damage can't be larger than layer
- layerDamage.doIntersect(0, 0, layer->viewportWidth, layer->viewportHeight);
- layerNode->computeOrdering();
-
- // map current light center into RenderNode's coordinate space
- Vector3 lightCenter = mCanvasState.currentSnapshot()->getRelativeLightCenter();
- layer->inverseTransformInWindow.mapPoint3d(lightCenter);
-
- saveForLayer(layerNode->getWidth(), layerNode->getHeight(), 0, 0, layerDamage,
- lightCenter, nullptr, layerNode);
-
- if (layerNode->getDisplayList()) {
- deferNodeOps(*layerNode);
- }
- restoreForLayer();
- }
- }
-}
-
-void FrameBuilder::deferRenderNode(RenderNode& renderNode) {
- renderNode.computeOrdering();
-
- mCanvasState.save(SaveFlags::MatrixClip);
- deferNodePropsAndOps(renderNode);
- mCanvasState.restore();
-}
-
-void FrameBuilder::deferRenderNode(float tx, float ty, Rect clipRect, RenderNode& renderNode) {
- renderNode.computeOrdering();
-
- mCanvasState.save(SaveFlags::MatrixClip);
- mCanvasState.translate(tx, ty);
- mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
- SkClipOp::kIntersect);
- deferNodePropsAndOps(renderNode);
- mCanvasState.restore();
-}
-
-static Rect nodeBounds(RenderNode& node) {
- auto& props = node.properties();
- return Rect(props.getLeft(), props.getTop(), props.getRight(), props.getBottom());
-}
-
-void FrameBuilder::deferRenderNodeScene(const std::vector<sp<RenderNode> >& nodes,
- const Rect& contentDrawBounds) {
- if (nodes.size() < 1) return;
- if (nodes.size() == 1) {
- if (!nodes[0]->nothingToDraw()) {
- deferRenderNode(*nodes[0]);
- }
- return;
- }
- // It there are multiple render nodes, they are laid out as follows:
- // #0 - backdrop (content + caption)
- // #1 - content (local bounds are at (0,0), will be translated and clipped to backdrop)
- // #2 - additional overlay nodes
- // Usually the backdrop cannot be seen since it will be entirely covered by the content. While
- // resizing however it might become partially visible. The following render loop will crop the
- // backdrop against the content and draw the remaining part of it. It will then draw the content
- // cropped to the backdrop (since that indicates a shrinking of the window).
- //
- // Additional nodes will be drawn on top with no particular clipping semantics.
-
- // Usually the contents bounds should be mContentDrawBounds - however - we will
- // move it towards the fixed edge to give it a more stable appearance (for the moment).
- // If there is no content bounds we ignore the layering as stated above and start with 2.
-
- // Backdrop bounds in render target space
- const Rect backdrop = nodeBounds(*nodes[0]);
-
- // Bounds that content will fill in render target space (note content node bounds may be bigger)
- Rect content(contentDrawBounds.getWidth(), contentDrawBounds.getHeight());
- content.translate(backdrop.left, backdrop.top);
- if (!content.contains(backdrop) && !nodes[0]->nothingToDraw()) {
- // Content doesn't entirely overlap backdrop, so fill around content (right/bottom)
-
- // Note: in the future, if content doesn't snap to backdrop's left/top, this may need to
- // also fill left/top. Currently, both 2up and freeform position content at the top/left of
- // the backdrop, so this isn't necessary.
- if (content.right < backdrop.right) {
- // draw backdrop to right side of content
- deferRenderNode(0, 0,
- Rect(content.right, backdrop.top, backdrop.right, backdrop.bottom),
- *nodes[0]);
- }
- if (content.bottom < backdrop.bottom) {
- // draw backdrop to bottom of content
- // Note: bottom fill uses content left/right, to avoid overdrawing left/right fill
- deferRenderNode(0, 0,
- Rect(content.left, content.bottom, content.right, backdrop.bottom),
- *nodes[0]);
- }
- }
-
- if (!nodes[1]->nothingToDraw()) {
- if (!backdrop.isEmpty()) {
- // content node translation to catch up with backdrop
- float dx = contentDrawBounds.left - backdrop.left;
- float dy = contentDrawBounds.top - backdrop.top;
-
- Rect contentLocalClip = backdrop;
- contentLocalClip.translate(dx, dy);
- deferRenderNode(-dx, -dy, contentLocalClip, *nodes[1]);
- } else {
- deferRenderNode(*nodes[1]);
- }
- }
-
- // remaining overlay nodes, simply defer
- for (size_t index = 2; index < nodes.size(); index++) {
- if (!nodes[index]->nothingToDraw()) {
- deferRenderNode(*nodes[index]);
- }
- }
-}
-
-void FrameBuilder::onViewportInitialized() {}
-
-void FrameBuilder::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {}
-
-void FrameBuilder::deferNodePropsAndOps(RenderNode& node) {
- const RenderProperties& properties = node.properties();
- const Outline& outline = properties.getOutline();
- if (properties.getAlpha() <= 0 || (outline.getShouldClip() && outline.isEmpty()) ||
- properties.getScaleX() == 0 || properties.getScaleY() == 0) {
- return; // rejected
- }
-
- if (properties.getLeft() != 0 || properties.getTop() != 0) {
- mCanvasState.translate(properties.getLeft(), properties.getTop());
- }
- if (properties.getStaticMatrix()) {
- mCanvasState.concatMatrix(*properties.getStaticMatrix());
- } else if (properties.getAnimationMatrix()) {
- mCanvasState.concatMatrix(*properties.getAnimationMatrix());
- }
- if (properties.hasTransformMatrix()) {
- if (properties.isTransformTranslateOnly()) {
- mCanvasState.translate(properties.getTranslationX(), properties.getTranslationY());
- } else {
- mCanvasState.concatMatrix(*properties.getTransformMatrix());
- }
- }
-
- const int width = properties.getWidth();
- const int height = properties.getHeight();
-
- Rect saveLayerBounds; // will be set to non-empty if saveLayer needed
- const bool isLayer = properties.effectiveLayerType() != LayerType::None;
- int clipFlags = properties.getClippingFlags();
- if (properties.getAlpha() < 1) {
- if (isLayer) {
- clipFlags &= ~CLIP_TO_BOUNDS; // bounds clipping done by layer
- }
- if (CC_LIKELY(isLayer || !properties.getHasOverlappingRendering())) {
- // simply scale rendering content's alpha
- mCanvasState.scaleAlpha(properties.getAlpha());
- } else {
- // schedule saveLayer by initializing saveLayerBounds
- saveLayerBounds.set(0, 0, width, height);
- if (clipFlags) {
- properties.getClippingRectForFlags(clipFlags, &saveLayerBounds);
- clipFlags = 0; // all clipping done by savelayer
- }
- }
-
- if (CC_UNLIKELY(ATRACE_ENABLED() && properties.promotedToLayer())) {
- // pretend alpha always causes savelayer to warn about
- // performance problem affecting old versions
- ATRACE_FORMAT("%s alpha caused saveLayer %dx%d", node.getName(), width, height);
- }
- }
- if (clipFlags) {
- Rect clipRect;
- properties.getClippingRectForFlags(clipFlags, &clipRect);
- mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
- SkClipOp::kIntersect);
- }
-
- if (properties.getRevealClip().willClip()) {
- Rect bounds;
- properties.getRevealClip().getBounds(&bounds);
- mCanvasState.setClippingRoundRect(mAllocator, bounds,
- properties.getRevealClip().getRadius());
- } else if (properties.getOutline().willClip()) {
- mCanvasState.setClippingOutline(mAllocator, &(properties.getOutline()));
- }
-
- bool quickRejected = mCanvasState.currentSnapshot()->getRenderTargetClip().isEmpty() ||
- (properties.getClipToBounds() &&
- mCanvasState.quickRejectConservative(0, 0, width, height));
- if (!quickRejected) {
- // not rejected, so defer render as either Layer, or direct (possibly wrapped in saveLayer)
- if (node.getLayer()) {
- // HW layer
- LayerOp* drawLayerOp = mAllocator.create_trivial<LayerOp>(node);
- BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp);
- if (bakedOpState) {
- // Node's layer already deferred, schedule it to render into parent layer
- currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap);
- }
- } else if (CC_UNLIKELY(!saveLayerBounds.isEmpty())) {
- // draw DisplayList contents within temporary, since persisted layer could not be used.
- // (temp layers are clipped to viewport, since they don't persist offscreen content)
- SkPaint saveLayerPaint;
- saveLayerPaint.setAlpha(properties.getAlpha());
- deferBeginLayerOp(*mAllocator.create_trivial<BeginLayerOp>(
- saveLayerBounds, Matrix4::identity(),
- nullptr, // no record-time clip - need only respect defer-time one
- &saveLayerPaint));
- deferNodeOps(node);
- deferEndLayerOp(*mAllocator.create_trivial<EndLayerOp>());
- } else {
- deferNodeOps(node);
- }
- }
-}
-
-typedef key_value_pair_t<float, const RenderNodeOp*> ZRenderNodeOpPair;
-
-template <typename V>
-static void buildZSortedChildList(V* zTranslatedNodes, const DisplayList& displayList,
- const DisplayList::Chunk& chunk) {
- if (chunk.beginChildIndex == chunk.endChildIndex) return;
-
- for (size_t i = chunk.beginChildIndex; i < chunk.endChildIndex; i++) {
- RenderNodeOp* childOp = displayList.getChildren()[i];
- RenderNode* child = childOp->renderNode;
- float childZ = child->properties().getZ();
-
- if (!MathUtils::isZero(childZ) && chunk.reorderChildren) {
- zTranslatedNodes->push_back(ZRenderNodeOpPair(childZ, childOp));
- childOp->skipInOrderDraw = true;
- } else if (!child->properties().getProjectBackwards()) {
- // regular, in order drawing DisplayList
- childOp->skipInOrderDraw = false;
- }
- }
-
- // Z sort any 3d children (stable-ness makes z compare fall back to standard drawing order)
- std::stable_sort(zTranslatedNodes->begin(), zTranslatedNodes->end());
-}
-
-template <typename V>
-static size_t findNonNegativeIndex(const V& zTranslatedNodes) {
- for (size_t i = 0; i < zTranslatedNodes.size(); i++) {
- if (zTranslatedNodes[i].key >= 0.0f) return i;
- }
- return zTranslatedNodes.size();
-}
-
-template <typename V>
-void FrameBuilder::defer3dChildren(const ClipBase* reorderClip, ChildrenSelectMode mode,
- const V& zTranslatedNodes) {
- const int size = zTranslatedNodes.size();
- if (size == 0 || (mode == ChildrenSelectMode::Negative && zTranslatedNodes[0].key > 0.0f) ||
- (mode == ChildrenSelectMode::Positive && zTranslatedNodes[size - 1].key < 0.0f)) {
- // no 3d children to draw
- return;
- }
-
- /**
- * Draw shadows and (potential) casters mostly in order, but allow the shadows of casters
- * with very similar Z heights to draw together.
- *
- * This way, if Views A & B have the same Z height and are both casting shadows, the shadows are
- * underneath both, and neither's shadow is drawn on top of the other.
- */
- const size_t nonNegativeIndex = findNonNegativeIndex(zTranslatedNodes);
- size_t drawIndex, shadowIndex, endIndex;
- if (mode == ChildrenSelectMode::Negative) {
- drawIndex = 0;
- endIndex = nonNegativeIndex;
- shadowIndex = endIndex; // draw no shadows
- } else {
- drawIndex = nonNegativeIndex;
- endIndex = size;
- shadowIndex = drawIndex; // potentially draw shadow for each pos Z child
- }
-
- float lastCasterZ = 0.0f;
- while (shadowIndex < endIndex || drawIndex < endIndex) {
- if (shadowIndex < endIndex) {
- const RenderNodeOp* casterNodeOp = zTranslatedNodes[shadowIndex].value;
- const float casterZ = zTranslatedNodes[shadowIndex].key;
- // attempt to render the shadow if the caster about to be drawn is its caster,
- // OR if its caster's Z value is similar to the previous potential caster
- if (shadowIndex == drawIndex || casterZ - lastCasterZ < 0.1f) {
- deferShadow(reorderClip, *casterNodeOp);
-
- lastCasterZ = casterZ; // must do this even if current caster not casting a shadow
- shadowIndex++;
- continue;
- }
- }
-
- const RenderNodeOp* childOp = zTranslatedNodes[drawIndex].value;
- deferRenderNodeOpImpl(*childOp);
- drawIndex++;
- }
-}
-
-void FrameBuilder::deferShadow(const ClipBase* reorderClip, const RenderNodeOp& casterNodeOp) {
- // DEAD CODE
-}
-
-void FrameBuilder::deferProjectedChildren(const RenderNode& renderNode) {
- int count = mCanvasState.save(SaveFlags::MatrixClip);
- const SkPath* projectionReceiverOutline = renderNode.properties().getOutline().getPath();
-
- SkPath transformedMaskPath; // on stack, since BakedOpState makes a deep copy
- if (projectionReceiverOutline) {
- // transform the mask for this projector into render target space
- // TODO: consider combining both transforms by stashing transform instead of applying
- SkMatrix skCurrentTransform;
- mCanvasState.currentTransform()->copyTo(skCurrentTransform);
- projectionReceiverOutline->transform(skCurrentTransform, &transformedMaskPath);
- mCanvasState.setProjectionPathMask(&transformedMaskPath);
- }
-
- for (size_t i = 0; i < renderNode.mProjectedNodes.size(); i++) {
- RenderNodeOp* childOp = renderNode.mProjectedNodes[i];
- RenderNode& childNode = *childOp->renderNode;
-
- // Draw child if it has content, but ignore state in childOp - matrix already applied to
- // transformFromCompositingAncestor, and record-time clip is ignored when projecting
- if (!childNode.nothingToDraw()) {
- int restoreTo = mCanvasState.save(SaveFlags::MatrixClip);
-
- // Apply transform between ancestor and projected descendant
- mCanvasState.concatMatrix(childOp->transformFromCompositingAncestor);
-
- deferNodePropsAndOps(childNode);
-
- mCanvasState.restoreToCount(restoreTo);
- }
- }
- mCanvasState.restoreToCount(count);
-}
-
-/**
- * Used to define a list of lambdas referencing private FrameBuilder::onXX::defer() methods.
- *
- * This allows opIds embedded in the RecordedOps to be used for dispatching to these lambdas.
- * E.g. a BitmapOp op then would be dispatched to FrameBuilder::onBitmapOp(const BitmapOp&)
- */
-#define OP_RECEIVER(Type) \
- [](FrameBuilder& frameBuilder, const RecordedOp& op) { \
- frameBuilder.defer##Type(static_cast<const Type&>(op)); \
- },
-void FrameBuilder::deferNodeOps(const RenderNode& renderNode) {
- typedef void (*OpDispatcher)(FrameBuilder & frameBuilder, const RecordedOp& op);
- static OpDispatcher receivers[] = BUILD_DEFERRABLE_OP_LUT(OP_RECEIVER);
-
- // can't be null, since DL=null node rejection happens before deferNodePropsAndOps
- const DisplayList& displayList = *(renderNode.getDisplayList());
- for (auto& chunk : displayList.getChunks()) {
- FatVector<ZRenderNodeOpPair, 16> zTranslatedNodes;
- buildZSortedChildList(&zTranslatedNodes, displayList, chunk);
-
- defer3dChildren(chunk.reorderClip, ChildrenSelectMode::Negative, zTranslatedNodes);
- for (size_t opIndex = chunk.beginOpIndex; opIndex < chunk.endOpIndex; opIndex++) {
- const RecordedOp* op = displayList.getOps()[opIndex];
- receivers[op->opId](*this, *op);
-
- if (CC_UNLIKELY(!renderNode.mProjectedNodes.empty() &&
- displayList.projectionReceiveIndex >= 0 &&
- static_cast<int>(opIndex) == displayList.projectionReceiveIndex)) {
- deferProjectedChildren(renderNode);
- }
- }
- defer3dChildren(chunk.reorderClip, ChildrenSelectMode::Positive, zTranslatedNodes);
- }
-}
-
-void FrameBuilder::deferRenderNodeOpImpl(const RenderNodeOp& op) {
- if (op.renderNode->nothingToDraw()) return;
- int count = mCanvasState.save(SaveFlags::MatrixClip);
-
- // apply state from RecordedOp (clip first, since op's clip is transformed by current matrix)
- mCanvasState.writableSnapshot()->applyClip(op.localClip,
- *mCanvasState.currentSnapshot()->transform);
- mCanvasState.concatMatrix(op.localMatrix);
-
- // then apply state from node properties, and defer ops
- deferNodePropsAndOps(*op.renderNode);
-
- mCanvasState.restoreToCount(count);
-}
-
-void FrameBuilder::deferRenderNodeOp(const RenderNodeOp& op) {
- if (!op.skipInOrderDraw) {
- deferRenderNodeOpImpl(op);
- }
-}
-
-/**
- * Defers an unmergeable, strokeable op, accounting correctly
- * for paint's style on the bounds being computed.
- */
-BakedOpState* FrameBuilder::deferStrokeableOp(const RecordedOp& op, batchid_t batchId,
- BakedOpState::StrokeBehavior strokeBehavior,
- bool expandForPathTexture) {
- // Note: here we account for stroke when baking the op
- BakedOpState* bakedState = BakedOpState::tryStrokeableOpConstruct(
- mAllocator, *mCanvasState.writableSnapshot(), op, strokeBehavior, expandForPathTexture);
- if (!bakedState) return nullptr; // quick rejected
-
- if (op.opId == RecordedOpId::RectOp && op.paint->getStyle() != SkPaint::kStroke_Style) {
- bakedState->setupOpacity(op.paint);
- }
-
- currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId);
- return bakedState;
-}
-
-/**
- * Returns batch id for tessellatable shapes, based on paint. Checks to see if path effect/AA will
- * be used, since they trigger significantly different rendering paths.
- *
- * Note: not used for lines/points, since they don't currently support path effects.
- */
-static batchid_t tessBatchId(const RecordedOp& op) {
- const SkPaint& paint = *(op.paint);
- return paint.getPathEffect()
- ? OpBatchType::AlphaMaskTexture
- : (paint.isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices);
-}
-
-void FrameBuilder::deferArcOp(const ArcOp& op) {
- // Pass true below since arcs have a tendency to draw outside their expected bounds within
- // their path textures. Passing true makes it more likely that we'll scissor, instead of
- // corrupting the frame by drawing outside of clip bounds.
- deferStrokeableOp(op, tessBatchId(op), BakedOpState::StrokeBehavior::StyleDefined, true);
-}
-
-static bool hasMergeableClip(const BakedOpState& state) {
- return !state.computedState.clipState ||
- state.computedState.clipState->mode == ClipMode::Rectangle;
-}
-
-void FrameBuilder::deferBitmapOp(const BitmapOp& op) {
- BakedOpState* bakedState = tryBakeOpState(op);
- if (!bakedState) return; // quick rejected
-
- if (op.bitmap->isOpaque()) {
- bakedState->setupOpacity(op.paint);
- }
-
- // Don't merge non-simply transformed or neg scale ops, SET_TEXTURE doesn't handle rotation
- // Don't merge A8 bitmaps - the paint's color isn't compared by mergeId, or in
- // MergingDrawBatch::canMergeWith()
- if (bakedState->computedState.transform.isSimple() &&
- bakedState->computedState.transform.positiveScale() &&
- PaintUtils::getBlendModeDirect(op.paint) == SkBlendMode::kSrcOver &&
- op.bitmap->colorType() != kAlpha_8_SkColorType && hasMergeableClip(*bakedState)) {
- mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID());
- currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::Bitmap, mergeId);
- } else {
- currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
- }
-}
-
-void FrameBuilder::deferBitmapMeshOp(const BitmapMeshOp& op) {
- BakedOpState* bakedState = tryBakeOpState(op);
- if (!bakedState) return; // quick rejected
- currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
-}
-
-void FrameBuilder::deferBitmapRectOp(const BitmapRectOp& op) {
- BakedOpState* bakedState = tryBakeOpState(op);
- if (!bakedState) return; // quick rejected
- currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
-}
-
-void FrameBuilder::deferVectorDrawableOp(const VectorDrawableOp& op) {
- Bitmap& bitmap = op.vectorDrawable->getBitmapUpdateIfDirty();
- SkPaint* paint = op.vectorDrawable->getPaint();
- const BitmapRectOp* resolvedOp = mAllocator.create_trivial<BitmapRectOp>(
- op.unmappedBounds, op.localMatrix, op.localClip, paint, &bitmap,
- Rect(bitmap.width(), bitmap.height()));
- deferBitmapRectOp(*resolvedOp);
-}
-
-void FrameBuilder::deferCirclePropsOp(const CirclePropsOp& op) {
- // allocate a temporary oval op (with mAllocator, so it persists until render), so the
- // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple.
- float x = *(op.x);
- float y = *(op.y);
- float radius = *(op.radius);
- Rect unmappedBounds(x - radius, y - radius, x + radius, y + radius);
- const OvalOp* resolvedOp = mAllocator.create_trivial<OvalOp>(unmappedBounds, op.localMatrix,
- op.localClip, op.paint);
- deferOvalOp(*resolvedOp);
-}
-
-void FrameBuilder::deferColorOp(const ColorOp& op) {
- BakedOpState* bakedState = tryBakeUnboundedOpState(op);
- if (!bakedState) return; // quick rejected
- currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices);
-}
-
-void FrameBuilder::deferFunctorOp(const FunctorOp& op) {
- BakedOpState* bakedState = tryBakeUnboundedOpState(op);
- if (!bakedState) return; // quick rejected
- currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Functor);
-}
-
-void FrameBuilder::deferLinesOp(const LinesOp& op) {
- batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices;
- deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced);
-}
-
-void FrameBuilder::deferOvalOp(const OvalOp& op) {
- deferStrokeableOp(op, tessBatchId(op));
-}
-
-void FrameBuilder::deferPatchOp(const PatchOp& op) {
- BakedOpState* bakedState = tryBakeOpState(op);
- if (!bakedState) return; // quick rejected
-
- if (bakedState->computedState.transform.isPureTranslate() &&
- PaintUtils::getBlendModeDirect(op.paint) == SkBlendMode::kSrcOver &&
- hasMergeableClip(*bakedState)) {
- mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID());
-
- // Only use the MergedPatch batchId when merged, so Bitmap+Patch don't try to merge together
- currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::MergedPatch, mergeId);
- } else {
- // Use Bitmap batchId since Bitmap+Patch use same shader
- currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
- }
-}
-
-void FrameBuilder::deferPathOp(const PathOp& op) {
- /*auto state = */deferStrokeableOp(op, OpBatchType::AlphaMaskTexture);
-}
-
-void FrameBuilder::deferPointsOp(const PointsOp& op) {
- batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices;
- deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced);
-}
-
-void FrameBuilder::deferRectOp(const RectOp& op) {
- deferStrokeableOp(op, tessBatchId(op));
-}
-
-void FrameBuilder::deferRoundRectOp(const RoundRectOp& op) {
- // DEAD CODE
-}
-
-void FrameBuilder::deferRoundRectPropsOp(const RoundRectPropsOp& op) {
- // allocate a temporary round rect op (with mAllocator, so it persists until render), so the
- // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple.
- const RoundRectOp* resolvedOp = mAllocator.create_trivial<RoundRectOp>(
- Rect(*(op.left), *(op.top), *(op.right), *(op.bottom)), op.localMatrix, op.localClip,
- op.paint, *op.rx, *op.ry);
- deferRoundRectOp(*resolvedOp);
-}
-
-void FrameBuilder::deferSimpleRectsOp(const SimpleRectsOp& op) {
- BakedOpState* bakedState = tryBakeOpState(op);
- if (!bakedState) return; // quick rejected
- currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices);
-}
-
-void FrameBuilder::deferTextOp(const TextOp& op) {
- // DEAD CODE
-}
-
-void FrameBuilder::deferTextOnPathOp(const TextOnPathOp& op) {
- // DEAD CODE
-}
-
-void FrameBuilder::deferTextureLayerOp(const TextureLayerOp& op) {
- GlLayer* layer = static_cast<GlLayer*>(op.layerHandle->backingLayer());
- if (CC_UNLIKELY(!layer || !layer->isRenderable())) return;
-
- const TextureLayerOp* textureLayerOp = &op;
- // Now safe to access transform (which was potentially unready at record time)
- if (!layer->getTransform().isIdentity()) {
- // non-identity transform present, so 'inject it' into op by copying + replacing matrix
- Matrix4 combinedMatrix(op.localMatrix);
- combinedMatrix.multiply(layer->getTransform());
- textureLayerOp = mAllocator.create<TextureLayerOp>(op, combinedMatrix);
- }
- BakedOpState* bakedState = tryBakeOpState(*textureLayerOp);
-
- if (!bakedState) return; // quick rejected
- currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::TextureLayer);
-}
-
-void FrameBuilder::saveForLayer(uint32_t layerWidth, uint32_t layerHeight, float contentTranslateX,
- float contentTranslateY, const Rect& repaintRect,
- const Vector3& lightCenter, const BeginLayerOp* beginLayerOp,
- RenderNode* renderNode) {
- mCanvasState.save(SaveFlags::MatrixClip);
- mCanvasState.writableSnapshot()->initializeViewport(layerWidth, layerHeight);
- mCanvasState.writableSnapshot()->roundRectClipState = nullptr;
- mCanvasState.writableSnapshot()->setRelativeLightCenter(lightCenter);
- mCanvasState.writableSnapshot()->transform->loadTranslate(contentTranslateX, contentTranslateY,
- 0);
- mCanvasState.writableSnapshot()->setClip(repaintRect.left, repaintRect.top, repaintRect.right,
- repaintRect.bottom);
-
- // create a new layer repaint, and push its index on the stack
- mLayerStack.push_back(mLayerBuilders.size());
- auto newFbo = mAllocator.create<LayerBuilder>(layerWidth, layerHeight, repaintRect,
- beginLayerOp, renderNode);
- mLayerBuilders.push_back(newFbo);
-}
-
-void FrameBuilder::restoreForLayer() {
- // restore canvas, and pop finished layer off of the stack
- mCanvasState.restore();
- mLayerStack.pop_back();
-}
-
-// TODO: defer time rejection (when bounds become empty) + tests
-// Option - just skip layers with no bounds at playback + defer?
-void FrameBuilder::deferBeginLayerOp(const BeginLayerOp& op) {
- uint32_t layerWidth = (uint32_t)op.unmappedBounds.getWidth();
- uint32_t layerHeight = (uint32_t)op.unmappedBounds.getHeight();
-
- auto previous = mCanvasState.currentSnapshot();
- Vector3 lightCenter = previous->getRelativeLightCenter();
-
- // Combine all transforms used to present saveLayer content:
- // parent content transform * canvas transform * bounds offset
- Matrix4 contentTransform(*(previous->transform));
- contentTransform.multiply(op.localMatrix);
- contentTransform.translate(op.unmappedBounds.left, op.unmappedBounds.top);
-
- Matrix4 inverseContentTransform;
- inverseContentTransform.loadInverse(contentTransform);
-
- // map the light center into layer-relative space
- inverseContentTransform.mapPoint3d(lightCenter);
-
- // Clip bounds of temporary layer to parent's clip rect, so:
- Rect saveLayerBounds(layerWidth, layerHeight);
- // 1) transform Rect(width, height) into parent's space
- // note: left/top offsets put in contentTransform above
- contentTransform.mapRect(saveLayerBounds);
- // 2) intersect with parent's clip
- saveLayerBounds.doIntersect(previous->getRenderTargetClip());
- // 3) and transform back
- inverseContentTransform.mapRect(saveLayerBounds);
- saveLayerBounds.doIntersect(Rect(layerWidth, layerHeight));
- saveLayerBounds.roundOut();
-
- // if bounds are reduced, will clip the layer's area by reducing required bounds...
- layerWidth = saveLayerBounds.getWidth();
- layerHeight = saveLayerBounds.getHeight();
- // ...and shifting drawing content to account for left/top side clipping
- float contentTranslateX = -saveLayerBounds.left;
- float contentTranslateY = -saveLayerBounds.top;
-
- saveForLayer(layerWidth, layerHeight, contentTranslateX, contentTranslateY,
- Rect(layerWidth, layerHeight), lightCenter, &op, nullptr);
-}
-
-void FrameBuilder::deferEndLayerOp(const EndLayerOp& /* ignored */) {
- const BeginLayerOp& beginLayerOp = *currentLayer().beginLayerOp;
- int finishedLayerIndex = mLayerStack.back();
-
- restoreForLayer();
-
- // saveLayer will clip & translate the draw contents, so we need
- // to translate the drawLayer by how much the contents was translated
- // TODO: Unify this with beginLayerOp so we don't have to calculate this
- // twice
- uint32_t layerWidth = (uint32_t)beginLayerOp.unmappedBounds.getWidth();
- uint32_t layerHeight = (uint32_t)beginLayerOp.unmappedBounds.getHeight();
-
- auto previous = mCanvasState.currentSnapshot();
- Vector3 lightCenter = previous->getRelativeLightCenter();
-
- // Combine all transforms used to present saveLayer content:
- // parent content transform * canvas transform * bounds offset
- Matrix4 contentTransform(*(previous->transform));
- contentTransform.multiply(beginLayerOp.localMatrix);
- contentTransform.translate(beginLayerOp.unmappedBounds.left, beginLayerOp.unmappedBounds.top);
-
- Matrix4 inverseContentTransform;
- inverseContentTransform.loadInverse(contentTransform);
-
- // map the light center into layer-relative space
- inverseContentTransform.mapPoint3d(lightCenter);
-
- // Clip bounds of temporary layer to parent's clip rect, so:
- Rect saveLayerBounds(layerWidth, layerHeight);
- // 1) transform Rect(width, height) into parent's space
- // note: left/top offsets put in contentTransform above
- contentTransform.mapRect(saveLayerBounds);
- // 2) intersect with parent's clip
- saveLayerBounds.doIntersect(previous->getRenderTargetClip());
- // 3) and transform back
- inverseContentTransform.mapRect(saveLayerBounds);
- saveLayerBounds.doIntersect(Rect(layerWidth, layerHeight));
- saveLayerBounds.roundOut();
-
- Matrix4 localMatrix(beginLayerOp.localMatrix);
- localMatrix.translate(saveLayerBounds.left, saveLayerBounds.top);
-
- // record the draw operation into the previous layer's list of draw commands
- // uses state from the associated beginLayerOp, since it has all the state needed for drawing
- LayerOp* drawLayerOp = mAllocator.create_trivial<LayerOp>(
- beginLayerOp.unmappedBounds, localMatrix, beginLayerOp.localClip, beginLayerOp.paint,
- &(mLayerBuilders[finishedLayerIndex]->offscreenBuffer));
- BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp);
-
- if (bakedOpState) {
- // Layer will be drawn into parent layer (which is now current, since we popped mLayerStack)
- currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap);
- } else {
- // Layer won't be drawn - delete its drawing batches to prevent it from doing any work
- // TODO: need to prevent any render work from being done
- // - create layerop earlier for reject purposes?
- mLayerBuilders[finishedLayerIndex]->clear();
- return;
- }
-}
-
-void FrameBuilder::deferBeginUnclippedLayerOp(const BeginUnclippedLayerOp& op) {
- Matrix4 boundsTransform(*(mCanvasState.currentSnapshot()->transform));
- boundsTransform.multiply(op.localMatrix);
-
- Rect dstRect(op.unmappedBounds);
- boundsTransform.mapRect(dstRect);
- dstRect.roundOut();
- dstRect.doIntersect(mCanvasState.currentSnapshot()->getRenderTargetClip());
-
- if (dstRect.isEmpty()) {
- // Unclipped layer rejected - push a null op, so next EndUnclippedLayerOp is ignored
- currentLayer().activeUnclippedSaveLayers.push_back(nullptr);
- } else {
- // Allocate a holding position for the layer object (copyTo will produce, copyFrom will
- // consume)
- OffscreenBuffer** layerHandle = mAllocator.create<OffscreenBuffer*>(nullptr);
-
- /**
- * First, defer an operation to copy out the content from the rendertarget into a layer.
- */
- auto copyToOp = mAllocator.create_trivial<CopyToLayerOp>(op, layerHandle);
- BakedOpState* bakedState = BakedOpState::directConstruct(
- mAllocator, &(currentLayer().repaintClip), dstRect, *copyToOp);
- currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::CopyToLayer);
-
- /**
- * Defer a clear rect, so that clears from multiple unclipped layers can be drawn
- * both 1) simultaneously, and 2) as long after the copyToLayer executes as possible
- */
- currentLayer().deferLayerClear(dstRect);
-
- /**
- * And stash an operation to copy that layer back under the rendertarget until
- * a balanced EndUnclippedLayerOp is seen
- */
- auto copyFromOp = mAllocator.create_trivial<CopyFromLayerOp>(op, layerHandle);
- bakedState = BakedOpState::directConstruct(mAllocator, &(currentLayer().repaintClip),
- dstRect, *copyFromOp);
- currentLayer().activeUnclippedSaveLayers.push_back(bakedState);
- }
-}
-
-void FrameBuilder::deferEndUnclippedLayerOp(const EndUnclippedLayerOp& /* ignored */) {
- LOG_ALWAYS_FATAL_IF(currentLayer().activeUnclippedSaveLayers.empty(), "no layer to end!");
-
- BakedOpState* copyFromLayerOp = currentLayer().activeUnclippedSaveLayers.back();
- currentLayer().activeUnclippedSaveLayers.pop_back();
- if (copyFromLayerOp) {
- currentLayer().deferUnmergeableOp(mAllocator, copyFromLayerOp, OpBatchType::CopyFromLayer);
- }
-}
-
-void FrameBuilder::finishDefer() {
- // DEAD CODE
-}
-
-} // namespace uirenderer
-} // namespace android
diff --git a/libs/hwui/FrameBuilder.h b/libs/hwui/FrameBuilder.h
deleted file mode 100644
index 974daf8..0000000
--- a/libs/hwui/FrameBuilder.h
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include "BakedOpState.h"
-#include "CanvasState.h"
-#include "DisplayList.h"
-#include "LayerBuilder.h"
-#include "RecordedOp.h"
-#include "utils/GLUtils.h"
-
-#include <unordered_map>
-#include <vector>
-
-struct SkRect;
-
-namespace android {
-namespace uirenderer {
-
-class BakedOpState;
-class LayerUpdateQueue;
-class OffscreenBuffer;
-class Rect;
-
-/**
- * Processes, optimizes, and stores rendering commands from RenderNodes and
- * LayerUpdateQueue, building content needed to render a frame.
- *
- * Resolves final drawing state for each operation (including clip, alpha and matrix), and then
- * reorder and merge each op as it is resolved for drawing efficiency. Each layer of content (either
- * from the LayerUpdateQueue, or temporary layers created by saveLayer operations in the
- * draw stream) will create different reorder contexts, each in its own LayerBuilder.
- *
- * Then the prepared or 'baked' drawing commands can be issued by calling the templated
- * replayBakedOps() function, which will dispatch them (including any created merged op collections)
- * to a Dispatcher and Renderer. See BakedOpDispatcher for how these baked drawing operations are
- * resolved into Glops and rendered via BakedOpRenderer.
- *
- * This class is also the authoritative source for traversing RenderNodes, both for standard op
- * traversal within a DisplayList, and for out of order RenderNode traversal for Z and projection.
- */
-class FrameBuilder : public CanvasStateClient {
-public:
- struct LightGeometry {
- Vector3 center;
- float radius;
- };
-
- FrameBuilder(const SkRect& clip, uint32_t viewportWidth, uint32_t viewportHeight,
- const LightGeometry& lightGeometry, Caches& caches);
-
- FrameBuilder(const LayerUpdateQueue& layerUpdateQueue, const LightGeometry& lightGeometry,
- Caches& caches);
-
- void deferLayers(const LayerUpdateQueue& layers);
-
- void deferRenderNode(RenderNode& renderNode);
-
- void deferRenderNode(float tx, float ty, Rect clipRect, RenderNode& renderNode);
-
- void deferRenderNodeScene(const std::vector<sp<RenderNode> >& nodes,
- const Rect& contentDrawBounds);
-
- virtual ~FrameBuilder() {}
-
- /**
- * replayBakedOps() is templated based on what class will receive ops being replayed.
- *
- * It constructs a lookup array of lambdas, which allows a recorded BakeOpState to use
- * state->op->opId to lookup a receiver that will be called when the op is replayed.
- */
- template <typename StaticDispatcher, typename Renderer>
- void replayBakedOps(Renderer& renderer) {
- std::vector<OffscreenBuffer*> temporaryLayers;
- finishDefer();
-/**
- * Defines a LUT of lambdas which allow a recorded BakedOpState to use state->op->opId to
- * dispatch the op via a method on a static dispatcher when the op is replayed.
- *
- * For example a BitmapOp would resolve, via the lambda lookup, to calling:
- *
- * StaticDispatcher::onBitmapOp(Renderer& renderer, const BitmapOp& op, const BakedOpState& state);
- */
-#define X(Type) \
- [](void* renderer, const BakedOpState& state) { \
- StaticDispatcher::on##Type(*(static_cast<Renderer*>(renderer)), \
- static_cast<const Type&>(*(state.op)), state); \
- },
- static BakedOpReceiver unmergedReceivers[] = BUILD_RENDERABLE_OP_LUT(X);
-#undef X
-
-/**
- * Defines a LUT of lambdas which allow merged arrays of BakedOpState* to be passed to a
- * static dispatcher when the group of merged ops is replayed.
- */
-#define X(Type) \
- [](void* renderer, const MergedBakedOpList& opList) { \
- StaticDispatcher::onMerged##Type##s(*(static_cast<Renderer*>(renderer)), opList); \
- },
- static MergedOpReceiver mergedReceivers[] = BUILD_MERGEABLE_OP_LUT(X);
-#undef X
-
- // Relay through layers in reverse order, since layers
- // later in the list will be drawn by earlier ones
- for (int i = mLayerBuilders.size() - 1; i >= 1; i--) {
- GL_CHECKPOINT(MODERATE);
- LayerBuilder& layer = *(mLayerBuilders[i]);
- if (layer.renderNode) {
- // cached HW layer - can't skip layer if empty
- renderer.startRepaintLayer(layer.offscreenBuffer, layer.repaintRect);
- GL_CHECKPOINT(MODERATE);
- layer.replayBakedOpsImpl((void*)&renderer, unmergedReceivers, mergedReceivers);
- GL_CHECKPOINT(MODERATE);
- renderer.endLayer();
- } else if (!layer.empty()) {
- // save layer - skip entire layer if empty (in which case, LayerOp has null layer).
- layer.offscreenBuffer = renderer.startTemporaryLayer(layer.width, layer.height);
- temporaryLayers.push_back(layer.offscreenBuffer);
- GL_CHECKPOINT(MODERATE);
- layer.replayBakedOpsImpl((void*)&renderer, unmergedReceivers, mergedReceivers);
- GL_CHECKPOINT(MODERATE);
- renderer.endLayer();
- }
- }
-
- GL_CHECKPOINT(MODERATE);
- if (CC_LIKELY(mDrawFbo0)) {
- const LayerBuilder& fbo0 = *(mLayerBuilders[0]);
- renderer.startFrame(fbo0.width, fbo0.height, fbo0.repaintRect);
- GL_CHECKPOINT(MODERATE);
- fbo0.replayBakedOpsImpl((void*)&renderer, unmergedReceivers, mergedReceivers);
- GL_CHECKPOINT(MODERATE);
- renderer.endFrame(fbo0.repaintRect);
- }
-
- for (auto& temporaryLayer : temporaryLayers) {
- renderer.recycleTemporaryLayer(temporaryLayer);
- }
- }
-
- void dump() const {
- for (auto&& layer : mLayerBuilders) {
- layer->dump();
- }
- }
-
- ///////////////////////////////////////////////////////////////////
- /// CanvasStateClient interface
- ///////////////////////////////////////////////////////////////////
- virtual void onViewportInitialized() override;
- virtual void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) override;
- virtual GLuint getTargetFbo() const override { return 0; }
-
-private:
- void finishDefer();
- enum class ChildrenSelectMode { Negative, Positive };
- void saveForLayer(uint32_t layerWidth, uint32_t layerHeight, float contentTranslateX,
- float contentTranslateY, const Rect& repaintRect, const Vector3& lightCenter,
- const BeginLayerOp* beginLayerOp, RenderNode* renderNode);
- void restoreForLayer();
-
- LayerBuilder& currentLayer() { return *(mLayerBuilders[mLayerStack.back()]); }
-
- BakedOpState* tryBakeOpState(const RecordedOp& recordedOp) {
- return BakedOpState::tryConstruct(mAllocator, *mCanvasState.writableSnapshot(), recordedOp);
- }
- BakedOpState* tryBakeUnboundedOpState(const RecordedOp& recordedOp) {
- return BakedOpState::tryConstructUnbounded(mAllocator, *mCanvasState.writableSnapshot(),
- recordedOp);
- }
-
- // should always be surrounded by a save/restore pair, and not called if DisplayList is null
- void deferNodePropsAndOps(RenderNode& node);
-
- template <typename V>
- void defer3dChildren(const ClipBase* reorderClip, ChildrenSelectMode mode,
- const V& zTranslatedNodes);
-
- void deferShadow(const ClipBase* reorderClip, const RenderNodeOp& casterOp);
-
- void deferProjectedChildren(const RenderNode& renderNode);
-
- void deferNodeOps(const RenderNode& renderNode);
-
- void deferRenderNodeOpImpl(const RenderNodeOp& op);
-
- void replayBakedOpsImpl(void* arg, BakedOpReceiver* receivers);
-
- SkPath* createFrameAllocatedPath() { return mAllocator.create<SkPath>(); }
-
- BakedOpState* deferStrokeableOp(const RecordedOp& op, batchid_t batchId,
- BakedOpState::StrokeBehavior strokeBehavior =
- BakedOpState::StrokeBehavior::StyleDefined,
- bool expandForPathTexture = false);
-
-/**
- * Declares all FrameBuilder::deferXXXXOp() methods for every RecordedOp type.
- *
- * These private methods are called from within deferImpl to defer each individual op
- * type differently.
- */
-#define X(Type) void defer##Type(const Type& op);
- MAP_DEFERRABLE_OPS(X)
-#undef X
-
- // contains single-frame objects, such as BakedOpStates, LayerBuilders, Batches
- LinearAllocator mAllocator;
- LinearStdAllocator<void*> mStdAllocator;
-
- // List of every deferred layer's render state. Replayed in reverse order to render a frame.
- LsaVector<LayerBuilder*> mLayerBuilders;
-
- /*
- * Stack of indices within mLayerBuilders representing currently active layers. If drawing
- * layerA within a layerB, will contain, in order:
- * - 0 (representing FBO 0, always present)
- * - layerB's index
- * - layerA's index
- *
- * Note that this doesn't vector doesn't always map onto all values of mLayerBuilders. When a
- * layer is finished deferring, it will still be represented in mLayerBuilders, but it's index
- * won't be in mLayerStack. This is because it can be replayed, but can't have any more drawing
- * ops added to it.
- */
- LsaVector<size_t> mLayerStack;
-
- CanvasState mCanvasState;
-
- Caches& mCaches;
-
- float mLightRadius;
-
- const bool mDrawFbo0;
-};
-
-}; // namespace uirenderer
-}; // namespace android
diff --git a/libs/hwui/Lighting.h b/libs/hwui/Lighting.h
new file mode 100644
index 0000000..d972c21
--- /dev/null
+++ b/libs/hwui/Lighting.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include "Vector.h"
+
+namespace android {
+namespace uirenderer {
+
+struct LightGeometry {
+ Vector3 center;
+ float radius;
+};
+
+struct LightInfo {
+ LightInfo() : LightInfo(0, 0) {}
+ LightInfo(uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha)
+ : ambientShadowAlpha(ambientShadowAlpha), spotShadowAlpha(spotShadowAlpha) {}
+ uint8_t ambientShadowAlpha;
+ uint8_t spotShadowAlpha;
+};
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/RecordingCanvas.cpp b/libs/hwui/RecordingCanvas.cpp
deleted file mode 100644
index e1df1e7..0000000
--- a/libs/hwui/RecordingCanvas.cpp
+++ /dev/null
@@ -1,631 +0,0 @@
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "RecordingCanvas.h"
-
-#include "DeferredLayerUpdater.h"
-#include "RecordedOp.h"
-#include "RenderNode.h"
-#include "VectorDrawable.h"
-#include "hwui/MinikinUtils.h"
-
-namespace android {
-namespace uirenderer {
-
-RecordingCanvas::RecordingCanvas(size_t width, size_t height)
- : mState(*this), mResourceCache(ResourceCache::getInstance()) {
- resetRecording(width, height);
-}
-
-RecordingCanvas::~RecordingCanvas() {
- LOG_ALWAYS_FATAL_IF(mDisplayList, "Destroyed a RecordingCanvas during a record!");
-}
-
-void RecordingCanvas::resetRecording(int width, int height, RenderNode* node) {
- LOG_ALWAYS_FATAL_IF(mDisplayList, "prepareDirty called a second time during a recording!");
- mDisplayList = new DisplayList();
-
- mState.initializeRecordingSaveStack(width, height);
-
- mDeferredBarrierType = DeferredBarrierType::InOrder;
-}
-
-DisplayList* RecordingCanvas::finishRecording() {
- restoreToCount(1);
- mPaintMap.clear();
- mRegionMap.clear();
- mPathMap.clear();
- DisplayList* displayList = mDisplayList;
- mDisplayList = nullptr;
- mSkiaCanvasProxy.reset(nullptr);
- return displayList;
-}
-
-void RecordingCanvas::insertReorderBarrier(bool enableReorder) {
- if (enableReorder) {
- mDeferredBarrierType = DeferredBarrierType::OutOfOrder;
- mDeferredBarrierClip = getRecordedClip();
- } else {
- mDeferredBarrierType = DeferredBarrierType::InOrder;
- mDeferredBarrierClip = nullptr;
- }
-}
-
-SkCanvas* RecordingCanvas::asSkCanvas() {
- LOG_ALWAYS_FATAL_IF(!mDisplayList, "attempting to get an SkCanvas when we are not recording!");
- if (!mSkiaCanvasProxy) {
- mSkiaCanvasProxy.reset(new SkiaCanvasProxy(this));
- }
-
- // SkCanvas instances default to identity transform, but should inherit
- // the state of this Canvas; if this code was in the SkiaCanvasProxy
- // constructor, we couldn't cache mSkiaCanvasProxy.
- SkMatrix parentTransform;
- getMatrix(&parentTransform);
- mSkiaCanvasProxy.get()->setMatrix(parentTransform);
-
- return mSkiaCanvasProxy.get();
-}
-
-// ----------------------------------------------------------------------------
-// CanvasStateClient implementation
-// ----------------------------------------------------------------------------
-
-void RecordingCanvas::onViewportInitialized() {}
-
-void RecordingCanvas::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {
- if (removed.flags & Snapshot::kFlagIsFboLayer) {
- addOp(alloc().create_trivial<EndLayerOp>());
- } else if (removed.flags & Snapshot::kFlagIsLayer) {
- addOp(alloc().create_trivial<EndUnclippedLayerOp>());
- }
-}
-
-// ----------------------------------------------------------------------------
-// android/graphics/Canvas state operations
-// ----------------------------------------------------------------------------
-// Save (layer)
-int RecordingCanvas::save(SaveFlags::Flags flags) {
- return mState.save((int)flags);
-}
-
-void RecordingCanvas::RecordingCanvas::restore() {
- mState.restore();
-}
-
-void RecordingCanvas::restoreToCount(int saveCount) {
- mState.restoreToCount(saveCount);
-}
-
-int RecordingCanvas::saveLayer(float left, float top, float right, float bottom,
- const SkPaint* paint, SaveFlags::Flags flags) {
- // force matrix/clip isolation for layer
- flags |= SaveFlags::MatrixClip;
- bool clippedLayer = flags & SaveFlags::ClipToLayer;
-
- const Snapshot& previous = *mState.currentSnapshot();
-
- // initialize the snapshot as though it almost represents an FBO layer so deferred draw
- // operations will be able to store and restore the current clip and transform info, and
- // quick rejection will be correct (for display lists)
-
- Rect unmappedBounds(left, top, right, bottom);
- unmappedBounds.roundOut();
-
- // determine clipped bounds relative to previous viewport.
- Rect visibleBounds = unmappedBounds;
- previous.transform->mapRect(visibleBounds);
-
- if (CC_UNLIKELY(!clippedLayer && previous.transform->rectToRect() &&
- visibleBounds.contains(previous.getRenderTargetClip()))) {
- // unlikely case where an unclipped savelayer is recorded with a clip it can use,
- // as none of its unaffected/unclipped area is visible
- clippedLayer = true;
- flags |= SaveFlags::ClipToLayer;
- }
-
- visibleBounds.doIntersect(previous.getRenderTargetClip());
- visibleBounds.snapToPixelBoundaries();
- visibleBounds.doIntersect(Rect(previous.getViewportWidth(), previous.getViewportHeight()));
-
- // Map visible bounds back to layer space, and intersect with parameter bounds
- Rect layerBounds = visibleBounds;
- if (CC_LIKELY(!layerBounds.isEmpty())) {
- // if non-empty, can safely map by the inverse transform
- Matrix4 inverse;
- inverse.loadInverse(*previous.transform);
- inverse.mapRect(layerBounds);
- layerBounds.doIntersect(unmappedBounds);
- }
-
- int saveValue = mState.save((int)flags);
- Snapshot& snapshot = *mState.writableSnapshot();
-
- // layerBounds is in original bounds space, but clipped by current recording clip
- if (!layerBounds.isEmpty() && !unmappedBounds.isEmpty()) {
- if (CC_LIKELY(clippedLayer)) {
- auto previousClip = getRecordedClip(); // capture before new snapshot clip has changed
- if (addOp(alloc().create_trivial<BeginLayerOp>(
- unmappedBounds,
- *previous.transform, // transform to *draw* with
- previousClip, // clip to *draw* with
- refPaint(paint))) >= 0) {
- snapshot.flags |= Snapshot::kFlagIsLayer | Snapshot::kFlagIsFboLayer;
- snapshot.initializeViewport(unmappedBounds.getWidth(), unmappedBounds.getHeight());
- snapshot.transform->loadTranslate(-unmappedBounds.left, -unmappedBounds.top, 0.0f);
-
- Rect clip = layerBounds;
- clip.translate(-unmappedBounds.left, -unmappedBounds.top);
- snapshot.resetClip(clip.left, clip.top, clip.right, clip.bottom);
- snapshot.roundRectClipState = nullptr;
- return saveValue;
- }
- } else {
- if (addOp(alloc().create_trivial<BeginUnclippedLayerOp>(
- unmappedBounds, *mState.currentSnapshot()->transform, getRecordedClip(),
- refPaint(paint))) >= 0) {
- snapshot.flags |= Snapshot::kFlagIsLayer;
- return saveValue;
- }
- }
- }
-
- // Layer not needed, so skip recording it...
- if (CC_LIKELY(clippedLayer)) {
- // ... and set empty clip to reject inner content, if possible
- snapshot.resetClip(0, 0, 0, 0);
- }
- return saveValue;
-}
-
-// Matrix
-void RecordingCanvas::rotate(float degrees) {
- if (degrees == 0) return;
-
- mState.rotate(degrees);
-}
-
-void RecordingCanvas::scale(float sx, float sy) {
- if (sx == 1 && sy == 1) return;
-
- mState.scale(sx, sy);
-}
-
-void RecordingCanvas::skew(float sx, float sy) {
- mState.skew(sx, sy);
-}
-
-void RecordingCanvas::translate(float dx, float dy) {
- if (dx == 0 && dy == 0) return;
-
- mState.translate(dx, dy, 0);
-}
-
-// Clip
-bool RecordingCanvas::getClipBounds(SkRect* outRect) const {
- *outRect = mState.getLocalClipBounds().toSkRect();
- return !(outRect->isEmpty());
-}
-bool RecordingCanvas::quickRejectRect(float left, float top, float right, float bottom) const {
- return mState.quickRejectConservative(left, top, right, bottom);
-}
-bool RecordingCanvas::quickRejectPath(const SkPath& path) const {
- SkRect bounds = path.getBounds();
- return mState.quickRejectConservative(bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom);
-}
-bool RecordingCanvas::clipRect(float left, float top, float right, float bottom, SkClipOp op) {
- return mState.clipRect(left, top, right, bottom, op);
-}
-bool RecordingCanvas::clipPath(const SkPath* path, SkClipOp op) {
- return mState.clipPath(path, op);
-}
-
-// ----------------------------------------------------------------------------
-// android/graphics/Canvas draw operations
-// ----------------------------------------------------------------------------
-void RecordingCanvas::drawColor(int color, SkBlendMode mode) {
- addOp(alloc().create_trivial<ColorOp>(getRecordedClip(), color, mode));
-}
-
-void RecordingCanvas::drawPaint(const SkPaint& paint) {
- SkRect bounds;
- if (getClipBounds(&bounds)) {
- drawRect(bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom, paint);
- }
-}
-
-static Rect calcBoundsOfPoints(const float* points, int floatCount) {
- Rect unmappedBounds(points[0], points[1], points[0], points[1]);
- for (int i = 2; i < floatCount; i += 2) {
- unmappedBounds.expandToCover(points[i], points[i + 1]);
- }
- return unmappedBounds;
-}
-
-// Geometry
-void RecordingCanvas::drawPoints(const float* points, int floatCount, const SkPaint& paint) {
- if (CC_UNLIKELY(floatCount < 2 || paint.nothingToDraw())) return;
- floatCount &= ~0x1; // round down to nearest two
-
- addOp(alloc().create_trivial<PointsOp>(
- calcBoundsOfPoints(points, floatCount), *mState.currentSnapshot()->transform,
- getRecordedClip(), refPaint(&paint), refBuffer<float>(points, floatCount), floatCount));
-}
-
-void RecordingCanvas::drawLines(const float* points, int floatCount, const SkPaint& paint) {
- if (CC_UNLIKELY(floatCount < 4 || paint.nothingToDraw())) return;
- floatCount &= ~0x3; // round down to nearest four
-
- addOp(alloc().create_trivial<LinesOp>(
- calcBoundsOfPoints(points, floatCount), *mState.currentSnapshot()->transform,
- getRecordedClip(), refPaint(&paint), refBuffer<float>(points, floatCount), floatCount));
-}
-
-void RecordingCanvas::drawRect(float left, float top, float right, float bottom,
- const SkPaint& paint) {
- if (CC_UNLIKELY(paint.nothingToDraw())) return;
-
- addOp(alloc().create_trivial<RectOp>(Rect(left, top, right, bottom),
- *(mState.currentSnapshot()->transform), getRecordedClip(),
- refPaint(&paint)));
-}
-
-void RecordingCanvas::drawSimpleRects(const float* rects, int vertexCount, const SkPaint* paint) {
- if (rects == nullptr) return;
-
- Vertex* rectData = (Vertex*)mDisplayList->allocator.create_trivial_array<Vertex>(vertexCount);
- Vertex* vertex = rectData;
-
- float left = FLT_MAX;
- float top = FLT_MAX;
- float right = FLT_MIN;
- float bottom = FLT_MIN;
- for (int index = 0; index < vertexCount; index += 4) {
- float l = rects[index + 0];
- float t = rects[index + 1];
- float r = rects[index + 2];
- float b = rects[index + 3];
-
- Vertex::set(vertex++, l, t);
- Vertex::set(vertex++, r, t);
- Vertex::set(vertex++, l, b);
- Vertex::set(vertex++, r, b);
-
- left = std::min(left, l);
- top = std::min(top, t);
- right = std::max(right, r);
- bottom = std::max(bottom, b);
- }
- addOp(alloc().create_trivial<SimpleRectsOp>(
- Rect(left, top, right, bottom), *(mState.currentSnapshot()->transform),
- getRecordedClip(), refPaint(paint), rectData, vertexCount));
-}
-
-void RecordingCanvas::drawRegion(const SkRegion& region, const SkPaint& paint) {
- if (CC_UNLIKELY(paint.nothingToDraw())) return;
-
- if (paint.getStyle() == SkPaint::kFill_Style &&
- (!paint.isAntiAlias() || mState.currentTransform()->isSimple())) {
- int count = 0;
- Vector<float> rects;
- SkRegion::Iterator it(region);
- while (!it.done()) {
- const SkIRect& r = it.rect();
- rects.push(r.fLeft);
- rects.push(r.fTop);
- rects.push(r.fRight);
- rects.push(r.fBottom);
- count += 4;
- it.next();
- }
- drawSimpleRects(rects.array(), count, &paint);
- } else {
- SkRegion::Iterator it(region);
- while (!it.done()) {
- const SkIRect& r = it.rect();
- drawRect(r.fLeft, r.fTop, r.fRight, r.fBottom, paint);
- it.next();
- }
- }
-}
-
-void RecordingCanvas::drawRoundRect(float left, float top, float right, float bottom, float rx,
- float ry, const SkPaint& paint) {
- if (CC_UNLIKELY(paint.nothingToDraw())) return;
-
- if (CC_LIKELY(MathUtils::isPositive(rx) || MathUtils::isPositive(ry))) {
- addOp(alloc().create_trivial<RoundRectOp>(Rect(left, top, right, bottom),
- *(mState.currentSnapshot()->transform),
- getRecordedClip(), refPaint(&paint), rx, ry));
- } else {
- drawRect(left, top, right, bottom, paint);
- }
-}
-
-void RecordingCanvas::drawRoundRect(CanvasPropertyPrimitive* left, CanvasPropertyPrimitive* top,
- CanvasPropertyPrimitive* right, CanvasPropertyPrimitive* bottom,
- CanvasPropertyPrimitive* rx, CanvasPropertyPrimitive* ry,
- CanvasPropertyPaint* paint) {
- mDisplayList->ref(left);
- mDisplayList->ref(top);
- mDisplayList->ref(right);
- mDisplayList->ref(bottom);
- mDisplayList->ref(rx);
- mDisplayList->ref(ry);
- mDisplayList->ref(paint);
- refBitmapsInShader(paint->value.getShader());
- addOp(alloc().create_trivial<RoundRectPropsOp>(
- *(mState.currentSnapshot()->transform), getRecordedClip(), &paint->value, &left->value,
- &top->value, &right->value, &bottom->value, &rx->value, &ry->value));
-}
-
-void RecordingCanvas::drawCircle(float x, float y, float radius, const SkPaint& paint) {
- // TODO: move to Canvas.h
- if (CC_UNLIKELY(radius <= 0 || paint.nothingToDraw())) return;
-
- drawOval(x - radius, y - radius, x + radius, y + radius, paint);
-}
-
-void RecordingCanvas::drawCircle(CanvasPropertyPrimitive* x, CanvasPropertyPrimitive* y,
- CanvasPropertyPrimitive* radius, CanvasPropertyPaint* paint) {
- mDisplayList->ref(x);
- mDisplayList->ref(y);
- mDisplayList->ref(radius);
- mDisplayList->ref(paint);
- refBitmapsInShader(paint->value.getShader());
- addOp(alloc().create_trivial<CirclePropsOp>(*(mState.currentSnapshot()->transform),
- getRecordedClip(), &paint->value, &x->value,
- &y->value, &radius->value));
-}
-
-void RecordingCanvas::drawOval(float left, float top, float right, float bottom,
- const SkPaint& paint) {
- if (CC_UNLIKELY(paint.nothingToDraw())) return;
-
- addOp(alloc().create_trivial<OvalOp>(Rect(left, top, right, bottom),
- *(mState.currentSnapshot()->transform), getRecordedClip(),
- refPaint(&paint)));
-}
-
-void RecordingCanvas::drawArc(float left, float top, float right, float bottom, float startAngle,
- float sweepAngle, bool useCenter, const SkPaint& paint) {
- if (CC_UNLIKELY(paint.nothingToDraw())) return;
-
- if (fabs(sweepAngle) >= 360.0f) {
- drawOval(left, top, right, bottom, paint);
- } else {
- addOp(alloc().create_trivial<ArcOp>(
- Rect(left, top, right, bottom), *(mState.currentSnapshot()->transform),
- getRecordedClip(), refPaint(&paint), startAngle, sweepAngle, useCenter));
- }
-}
-
-void RecordingCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
- if (CC_UNLIKELY(paint.nothingToDraw())) return;
-
- addOp(alloc().create_trivial<PathOp>(Rect(path.getBounds()),
- *(mState.currentSnapshot()->transform), getRecordedClip(),
- refPaint(&paint), refPath(&path)));
-}
-
-void RecordingCanvas::drawVectorDrawable(VectorDrawableRoot* tree) {
- mDisplayList->ref(tree);
- mDisplayList->vectorDrawables.push_back(tree);
- addOp(alloc().create_trivial<VectorDrawableOp>(
- tree, Rect(tree->stagingProperties()->getBounds()),
- *(mState.currentSnapshot()->transform), getRecordedClip()));
-}
-
-// Bitmap-based
-void RecordingCanvas::drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) {
- save(SaveFlags::Matrix);
- translate(left, top);
- drawBitmap(bitmap, paint);
- restore();
-}
-
-void RecordingCanvas::drawBitmap(Bitmap& bitmap, const SkMatrix& matrix, const SkPaint* paint) {
- if (matrix.isIdentity()) {
- drawBitmap(bitmap, paint);
- } else if (!(matrix.getType() & ~(SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) &&
- MathUtils::isPositive(matrix.getScaleX()) &&
- MathUtils::isPositive(matrix.getScaleY())) {
- // SkMatrix::isScaleTranslate() not available in L
- SkRect src;
- SkRect dst;
- bitmap.getBounds(&src);
- matrix.mapRect(&dst, src);
- drawBitmap(bitmap, src.fLeft, src.fTop, src.fRight, src.fBottom, dst.fLeft, dst.fTop,
- dst.fRight, dst.fBottom, paint);
- } else {
- save(SaveFlags::Matrix);
- concat(matrix);
- drawBitmap(bitmap, paint);
- restore();
- }
-}
-
-void RecordingCanvas::drawBitmap(Bitmap& bitmap, float srcLeft, float srcTop, float srcRight,
- float srcBottom, float dstLeft, float dstTop, float dstRight,
- float dstBottom, const SkPaint* paint) {
- if (srcLeft == 0 && srcTop == 0 && srcRight == bitmap.width() && srcBottom == bitmap.height() &&
- (srcBottom - srcTop == dstBottom - dstTop) && (srcRight - srcLeft == dstRight - dstLeft)) {
- // transform simple rect to rect drawing case into position bitmap ops, since they merge
- save(SaveFlags::Matrix);
- translate(dstLeft, dstTop);
- drawBitmap(bitmap, paint);
- restore();
- } else {
- addOp(alloc().create_trivial<BitmapRectOp>(
- Rect(dstLeft, dstTop, dstRight, dstBottom), *(mState.currentSnapshot()->transform),
- getRecordedClip(), refPaint(paint), refBitmap(bitmap),
- Rect(srcLeft, srcTop, srcRight, srcBottom)));
- }
-}
-
-void RecordingCanvas::drawBitmapMesh(Bitmap& bitmap, int meshWidth, int meshHeight,
- const float* vertices, const int* colors,
- const SkPaint* paint) {
- int vertexCount = (meshWidth + 1) * (meshHeight + 1);
- addOp(alloc().create_trivial<BitmapMeshOp>(
- calcBoundsOfPoints(vertices, vertexCount * 2), *(mState.currentSnapshot()->transform),
- getRecordedClip(), refPaint(paint), refBitmap(bitmap), meshWidth, meshHeight,
- refBuffer<float>(vertices, vertexCount * 2), // 2 floats per vertex
- refBuffer<int>(colors, vertexCount))); // 1 color per vertex
-}
-
-void RecordingCanvas::drawNinePatch(Bitmap& bitmap, const android::Res_png_9patch& patch,
- float dstLeft, float dstTop, float dstRight, float dstBottom,
- const SkPaint* paint) {
- addOp(alloc().create_trivial<PatchOp>(Rect(dstLeft, dstTop, dstRight, dstBottom),
- *(mState.currentSnapshot()->transform), getRecordedClip(),
- refPaint(paint), refBitmap(bitmap), refPatch(&patch)));
-}
-
-double RecordingCanvas::drawAnimatedImage(AnimatedImageDrawable*) {
- // Unimplemented
- return 0;
-}
-
-// Text
-void RecordingCanvas::drawGlyphs(ReadGlyphFunc glyphFunc, int glyphCount, const SkPaint& paint,
- float x, float y, float boundsLeft, float boundsTop,
- float boundsRight, float boundsBottom, float totalAdvance) {
- if (glyphCount <= 0 || paint.nothingToDraw()) return;
- uint16_t* glyphs = (glyph_t*)alloc().alloc<glyph_t>(glyphCount * sizeof(glyph_t));
- float* positions = (float*)alloc().alloc<float>(2 * glyphCount * sizeof(float));
- glyphFunc(glyphs, positions);
-
- // TODO: either must account for text shadow in bounds, or record separate ops for text shadows
- addOp(alloc().create_trivial<TextOp>(Rect(boundsLeft, boundsTop, boundsRight, boundsBottom),
- *(mState.currentSnapshot()->transform), getRecordedClip(),
- refPaint(&paint), glyphs, positions, glyphCount, x, y));
- drawTextDecorations(x, y, totalAdvance, paint);
-}
-
-void RecordingCanvas::drawLayoutOnPath(const minikin::Layout& layout, float hOffset, float vOffset,
- const SkPaint& paint, const SkPath& path, size_t start,
- size_t end) {
- uint16_t glyphs[1];
- for (size_t i = start; i < end; i++) {
- glyphs[0] = layout.getGlyphId(i);
- float x = hOffset + layout.getX(i);
- float y = vOffset + layout.getY(i);
- if (paint.nothingToDraw()) return;
- const uint16_t* tempGlyphs = refBuffer<glyph_t>(glyphs, 1);
- addOp(alloc().create_trivial<TextOnPathOp>(*(mState.currentSnapshot()->transform),
- getRecordedClip(), refPaint(&paint), tempGlyphs,
- 1, refPath(&path), x, y));
- }
-}
-
-void RecordingCanvas::drawBitmap(Bitmap& bitmap, const SkPaint* paint) {
- addOp(alloc().create_trivial<BitmapOp>(Rect(bitmap.width(), bitmap.height()),
- *(mState.currentSnapshot()->transform),
- getRecordedClip(), refPaint(paint), refBitmap(bitmap)));
-}
-
-void RecordingCanvas::drawRenderNode(RenderNode* renderNode) {
- auto&& stagingProps = renderNode->stagingProperties();
- RenderNodeOp* op = alloc().create_trivial<RenderNodeOp>(
- Rect(stagingProps.getWidth(), stagingProps.getHeight()),
- *(mState.currentSnapshot()->transform), getRecordedClip(), renderNode);
- int opIndex = addOp(op);
- if (CC_LIKELY(opIndex >= 0)) {
- int childIndex = mDisplayList->addChild(op);
-
- // update the chunk's child indices
- DisplayList::Chunk& chunk = mDisplayList->chunks.back();
- chunk.endChildIndex = childIndex + 1;
-
- if (renderNode->stagingProperties().isProjectionReceiver()) {
- // use staging property, since recording on UI thread
- mDisplayList->projectionReceiveIndex = opIndex;
- }
- }
-}
-
-void RecordingCanvas::drawLayer(DeferredLayerUpdater* layerHandle) {
- // We ref the DeferredLayerUpdater due to its thread-safe ref-counting semantics.
- mDisplayList->ref(layerHandle);
-
- LOG_ALWAYS_FATAL_IF(layerHandle->getBackingLayerApi() != Layer::Api::OpenGL);
- // Note that the backing layer has *not* yet been updated, so don't trust
- // its width, height, transform, etc...!
- addOp(alloc().create_trivial<TextureLayerOp>(
- Rect(layerHandle->getWidth(), layerHandle->getHeight()),
- *(mState.currentSnapshot()->transform), getRecordedClip(), layerHandle));
-}
-
-void RecordingCanvas::callDrawGLFunction(Functor* functor, GlFunctorLifecycleListener* listener) {
- mDisplayList->functors.push_back({functor, listener});
- mDisplayList->ref(listener);
- addOp(alloc().create_trivial<FunctorOp>(*(mState.currentSnapshot()->transform),
- getRecordedClip(), functor));
-}
-
-int RecordingCanvas::addOp(RecordedOp* op) {
- // skip op with empty clip
- if (op->localClip && op->localClip->rect.isEmpty()) {
- // NOTE: this rejection happens after op construction/content ref-ing, so content ref'd
- // and held by renderthread isn't affected by clip rejection.
- // Could rewind alloc here if desired, but callers would have to not touch op afterwards.
- return -1;
- }
-
- int insertIndex = mDisplayList->ops.size();
- mDisplayList->ops.push_back(op);
- if (mDeferredBarrierType != DeferredBarrierType::None) {
- // op is first in new chunk
- mDisplayList->chunks.emplace_back();
- DisplayList::Chunk& newChunk = mDisplayList->chunks.back();
- newChunk.beginOpIndex = insertIndex;
- newChunk.endOpIndex = insertIndex + 1;
- newChunk.reorderChildren = (mDeferredBarrierType == DeferredBarrierType::OutOfOrder);
- newChunk.reorderClip = mDeferredBarrierClip;
-
- int nextChildIndex = mDisplayList->children.size();
- newChunk.beginChildIndex = newChunk.endChildIndex = nextChildIndex;
- mDeferredBarrierType = DeferredBarrierType::None;
- } else {
- // standard case - append to existing chunk
- mDisplayList->chunks.back().endOpIndex = insertIndex + 1;
- }
- return insertIndex;
-}
-
-void RecordingCanvas::refBitmapsInShader(const SkShader* shader) {
- if (!shader) return;
-
- // If this paint has an SkShader that has an SkBitmap add
- // it to the bitmap pile
- SkBitmap bitmap;
- SkShader::TileMode xy[2];
- if (shader->isABitmap(&bitmap, nullptr, xy)) {
- Bitmap* hwuiBitmap = static_cast<Bitmap*>(bitmap.pixelRef());
- refBitmap(*hwuiBitmap);
- return;
- }
- SkShader::ComposeRec rec;
- if (shader->asACompose(&rec)) {
- refBitmapsInShader(rec.fShaderA);
- refBitmapsInShader(rec.fShaderB);
- return;
- }
-}
-
-}; // namespace uirenderer
-}; // namespace android
diff --git a/libs/hwui/RecordingCanvas.h b/libs/hwui/RecordingCanvas.h
deleted file mode 100644
index e663402..0000000
--- a/libs/hwui/RecordingCanvas.h
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ANDROID_HWUI_RECORDING_CANVAS_H
-#define ANDROID_HWUI_RECORDING_CANVAS_H
-
-#include "CanvasState.h"
-#include "DisplayList.h"
-#include "ResourceCache.h"
-#include "SkiaCanvasProxy.h"
-#include "Snapshot.h"
-#include "hwui/Bitmap.h"
-#include "hwui/Canvas.h"
-#include "utils/LinearAllocator.h"
-#include "utils/Macros.h"
-
-#include <SkDrawFilter.h>
-#include <SkPaint.h>
-#include <SkTLazy.h>
-
-#include <vector>
-
-namespace android {
-namespace uirenderer {
-
-struct ClipBase;
-class DeferredLayerUpdater;
-struct RecordedOp;
-
-class ANDROID_API RecordingCanvas : public Canvas, public CanvasStateClient {
- enum class DeferredBarrierType {
- None,
- InOrder,
- OutOfOrder,
- };
-
-public:
- RecordingCanvas(size_t width, size_t height);
- virtual ~RecordingCanvas();
-
- virtual void resetRecording(int width, int height, RenderNode* node = nullptr) override;
- virtual WARN_UNUSED_RESULT DisplayList* finishRecording() override;
- // ----------------------------------------------------------------------------
- // MISC HWUI OPERATIONS - TODO: CATEGORIZE
- // ----------------------------------------------------------------------------
- virtual void insertReorderBarrier(bool enableReorder) override;
-
- virtual void drawLayer(DeferredLayerUpdater* layerHandle) override;
- virtual void drawRenderNode(RenderNode* renderNode) override;
- virtual void callDrawGLFunction(Functor* functor,
- GlFunctorLifecycleListener* listener) override;
-
- // ----------------------------------------------------------------------------
- // CanvasStateClient interface
- // ----------------------------------------------------------------------------
- virtual void onViewportInitialized() override;
- virtual void onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) override;
- virtual GLuint getTargetFbo() const override { return -1; }
-
- // ----------------------------------------------------------------------------
- // HWUI Canvas draw operations
- // ----------------------------------------------------------------------------
-
- virtual void drawRoundRect(CanvasPropertyPrimitive* left, CanvasPropertyPrimitive* top,
- CanvasPropertyPrimitive* right, CanvasPropertyPrimitive* bottom,
- CanvasPropertyPrimitive* rx, CanvasPropertyPrimitive* ry,
- CanvasPropertyPaint* paint) override;
- virtual void drawCircle(CanvasPropertyPrimitive* x, CanvasPropertyPrimitive* y,
- CanvasPropertyPrimitive* radius, CanvasPropertyPaint* paint) override;
-
- // ----------------------------------------------------------------------------
- // android/graphics/Canvas interface
- // ----------------------------------------------------------------------------
- virtual SkCanvas* asSkCanvas() override;
-
- virtual void setBitmap(const SkBitmap& bitmap) override {
- LOG_ALWAYS_FATAL("RecordingCanvas is not backed by a bitmap.");
- }
-
- virtual bool isOpaque() override { return false; }
- virtual int width() override { return mState.getWidth(); }
- virtual int height() override { return mState.getHeight(); }
-
- // ----------------------------------------------------------------------------
- // android/graphics/Canvas state operations
- // ----------------------------------------------------------------------------
- // Save (layer)
- virtual int getSaveCount() const override { return mState.getSaveCount(); }
- virtual int save(SaveFlags::Flags flags) override;
- virtual void restore() override;
- virtual void restoreToCount(int saveCount) override;
-
- virtual int saveLayer(float left, float top, float right, float bottom, const SkPaint* paint,
- SaveFlags::Flags flags) override;
- virtual int saveLayerAlpha(float left, float top, float right, float bottom, int alpha,
- SaveFlags::Flags flags) override {
- SkPaint paint;
- paint.setAlpha(alpha);
- return saveLayer(left, top, right, bottom, &paint, flags);
- }
-
- // Matrix
- virtual void getMatrix(SkMatrix* outMatrix) const override { mState.getMatrix(outMatrix); }
- virtual void setMatrix(const SkMatrix& matrix) override { mState.setMatrix(matrix); }
-
- virtual void concat(const SkMatrix& matrix) override { mState.concatMatrix(matrix); }
- virtual void rotate(float degrees) override;
- virtual void scale(float sx, float sy) override;
- virtual void skew(float sx, float sy) override;
- virtual void translate(float dx, float dy) override;
-
- // Clip
- virtual bool getClipBounds(SkRect* outRect) const override;
- virtual bool quickRejectRect(float left, float top, float right, float bottom) const override;
- virtual bool quickRejectPath(const SkPath& path) const override;
-
- virtual bool clipRect(float left, float top, float right, float bottom, SkClipOp op) override;
- virtual bool clipPath(const SkPath* path, SkClipOp op) override;
-
- // Misc
- virtual SkDrawFilter* getDrawFilter() override { return mDrawFilter.get(); }
- virtual void setDrawFilter(SkDrawFilter* filter) override {
- mDrawFilter.reset(SkSafeRef(filter));
- }
-
- // ----------------------------------------------------------------------------
- // android/graphics/Canvas draw operations
- // ----------------------------------------------------------------------------
- virtual void drawColor(int color, SkBlendMode mode) override;
- virtual void drawPaint(const SkPaint& paint) override;
-
- // Geometry
- virtual void drawPoint(float x, float y, const SkPaint& paint) override {
- float points[2] = {x, y};
- drawPoints(points, 2, paint);
- }
- virtual void drawPoints(const float* points, int floatCount, const SkPaint& paint) override;
- virtual void drawLine(float startX, float startY, float stopX, float stopY,
- const SkPaint& paint) override {
- float points[4] = {startX, startY, stopX, stopY};
- drawLines(points, 4, paint);
- }
- virtual void drawLines(const float* points, int floatCount, const SkPaint& paint) override;
- virtual void drawRect(float left, float top, float right, float bottom,
- const SkPaint& paint) override;
- virtual void drawRegion(const SkRegion& region, const SkPaint& paint) override;
- virtual void drawRoundRect(float left, float top, float right, float bottom, float rx, float ry,
- const SkPaint& paint) override;
- virtual void drawCircle(float x, float y, float radius, const SkPaint& paint) override;
- virtual void drawOval(float left, float top, float right, float bottom,
- const SkPaint& paint) override;
- virtual void drawArc(float left, float top, float right, float bottom, float startAngle,
- float sweepAngle, bool useCenter, const SkPaint& paint) override;
- virtual void drawPath(const SkPath& path, const SkPaint& paint) override;
- virtual void drawVertices(const SkVertices*, SkBlendMode, const SkPaint& paint)
- override { /* RecordingCanvas does not support drawVertices(); ignore */
- }
-
- virtual void drawVectorDrawable(VectorDrawableRoot* tree) override;
-
- // Bitmap-based
- virtual void drawBitmap(Bitmap& bitmap, float left, float top, const SkPaint* paint) override;
- virtual void drawBitmap(Bitmap& bitmap, const SkMatrix& matrix, const SkPaint* paint) override;
- virtual void drawBitmap(Bitmap& bitmap, float srcLeft, float srcTop, float srcRight,
- float srcBottom, float dstLeft, float dstTop, float dstRight,
- float dstBottom, const SkPaint* paint) override;
- virtual void drawBitmapMesh(Bitmap& bitmap, int meshWidth, int meshHeight,
- const float* vertices, const int* colors,
- const SkPaint* paint) override;
- virtual void drawNinePatch(Bitmap& bitmap, const android::Res_png_9patch& chunk, float dstLeft,
- float dstTop, float dstRight, float dstBottom,
- const SkPaint* paint) override;
- virtual double drawAnimatedImage(AnimatedImageDrawable*) override;
-
- // Text
- virtual bool drawTextAbsolutePos() const override { return false; }
-
-protected:
- virtual void drawGlyphs(ReadGlyphFunc glyphFunc, int count, const SkPaint& paint, float x,
- float y, float boundsLeft, float boundsTop, float boundsRight,
- float boundsBottom, float totalAdvance) override;
- virtual void drawLayoutOnPath(const minikin::Layout& layout, float hOffset, float vOffset,
- const SkPaint& paint, const SkPath& path, size_t start,
- size_t end) override;
-
-private:
- const ClipBase* getRecordedClip() {
- return mState.writableSnapshot()->mutateClipArea().serializeClip(alloc());
- }
-
- void drawBitmap(Bitmap& bitmap, const SkPaint* paint);
- void drawSimpleRects(const float* rects, int vertexCount, const SkPaint* paint);
-
- int addOp(RecordedOp* op);
- // ----------------------------------------------------------------------------
- // lazy object copy
- // ----------------------------------------------------------------------------
- LinearAllocator& alloc() { return mDisplayList->allocator; }
-
- void refBitmapsInShader(const SkShader* shader);
-
- template <class T>
- inline const T* refBuffer(const T* srcBuffer, int32_t count) {
- if (!srcBuffer) return nullptr;
-
- T* dstBuffer = (T*)mDisplayList->allocator.alloc<T>(count * sizeof(T));
- memcpy(dstBuffer, srcBuffer, count * sizeof(T));
- return dstBuffer;
- }
-
- inline const SkPath* refPath(const SkPath* path) {
- if (!path) return nullptr;
-
- // The points/verbs within the path are refcounted so this copy operation
- // is inexpensive and maintains the generationID of the original path.
- const SkPath* cachedPath = new SkPath(*path);
- mDisplayList->pathResources.push_back(cachedPath);
- return cachedPath;
- }
-
- /**
- * Returns a RenderThread-safe, const copy of the SkPaint parameter passed in
- * (with deduping based on paint hash / equality check)
- */
- inline const SkPaint* refPaint(const SkPaint* paint) {
- if (!paint) return nullptr;
-
- // If there is a draw filter apply it here and store the modified paint
- // so that we don't need to modify the paint every time we access it.
- SkTLazy<SkPaint> filteredPaint;
- if (mDrawFilter.get()) {
- filteredPaint.set(*paint);
- mDrawFilter->filter(filteredPaint.get(), SkDrawFilter::kPaint_Type);
- paint = filteredPaint.get();
- }
-
- // compute the hash key for the paint and check the cache.
- const uint32_t key = paint->getHash();
- const SkPaint* cachedPaint = mPaintMap.valueFor(key);
- // In the unlikely event that 2 unique paints have the same hash we do a
- // object equality check to ensure we don't erroneously dedup them.
- if (cachedPaint == nullptr || *cachedPaint != *paint) {
- cachedPaint = new SkPaint(*paint);
- mDisplayList->paints.emplace_back(cachedPaint);
- // replaceValueFor() performs an add if the entry doesn't exist
- mPaintMap.replaceValueFor(key, cachedPaint);
- refBitmapsInShader(cachedPaint->getShader());
- }
-
- return cachedPaint;
- }
-
- inline const SkRegion* refRegion(const SkRegion* region) {
- if (!region) {
- return region;
- }
-
- const SkRegion* cachedRegion = mRegionMap.valueFor(region);
- // TODO: Add generation ID to SkRegion
- if (cachedRegion == nullptr) {
- std::unique_ptr<const SkRegion> copy(new SkRegion(*region));
- cachedRegion = copy.get();
- mDisplayList->regions.push_back(std::move(copy));
-
- // replaceValueFor() performs an add if the entry doesn't exist
- mRegionMap.replaceValueFor(region, cachedRegion);
- }
-
- return cachedRegion;
- }
-
- inline Bitmap* refBitmap(Bitmap& bitmap) {
- // Note that this assumes the bitmap is immutable. There are cases this won't handle
- // correctly, such as creating the bitmap from scratch, drawing with it, changing its
- // contents, and drawing again. The only fix would be to always copy it the first time,
- // which doesn't seem worth the extra cycles for this unlikely case.
-
- // this is required because sk_sp's ctor adopts the pointer,
- // but does not increment the refcount,
- bitmap.ref();
- mDisplayList->bitmapResources.emplace_back(&bitmap);
- return &bitmap;
- }
-
- inline const Res_png_9patch* refPatch(const Res_png_9patch* patch) {
- mDisplayList->patchResources.push_back(patch);
- mResourceCache.incrementRefcount(patch);
- return patch;
- }
-
- DefaultKeyedVector<uint32_t, const SkPaint*> mPaintMap;
- DefaultKeyedVector<const SkPath*, const SkPath*> mPathMap;
- DefaultKeyedVector<const SkRegion*, const SkRegion*> mRegionMap;
-
- CanvasState mState;
- std::unique_ptr<SkiaCanvasProxy> mSkiaCanvasProxy;
- ResourceCache& mResourceCache;
- DeferredBarrierType mDeferredBarrierType = DeferredBarrierType::None;
- const ClipBase* mDeferredBarrierClip = nullptr;
- DisplayList* mDisplayList = nullptr;
- sk_sp<SkDrawFilter> mDrawFilter;
-}; // class RecordingCanvas
-
-}; // namespace uirenderer
-}; // namespace android
-
-#endif // ANDROID_HWUI_RECORDING_CANVAS_H
diff --git a/libs/hwui/RenderNode.cpp b/libs/hwui/RenderNode.cpp
index 62b80c43..e903900 100644
--- a/libs/hwui/RenderNode.cpp
+++ b/libs/hwui/RenderNode.cpp
@@ -381,78 +381,6 @@
}
}
-/**
- * Organizes the DisplayList hierarchy to prepare for background projection reordering.
- *
- * This should be called before a call to defer() or drawDisplayList()
- *
- * Each DisplayList that serves as a 3d root builds its list of composited children,
- * which are flagged to not draw in the standard draw loop.
- */
-void RenderNode::computeOrdering() {
- ATRACE_CALL();
- mProjectedNodes.clear();
-
- // TODO: create temporary DDLOp and call computeOrderingImpl on top DisplayList so that
- // transform properties are applied correctly to top level children
- if (mDisplayList == nullptr) return;
- for (unsigned int i = 0; i < mDisplayList->getChildren().size(); i++) {
- RenderNodeOp* childOp = mDisplayList->getChildren()[i];
- childOp->renderNode->computeOrderingImpl(childOp, &mProjectedNodes, &mat4::identity());
- }
-}
-
-void RenderNode::computeOrderingImpl(
- RenderNodeOp* opState, std::vector<RenderNodeOp*>* compositedChildrenOfProjectionSurface,
- const mat4* transformFromProjectionSurface) {
- mProjectedNodes.clear();
- if (mDisplayList == nullptr || mDisplayList->isEmpty()) return;
-
- // TODO: should avoid this calculation in most cases
- // TODO: just calculate single matrix, down to all leaf composited elements
- Matrix4 localTransformFromProjectionSurface(*transformFromProjectionSurface);
- localTransformFromProjectionSurface.multiply(opState->localMatrix);
-
- if (properties().getProjectBackwards()) {
- // composited projectee, flag for out of order draw, save matrix, and store in proj surface
- opState->skipInOrderDraw = true;
- opState->transformFromCompositingAncestor = localTransformFromProjectionSurface;
- compositedChildrenOfProjectionSurface->push_back(opState);
- } else {
- // standard in order draw
- opState->skipInOrderDraw = false;
- }
-
- if (mDisplayList->getChildren().size() > 0) {
- const bool isProjectionReceiver = mDisplayList->projectionReceiveIndex >= 0;
- bool haveAppliedPropertiesToProjection = false;
- for (unsigned int i = 0; i < mDisplayList->getChildren().size(); i++) {
- RenderNodeOp* childOp = mDisplayList->getChildren()[i];
- RenderNode* child = childOp->renderNode;
-
- std::vector<RenderNodeOp*>* projectionChildren = nullptr;
- const mat4* projectionTransform = nullptr;
- if (isProjectionReceiver && !child->properties().getProjectBackwards()) {
- // if receiving projections, collect projecting descendant
-
- // Note that if a direct descendant is projecting backwards, we pass its
- // grandparent projection collection, since it shouldn't project onto its
- // parent, where it will already be drawing.
- projectionChildren = &mProjectedNodes;
- projectionTransform = &mat4::identity();
- } else {
- if (!haveAppliedPropertiesToProjection) {
- applyViewPropertyTransforms(localTransformFromProjectionSurface);
- haveAppliedPropertiesToProjection = true;
- }
- projectionChildren = compositedChildrenOfProjectionSurface;
- projectionTransform = &localTransformFromProjectionSurface;
- }
- child->computeOrderingImpl(childOp, projectionChildren, projectionTransform);
- }
- }
-}
-
const SkPath* RenderNode::getClippedOutline(const SkRect& clipRect) const {
const SkPath* outlinePath = properties().getOutline().getPath();
const uint32_t outlineID = outlinePath->getGenerationID();
diff --git a/libs/hwui/RenderNode.h b/libs/hwui/RenderNode.h
index 1e0d4e2..45a53f9 100644
--- a/libs/hwui/RenderNode.h
+++ b/libs/hwui/RenderNode.h
@@ -48,8 +48,6 @@
namespace uirenderer {
class CanvasState;
-class DisplayListOp;
-class FrameBuilder;
class OffscreenBuffer;
class Rect;
class SkiaShader;
@@ -76,7 +74,6 @@
*/
class RenderNode : public VirtualLightRefBase {
friend class TestUtils; // allow TestUtils to access syncDisplayList / syncProperties
- friend class FrameBuilder;
public:
enum DirtyPropertyMask {
@@ -104,8 +101,6 @@
ANDROID_API void setStagingDisplayList(DisplayList* newData);
- void computeOrdering();
-
ANDROID_API void output();
ANDROID_API int getDebugSize();
diff --git a/libs/hwui/VectorDrawable.h b/libs/hwui/VectorDrawable.h
index da52a95..e84b9ac 100644
--- a/libs/hwui/VectorDrawable.h
+++ b/libs/hwui/VectorDrawable.h
@@ -718,6 +718,8 @@
} // namespace VectorDrawable
typedef VectorDrawable::Path::Data PathData;
+typedef uirenderer::VectorDrawable::Tree VectorDrawableRoot;
+
} // namespace uirenderer
} // namespace android
diff --git a/libs/hwui/hwui/Canvas.cpp b/libs/hwui/hwui/Canvas.cpp
index b453227..30f6f12 100644
--- a/libs/hwui/hwui/Canvas.cpp
+++ b/libs/hwui/hwui/Canvas.cpp
@@ -19,7 +19,6 @@
#include "MinikinUtils.h"
#include "Paint.h"
#include "Properties.h"
-#include "RecordingCanvas.h"
#include "RenderNode.h"
#include "Typeface.h"
#include "pipeline/skia/SkiaRecordingCanvas.h"
diff --git a/libs/hwui/hwui/Canvas.h b/libs/hwui/hwui/Canvas.h
index f341cf9..341b0c5 100644
--- a/libs/hwui/hwui/Canvas.h
+++ b/libs/hwui/hwui/Canvas.h
@@ -44,8 +44,16 @@
class CanvasPropertyPaint;
class CanvasPropertyPrimitive;
class DeferredLayerUpdater;
-class DisplayList;
class RenderNode;
+
+namespace skiapipeline {
+class SkiaDisplayList;
+}
+
+/**
+ * Data structure that holds the list of commands used in display list stream
+ */
+using DisplayList = skiapipeline::SkiaDisplayList;
}
namespace SaveFlags {
diff --git a/libs/hwui/pipeline/skia/GLFunctorDrawable.h b/libs/hwui/pipeline/skia/GLFunctorDrawable.h
index af57d7d..d9e65c9 100644
--- a/libs/hwui/pipeline/skia/GLFunctorDrawable.h
+++ b/libs/hwui/pipeline/skia/GLFunctorDrawable.h
@@ -16,6 +16,8 @@
#pragma once
+#include "GlFunctorLifecycleListener.h"
+
#include <SkCanvas.h>
#include <SkDrawable.h>
@@ -25,8 +27,6 @@
namespace android {
namespace uirenderer {
-class GlFunctorLifecycleListener;
-
namespace skiapipeline {
/**
diff --git a/libs/hwui/pipeline/skia/RenderNodeDrawable.cpp b/libs/hwui/pipeline/skia/RenderNodeDrawable.cpp
index 6c04d78..1b816fe 100644
--- a/libs/hwui/pipeline/skia/RenderNodeDrawable.cpp
+++ b/libs/hwui/pipeline/skia/RenderNodeDrawable.cpp
@@ -25,6 +25,19 @@
namespace uirenderer {
namespace skiapipeline {
+RenderNodeDrawable::RenderNodeDrawable(RenderNode* node, SkCanvas* canvas, bool composeLayer,
+ bool inReorderingSection)
+ : mRenderNode(node)
+ , mRecordedTransform(canvas->getTotalMatrix())
+ , mComposeLayer(composeLayer)
+ , mInReorderingSection(inReorderingSection) {}
+
+RenderNodeDrawable::~RenderNodeDrawable() {
+ // Just here to move the destructor into the cpp file where we can access RenderNode.
+
+ // TODO: Detangle the header nightmare.
+}
+
void RenderNodeDrawable::drawBackwardsProjectedNodes(SkCanvas* canvas,
const SkiaDisplayList& displayList,
int nestLevel) {
@@ -115,7 +128,6 @@
return;
}
- SkASSERT(renderNode->getDisplayList()->isSkiaDL());
SkiaDisplayList* displayList = (SkiaDisplayList*)renderNode->getDisplayList();
SkAutoCanvasRestore acr(canvas, true);
diff --git a/libs/hwui/pipeline/skia/RenderNodeDrawable.h b/libs/hwui/pipeline/skia/RenderNodeDrawable.h
index ef21cd8..6594bd22 100644
--- a/libs/hwui/pipeline/skia/RenderNodeDrawable.h
+++ b/libs/hwui/pipeline/skia/RenderNodeDrawable.h
@@ -47,11 +47,9 @@
* layer into the canvas.
*/
explicit RenderNodeDrawable(RenderNode* node, SkCanvas* canvas, bool composeLayer = true,
- bool inReorderingSection = false)
- : mRenderNode(node)
- , mRecordedTransform(canvas->getTotalMatrix())
- , mComposeLayer(composeLayer)
- , mInReorderingSection(inReorderingSection) {}
+ bool inReorderingSection = false);
+
+ ~RenderNodeDrawable();
/**
* Draws into the canvas this render node and its children. If the node is marked as a
diff --git a/libs/hwui/pipeline/skia/SkiaDisplayList.h b/libs/hwui/pipeline/skia/SkiaDisplayList.h
index 818ec11..58b9242 100644
--- a/libs/hwui/pipeline/skia/SkiaDisplayList.h
+++ b/libs/hwui/pipeline/skia/SkiaDisplayList.h
@@ -16,10 +16,11 @@
#pragma once
-#include "DisplayList.h"
#include "hwui/AnimatedImageDrawable.h"
#include "GLFunctorDrawable.h"
#include "RenderNodeDrawable.h"
+#include "TreeInfo.h"
+#include "utils/LinearAllocator.h"
#include <SkLiteDL.h>
#include <SkLiteRecorder.h>
@@ -28,8 +29,17 @@
namespace android {
namespace uirenderer {
+namespace renderthread {
+class CanvasContext;
+}
+
class Outline;
+namespace VectorDrawable {
+class Tree;
+};
+typedef uirenderer::VectorDrawable::Tree VectorDrawableRoot;
+
namespace skiapipeline {
/**
@@ -38,10 +48,14 @@
* runtime. The downside of this inheritance is that we pay for the overhead
* of the parent class construction/destruction without any real benefit.
*/
-class SkiaDisplayList : public DisplayList {
+class SkiaDisplayList {
public:
- SkiaDisplayList() { SkASSERT(projectionReceiveIndex == -1); }
- virtual ~SkiaDisplayList() {
+ // index of DisplayListOp restore, after which projected descendants should be drawn
+ int projectionReceiveIndex = -1;
+
+ size_t getUsedSize() { return allocator.usedSize(); }
+
+ ~SkiaDisplayList() {
/* Given that we are using a LinearStdAllocator to store some of the
* SkDrawable contents we must ensure that any other object that is
* holding a reference to those drawables is destroyed prior to their
@@ -68,29 +82,27 @@
return allocator.create<T>(std::forward<Params>(params)...);
}
- bool isSkiaDL() const override { return true; }
-
/**
* Returns true if the DisplayList does not have any recorded content
*/
- bool isEmpty() const override { return mDisplayList.empty(); }
+ bool isEmpty() const { return mDisplayList.empty(); }
/**
* Returns true if this list directly contains a GLFunctor drawing command.
*/
- bool hasFunctor() const override { return !mChildFunctors.empty(); }
+ bool hasFunctor() const { return !mChildFunctors.empty(); }
/**
* Returns true if this list directly contains a VectorDrawable drawing command.
*/
- bool hasVectorDrawables() const override { return !mVectorDrawables.empty(); }
+ bool hasVectorDrawables() const { return !mVectorDrawables.empty(); }
/**
* Attempts to reset and reuse this DisplayList.
*
* @return true if the displayList will be reused and therefore should not be deleted
*/
- bool reuseDisplayList(RenderNode* node, renderthread::CanvasContext* context) override;
+ bool reuseDisplayList(RenderNode* node, renderthread::CanvasContext* context);
/**
* ONLY to be called by RenderNode::syncDisplayList so that we can notify any
@@ -99,7 +111,7 @@
* NOTE: This function can be folded into RenderNode when we no longer need
* to subclass from DisplayList
*/
- void syncContents() override;
+ void syncContents();
/**
* ONLY to be called by RenderNode::prepareTree in order to prepare this
@@ -116,12 +128,12 @@
bool prepareListAndChildren(
TreeObserver& observer, TreeInfo& info, bool functorsNeedLayer,
- std::function<void(RenderNode*, TreeObserver&, TreeInfo&, bool)> childFn) override;
+ std::function<void(RenderNode*, TreeObserver&, TreeInfo&, bool)> childFn);
/**
* Calls the provided function once for each child of this DisplayList
*/
- void updateChildren(std::function<void(RenderNode*)> updateFn) override;
+ void updateChildren(std::function<void(RenderNode*)> updateFn);
/**
* Returns true if there is a child render node that is a projection receiver.
@@ -134,7 +146,9 @@
void draw(SkCanvas* canvas) { mDisplayList.draw(canvas); }
- void output(std::ostream& output, uint32_t level) override;
+ void output(std::ostream& output, uint32_t level);
+
+ LinearAllocator allocator;
/**
* We use std::deque here because (1) we need to iterate through these
diff --git a/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp b/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
index cfcfd2b..15277f1 100644
--- a/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
+++ b/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
@@ -25,6 +25,7 @@
#include "renderstate/RenderState.h"
#include "renderthread/EglManager.h"
#include "renderthread/Frame.h"
+#include "utils/GLUtils.h"
#include "utils/TraceUtils.h"
#include <GrBackendSurface.h>
@@ -58,10 +59,10 @@
}
bool SkiaOpenGLPipeline::draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
- const FrameBuilder::LightGeometry& lightGeometry,
+ const LightGeometry& lightGeometry,
LayerUpdateQueue* layerUpdateQueue, const Rect& contentDrawBounds,
bool opaque, bool wideColorGamut,
- const BakedOpRenderer::LightInfo& lightInfo,
+ const LightInfo& lightInfo,
const std::vector<sp<RenderNode>>& renderNodes,
FrameInfoVisualizer* profiler) {
mEglManager.damageFrame(frame, dirty);
diff --git a/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.h b/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.h
index ef5d934..04b68f5 100644
--- a/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.h
+++ b/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.h
@@ -33,9 +33,9 @@
renderthread::MakeCurrentResult makeCurrent() override;
renderthread::Frame getFrame() override;
bool draw(const renderthread::Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
- const FrameBuilder::LightGeometry& lightGeometry, LayerUpdateQueue* layerUpdateQueue,
+ const LightGeometry& lightGeometry, LayerUpdateQueue* layerUpdateQueue,
const Rect& contentDrawBounds, bool opaque, bool wideColorGamut,
- const BakedOpRenderer::LightInfo& lightInfo,
+ const LightInfo& lightInfo,
const std::vector<sp<RenderNode> >& renderNodes,
FrameInfoVisualizer* profiler) override;
bool swapBuffers(const renderthread::Frame& frame, bool drew, const SkRect& screenDirty,
diff --git a/libs/hwui/pipeline/skia/SkiaPipeline.cpp b/libs/hwui/pipeline/skia/SkiaPipeline.cpp
index d66cba1..988981d 100644
--- a/libs/hwui/pipeline/skia/SkiaPipeline.cpp
+++ b/libs/hwui/pipeline/skia/SkiaPipeline.cpp
@@ -81,9 +81,9 @@
mVectorDrawables.clear();
}
-void SkiaPipeline::renderLayers(const FrameBuilder::LightGeometry& lightGeometry,
+void SkiaPipeline::renderLayers(const LightGeometry& lightGeometry,
LayerUpdateQueue* layerUpdateQueue, bool opaque,
- bool wideColorGamut, const BakedOpRenderer::LightInfo& lightInfo) {
+ bool wideColorGamut, const LightInfo& lightInfo) {
updateLighting(lightGeometry, lightInfo);
ATRACE_NAME("draw layers");
renderVectorDrawableCache();
@@ -103,7 +103,6 @@
// as not to lose info on what portion is damaged
if (CC_LIKELY(layerNode->getLayerSurface() != nullptr)) {
SkASSERT(layerNode->getLayerSurface());
- SkASSERT(layerNode->getDisplayList()->isSkiaDL());
SkiaDisplayList* displayList = (SkiaDisplayList*)layerNode->getDisplayList();
if (!displayList || displayList->isEmpty()) {
SkDEBUGF(("%p drawLayers(%s) : missing drawable", layerNode, layerNode->getName()));
diff --git a/libs/hwui/pipeline/skia/SkiaPipeline.h b/libs/hwui/pipeline/skia/SkiaPipeline.h
index 38ad9c0..8c9c803 100644
--- a/libs/hwui/pipeline/skia/SkiaPipeline.h
+++ b/libs/hwui/pipeline/skia/SkiaPipeline.h
@@ -17,7 +17,7 @@
#pragma once
#include <SkSurface.h>
-#include "FrameBuilder.h"
+#include "Lighting.h"
#include "hwui/AnimatedImageDrawable.h"
#include "renderthread/CanvasContext.h"
#include "renderthread/IRenderPipeline.h"
@@ -42,9 +42,9 @@
void unpinImages() override;
void onPrepareTree() override;
- void renderLayers(const FrameBuilder::LightGeometry& lightGeometry,
+ void renderLayers(const LightGeometry& lightGeometry,
LayerUpdateQueue* layerUpdateQueue, bool opaque, bool wideColorGamut,
- const BakedOpRenderer::LightInfo& lightInfo) override;
+ const LightInfo& lightInfo) override;
bool createOrUpdateLayer(RenderNode* node, const DamageAccumulator& damageAccumulator,
bool wideColorGamut, ErrorHandler* errorHandler) override;
@@ -97,8 +97,8 @@
return mLightCenter;
}
- static void updateLighting(const FrameBuilder::LightGeometry& lightGeometry,
- const BakedOpRenderer::LightInfo& lightInfo) {
+ static void updateLighting(const LightGeometry& lightGeometry,
+ const LightInfo& lightInfo) {
mLightRadius = lightGeometry.radius;
mAmbientShadowAlpha = lightInfo.ambientShadowAlpha;
mSpotShadowAlpha = lightInfo.spotShadowAlpha;
diff --git a/libs/hwui/pipeline/skia/SkiaVulkanPipeline.cpp b/libs/hwui/pipeline/skia/SkiaVulkanPipeline.cpp
index 5825060..b2519fe 100644
--- a/libs/hwui/pipeline/skia/SkiaVulkanPipeline.cpp
+++ b/libs/hwui/pipeline/skia/SkiaVulkanPipeline.cpp
@@ -62,10 +62,10 @@
}
bool SkiaVulkanPipeline::draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
- const FrameBuilder::LightGeometry& lightGeometry,
+ const LightGeometry& lightGeometry,
LayerUpdateQueue* layerUpdateQueue, const Rect& contentDrawBounds,
bool opaque, bool wideColorGamut,
- const BakedOpRenderer::LightInfo& lightInfo,
+ const LightInfo& lightInfo,
const std::vector<sp<RenderNode>>& renderNodes,
FrameInfoVisualizer* profiler) {
sk_sp<SkSurface> backBuffer = mVkSurface->getBackBufferSurface();
diff --git a/libs/hwui/pipeline/skia/SkiaVulkanPipeline.h b/libs/hwui/pipeline/skia/SkiaVulkanPipeline.h
index 03b4c79..7806b42 100644
--- a/libs/hwui/pipeline/skia/SkiaVulkanPipeline.h
+++ b/libs/hwui/pipeline/skia/SkiaVulkanPipeline.h
@@ -31,9 +31,9 @@
renderthread::MakeCurrentResult makeCurrent() override;
renderthread::Frame getFrame() override;
bool draw(const renderthread::Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
- const FrameBuilder::LightGeometry& lightGeometry, LayerUpdateQueue* layerUpdateQueue,
+ const LightGeometry& lightGeometry, LayerUpdateQueue* layerUpdateQueue,
const Rect& contentDrawBounds, bool opaque, bool wideColorGamut,
- const BakedOpRenderer::LightInfo& lightInfo,
+ const LightInfo& lightInfo,
const std::vector<sp<RenderNode> >& renderNodes,
FrameInfoVisualizer* profiler) override;
bool swapBuffers(const renderthread::Frame& frame, bool drew, const SkRect& screenDirty,
diff --git a/libs/hwui/renderstate/RenderState.cpp b/libs/hwui/renderstate/RenderState.cpp
index f173136..a60e2b5 100644
--- a/libs/hwui/renderstate/RenderState.cpp
+++ b/libs/hwui/renderstate/RenderState.cpp
@@ -18,6 +18,7 @@
#include "DeferredLayerUpdater.h"
#include "GlLayer.h"
#include "VkLayer.h"
+#include "Snapshot.h"
#include "renderthread/CanvasContext.h"
#include "renderthread/EglManager.h"
diff --git a/libs/hwui/renderthread/CanvasContext.h b/libs/hwui/renderthread/CanvasContext.h
index aaef85a..358b842 100644
--- a/libs/hwui/renderthread/CanvasContext.h
+++ b/libs/hwui/renderthread/CanvasContext.h
@@ -16,10 +16,8 @@
#pragma once
-#include "BakedOpDispatcher.h"
-#include "BakedOpRenderer.h"
#include "DamageAccumulator.h"
-#include "FrameBuilder.h"
+#include "Lighting.h"
#include "FrameInfo.h"
#include "FrameInfoVisualizer.h"
#include "FrameMetricsReporter.h"
@@ -231,8 +229,8 @@
bool mOpaque;
bool mWideColorGamut = false;
- BakedOpRenderer::LightInfo mLightInfo;
- FrameBuilder::LightGeometry mLightGeometry = {{0, 0, 0}, 0};
+ LightInfo mLightInfo;
+ LightGeometry mLightGeometry = {{0, 0, 0}, 0};
bool mHaveNewSurface = false;
DamageAccumulator mDamageAccumulator;
diff --git a/libs/hwui/renderthread/DrawFrameTask.h b/libs/hwui/renderthread/DrawFrameTask.h
index d8c43e0..0037a0f 100644
--- a/libs/hwui/renderthread/DrawFrameTask.h
+++ b/libs/hwui/renderthread/DrawFrameTask.h
@@ -32,7 +32,6 @@
namespace uirenderer {
class DeferredLayerUpdater;
-class DisplayList;
class RenderNode;
namespace renderthread {
diff --git a/libs/hwui/renderthread/IRenderPipeline.h b/libs/hwui/renderthread/IRenderPipeline.h
index b1de497..b94a758 100644
--- a/libs/hwui/renderthread/IRenderPipeline.h
+++ b/libs/hwui/renderthread/IRenderPipeline.h
@@ -17,7 +17,10 @@
#pragma once
#include "FrameInfoVisualizer.h"
+#include "LayerUpdateQueue.h"
#include "SwapBehavior.h"
+#include "hwui/Bitmap.h"
+#include "thread/TaskManager.h"
#include <SkRect.h>
#include <utils/RefBase.h>
@@ -50,9 +53,9 @@
virtual MakeCurrentResult makeCurrent() = 0;
virtual Frame getFrame() = 0;
virtual bool draw(const Frame& frame, const SkRect& screenDirty, const SkRect& dirty,
- const FrameBuilder::LightGeometry& lightGeometry,
+ const LightGeometry& lightGeometry,
LayerUpdateQueue* layerUpdateQueue, const Rect& contentDrawBounds,
- bool opaque, bool wideColorGamut, const BakedOpRenderer::LightInfo& lightInfo,
+ bool opaque, bool wideColorGamut, const LightInfo& lightInfo,
const std::vector<sp<RenderNode>>& renderNodes,
FrameInfoVisualizer* profiler) = 0;
virtual bool swapBuffers(const Frame& frame, bool drew, const SkRect& screenDirty,
@@ -64,9 +67,9 @@
virtual bool isSurfaceReady() = 0;
virtual bool isContextReady() = 0;
virtual void onDestroyHardwareResources() = 0;
- virtual void renderLayers(const FrameBuilder::LightGeometry& lightGeometry,
+ virtual void renderLayers(const LightGeometry& lightGeometry,
LayerUpdateQueue* layerUpdateQueue, bool opaque, bool wideColorGamut,
- const BakedOpRenderer::LightInfo& lightInfo) = 0;
+ const LightInfo& lightInfo) = 0;
virtual TaskManager* getTaskManager() = 0;
virtual bool createOrUpdateLayer(RenderNode* node, const DamageAccumulator& damageAccumulator,
bool wideColorGamut, ErrorHandler* errorHandler) = 0;
diff --git a/libs/hwui/renderthread/RenderProxy.cpp b/libs/hwui/renderthread/RenderProxy.cpp
index 0caf59b..4d1e1e8 100644
--- a/libs/hwui/renderthread/RenderProxy.cpp
+++ b/libs/hwui/renderthread/RenderProxy.cpp
@@ -66,10 +66,7 @@
bool RenderProxy::loadSystemProperties() {
return mRenderThread.queue().runSync([this]() -> bool {
- bool needsRedraw = false;
- if (Caches::hasInstance()) {
- needsRedraw = Properties::load();
- }
+ bool needsRedraw = Properties::load();
if (mContext->profiler().consumeProperties()) {
needsRedraw = true;
}
diff --git a/libs/hwui/tests/common/TestUtils.h b/libs/hwui/tests/common/TestUtils.h
index ca5a88b..13fb528 100644
--- a/libs/hwui/tests/common/TestUtils.h
+++ b/libs/hwui/tests/common/TestUtils.h
@@ -29,7 +29,6 @@
#include <renderthread/RenderThread.h>
#include <RecordedOp.h>
-#include <RecordingCanvas.h>
#include <memory>
@@ -335,16 +334,10 @@
}
auto displayList = node->getDisplayList();
if (displayList) {
- if (displayList->isSkiaDL()) {
- for (auto&& childDr : static_cast<skiapipeline::SkiaDisplayList*>(
- const_cast<DisplayList*>(displayList))
- ->mChildNodes) {
- syncHierarchyPropertiesAndDisplayListImpl(childDr.getRenderNode());
- }
- } else {
- for (auto&& childOp : displayList->getChildren()) {
- syncHierarchyPropertiesAndDisplayListImpl(childOp->renderNode);
- }
+ for (auto&& childDr : static_cast<skiapipeline::SkiaDisplayList*>(
+ const_cast<DisplayList*>(displayList))
+ ->mChildNodes) {
+ syncHierarchyPropertiesAndDisplayListImpl(childDr.getRenderNode());
}
}
}
diff --git a/libs/hwui/tests/common/scenes/TestSceneBase.h b/libs/hwui/tests/common/scenes/TestSceneBase.h
index 792312a..6f76a50 100644
--- a/libs/hwui/tests/common/scenes/TestSceneBase.h
+++ b/libs/hwui/tests/common/scenes/TestSceneBase.h
@@ -16,7 +16,7 @@
#pragma once
-#include "RecordingCanvas.h"
+#include "hwui/Canvas.h"
#include "RenderNode.h"
#include "tests/common/TestContext.h"
#include "tests/common/TestScene.h"
diff --git a/libs/hwui/tests/microbench/DisplayListCanvasBench.cpp b/libs/hwui/tests/microbench/DisplayListCanvasBench.cpp
index 0aaf773..9388c20 100644
--- a/libs/hwui/tests/microbench/DisplayListCanvasBench.cpp
+++ b/libs/hwui/tests/microbench/DisplayListCanvasBench.cpp
@@ -16,8 +16,10 @@
#include <benchmark/benchmark.h>
+#include "CanvasState.h"
#include "DisplayList.h"
-#include "RecordingCanvas.h"
+#include "hwui/Canvas.h"
+#include "pipeline/skia/SkiaDisplayList.h"
#include "tests/common/TestUtils.h"
using namespace android;
@@ -25,7 +27,7 @@
void BM_DisplayList_alloc(benchmark::State& benchState) {
while (benchState.KeepRunning()) {
- auto displayList = new DisplayList();
+ auto displayList = new skiapipeline::SkiaDisplayList();
benchmark::DoNotOptimize(displayList);
delete displayList;
}
@@ -34,7 +36,7 @@
void BM_DisplayList_alloc_theoretical(benchmark::State& benchState) {
while (benchState.KeepRunning()) {
- auto displayList = new char[sizeof(DisplayList)];
+ auto displayList = new char[sizeof(skiapipeline::SkiaDisplayList)];
benchmark::DoNotOptimize(displayList);
delete[] displayList;
}
diff --git a/libs/hwui/tests/microbench/FrameBuilderBench.cpp b/libs/hwui/tests/microbench/FrameBuilderBench.cpp
deleted file mode 100644
index b621766..0000000
--- a/libs/hwui/tests/microbench/FrameBuilderBench.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <benchmark/benchmark.h>
-
-#include "BakedOpDispatcher.h"
-#include "BakedOpRenderer.h"
-#include "BakedOpState.h"
-#include "FrameBuilder.h"
-#include "LayerUpdateQueue.h"
-#include "RecordedOp.h"
-#include "RecordingCanvas.h"
-#include "Vector.h"
-#include "tests/common/TestContext.h"
-#include "tests/common/TestScene.h"
-#include "tests/common/TestUtils.h"
-
-#include <vector>
-
-using namespace android;
-using namespace android::uirenderer;
-using namespace android::uirenderer::renderthread;
-using namespace android::uirenderer::test;
-
-const FrameBuilder::LightGeometry sLightGeometry = {{100, 100, 100}, 50};
-const BakedOpRenderer::LightInfo sLightInfo = {128, 128};
-
-static sp<RenderNode> createTestNode() {
- auto node = TestUtils::createNode<RecordingCanvas>(
- 0, 0, 200, 200, [](RenderProperties& props, RecordingCanvas& canvas) {
- sk_sp<Bitmap> bitmap(TestUtils::createBitmap(10, 10));
- SkPaint paint;
-
- // Alternate between drawing rects and bitmaps, with bitmaps overlapping rects.
- // Rects don't overlap bitmaps, so bitmaps should be brought to front as a group.
- canvas.save(SaveFlags::MatrixClip);
- for (int i = 0; i < 30; i++) {
- canvas.translate(0, 10);
- canvas.drawRect(0, 0, 10, 10, paint);
- canvas.drawBitmap(*bitmap, 5, 0, nullptr);
- }
- canvas.restore();
- });
- TestUtils::syncHierarchyPropertiesAndDisplayList(node);
- return node;
-}
-
-void BM_FrameBuilder_defer(benchmark::State& state) {
- TestUtils::runOnRenderThread([&state](RenderThread& thread) {
- auto node = createTestNode();
- while (state.KeepRunning()) {
- FrameBuilder frameBuilder(SkRect::MakeWH(100, 200), 100, 200, sLightGeometry,
- Caches::getInstance());
- frameBuilder.deferRenderNode(*node);
- benchmark::DoNotOptimize(&frameBuilder);
- }
- });
-}
-BENCHMARK(BM_FrameBuilder_defer);
-
-void BM_FrameBuilder_deferAndRender(benchmark::State& state) {
- TestUtils::runOnRenderThread([&state](RenderThread& thread) {
- auto node = createTestNode();
-
- RenderState& renderState = thread.renderState();
- Caches& caches = Caches::getInstance();
-
- while (state.KeepRunning()) {
- FrameBuilder frameBuilder(SkRect::MakeWH(100, 200), 100, 200, sLightGeometry, caches);
- frameBuilder.deferRenderNode(*node);
-
- BakedOpRenderer renderer(caches, renderState, true, false, sLightInfo);
- frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
- benchmark::DoNotOptimize(&renderer);
- }
- });
-}
-BENCHMARK(BM_FrameBuilder_deferAndRender);
-
-static sp<RenderNode> getSyncedSceneNode(const char* sceneName) {
- gDisplay = getBuiltInDisplay(); // switch to real display if present
-
- TestContext testContext;
- TestScene::Options opts;
- std::unique_ptr<TestScene> scene(TestScene::testMap()[sceneName].createScene(opts));
-
- sp<RenderNode> rootNode = TestUtils::createNode<RecordingCanvas>(
- 0, 0, gDisplay.w, gDisplay.h,
- [&scene](RenderProperties& props, RecordingCanvas& canvas) {
- scene->createContent(gDisplay.w, gDisplay.h, canvas);
- });
-
- TestUtils::syncHierarchyPropertiesAndDisplayList(rootNode);
- return rootNode;
-}
-
-static auto SCENES = {
- "listview",
-};
-
-void BM_FrameBuilder_defer_scene(benchmark::State& state) {
- TestUtils::runOnRenderThread([&state](RenderThread& thread) {
- const char* sceneName = *(SCENES.begin() + state.range(0));
- state.SetLabel(sceneName);
- auto node = getSyncedSceneNode(sceneName);
- while (state.KeepRunning()) {
- FrameBuilder frameBuilder(SkRect::MakeWH(gDisplay.w, gDisplay.h), gDisplay.w,
- gDisplay.h, sLightGeometry, Caches::getInstance());
- frameBuilder.deferRenderNode(*node);
- benchmark::DoNotOptimize(&frameBuilder);
- }
- });
-}
-BENCHMARK(BM_FrameBuilder_defer_scene)->DenseRange(0, SCENES.size() - 1);
-
-void BM_FrameBuilder_deferAndRender_scene(benchmark::State& state) {
- TestUtils::runOnRenderThread([&state](RenderThread& thread) {
- const char* sceneName = *(SCENES.begin() + state.range(0));
- state.SetLabel(sceneName);
- auto node = getSyncedSceneNode(sceneName);
-
- RenderState& renderState = thread.renderState();
- Caches& caches = Caches::getInstance();
-
- while (state.KeepRunning()) {
- FrameBuilder frameBuilder(SkRect::MakeWH(gDisplay.w, gDisplay.h), gDisplay.w,
- gDisplay.h, sLightGeometry, Caches::getInstance());
- frameBuilder.deferRenderNode(*node);
-
- BakedOpRenderer renderer(caches, renderState, true, false, sLightInfo);
- frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
- benchmark::DoNotOptimize(&renderer);
- }
- });
-}
-BENCHMARK(BM_FrameBuilder_deferAndRender_scene)->DenseRange(0, SCENES.size() - 1);
diff --git a/libs/hwui/tests/unit/SkiaCanvasTests.cpp b/libs/hwui/tests/unit/SkiaCanvasTests.cpp
index 2e4de0b..634ceff 100644
--- a/libs/hwui/tests/unit/SkiaCanvasTests.cpp
+++ b/libs/hwui/tests/unit/SkiaCanvasTests.cpp
@@ -16,7 +16,6 @@
#include "tests/common/TestUtils.h"
-#include <RecordingCanvas.h>
#include <SkBlurDrawLooper.h>
#include <SkCanvasStateUtils.h>
#include <SkPicture.h>
diff --git a/libs/hwui/tests/unit/SkiaPipelineTests.cpp b/libs/hwui/tests/unit/SkiaPipelineTests.cpp
index 42a92fc..26b6000 100644
--- a/libs/hwui/tests/unit/SkiaPipelineTests.cpp
+++ b/libs/hwui/tests/unit/SkiaPipelineTests.cpp
@@ -167,10 +167,10 @@
ASSERT_EQ(layerUpdateQueue.entries().size(), 2UL);
bool opaque = true;
- FrameBuilder::LightGeometry lightGeometry;
+ LightGeometry lightGeometry;
lightGeometry.radius = 1.0f;
lightGeometry.center = {0.0f, 0.0f, 0.0f};
- BakedOpRenderer::LightInfo lightInfo;
+ LightInfo lightInfo;
auto pipeline = std::make_unique<SkiaOpenGLPipeline>(renderThread);
pipeline->renderLayers(lightGeometry, &layerUpdateQueue, opaque, false, lightInfo);
ASSERT_EQ(TestUtils::getColor(surfaceLayer1, 0, 0), SK_ColorRED);
diff --git a/libs/hwui/utils/TestWindowContext.cpp b/libs/hwui/utils/TestWindowContext.cpp
index 700d3b3..8ac6e1f 100644
--- a/libs/hwui/utils/TestWindowContext.cpp
+++ b/libs/hwui/utils/TestWindowContext.cpp
@@ -17,7 +17,6 @@
#include "AnimationContext.h"
#include "IContextFactory.h"
-#include "RecordingCanvas.h"
#include "RenderNode.h"
#include "SkTypes.h"
#include "gui/BufferQueue.h"
@@ -25,6 +24,7 @@
#include "gui/IGraphicBufferConsumer.h"
#include "gui/IGraphicBufferProducer.h"
#include "gui/Surface.h"
+#include "hwui/Canvas.h"
#include "renderthread/RenderProxy.h"
#include <cutils/memory.h>
@@ -81,7 +81,7 @@
android::uirenderer::Vector3 lightVector{lightX, -200.0f, 800.0f};
mProxy->setup(800.0f, 255 * 0.075f, 255 * 0.15f);
mProxy->setLightCenter(lightVector);
- mCanvas.reset(new android::uirenderer::RecordingCanvas(mSize.width(), mSize.height()));
+ mCanvas.reset(Canvas::create_recording_canvas(mSize.width(), mSize.height(), mRootNode.get()));
}
SkCanvas* prepareToDraw() {
@@ -155,7 +155,7 @@
private:
std::unique_ptr<android::uirenderer::RenderNode> mRootNode;
std::unique_ptr<android::uirenderer::renderthread::RenderProxy> mProxy;
- std::unique_ptr<android::uirenderer::RecordingCanvas> mCanvas;
+ std::unique_ptr<android::Canvas> mCanvas;
android::sp<android::IGraphicBufferProducer> mProducer;
android::sp<android::IGraphicBufferConsumer> mConsumer;
android::sp<android::CpuConsumer> mCpuConsumer;