remove BakedOps and much of renderstate (e7f688bd) · Commits · e / os / android_frameworks_base

libs/hwui/Android.bp

+0 −10

Original line number	Diff line number	Diff line
		@@ -170,13 +170,9 @@ cc_defaults {
		"pipeline/skia/SkiaRecordingCanvas.cpp",
		"pipeline/skia/SkiaVulkanPipeline.cpp",
		"pipeline/skia/VectorDrawableAtlas.cpp",
		"renderstate/Blend.cpp",
		"renderstate/MeshState.cpp",
		"renderstate/OffscreenBufferPool.cpp",
		"renderstate/PixelBufferState.cpp",
		"renderstate/RenderState.cpp",
		"renderstate/Scissor.cpp",
		"renderstate/Stencil.cpp",
		"renderstate/TextureState.cpp",
		"renderthread/CacheManager.cpp",
		"renderthread/CanvasContext.cpp",
		@@ -200,9 +196,6 @@ cc_defaults {
		"AnimationContext.cpp",
		"Animator.cpp",
		"AnimatorManager.cpp",
		"BakedOpDispatcher.cpp",
		"BakedOpRenderer.cpp",
		"BakedOpState.cpp",
		"Caches.cpp",
		"CanvasState.cpp",
		"ClipArea.cpp",
		@@ -212,13 +205,11 @@ cc_defaults {
		"FrameInfo.cpp",
		"FrameInfoVisualizer.cpp",
		"GlLayer.cpp",
		"GlopBuilder.cpp",
		"GpuMemoryTracker.cpp",
		"Image.cpp",
		"Interpolator.cpp",
		"JankTracker.cpp",
		"Layer.cpp",
		"LayerBuilder.cpp",
		"LayerUpdateQueue.cpp",
		"Matrix.cpp",
		"OpDumper.cpp",
		@@ -229,7 +220,6 @@ cc_defaults {
		"PixelBuffer.cpp",
		"ProfileData.cpp",
		"ProfileDataContainer.cpp",
		"ProfileRenderer.cpp",
		"Program.cpp",
		"Properties.cpp",
		"PropertyValuesAnimatorSet.cpp",

libs/hwui/BakedOpDispatcher.cpp

deleted100644 → 0

+0 −367

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include "BakedOpDispatcher.h"

		#include "BakedOpRenderer.h"
		#include "Caches.h"
		#include "DeferredLayerUpdater.h"
		#include "Glop.h"
		#include "GlopBuilder.h"
		#include "Patch.h"
		#include "PathTessellator.h"
		#include "VertexBuffer.h"
		#include "renderstate/OffscreenBufferPool.h"
		#include "renderstate/RenderState.h"
		#include "utils/GLUtils.h"

		#include <SkPaintDefaults.h>
		#include <SkPathOps.h>
		#include <math.h>
		#include <algorithm>

		namespace android {
		namespace uirenderer {

		void BakedOpDispatcher::onMergedBitmapOps(BakedOpRenderer& renderer,
		const MergedBakedOpList& opList) {
		// DEAD CODE
		}

		void BakedOpDispatcher::onMergedPatchOps(BakedOpRenderer& renderer,
		const MergedBakedOpList& opList) {
		// DEAD CODE
		}

		static void renderTextShadow(BakedOpRenderer& renderer, const TextOp& op,
		const BakedOpState& textOpState) {
		// DEAD CODE
		}

		enum class TextRenderType { Defer, Flush };

		static void renderText(BakedOpRenderer& renderer, const TextOp& op, const BakedOpState& state,
		const ClipBase* renderClip, TextRenderType renderType) {
		// DEAD CODE
		}

		void BakedOpDispatcher::onMergedTextOps(BakedOpRenderer& renderer,
		const MergedBakedOpList& opList) {
		for (size_t i = 0; i < opList.count; i++) {
		const BakedOpState& state = *(opList.states[i]);
		const TextOp& op = (static_cast<const TextOp>(state.op));
		renderTextShadow(renderer, op, state);
		}

		ClipRect renderTargetClip(opList.clip);
		const ClipBase* clip = opList.clipSideFlags ? &renderTargetClip : nullptr;
		for (size_t i = 0; i < opList.count; i++) {
		const BakedOpState& state = *(opList.states[i]);
		const TextOp& op = (static_cast<const TextOp>(state.op));
		TextRenderType renderType =
		(i + 1 == opList.count) ? TextRenderType::Flush : TextRenderType::Defer;
		renderText(renderer, op, state, clip, renderType);
		}
		}

		namespace VertexBufferRenderFlags {
		enum {
		Offset = 0x1,
		ShadowInterp = 0x2,
		};
		}

		static void renderVertexBuffer(BakedOpRenderer& renderer, const BakedOpState& state,
		const VertexBuffer& vertexBuffer, float translateX, float translateY,
		const SkPaint& paint, int vertexBufferRenderFlags) {
		if (CC_LIKELY(vertexBuffer.getVertexCount())) {
		bool shadowInterp = vertexBufferRenderFlags & VertexBufferRenderFlags::ShadowInterp;
		const int transformFlags = vertexBufferRenderFlags & VertexBufferRenderFlags::Offset
		? TransformFlags::OffsetByFudgeFactor
		: 0;

		Glop glop;
		GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
		.setRoundRectClipState(state.roundRectClipState)
		.setMeshVertexBuffer(vertexBuffer)
		.setFillPaint(paint, state.alpha, shadowInterp)
		.setTransform(state.computedState.transform, transformFlags)
		.setModelViewOffsetRect(translateX, translateY, vertexBuffer.getBounds())
		.build();
		renderer.renderGlop(state, glop);
		}
		}

		SkRect getBoundsOfFill(const RecordedOp& op) {
		SkRect bounds = op.unmappedBounds.toSkRect();
		if (op.paint->getStyle() == SkPaint::kStrokeAndFill_Style) {
		float outsetDistance = op.paint->getStrokeWidth() / 2;
		bounds.outset(outsetDistance, outsetDistance);
		}
		return bounds;
		}

		void BakedOpDispatcher::onArcOp(BakedOpRenderer& renderer, const ArcOp& op,
		const BakedOpState& state) {
		// DEAD CODE
		}

		void BakedOpDispatcher::onBitmapOp(BakedOpRenderer& renderer, const BitmapOp& op,
		const BakedOpState& state) {
		Texture* texture = renderer.getTexture(op.bitmap);
		if (!texture) return;
		const AutoTexture autoCleanup(texture);

		const int textureFillFlags = (op.bitmap->colorType() == kAlpha_8_SkColorType)
		? TextureFillFlags::IsAlphaMaskTexture
		: TextureFillFlags::None;
		Glop glop;
		GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
		.setRoundRectClipState(state.roundRectClipState)
		.setMeshTexturedUnitQuad(texture->uvMapper)
		.setFillTexturePaint(*texture, textureFillFlags, op.paint, state.alpha)
		.setTransform(state.computedState.transform, TransformFlags::None)
		.setModelViewMapUnitToRectSnap(Rect(texture->width(), texture->height()))
		.build();
		renderer.renderGlop(state, glop);
		}

		void BakedOpDispatcher::onBitmapMeshOp(BakedOpRenderer& renderer, const BitmapMeshOp& op,
		const BakedOpState& state) {
		// DEAD CODE
		}

		void BakedOpDispatcher::onBitmapRectOp(BakedOpRenderer& renderer, const BitmapRectOp& op,
		const BakedOpState& state) {
		Texture* texture = renderer.getTexture(op.bitmap);
		if (!texture) return;
		const AutoTexture autoCleanup(texture);

		Rect uv(std::max(0.0f, op.src.left / texture->width()),
		std::max(0.0f, op.src.top / texture->height()),
		std::min(1.0f, op.src.right / texture->width()),
		std::min(1.0f, op.src.bottom / texture->height()));

		const int textureFillFlags = (op.bitmap->colorType() == kAlpha_8_SkColorType)
		? TextureFillFlags::IsAlphaMaskTexture
		: TextureFillFlags::None;
		const bool tryToSnap = MathUtils::areEqual(op.src.getWidth(), op.unmappedBounds.getWidth()) &&
		MathUtils::areEqual(op.src.getHeight(), op.unmappedBounds.getHeight());
		Glop glop;
		GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
		.setRoundRectClipState(state.roundRectClipState)
		.setMeshTexturedUvQuad(texture->uvMapper, uv)
		.setFillTexturePaint(*texture, textureFillFlags, op.paint, state.alpha)
		.setTransform(state.computedState.transform, TransformFlags::None)
		.setModelViewMapUnitToRectOptionalSnap(tryToSnap, op.unmappedBounds)
		.build();
		renderer.renderGlop(state, glop);
		}

		void BakedOpDispatcher::onColorOp(BakedOpRenderer& renderer, const ColorOp& op,
		const BakedOpState& state) {
		SkPaint paint;
		paint.setColor(op.color);
		paint.setBlendMode(op.mode);

		Glop glop;
		GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
		.setRoundRectClipState(state.roundRectClipState)
		.setMeshUnitQuad()
		.setFillPaint(paint, state.alpha)
		.setTransform(Matrix4::identity(), TransformFlags::None)
		.setModelViewMapUnitToRect(state.computedState.clipState->rect)
		.build();
		renderer.renderGlop(state, glop);
		}

		void BakedOpDispatcher::onFunctorOp(BakedOpRenderer& renderer, const FunctorOp& op,
		const BakedOpState& state) {
		renderer.renderFunctor(op, state);
		}

		void BakedOpDispatcher::onLinesOp(BakedOpRenderer& renderer, const LinesOp& op,
		const BakedOpState& state) {
		VertexBuffer buffer;
		PathTessellator::tessellateLines(op.points, op.floatCount, op.paint,
		state.computedState.transform, buffer);
		int displayFlags = op.paint->isAntiAlias() ? 0 : VertexBufferRenderFlags::Offset;
		renderVertexBuffer(renderer, state, buffer, 0, 0, *(op.paint), displayFlags);
		}

		void BakedOpDispatcher::onOvalOp(BakedOpRenderer& renderer, const OvalOp& op,
		const BakedOpState& state) {
		// DEAD CODE
		}

		void BakedOpDispatcher::onPatchOp(BakedOpRenderer& renderer, const PatchOp& op,
		const BakedOpState& state) {
		// DEAD CODE
		}

		void BakedOpDispatcher::onPathOp(BakedOpRenderer& renderer, const PathOp& op,
		const BakedOpState& state) {
		// DEAD CODE
		}

		void BakedOpDispatcher::onPointsOp(BakedOpRenderer& renderer, const PointsOp& op,
		const BakedOpState& state) {
		VertexBuffer buffer;
		PathTessellator::tessellatePoints(op.points, op.floatCount, op.paint,
		state.computedState.transform, buffer);
		int displayFlags = op.paint->isAntiAlias() ? 0 : VertexBufferRenderFlags::Offset;
		renderVertexBuffer(renderer, state, buffer, 0, 0, *(op.paint), displayFlags);
		}

		// See SkPaintDefaults.h
		#define SkPaintDefaults_MiterLimit SkIntToScalar(4)

		void BakedOpDispatcher::onRectOp(BakedOpRenderer& renderer, const RectOp& op,
		const BakedOpState& state) {
		// DEAD CODE
		}

		void BakedOpDispatcher::onRoundRectOp(BakedOpRenderer& renderer, const RoundRectOp& op,
		const BakedOpState& state) {
		// DEAD CODE
		}

		void BakedOpDispatcher::onSimpleRectsOp(BakedOpRenderer& renderer, const SimpleRectsOp& op,
		const BakedOpState& state) {
		Glop glop;
		GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
		.setRoundRectClipState(state.roundRectClipState)
		.setMeshIndexedQuads(&op.vertices[0], op.vertexCount / 4)
		.setFillPaint(*op.paint, state.alpha)
		.setTransform(state.computedState.transform, TransformFlags::None)
		.setModelViewOffsetRect(0, 0, op.unmappedBounds)
		.build();
		renderer.renderGlop(state, glop);
		}

		void BakedOpDispatcher::onTextOp(BakedOpRenderer& renderer, const TextOp& op,
		const BakedOpState& state) {
		renderTextShadow(renderer, op, state);
		renderText(renderer, op, state, state.computedState.getClipIfNeeded(), TextRenderType::Flush);
		}

		void BakedOpDispatcher::onTextOnPathOp(BakedOpRenderer& renderer, const TextOnPathOp& op,
		const BakedOpState& state) {
		// DEAD CODE
		}

		void BakedOpDispatcher::onTextureLayerOp(BakedOpRenderer& renderer, const TextureLayerOp& op,
		const BakedOpState& state) {
		GlLayer* layer = static_cast<GlLayer*>(op.layerHandle->backingLayer());
		if (!layer) {
		return;
		}
		const bool tryToSnap = layer->getForceFilter();
		float alpha = (layer->getAlpha() / 255.0f) * state.alpha;
		Glop glop;
		GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
		.setRoundRectClipState(state.roundRectClipState)
		.setMeshTexturedUvQuad(nullptr, Rect(0, 1, 1, 0)) // TODO: simplify with VBO
		.setFillTextureLayer(*(layer), alpha)
		.setTransform(state.computedState.transform, TransformFlags::None)
		.setModelViewMapUnitToRectOptionalSnap(tryToSnap,
		Rect(layer->getWidth(), layer->getHeight()))
		.build();
		renderer.renderGlop(state, glop);
		}

		void renderRectForLayer(BakedOpRenderer& renderer, const LayerOp& op, const BakedOpState& state,
		int color, SkBlendMode mode, SkColorFilter* colorFilter) {
		SkPaint paint;
		paint.setColor(color);
		paint.setBlendMode(mode);
		paint.setColorFilter(sk_ref_sp(colorFilter));
		RectOp rectOp(op.unmappedBounds, op.localMatrix, op.localClip, &paint);
		BakedOpDispatcher::onRectOp(renderer, rectOp, state);
		}

		void BakedOpDispatcher::onLayerOp(BakedOpRenderer& renderer, const LayerOp& op,
		const BakedOpState& state) {
		// Note that we don't use op->paint in this function - it's never set on a LayerOp
		OffscreenBuffer* buffer = *op.layerHandle;

		if (CC_UNLIKELY(!buffer)) return;

		float layerAlpha = op.alpha * state.alpha;
		Glop glop;
		GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
		.setRoundRectClipState(state.roundRectClipState)
		.setMeshTexturedIndexedVbo(buffer->vbo, buffer->elementCount)
		.setFillLayer(buffer->texture, op.colorFilter, layerAlpha, op.mode,
		Blend::ModeOrderSwap::NoSwap)
		.setTransform(state.computedState.transform, TransformFlags::None)
		.setModelViewOffsetRectSnap(
		op.unmappedBounds.left, op.unmappedBounds.top,
		Rect(op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight()))
		.build();
		renderer.renderGlop(state, glop);

		if (!buffer->hasRenderedSinceRepaint) {
		buffer->hasRenderedSinceRepaint = true;
		if (CC_UNLIKELY(Properties::debugLayersUpdates)) {
		// render debug layer highlight
		renderRectForLayer(renderer, op, state, 0x7f00ff00, SkBlendMode::kSrcOver, nullptr);
		} else if (CC_UNLIKELY(Properties::debugOverdraw)) {
		// render transparent to increment overdraw for repaint area
		renderRectForLayer(renderer, op, state, SK_ColorTRANSPARENT, SkBlendMode::kSrcOver,
		nullptr);
		}
		}
		}

		void BakedOpDispatcher::onCopyToLayerOp(BakedOpRenderer& renderer, const CopyToLayerOp& op,
		const BakedOpState& state) {
		LOG_ALWAYS_FATAL_IF(*(op.layerHandle) != nullptr, "layer already exists!");
		*(op.layerHandle) = renderer.copyToLayer(state.computedState.clippedBounds);
		LOG_ALWAYS_FATAL_IF(*op.layerHandle == nullptr, "layer copy failed");
		}

		void BakedOpDispatcher::onCopyFromLayerOp(BakedOpRenderer& renderer, const CopyFromLayerOp& op,
		const BakedOpState& state) {
		LOG_ALWAYS_FATAL_IF(*op.layerHandle == nullptr, "no layer to draw underneath!");
		if (!state.computedState.clippedBounds.isEmpty()) {
		if (op.paint && op.paint->getAlpha() < 255) {
		SkPaint layerPaint;
		layerPaint.setAlpha(op.paint->getAlpha());
		layerPaint.setBlendMode(SkBlendMode::kDstIn);
		layerPaint.setColorFilter(sk_ref_sp(op.paint->getColorFilter()));
		RectOp rectOp(state.computedState.clippedBounds, Matrix4::identity(), nullptr,
		&layerPaint);
		BakedOpDispatcher::onRectOp(renderer, rectOp, state);
		}

		OffscreenBuffer& layer = **(op.layerHandle);
		auto mode = PaintUtils::getBlendModeDirect(op.paint);
		Glop glop;
		GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
		.setRoundRectClipState(state.roundRectClipState)
		.setMeshTexturedUvQuad(nullptr, layer.getTextureCoordinates())
		.setFillLayer(layer.texture, nullptr, 1.0f, mode, Blend::ModeOrderSwap::Swap)
		.setTransform(state.computedState.transform, TransformFlags::None)
		.setModelViewMapUnitToRect(state.computedState.clippedBounds)
		.build();
		renderer.renderGlop(state, glop);
		}
		renderer.renderState().layerPool().putOrDelete(*op.layerHandle);
		}

		} // namespace uirenderer
		} // namespace android

libs/hwui/BakedOpDispatcher.h

deleted100644 → 0

+0 −54

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_HWUI_BAKED_OP_DISPATCHER_H
		#define ANDROID_HWUI_BAKED_OP_DISPATCHER_H

		#include "BakedOpState.h"
		#include "RecordedOp.h"

		namespace android {
		namespace uirenderer {

		class BakedOpRenderer;

		/**
		* Provides all "onBitmapOp(...)" style static methods for every op type, which convert the
		* RecordedOps and their state to Glops, and renders them with the provided BakedOpRenderer.
		*
		* onXXXOp methods must either render directly with the renderer, or call a static renderYYY
		* method to render content. There should never be draw content rejection in BakedOpDispatcher -
		* it must happen at a higher level (except in error-ish cases, like texture-too-big).
		*/
		class BakedOpDispatcher {
		public:
		// Declares all "onMergedBitmapOps(...)" style methods for mergeable op types
		#define X(Type) \
		static void onMerged##Type##s(BakedOpRenderer& renderer, const MergedBakedOpList& opList);
		MAP_MERGEABLE_OPS(X)
		#undef X

		// Declares all "onBitmapOp(...)" style methods for every op type
		#define X(Type) \
		static void on##Type(BakedOpRenderer& renderer, const Type& op, const BakedOpState& state);
		MAP_RENDERABLE_OPS(X)
		#undef X
		};

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

		#endif // ANDROID_HWUI_BAKED_OP_DISPATCHER_H

libs/hwui/BakedOpRenderer.cpp

deleted100644 → 0

+0 −374

File deleted.

Preview size limit exceeded, changes collapsed.

libs/hwui/BakedOpRenderer.h

deleted100644 → 0

+0 −141

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#pragma once

		#include "BakedOpState.h"
		#include "Lighting.h"
		#include "Matrix.h"
		#include "utils/Macros.h"

		namespace android {
		namespace uirenderer {

		class Caches;
		struct Glop;
		class Layer;
		struct RenderBuffer;
		class RenderState;
		struct ClipBase;

		/**
		* Main rendering manager for a collection of work - one frame + any contained FBOs.
		*
		* Manages frame and FBO lifecycle, binding the GL framebuffer as appropriate. This is the only
		* place where FBOs are bound, created, and destroyed.
		*
		* All rendering operations will be sent by the Dispatcher, a collection of static methods,
		* which has intentionally limited access to the renderer functionality.
		*/
		class BakedOpRenderer {
		public:
		typedef void (GlopReceiver)(BakedOpRenderer&, const Rect, const ClipBase*, const Glop&);

		BakedOpRenderer(Caches& caches, RenderState& renderState, bool opaque, bool wideColorGamut,
		const LightInfo& lightInfo)
		: mGlopReceiver(DefaultGlopReceiver)
		, mRenderState(renderState)
		, mCaches(caches)
		, mOpaque(opaque)
		, mWideColorGamut(wideColorGamut)
		, mLightInfo(lightInfo) {}

		RenderState& renderState() { return mRenderState; }
		Caches& caches() { return mCaches; }

		void startFrame(uint32_t width, uint32_t height, const Rect& repaintRect);
		void endFrame(const Rect& repaintRect);
		WARN_UNUSED_RESULT OffscreenBuffer* startTemporaryLayer(uint32_t width, uint32_t height);
		void recycleTemporaryLayer(OffscreenBuffer* offscreenBuffer);
		void startRepaintLayer(OffscreenBuffer* offscreenBuffer, const Rect& repaintRect);
		void endLayer();
		WARN_UNUSED_RESULT OffscreenBuffer* copyToLayer(const Rect& area);

		Texture* getTexture(Bitmap* bitmap);
		const LightInfo& getLightInfo() const { return mLightInfo; }

		void renderGlop(const BakedOpState& state, const Glop& glop) {
		renderGlop(&state.computedState.clippedBounds, state.computedState.getClipIfNeeded(), glop);
		}
		void renderFunctor(const FunctorOp& op, const BakedOpState& state);

		void renderGlop(const Rect* dirtyBounds, const ClipBase* clip, const Glop& glop) {
		mGlopReceiver(*this, dirtyBounds, clip, glop);
		}
		bool offscreenRenderTarget() { return mRenderTarget.offscreenBuffer != nullptr; }
		void dirtyRenderTarget(const Rect& dirtyRect);
		bool didDraw() const { return mHasDrawn; }

		uint32_t getViewportWidth() const { return mRenderTarget.viewportWidth; }
		uint32_t getViewportHeight() const { return mRenderTarget.viewportHeight; }

		// simple draw methods, to be used for end frame decoration
		void drawRect(float left, float top, float right, float bottom, const SkPaint* paint) {
		float ltrb[4] = {left, top, right, bottom};
		drawRects(ltrb, 4, paint);
		}
		void drawRects(const float* rects, int count, const SkPaint* paint);

		protected:
		GlopReceiver mGlopReceiver;

		private:
		static void DefaultGlopReceiver(BakedOpRenderer& renderer, const Rect* dirtyBounds,
		const ClipBase* clip, const Glop& glop) {
		renderer.renderGlopImpl(dirtyBounds, clip, glop);
		}
		void renderGlopImpl(const Rect* dirtyBounds, const ClipBase* clip, const Glop& glop);
		void setViewport(uint32_t width, uint32_t height);
		void clearColorBuffer(const Rect& clearRect);
		void prepareRender(const Rect* dirtyBounds, const ClipBase* clip);
		void setupStencilRectList(const ClipBase* clip);
		void setupStencilRegion(const ClipBase* clip);
		void setupStencilQuads(std::vector<Vertex>& quadVertices, int incrementThreshold);

		RenderState& mRenderState;
		Caches& mCaches;
		bool mOpaque;
		bool mWideColorGamut;
		bool mHasDrawn = false;

		// render target state - setup by start/end layer/frame
		// only valid to use in between start/end pairs.
		struct {
		// If not drawing to a layer: fbo = 0, offscreenBuffer = null,
		// Otherwise these refer to currently painting layer's state
		GLuint frameBufferId = 0;
		OffscreenBuffer* offscreenBuffer = nullptr;

		// Used when drawing to a layer and using stencil clipping. otherwise null.
		RenderBuffer* stencil = nullptr;

		// value representing the ClipRectList* or ClipRegion* currently stored in
		// the stencil of the current render target
		const ClipBase* lastStencilClip = nullptr;

		// Size of renderable region in current render target - for layers, may not match actual
		// bounds of FBO texture. offscreenBuffer->texture has this information.
		uint32_t viewportWidth = 0;
		uint32_t viewportHeight = 0;

		Matrix4 orthoMatrix;
		} mRenderTarget;

		const LightInfo mLightInfo;
		};

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