libs/hwui/pipeline/skia/VkFunctorDrawable.cpp

/*
 * Copyright (C) 2018 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 "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>
#include <utils/Trace.h>
#include <utils/TraceUtils.h>
#include <vk/GrVkTypes.h>
#include <thread>
#include "thread/ThreadBase.h"
#include "utils/TimeUtils.h"

namespace android {
namespace uirenderer {
namespace skiapipeline {

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() {
    if (mDrawn) {
        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());

    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;

    mFunctorHandle->drawVk(params);
    mDrawn = true;

    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() {
}

void VkFunctorDrawable::onDraw(SkCanvas* /*canvas*/) {
    LOG_ALWAYS_FATAL("VkFunctorDrawable::onDraw() should never be called.");
    // Instead of calling onDraw(), the call should come from onSnapGpuDrawHandler.
}

std::unique_ptr<FunctorDrawable::GpuDrawHandler> VkFunctorDrawable::onSnapGpuDrawHandler(
        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) {
        return std::make_unique<VkFunctorDrawHandler>(std::get<0>(mAnyFunctor).handle, matrix, clip,
                                                      image_info);
    } else {
        LOG_ALWAYS_FATAL("Not implemented");
    }
}

}  // namespace skiapipeline
}  // namespace uirenderer
}  // namespace android