1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_OZONE_DEMO_VULKAN_OVERLAY_RENDERER_H_
#define UI_OZONE_DEMO_VULKAN_OVERLAY_RENDERER_H_
#include <vulkan/vulkan_core.h>
#include <array>
#include <memory>
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "ui/gfx/buffer_types.h"
#include "ui/gfx/presentation_feedback.h"
#include "ui/gfx/swap_result.h"
#include "ui/ozone/demo/renderer_base.h"
namespace gfx {
class NativePixmap;
class GpuFence;
} // namespace gfx
namespace gpu {
class VulkanDeviceQueue;
class VulkanImplementation;
class VulkanCommandBuffer;
class VulkanCommandPool;
} // namespace gpu
namespace ui {
class OverlaySurface;
class PlatformWindowSurface;
class SurfaceFactoryOzone;
class VulkanOverlayRenderer : public RendererBase {
public:
VulkanOverlayRenderer(std::unique_ptr<PlatformWindowSurface> window_surface,
std::unique_ptr<OverlaySurface> overlay_surface,
SurfaceFactoryOzone* surface_factory_ozone,
gpu::VulkanImplementation* vulkan_instance,
gfx::AcceleratedWidget widget,
const gfx::Size& size);
VulkanOverlayRenderer(const VulkanOverlayRenderer&) = delete;
VulkanOverlayRenderer& operator=(const VulkanOverlayRenderer&) = delete;
~VulkanOverlayRenderer() override;
// Renderer:
bool Initialize() override;
private:
class Buffer {
public:
Buffer(const gfx::Size& size,
scoped_refptr<gfx::NativePixmap> native_pixmap,
VkDeviceMemory vk_device_memory,
VkImage vk_image,
VkImageView vk_image_view,
VkFramebuffer vk_framebuffer,
std::unique_ptr<gpu::VulkanCommandBuffer> command_buffer,
VkFence fence);
~Buffer();
static std::unique_ptr<Buffer> Create(
SurfaceFactoryOzone* surface_factory_ozone,
gpu::VulkanImplementation* vulkan_implementation,
gpu::VulkanDeviceQueue* vulkan_device_queue,
gpu::VulkanCommandPool* vulkan_command_pool,
VkRenderPass vk_render_pass,
gfx::AcceleratedWidget widget,
const gfx::Size& size);
const gfx::Size& size() const { return size_; }
const scoped_refptr<gfx::NativePixmap>& native_pixmap() const {
return native_pixmap_;
}
VkDeviceMemory vk_device_memory() const { return vk_device_memory_; }
VkImage vk_image() const { return vk_image_; }
VkImageView vk_image_view() const { return vk_image_view_; }
VkFramebuffer vk_framebuffer() const { return vk_framebuffer_; }
gpu::VulkanCommandBuffer* command_buffer() const {
return command_buffer_.get();
}
VkFence fence() const { return fence_; }
private:
const scoped_refptr<gfx::NativePixmap> native_pixmap_;
const gfx::Size size_;
const VkDeviceMemory vk_device_memory_;
const VkImage vk_image_;
const VkImageView vk_image_view_;
const VkFramebuffer vk_framebuffer_;
const std::unique_ptr<gpu::VulkanCommandBuffer> command_buffer_;
const VkFence fence_;
};
void DestroyRenderPass();
void DestroyBuffers();
void RecreateBuffers();
void RenderFrame();
std::unique_ptr<gfx::GpuFence> SubmitFence(VkFence fence);
void SubmitFrame(const Buffer* buffer);
void PostRenderFrameTask();
void OnFrameSubmitted(uint64_t frame_sequence, gfx::SwapResult swap_result);
void OnFramePresented(uint64_t frame_sequence,
const gfx::PresentationFeedback& feedback);
void OnFrameReleased(uint64_t frame_sequence);
uint64_t frame_sequence_ = 0;
int next_buffer_ = 0;
size_t in_use_buffers_ = 0;
std::array<std::unique_ptr<Buffer>, 2> buffers_;
std::unique_ptr<PlatformWindowSurface> window_surface_;
const raw_ptr<SurfaceFactoryOzone> surface_factory_ozone_;
const raw_ptr<gpu::VulkanImplementation> vulkan_implementation_;
std::unique_ptr<gpu::VulkanDeviceQueue> device_queue_;
std::unique_ptr<gpu::VulkanCommandPool> command_pool_;
std::unique_ptr<OverlaySurface> overlay_surface_;
VkRenderPass render_pass_ = VK_NULL_HANDLE;
base::WeakPtrFactory<VulkanOverlayRenderer> weak_ptr_factory_{this};
};
} // namespace ui
#endif // UI_OZONE_DEMO_VULKAN_OVERLAY_RENDERER_H_
|
