Merge "VkFunctorDrawable implementation" (34495b9f) · Commits · e / os / android_frameworks_base

libs/hwui/WebViewFunctorManager.cpp

+20 −0

Original line number	Original line	Diff line number	Diff line
	@@ -86,6 +86,26 @@ void WebViewFunctor::drawGl(const DrawGlInfo& drawInfo) {
	mCallbacks.gles.draw(mFunctor, mData, drawInfo);		mCallbacks.gles.draw(mFunctor, mData, drawInfo);
	}		}

			void WebViewFunctor::initVk(const VkFunctorInitParams& params) {
			ATRACE_NAME("WebViewFunctor::initVk");
			if (!mHasContext) {
			mHasContext = true;
			} else {
			return;
			}
			mCallbacks.vk.initialize(mFunctor, mData, params);
			}

			void WebViewFunctor::drawVk(const VkFunctorDrawParams& params) {
			ATRACE_NAME("WebViewFunctor::drawVk");
			mCallbacks.vk.draw(mFunctor, mData, params);
			}

			void WebViewFunctor::postDrawVk() {
			ATRACE_NAME("WebViewFunctor::postDrawVk");
			mCallbacks.vk.postDraw(mFunctor, mData);
			}

	void WebViewFunctor::destroyContext() {		void WebViewFunctor::destroyContext() {
	if (mHasContext) {		if (mHasContext) {
	mHasContext = false;		mHasContext = false;

libs/hwui/WebViewFunctorManager.h

+9 −0

Original line number	Original line	Diff line number	Diff line
	@@ -42,6 +42,12 @@ public:

	void drawGl(const DrawGlInfo& drawInfo) const { mReference.drawGl(drawInfo); }		void drawGl(const DrawGlInfo& drawInfo) const { mReference.drawGl(drawInfo); }

			void initVk(const VkFunctorInitParams& params) { mReference.initVk(params); }

			void drawVk(const VkFunctorDrawParams& params) { mReference.drawVk(params); }

			void postDrawVk() { mReference.postDrawVk(); }

	private:		private:
	friend class WebViewFunctor;		friend class WebViewFunctor;

	@@ -53,6 +59,9 @@ public:
	int id() const { return mFunctor; }		int id() const { return mFunctor; }
	void sync(const WebViewSyncData& syncData) const;		void sync(const WebViewSyncData& syncData) const;
	void drawGl(const DrawGlInfo& drawInfo);		void drawGl(const DrawGlInfo& drawInfo);
			void initVk(const VkFunctorInitParams& params);
			void drawVk(const VkFunctorDrawParams& params);
			void postDrawVk();
	void destroyContext();		void destroyContext();

	sp<Handle> createHandle() {		sp<Handle> createHandle() {

libs/hwui/pipeline/skia/SkiaRecordingCanvas.cpp

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -125,8 +125,6 @@ void SkiaRecordingCanvas::callDrawGLFunction(Functor* functor,
	uirenderer::GlFunctorLifecycleListener* listener) {		uirenderer::GlFunctorLifecycleListener* listener) {
	FunctorDrawable* functorDrawable;		FunctorDrawable* functorDrawable;
	if (Properties::getRenderPipelineType() == RenderPipelineType::SkiaVulkan) {		if (Properties::getRenderPipelineType() == RenderPipelineType::SkiaVulkan) {
	// TODO(cblume) use VkFunctorDrawable instead of VkInteropFunctorDrawable here when the
	// interop is disabled/moved.
	functorDrawable = mDisplayList->allocateDrawable<VkInteropFunctorDrawable>(		functorDrawable = mDisplayList->allocateDrawable<VkInteropFunctorDrawable>(
	functor, listener, asSkCanvas());		functor, listener, asSkCanvas());
	} else {		} else {

libs/hwui/pipeline/skia/VkFunctorDrawable.cpp

+43 −16

Original line number	Original line	Diff line number	Diff line
	@@ -17,6 +17,8 @@
	#include "VkFunctorDrawable.h"		#include "VkFunctorDrawable.h"
	#include <private/hwui/DrawVkInfo.h>		#include <private/hwui/DrawVkInfo.h>

			#include "renderthread/VulkanManager.h"
			#include "renderthread/RenderThread.h"
	#include <GrBackendDrawableInfo.h>		#include <GrBackendDrawableInfo.h>
	#include <SkImage.h>		#include <SkImage.h>
	#include <utils/Color.h>		#include <utils/Color.h>
	@@ -31,34 +33,58 @@ namespace android {
	namespace uirenderer {		namespace uirenderer {
	namespace skiapipeline {		namespace skiapipeline {

	VkFunctorDrawHandler::VkFunctorDrawHandler(Functor* functor) : INHERITED(), mFunctor(functor) {}		VkFunctorDrawHandler::VkFunctorDrawHandler(sp<WebViewFunctor::Handle> functor_handle,
			const SkMatrix& matrix, const SkIRect& clip,
			const SkImageInfo& image_info)
			: INHERITED()
			, mFunctorHandle(functor_handle)
			, mMatrix(matrix)
			, mClip(clip)
			, mImageInfo(image_info) {}

	VkFunctorDrawHandler::~VkFunctorDrawHandler() {		VkFunctorDrawHandler::~VkFunctorDrawHandler() {
	// TODO(cblume) Fill in the DrawVkInfo parameters.		mFunctorHandle->postDrawVk();
	(*mFunctor)(DrawVkInfo::kModePostComposite, nullptr);
	}		}

	void VkFunctorDrawHandler::draw(const GrBackendDrawableInfo& info) {		void VkFunctorDrawHandler::draw(const GrBackendDrawableInfo& info) {
	ATRACE_CALL();		ATRACE_CALL();
			if (!renderthread::RenderThread::isCurrent())
			LOG_ALWAYS_FATAL("VkFunctorDrawHandler::draw not called on render thread");

	GrVkDrawableInfo vulkan_info;		GrVkDrawableInfo vulkan_info;
	if (!info.getVkDrawableInfo(&vulkan_info)) {		if (!info.getVkDrawableInfo(&vulkan_info)) {
	return;		return;
	}		}
			renderthread::VulkanManager& vk_manager =
			renderthread::RenderThread::getInstance().vulkanManager();
			mFunctorHandle->initVk(vk_manager.getVkFunctorInitParams());

	DrawVkInfo draw_vk_info;		SkMatrix44 mat4(mMatrix);
	// TODO(cblume) Fill in the rest of the parameters and test the actual call.		VkFunctorDrawParams params{
	draw_vk_info.isLayer = true;		.width = mImageInfo.width(),
			.height = mImageInfo.height(),
			.is_layer = false, // TODO(boliu): Populate is_layer.
			.color_space_ptr = mImageInfo.colorSpace(),
			.clip_left = mClip.fLeft,
			.clip_top = mClip.fTop,
			.clip_right = mClip.fRight,
			.clip_bottom = mClip.fBottom,
			};
			mat4.asColMajorf(&params.transform[0]);
			params.secondary_command_buffer = vulkan_info.fSecondaryCommandBuffer;
			params.color_attachment_index = vulkan_info.fColorAttachmentIndex;
			params.compatible_render_pass = vulkan_info.fCompatibleRenderPass;
			params.format = vulkan_info.fFormat;

	(*mFunctor)(DrawVkInfo::kModeComposite, &draw_vk_info);		mFunctorHandle->drawVk(params);

			vulkan_info.fDrawBounds->offset.x = mClip.fLeft;
			vulkan_info.fDrawBounds->offset.y = mClip.fTop;
			vulkan_info.fDrawBounds->extent.width = mClip.fRight - mClip.fLeft;
			vulkan_info.fDrawBounds->extent.height = mClip.fBottom - mClip.fTop;
	}		}

	VkFunctorDrawable::~VkFunctorDrawable() {		VkFunctorDrawable::~VkFunctorDrawable() {
	if (auto lp = std::get_if<LegacyFunctor>(&mAnyFunctor)) {
	if (lp->listener) {
	lp->listener->onGlFunctorReleased(lp->functor);
	}
	}
	}		}

	void VkFunctorDrawable::onDraw(SkCanvas* /canvas/) {		void VkFunctorDrawable::onDraw(SkCanvas* /canvas/) {
	@@ -67,16 +93,17 @@ void VkFunctorDrawable::onDraw(SkCanvas* /canvas/) {
	}		}

	std::unique_ptr<FunctorDrawable::GpuDrawHandler> VkFunctorDrawable::onSnapGpuDrawHandler(		std::unique_ptr<FunctorDrawable::GpuDrawHandler> VkFunctorDrawable::onSnapGpuDrawHandler(
	GrBackendApi backendApi, const SkMatrix& matrix) {		GrBackendApi backendApi, const SkMatrix& matrix, const SkIRect& clip,
			const SkImageInfo& image_info) {
	if (backendApi != GrBackendApi::kVulkan) {		if (backendApi != GrBackendApi::kVulkan) {
	return nullptr;		return nullptr;
	}		}
	std::unique_ptr<VkFunctorDrawHandler> draw;		std::unique_ptr<VkFunctorDrawHandler> draw;
	if (mAnyFunctor.index() == 0) {		if (mAnyFunctor.index() == 0) {
	LOG_ALWAYS_FATAL("Not implemented");		return std::make_unique<VkFunctorDrawHandler>(std::get<0>(mAnyFunctor).handle, matrix, clip,
	return nullptr;		image_info);
	} else {		} else {
	return std::make_unique<VkFunctorDrawHandler>(std::get<1>(mAnyFunctor).functor);		LOG_ALWAYS_FATAL("Not implemented");
	}		}
	}		}

libs/hwui/pipeline/skia/VkFunctorDrawable.h

+8 −4

Original line number	Original line	Diff line number	Diff line
	@@ -32,15 +32,18 @@ namespace skiapipeline {
	*/		*/
	class VkFunctorDrawHandler : public FunctorDrawable::GpuDrawHandler {		class VkFunctorDrawHandler : public FunctorDrawable::GpuDrawHandler {
	public:		public:
	explicit VkFunctorDrawHandler(Functor* functor);		VkFunctorDrawHandler(sp<WebViewFunctor::Handle> functor_handle, const SkMatrix& matrix,
			const SkIRect& clip, const SkImageInfo& image_info);
	~VkFunctorDrawHandler() override;		~VkFunctorDrawHandler() override;

	void draw(const GrBackendDrawableInfo& info) override;		void draw(const GrBackendDrawableInfo& info) override;

	private:		private:
	typedef GpuDrawHandler INHERITED;		typedef GpuDrawHandler INHERITED;
			sp<WebViewFunctor::Handle> mFunctorHandle;
	Functor* mFunctor;		const SkMatrix mMatrix;
			const SkIRect mClip;
			const SkImageInfo mImageInfo;
	};		};

	/**		/**
	@@ -57,7 +60,8 @@ protected:
	// SkDrawable functions:		// SkDrawable functions:
	void onDraw(SkCanvas* canvas) override;		void onDraw(SkCanvas* canvas) override;
	std::unique_ptr<FunctorDrawable::GpuDrawHandler> onSnapGpuDrawHandler(		std::unique_ptr<FunctorDrawable::GpuDrawHandler> onSnapGpuDrawHandler(
	GrBackendApi backendApi, const SkMatrix& matrix) override;		GrBackendApi backendApi, const SkMatrix& matrix, const SkIRect& clip,
			const SkImageInfo& image_info) override;
	};		};

	} // namespace skiapipeline		} // namespace skiapipeline