blob: 2ebd3807382c057a1086eb5f461aff44a0c99b09 [file] [log] [blame]
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "gpu/vulkan/demo/vulkan_demo.h"
#include "base/bind.h"
#include "base/run_loop.h"
#include "base/threading/thread_task_runner_handle.h"
#include "components/viz/common/gpu/vulkan_in_process_context_provider.h"
#include "gpu/vulkan/init/vulkan_factory.h"
#include "gpu/vulkan/vulkan_function_pointers.h"
#include "gpu/vulkan/vulkan_implementation.h"
#include "gpu/vulkan/vulkan_surface.h"
#include "skia/ext/legacy_display_globals.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkFont.h"
#include "third_party/skia/include/core/SkSurface.h"
#include "third_party/skia/include/effects/SkGradientShader.h"
#include "third_party/skia/include/gpu/GrBackendSemaphore.h"
#include "third_party/skia/include/gpu/GrBackendSurface.h"
#include "third_party/skia/include/gpu/GrDirectContext.h"
#include "ui/events/platform/platform_event_source.h"
#include "ui/platform_window/platform_window_init_properties.h"
#include "ui/platform_window/x11/x11_window.h"
namespace gpu {
VulkanDemo::VulkanDemo() = default;
VulkanDemo::~VulkanDemo() = default;
void VulkanDemo::Initialize() {
vulkan_implementation_ = gpu::CreateVulkanImplementation();
DCHECK(vulkan_implementation_) << ":Failed to create vulkan implementation.";
auto result = vulkan_implementation_->InitializeVulkanInstance();
DCHECK(result) << "Failed to initialize vulkan implementation.";
vulkan_context_provider_ =
viz::VulkanInProcessContextProvider::Create(vulkan_implementation_.get());
DCHECK(vulkan_context_provider_)
<< "Failed to create vulkan context provider.";
event_source_ = ui::PlatformEventSource::CreateDefault();
ui::PlatformWindowInitProperties properties;
properties.bounds = gfx::Rect(100, 100, 800, 600);
auto x11_window = std::make_unique<ui::X11Window>(this);
x11_window->Initialize(std::move(properties));
window_ = std::move(x11_window);
window_->Show();
// Sync up size between |window_| and |vulkan_surface_|
vulkan_surface_->Reshape(window_->GetBounds().size(),
gfx::OVERLAY_TRANSFORM_NONE);
sk_surfaces_.resize(vulkan_surface_->swap_chain()->num_images());
}
void VulkanDemo::Destroy() {
VkDevice device =
vulkan_context_provider_->GetDeviceQueue()->GetVulkanDevice();
vkDeviceWaitIdle(device);
vulkan_surface_->Destroy();
}
void VulkanDemo::Run() {
DCHECK(!is_running_);
DCHECK(!run_loop_);
base::RunLoop run_loop;
is_running_ = true;
run_loop_ = &run_loop;
RenderFrame();
run_loop.Run();
run_loop_ = nullptr;
}
void VulkanDemo::OnBoundsChanged(const gfx::Rect& new_bounds) {
if (vulkan_surface_->image_size() == new_bounds.size())
return;
auto generation = vulkan_surface_->swap_chain_generation();
vulkan_surface_->Reshape(new_bounds.size(), gfx::OVERLAY_TRANSFORM_NONE);
if (vulkan_surface_->swap_chain_generation() != generation) {
// Size has been changed, we need to clear all surfaces which will be
// recreated later.
sk_surfaces_.clear();
sk_surfaces_.resize(vulkan_surface_->swap_chain()->num_images());
}
}
void VulkanDemo::OnCloseRequest() {
is_running_ = false;
if (run_loop_)
run_loop_->QuitWhenIdle();
}
void VulkanDemo::OnAcceleratedWidgetAvailable(gfx::AcceleratedWidget widget) {
DCHECK_EQ(accelerated_widget_, gfx::kNullAcceleratedWidget);
accelerated_widget_ = widget;
vulkan_surface_ =
vulkan_implementation_->CreateViewSurface(accelerated_widget_);
DCHECK(vulkan_surface_);
auto result =
vulkan_surface_->Initialize(vulkan_context_provider_->GetDeviceQueue(),
gpu::VulkanSurface::DEFAULT_SURFACE_FORMAT);
DCHECK(result) << "Failed to initialize vulkan surface.";
}
void VulkanDemo::CreateSkSurface() {
scoped_write_.emplace(vulkan_surface_->swap_chain());
auto& sk_surface = sk_surfaces_[scoped_write_->image_index()];
if (!sk_surface) {
SkSurfaceProps surface_props =
skia::LegacyDisplayGlobals::GetSkSurfaceProps();
GrVkImageInfo vk_image_info;
vk_image_info.fImage = scoped_write_->image();
vk_image_info.fImageLayout = scoped_write_->image_layout();
vk_image_info.fImageTiling = VK_IMAGE_TILING_OPTIMAL;
vk_image_info.fFormat = VK_FORMAT_B8G8R8A8_UNORM;
vk_image_info.fImageUsageFlags = scoped_write_->image_usage();
vk_image_info.fSampleCount = 1;
vk_image_info.fLevelCount = 1;
const auto& size = vulkan_surface_->image_size();
GrBackendRenderTarget render_target(size.width(), size.height(), 0,
vk_image_info);
sk_surface = SkSurface::MakeFromBackendRenderTarget(
vulkan_context_provider_->GetGrContext(), render_target,
kTopLeft_GrSurfaceOrigin, kBGRA_8888_SkColorType, nullptr,
&surface_props);
} else {
auto backend = sk_surface->getBackendRenderTarget(
SkSurface::kFlushRead_BackendHandleAccess);
backend.setVkImageLayout(scoped_write_->image_layout());
}
sk_surface_ = sk_surface;
GrBackendSemaphore semaphore;
semaphore.initVulkan(scoped_write_->begin_semaphore());
auto result =
sk_surface_->wait(1, &semaphore, /*deleteSemaphoresAfterWait=*/false);
DCHECK(result);
}
void VulkanDemo::Draw(SkCanvas* canvas, float fraction) {
canvas->save();
canvas->clear(SkColorSetARGB(255, 255 * fraction, 255 * (1 - fraction), 0));
constexpr float kWidth = 800;
constexpr float kHeight = 600;
const auto& size = vulkan_surface_->image_size();
canvas->scale(size.width() / kWidth, size.height() / kHeight);
SkPaint paint;
paint.setColor(SK_ColorRED);
// Draw a rectangle with red paint
SkRect rect = SkRect::MakeXYWH(10, 10, 128, 128);
canvas->drawRect(rect, paint);
// Set up a linear gradient and draw a circle
{
SkPoint linearPoints[] = {{0, 0}, {300, 300}};
SkColor linearColors[] = {SK_ColorGREEN, SK_ColorBLACK};
paint.setShader(SkGradientShader::MakeLinear(
linearPoints, linearColors, nullptr, 2, SkTileMode::kMirror));
paint.setAntiAlias(true);
canvas->drawCircle(200, 200, 64, paint);
// Detach shader
paint.setShader(nullptr);
}
// Draw a message with a nice black paint
paint.setColor(SK_ColorBLACK);
SkFont font;
font.setSize(32);
font.setSubpixel(true);
static const char message[] = "Hello Vulkan";
// Translate and rotate
canvas->translate(300, 300);
rotation_angle_ += 0.2f;
if (rotation_angle_ > 360) {
rotation_angle_ -= 360;
}
canvas->rotate(rotation_angle_);
// Draw the text
canvas->drawString(message, 0, 0, font, paint);
canvas->restore();
}
void VulkanDemo::RenderFrame() {
if (!is_running_)
return;
CreateSkSurface();
Draw(sk_surface_->getCanvas(), 0.7);
GrBackendSemaphore semaphore;
semaphore.initVulkan(scoped_write_->end_semaphore());
GrFlushInfo flush_info = {
.fNumSemaphores = 1,
.fSignalSemaphores = &semaphore,
};
auto queue_index =
vulkan_context_provider_->GetDeviceQueue()->GetVulkanQueueIndex();
GrBackendSurfaceMutableState state(VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
queue_index);
sk_surface_->flush(flush_info, &state);
sk_surface_->recordingContext()->asDirectContext()->submit();
auto backend = sk_surface_->getBackendRenderTarget(
SkSurface::kFlushRead_BackendHandleAccess);
GrVkImageInfo vk_image_info;
if (!backend.getVkImageInfo(&vk_image_info))
NOTREACHED() << "Failed to get image info";
DCHECK_EQ(vk_image_info.fImageLayout, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
scoped_write_.reset();
vulkan_surface_->SwapBuffers();
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::BindOnce(&VulkanDemo::RenderFrame, base::Unretained(this)));
}
} // namespace gpu