am da42438c: Merge "Add a property to disable libhwui\'s scissor optimization... (c49e5d0d) · Commits · e / os / android_frameworks_base

core/jni/android_view_GLES20Canvas.cpp

+6 −2

Original line number	Original line	Diff line number	Diff line
	@@ -116,7 +116,9 @@ static void android_view_GLES20Canvas_terminateCaches(JNIEnv* env, jobject clazz

	static OpenGLRenderer* android_view_GLES20Canvas_createRenderer(JNIEnv* env, jobject clazz) {		static OpenGLRenderer* android_view_GLES20Canvas_createRenderer(JNIEnv* env, jobject clazz) {
	RENDERER_LOGD("Create OpenGLRenderer");		RENDERER_LOGD("Create OpenGLRenderer");
	return new OpenGLRenderer;		OpenGLRenderer* renderer = new OpenGLRenderer();
			renderer->initProperties();
			return renderer;
	}		}

	static void android_view_GLES20Canvas_destroyRenderer(JNIEnv* env, jobject clazz,		static void android_view_GLES20Canvas_destroyRenderer(JNIEnv* env, jobject clazz,
	@@ -734,7 +736,9 @@ static void android_view_GLES20Canvas_resume(JNIEnv* env, jobject clazz,
	static OpenGLRenderer* android_view_GLES20Canvas_createLayerRenderer(JNIEnv* env,		static OpenGLRenderer* android_view_GLES20Canvas_createLayerRenderer(JNIEnv* env,
	jobject clazz, Layer* layer) {		jobject clazz, Layer* layer) {
	if (layer) {		if (layer) {
	return new LayerRenderer(layer);		OpenGLRenderer* renderer = new LayerRenderer(layer);
			renderer->initProperties();
			return renderer;
	}		}
	return NULL;		return NULL;
	}		}

libs/hwui/OpenGLRenderer.cpp

+60 −46

Original line number	Original line	Diff line number	Diff line
	@@ -34,6 +34,7 @@
	#include "OpenGLRenderer.h"		#include "OpenGLRenderer.h"
	#include "DisplayListRenderer.h"		#include "DisplayListRenderer.h"
	#include "PathRenderer.h"		#include "PathRenderer.h"
			#include "Properties.h"
	#include "Vector.h"		#include "Vector.h"

	namespace android {		namespace android {
	@@ -117,6 +118,8 @@ OpenGLRenderer::OpenGLRenderer(): mCaches(Caches::getInstance()) {
	memcpy(mMeshVertices, gMeshVertices, sizeof(gMeshVertices));		memcpy(mMeshVertices, gMeshVertices, sizeof(gMeshVertices));

	mFirstSnapshot = new Snapshot;		mFirstSnapshot = new Snapshot;

			mScissorOptimizationDisabled = false;
	}		}

	OpenGLRenderer::~OpenGLRenderer() {		OpenGLRenderer::~OpenGLRenderer() {
	@@ -124,16 +127,15 @@ OpenGLRenderer::~OpenGLRenderer() {
	// GL APIs. All GL state should be kept in Caches.h		// GL APIs. All GL state should be kept in Caches.h
	}		}

	///////////////////////////////////////////////////////////////////////////////		void OpenGLRenderer::initProperties() {
	// Debug		char property[PROPERTY_VALUE_MAX];
	///////////////////////////////////////////////////////////////////////////////		if (property_get(PROPERTY_DISABLE_SCISSOR_OPTIMIZATION, property, "false")) {
			mScissorOptimizationDisabled = !strcasecmp(property, "true");
	void OpenGLRenderer::startMark(const char* name) const {		INIT_LOGD(" Scissor optimization %s",
	mCaches.startMark(0, name);		mScissorOptimizationDisabled ? "disabled" : "enabled");
			} else {
			INIT_LOGD(" Scissor optimization enabled");
	}		}

	void OpenGLRenderer::endMark() const {
	mCaches.endMark();
	}		}

	///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
	@@ -268,40 +270,6 @@ void OpenGLRenderer::finish() {
	}		}
	}		}

	void OpenGLRenderer::debugOverdraw(bool enable, bool clear) {
	if (mCaches.debugOverdraw && getTargetFbo() == 0) {
	if (clear) {
	mCaches.disableScissor();
	mCaches.stencil.clear();
	}
	if (enable) {
	mCaches.stencil.enableDebugWrite();
	} else {
	mCaches.stencil.disable();
	}
	}
	}

	void OpenGLRenderer::renderOverdraw() {
	if (mCaches.debugOverdraw && getTargetFbo() == 0) {
	const Rect* clip = mTilingSnapshot->clipRect;

	mCaches.enableScissor();
	mCaches.setScissor(clip->left, mTilingSnapshot->height - clip->bottom,
	clip->right - clip->left, clip->bottom - clip->top);

	mCaches.stencil.enableDebugTest(2);
	drawColor(0x2f0000ff, SkXfermode::kSrcOver_Mode);
	mCaches.stencil.enableDebugTest(3);
	drawColor(0x2f00ff00, SkXfermode::kSrcOver_Mode);
	mCaches.stencil.enableDebugTest(4);
	drawColor(0x3fff0000, SkXfermode::kSrcOver_Mode);
	mCaches.stencil.enableDebugTest(4, true);
	drawColor(0x7fff0000, SkXfermode::kSrcOver_Mode);
	mCaches.stencil.disable();
	}
	}

	void OpenGLRenderer::interrupt() {		void OpenGLRenderer::interrupt() {
	if (mCaches.currentProgram) {		if (mCaches.currentProgram) {
	if (mCaches.currentProgram->isInUse()) {		if (mCaches.currentProgram->isInUse()) {
	@@ -438,6 +406,52 @@ status_t OpenGLRenderer::callDrawGLFunction(Functor* functor, Rect& dirty) {
	return result;		return result;
	}		}

			///////////////////////////////////////////////////////////////////////////////
			// Debug
			///////////////////////////////////////////////////////////////////////////////

			void OpenGLRenderer::startMark(const char* name) const {
			mCaches.startMark(0, name);
			}

			void OpenGLRenderer::endMark() const {
			mCaches.endMark();
			}

			void OpenGLRenderer::debugOverdraw(bool enable, bool clear) {
			if (mCaches.debugOverdraw && getTargetFbo() == 0) {
			if (clear) {
			mCaches.disableScissor();
			mCaches.stencil.clear();
			}
			if (enable) {
			mCaches.stencil.enableDebugWrite();
			} else {
			mCaches.stencil.disable();
			}
			}
			}

			void OpenGLRenderer::renderOverdraw() {
			if (mCaches.debugOverdraw && getTargetFbo() == 0) {
			const Rect* clip = mTilingSnapshot->clipRect;

			mCaches.enableScissor();
			mCaches.setScissor(clip->left, mTilingSnapshot->height - clip->bottom,
			clip->right - clip->left, clip->bottom - clip->top);

			mCaches.stencil.enableDebugTest(2);
			drawColor(0x2f0000ff, SkXfermode::kSrcOver_Mode);
			mCaches.stencil.enableDebugTest(3);
			drawColor(0x2f00ff00, SkXfermode::kSrcOver_Mode);
			mCaches.stencil.enableDebugTest(4);
			drawColor(0x3fff0000, SkXfermode::kSrcOver_Mode);
			mCaches.stencil.enableDebugTest(4, true);
			drawColor(0x7fff0000, SkXfermode::kSrcOver_Mode);
			mCaches.stencil.disable();
			}
			}

	///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
	// Layers		// Layers
	///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////
	@@ -1248,7 +1262,7 @@ bool OpenGLRenderer::quickReject(float left, float top, float right, float botto

	bool rejected = !clipRect.intersects(r);		bool rejected = !clipRect.intersects(r);
	if (!isDeferred() && !rejected) {		if (!isDeferred() && !rejected) {
	mCaches.setScissorEnabled(!clipRect.contains(r));		mCaches.setScissorEnabled(mScissorOptimizationDisabled \|\| !clipRect.contains(r));
	}		}

	return rejected;		return rejected;
	@@ -2711,7 +2725,7 @@ status_t OpenGLRenderer::drawLayer(Layer* layer, float x, float y, SkPaint* pain
	debugLayerUpdate = mCaches.debugLayersUpdates;		debugLayerUpdate = mCaches.debugLayersUpdates;
	}		}

	mCaches.setScissorEnabled(!clip.contains(transformed));		mCaches.setScissorEnabled(mScissorOptimizationDisabled \|\| !clip.contains(transformed));
	mCaches.activeTexture(0);		mCaches.activeTexture(0);

	if (CC_LIKELY(!layer->region.isEmpty())) {		if (CC_LIKELY(!layer->region.isEmpty())) {

libs/hwui/OpenGLRenderer.h

+10 −0

Original line number	Original line	Diff line number	Diff line
	@@ -63,6 +63,12 @@ public:
	ANDROID_API OpenGLRenderer();		ANDROID_API OpenGLRenderer();
	virtual ~OpenGLRenderer();		virtual ~OpenGLRenderer();

			/**
			* Read externally defined properties to control the behavior
			* of the renderer.
			*/
			ANDROID_API void initProperties();

	/**		/**
	* Indicates whether this renderer executes drawing commands immediately.		* Indicates whether this renderer executes drawing commands immediately.
	* If this method returns true, the drawing commands will be executed		* If this method returns true, the drawing commands will be executed
	@@ -804,6 +810,10 @@ private:
	// Indicate whether we are drawing an opaque frame		// Indicate whether we are drawing an opaque frame
	bool mOpaqueFrame;		bool mOpaqueFrame;

			// See PROPERTY_DISABLE_SCISSOR_OPTIMIZATION in
			// Properties.h
			bool mScissorOptimizationDisabled;

	friend class DisplayListRenderer;		friend class DisplayListRenderer;

	}; // class OpenGLRenderer		}; // class OpenGLRenderer

libs/hwui/Properties.h

+15 −0

Original line number	Original line	Diff line number	Diff line
	@@ -67,6 +67,21 @@ enum DebugLevel {
	*/		*/
	#define PROPERTY_DEBUG_OVERDRAW "debug.hwui.show_overdraw"		#define PROPERTY_DEBUG_OVERDRAW "debug.hwui.show_overdraw"

			/**
			* Used to enable/disable scissor optimization. The accepted values are
			* "true" and "false". The default value is "false".
			*
			* When scissor optimization is enabled, OpenGLRenderer will attempt to
			* minimize the use of scissor by selectively enabling and disabling the
			* GL scissor test.
			* When the optimization is disabled, OpenGLRenderer will keep the GL
			* scissor test enabled and change the scissor rect as needed.
			* Some GPUs (for instance the SGX 540) perform better when changing
			* the scissor rect often than when enabling/disabling the scissor test
			* often.
			*/
			#define PROPERTY_DISABLE_SCISSOR_OPTIMIZATION "ro.hwui.disable_scissor_opt"

	// These properties are defined in mega-bytes		// These properties are defined in mega-bytes
	#define PROPERTY_TEXTURE_CACHE_SIZE "ro.hwui.texture_cache_size"		#define PROPERTY_TEXTURE_CACHE_SIZE "ro.hwui.texture_cache_size"
	#define PROPERTY_LAYER_CACHE_SIZE "ro.hwui.layer_cache_size"		#define PROPERTY_LAYER_CACHE_SIZE "ro.hwui.layer_cache_size"