Split out RenderProperties (acb6f076) · Commits · e / os / android_frameworks_base

core/jni/android_view_DisplayList.cpp

+55 −55

Original line number	Diff line number	Diff line
		@@ -75,27 +75,27 @@ static void android_view_DisplayList_destroyDisplayList(JNIEnv* env,
		static void android_view_DisplayList_setCaching(JNIEnv* env,
		jobject clazz, jlong displayListPtr, jboolean caching) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setCaching(caching);
		displayList->properties().setCaching(caching);
		}

		static void android_view_DisplayList_setStaticMatrix(JNIEnv* env,
		jobject clazz, jlong displayListPtr, jlong matrixPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
		displayList->setStaticMatrix(matrix);
		displayList->properties().setStaticMatrix(matrix);
		}

		static void android_view_DisplayList_setAnimationMatrix(JNIEnv* env,
		jobject clazz, jlong displayListPtr, jlong matrixPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
		displayList->setAnimationMatrix(matrix);
		displayList->properties().setAnimationMatrix(matrix);
		}

		static void android_view_DisplayList_setClipToBounds(JNIEnv* env,
		jobject clazz, jlong displayListPtr, jboolean clipToBounds) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setClipToBounds(clipToBounds);
		displayList->properties().setClipToBounds(clipToBounds);
		}

		static void android_view_DisplayList_setIsolatedZVolume(JNIEnv* env,
		@@ -106,98 +106,98 @@ static void android_view_DisplayList_setIsolatedZVolume(JNIEnv* env,
		static void android_view_DisplayList_setProjectBackwards(JNIEnv* env,
		jobject clazz, jlong displayListPtr, jboolean shouldProject) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setProjectBackwards(shouldProject);
		displayList->properties().setProjectBackwards(shouldProject);
		}

		static void android_view_DisplayList_setProjectionReceiver(JNIEnv* env,
		jobject clazz, jlong displayListPtr, jboolean shouldRecieve) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setProjectionReceiver(shouldRecieve);
		displayList->properties().setProjectionReceiver(shouldRecieve);
		}

		static void android_view_DisplayList_setOutline(JNIEnv* env,
		jobject clazz, jlong displayListPtr, jlong outlinePathPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		SkPath* outline = reinterpret_cast<SkPath*>(outlinePathPtr);
		displayList->setOutline(outline);
		displayList->properties().setOutline(outline);
		}

		static void android_view_DisplayList_setClipToOutline(JNIEnv* env,
		jobject clazz, jlong displayListPtr, jboolean clipToOutline) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setClipToOutline(clipToOutline);
		displayList->properties().setClipToOutline(clipToOutline);
		}

		static void android_view_DisplayList_setCastsShadow(JNIEnv* env,
		jobject clazz, jlong displayListPtr, jboolean castsShadow) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setCastsShadow(castsShadow);
		displayList->properties().setCastsShadow(castsShadow);
		}

		static void android_view_DisplayList_setUsesGlobalCamera(JNIEnv* env,
		jobject clazz, jlong displayListPtr, jboolean usesGlobalCamera) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setUsesGlobalCamera(usesGlobalCamera);
		displayList->properties().setUsesGlobalCamera(usesGlobalCamera);
		}

		static void android_view_DisplayList_setAlpha(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float alpha) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setAlpha(alpha);
		displayList->properties().setAlpha(alpha);
		}

		static void android_view_DisplayList_setHasOverlappingRendering(JNIEnv* env,
		jobject clazz, jlong displayListPtr, bool hasOverlappingRendering) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setHasOverlappingRendering(hasOverlappingRendering);
		displayList->properties().setHasOverlappingRendering(hasOverlappingRendering);
		}

		static void android_view_DisplayList_setTranslationX(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float tx) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setTranslationX(tx);
		displayList->properties().setTranslationX(tx);
		}

		static void android_view_DisplayList_setTranslationY(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float ty) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setTranslationY(ty);
		displayList->properties().setTranslationY(ty);
		}

		static void android_view_DisplayList_setTranslationZ(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float tz) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setTranslationZ(tz);
		displayList->properties().setTranslationZ(tz);
		}

		static void android_view_DisplayList_setRotation(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float rotation) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setRotation(rotation);
		displayList->properties().setRotation(rotation);
		}

		static void android_view_DisplayList_setRotationX(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float rx) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setRotationX(rx);
		displayList->properties().setRotationX(rx);
		}

		static void android_view_DisplayList_setRotationY(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float ry) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setRotationY(ry);
		displayList->properties().setRotationY(ry);
		}

		static void android_view_DisplayList_setScaleX(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float sx) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setScaleX(sx);
		displayList->properties().setScaleX(sx);
		}

		static void android_view_DisplayList_setScaleY(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float sy) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setScaleY(sy);
		displayList->properties().setScaleY(sy);
		}

		static void android_view_DisplayList_setTransformationInfo(JNIEnv* env,
		@@ -205,172 +205,172 @@ static void android_view_DisplayList_setTransformationInfo(JNIEnv* env,
		float translationX, float translationY, float translationZ,
		float rotation, float rotationX, float rotationY, float scaleX, float scaleY) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setAlpha(alpha);
		displayList->setTranslationX(translationX);
		displayList->setTranslationY(translationY);
		displayList->setTranslationZ(translationZ);
		displayList->setRotation(rotation);
		displayList->setRotationX(rotationX);
		displayList->setRotationY(rotationY);
		displayList->setScaleX(scaleX);
		displayList->setScaleY(scaleY);
		displayList->properties().setAlpha(alpha);
		displayList->properties().setTranslationX(translationX);
		displayList->properties().setTranslationY(translationY);
		displayList->properties().setTranslationZ(translationZ);
		displayList->properties().setRotation(rotation);
		displayList->properties().setRotationX(rotationX);
		displayList->properties().setRotationY(rotationY);
		displayList->properties().setScaleX(scaleX);
		displayList->properties().setScaleY(scaleY);
		}

		static void android_view_DisplayList_setPivotX(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float px) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setPivotX(px);
		displayList->properties().setPivotX(px);
		}

		static void android_view_DisplayList_setPivotY(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float py) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setPivotY(py);
		displayList->properties().setPivotY(py);
		}

		static void android_view_DisplayList_setCameraDistance(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float distance) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setCameraDistance(distance);
		displayList->properties().setCameraDistance(distance);
		}

		static void android_view_DisplayList_setLeft(JNIEnv* env,
		jobject clazz, jlong displayListPtr, int left) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setLeft(left);
		displayList->properties().setLeft(left);
		}

		static void android_view_DisplayList_setTop(JNIEnv* env,
		jobject clazz, jlong displayListPtr, int top) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setTop(top);
		displayList->properties().setTop(top);
		}

		static void android_view_DisplayList_setRight(JNIEnv* env,
		jobject clazz, jlong displayListPtr, int right) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setRight(right);
		displayList->properties().setRight(right);
		}

		static void android_view_DisplayList_setBottom(JNIEnv* env,
		jobject clazz, jlong displayListPtr, int bottom) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setBottom(bottom);
		displayList->properties().setBottom(bottom);
		}

		static void android_view_DisplayList_setLeftTopRightBottom(JNIEnv* env,
		jobject clazz, jlong displayListPtr, int left, int top,
		int right, int bottom) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->setLeftTopRightBottom(left, top, right, bottom);
		displayList->properties().setLeftTopRightBottom(left, top, right, bottom);
		}

		static void android_view_DisplayList_offsetLeftAndRight(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float offset) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->offsetLeftRight(offset);
		displayList->properties().offsetLeftRight(offset);
		}

		static void android_view_DisplayList_offsetTopAndBottom(JNIEnv* env,
		jobject clazz, jlong displayListPtr, float offset) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		displayList->offsetTopBottom(offset);
		displayList->properties().offsetTopBottom(offset);
		}

		static jboolean android_view_DisplayList_hasOverlappingRendering(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->hasOverlappingRendering();
		return displayList->properties().hasOverlappingRendering();
		}

		static jfloat android_view_DisplayList_getAlpha(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getAlpha();
		return displayList->properties().getAlpha();
		}

		static jfloat android_view_DisplayList_getLeft(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getLeft();
		return displayList->properties().getLeft();
		}

		static jfloat android_view_DisplayList_getTop(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getTop();
		return displayList->properties().getTop();
		}

		static jfloat android_view_DisplayList_getRight(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getRight();
		return displayList->properties().getRight();
		}

		static jfloat android_view_DisplayList_getBottom(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getBottom();
		return displayList->properties().getBottom();
		}

		static jfloat android_view_DisplayList_getCameraDistance(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getCameraDistance();
		return displayList->properties().getCameraDistance();
		}

		static jfloat android_view_DisplayList_getScaleX(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getScaleX();
		return displayList->properties().getScaleX();
		}

		static jfloat android_view_DisplayList_getScaleY(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getScaleY();
		return displayList->properties().getScaleY();
		}

		static jfloat android_view_DisplayList_getTranslationX(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getTranslationX();
		return displayList->properties().getTranslationX();
		}

		static jfloat android_view_DisplayList_getTranslationY(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getTranslationY();
		return displayList->properties().getTranslationY();
		}

		static jfloat android_view_DisplayList_getRotation(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getRotation();
		return displayList->properties().getRotation();
		}

		static jfloat android_view_DisplayList_getRotationX(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getRotationX();
		return displayList->properties().getRotationX();
		}

		static jfloat android_view_DisplayList_getRotationY(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getRotationY();
		return displayList->properties().getRotationY();
		}

		static jfloat android_view_DisplayList_getPivotX(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getPivotX();
		return displayList->properties().getPivotX();
		}

		static jfloat android_view_DisplayList_getPivotY(JNIEnv* env,
		jobject clazz, jlong displayListPtr) {
		RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
		return displayList->getPivotY();
		return displayList->properties().getPivotY();
		}

		#endif // USE_OPENGL_RENDERER

