Update 'DisplayList' vs 'RenderNode' naming in several places
Change-Id: I635c6627d098b661fb9b0ba1bd42fa6d7277d287
diff --git a/core/java/android/view/GLES20Canvas.java b/core/java/android/view/GLES20Canvas.java
index 9fafc48..dcd9ba9 100644
--- a/core/java/android/view/GLES20Canvas.java
+++ b/core/java/android/view/GLES20Canvas.java
@@ -234,12 +234,11 @@
protected static native long nFinishRecording(long renderer);
@Override
- public int drawDisplayList(RenderNode displayList, Rect dirty, int flags) {
- return nDrawDisplayList(mRenderer, displayList.getNativeDisplayList(),
- dirty, flags);
+ public int drawRenderNode(RenderNode renderNode, Rect dirty, int flags) {
+ return nDrawRenderNode(mRenderer, renderNode.getNativeDisplayList(), dirty, flags);
}
- private static native int nDrawDisplayList(long renderer, long displayList,
+ private static native int nDrawRenderNode(long renderer, long renderNode,
Rect dirty, int flags);
///////////////////////////////////////////////////////////////////////////
diff --git a/core/java/android/view/HardwareCanvas.java b/core/java/android/view/HardwareCanvas.java
index b8e7d8c..263ebda 100644
--- a/core/java/android/view/HardwareCanvas.java
+++ b/core/java/android/view/HardwareCanvas.java
@@ -61,16 +61,16 @@
* Draws the specified display list onto this canvas. The display list can only
* be drawn if {@link android.view.RenderNode#isValid()} returns true.
*
- * @param displayList The display list to replay.
+ * @param renderNode The RenderNode to replay.
*/
- public void drawDisplayList(RenderNode displayList) {
- drawDisplayList(displayList, null, RenderNode.FLAG_CLIP_CHILDREN);
+ public void drawRenderNode(RenderNode renderNode) {
+ drawRenderNode(renderNode, null, RenderNode.FLAG_CLIP_CHILDREN);
}
/**
* Draws the specified display list onto this canvas.
*
- * @param displayList The display list to replay.
+ * @param renderNode The RenderNode to replay.
* @param dirty Ignored, can be null.
* @param flags Optional flags about drawing, see {@link RenderNode} for
* the possible flags.
@@ -80,7 +80,7 @@
*
* @hide
*/
- public abstract int drawDisplayList(RenderNode displayList, Rect dirty, int flags);
+ public abstract int drawRenderNode(RenderNode renderNode, Rect dirty, int flags);
/**
* Draws the specified layer onto this canvas.
diff --git a/core/java/android/view/ThreadedRenderer.java b/core/java/android/view/ThreadedRenderer.java
index 166edc2..a2ff0fb 100644
--- a/core/java/android/view/ThreadedRenderer.java
+++ b/core/java/android/view/ThreadedRenderer.java
@@ -222,7 +222,7 @@
try {
canvas.save();
callbacks.onHardwarePreDraw(canvas);
- canvas.drawDisplayList(view.getDisplayList());
+ canvas.drawRenderNode(view.getDisplayList());
callbacks.onHardwarePostDraw(canvas);
canvas.restore();
} finally {
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index d25ef16..bddab59 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -3193,13 +3193,13 @@
private boolean mHasBackgroundTint = false;
/**
- * Display list used for backgrounds.
+ * RenderNode used for backgrounds.
* <p>
* When non-null and valid, this is expected to contain an up-to-date copy
- * of the background drawable. It is cleared on temporary detach and reset
+ * of the background drawable. It is cleared on temporary detach, and reset
* on cleanup.
*/
- private RenderNode mBackgroundDisplayList;
+ private RenderNode mBackgroundRenderNode;
private int mBackgroundResource;
private boolean mBackgroundSizeChanged;
@@ -13755,8 +13755,8 @@
mRenderNode.destroyDisplayListData();
}
- if (mBackgroundDisplayList != null && mBackgroundDisplayList.isValid()) {
- mBackgroundDisplayList.destroyDisplayListData();
+ if (mBackgroundRenderNode != null && mBackgroundRenderNode.isValid()) {
+ mBackgroundRenderNode.destroyDisplayListData();
}
}
@@ -14471,7 +14471,7 @@
mPrivateFlags &= ~PFLAG_INVALIDATED;
}
- RenderNode displayList = null;
+ RenderNode renderNode = null;
Bitmap cache = null;
boolean hasDisplayList = false;
if (caching) {
@@ -14506,12 +14506,12 @@
}
useDisplayListProperties &= hasDisplayList;
if (useDisplayListProperties) {
- displayList = getDisplayList();
- if (!displayList.isValid()) {
+ renderNode = getDisplayList();
+ if (!renderNode.isValid()) {
// Uncommon, but possible. If a view is removed from the hierarchy during the call
// to getDisplayList(), the display list will be marked invalid and we should not
// try to use it again.
- displayList = null;
+ renderNode = null;
hasDisplayList = false;
useDisplayListProperties = false;
}
@@ -14565,7 +14565,7 @@
if (transformToApply != null) {
if (concatMatrix) {
if (useDisplayListProperties) {
- displayList.setAnimationMatrix(transformToApply.getMatrix());
+ renderNode.setAnimationMatrix(transformToApply.getMatrix());
} else {
// Undo the scroll translation, apply the transformation matrix,
// then redo the scroll translate to get the correct result.
@@ -14608,7 +14608,7 @@
layerFlags |= Canvas.CLIP_TO_LAYER_SAVE_FLAG;
}
if (useDisplayListProperties) {
- displayList.setAlpha(alpha * getAlpha() * getTransitionAlpha());
+ renderNode.setAlpha(alpha * getAlpha() * getTransitionAlpha());
} else if (layerType == LAYER_TYPE_NONE) {
final int scrollX = hasDisplayList ? 0 : sx;
final int scrollY = hasDisplayList ? 0 : sy;
@@ -14640,12 +14640,12 @@
}
if (!useDisplayListProperties && hasDisplayList) {
- displayList = getDisplayList();
- if (!displayList.isValid()) {
+ renderNode = getDisplayList();
+ if (!renderNode.isValid()) {
// Uncommon, but possible. If a view is removed from the hierarchy during the call
// to getDisplayList(), the display list will be marked invalid and we should not
// try to use it again.
- displayList = null;
+ renderNode = null;
hasDisplayList = false;
}
}
@@ -14678,7 +14678,7 @@
}
} else {
mPrivateFlags &= ~PFLAG_DIRTY_MASK;
- ((HardwareCanvas) canvas).drawDisplayList(displayList, null, flags);
+ ((HardwareCanvas) canvas).drawRenderNode(renderNode, null, flags);
}
}
} else if (cache != null) {
@@ -14949,12 +14949,12 @@
// Attempt to use a display list if requested.
if (canvas.isHardwareAccelerated() && mAttachInfo != null
&& mAttachInfo.mHardwareRenderer != null) {
- mBackgroundDisplayList = getDrawableDisplayList(background, mBackgroundDisplayList);
+ mBackgroundRenderNode = getDrawableRenderNode(background, mBackgroundRenderNode);
- final RenderNode displayList = mBackgroundDisplayList;
+ final RenderNode displayList = mBackgroundRenderNode;
if (displayList != null && displayList.isValid()) {
setBackgroundDisplayListProperties(displayList);
- ((HardwareCanvas) canvas).drawDisplayList(displayList);
+ ((HardwareCanvas) canvas).drawRenderNode(displayList);
return;
}
}
@@ -14985,30 +14985,30 @@
* specified Drawable.
*
* @param drawable Drawable for which to create a display list
- * @param displayList Existing display list, or {@code null}
+ * @param renderNode Existing RenderNode, or {@code null}
* @return A valid display list for the specified drawable
*/
- private RenderNode getDrawableDisplayList(Drawable drawable, RenderNode displayList) {
- if (displayList == null) {
- displayList = RenderNode.create(drawable.getClass().getName());
+ private RenderNode getDrawableRenderNode(Drawable drawable, RenderNode renderNode) {
+ if (renderNode == null) {
+ renderNode = RenderNode.create(drawable.getClass().getName());
}
final Rect bounds = drawable.getBounds();
final int width = bounds.width();
final int height = bounds.height();
- final HardwareCanvas canvas = displayList.start(width, height);
+ final HardwareCanvas canvas = renderNode.start(width, height);
try {
drawable.draw(canvas);
} finally {
- displayList.end(canvas);
+ renderNode.end(canvas);
}
// Set up drawable properties that are view-independent.
- displayList.setLeftTopRightBottom(bounds.left, bounds.top, bounds.right, bounds.bottom);
- displayList.setProjectBackwards(drawable.isProjected());
- displayList.setProjectionReceiver(true);
- displayList.setClipToBounds(false);
- return displayList;
+ renderNode.setLeftTopRightBottom(bounds.left, bounds.top, bounds.right, bounds.bottom);
+ renderNode.setProjectBackwards(drawable.isProjected());
+ renderNode.setProjectionReceiver(true);
+ renderNode.setClipToBounds(false);
+ return renderNode;
}
/**
diff --git a/core/java/android/widget/Editor.java b/core/java/android/widget/Editor.java
index 4467128..13a0849 100644
--- a/core/java/android/widget/Editor.java
+++ b/core/java/android/widget/Editor.java
@@ -1420,7 +1420,7 @@
blockDisplayList.setLeftTopRightBottom(left, top, right, bottom);
}
- ((HardwareCanvas) canvas).drawDisplayList(blockDisplayList, null,
+ ((HardwareCanvas) canvas).drawRenderNode(blockDisplayList, null,
0 /* no child clipping, our TextView parent enforces it */);
endOfPreviousBlock = blockEndLine;
diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp
index 4362018..329e371 100644
--- a/core/jni/android_view_GLES20Canvas.cpp
+++ b/core/jni/android_view_GLES20Canvas.cpp
@@ -854,13 +854,13 @@
return reinterpret_cast<jlong>(new DisplayListRenderer);
}
-static jint android_view_GLES20Canvas_drawDisplayList(JNIEnv* env,
- jobject clazz, jlong rendererPtr, jlong displayListPtr,
+static jint android_view_GLES20Canvas_drawRenderNode(JNIEnv* env,
+ jobject clazz, jlong rendererPtr, jlong renderNodePtr,
jobject dirty, jint flags) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
android::uirenderer::Rect bounds;
- status_t status = renderer->drawDisplayList(displayList, bounds, flags);
+ status_t status = renderer->drawRenderNode(renderNode, bounds, flags);
if (status != DrawGlInfo::kStatusDone && dirty != NULL) {
env->CallVoidMethod(dirty, gRectClassInfo.set,
int(bounds.left), int(bounds.top), int(bounds.right), int(bounds.bottom));
@@ -996,12 +996,10 @@
{ "nDrawTextRun", "(JLjava/lang/String;IIIIFFZJJ)V",
(void*) android_view_GLES20Canvas_drawTextRun },
- { "nGetClipBounds", "(JLandroid/graphics/Rect;)Z",
- (void*) android_view_GLES20Canvas_getClipBounds },
+ { "nGetClipBounds", "(JLandroid/graphics/Rect;)Z", (void*) android_view_GLES20Canvas_getClipBounds },
- { "nFinishRecording", "(J)J", (void*) android_view_GLES20Canvas_finishRecording },
- { "nDrawDisplayList", "(JJLandroid/graphics/Rect;I)I",
- (void*) android_view_GLES20Canvas_drawDisplayList },
+ { "nFinishRecording", "(J)J", (void*) android_view_GLES20Canvas_finishRecording },
+ { "nDrawRenderNode", "(JJLandroid/graphics/Rect;I)I", (void*) android_view_GLES20Canvas_drawRenderNode },
{ "nCreateDisplayListRenderer", "()J", (void*) android_view_GLES20Canvas_createDisplayListRenderer },
diff --git a/libs/hwui/DisplayList.cpp b/libs/hwui/DisplayList.cpp
index f418c9b..e38b532 100644
--- a/libs/hwui/DisplayList.cpp
+++ b/libs/hwui/DisplayList.cpp
@@ -90,8 +90,8 @@
layers.clear();
}
-void DisplayListData::addChild(DrawDisplayListOp* op) {
- LOG_ALWAYS_FATAL_IF(!op->renderNode(), "DrawDisplayListOp with no render node!");
+void DisplayListData::addChild(DrawRenderNodeOp* op) {
+ LOG_ALWAYS_FATAL_IF(!op->renderNode(), "DrawRenderNodeOp with no render node!");
mChildren.push(op);
mReferenceHolders.push(op->renderNode());
diff --git a/libs/hwui/DisplayList.h b/libs/hwui/DisplayList.h
index 7b7dc16..bfffbb4 100644
--- a/libs/hwui/DisplayList.h
+++ b/libs/hwui/DisplayList.h
@@ -61,7 +61,7 @@
class SaveLayerOp;
class SaveOp;
class RestoreToCountOp;
-class DrawDisplayListOp;
+class DrawRenderNodeOp;
/**
* Holds data used in the playback a tree of DisplayLists.
@@ -133,8 +133,8 @@
return !displayListOps.size();
}
- void addChild(DrawDisplayListOp* childOp);
- const Vector<DrawDisplayListOp*>& children() { return mChildren; }
+ void addChild(DrawRenderNodeOp* childOp);
+ const Vector<DrawRenderNodeOp*>& children() { return mChildren; }
void refProperty(CanvasPropertyPrimitive* prop) {
mReferenceHolders.push(prop);
@@ -148,7 +148,7 @@
Vector< sp<VirtualLightRefBase> > mReferenceHolders;
// list of children display lists for quick, non-drawing traversal
- Vector<DrawDisplayListOp*> mChildren;
+ Vector<DrawRenderNodeOp*> mChildren;
void cleanupResources();
};
diff --git a/libs/hwui/DisplayListOp.h b/libs/hwui/DisplayListOp.h
index f8d620d..811af39 100644
--- a/libs/hwui/DisplayListOp.h
+++ b/libs/hwui/DisplayListOp.h
@@ -1465,23 +1465,23 @@
Functor* mFunctor;
};
-class DrawDisplayListOp : public DrawBoundedOp {
- friend class RenderNode; // grant DisplayList access to info of child
+class DrawRenderNodeOp : public DrawBoundedOp {
+ friend class RenderNode; // grant RenderNode access to info of child
public:
- DrawDisplayListOp(RenderNode* displayList, int flags, const mat4& transformFromParent)
- : DrawBoundedOp(0, 0, displayList->getWidth(), displayList->getHeight(), 0),
- mDisplayList(displayList), mFlags(flags), mTransformFromParent(transformFromParent) {}
+ DrawRenderNodeOp(RenderNode* renderNode, int flags, const mat4& transformFromParent)
+ : DrawBoundedOp(0, 0, renderNode->getWidth(), renderNode->getHeight(), 0),
+ mRenderNode(renderNode), mFlags(flags), mTransformFromParent(transformFromParent) {}
virtual void defer(DeferStateStruct& deferStruct, int saveCount, int level,
bool useQuickReject) {
- if (mDisplayList && mDisplayList->isRenderable() && !mSkipInOrderDraw) {
- mDisplayList->defer(deferStruct, level + 1);
+ if (mRenderNode && mRenderNode->isRenderable() && !mSkipInOrderDraw) {
+ mRenderNode->defer(deferStruct, level + 1);
}
}
virtual void replay(ReplayStateStruct& replayStruct, int saveCount, int level,
bool useQuickReject) {
- if (mDisplayList && mDisplayList->isRenderable() && !mSkipInOrderDraw) {
- mDisplayList->replay(replayStruct, level + 1);
+ if (mRenderNode && mRenderNode->isRenderable() && !mSkipInOrderDraw) {
+ mRenderNode->replay(replayStruct, level + 1);
}
}
@@ -1491,22 +1491,22 @@
}
virtual void output(int level, uint32_t logFlags) const {
- OP_LOG("Draw Display List %p, flags %#x", mDisplayList, mFlags);
- if (mDisplayList && (logFlags & kOpLogFlag_Recurse)) {
- mDisplayList->output(level + 1);
+ OP_LOG("Draw Display List %p, flags %#x", mRenderNode, mFlags);
+ if (mRenderNode && (logFlags & kOpLogFlag_Recurse)) {
+ mRenderNode->output(level + 1);
}
}
- virtual const char* name() { return "DrawDisplayList"; }
+ virtual const char* name() { return "DrawRenderNode"; }
- RenderNode* renderNode() { return mDisplayList; }
+ RenderNode* renderNode() { return mRenderNode; }
private:
- RenderNode* mDisplayList;
+ RenderNode* mRenderNode;
const int mFlags;
///////////////////////////
- // Properties below are used by DisplayList::computeOrderingImpl() and iterate()
+ // Properties below are used by RenderNode::computeOrderingImpl() and issueOperations()
///////////////////////////
/**
* Records transform vs parent, used for computing total transform without rerunning DL contents
@@ -1514,12 +1514,12 @@
const mat4 mTransformFromParent;
/**
- * Holds the transformation between the projection surface ViewGroup and this DisplayList
+ * Holds the transformation between the projection surface ViewGroup and this RenderNode
* drawing instance. Represents any translations / transformations done within the drawing of
* the compositing ancestor ViewGroup's draw, before the draw of the View represented by this
* DisplayList draw instance.
*
- * Note: doesn't include any transformation recorded within the DisplayList and its properties.
+ * Note: doesn't include transformation within the RenderNode, or its properties.
*/
mat4 mTransformFromCompositingAncestor;
bool mSkipInOrderDraw;
diff --git a/libs/hwui/DisplayListRenderer.cpp b/libs/hwui/DisplayListRenderer.cpp
index fc4d40b..b6d3f4b 100644
--- a/libs/hwui/DisplayListRenderer.cpp
+++ b/libs/hwui/DisplayListRenderer.cpp
@@ -169,18 +169,16 @@
return StatefulBaseRenderer::clipRegion(region, op);
}
-status_t DisplayListRenderer::drawDisplayList(RenderNode* displayList,
- Rect& dirty, int32_t flags) {
+status_t DisplayListRenderer::drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t flags) {
// dirty is an out parameter and should not be recorded,
// it matters only when replaying the display list
- if (displayList->stagingProperties().isProjectionReceiver()) {
+ if (renderNode->stagingProperties().isProjectionReceiver()) {
// use staging property, since recording on UI thread
mDisplayListData->projectionReceiveIndex = mDisplayListData->displayListOps.size();
}
- DrawDisplayListOp* op = new (alloc()) DrawDisplayListOp(displayList,
- flags, *currentTransform());
+ DrawRenderNodeOp* op = new (alloc()) DrawRenderNodeOp(renderNode, flags, *currentTransform());
addDrawOp(op);
mDisplayListData->addChild(op);
return DrawGlInfo::kStatusDone;
diff --git a/libs/hwui/DisplayListRenderer.h b/libs/hwui/DisplayListRenderer.h
index 2eaa671..1de656e 100644
--- a/libs/hwui/DisplayListRenderer.h
+++ b/libs/hwui/DisplayListRenderer.h
@@ -148,8 +148,7 @@
// Canvas draw operations - special
// ----------------------------------------------------------------------------
virtual status_t drawLayer(Layer* layer, float x, float y);
- virtual status_t drawDisplayList(RenderNode* displayList, Rect& dirty,
- int32_t replayFlags);
+ virtual status_t drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t replayFlags);
// TODO: rename for consistency
virtual status_t callDrawGLFunction(Functor* functor, Rect& dirty);
diff --git a/libs/hwui/Layer.cpp b/libs/hwui/Layer.cpp
index 24dd1d3..b6414e5 100644
--- a/libs/hwui/Layer.cpp
+++ b/libs/hwui/Layer.cpp
@@ -41,7 +41,7 @@
colorFilter = NULL;
deferredUpdateScheduled = false;
renderer = NULL;
- displayList = NULL;
+ renderNode = NULL;
fbo = 0;
stencil = NULL;
debugDrawUpdate = false;
@@ -141,10 +141,9 @@
}
}
-void Layer::updateDeferred(RenderNode* displayList,
- int left, int top, int right, int bottom) {
+void Layer::updateDeferred(RenderNode* renderNode, int left, int top, int right, int bottom) {
requireRenderer();
- this->displayList = displayList;
+ this->renderNode = renderNode;
const Rect r(left, top, right, bottom);
dirtyRect.unionWith(r);
deferredUpdateScheduled = true;
@@ -219,14 +218,14 @@
renderer->setupFrameState(dirtyRect.left, dirtyRect.top,
dirtyRect.right, dirtyRect.bottom, !isBlend());
- displayList->computeOrdering();
- displayList->defer(deferredState, 0);
+ renderNode->computeOrdering();
+ renderNode->defer(deferredState, 0);
deferredUpdateScheduled = false;
}
void Layer::cancelDefer() {
- displayList = NULL;
+ renderNode = NULL;
deferredUpdateScheduled = false;
if (deferredList) {
delete deferredList;
@@ -246,7 +245,7 @@
renderer->finish();
dirtyRect.setEmpty();
- displayList = NULL;
+ renderNode = NULL;
}
}
@@ -255,14 +254,14 @@
renderer->prepareDirty(dirtyRect.left, dirtyRect.top, dirtyRect.right, dirtyRect.bottom,
!isBlend());
- renderer->drawDisplayList(displayList.get(), dirtyRect, RenderNode::kReplayFlag_ClipChildren);
+ renderer->drawRenderNode(renderNode.get(), dirtyRect, RenderNode::kReplayFlag_ClipChildren);
renderer->finish();
dirtyRect.setEmpty();
deferredUpdateScheduled = false;
- displayList = NULL;
+ renderNode = NULL;
}
}; // namespace uirenderer
diff --git a/libs/hwui/Layer.h b/libs/hwui/Layer.h
index 49610d5..741f4c3 100644
--- a/libs/hwui/Layer.h
+++ b/libs/hwui/Layer.h
@@ -85,8 +85,7 @@
regionRect.translate(layer.left, layer.top);
}
- void updateDeferred(RenderNode* displayList,
- int left, int top, int right, int bottom);
+ void updateDeferred(RenderNode* renderNode, int left, int top, int right, int bottom);
inline uint32_t getWidth() const {
return texture.width;
@@ -297,7 +296,7 @@
*/
bool deferredUpdateScheduled;
OpenGLRenderer* renderer;
- sp<RenderNode> displayList;
+ sp<RenderNode> renderNode;
Rect dirtyRect;
bool debugDrawUpdate;
bool hasDrawnSinceUpdate;
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index e1dfeae..afb65a6 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -474,8 +474,8 @@
///////////////////////////////////////////////////////////////////////////////
bool OpenGLRenderer::updateLayer(Layer* layer, bool inFrame) {
- if (layer->deferredUpdateScheduled && layer->renderer &&
- layer->displayList.get() && layer->displayList->isRenderable()) {
+ if (layer->deferredUpdateScheduled && layer->renderer
+ && layer->renderNode.get() && layer->renderNode->isRenderable()) {
ATRACE_CALL();
Rect& dirty = layer->dirtyRect;
@@ -1931,25 +1931,24 @@
// Drawing
///////////////////////////////////////////////////////////////////////////////
-status_t OpenGLRenderer::drawDisplayList(RenderNode* displayList, Rect& dirty,
- int32_t replayFlags) {
+status_t OpenGLRenderer::drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t replayFlags) {
status_t status;
// All the usual checks and setup operations (quickReject, setupDraw, etc.)
// will be performed by the display list itself
- if (displayList && displayList->isRenderable()) {
+ if (renderNode && renderNode->isRenderable()) {
// compute 3d ordering
- displayList->computeOrdering();
+ renderNode->computeOrdering();
if (CC_UNLIKELY(mCaches.drawDeferDisabled)) {
status = startFrame();
ReplayStateStruct replayStruct(*this, dirty, replayFlags);
- displayList->replay(replayStruct, 0);
+ renderNode->replay(replayStruct, 0);
return status | replayStruct.mDrawGlStatus;
}
bool avoidOverdraw = !mCaches.debugOverdraw && !mCountOverdraw; // shh, don't tell devs!
DeferredDisplayList deferredList(*currentClipRect(), avoidOverdraw);
DeferStateStruct deferStruct(deferredList, *this, replayFlags);
- displayList->defer(deferStruct, 0);
+ renderNode->defer(deferStruct, 0);
flushLayers();
status = startFrame();
diff --git a/libs/hwui/OpenGLRenderer.h b/libs/hwui/OpenGLRenderer.h
index 346a65c..066b267 100644
--- a/libs/hwui/OpenGLRenderer.h
+++ b/libs/hwui/OpenGLRenderer.h
@@ -158,7 +158,7 @@
int saveLayerDeferred(float left, float top, float right, float bottom,
const SkPaint* paint, int flags);
- virtual status_t drawDisplayList(RenderNode* displayList, Rect& dirty, int32_t replayFlags = 1);
+ virtual status_t drawRenderNode(RenderNode* displayList, Rect& dirty, int32_t replayFlags = 1);
virtual status_t drawLayer(Layer* layer, float x, float y);
virtual status_t drawBitmap(const SkBitmap* bitmap, float left, float top,
const SkPaint* paint);
diff --git a/libs/hwui/RenderNode.cpp b/libs/hwui/RenderNode.cpp
index 4cda178..e8f2dd2 100644
--- a/libs/hwui/RenderNode.cpp
+++ b/libs/hwui/RenderNode.cpp
@@ -323,8 +323,8 @@
info.prepareTextures = cache.prefetchAndMarkInUse(subtree->bitmapResources[i]);
}
for (size_t i = 0; i < subtree->children().size(); i++) {
- DrawDisplayListOp* op = subtree->children()[i];
- RenderNode* childNode = op->mDisplayList;
+ DrawRenderNodeOp* op = subtree->children()[i];
+ RenderNode* childNode = op->mRenderNode;
info.damageAccumulator->pushTransform(&op->mTransformFromParent);
childNode->prepareTreeImpl(info);
info.damageAccumulator->popTransform();
@@ -455,16 +455,16 @@
// transform properties are applied correctly to top level children
if (mDisplayListData == NULL) return;
for (unsigned int i = 0; i < mDisplayListData->children().size(); i++) {
- DrawDisplayListOp* childOp = mDisplayListData->children()[i];
- childOp->mDisplayList->computeOrderingImpl(childOp,
+ DrawRenderNodeOp* childOp = mDisplayListData->children()[i];
+ childOp->mRenderNode->computeOrderingImpl(childOp,
properties().getOutline().getPath(), &mProjectedNodes, &mat4::identity());
}
}
void RenderNode::computeOrderingImpl(
- DrawDisplayListOp* opState,
+ DrawRenderNodeOp* opState,
const SkPath* outlineOfProjectionSurface,
- Vector<DrawDisplayListOp*>* compositedChildrenOfProjectionSurface,
+ Vector<DrawRenderNodeOp*>* compositedChildrenOfProjectionSurface,
const mat4* transformFromProjectionSurface) {
mProjectedNodes.clear();
if (mDisplayListData == NULL || mDisplayListData->isEmpty()) return;
@@ -488,11 +488,11 @@
const bool isProjectionReceiver = mDisplayListData->projectionReceiveIndex >= 0;
bool haveAppliedPropertiesToProjection = false;
for (unsigned int i = 0; i < mDisplayListData->children().size(); i++) {
- DrawDisplayListOp* childOp = mDisplayListData->children()[i];
- RenderNode* child = childOp->mDisplayList;
+ DrawRenderNodeOp* childOp = mDisplayListData->children()[i];
+ RenderNode* child = childOp->mRenderNode;
const SkPath* projectionOutline = NULL;
- Vector<DrawDisplayListOp*>* projectionChildren = NULL;
+ Vector<DrawRenderNodeOp*>* projectionChildren = NULL;
const mat4* projectionTransform = NULL;
if (isProjectionReceiver && !child->properties().getProjectBackwards()) {
// if receiving projections, collect projecting descendent
@@ -571,16 +571,16 @@
issueOperations<ReplayOperationHandler>(replayStruct.mRenderer, handler);
}
-void RenderNode::buildZSortedChildList(Vector<ZDrawDisplayListOpPair>& zTranslatedNodes) {
+void RenderNode::buildZSortedChildList(Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes) {
if (mDisplayListData == NULL || mDisplayListData->children().size() == 0) return;
for (unsigned int i = 0; i < mDisplayListData->children().size(); i++) {
- DrawDisplayListOp* childOp = mDisplayListData->children()[i];
- RenderNode* child = childOp->mDisplayList;
+ DrawRenderNodeOp* childOp = mDisplayListData->children()[i];
+ RenderNode* child = childOp->mRenderNode;
float childZ = child->properties().getZ();
if (!MathUtils::isZero(childZ)) {
- zTranslatedNodes.add(ZDrawDisplayListOpPair(childZ, childOp));
+ zTranslatedNodes.add(ZDrawRenderNodeOpPair(childZ, childOp));
childOp->mSkipInOrderDraw = true;
} else if (!child->properties().getProjectBackwards()) {
// regular, in order drawing DisplayList
@@ -627,7 +627,7 @@
template <class T>
int RenderNode::issueOperationsOfNegZChildren(
- const Vector<ZDrawDisplayListOpPair>& zTranslatedNodes,
+ const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes,
OpenGLRenderer& renderer, T& handler) {
if (zTranslatedNodes.isEmpty()) return -1;
@@ -643,7 +643,7 @@
template <class T>
void RenderNode::issueOperationsOfPosZChildren(int shadowRestoreTo,
- const Vector<ZDrawDisplayListOpPair>& zTranslatedNodes,
+ const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes,
OpenGLRenderer& renderer, T& handler) {
if (zTranslatedNodes.isEmpty()) return;
@@ -658,7 +658,7 @@
#define SHADOW_DELTA 0.1f
template <class T>
-void RenderNode::issueOperationsOf3dChildren(const Vector<ZDrawDisplayListOpPair>& zTranslatedNodes,
+void RenderNode::issueOperationsOf3dChildren(const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes,
ChildrenSelectMode mode, OpenGLRenderer& renderer, T& handler) {
const int size = zTranslatedNodes.size();
if (size == 0
@@ -693,8 +693,8 @@
float lastCasterZ = 0.0f;
while (shadowIndex < endIndex || drawIndex < endIndex) {
if (shadowIndex < endIndex) {
- DrawDisplayListOp* casterOp = zTranslatedNodes[shadowIndex].value;
- RenderNode* caster = casterOp->mDisplayList;
+ DrawRenderNodeOp* casterOp = zTranslatedNodes[shadowIndex].value;
+ RenderNode* caster = casterOp->mRenderNode;
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
@@ -711,8 +711,8 @@
// since it modifies the renderer's matrix
int restoreTo = renderer.save(SkCanvas::kMatrix_SaveFlag);
- DrawDisplayListOp* childOp = zTranslatedNodes[drawIndex].value;
- RenderNode* child = childOp->mDisplayList;
+ DrawRenderNodeOp* childOp = zTranslatedNodes[drawIndex].value;
+ RenderNode* child = childOp->mRenderNode;
renderer.concatMatrix(childOp->mTransformFromParent);
childOp->mSkipInOrderDraw = false; // this is horrible, I'm so sorry everyone
@@ -761,7 +761,7 @@
// draw projected nodes
for (size_t i = 0; i < mProjectedNodes.size(); i++) {
- DrawDisplayListOp* childOp = mProjectedNodes[i];
+ DrawRenderNodeOp* childOp = mProjectedNodes[i];
// matrix save, concat, and restore can be done safely without allocating operations
int restoreTo = renderer.save(SkCanvas::kMatrix_SaveFlag);
@@ -833,7 +833,7 @@
handler(new (alloc) DrawLayerOp(mLayer, 0, 0),
renderer.getSaveCount() - 1, properties().getClipToBounds());
} else {
- Vector<ZDrawDisplayListOpPair> zTranslatedNodes;
+ Vector<ZDrawRenderNodeOpPair> zTranslatedNodes;
buildZSortedChildList(zTranslatedNodes);
// for 3d root, draw children with negative z values
diff --git a/libs/hwui/RenderNode.h b/libs/hwui/RenderNode.h
index c510ac6..2fa6078 100644
--- a/libs/hwui/RenderNode.h
+++ b/libs/hwui/RenderNode.h
@@ -67,7 +67,7 @@
class SaveLayerOp;
class SaveOp;
class RestoreToCountOp;
-class DrawDisplayListOp;
+class DrawRenderNodeOp;
/**
* Primary class for storing recorded canvas commands, as well as per-View/ViewGroup display properties.
@@ -195,9 +195,9 @@
virtual void damageSelf(TreeInfo& info);
private:
- typedef key_value_pair_t<float, DrawDisplayListOp*> ZDrawDisplayListOpPair;
+ typedef key_value_pair_t<float, DrawRenderNodeOp*> ZDrawRenderNodeOpPair;
- static size_t findNonNegativeIndex(const Vector<ZDrawDisplayListOpPair>& nodes) {
+ static size_t findNonNegativeIndex(const Vector<ZDrawRenderNodeOpPair>& nodes) {
for (size_t i = 0; i < nodes.size(); i++) {
if (nodes[i].key >= 0.0f) return i;
}
@@ -211,29 +211,29 @@
void applyViewPropertyTransforms(mat4& matrix, bool true3dTransform = false);
- void computeOrderingImpl(DrawDisplayListOp* opState,
+ void computeOrderingImpl(DrawRenderNodeOp* opState,
const SkPath* outlineOfProjectionSurface,
- Vector<DrawDisplayListOp*>* compositedChildrenOfProjectionSurface,
+ Vector<DrawRenderNodeOp*>* compositedChildrenOfProjectionSurface,
const mat4* transformFromProjectionSurface);
template <class T>
inline void setViewProperties(OpenGLRenderer& renderer, T& handler);
- void buildZSortedChildList(Vector<ZDrawDisplayListOpPair>& zTranslatedNodes);
+ void buildZSortedChildList(Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes);
template<class T>
inline void issueDrawShadowOperation(const Matrix4& transformFromParent, T& handler);
template <class T>
inline int issueOperationsOfNegZChildren(
- const Vector<ZDrawDisplayListOpPair>& zTranslatedNodes,
+ const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes,
OpenGLRenderer& renderer, T& handler);
template <class T>
inline void issueOperationsOfPosZChildren(int shadowRestoreTo,
- const Vector<ZDrawDisplayListOpPair>& zTranslatedNodes,
+ const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes,
OpenGLRenderer& renderer, T& handler);
template <class T>
- inline void issueOperationsOf3dChildren(const Vector<ZDrawDisplayListOpPair>& zTranslatedNodes,
+ inline void issueOperationsOf3dChildren(const Vector<ZDrawRenderNodeOpPair>& zTranslatedNodes,
ChildrenSelectMode mode, OpenGLRenderer& renderer, T& handler);
template <class T>
@@ -241,7 +241,7 @@
/**
* Issue the RenderNode's operations into a handler, recursing for subtrees through
- * DrawDisplayListOp's defer() or replay() methods
+ * DrawRenderNodeOp's defer() or replay() methods
*/
template <class T>
inline void issueOperations(OpenGLRenderer& renderer, T& handler);
@@ -292,7 +292,7 @@
*/
// for projection surfaces, contains a list of all children items
- Vector<DrawDisplayListOp*> mProjectedNodes;
+ Vector<DrawRenderNodeOp*> mProjectedNodes;
}; // class RenderNode
} /* namespace uirenderer */
diff --git a/libs/hwui/Renderer.h b/libs/hwui/Renderer.h
index 320895c..d68b932 100644
--- a/libs/hwui/Renderer.h
+++ b/libs/hwui/Renderer.h
@@ -233,7 +233,7 @@
// Canvas draw operations - special
// ----------------------------------------------------------------------------
virtual status_t drawLayer(Layer* layer, float x, float y) = 0;
- virtual status_t drawDisplayList(RenderNode* displayList, Rect& dirty,
+ virtual status_t drawRenderNode(RenderNode* renderNode, Rect& dirty,
int32_t replayFlags) = 0;
// TODO: rename for consistency
diff --git a/libs/hwui/renderthread/CanvasContext.cpp b/libs/hwui/renderthread/CanvasContext.cpp
index dc1951b..eab9810 100644
--- a/libs/hwui/renderthread/CanvasContext.cpp
+++ b/libs/hwui/renderthread/CanvasContext.cpp
@@ -469,7 +469,7 @@
void CanvasContext::draw() {
LOG_ALWAYS_FATAL_IF(!mCanvas || mEglSurface == EGL_NO_SURFACE,
- "drawDisplayList called on a context with no canvas or surface!");
+ "drawRenderNode called on a context with no canvas or surface!");
profiler().markPlaybackStart();
@@ -496,7 +496,7 @@
}
Rect outBounds;
- status |= mCanvas->drawDisplayList(mRootRenderNode.get(), outBounds);
+ status |= mCanvas->drawRenderNode(mRootRenderNode.get(), outBounds);
profiler().draw(mCanvas);