Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rename Reorderers to Builders

Browse Source 
Change-Id: I9bb5a2e70055e2f6d14912fbd86ab72ac0d6e20c
This commit is contained in:
Chris Craik
2016-01-12 14:45:08 -08:00
parent 89ceb5c977
commit f158b49c88
9 changed files with 184 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
libs/hwui/Android.mk
View File

@@ -109,8 +109,8 @@ ifeq (true, $(HWUI_NEW_OPS))
BakedOpDispatcher.cpp \
BakedOpRenderer.cpp \
BakedOpState.cpp \
FrameReorderer.cpp \
LayerReorderer.cpp \
FrameBuilder.cpp \
LayerBuilder.cpp \
RecordingCanvas.cpp
hwui_cflags += -DHWUI_NEW_OPS
@@ -237,7 +237,7 @@ LOCAL_SRC_FILES += \
ifeq (true, $(HWUI_NEW_OPS))
LOCAL_SRC_FILES += \
tests/unit/BakedOpStateTests.cpp \
tests/unit/FrameReordererTests.cpp \
tests/unit/FrameBuilderTests.cpp \
tests/unit/RecordingCanvasTests.cpp
endif
@@ -299,7 +299,7 @@ LOCAL_SRC_FILES += \
ifeq (true, $(HWUI_NEW_OPS))
LOCAL_SRC_FILES += \
tests/microbench/FrameReordererBench.cpp
tests/microbench/FrameBuilderBench.cpp
endif
include $(BUILD_EXECUTABLE)

98
libs/hwui/FrameReorderer.cpp → libs/hwui/FrameBuilder.cpp
View File

