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

Merge "Rename DisplayList->RenderNode"

Browse Source
This commit is contained in:
John Reck
2014-03-12 21:03:03 +00:00
committed by Android (Google) Code Review
parent 141d889166 e18264b079
commit 361fd3d2ff
23 changed files with 124 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
core/jni/android_view_DisplayList.cpp
View File

@@ -43,7 +43,7 @@ using namespace uirenderer;
static void android_view_DisplayList_setDisplayListName(JNIEnv* env,
jobject clazz, jlong displayListPtr, jstring name) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
if (name != NULL) {
const char* textArray = env->GetStringUTFChars(name, NULL);
displayList->setName(textArray);
@@ -53,19 +53,19 @@ static void android_view_DisplayList_setDisplayListName(JNIEnv* env,
static void android_view_DisplayList_output(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->output();
}
static jlong android_view_DisplayList_create(JNIEnv* env, jobject clazz) {
DisplayList* displayList = new DisplayList();
RenderNode* displayList = new RenderNode();
return reinterpret_cast<jlong>(displayList);
}
static void android_view_DisplayList_destroyDisplayList(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
DisplayList::destroyDisplayListDeferred(displayList);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
RenderNode::destroyDisplayListDeferred(displayList);
}
// ----------------------------------------------------------------------------
@@ -74,130 +74,130 @@ static void android_view_DisplayList_destroyDisplayList(JNIEnv* env,
static void android_view_DisplayList_setCaching(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean caching) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setCaching(caching);
}
static void android_view_DisplayList_setStaticMatrix(JNIEnv* env,
jobject clazz, jlong displayListPtr, jlong matrixPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
displayList->setStaticMatrix(matrix);
}
static void android_view_DisplayList_setAnimationMatrix(JNIEnv* env,
jobject clazz, jlong displayListPtr, jlong matrixPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
displayList->setAnimationMatrix(matrix);
}
static void android_view_DisplayList_setClipToBounds(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean clipToBounds) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setClipToBounds(clipToBounds);
}
static void android_view_DisplayList_setIsolatedZVolume(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean shouldIsolate) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setIsolatedZVolume(shouldIsolate);
}
static void android_view_DisplayList_setProjectBackwards(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean shouldProject) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setProjectBackwards(shouldProject);
}
static void android_view_DisplayList_setProjectionReceiver(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean shouldRecieve) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setProjectionReceiver(shouldRecieve);
}
static void android_view_DisplayList_setOutline(JNIEnv* env,
jobject clazz, jlong displayListPtr, jlong outlinePathPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
SkPath* outline = reinterpret_cast<SkPath*>(outlinePathPtr);
displayList->setOutline(outline);
}
static void android_view_DisplayList_setClipToOutline(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean clipToOutline) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setClipToOutline(clipToOutline);
}
static void android_view_DisplayList_setCastsShadow(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean castsShadow) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setCastsShadow(castsShadow);
}
static void android_view_DisplayList_setUsesGlobalCamera(JNIEnv* env,
jobject clazz, jlong displayListPtr, jboolean usesGlobalCamera) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setUsesGlobalCamera(usesGlobalCamera);
}
static void android_view_DisplayList_setAlpha(JNIEnv* env,
jobject clazz, jlong displayListPtr, float alpha) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setAlpha(alpha);
}
static void android_view_DisplayList_setHasOverlappingRendering(JNIEnv* env,
jobject clazz, jlong displayListPtr, bool hasOverlappingRendering) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setHasOverlappingRendering(hasOverlappingRendering);
}
static void android_view_DisplayList_setTranslationX(JNIEnv* env,
jobject clazz, jlong displayListPtr, float tx) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setTranslationX(tx);
}
static void android_view_DisplayList_setTranslationY(JNIEnv* env,
jobject clazz, jlong displayListPtr, float ty) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setTranslationY(ty);
}
static void android_view_DisplayList_setTranslationZ(JNIEnv* env,
jobject clazz, jlong displayListPtr, float tz) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setTranslationZ(tz);
}
static void android_view_DisplayList_setRotation(JNIEnv* env,
jobject clazz, jlong displayListPtr, float rotation) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setRotation(rotation);
}
static void android_view_DisplayList_setRotationX(JNIEnv* env,
jobject clazz, jlong displayListPtr, float rx) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setRotationX(rx);
}
static void android_view_DisplayList_setRotationY(JNIEnv* env,
jobject clazz, jlong displayListPtr, float ry) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setRotationY(ry);
}
static void android_view_DisplayList_setScaleX(JNIEnv* env,
jobject clazz, jlong displayListPtr, float sx) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setScaleX(sx);
}
static void android_view_DisplayList_setScaleY(JNIEnv* env,
jobject clazz, jlong displayListPtr, float sy) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setScaleY(sy);
}
@@ -205,7 +205,7 @@ static void android_view_DisplayList_setTransformationInfo(JNIEnv* env,
jobject clazz, jlong displayListPtr, float alpha,
float translationX, float translationY, float translationZ,
float rotation, float rotationX, float rotationY, float scaleX, float scaleY) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setAlpha(alpha);
displayList->setTranslationX(translationX);
displayList->setTranslationY(translationY);
@@ -219,158 +219,158 @@ static void android_view_DisplayList_setTransformationInfo(JNIEnv* env,
static void android_view_DisplayList_setPivotX(JNIEnv* env,
jobject clazz, jlong displayListPtr, float px) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setPivotX(px);
}
static void android_view_DisplayList_setPivotY(JNIEnv* env,
jobject clazz, jlong displayListPtr, float py) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setPivotY(py);
}
static void android_view_DisplayList_setCameraDistance(JNIEnv* env,
jobject clazz, jlong displayListPtr, float distance) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setCameraDistance(distance);
}
static void android_view_DisplayList_setLeft(JNIEnv* env,
jobject clazz, jlong displayListPtr, int left) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setLeft(left);
}
static void android_view_DisplayList_setTop(JNIEnv* env,
jobject clazz, jlong displayListPtr, int top) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setTop(top);
}
static void android_view_DisplayList_setRight(JNIEnv* env,
jobject clazz, jlong displayListPtr, int right) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setRight(right);
}
static void android_view_DisplayList_setBottom(JNIEnv* env,
jobject clazz, jlong displayListPtr, int bottom) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setBottom(bottom);
}
static void android_view_DisplayList_setLeftTopRightBottom(JNIEnv* env,
jobject clazz, jlong displayListPtr, int left, int top,
int right, int bottom) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->setLeftTopRightBottom(left, top, right, bottom);
}
static void android_view_DisplayList_offsetLeftAndRight(JNIEnv* env,
jobject clazz, jlong displayListPtr, float offset) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->offsetLeftRight(offset);
}
static void android_view_DisplayList_offsetTopAndBottom(JNIEnv* env,
jobject clazz, jlong displayListPtr, float offset) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
displayList->offsetTopBottom(offset);
}
static jboolean android_view_DisplayList_hasOverlappingRendering(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->hasOverlappingRendering();
}
static jfloat android_view_DisplayList_getAlpha(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getAlpha();
}
static jfloat android_view_DisplayList_getLeft(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getLeft();
}
static jfloat android_view_DisplayList_getTop(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getTop();
}
static jfloat android_view_DisplayList_getRight(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getRight();
}
static jfloat android_view_DisplayList_getBottom(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getBottom();
}
static jfloat android_view_DisplayList_getCameraDistance(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getCameraDistance();
}
static jfloat android_view_DisplayList_getScaleX(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getScaleX();
}
static jfloat android_view_DisplayList_getScaleY(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getScaleY();
}
static jfloat android_view_DisplayList_getTranslationX(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getTranslationX();
}
static jfloat android_view_DisplayList_getTranslationY(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getTranslationY();
}
static jfloat android_view_DisplayList_getRotation(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getRotation();
}
static jfloat android_view_DisplayList_getRotationX(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getRotationX();
}
static jfloat android_view_DisplayList_getRotationY(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getRotationY();
}
static jfloat android_view_DisplayList_getPivotX(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getPivotX();
}
static jfloat android_view_DisplayList_getPivotY(JNIEnv* env,
jobject clazz, jlong displayListPtr) {
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
return displayList->getPivotY();
}

