CanvasState frame init refactor (64e445bf) · Commits · e / os / android_frameworks_base

libs/hwui/CanvasState.cpp

+10 −19

Original line number	Diff line number	Diff line
		@@ -34,12 +34,17 @@ CanvasState::CanvasState(CanvasStateClient& renderer)

		}

		CanvasState::~CanvasState() {

		void CanvasState::initializeSaveStack(
		int viewportWidth, int viewportHeight,
		float clipLeft, float clipTop,
		float clipRight, float clipBottom, const Vector3& lightCenter) {
		if (mWidth != viewportWidth \|\| mHeight != viewportHeight) {
		mWidth = viewportWidth;
		mHeight = viewportHeight;
		mFirstSnapshot->initializeViewport(viewportWidth, viewportHeight);
		mCanvas.onViewportInitialized();
		}

		void CanvasState::initializeSaveStack(float clipLeft, float clipTop,
		float clipRight, float clipBottom, const Vector3& lightCenter) {
		mSnapshot = new Snapshot(mFirstSnapshot,
		SkCanvas::kMatrix_SaveFlag \| SkCanvas::kClip_SaveFlag);
		mSnapshot->setClip(clipLeft, clipTop, clipRight, clipBottom);
		@@ -48,20 +53,6 @@ void CanvasState::initializeSaveStack(float clipLeft, float clipTop,
		mSaveCount = 1;
		}

		void CanvasState::setViewport(int width, int height) {
		mWidth = width;
		mHeight = height;
		mFirstSnapshot->initializeViewport(width, height);
		mCanvas.onViewportInitialized();

		// create a temporary 1st snapshot, so old snapshots are released,
		// and viewport can be queried safely.
		// TODO: remove, combine viewport + save stack initialization
		mSnapshot = new Snapshot(mFirstSnapshot,
		SkCanvas::kMatrix_SaveFlag \| SkCanvas::kClip_SaveFlag);
		mSaveCount = 1;
		}

		///////////////////////////////////////////////////////////////////////////////
		// Save (layer)
		///////////////////////////////////////////////////////////////////////////////

libs/hwui/CanvasState.h

+4 −11

Original line number	Diff line number	Diff line
		@@ -71,20 +71,18 @@ public:
		* (getClip/Matrix), but so that quickRejection can also be used.
		*/

		class ANDROID_API CanvasState {
		class CanvasState {
		public:
		CanvasState(CanvasStateClient& renderer);
		~CanvasState();

		/**
		* Initializes the first snapshot, computing the projection matrix,
		* and stores the dimensions of the render target.
		*/
		void initializeSaveStack(float clipLeft, float clipTop, float clipRight, float clipBottom,
		void initializeSaveStack(int viewportWidth, int viewportHeight,
		float clipLeft, float clipTop, float clipRight, float clipBottom,
		const Vector3& lightCenter);

		void setViewport(int width, int height);

		bool hasRectToRectTransform() const {
		return CC_LIKELY(currentTransform()->rectToRect());
		}
		@@ -159,16 +157,11 @@ public:
		int getHeight() const { return mHeight; }
		bool clipIsSimple() const { return currentSnapshot()->clipIsSimple(); }

		inline const Snapshot* currentSnapshot() const {
		return mSnapshot != nullptr ? mSnapshot.get() : mFirstSnapshot.get();
		}
		inline const Snapshot* currentSnapshot() const { return mSnapshot.get(); }
		inline Snapshot* writableSnapshot() { return mSnapshot.get(); }
		inline const Snapshot* firstSnapshot() const { return mFirstSnapshot.get(); }

		private:
		/// No default constructor - must supply a CanvasStateClient (mCanvas).
		CanvasState();

		/// indicates that the clip has been changed since the last time it was consumed
		bool mDirtyClip;

libs/hwui/DisplayListCanvas.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -54,8 +54,8 @@ void DisplayListCanvas::reset(int width, int height) {
		"prepareDirty called a second time during a recording!");
		mDisplayListData = new DisplayListData();

		mState.setViewport(width, height);
		mState.initializeSaveStack(0, 0, mState.getWidth(), mState.getHeight(), Vector3());
		mState.initializeSaveStack(width, height,
		0, 0, width, height, Vector3());

		mDeferredBarrierType = kBarrier_InOrder;
		mState.setDirtyClip(false);

libs/hwui/Layer.cpp

+5 −8

Original line number	Diff line number	Diff line
		@@ -236,8 +236,7 @@ void Layer::defer(const OpenGLRenderer& rootRenderer) {
		DeferStateStruct deferredState(deferredList, renderer,
		RenderNode::kReplayFlag_ClipChildren);

		renderer->setViewport(width, height);
		renderer->setupFrameState(dirtyRect.left, dirtyRect.top,
		renderer->setupFrameState(width, height, dirtyRect.left, dirtyRect.top,
		dirtyRect.right, dirtyRect.bottom, !isBlend());

		renderNode->computeOrdering();
		@@ -258,9 +257,8 @@ void Layer::flush() {
		ATRACE_LAYER_WORK("Issue");
		renderer->startMark((renderNode.get() != nullptr) ? renderNode->getName() : "Layer");

		renderer->setViewport(layer.getWidth(), layer.getHeight());
		renderer->prepareDirty(dirtyRect.left, dirtyRect.top, dirtyRect.right, dirtyRect.bottom,
		!isBlend());
		renderer->prepareDirty(layer.getWidth(), layer.getHeight(),
		dirtyRect.left, dirtyRect.top, dirtyRect.right, dirtyRect.bottom, !isBlend());

		deferredList->flush(*renderer, dirtyRect);

		@@ -277,9 +275,8 @@ void Layer::render(const OpenGLRenderer& rootRenderer) {
		ATRACE_LAYER_WORK("Direct-Issue");

		updateLightPosFromRenderer(rootRenderer);
		renderer->setViewport(layer.getWidth(), layer.getHeight());
		renderer->prepareDirty(dirtyRect.left, dirtyRect.top, dirtyRect.right, dirtyRect.bottom,
		!isBlend());
		renderer->prepareDirty(layer.getWidth(), layer.getHeight(),
		dirtyRect.left, dirtyRect.top, dirtyRect.right, dirtyRect.bottom, !isBlend());

		renderer->drawRenderNode(renderNode.get(), dirtyRect, RenderNode::kReplayFlag_ClipChildren);

libs/hwui/LayerRenderer.cpp

+6 −6

Original line number	Diff line number	Diff line
		@@ -43,8 +43,8 @@ LayerRenderer::LayerRenderer(RenderState& renderState, Layer* layer)
		LayerRenderer::~LayerRenderer() {
		}

		void LayerRenderer::prepareDirty(float left, float top, float right, float bottom,
		bool opaque) {
		void LayerRenderer::prepareDirty(int viewportWidth, int viewportHeight,
		float left, float top, float right, float bottom, bool opaque) {
		LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo());

		mRenderState.bindFramebuffer(mLayer->getFbo());
		@@ -64,7 +64,8 @@ void LayerRenderer::prepareDirty(float left, float top, float right, float botto
		}
		mLayer->clipRect.set(dirty);

		OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
		OpenGLRenderer::prepareDirty(viewportWidth, viewportHeight,
		dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
		}

		void LayerRenderer::clear(float left, float top, float right, float bottom, bool opaque) {
		@@ -430,9 +431,8 @@ bool LayerRenderer::copyLayer(RenderState& renderState, Layer* layer, SkBitmap*

		{
		LayerRenderer renderer(renderState, layer);
		renderer.setViewport(bitmap->width(), bitmap->height());
		renderer.OpenGLRenderer::prepareDirty(0.0f, 0.0f,
		bitmap->width(), bitmap->height(), !layer->isBlend());
		renderer.OpenGLRenderer::prepareDirty(bitmap->width(), bitmap->height(),
		0.0f, 0.0f, bitmap->width(), bitmap->height(), !layer->isBlend());

		renderState.scissor().setEnabled(false);
		renderer.translate(0.0f, bitmap->height());