@@ -14,7 +14,7 @@
* limitations under the License.
*/
#include "FrameReorderer.h"
#include "FrameBuilder.h"
#include "LayerUpdateQueue.h"
#include "RenderNode.h"
@@ -30,25 +30,25 @@
namespace android {
namespace uirenderer {
FrameReorderer::FrameReorderer(const LayerUpdateQueue& layers, const SkRect& clip,
FrameBuilder::FrameBuilder(const LayerUpdateQueue& layers, const SkRect& clip,
uint32_t viewportWidth, uint32_t viewportHeight,
const std::vector< sp<RenderNode> >& nodes, const Vector3& lightCenter)
: mCanvasState(*this) {
ATRACE_NAME("prepare drawing commands");
mLayerReorderers.reserve(layers.entries().size());
mLayerBuilders.reserve(layers.entries().size());
mLayerStack.reserve(layers.entries().size());
// Prepare to defer Fbo0
auto fbo0 = mAllocator.create<LayerReorderer>(viewportWidth, viewportHeight, Rect(clip));
mLayerReorderers.push_back(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,
lightCenter);
// 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 (mLayerReorderers are issued to Renderer in reverse)
// 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;
const Rect& layerDamage = layers.entries()[i].damage;
@@ -78,11 +78,11 @@ FrameReorderer::FrameReorderer(const LayerUpdateQueue& layers, const SkRect& cli
}
}
void FrameReorderer::onViewportInitialized() {}
void FrameBuilder::onViewportInitialized() {}
void FrameReorderer::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {}
void FrameBuilder::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {}
void FrameReorderer::deferNodePropsAndOps(RenderNode& node) {
void FrameBuilder::deferNodePropsAndOps(RenderNode& node) {
const RenderProperties& properties = node.properties();
const Outline& outline = properties.getOutline();
if (properties.getAlpha() <= 0
@@ -214,7 +214,7 @@ static size_t findNonNegativeIndex(const V& zTranslatedNodes) {
}
template <typename V>
void FrameReorderer::defer3dChildren(ChildrenSelectMode mode, const V& zTranslatedNodes) {
void FrameBuilder::defer3dChildren(ChildrenSelectMode mode, const V& zTranslatedNodes) {
const int size = zTranslatedNodes.size();
if (size == 0
|| (mode == ChildrenSelectMode::Negative&& zTranslatedNodes[0].key > 0.0f)
@@ -264,7 +264,7 @@ void FrameReorderer::defer3dChildren(ChildrenSelectMode mode, const V& zTranslat
}
}
void FrameReorderer::deferShadow(const RenderNodeOp& casterNodeOp) {
void FrameBuilder::deferShadow(const RenderNodeOp& casterNodeOp) {
auto& node = *casterNodeOp.renderNode;
auto& properties = node.properties();
@@ -320,7 +320,7 @@ void FrameReorderer::deferShadow(const RenderNodeOp& casterNodeOp) {
}
}
void FrameReorderer::deferProjectedChildren(const RenderNode& renderNode) {
void FrameBuilder::deferProjectedChildren(const RenderNode& renderNode) {
const SkPath* projectionReceiverOutline = renderNode.properties().getOutline().getPath();
int count = mCanvasState.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
@@ -353,15 +353,15 @@ void FrameReorderer::deferProjectedChildren(const RenderNode& renderNode) {
}
/**
* Used to define a list of lambdas referencing private FrameReorderer::onXX::defer() methods.
* 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 FrameReorderer::onBitmapOp(const BitmapOp&)
* E.g. a BitmapOp op then would be dispatched to FrameBuilder::onBitmapOp(const BitmapOp&)
*/
#define OP_RECEIVER(Type) \
[](FrameReorderer& reorderer, const RecordedOp& op) { reorderer.defer##Type(static_cast<const Type&>(op)); },
void FrameReorderer::deferNodeOps(const RenderNode& renderNode) {
typedef void (*OpDispatcher) (FrameReorderer& reorderer, const RecordedOp& op);
[](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
@@ -385,7 +385,7 @@ void FrameReorderer::deferNodeOps(const RenderNode& renderNode) {
}
}
void FrameReorderer::deferRenderNodeOpImpl(const RenderNodeOp& op) {
void FrameBuilder::deferRenderNodeOpImpl(const RenderNodeOp& op) {
if (op.renderNode->nothingToDraw()) return;
int count = mCanvasState.save(SkCanvas::kClip_SaveFlag | SkCanvas::kMatrix_SaveFlag);
@@ -400,7 +400,7 @@ void FrameReorderer::deferRenderNodeOpImpl(const RenderNodeOp& op) {
mCanvasState.restoreToCount(count);
}
void FrameReorderer::deferRenderNodeOp(const RenderNodeOp& op) {
void FrameBuilder::deferRenderNodeOp(const RenderNodeOp& op) {
if (!op.skipInOrderDraw) {
deferRenderNodeOpImpl(op);
}
@@ -410,7 +410,7 @@ void FrameReorderer::deferRenderNodeOp(const RenderNodeOp& op) {
* Defers an unmergeable, strokeable op, accounting correctly
* for paint's style on the bounds being computed.
*/
void FrameReorderer::deferStrokeableOp(const RecordedOp& op, batchid_t batchId,
void FrameBuilder::deferStrokeableOp(const RecordedOp& op, batchid_t batchId,
BakedOpState::StrokeBehavior strokeBehavior) {
// Note: here we account for stroke when baking the op
BakedOpState* bakedState = BakedOpState::tryStrokeableOpConstruct(
@@ -432,7 +432,7 @@ static batchid_t tessBatchId(const RecordedOp& op) {
: (paint.isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices);
}
void FrameReorderer::deferArcOp(const ArcOp& op) {
void FrameBuilder::deferArcOp(const ArcOp& op) {
deferStrokeableOp(op, tessBatchId(op));
}
@@ -441,7 +441,7 @@ static bool hasMergeableClip(const BakedOpState& state) {
|| state.computedState.clipState->mode == ClipMode::Rectangle;
}
void FrameReorderer::deferBitmapOp(const BitmapOp& op) {
void FrameBuilder::deferBitmapOp(const BitmapOp& op) {
BakedOpState* bakedState = tryBakeOpState(op);
if (!bakedState) return; // quick rejected
@@ -461,19 +461,19 @@ void FrameReorderer::deferBitmapOp(const BitmapOp& op) {
}
}
void FrameReorderer::deferBitmapMeshOp(const BitmapMeshOp& op) {
void FrameBuilder::deferBitmapMeshOp(const BitmapMeshOp& op) {
BakedOpState* bakedState = tryBakeOpState(op);
if (!bakedState) return; // quick rejected
currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
}
void FrameReorderer::deferBitmapRectOp(const BitmapRectOp& op) {
void FrameBuilder::deferBitmapRectOp(const BitmapRectOp& op) {
BakedOpState* bakedState = tryBakeOpState(op);
if (!bakedState) return; // quick rejected
currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
}
void FrameReorderer::deferCirclePropsOp(const CirclePropsOp& op) {
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);
@@ -488,22 +488,22 @@ void FrameReorderer::deferCirclePropsOp(const CirclePropsOp& op) {
deferOvalOp(*resolvedOp);
}
void FrameReorderer::deferFunctorOp(const FunctorOp& op) {
void FrameBuilder::deferFunctorOp(const FunctorOp& op) {
BakedOpState* bakedState = tryBakeOpState(op);
if (!bakedState) return; // quick rejected
currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Functor);
}
void FrameReorderer::deferLinesOp(const LinesOp& op) {
void FrameBuilder::deferLinesOp(const LinesOp& op) {
batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices;
deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced);
}
void FrameReorderer::deferOvalOp(const OvalOp& op) {
void FrameBuilder::deferOvalOp(const OvalOp& op) {
deferStrokeableOp(op, tessBatchId(op));
}
void FrameReorderer::deferPatchOp(const PatchOp& op) {
void FrameBuilder::deferPatchOp(const PatchOp& op) {
BakedOpState* bakedState = tryBakeOpState(op);
if (!bakedState) return; // quick rejected
@@ -521,24 +521,24 @@ void FrameReorderer::deferPatchOp(const PatchOp& op) {
}
}
void FrameReorderer::deferPathOp(const PathOp& op) {
void FrameBuilder::deferPathOp(const PathOp& op) {
deferStrokeableOp(op, OpBatchType::Bitmap);
}
void FrameReorderer::deferPointsOp(const PointsOp& op) {
void FrameBuilder::deferPointsOp(const PointsOp& op) {
batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices;
deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced);
}
void FrameReorderer::deferRectOp(const RectOp& op) {
void FrameBuilder::deferRectOp(const RectOp& op) {
deferStrokeableOp(op, tessBatchId(op));
}
void FrameReorderer::deferRoundRectOp(const RoundRectOp& op) {
void FrameBuilder::deferRoundRectOp(const RoundRectOp& op) {
deferStrokeableOp(op, tessBatchId(op));
}
void FrameReorderer::deferRoundRectPropsOp(const RoundRectPropsOp& op) {
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 = new (mAllocator) RoundRectOp(
@@ -549,7 +549,7 @@ void FrameReorderer::deferRoundRectPropsOp(const RoundRectPropsOp& op) {
deferRoundRectOp(*resolvedOp);
}
void FrameReorderer::deferSimpleRectsOp(const SimpleRectsOp& op) {
void FrameBuilder::deferSimpleRectsOp(const SimpleRectsOp& op) {
BakedOpState* bakedState = tryBakeOpState(op);
if (!bakedState) return; // quick rejected
currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices);
@@ -560,7 +560,7 @@ static batchid_t textBatchId(const SkPaint& paint) {
return paint.getColor() == SK_ColorBLACK ? OpBatchType::Text : OpBatchType::ColorText;
}
void FrameReorderer::deferTextOp(const TextOp& op) {
void FrameBuilder::deferTextOp(const TextOp& op) {
BakedOpState* bakedState = tryBakeOpState(op);
if (!bakedState) return; // quick rejected
@@ -575,19 +575,19 @@ void FrameReorderer::deferTextOp(const TextOp& op) {
}
}
void FrameReorderer::deferTextOnPathOp(const TextOnPathOp& op) {
void FrameBuilder::deferTextOnPathOp(const TextOnPathOp& op) {
BakedOpState* bakedState = tryBakeOpState(op);
if (!bakedState) return; // quick rejected
currentLayer().deferUnmergeableOp(mAllocator, bakedState, textBatchId(*(op.paint)));
}
void FrameReorderer::deferTextureLayerOp(const TextureLayerOp& op) {
void FrameBuilder::deferTextureLayerOp(const TextureLayerOp& op) {
BakedOpState* bakedState = tryBakeOpState(op);
if (!bakedState) return; // quick rejected
currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::TextureLayer);
}
void FrameReorderer::saveForLayer(uint32_t layerWidth, uint32_t layerHeight,
void FrameBuilder::saveForLayer(uint32_t layerWidth, uint32_t layerHeight,
float contentTranslateX, float contentTranslateY,
const Rect& repaintRect,
const Vector3& lightCenter,
@@ -602,13 +602,13 @@ void FrameReorderer::saveForLayer(uint32_t layerWidth, uint32_t layerHeight,
repaintRect.left, repaintRect.top, repaintRect.right, repaintRect.bottom);
// create a new layer repaint, and push its index on the stack
mLayerStack.push_back(mLayerReorderers.size());
auto newFbo = mAllocator.create<LayerReorderer>(layerWidth, layerHeight,
mLayerStack.push_back(mLayerBuilders.size());
auto newFbo = mAllocator.create<LayerBuilder>(layerWidth, layerHeight,
repaintRect, beginLayerOp, renderNode);
mLayerReorderers.push_back(newFbo);
mLayerBuilders.push_back(newFbo);
}
void FrameReorderer::restoreForLayer() {
void FrameBuilder::restoreForLayer() {
// restore canvas, and pop finished layer off of the stack
mCanvasState.restore();
mLayerStack.pop_back();
@@ -616,7 +616,7 @@ void FrameReorderer::restoreForLayer() {
// TODO: defer time rejection (when bounds become empty) + tests
// Option - just skip layers with no bounds at playback + defer?
void FrameReorderer::deferBeginLayerOp(const BeginLayerOp& op) {
void FrameBuilder::deferBeginLayerOp(const BeginLayerOp& op) {
uint32_t layerWidth = (uint32_t) op.unmappedBounds.getWidth();
uint32_t layerHeight = (uint32_t) op.unmappedBounds.getHeight();
@@ -661,7 +661,7 @@ void FrameReorderer::deferBeginLayerOp(const BeginLayerOp& op) {
&op, nullptr);
}
void FrameReorderer::deferEndLayerOp(const EndLayerOp& /* ignored */) {
void FrameBuilder::deferEndLayerOp(const EndLayerOp& /* ignored */) {
const BeginLayerOp& beginLayerOp = *currentLayer().beginLayerOp;
int finishedLayerIndex = mLayerStack.back();
@@ -674,7 +674,7 @@ void FrameReorderer::deferEndLayerOp(const EndLayerOp& /* ignored */) {
beginLayerOp.localMatrix,
beginLayerOp.localClip,
beginLayerOp.paint,
&(mLayerReorderers[finishedLayerIndex]->offscreenBuffer));
&(mLayerBuilders[finishedLayerIndex]->offscreenBuffer));
BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp);
if (bakedOpState) {
@@ -684,12 +684,12 @@ void FrameReorderer::deferEndLayerOp(const EndLayerOp& /* ignored */) {
// 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?
mLayerReorderers[finishedLayerIndex]->clear();
mLayerBuilders[finishedLayerIndex]->clear();
return;
}
}
void FrameReorderer::deferBeginUnclippedLayerOp(const BeginUnclippedLayerOp& op) {
void FrameBuilder::deferBeginUnclippedLayerOp(const BeginUnclippedLayerOp& op) {
Matrix4 boundsTransform(*(mCanvasState.currentSnapshot()->transform));
boundsTransform.multiply(op.localMatrix);
@@ -724,7 +724,7 @@ void FrameReorderer::deferBeginUnclippedLayerOp(const BeginUnclippedLayerOp& op)
currentLayer().activeUnclippedSaveLayers.push_back(bakedState);
}
void FrameReorderer::deferEndUnclippedLayerOp(const EndUnclippedLayerOp& /* ignored */) {
void FrameBuilder::deferEndUnclippedLayerOp(const EndUnclippedLayerOp& /* ignored */) {
LOG_ALWAYS_FATAL_IF(currentLayer().activeUnclippedSaveLayers.empty(), "no layer to end!");
BakedOpState* copyFromLayerOp = currentLayer().activeUnclippedSaveLayers.back();

30
libs/hwui/FrameReorderer.h → libs/hwui/FrameBuilder.h
View File

@@ -19,7 +19,7 @@
#include "BakedOpState.h"
#include "CanvasState.h"
#include "DisplayList.h"
#include "LayerReorderer.h"
#include "LayerBuilder.h"
#include "RecordedOp.h"
#include <vector>
@@ -42,7 +42,7 @@ class Rect;
* 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 LayerReorderer.
* 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)
@@ -52,13 +52,13 @@ class Rect;
* 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 FrameReorderer : public CanvasStateClient {
class FrameBuilder : public CanvasStateClient {
public:
FrameReorderer(const LayerUpdateQueue& layers, const SkRect& clip,
FrameBuilder(const LayerUpdateQueue& layers, const SkRect& clip,
uint32_t viewportWidth, uint32_t viewportHeight,
const std::vector< sp<RenderNode> >& nodes, const Vector3& lightCenter);
virtual ~FrameReorderer() {}
virtual ~FrameBuilder() {}
/**
* replayBakedOps() is templated based on what class will receive ops being replayed.
@@ -98,8 +98,8 @@ public:
// Relay through layers in reverse order, since layers
// later in the list will be drawn by earlier ones
for (int i = mLayerReorderers.size() - 1; i >= 1; i--) {
LayerReorderer& layer = *(mLayerReorderers[i]);
for (int i = mLayerBuilders.size() - 1; i >= 1; i--) {
LayerBuilder& layer = *(mLayerBuilders[i]);
if (layer.renderNode) {
// cached HW layer - can't skip layer if empty
renderer.startRepaintLayer(layer.offscreenBuffer, layer.repaintRect);
@@ -112,14 +112,14 @@ public:
}
}
const LayerReorderer& fbo0 = *(mLayerReorderers[0]);
const LayerBuilder& fbo0 = *(mLayerBuilders[0]);
renderer.startFrame(fbo0.width, fbo0.height, fbo0.repaintRect);
fbo0.replayBakedOpsImpl((void*)&renderer, unmergedReceivers, mergedReceivers);
renderer.endFrame(fbo0.repaintRect);
}
void dump() const {
for (auto&& layer : mLayerReorderers) {
for (auto&& layer : mLayerBuilders) {
layer->dump();
}
}
@@ -143,7 +143,7 @@ private:
const BeginLayerOp* beginLayerOp, RenderNode* renderNode);
void restoreForLayer();
LayerReorderer& currentLayer() { return *(mLayerReorderers[mLayerStack.back()]); }
LayerBuilder& currentLayer() { return *(mLayerBuilders[mLayerStack.back()]); }
BakedOpState* tryBakeOpState(const RecordedOp& recordedOp) {
return BakedOpState::tryConstruct(mAllocator, *mCanvasState.writableSnapshot(), recordedOp);
@@ -173,7 +173,7 @@ private:
BakedOpState::StrokeBehavior strokeBehavior = BakedOpState::StrokeBehavior::StyleDefined);
/**
* Declares all FrameReorderer::deferXXXXOp() methods for every RecordedOp type.
* Declares all FrameBuilder::deferXXXXOp() methods for every RecordedOp type.
*
* These private methods are called from within deferImpl to defer each individual op
* type differently.
@@ -183,17 +183,17 @@ private:
#undef X
// List of every deferred layer's render state. Replayed in reverse order to render a frame.
std::vector<LayerReorderer*> mLayerReorderers;
std::vector<LayerBuilder*> mLayerBuilders;
/*
* Stack of indices within mLayerReorderers representing currently active layers. If drawing
* 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 mLayerReorderers. When a
* layer is finished deferring, it will still be represented in mLayerReorderers, but it'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.
*/

20
libs/hwui/LayerReorderer.cpp → libs/hwui/LayerBuilder.cpp
View File

@@ -14,7 +14,7 @@
* limitations under the License.
*/
#include "LayerReorderer.h"
#include "LayerBuilder.h"
#include "BakedOpState.h"
#include "RenderNode.h"
@@ -202,7 +202,7 @@ private:
int mClipSideFlags;
};
LayerReorderer::LayerReorderer(uint32_t width, uint32_t height,
LayerBuilder::LayerBuilder(uint32_t width, uint32_t height,
const Rect& repaintRect, const BeginLayerOp* beginLayerOp, RenderNode* renderNode)
: width(width)
, height(height)
@@ -214,7 +214,7 @@ LayerReorderer::LayerReorderer(uint32_t width, uint32_t height,
// iterate back toward target to see if anything drawn since should overlap the new op
// if no target, merging ops still iterate to find similar batch to insert after
void LayerReorderer::locateInsertIndex(int batchId, const Rect& clippedBounds,
void LayerBuilder::locateInsertIndex(int batchId, const Rect& clippedBounds,
BatchBase** targetBatch, size_t* insertBatchIndex) const {
for (int i = mBatches.size() - 1; i >= 0; i--) {
BatchBase* overBatch = mBatches[i];
@@ -237,11 +237,11 @@ void LayerReorderer::locateInsertIndex(int batchId, const Rect& clippedBounds,
}
}
void LayerReorderer::deferLayerClear(const Rect& rect) {
void LayerBuilder::deferLayerClear(const Rect& rect) {
mClearRects.push_back(rect);
}
void LayerReorderer::flushLayerClears(LinearAllocator& allocator) {
void LayerBuilder::flushLayerClears(LinearAllocator& allocator) {
if (CC_UNLIKELY(!mClearRects.empty())) {
const int vertCount = mClearRects.size() * 4;
// put the verts in the frame allocator, since
@@ -273,7 +273,7 @@ void LayerReorderer::flushLayerClears(LinearAllocator& allocator) {
}
}
void LayerReorderer::deferUnmergeableOp(LinearAllocator& allocator,
void LayerBuilder::deferUnmergeableOp(LinearAllocator& allocator,
BakedOpState* op, batchid_t batchId) {
if (batchId != OpBatchType::CopyToLayer) {
// if first op after one or more unclipped saveLayers, flush the layer clears
@@ -298,7 +298,7 @@ void LayerReorderer::deferUnmergeableOp(LinearAllocator& allocator,
}
}
void LayerReorderer::deferMergeableOp(LinearAllocator& allocator,
void LayerBuilder::deferMergeableOp(LinearAllocator& allocator,
BakedOpState* op, batchid_t batchId, mergeid_t mergeId) {
if (batchId != OpBatchType::CopyToLayer) {
// if first op after one or more unclipped saveLayers, flush the layer clears
@@ -330,7 +330,7 @@ void LayerReorderer::deferMergeableOp(LinearAllocator& allocator,
}
}
void LayerReorderer::replayBakedOpsImpl(void* arg,
void LayerBuilder::replayBakedOpsImpl(void* arg,
BakedOpReceiver* unmergedReceivers, MergedOpReceiver* mergedReceivers) const {
ATRACE_NAME("flush drawing commands");
for (const BatchBase* batch : mBatches) {
@@ -353,8 +353,8 @@ void LayerReorderer::replayBakedOpsImpl(void* arg,
}
}
void LayerReorderer::dump() const {
ALOGD("LayerReorderer %p, %ux%u buffer %p, blo %p, rn %p",
void LayerBuilder::dump() const {
ALOGD("LayerBuilder %p, %ux%u buffer %p, blo %p, rn %p",
this, width, height, offscreenBuffer, beginLayerOp, renderNode);
for (const BatchBase* batch : mBatches) {
batch->dump();

14
libs/hwui/LayerReorderer.h → libs/hwui/LayerBuilder.h
View File

@@ -67,17 +67,17 @@ typedef void (*MergedOpReceiver)(void*, const MergedBakedOpList& opList);
* Stores the deferred render operations and state used to compute ordering
* for a single FBO/layer.
*/
class LayerReorderer {
class LayerBuilder {
// Prevent copy/assign because users may stash pointer to offscreenBuffer and viewportClip
PREVENT_COPY_AND_ASSIGN(LayerReorderer);
PREVENT_COPY_AND_ASSIGN(LayerBuilder);
public:
// Create LayerReorderer for Fbo0
LayerReorderer(uint32_t width, uint32_t height, const Rect& repaintRect)
: LayerReorderer(width, height, repaintRect, nullptr, nullptr) {};
// Create LayerBuilder for Fbo0
LayerBuilder(uint32_t width, uint32_t height, const Rect& repaintRect)
: LayerBuilder(width, height, repaintRect, nullptr, nullptr) {};
// Create LayerReorderer for an offscreen layer, where beginLayerOp is present for a
// Create LayerBuilder for an offscreen layer, where beginLayerOp is present for a
// saveLayer, renderNode is present for a HW layer.
LayerReorderer(uint32_t width, uint32_t height,
LayerBuilder(uint32_t width, uint32_t height,
const Rect& repaintRect, const BeginLayerOp* beginLayerOp, RenderNode* renderNode);
// iterate back toward target to see if anything drawn since should overlap the new op

4
libs/hwui/RenderNode.h
View File

@@ -47,11 +47,11 @@ class CanvasState;
class DisplayListCanvas;
class DisplayListOp;
class OpenGLRenderer;
class OpReorderer;
class Rect;
class SkiaShader;
#if HWUI_NEW_OPS
class FrameBuilder;
class OffscreenBuffer;
struct RenderNodeOp;
typedef OffscreenBuffer layer_t;
@@ -87,7 +87,7 @@ class RenderNode;
*/
class RenderNode : public VirtualLightRefBase {
friend class TestUtils; // allow TestUtils to access syncDisplayList / syncProperties
friend class FrameReorderer;
friend class FrameBuilder;
public:
enum DirtyPropertyMask {
GENERIC = 1 << 1,

7
libs/hwui/renderthread/CanvasContext.cpp
View File

@@ -31,7 +31,7 @@
#include "utils/TimeUtils.h"
#if HWUI_NEW_OPS
#include "FrameReorderer.h"
#include "FrameBuilder.h"
#endif
#include <cutils/properties.h>
@@ -338,14 +338,13 @@ void CanvasContext::draw() {
mEglManager.damageFrame(frame, dirty);
#if HWUI_NEW_OPS
FrameReorderer reorderer(mLayerUpdateQueue, dirty, frame.width(), frame.height(),
FrameBuilder frameBuilder(mLayerUpdateQueue, dirty, frame.width(), frame.height(),
mRenderNodes, mLightCenter);
mLayerUpdateQueue.clear();
BakedOpRenderer renderer(Caches::getInstance(), mRenderThread.renderState(),
mOpaque, mLightInfo);
// TODO: profiler().draw(mCanvas);
reorderer.replayBakedOps<BakedOpDispatcher>(renderer);
frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
bool drew = renderer.didDraw();
#else

18
libs/hwui/tests/microbench/FrameReordererBench.cpp → libs/hwui/tests/microbench/FrameBuilderBench.cpp
View File

@@ -19,7 +19,7 @@
#include "BakedOpState.h"
#include "BakedOpDispatcher.h"
#include "BakedOpRenderer.h"
#include "FrameReorderer.h"
#include "FrameBuilder.h"
#include "LayerUpdateQueue.h"
#include "RecordedOp.h"
#include "RecordingCanvas.h"
@@ -66,9 +66,9 @@ void BM_FrameBuilder_defer::Run(int iters) {
auto nodes = createTestNodeList();
StartBenchmarkTiming();
for (int i = 0; i < iters; i++) {
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 200), 100, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 200), 100, 200,
nodes, sLightCenter);
MicroBench::DoNotOptimize(&reorderer);
MicroBench::DoNotOptimize(&frameBuilder);
}
StopBenchmarkTiming();
}
@@ -84,11 +84,11 @@ void BM_FrameBuilder_deferAndRender::Run(int iters) {
StartBenchmarkTiming();
for (int i = 0; i < iters; i++) {
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 200), 100, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 200), 100, 200,
nodes, sLightCenter);
BakedOpRenderer renderer(caches, renderState, true, lightInfo);
reorderer.replayBakedOps<BakedOpDispatcher>(renderer);
frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
MicroBench::DoNotOptimize(&renderer);
}
StopBenchmarkTiming();
@@ -117,10 +117,10 @@ static void benchDeferScene(testing::Benchmark& benchmark, int iters, const char
auto nodes = getSyncedSceneNodes(sceneName);
benchmark.StartBenchmarkTiming();
for (int i = 0; i < iters; i++) {
FrameReorderer reorderer(sEmptyLayerUpdateQueue,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue,
SkRect::MakeWH(gDisplay.w, gDisplay.h), gDisplay.w, gDisplay.h,
nodes, sLightCenter);
MicroBench::DoNotOptimize(&reorderer);
MicroBench::DoNotOptimize(&frameBuilder);
}
benchmark.StopBenchmarkTiming();
}
@@ -136,12 +136,12 @@ static void benchDeferAndRenderScene(testing::Benchmark& benchmark,
benchmark.StartBenchmarkTiming();
for (int i = 0; i < iters; i++) {
FrameReorderer reorderer(sEmptyLayerUpdateQueue,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue,
SkRect::MakeWH(gDisplay.w, gDisplay.h), gDisplay.w, gDisplay.h,
nodes, sLightCenter);
BakedOpRenderer renderer(caches, renderState, true, lightInfo);
reorderer.replayBakedOps<BakedOpDispatcher>(renderer);
frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
MicroBench::DoNotOptimize(&renderer);
}
benchmark.StopBenchmarkTiming();

170
libs/hwui/tests/unit/FrameReordererTests.cpp → libs/hwui/tests/unit/FrameBuilderTests.cpp
View File

@@ -18,7 +18,7 @@
#include <BakedOpState.h>
#include <DeferredLayerUpdater.h>
#include <FrameReorderer.h>
#include <FrameBuilder.h>
#include <LayerUpdateQueue.h>
#include <RecordedOp.h>
#include <RecordingCanvas.h>
@@ -113,7 +113,7 @@ public:
class FailRenderer : public TestRendererBase {};
TEST(FrameReorderer, simple) {
TEST(FrameBuilder, simple) {
class SimpleTestRenderer : public TestRendererBase {
public:
void startFrame(uint32_t width, uint32_t height, const Rect& repaintRect) override {
@@ -138,14 +138,14 @@ TEST(FrameReorderer, simple) {
canvas.drawRect(0, 0, 100, 200, SkPaint());
canvas.drawBitmap(bitmap, 10, 10, nullptr);
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 200), 100, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 200), 100, 200,
createSyncedNodeList(node), sLightCenter);
SimpleTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(4, renderer.getIndex()); // 2 ops + start + end
}
TEST(FrameReorderer, simpleStroke) {
TEST(FrameBuilder, simpleStroke) {
class SimpleStrokeTestRenderer : public TestRendererBase {
public:
void onPointsOp(const PointsOp& op, const BakedOpState& state) override {
@@ -164,14 +164,14 @@ TEST(FrameReorderer, simpleStroke) {
strokedPaint.setStrokeWidth(10);
canvas.drawPoint(50, 50, strokedPaint);
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 200), 100, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 200), 100, 200,
createSyncedNodeList(node), sLightCenter);
SimpleStrokeTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(1, renderer.getIndex());
}
TEST(FrameReorderer, simpleRejection) {
TEST(FrameBuilder, simpleRejection) {
auto node = TestUtils::createNode(0, 0, 200, 200,
[](RenderProperties& props, RecordingCanvas& canvas) {
canvas.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
@@ -179,14 +179,14 @@ TEST(FrameReorderer, simpleRejection) {
canvas.drawRect(0, 0, 400, 400, SkPaint());
canvas.restore();
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(node), sLightCenter);
FailRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
}
TEST(FrameReorderer, simpleBatching) {
TEST(FrameBuilder, simpleBatching) {
const int LOOPS = 5;
class SimpleBatchingTestRenderer : public TestRendererBase {
public:
@@ -214,15 +214,15 @@ TEST(FrameReorderer, simpleBatching) {
canvas.restore();
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(node), sLightCenter);
SimpleBatchingTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(2 * LOOPS, renderer.getIndex())
<< "Expect number of ops = 2 * loop count";
}
TEST(FrameReorderer, clippedMerging) {
TEST(FrameBuilder, clippedMerging) {
class ClippedMergingTestRenderer : public TestRendererBase {
public:
void onMergedBitmapOps(const MergedBakedOpList& opList) override {
@@ -255,14 +255,14 @@ TEST(FrameReorderer, clippedMerging) {
canvas.drawBitmap(bitmap, 40, 70, nullptr);
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 100, 100,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 100, 100,
createSyncedNodeList(node), sLightCenter);
ClippedMergingTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(4, renderer.getIndex());
}
TEST(FrameReorderer, textMerging) {
TEST(FrameBuilder, textMerging) {
class TextMergingTestRenderer : public TestRendererBase {
public:
void onMergedTextOps(const MergedBakedOpList& opList) override {
@@ -283,14 +283,14 @@ TEST(FrameReorderer, textMerging) {
TestUtils::drawTextToCanvas(&canvas, "Test string1", paint, 100, 0); // will be top clipped
TestUtils::drawTextToCanvas(&canvas, "Test string1", paint, 100, 100); // not clipped
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(400, 400), 400, 400,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(400, 400), 400, 400,
createSyncedNodeList(node), sLightCenter);
TextMergingTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(2, renderer.getIndex()) << "Expect 2 ops";
}
TEST(FrameReorderer, textStrikethrough) {
TEST(FrameBuilder, textStrikethrough) {
const int LOOPS = 5;
class TextStrikethroughTestRenderer : public TestRendererBase {
public:
@@ -314,15 +314,15 @@ TEST(FrameReorderer, textStrikethrough) {
TestUtils::drawTextToCanvas(&canvas, "test text", textPaint, 10, 100 * (i + 1));
}
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 2000), 200, 2000,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 2000), 200, 2000,
createSyncedNodeList(node), sLightCenter);
TextStrikethroughTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(2 * LOOPS, renderer.getIndex())
<< "Expect number of ops = 2 * loop count";
}
RENDERTHREAD_TEST(FrameReorderer, textureLayer) {
RENDERTHREAD_TEST(FrameBuilder, textureLayer) {
class TextureLayerTestRenderer : public TestRendererBase {
public:
void onTextureLayerOp(const TextureLayerOp& op, const BakedOpState& state) override {
@@ -348,14 +348,14 @@ RENDERTHREAD_TEST(FrameReorderer, textureLayer) {
canvas.drawLayer(layerUpdater.get());
canvas.restore();
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(node), sLightCenter);
TextureLayerTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(1, renderer.getIndex());
}
TEST(FrameReorderer, renderNode) {
TEST(FrameBuilder, renderNode) {
class RenderNodeTestRenderer : public TestRendererBase {
public:
void onRectOp(const RectOp& op, const BakedOpState& state) override {
@@ -393,13 +393,13 @@ TEST(FrameReorderer, renderNode) {
canvas.restore();
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(parent), sLightCenter);
RenderNodeTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
}
TEST(FrameReorderer, clipped) {
TEST(FrameBuilder, clipped) {
class ClippedTestRenderer : public TestRendererBase {
public:
void onBitmapOp(const BitmapOp& op, const BakedOpState& state) override {
@@ -416,14 +416,14 @@ TEST(FrameReorderer, clipped) {
canvas.drawBitmap(bitmap, 0, 0, nullptr);
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue,
SkRect::MakeLTRB(10, 20, 30, 40), // clip to small area, should see in receiver
200, 200, createSyncedNodeList(node), sLightCenter);
ClippedTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
}
TEST(FrameReorderer, saveLayer_simple) {
TEST(FrameBuilder, saveLayer_simple) {
class SaveLayerSimpleTestRenderer : public TestRendererBase {
public:
OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height) override {
@@ -459,14 +459,14 @@ TEST(FrameReorderer, saveLayer_simple) {
canvas.drawRect(10, 10, 190, 190, SkPaint());
canvas.restore();
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(node), sLightCenter);
SaveLayerSimpleTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(4, renderer.getIndex());
}
TEST(FrameReorderer, saveLayer_nested) {
TEST(FrameBuilder, saveLayer_nested) {
/* saveLayer1 { rect1, saveLayer2 { rect2 } } will play back as:
* - startTemporaryLayer2, rect2 endLayer2
* - startTemporaryLayer1, rect1, drawLayer2, endLayer1
@@ -531,14 +531,14 @@ TEST(FrameReorderer, saveLayer_nested) {
canvas.restore();
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(800, 800), 800, 800,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(800, 800), 800, 800,
createSyncedNodeList(node), sLightCenter);
SaveLayerNestedTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(10, renderer.getIndex());
}
TEST(FrameReorderer, saveLayer_contentRejection) {
TEST(FrameBuilder, saveLayer_contentRejection) {
auto node = TestUtils::createNode(0, 0, 200, 200,
[](RenderProperties& props, RecordingCanvas& canvas) {
canvas.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
@@ -551,15 +551,15 @@ TEST(FrameReorderer, saveLayer_contentRejection) {
canvas.restore();
canvas.restore();
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(node), sLightCenter);
FailRenderer renderer;
// should see no ops, even within the layer, since the layer should be rejected
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
}
TEST(FrameReorderer, saveLayerUnclipped_simple) {
TEST(FrameBuilder, saveLayerUnclipped_simple) {
class SaveLayerUnclippedSimpleTestRenderer : public TestRendererBase {
public:
void onCopyToLayerOp(const CopyToLayerOp& op, const BakedOpState& state) override {
@@ -594,14 +594,14 @@ TEST(FrameReorderer, saveLayerUnclipped_simple) {
canvas.drawRect(0, 0, 200, 200, SkPaint());
canvas.restore();
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(node), sLightCenter);
SaveLayerUnclippedSimpleTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(4, renderer.getIndex());
}
TEST(FrameReorderer, saveLayerUnclipped_mergedClears) {
TEST(FrameBuilder, saveLayerUnclipped_mergedClears) {
class SaveLayerUnclippedMergedClearsTestRenderer : public TestRendererBase {
public:
void onCopyToLayerOp(const CopyToLayerOp& op, const BakedOpState& state) override {
@@ -648,10 +648,10 @@ TEST(FrameReorderer, saveLayerUnclipped_mergedClears) {
canvas.drawRect(0, 0, 100, 100, SkPaint());
canvas.restoreToCount(restoreTo);
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(node), sLightCenter);
SaveLayerUnclippedMergedClearsTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(10, renderer.getIndex())
<< "Expect 4 copyTos, 4 copyFroms, 1 clear SimpleRects, and 1 rect.";
}
@@ -660,7 +660,7 @@ TEST(FrameReorderer, saveLayerUnclipped_mergedClears) {
* - startTemporaryLayer, onCopyToLayer, onSimpleRects, onRect, onCopyFromLayer, endLayer
* - startFrame, onCopyToLayer, onSimpleRects, drawLayer, onCopyFromLayer, endframe
*/
TEST(FrameReorderer, saveLayerUnclipped_complex) {
TEST(FrameBuilder, saveLayerUnclipped_complex) {
class SaveLayerUnclippedComplexTestRenderer : public TestRendererBase {
public:
OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height) {
@@ -710,14 +710,14 @@ TEST(FrameReorderer, saveLayerUnclipped_complex) {
canvas.restore();
canvas.restore();
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(600, 600), 600, 600,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(600, 600), 600, 600,
createSyncedNodeList(node), sLightCenter);
SaveLayerUnclippedComplexTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(12, renderer.getIndex());
}
RENDERTHREAD_TEST(FrameReorderer, hwLayer_simple) {
RENDERTHREAD_TEST(FrameBuilder, hwLayer_simple) {
class HwLayerSimpleTestRenderer : public TestRendererBase {
public:
void startRepaintLayer(OffscreenBuffer* offscreenBuffer, const Rect& repaintRect) override {
@@ -768,17 +768,17 @@ RENDERTHREAD_TEST(FrameReorderer, hwLayer_simple) {
LayerUpdateQueue layerUpdateQueue; // Note: enqueue damage post-sync, so bounds are valid
layerUpdateQueue.enqueueLayerWithDamage(node.get(), Rect(25, 25, 75, 75));
FrameReorderer reorderer(layerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(layerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
syncedNodeList, sLightCenter);
HwLayerSimpleTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(6, renderer.getIndex());
// clean up layer pointer, so we can safely destruct RenderNode
*layerHandle = nullptr;
}
RENDERTHREAD_TEST(FrameReorderer, hwLayer_complex) {
RENDERTHREAD_TEST(FrameBuilder, hwLayer_complex) {
/* parentLayer { greyRect, saveLayer { childLayer { whiteRect } } } will play back as:
* - startRepaintLayer(child), rect(grey), endLayer
* - startTemporaryLayer, drawLayer(child), endLayer
@@ -869,10 +869,10 @@ RENDERTHREAD_TEST(FrameReorderer, hwLayer_complex) {
layerUpdateQueue.enqueueLayerWithDamage(child.get(), Rect(100, 100));
layerUpdateQueue.enqueueLayerWithDamage(parent.get(), Rect(200, 200));
FrameReorderer reorderer(layerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(layerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
syncedList, sLightCenter);
HwLayerComplexTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(13, renderer.getIndex());
// clean up layer pointers, so we can safely destruct RenderNodes
@@ -894,7 +894,7 @@ static void drawOrderedNode(RecordingCanvas* canvas, uint8_t expectedDrawOrder,
node->setPropertyFieldsDirty(RenderNode::TRANSLATION_Z);
canvas->drawRenderNode(node.get()); // canvas takes reference/sole ownership
}
TEST(FrameReorderer, zReorder) {
TEST(FrameBuilder, zReorder) {
class ZReorderTestRenderer : public TestRendererBase {
public:
void onRectOp(const RectOp& op, const BakedOpState& state) override {
@@ -918,14 +918,14 @@ TEST(FrameReorderer, zReorder) {
drawOrderedRect(&canvas, 8);
drawOrderedNode(&canvas, 9, -10.0f); // in reorder=false at this point, so played inorder
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 100, 100,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 100, 100,
createSyncedNodeList(parent), sLightCenter);
ZReorderTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(10, renderer.getIndex());
};
TEST(FrameReorderer, projectionReorder) {
TEST(FrameBuilder, projectionReorder) {
static const int scrollX = 5;
static const int scrollY = 10;
class ProjectionReorderTestRenderer : public TestRendererBase {
@@ -1001,10 +1001,10 @@ TEST(FrameReorderer, projectionReorder) {
canvas.restore();
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 100, 100,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 100, 100,
createSyncedNodeList(parent), sLightCenter);
ProjectionReorderTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(3, renderer.getIndex());
}
@@ -1020,7 +1020,7 @@ static sp<RenderNode> createWhiteRectShadowCaster(float translationZ) {
});
}
TEST(FrameReorderer, shadow) {
TEST(FrameBuilder, shadow) {
class ShadowTestRenderer : public TestRendererBase {
public:
void onShadowOp(const ShadowOp& op, const BakedOpState& state) override {
@@ -1044,14 +1044,14 @@ TEST(FrameReorderer, shadow) {
canvas.drawRenderNode(createWhiteRectShadowCaster(5.0f).get());
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(parent), sLightCenter);
ShadowTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(2, renderer.getIndex());
}
TEST(FrameReorderer, shadowSaveLayer) {
TEST(FrameBuilder, shadowSaveLayer) {
class ShadowSaveLayerTestRenderer : public TestRendererBase {
public:
OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height) override {
@@ -1085,14 +1085,14 @@ TEST(FrameReorderer, shadowSaveLayer) {
canvas.restoreToCount(count);
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(parent), (Vector3) { 100, 100, 100 });
ShadowSaveLayerTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(5, renderer.getIndex());
}
RENDERTHREAD_TEST(FrameReorderer, shadowHwLayer) {
RENDERTHREAD_TEST(FrameBuilder, shadowHwLayer) {
class ShadowHwLayerTestRenderer : public TestRendererBase {
public:
void startRepaintLayer(OffscreenBuffer* offscreenBuffer, const Rect& repaintRect) override {
@@ -1135,17 +1135,17 @@ RENDERTHREAD_TEST(FrameReorderer, shadowHwLayer) {
auto syncedList = createSyncedNodeList(parent);
LayerUpdateQueue layerUpdateQueue; // Note: enqueue damage post-sync, so bounds are valid
layerUpdateQueue.enqueueLayerWithDamage(parent.get(), Rect(100, 100));
FrameReorderer reorderer(layerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(layerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
syncedList, (Vector3) { 100, 100, 100 });
ShadowHwLayerTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(5, renderer.getIndex());
// clean up layer pointer, so we can safely destruct RenderNode
*layerHandle = nullptr;
}
TEST(FrameReorderer, shadowLayering) {
TEST(FrameBuilder, shadowLayering) {
class ShadowLayeringTestRenderer : public TestRendererBase {
public:
void onShadowOp(const ShadowOp& op, const BakedOpState& state) override {
@@ -1164,10 +1164,10 @@ TEST(FrameReorderer, shadowLayering) {
canvas.drawRenderNode(createWhiteRectShadowCaster(5.0001f).get());
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200,
createSyncedNodeList(parent), sLightCenter);
ShadowLayeringTestRenderer renderer;
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(4, renderer.getIndex());
}
@@ -1192,14 +1192,14 @@ static void testProperty(std::function<void(RenderProperties&)> propSetupCallbac
canvas.drawRect(0, 0, 100, 100, paint);
});
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 200, 200,
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(100, 100), 200, 200,
createSyncedNodeList(node), sLightCenter);
PropertyTestRenderer renderer(opValidateCallback);
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
EXPECT_EQ(1, renderer.getIndex()) << "Should have seen one op";
}
TEST(FrameReorderer, renderPropOverlappingRenderingAlpha) {
TEST(FrameBuilder, renderPropOverlappingRenderingAlpha) {
testProperty([](RenderProperties& properties) {
properties.setAlpha(0.5f);
properties.setHasOverlappingRendering(false);
@@ -1208,7 +1208,7 @@ TEST(FrameReorderer, renderPropOverlappingRenderingAlpha) {
});
}
TEST(FrameReorderer, renderPropClipping) {
TEST(FrameBuilder, renderPropClipping) {
testProperty([](RenderProperties& properties) {
properties.setClipToBounds(true);
properties.setClipBounds(Rect(10, 20, 300, 400));
@@ -1218,7 +1218,7 @@ TEST(FrameReorderer, renderPropClipping) {
});
}
TEST(FrameReorderer, renderPropRevealClip) {
TEST(FrameBuilder, renderPropRevealClip) {
testProperty([](RenderProperties& properties) {
properties.mutableRevealClip().set(true, 50, 50, 25);
}, [](const RectOp& op, const BakedOpState& state) {
@@ -1229,7 +1229,7 @@ TEST(FrameReorderer, renderPropRevealClip) {
});
}
TEST(FrameReorderer, renderPropOutlineClip) {
TEST(FrameBuilder, renderPropOutlineClip) {
testProperty([](RenderProperties& properties) {
properties.mutableOutline().setShouldClip(true);
properties.mutableOutline().setRoundRect(10, 20, 30, 40, 5.0f, 0.5f);
@@ -1241,7 +1241,7 @@ TEST(FrameReorderer, renderPropOutlineClip) {
});
}
TEST(FrameReorderer, renderPropTransform) {
TEST(FrameBuilder, renderPropTransform) {
testProperty([](RenderProperties& properties) {
properties.setLeftTopRightBottom(10, 10, 110, 110);
@@ -1334,15 +1334,15 @@ void testSaveLayerAlphaClip(SaveLayerAlphaData* outObservedData,
});
auto nodes = createSyncedNodeList(node); // sync before querying height
FrameReorderer reorderer(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, nodes, sLightCenter);
FrameBuilder frameBuilder(sEmptyLayerUpdateQueue, SkRect::MakeWH(200, 200), 200, 200, nodes, sLightCenter);
SaveLayerAlphaClipTestRenderer renderer(outObservedData);
reorderer.replayBakedOps<TestDispatcher>(renderer);
frameBuilder.replayBakedOps<TestDispatcher>(renderer);
// assert, since output won't be valid if we haven't seen a save layer triggered
ASSERT_EQ(4, renderer.getIndex()) << "Test must trigger saveLayer alpha behavior.";
}
TEST(FrameReorderer, renderPropSaveLayerAlphaClipBig) {
TEST(FrameBuilder, renderPropSaveLayerAlphaClipBig) {
SaveLayerAlphaData observedData;
testSaveLayerAlphaClip(&observedData, [](RenderProperties& properties) {
properties.setTranslationX(10); // offset rendering content
@@ -1358,7 +1358,7 @@ TEST(FrameReorderer, renderPropSaveLayerAlphaClipBig) {
<< "expect content to be translated as part of being clipped";
}
TEST(FrameReorderer, renderPropSaveLayerAlphaRotate) {
TEST(FrameBuilder, renderPropSaveLayerAlphaRotate) {
SaveLayerAlphaData observedData;
testSaveLayerAlphaClip(&observedData, [](RenderProperties& properties) {
// Translate and rotate the view so that the only visible part is the top left corner of
@@ -1377,7 +1377,7 @@ TEST(FrameReorderer, renderPropSaveLayerAlphaRotate) {
EXPECT_MATRIX_APPROX_EQ(Matrix4::identity(), observedData.rectMatrix);
}
TEST(FrameReorderer, renderPropSaveLayerAlphaScale) {
TEST(FrameBuilder, renderPropSaveLayerAlphaScale) {
SaveLayerAlphaData observedData;
testSaveLayerAlphaClip(&observedData, [](RenderProperties& properties) {
properties.setPivotX(0);