libs/hwui/Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@ ifeq ($(USE_OPENGL_RENDERER),true)
		Program.cpp \
		ProgramCache.cpp \
		RenderBufferCache.cpp \
		RenderProperties.cpp \
		ResourceCache.cpp \
		ShadowTessellator.cpp \
		SkiaShader.cpp \

libs/hwui/DisplayList.cpp

+91 −192

File changed.

Preview size limit exceeded, changes collapsed.

libs/hwui/DisplayList.h

+8 −391

Original line number	Diff line number	Diff line
		@@ -40,12 +40,7 @@
		#include "Debug.h"
		#include "Matrix.h"
		#include "DeferredDisplayList.h"

		#define TRANSLATION 0x0001
		#define ROTATION 0x0002
		#define ROTATION_3D 0x0004
		#define SCALE 0x0008
		#define PIVOT 0x0010
		#include "RenderProperties.h"

		class SkBitmap;
		class SkPaint;
		@@ -196,351 +191,20 @@ public:
		}
		}

		const char* getName() const {
		return mName.string();
		}

		void setClipToBounds(bool clipToBounds) {
		mClipToBounds = clipToBounds;
		}

		void setCastsShadow(bool castsShadow) {
		mCastsShadow = castsShadow;
		}

		void setUsesGlobalCamera(bool usesGlobalCamera) {
		mUsesGlobalCamera = usesGlobalCamera;
		}

		void setProjectBackwards(bool shouldProject) {
		mProjectBackwards = shouldProject;
		}

		void setProjectionReceiver(bool shouldRecieve) {
		mProjectionReceiver = shouldRecieve;
		RenderProperties& properties() {
		return mProperties;
		}

		bool isProjectionReceiver() {
		return mProjectionReceiver;
		}

		void setOutline(const SkPath* outline) {
		if (!outline) {
		mOutline.reset();
		} else {
		mOutline = *outline;
		}
		}

		void setClipToOutline(bool clipToOutline) {
		mClipToOutline = clipToOutline;
		}

		void setStaticMatrix(SkMatrix* matrix) {
		delete mStaticMatrix;
		mStaticMatrix = new SkMatrix(*matrix);
		}

		// Can return NULL
		SkMatrix* getStaticMatrix() {
		return mStaticMatrix;
		}

		void setAnimationMatrix(SkMatrix* matrix) {
		delete mAnimationMatrix;
		if (matrix) {
		mAnimationMatrix = new SkMatrix(*matrix);
		} else {
		mAnimationMatrix = NULL;
		}
		}

		void setAlpha(float alpha) {
		alpha = fminf(1.0f, fmaxf(0.0f, alpha));
		if (alpha != mAlpha) {
		mAlpha = alpha;
		}
		}

		float getAlpha() const {
		return mAlpha;
		}

		void setHasOverlappingRendering(bool hasOverlappingRendering) {
		mHasOverlappingRendering = hasOverlappingRendering;
		}

		bool hasOverlappingRendering() const {
		return mHasOverlappingRendering;
		}

		void setTranslationX(float translationX) {
		if (translationX != mTranslationX) {
		mTranslationX = translationX;
		onTranslationUpdate();
		}
		}

		float getTranslationX() const {
		return mTranslationX;
		}

		void setTranslationY(float translationY) {
		if (translationY != mTranslationY) {
		mTranslationY = translationY;
		onTranslationUpdate();
		}
		}

		float getTranslationY() const {
		return mTranslationY;
		}

		void setTranslationZ(float translationZ) {
		if (translationZ != mTranslationZ) {
		mTranslationZ = translationZ;
		onTranslationUpdate();
		}
		}

		float getTranslationZ() const {
		return mTranslationZ;
		}

		void setRotation(float rotation) {
		if (rotation != mRotation) {
		mRotation = rotation;
		mMatrixDirty = true;
		if (mRotation == 0.0f) {
		mMatrixFlags &= ~ROTATION;
		} else {
		mMatrixFlags \|= ROTATION;
		}
		}
		}

		float getRotation() const {
		return mRotation;
		}

		void setRotationX(float rotationX) {
		if (rotationX != mRotationX) {
		mRotationX = rotationX;
		mMatrixDirty = true;
		if (mRotationX == 0.0f && mRotationY == 0.0f) {
		mMatrixFlags &= ~ROTATION_3D;
		} else {
		mMatrixFlags \|= ROTATION_3D;
		}
		}
		}

		float getRotationX() const {
		return mRotationX;
		}

		void setRotationY(float rotationY) {
		if (rotationY != mRotationY) {
		mRotationY = rotationY;
		mMatrixDirty = true;
		if (mRotationX == 0.0f && mRotationY == 0.0f) {
		mMatrixFlags &= ~ROTATION_3D;
		} else {
		mMatrixFlags \|= ROTATION_3D;
		}
		}
		}

		float getRotationY() const {
		return mRotationY;
		}

		void setScaleX(float scaleX) {
		if (scaleX != mScaleX) {
		mScaleX = scaleX;
		mMatrixDirty = true;
		if (mScaleX == 1.0f && mScaleY == 1.0f) {
		mMatrixFlags &= ~SCALE;
		} else {
		mMatrixFlags \|= SCALE;
		}
		}
		}

		float getScaleX() const {
		return mScaleX;
		}

		void setScaleY(float scaleY) {
		if (scaleY != mScaleY) {
		mScaleY = scaleY;
		mMatrixDirty = true;
		if (mScaleX == 1.0f && mScaleY == 1.0f) {
		mMatrixFlags &= ~SCALE;
		} else {
		mMatrixFlags \|= SCALE;
		}
		}
		}

		float getScaleY() const {
		return mScaleY;
		}

		void setPivotX(float pivotX) {
		mPivotX = pivotX;
		mMatrixDirty = true;
		if (mPivotX == 0.0f && mPivotY == 0.0f) {
		mMatrixFlags &= ~PIVOT;
		} else {
		mMatrixFlags \|= PIVOT;
		}
		mPivotExplicitlySet = true;
		}

		ANDROID_API float getPivotX();

		void setPivotY(float pivotY) {
		mPivotY = pivotY;
		mMatrixDirty = true;
		if (mPivotX == 0.0f && mPivotY == 0.0f) {
		mMatrixFlags &= ~PIVOT;
		} else {
		mMatrixFlags \|= PIVOT;
		}
		mPivotExplicitlySet = true;
		}

		ANDROID_API float getPivotY();

		void setCameraDistance(float distance) {
		if (distance != mCameraDistance) {
		mCameraDistance = distance;
		mMatrixDirty = true;
		if (!mTransformCamera) {
		mTransformCamera = new Sk3DView();
		mTransformMatrix3D = new SkMatrix();
		}
		mTransformCamera->setCameraLocation(0, 0, distance);
		}
		}

		float getCameraDistance() const {
		return mCameraDistance;
		}

		void setLeft(int left) {
		if (left != mLeft) {
		mLeft = left;
		mWidth = mRight - mLeft;
		if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) {
		mMatrixDirty = true;
		}
		}
		}

		float getLeft() const {
		return mLeft;
		}

		void setTop(int top) {
		if (top != mTop) {
		mTop = top;
		mHeight = mBottom - mTop;
		if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) {
		mMatrixDirty = true;
		}
		}
		}

		float getTop() const {
		return mTop;
		}

		void setRight(int right) {
		if (right != mRight) {
		mRight = right;
		mWidth = mRight - mLeft;
		if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) {
		mMatrixDirty = true;
		}
		}
		}

		float getRight() const {
		return mRight;
		}

		void setBottom(int bottom) {
		if (bottom != mBottom) {
		mBottom = bottom;
		mHeight = mBottom - mTop;
		if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) {
		mMatrixDirty = true;
		}
		}
		}

		float getBottom() const {
		return mBottom;
		}

		void setLeftTop(int left, int top) {
		if (left != mLeft \|\| top != mTop) {
		mLeft = left;
		mTop = top;
		mWidth = mRight - mLeft;
		mHeight = mBottom - mTop;
		if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) {
		mMatrixDirty = true;
		}
		}
		}

		void setLeftTopRightBottom(int left, int top, int right, int bottom) {
		if (left != mLeft \|\| top != mTop \|\| right != mRight \|\| bottom != mBottom) {
		mLeft = left;
		mTop = top;
		mRight = right;
		mBottom = bottom;
		mWidth = mRight - mLeft;
		mHeight = mBottom - mTop;
		if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) {
		mMatrixDirty = true;
		}
		}
		}

		void offsetLeftRight(float offset) {
		if (offset != 0) {
		mLeft += offset;
		mRight += offset;
		if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) {
		mMatrixDirty = true;
		}
		}
		}

		void offsetTopBottom(float offset) {
		if (offset != 0) {
		mTop += offset;
		mBottom += offset;
		if (mMatrixFlags > TRANSLATION && !mPivotExplicitlySet) {
		mMatrixDirty = true;
		}
		}
		}

		void setCaching(bool caching) {
		mCaching = caching;
		return properties().isProjectionReceiver();
		}

		int getWidth() {
		return mWidth;
		return properties().getWidth();
		}

		int getHeight() {
		return mHeight;
		return properties().getHeight();
		}

		private:
		@@ -558,15 +222,6 @@ private:
		kPositiveZChildren
		};

		void onTranslationUpdate() {
		mMatrixDirty = true;
		if (mTranslationX == 0.0f && mTranslationY == 0.0f && mTranslationZ == 0.0f) {
		mMatrixFlags &= ~TRANSLATION;
		} else {
		mMatrixFlags \|= TRANSLATION;
		}
		}

		void outputViewProperties(const int level);

		void applyViewPropertyTransforms(mat4& matrix, bool true3dTransform = false);
		@@ -590,8 +245,6 @@ private:
		template <class T>
		inline void iterate(OpenGLRenderer& renderer, T& handler, const int level);

		void updateMatrix();

		class TextContainer {
		public:
		size_t length() const {
		@@ -606,47 +259,11 @@ private:
		const char* mText;
		};

		DisplayListData* mDisplayListData;

		String8 mName;
		bool mDestroyed; // used for debugging crash, TODO: remove once invalid state crash fixed

		// Rendering properties
		bool mClipToBounds;
		bool mProjectBackwards;
		bool mProjectionReceiver;
		SkPath mOutline;
		bool mClipToOutline;
		bool mCastsShadow;
		bool mUsesGlobalCamera; // TODO: respect value when rendering
		float mAlpha;
		bool mHasOverlappingRendering;
		float mTranslationX, mTranslationY, mTranslationZ;
		float mRotation, mRotationX, mRotationY;
		float mScaleX, mScaleY;
		float mPivotX, mPivotY;
		float mCameraDistance;
		int mLeft, mTop, mRight, mBottom;
		int mWidth, mHeight;
		int mPrevWidth, mPrevHeight;
		bool mPivotExplicitlySet;
		bool mMatrixDirty;
		bool mMatrixIsIdentity;

		/**
		* Stores the total transformation of the DisplayList based upon its scalar
		* translate/rotate/scale properties.
		*
		* In the common translation-only case, the matrix isn't allocated and the mTranslation
		* properties are used directly.
		*/
		Matrix4* mTransformMatrix;
		uint32_t mMatrixFlags;
		Sk3DView* mTransformCamera;
		SkMatrix* mTransformMatrix3D;
		SkMatrix* mStaticMatrix;
		SkMatrix* mAnimationMatrix;
		bool mCaching;
		RenderProperties mProperties;
		DisplayListData* mDisplayListData;

		/**
		* Draw time state - these properties are only set and used during rendering

libs/hwui/RenderProperties.cpp

0 → 100644

+126 −0

File added.

Preview size limit exceeded, changes collapsed.