4
core/jni/android_view_GLES20Canvas.cpp
View File

@@ -879,7 +879,7 @@ static jint android_view_GLES20Canvas_drawDisplayList(JNIEnv* env,
jobject clazz, jlong rendererPtr, jlong displayListPtr,
jobject dirty, jint flags) {
OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
android::uirenderer::Rect bounds;
status_t status = renderer->drawDisplayList(displayList, bounds, flags);
if (status != DrawGlInfo::kStatusDone && dirty != NULL) {
@@ -975,7 +975,7 @@ static void
android_app_ActivityThread_dumpGraphics(JNIEnv* env, jobject clazz, jobject javaFileDescriptor) {
#ifdef USE_OPENGL_RENDERER
int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);
android::uirenderer::DisplayList::outputLogBuffer(fd);
android::uirenderer::RenderNode::outputLogBuffer(fd);
#endif // USE_OPENGL_RENDERER
}

2
core/jni/android_view_GLRenderer.cpp
View File

@@ -143,7 +143,7 @@ static void android_view_GLRenderer_destroyLayer(JNIEnv* env, jobject clazz,
static void android_view_GLRenderer_setDisplayListData(JNIEnv* env, jobject clazz,
jlong displayListPtr, jlong newDataPtr) {
using namespace android::uirenderer;
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
DisplayListData* newData = reinterpret_cast<DisplayListData*>(newDataPtr);
displayList->setData(newData);
}

2
core/jni/android_view_HardwareLayer.cpp
View File

@@ -120,7 +120,7 @@ static void android_view_HardwareLayer_updateRenderLayer(JNIEnv* env, jobject cl
jlong layerUpdaterPtr, jlong displayListPtr,
jint left, jint top, jint right, jint bottom) {
DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerUpdaterPtr);
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
layer->setDisplayList(displayList, left, top, right, bottom);
}

4
core/jni/android_view_ThreadedRenderer.cpp
View File

@@ -106,7 +106,7 @@ static void android_view_ThreadedRenderer_setup(JNIEnv* env, jobject clazz,
static void android_view_ThreadedRenderer_setDisplayListData(JNIEnv* env, jobject clazz,
jlong proxyPtr, jlong displayListPtr, jlong newDataPtr) {
RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
DisplayListData* newData = reinterpret_cast<DisplayListData*>(newDataPtr);
proxy->setDisplayListData(displayList, newData);
}
@@ -115,7 +115,7 @@ static void android_view_ThreadedRenderer_drawDisplayList(JNIEnv* env, jobject c
jlong proxyPtr, jlong displayListPtr, jint dirtyLeft, jint dirtyTop,
jint dirtyRight, jint dirtyBottom) {
RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
DisplayList* displayList = reinterpret_cast<DisplayList*>(displayListPtr);
RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
proxy->drawDisplayList(displayList, dirtyLeft, dirtyTop, dirtyRight, dirtyBottom);
}

6
libs/hwui/Caches.cpp
View File

@@ -315,7 +315,7 @@ void Caches::clearGarbage() {
pathCache.clearGarbage();
patchCache.clearGarbage();
Vector<DisplayList*> displayLists;
Vector<RenderNode*> displayLists;
Vector<Layer*> layers;
{ // scope for the lock
@@ -328,7 +328,7 @@ void Caches::clearGarbage() {
size_t count = displayLists.size();
for (size_t i = 0; i < count; i++) {
DisplayList* displayList = displayLists.itemAt(i);
RenderNode* displayList = displayLists.itemAt(i);
delete displayList;
}
@@ -345,7 +345,7 @@ void Caches::deleteLayerDeferred(Layer* layer) {
mLayerGarbage.push(layer);
}
void Caches::deleteDisplayListDeferred(DisplayList* displayList) {
void Caches::deleteDisplayListDeferred(RenderNode* displayList) {
Mutex::Autolock _l(mGarbageLock);
mDisplayListGarbage.push(displayList);
}

6
libs/hwui/Caches.h
View File

@@ -102,7 +102,7 @@ struct CacheLogger {
// Caches
///////////////////////////////////////////////////////////////////////////////
class DisplayList;
class RenderNode;
class ANDROID_API Caches: public Singleton<Caches> {
Caches();
@@ -169,7 +169,7 @@ public:
/*
* Can be used to delete a display list from a non EGL thread.
*/
void deleteDisplayListDeferred(DisplayList* layer);
void deleteDisplayListDeferred(RenderNode* layer);
/**
* Binds the VBO used to render simple textured quads.
@@ -420,7 +420,7 @@ private:
mutable Mutex mGarbageLock;
Vector<Layer*> mLayerGarbage;
Vector<DisplayList*> mDisplayListGarbage;
Vector<RenderNode*> mDisplayListGarbage;
DebugLevel mDebugLevel;
bool mInitialized;

2
libs/hwui/DeferredLayerUpdater.cpp
View File

@@ -54,7 +54,7 @@ void DeferredLayerUpdater::setPaint(const SkPaint* paint) {
SkRefCnt_SafeAssign(mColorFilter, colorFilter);
}
void DeferredLayerUpdater::setDisplayList(DisplayList* displayList,
void DeferredLayerUpdater::setDisplayList(RenderNode* displayList,
int left, int top, int right, int bottom) {
mDisplayList = displayList;
if (mDirtyRect.isEmpty()) {

4
libs/hwui/DeferredLayerUpdater.h
View File

@@ -72,7 +72,7 @@ public:
mTransform = matrix ? new SkMatrix(*matrix) : 0;
}
ANDROID_API void setDisplayList(DisplayList* displayList,
ANDROID_API void setDisplayList(RenderNode* displayList,
int left, int top, int right, int bottom);
ANDROID_API void setPaint(const SkPaint* paint);
@@ -101,7 +101,7 @@ private:
// Layer type specific properties
// displayList and surfaceTexture are mutually exclusive, only 1 may be set
// dirtyRect is only valid if displayList is set
DisplayList* mDisplayList;
RenderNode* mDisplayList;
Rect mDirtyRect;
sp<GLConsumer> mSurfaceTexture;
SkMatrix* mTransform;

48
libs/hwui/DisplayList.cpp
View File

@@ -29,7 +29,7 @@
namespace android {
namespace uirenderer {
void DisplayList::outputLogBuffer(int fd) {
void RenderNode::outputLogBuffer(int fd) {
DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance();
if (logBuffer.isEmpty()) {
return;
@@ -48,7 +48,7 @@ void DisplayList::outputLogBuffer(int fd) {
fflush(file);
}
DisplayList::DisplayList() :
RenderNode::RenderNode() :
mDisplayListData(0), mDestroyed(false), mTransformMatrix(NULL), mTransformCamera(NULL),
mTransformMatrix3D(NULL), mStaticMatrix(NULL), mAnimationMatrix(NULL) {
@@ -87,7 +87,7 @@ DisplayList::DisplayList() :
mCaching = false;
}
DisplayList::~DisplayList() {
RenderNode::~RenderNode() {
LOG_ALWAYS_FATAL_IF(mDestroyed, "Double destroyed DisplayList %p", this);
mDestroyed = true;
@@ -99,14 +99,14 @@ DisplayList::~DisplayList() {
delete mAnimationMatrix;
}
void DisplayList::destroyDisplayListDeferred(DisplayList* displayList) {
void RenderNode::destroyDisplayListDeferred(RenderNode* displayList) {
if (displayList) {
DISPLAY_LIST_LOGD("Deferring display list destruction");
Caches::getInstance().deleteDisplayListDeferred(displayList);
}
}
void DisplayList::setData(DisplayListData* data) {
void RenderNode::setData(DisplayListData* data) {
delete mDisplayListData;
mDisplayListData = data;
if (mDisplayListData) {
@@ -118,7 +118,7 @@ void DisplayList::setData(DisplayListData* data) {
* This function is a simplified version of replay(), where we simply retrieve and log the
* display list. This function should remain in sync with the replay() function.
*/
void DisplayList::output(uint32_t level) {
void RenderNode::output(uint32_t level) {
ALOGD("%*sStart display list (%p, %s, render=%d)", (level - 1) * 2, "", this,
mName.string(), isRenderable());
ALOGD("%*s%s %d", level * 2, "", "Save",
@@ -133,17 +133,17 @@ void DisplayList::output(uint32_t level) {
ALOGD("%*sDone (%p, %s)", (level - 1) * 2, "", this, mName.string());
}
float DisplayList::getPivotX() {
float RenderNode::getPivotX() {
updateMatrix();
return mPivotX;
}
float DisplayList::getPivotY() {
float RenderNode::getPivotY() {
updateMatrix();
return mPivotY;
}
void DisplayList::updateMatrix() {
void RenderNode::updateMatrix() {
if (mMatrixDirty) {
// NOTE: mTransformMatrix won't be up to date if a DisplayList goes from a complex transform
// to a pure translate. This is safe because the matrix isn't read in pure translate cases.
@@ -195,7 +195,7 @@ void DisplayList::updateMatrix() {
}
}
void DisplayList::outputViewProperties(const int level) {
void RenderNode::outputViewProperties(const int level) {
updateMatrix();
if (mLeft != 0 || mTop != 0) {
ALOGD("%*sTranslate (left, top) %d, %d", level * 2, "", mLeft, mTop);
@@ -249,7 +249,7 @@ void DisplayList::outputViewProperties(const int level) {
#define PROPERTY_SAVECOUNT 0
template <class T>
void DisplayList::setViewProperties(OpenGLRenderer& renderer, T& handler,
void RenderNode::setViewProperties(OpenGLRenderer& renderer, T& handler,
const int level) {
#if DEBUG_DISPLAY_LIST
outputViewProperties(level);
@@ -308,7 +308,7 @@ void DisplayList::setViewProperties(OpenGLRenderer& renderer, T& handler,
* If true3dTransform is set to true, the transform applied to the input matrix will use true 4x4
* matrix computation instead of the Skia 3x3 matrix + camera hackery.
*/
void DisplayList::applyViewPropertyTransforms(mat4& matrix, bool true3dTransform) {
void RenderNode::applyViewPropertyTransforms(mat4& matrix, bool true3dTransform) {
if (mLeft != 0 || mTop != 0) {
matrix.translate(mLeft, mTop);
}
@@ -353,7 +353,7 @@ void DisplayList::applyViewPropertyTransforms(mat4& matrix, bool true3dTransform
* 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 DisplayList::computeOrdering() {
void RenderNode::computeOrdering() {
ATRACE_CALL();
mProjectedNodes.clear();
@@ -367,7 +367,7 @@ void DisplayList::computeOrdering() {
}
}
void DisplayList::computeOrderingImpl(
void RenderNode::computeOrderingImpl(
DrawDisplayListOp* opState,
Vector<DrawDisplayListOp*>* compositedChildrenOfProjectionSurface,
const mat4* transformFromProjectionSurface) {
@@ -394,7 +394,7 @@ void DisplayList::computeOrderingImpl(
bool haveAppliedPropertiesToProjection = false;
for (unsigned int i = 0; i < mDisplayListData->children.size(); i++) {
DrawDisplayListOp* childOp = mDisplayListData->children[i];
DisplayList* child = childOp->mDisplayList;
RenderNode* child = childOp->mDisplayList;
Vector<DrawDisplayListOp*>* projectionChildren = NULL;
const mat4* projectionTransform = NULL;
@@ -434,7 +434,7 @@ private:
const int mLevel;
};
void DisplayList::defer(DeferStateStruct& deferStruct, const int level) {
void RenderNode::defer(DeferStateStruct& deferStruct, const int level) {
DeferOperationHandler handler(deferStruct, level);
iterate<DeferOperationHandler>(deferStruct.mRenderer, handler, level);
}
@@ -456,7 +456,7 @@ private:
const int mLevel;
};
void DisplayList::replay(ReplayStateStruct& replayStruct, const int level) {
void RenderNode::replay(ReplayStateStruct& replayStruct, const int level) {
ReplayOperationHandler handler(replayStruct, level);
replayStruct.mRenderer.startMark(mName.string());
@@ -467,12 +467,12 @@ void DisplayList::replay(ReplayStateStruct& replayStruct, const int level) {
replayStruct.mDrawGlStatus);
}
void DisplayList::buildZSortedChildList(Vector<ZDrawDisplayListOpPair>& zTranslatedNodes) {
void RenderNode::buildZSortedChildList(Vector<ZDrawDisplayListOpPair>& zTranslatedNodes) {
if (mDisplayListData == NULL || mDisplayListData->children.size() == 0) return;
for (unsigned int i = 0; i < mDisplayListData->children.size(); i++) {
DrawDisplayListOp* childOp = mDisplayListData->children[i];
DisplayList* child = childOp->mDisplayList;
RenderNode* child = childOp->mDisplayList;
float childZ = child->mTranslationZ;
if (childZ != 0.0f) {
@@ -491,7 +491,7 @@ void DisplayList::buildZSortedChildList(Vector<ZDrawDisplayListOpPair>& zTransla
#define SHADOW_DELTA 0.1f
template <class T>
void DisplayList::iterate3dChildren(const Vector<ZDrawDisplayListOpPair>& zTranslatedNodes,
void RenderNode::iterate3dChildren(const Vector<ZDrawDisplayListOpPair>& zTranslatedNodes,
ChildrenSelectMode mode, OpenGLRenderer& renderer, T& handler) {
const int size = zTranslatedNodes.size();
if (size == 0
@@ -529,7 +529,7 @@ void DisplayList::iterate3dChildren(const Vector<ZDrawDisplayListOpPair>& zTrans
while (shadowIndex < endIndex || drawIndex < endIndex) {
if (shadowIndex < endIndex) {
DrawDisplayListOp* casterOp = zTranslatedNodes[shadowIndex].value;
DisplayList* caster = casterOp->mDisplayList;
RenderNode* caster = casterOp->mDisplayList;
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
@@ -560,7 +560,7 @@ void DisplayList::iterate3dChildren(const Vector<ZDrawDisplayListOpPair>& zTrans
int restoreTo = renderer.save(SkCanvas::kMatrix_SaveFlag);
DrawDisplayListOp* childOp = zTranslatedNodes[drawIndex].value;
DisplayList* child = childOp->mDisplayList;
RenderNode* child = childOp->mDisplayList;
renderer.concatMatrix(childOp->mTransformFromParent);
childOp->mSkipInOrderDraw = false; // this is horrible, I'm so sorry everyone
@@ -574,7 +574,7 @@ void DisplayList::iterate3dChildren(const Vector<ZDrawDisplayListOpPair>& zTrans
}
template <class T>
void DisplayList::iterateProjectedChildren(OpenGLRenderer& renderer, T& handler, const int level) {
void RenderNode::iterateProjectedChildren(OpenGLRenderer& renderer, T& handler, const int level) {
int rootRestoreTo = renderer.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
LinearAllocator& alloc = handler.allocator();
ClipRectOp* clipOp = new (alloc) ClipRectOp(0, 0, mWidth, mHeight,
@@ -605,7 +605,7 @@ void DisplayList::iterateProjectedChildren(OpenGLRenderer& renderer, T& handler,
* defer vs replay logic, per operation
*/
template <class T>
void DisplayList::iterate(OpenGLRenderer& renderer, T& handler, const int level) {
void RenderNode::iterate(OpenGLRenderer& renderer, T& handler, const int level) {
if (CC_UNLIKELY(mDestroyed)) { // temporary debug logging
ALOGW("Error: %s is drawing after destruction", getName());
CRASH();

8
libs/hwui/DisplayList.h
View File

@@ -160,17 +160,17 @@ private:
* recorded stream of canvas operations is refreshed. The DisplayList (and its properties) stay
* attached.
*/
class DisplayList {
class RenderNode {
public:
ANDROID_API DisplayList();
ANDROID_API ~DisplayList();
ANDROID_API RenderNode();
ANDROID_API ~RenderNode();
// See flags defined in DisplayList.java
enum ReplayFlag {
kReplayFlag_ClipChildren = 0x1
};
ANDROID_API static void destroyDisplayListDeferred(DisplayList* displayList);
ANDROID_API static void destroyDisplayListDeferred(RenderNode* displayList);
ANDROID_API static void outputLogBuffer(int fd);
ANDROID_API void setData(DisplayListData* newData);

6
libs/hwui/DisplayListOp.h
View File

@@ -1488,9 +1488,9 @@ private:
};
class DrawDisplayListOp : public DrawBoundedOp {
friend class DisplayList; // grant DisplayList access to info of child
friend class RenderNode; // grant DisplayList access to info of child
public:
DrawDisplayListOp(DisplayList* displayList, int flags, const mat4& transformFromParent)
DrawDisplayListOp(RenderNode* displayList, int flags, const mat4& transformFromParent)
: DrawBoundedOp(0, 0, displayList->getWidth(), displayList->getHeight(), 0),
mDisplayList(displayList), mFlags(flags), mTransformFromParent(transformFromParent) {}
@@ -1522,7 +1522,7 @@ public:
virtual const char* name() { return "DrawDisplayList"; }
private:
DisplayList* mDisplayList;
RenderNode* mDisplayList;
const int mFlags;
///////////////////////////

2
libs/hwui/DisplayListRenderer.cpp
View File

@@ -179,7 +179,7 @@ bool DisplayListRenderer::clipRegion(const SkRegion* region, SkRegion::Op op) {
return StatefulBaseRenderer::clipRegion(region, op);
}
status_t DisplayListRenderer::drawDisplayList(DisplayList* displayList,
status_t DisplayListRenderer::drawDisplayList(RenderNode* displayList,
Rect& dirty, int32_t flags) {
// dirty is an out parameter and should not be recorded,
// it matters only when replaying the display list

4
libs/hwui/DisplayListRenderer.h
View File

@@ -156,7 +156,7 @@ public:
// Canvas draw operations - special
// ----------------------------------------------------------------------------
virtual status_t drawLayer(Layer* layer, float x, float y);
virtual status_t drawDisplayList(DisplayList* displayList, Rect& dirty,
virtual status_t drawDisplayList(RenderNode* displayList, Rect& dirty,
int32_t replayFlags);
// TODO: rename for consistency
@@ -309,7 +309,7 @@ private:
int mRestoreSaveCount;
friend class DisplayList;
friend class RenderNode;
}; // class DisplayListRenderer

4
libs/hwui/Layer.cpp
View File

@@ -194,7 +194,7 @@ void Layer::defer() {
deferredList = new DeferredDisplayList(dirtyRect);
DeferStateStruct deferredState(*deferredList, *renderer,
DisplayList::kReplayFlag_ClipChildren);
RenderNode::kReplayFlag_ClipChildren);
renderer->initViewport(width, height);
renderer->setupFrameState(dirtyRect.left, dirtyRect.top,
@@ -238,7 +238,7 @@ void Layer::render() {
renderer->prepareDirty(dirtyRect.left, dirtyRect.top, dirtyRect.right, dirtyRect.bottom,
!isBlend());
renderer->drawDisplayList(displayList, dirtyRect, DisplayList::kReplayFlag_ClipChildren);
renderer->drawDisplayList(displayList, dirtyRect, RenderNode::kReplayFlag_ClipChildren);
renderer->finish();
renderer = NULL;

6
libs/hwui/Layer.h
View File

@@ -43,7 +43,7 @@ namespace uirenderer {
// Forward declarations
class Caches;
class OpenGLRenderer;
class DisplayList;
class RenderNode;
class DeferredDisplayList;
class DeferStateStruct;
@@ -84,7 +84,7 @@ public:
regionRect.translate(layer.left, layer.top);
}
void updateDeferred(OpenGLRenderer* renderer, DisplayList* displayList,
void updateDeferred(OpenGLRenderer* renderer, RenderNode* displayList,
int left, int top, int right, int bottom) {
this->renderer = renderer;
this->displayList = displayList;
@@ -294,7 +294,7 @@ public:
*/
bool deferredUpdateScheduled;
OpenGLRenderer* renderer;
DisplayList* displayList;
RenderNode* displayList;
Rect dirtyRect;
bool debugDrawUpdate;
bool hasDrawnSinceUpdate;

2
libs/hwui/OpenGLRenderer.cpp
View File

@@ -1912,7 +1912,7 @@ void OpenGLRenderer::setupDrawIndexedVertices(GLvoid* vertices) {
// Drawing
///////////////////////////////////////////////////////////////////////////////
status_t OpenGLRenderer::drawDisplayList(DisplayList* displayList, Rect& dirty,
status_t OpenGLRenderer::drawDisplayList(RenderNode* displayList, Rect& dirty,
int32_t replayFlags) {
status_t status;
// All the usual checks and setup operations (quickReject, setupDraw, etc.)

4
libs/hwui/OpenGLRenderer.h
View File

@@ -54,7 +54,7 @@ namespace android {
namespace uirenderer {
class DeferredDisplayState;
class DisplayList;
class RenderNode;
class TextSetupFunctor;
class VertexBuffer;
class SkiaShader;
@@ -165,7 +165,7 @@ public:
int saveLayerDeferred(float left, float top, float right, float bottom,
const SkPaint* paint, int flags);
virtual status_t drawDisplayList(DisplayList* displayList, Rect& dirty, int32_t replayFlags = 1);
virtual status_t drawDisplayList(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);

4
libs/hwui/Renderer.h
View File

@@ -31,7 +31,7 @@ struct Res_png_9patch;
namespace uirenderer {
class DisplayList;
class RenderNode;
class Layer;
class Matrix4;
class SkiaColorFilter;
@@ -232,7 +232,7 @@ public:
// Canvas draw operations - special
// ----------------------------------------------------------------------------
virtual status_t drawLayer(Layer* layer, float x, float y) = 0;
virtual status_t drawDisplayList(DisplayList* displayList, Rect& dirty,
virtual status_t drawDisplayList(RenderNode* displayList, Rect& dirty,
int32_t replayFlags) = 0;
// TODO: rename for consistency

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

@@ -373,7 +373,7 @@ void CanvasContext::setup(int width, int height) {
mCanvas->setViewport(width, height);
}
void CanvasContext::setDisplayListData(DisplayList* displayList, DisplayListData* newData) {
void CanvasContext::setDisplayListData(RenderNode* displayList, DisplayListData* newData) {
displayList->setData(newData);
}
@@ -388,7 +388,7 @@ void CanvasContext::processLayerUpdates(const Vector<DeferredLayerUpdater*>* lay
}
}
void CanvasContext::drawDisplayList(DisplayList* displayList, Rect* dirty) {
void CanvasContext::drawDisplayList(RenderNode* displayList, Rect* dirty) {
LOG_ALWAYS_FATAL_IF(!mCanvas || mEglSurface == EGL_NO_SURFACE,
"drawDisplayList called on a context with no canvas or surface!");

6
libs/hwui/renderthread/CanvasContext.h
View File

@@ -31,7 +31,7 @@ namespace android {
namespace uirenderer {
class DeferredLayerUpdater;
class DisplayList;
class RenderNode;
class DisplayListData;
class OpenGLRenderer;
class Rect;
@@ -63,9 +63,9 @@ public:
bool initialize(EGLNativeWindowType window);
void updateSurface(EGLNativeWindowType window);
void setup(int width, int height);
void setDisplayListData(DisplayList* displayList, DisplayListData* newData);
void setDisplayListData(RenderNode* displayList, DisplayListData* newData);
void processLayerUpdates(const Vector<DeferredLayerUpdater*>* layerUpdaters);
void drawDisplayList(DisplayList* displayList, Rect* dirty);
void drawDisplayList(RenderNode* displayList, Rect* dirty);
void destroyCanvas();
bool copyLayerInto(DeferredLayerUpdater* layer, SkBitmap* bitmap);

8
libs/hwui/renderthread/RenderProxy.cpp
View File

@@ -117,13 +117,13 @@ void RenderProxy::setup(int width, int height) {
post(task);
}
CREATE_BRIDGE3(setDisplayListData, CanvasContext* context, DisplayList* displayList,
CREATE_BRIDGE3(setDisplayListData, CanvasContext* context, RenderNode* displayList,
DisplayListData* newData) {
args->context->setDisplayListData(args->displayList, args->newData);
return NULL;
}
void RenderProxy::setDisplayListData(DisplayList* displayList, DisplayListData* newData) {
void RenderProxy::setDisplayListData(RenderNode* displayList, DisplayListData* newData) {
SETUP_TASK(setDisplayListData);
args->context = mContext;
args->displayList = displayList;
@@ -131,7 +131,7 @@ void RenderProxy::setDisplayListData(DisplayList* displayList, DisplayListData*
post(task);
}
CREATE_BRIDGE4(drawDisplayList, CanvasContext* context, DisplayList* displayList,
CREATE_BRIDGE4(drawDisplayList, CanvasContext* context, RenderNode* displayList,
Rect dirty, const Vector<DeferredLayerUpdater*>* layerUpdates) {
Rect* dirty = &args->dirty;
if (dirty->bottom == -1 && dirty->left == -1 &&
@@ -143,7 +143,7 @@ CREATE_BRIDGE4(drawDisplayList, CanvasContext* context, DisplayList* displayList
return NULL;
}
void RenderProxy::drawDisplayList(DisplayList* displayList,
void RenderProxy::drawDisplayList(RenderNode* displayList,
int dirtyLeft, int dirtyTop, int dirtyRight, int dirtyBottom) {
SETUP_TASK(drawDisplayList);
args->context = mContext;

6
libs/hwui/renderthread/RenderProxy.h
View File

@@ -32,7 +32,7 @@ namespace android {
namespace uirenderer {
class DeferredLayerUpdater;
class DisplayList;
class RenderNode;
class DisplayListData;
class Layer;
class Rect;
@@ -60,8 +60,8 @@ public:
ANDROID_API bool initialize(EGLNativeWindowType window);
ANDROID_API void updateSurface(EGLNativeWindowType window);
ANDROID_API void setup(int width, int height);
ANDROID_API void setDisplayListData(DisplayList* displayList, DisplayListData* newData);
ANDROID_API void drawDisplayList(DisplayList* displayList,
ANDROID_API void setDisplayListData(RenderNode* displayList, DisplayListData* newData);
ANDROID_API void drawDisplayList(RenderNode* displayList,
int dirtyLeft, int dirtyTop, int dirtyRight, int dirtyBottom);
ANDROID_API void destroyCanvas();