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

libs/hwui/WebViewFunctorManager.cpp

+20 −0

Original line number	Diff line number	Diff line
		@@ -86,6 +86,26 @@ void WebViewFunctor::drawGl(const DrawGlInfo& 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() {
		if (mHasContext) {
		mHasContext = false;

libs/hwui/WebViewFunctorManager.h

+9 −0

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

		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:
		friend class WebViewFunctor;

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

		sp<Handle> createHandle() {

libs/hwui/pipeline/skia/SkiaRecordingCanvas.cpp

+0 −2

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

libs/hwui/pipeline/skia/VkFunctorDrawable.cpp

+43 −16

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

		#include "renderthread/VulkanManager.h"
		#include "renderthread/RenderThread.h"
		#include <GrBackendDrawableInfo.h>
		#include <SkImage.h>
		#include <utils/Color.h>
		@@ -31,34 +33,58 @@ namespace android {
		namespace uirenderer {
		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() {
		// TODO(cblume) Fill in the DrawVkInfo parameters.
		(*mFunctor)(DrawVkInfo::kModePostComposite, nullptr);
		mFunctorHandle->postDrawVk();
		}

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

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

		DrawVkInfo draw_vk_info;
		// TODO(cblume) Fill in the rest of the parameters and test the actual call.
		draw_vk_info.isLayer = true;
		SkMatrix44 mat4(mMatrix);
		VkFunctorDrawParams params{
		.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() {
		if (auto lp = std::get_if<LegacyFunctor>(&mAnyFunctor)) {
		if (lp->listener) {
		lp->listener->onGlFunctorReleased(lp->functor);
		}
		}
		}

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

		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) {
		return nullptr;
		}
		std::unique_ptr<VkFunctorDrawHandler> draw;
		if (mAnyFunctor.index() == 0) {
		LOG_ALWAYS_FATAL("Not implemented");
		return nullptr;
		return std::make_unique<VkFunctorDrawHandler>(std::get<0>(mAnyFunctor).handle, matrix, clip,
		image_info);
		} 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	Diff line number	Diff line
		@@ -32,15 +32,18 @@ namespace skiapipeline {
		*/
		class VkFunctorDrawHandler : public FunctorDrawable::GpuDrawHandler {
		public:
		explicit VkFunctorDrawHandler(Functor* functor);
		VkFunctorDrawHandler(sp<WebViewFunctor::Handle> functor_handle, const SkMatrix& matrix,
		const SkIRect& clip, const SkImageInfo& image_info);
		~VkFunctorDrawHandler() override;

		void draw(const GrBackendDrawableInfo& info) override;

		private:
		typedef GpuDrawHandler INHERITED;

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

		/**
		@@ -57,7 +60,8 @@ protected:
		// SkDrawable functions:
		void onDraw(SkCanvas* canvas) override;
		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