Keep shaders to render properly (3e263fac) · Commits · e / os / android_frameworks_base

libs/hwui/LayerRenderer.cpp

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -233,7 +233,6 @@ Layer* LayerRenderer::createLayer(uint32_t width, uint32_t height, bool isOpaque
	layer->getTexture(), 0);		layer->getTexture(), 0);

	glDisable(GL_SCISSOR_TEST);		glDisable(GL_SCISSOR_TEST);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClear(GL_COLOR_BUFFER_BIT);		glClear(GL_COLOR_BUFFER_BIT);
	glEnable(GL_SCISSOR_TEST);		glEnable(GL_SCISSOR_TEST);

libs/hwui/OpenGLRenderer.cpp

+11 −6

Original line number	Original line	Diff line number	Diff line
	@@ -133,8 +133,6 @@ OpenGLRenderer::~OpenGLRenderer() {
	///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

	void OpenGLRenderer::setViewport(int width, int height) {		void OpenGLRenderer::setViewport(int width, int height) {
	glDisable(GL_DITHER);
	glViewport(0, 0, width, height);
	mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1);		mOrthoMatrix.loadOrtho(0, width, height, 0, -1, 1);

	mWidth = width;		mWidth = width;
	@@ -144,6 +142,13 @@ void OpenGLRenderer::setViewport(int width, int height) {
	mFirstSnapshot->viewport.set(0, 0, width, height);		mFirstSnapshot->viewport.set(0, 0, width, height);

	mDirtyClip = false;		mDirtyClip = false;

			glDisable(GL_DITHER);
			glViewport(0, 0, width, height);

			glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

			glEnableVertexAttribArray(Program::kBindingPosition);
	}		}

	void OpenGLRenderer::prepare(bool opaque) {		void OpenGLRenderer::prepare(bool opaque) {
	@@ -159,14 +164,11 @@ void OpenGLRenderer::prepareDirty(float left, float top, float right, float bott

	mSaveCount = 1;		mSaveCount = 1;

	glViewport(0, 0, mWidth, mHeight);

	glEnable(GL_SCISSOR_TEST);		glEnable(GL_SCISSOR_TEST);
	glScissor(left, mSnapshot->height - bottom, right - left, bottom - top);		glScissor(left, mSnapshot->height - bottom, right - left, bottom - top);
	mSnapshot->setClip(left, top, right, bottom);		mSnapshot->setClip(left, top, right, bottom);

	if (!opaque) {		if (!opaque) {
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClear(GL_COLOR_BUFFER_BIT);		glClear(GL_COLOR_BUFFER_BIT);
	}		}
	}		}
	@@ -207,6 +209,8 @@ void OpenGLRenderer::resume() {

	glViewport(0, 0, snapshot->viewport.getWidth(), snapshot->viewport.getHeight());		glViewport(0, 0, snapshot->viewport.getWidth(), snapshot->viewport.getHeight());

			glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

	glEnable(GL_SCISSOR_TEST);		glEnable(GL_SCISSOR_TEST);
	dirtyClip();		dirtyClip();

	@@ -215,6 +219,8 @@ void OpenGLRenderer::resume() {
	glBindFramebuffer(GL_FRAMEBUFFER, snapshot->fbo);		glBindFramebuffer(GL_FRAMEBUFFER, snapshot->fbo);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

			glEnableVertexAttribArray(Program::kBindingPosition);

	mCaches.blend = true;		mCaches.blend = true;
	glEnable(GL_BLEND);		glEnable(GL_BLEND);
	glBlendFunc(mCaches.lastSrcMode, mCaches.lastDstMode);		glBlendFunc(mCaches.lastSrcMode, mCaches.lastDstMode);
	@@ -556,7 +562,6 @@ bool OpenGLRenderer::createFboLayer(Layer* layer, Rect& bounds, sp<Snapshot> sna
	// Clear the FBO, expand the clear region by 1 to get nice bilinear filtering		// Clear the FBO, expand the clear region by 1 to get nice bilinear filtering
	glScissor(clip.left - 1.0f, bounds.getHeight() - clip.bottom - 1.0f,		glScissor(clip.left - 1.0f, bounds.getHeight() - clip.bottom - 1.0f,
	clip.getWidth() + 2.0f, clip.getHeight() + 2.0f);		clip.getWidth() + 2.0f, clip.getHeight() + 2.0f);
	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
	glClear(GL_COLOR_BUFFER_BIT);		glClear(GL_COLOR_BUFFER_BIT);

	dirtyClip();		dirtyClip();

libs/hwui/Program.cpp

+34 −23

Original line number	Original line	Diff line number	Diff line
	@@ -25,21 +25,24 @@ namespace uirenderer {
	// Base program		// Base program
	///////////////////////////////////////////////////////////////////////////////		///////////////////////////////////////////////////////////////////////////////

			// TODO: Program instance should be created from a factory method
	Program::Program(const char* vertex, const char* fragment) {		Program::Program(const char* vertex, const char* fragment) {
	mInitialized = false;		mInitialized = false;
	mHasColorUniform = false;		mHasColorUniform = false;
			mUse = false;

	// No need to cache compiled shaders, rely instead on Android's		// No need to cache compiled shaders, rely instead on Android's
	// persistent shaders cache		// persistent shaders cache
	GLuint vertexShader = buildShader(vertex, GL_VERTEX_SHADER);		mVertexShader = buildShader(vertex, GL_VERTEX_SHADER);
	if (vertexShader) {		if (mVertexShader) {
			mFragmentShader = buildShader(fragment, GL_FRAGMENT_SHADER);
			if (mFragmentShader) {
			mProgramId = glCreateProgram();

	GLuint fragmentShader = buildShader(fragment, GL_FRAGMENT_SHADER);		glAttachShader(mProgramId, mVertexShader);
	if (fragmentShader) {		glAttachShader(mProgramId, mFragmentShader);

	mProgramId = glCreateProgram();		position = bindAttrib("position", kBindingPosition);
	glAttachShader(mProgramId, vertexShader);
	glAttachShader(mProgramId, fragmentShader);
	glLinkProgram(mProgramId);		glLinkProgram(mProgramId);

	GLint status;		GLint status;
	@@ -53,34 +56,35 @@ Program::Program(const char* vertex, const char* fragment) {
	glGetProgramInfoLog(mProgramId, infoLen, 0, &log[0]);		glGetProgramInfoLog(mProgramId, infoLen, 0, &log[0]);
	LOGE("%s", log);		LOGE("%s", log);
	}		}
	} else {
	mInitialized = true;
	}

	glDetachShader(mProgramId, vertexShader);		glDetachShader(mProgramId, mVertexShader);
	glDetachShader(mProgramId, fragmentShader);		glDetachShader(mProgramId, mFragmentShader);

	glDeleteShader(vertexShader);		glDeleteShader(mVertexShader);
	glDeleteShader(fragmentShader);		glDeleteShader(mFragmentShader);

	if (!mInitialized) {
	glDeleteProgram(mProgramId);		glDeleteProgram(mProgramId);
			} else {
			mInitialized = true;
	}		}
	} else {		} else {
	glDeleteShader(vertexShader);		glDeleteShader(mVertexShader);
	}		}
	}		}

	mUse = false;

	if (mInitialized) {		if (mInitialized) {
	position = addAttrib("position");
	transform = addUniform("transform");		transform = addUniform("transform");
	}		}
	}		}

	Program::~Program() {		Program::~Program() {
	if (mInitialized) {		if (mInitialized) {
			glDetachShader(mProgramId, mVertexShader);
			glDetachShader(mProgramId, mFragmentShader);

			glDeleteShader(mVertexShader);
			glDeleteShader(mFragmentShader);

	glDeleteProgram(mProgramId);		glDeleteProgram(mProgramId);
	}		}
	}		}
	@@ -91,6 +95,17 @@ int Program::addAttrib(const char* name) {
	return slot;		return slot;
	}		}

			int Program::bindAttrib(const char* name, ShaderBindings bindingSlot) {
			glBindAttribLocation(mProgramId, bindingSlot, name);
			GLenum status = GL_NO_ERROR;
			while ((status = glGetError()) != GL_NO_ERROR) {
			LOGD("Program::GL error from OpenGLRenderer: 0x%x", status);
			}

			mAttributes.add(name, bindingSlot);
			return bindingSlot;
			}

	int Program::getAttrib(const char* name) {		int Program::getAttrib(const char* name) {
	ssize_t index = mAttributes.indexOfKey(name);		ssize_t index = mAttributes.indexOfKey(name);
	if (index >= 0) {		if (index >= 0) {
	@@ -161,14 +176,10 @@ void Program::setColor(const float r, const float g, const float b, const float
	void Program::use() {		void Program::use() {
	glUseProgram(mProgramId);		glUseProgram(mProgramId);
	mUse = true;		mUse = true;
	glEnableVertexAttribArray(position);
	}		}

	void Program::remove() {		void Program::remove() {
	mUse = false;		mUse = false;
	// TODO: Is this necessary? It should not be since all of our shaders
	// use slot 0 for the position attrib
	// glDisableVertexAttribArray(position);
	}		}

	}; // namespace uirenderer		}; // namespace uirenderer

libs/hwui/Program.h

+13 −1

Original line number	Original line	Diff line number	Diff line
	@@ -33,6 +33,11 @@ namespace uirenderer {
	*/		*/
	class Program {		class Program {
	public:		public:
			enum ShaderBindings {
			kBindingPosition,
			kBindingTexCoords
			};

	/**		/**
	* Creates a new program with the specified vertex and fragment		* Creates a new program with the specified vertex and fragment
	* shaders sources.		* shaders sources.
	@@ -106,6 +111,11 @@ protected:
	*/		*/
	int addAttrib(const char* name);		int addAttrib(const char* name);

			/**
			* Binds the specified attribute name to the specified slot.
			*/
			int bindAttrib(const char* name, ShaderBindings bindingSlot);

	/**		/**
	* Adds a uniform with the specified name.		* Adds a uniform with the specified name.
	*		*
	@@ -121,8 +131,10 @@ private:
	*/		*/
	GLuint buildShader(const char* source, GLenum type);		GLuint buildShader(const char* source, GLenum type);

	// Name of the OpenGL program		// Name of the OpenGL program and shaders
	GLuint mProgramId;		GLuint mProgramId;
			GLuint mVertexShader;
			GLuint mFragmentShader;

	// Keeps track of attributes and uniforms slots		// Keeps track of attributes and uniforms slots
	KeyedVector<const char*, int> mAttributes;		KeyedVector<const char*, int> mAttributes;