blob: 8970a4eebfa2613ceadd30a3772fd29bb22e39bf [file] [log] [blame]
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001/*
Tony-LunarG495604b2019-06-13 15:32:05 -06002 * Copyright (c) 2015-2019 The Khronos Group Inc.
3 * Copyright (c) 2015-2019 Valve Corporation
4 * Copyright (c) 2015-2019 LunarG, Inc.
Dave Houlton5fa47912018-02-16 11:02:26 -07005 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 * Author: Jeremy Hayes <jeremy@lunarg.com>
Charles Giessen74f007d2022-02-08 14:04:45 -070019 * Author: Charles Giessen <charles@lunarg.com>
Dave Houlton5fa47912018-02-16 11:02:26 -070020 */
Richard S. Wright Jra7825742021-01-06 16:02:12 -050021
Jeremy Hayesf56427a2016-09-07 15:55:11 -060022#if defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_XCB_KHR)
23#include <X11/Xutil.h>
Joey Bzdek15eb0702017-06-07 09:40:36 -060024#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
25#include <linux/input.h>
Manuel Stoecklac939332019-06-26 20:55:53 -040026#include "xdg-shell-client-header.h"
27#include "xdg-decoration-client-header.h"
Jeremy Hayesf56427a2016-09-07 15:55:11 -060028#endif
29
30#include <cassert>
Petr Krausbc0ab752017-12-09 00:22:39 +010031#include <cinttypes>
Jeremy Hayesf56427a2016-09-07 15:55:11 -060032#include <cstdio>
33#include <cstdlib>
34#include <cstring>
35#include <csignal>
Charles Giessenc2f1a942022-02-06 23:38:39 -070036
Tony-LunarGd74734f2019-06-04 14:11:43 -060037#include <sstream>
Charles Giessenc2f1a942022-02-06 23:38:39 -070038#include <iostream>
Jeremy Hayesf56427a2016-09-07 15:55:11 -060039#include <memory>
40
41#define VULKAN_HPP_NO_EXCEPTIONS
Shannon McPherson2abb6992019-04-05 10:46:16 -060042#define VULKAN_HPP_TYPESAFE_CONVERSION
Jeremy Hayesf56427a2016-09-07 15:55:11 -060043#include <vulkan/vulkan.hpp>
44#include <vulkan/vk_sdk_platform.h>
45
46#include "linmath.h"
47
48#ifndef NDEBUG
49#define VERIFY(x) assert(x)
50#else
51#define VERIFY(x) ((void)(x))
52#endif
53
Charles Giessen87dd88d2022-02-03 13:46:29 -070054#define APP_SHORT_NAME "vkcubepp"
Jeremy Hayesf56427a2016-09-07 15:55:11 -060055
56// Allow a maximum of two outstanding presentation operations.
Charles Giessenc2f1a942022-02-06 23:38:39 -070057constexpr uint32_t FRAME_LAG = 2;
Jeremy Hayesf56427a2016-09-07 15:55:11 -060058
59#ifdef _WIN32
Mark Lobodzinski85dbd822017-01-26 13:34:13 -070060#define ERR_EXIT(err_msg, err_class) \
61 do { \
62 if (!suppress_popups) MessageBox(nullptr, err_msg, err_class, MB_OK); \
63 exit(1); \
Jeremy Hayesf56427a2016-09-07 15:55:11 -060064 } while (0)
65#else
Mark Lobodzinski85dbd822017-01-26 13:34:13 -070066#define ERR_EXIT(err_msg, err_class) \
67 do { \
Robert Morell4ccc6522017-02-01 14:51:00 -080068 printf("%s\n", err_msg); \
Mark Lobodzinski85dbd822017-01-26 13:34:13 -070069 fflush(stdout); \
70 exit(1); \
Jeremy Hayesf56427a2016-09-07 15:55:11 -060071 } while (0)
72#endif
73
Charles Giessen74f007d2022-02-08 14:04:45 -070074// easier to use the C function for extension functions
75PFN_vkCreateDebugUtilsMessengerEXT pfnVkCreateDebugUtilsMessengerEXT;
76PFN_vkDestroyDebugUtilsMessengerEXT pfnVkDestroyDebugUtilsMessengerEXT;
77VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(VkInstance instance,
78 const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo,
79 const VkAllocationCallbacks *pAllocator,
80 VkDebugUtilsMessengerEXT *pMessenger) {
81 return pfnVkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
82}
83
84VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger,
85 VkAllocationCallbacks const *pAllocator) {
86 return pfnVkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
87}
88
Jeremy Hayes9d304782016-10-09 11:48:12 -060089struct texture_object {
Jeremy Hayesf56427a2016-09-07 15:55:11 -060090 vk::Sampler sampler;
91
92 vk::Image image;
Tony-LunarGbc9fc052018-09-21 13:47:06 -060093 vk::Buffer buffer;
Mark Lobodzinski2dbc2662017-01-26 12:16:30 -070094 vk::ImageLayout imageLayout{vk::ImageLayout::eUndefined};
Jeremy Hayesf56427a2016-09-07 15:55:11 -060095
96 vk::MemoryAllocateInfo mem_alloc;
97 vk::DeviceMemory mem;
98 vk::ImageView view;
99
Charles Giessen3bcefe52022-02-21 11:57:16 -0700100 uint32_t tex_width{0};
101 uint32_t tex_height{0};
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600102};
103
Jeremy Hayes9d304782016-10-09 11:48:12 -0600104static char const *const tex_files[] = {"lunarg.ppm"};
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600105
106static int validation_error = 0;
107
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600108struct vktexcube_vs_uniform {
109 // Must start with MVP
110 float mvp[4][4];
111 float position[12 * 3][4];
112 float attr[12 * 3][4];
113};
114
115//--------------------------------------------------------------------------------------
116// Mesh and VertexFormat Data
117//--------------------------------------------------------------------------------------
118// clang-format off
119static const float g_vertex_buffer_data[] = {
120 -1.0f,-1.0f,-1.0f, // -X side
121 -1.0f,-1.0f, 1.0f,
122 -1.0f, 1.0f, 1.0f,
123 -1.0f, 1.0f, 1.0f,
124 -1.0f, 1.0f,-1.0f,
125 -1.0f,-1.0f,-1.0f,
126
127 -1.0f,-1.0f,-1.0f, // -Z side
128 1.0f, 1.0f,-1.0f,
129 1.0f,-1.0f,-1.0f,
130 -1.0f,-1.0f,-1.0f,
131 -1.0f, 1.0f,-1.0f,
132 1.0f, 1.0f,-1.0f,
133
134 -1.0f,-1.0f,-1.0f, // -Y side
135 1.0f,-1.0f,-1.0f,
136 1.0f,-1.0f, 1.0f,
137 -1.0f,-1.0f,-1.0f,
138 1.0f,-1.0f, 1.0f,
139 -1.0f,-1.0f, 1.0f,
140
141 -1.0f, 1.0f,-1.0f, // +Y side
142 -1.0f, 1.0f, 1.0f,
143 1.0f, 1.0f, 1.0f,
144 -1.0f, 1.0f,-1.0f,
145 1.0f, 1.0f, 1.0f,
146 1.0f, 1.0f,-1.0f,
147
148 1.0f, 1.0f,-1.0f, // +X side
149 1.0f, 1.0f, 1.0f,
150 1.0f,-1.0f, 1.0f,
151 1.0f,-1.0f, 1.0f,
152 1.0f,-1.0f,-1.0f,
153 1.0f, 1.0f,-1.0f,
154
155 -1.0f, 1.0f, 1.0f, // +Z side
156 -1.0f,-1.0f, 1.0f,
157 1.0f, 1.0f, 1.0f,
158 -1.0f,-1.0f, 1.0f,
159 1.0f,-1.0f, 1.0f,
160 1.0f, 1.0f, 1.0f,
161};
162
163static const float g_uv_buffer_data[] = {
164 0.0f, 1.0f, // -X side
165 1.0f, 1.0f,
166 1.0f, 0.0f,
167 1.0f, 0.0f,
168 0.0f, 0.0f,
169 0.0f, 1.0f,
170
171 1.0f, 1.0f, // -Z side
172 0.0f, 0.0f,
173 0.0f, 1.0f,
174 1.0f, 1.0f,
175 1.0f, 0.0f,
176 0.0f, 0.0f,
177
178 1.0f, 0.0f, // -Y side
179 1.0f, 1.0f,
180 0.0f, 1.0f,
181 1.0f, 0.0f,
182 0.0f, 1.0f,
183 0.0f, 0.0f,
184
185 1.0f, 0.0f, // +Y side
186 0.0f, 0.0f,
187 0.0f, 1.0f,
188 1.0f, 0.0f,
189 0.0f, 1.0f,
190 1.0f, 1.0f,
191
192 1.0f, 0.0f, // +X side
193 0.0f, 0.0f,
194 0.0f, 1.0f,
195 0.0f, 1.0f,
196 1.0f, 1.0f,
197 1.0f, 0.0f,
198
199 0.0f, 0.0f, // +Z side
200 0.0f, 1.0f,
201 1.0f, 0.0f,
202 0.0f, 1.0f,
203 1.0f, 1.0f,
204 1.0f, 0.0f,
205};
Jeremy Hayes9d304782016-10-09 11:48:12 -0600206// clang-format on
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600207
Charles Giessen87dd88d2022-02-03 13:46:29 -0700208struct SwapchainImageResources {
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600209 vk::Image image;
210 vk::CommandBuffer cmd;
211 vk::CommandBuffer graphics_to_present_cmd;
212 vk::ImageView view;
Jeremy Hayes00399e32017-06-14 15:07:32 -0600213 vk::Buffer uniform_buffer;
214 vk::DeviceMemory uniform_memory;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700215 void *uniform_memory_ptr = nullptr;
Jeremy Hayes00399e32017-06-14 15:07:32 -0600216 vk::Framebuffer framebuffer;
217 vk::DescriptorSet descriptor_set;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700218};
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600219
Joey Bzdekbaf66472017-06-07 09:37:37 -0600220struct Demo {
Charles Giessenc2f1a942022-02-06 23:38:39 -0700221 void build_image_ownership_cmd(const SwapchainImageResources &swapchain_image_resource);
Charles Giessen87dd88d2022-02-03 13:46:29 -0700222 vk::Bool32 check_layers(const std::vector<const char *> &check_names, const std::vector<vk::LayerProperties> &layers);
Joey Bzdekbaf66472017-06-07 09:37:37 -0600223 void cleanup();
Charles Giessen87dd88d2022-02-03 13:46:29 -0700224 void destroy_swapchain_related_resources();
Joey Bzdekbaf66472017-06-07 09:37:37 -0600225 void create_device();
Charles Giessen87dd88d2022-02-03 13:46:29 -0700226 void destroy_texture(texture_object &tex_objs);
Joey Bzdekbaf66472017-06-07 09:37:37 -0600227 void draw();
Charles Giessen87dd88d2022-02-03 13:46:29 -0700228 void draw_build_cmd(const SwapchainImageResources &swapchain_image_resource);
229 void prepare_init_cmd();
Joey Bzdekbaf66472017-06-07 09:37:37 -0600230 void flush_init_cmd();
Charles Giessenc2f1a942022-02-06 23:38:39 -0700231 void init(int argc, char **argv);
Joey Bzdekbaf66472017-06-07 09:37:37 -0600232 void init_connection();
233 void init_vk();
234 void init_vk_swapchain();
235 void prepare();
236 void prepare_buffers();
237 void prepare_cube_data_buffers();
238 void prepare_depth();
239 void prepare_descriptor_layout();
240 void prepare_descriptor_pool();
241 void prepare_descriptor_set();
242 void prepare_framebuffers();
Charles Giessenc2f1a942022-02-06 23:38:39 -0700243 vk::ShaderModule prepare_shader_module(const uint32_t *code, size_t size);
Petr Kraus9a4eb6a2017-11-30 14:49:20 +0100244 vk::ShaderModule prepare_vs();
Joey Bzdekbaf66472017-06-07 09:37:37 -0600245 vk::ShaderModule prepare_fs();
246 void prepare_pipeline();
247 void prepare_render_pass();
Charles Giessen87dd88d2022-02-03 13:46:29 -0700248 void prepare_texture_image(const char *filename, texture_object &tex_obj, vk::ImageTiling tiling, vk::ImageUsageFlags usage,
249 vk::MemoryPropertyFlags required_props);
250 void prepare_texture_buffer(const char *filename, texture_object &tex_obj);
Joey Bzdekbaf66472017-06-07 09:37:37 -0600251 void prepare_textures();
Petr Kraus9a4eb6a2017-11-30 14:49:20 +0100252
Joey Bzdekbaf66472017-06-07 09:37:37 -0600253 void resize();
Tony-LunarG6cebf142019-09-11 14:32:23 -0600254 void create_surface();
Charles Giessen87dd88d2022-02-03 13:46:29 -0700255 void set_image_layout(vk::Image image, vk::ImageAspectFlags aspectMask, vk::ImageLayout oldLayout, vk::ImageLayout newLayout,
256 vk::AccessFlags srcAccessMask, vk::PipelineStageFlags src_stages, vk::PipelineStageFlags dest_stages);
Joey Bzdekbaf66472017-06-07 09:37:37 -0600257 void update_data_buffer();
Charles Giessen3bcefe52022-02-21 11:57:16 -0700258 bool loadTexture(const char *filename, uint8_t *rgba_data, vk::SubresourceLayout &layout, uint32_t &width, uint32_t &height);
Charles Giessen87dd88d2022-02-03 13:46:29 -0700259 bool memory_type_from_properties(uint32_t typeBits, vk::MemoryPropertyFlags requirements_mask, uint32_t &typeIndex);
Charles Giessen7dc2dd52022-02-03 13:55:48 -0700260 vk::SurfaceFormatKHR pick_surface_format(const std::vector<vk::SurfaceFormatKHR> &surface_formats);
Joey Bzdekbaf66472017-06-07 09:37:37 -0600261
Charles Giessen74f007d2022-02-08 14:04:45 -0700262 static VKAPI_ATTR VkBool32 VKAPI_CALL debug_messenger_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
263 VkDebugUtilsMessageTypeFlagsEXT messageType,
264 const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData,
265 void *pUserData);
266
Joey Bzdekbaf66472017-06-07 09:37:37 -0600267#if defined(VK_USE_PLATFORM_WIN32_KHR)
268 void run();
269 void create_window();
270#elif defined(VK_USE_PLATFORM_XLIB_KHR)
271 void create_xlib_window();
Charles Giessenc2f1a942022-02-06 23:38:39 -0700272 void handle_xlib_event(const XEvent *event);
Joey Bzdekbaf66472017-06-07 09:37:37 -0600273 void run_xlib();
274#elif defined(VK_USE_PLATFORM_XCB_KHR)
Charles Giessenc2f1a942022-02-06 23:38:39 -0700275 void handle_xcb_event(const xcb_generic_event_t *event);
Joey Bzdekbaf66472017-06-07 09:37:37 -0600276 void run_xcb();
277 void create_xcb_window();
278#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
279 void run();
280 void create_window();
Nicolas Caramellic8be8c82020-07-13 17:22:09 +0200281#elif defined(VK_USE_PLATFORM_DIRECTFB_EXT)
Charles Giessenc2f1a942022-02-06 23:38:39 -0700282 void handle_directfb_event(const DFBInputEvent *event);
Nicolas Caramellic8be8c82020-07-13 17:22:09 +0200283 void run_directfb();
284 void create_directfb_window();
Bill Hollings0a0625a2019-07-15 17:39:18 -0400285#elif defined(VK_USE_PLATFORM_METAL_EXT)
Karl Schultz206b1c52018-04-13 18:02:07 -0600286 void run();
Joey Bzdekbaf66472017-06-07 09:37:37 -0600287#elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
288 vk::Result create_display_surface();
289 void run_display();
290#endif
291
Charles Giessenc2f1a942022-02-06 23:38:39 -0700292 std::string name = "vkcubepp"; // Name to put on the window/icon
Joey Bzdekbaf66472017-06-07 09:37:37 -0600293#if defined(VK_USE_PLATFORM_WIN32_KHR)
Charles Giessen87dd88d2022-02-03 13:46:29 -0700294 HINSTANCE connection = nullptr; // hInstance - Windows Instance
295 HWND window = nullptr; // hWnd - window handle
296 POINT minsize = {0, 0}; // minimum window size
Joey Bzdekbaf66472017-06-07 09:37:37 -0600297#elif defined(VK_USE_PLATFORM_XLIB_KHR)
Charles Giessen87dd88d2022-02-03 13:46:29 -0700298 Window xlib_window = 0;
299 Atom xlib_wm_delete_window = 0;
300 Display *display = nullptr;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600301#elif defined(VK_USE_PLATFORM_XCB_KHR)
Charles Giessen87dd88d2022-02-03 13:46:29 -0700302 xcb_window_t xcb_window = 0;
303 xcb_screen_t *screen = nullptr;
304 xcb_connection_t *connection = nullptr;
305 xcb_intern_atom_reply_t *atom_wm_delete_window = nullptr;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600306#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
Charles Giessen87dd88d2022-02-03 13:46:29 -0700307 wl_display *display = nullptr;
308 wl_registry *registry = nullptr;
309 wl_compositor *compositor = nullptr;
310 wl_surface *window = nullptr;
311 xdg_wm_base *wm_base = nullptr;
312 zxdg_decoration_manager_v1 *xdg_decoration_mgr = nullptr;
313 zxdg_toplevel_decoration_v1 *toplevel_decoration = nullptr;
314 xdg_surface *window_surface = nullptr;
315 bool xdg_surface_has_been_configured = false;
316 xdg_toplevel *window_toplevel = nullptr;
317 wl_seat *seat = nullptr;
318 wl_pointer *pointer = nullptr;
319 wl_keyboard *keyboard = nullptr;
Nicolas Caramellic8be8c82020-07-13 17:22:09 +0200320#elif defined(VK_USE_PLATFORM_DIRECTFB_EXT)
Charles Giessen87dd88d2022-02-03 13:46:29 -0700321 IDirectFB *dfb = nullptr;
322 IDirectFBSurface *window = nullptr;
323 IDirectFBEventBuffer *event_buffer = nullptr;
Bill Hollings0a0625a2019-07-15 17:39:18 -0400324#elif defined(VK_USE_PLATFORM_METAL_EXT)
325 void *caMetalLayer;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600326#endif
327
328 vk::SurfaceKHR surface;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700329 bool prepared = false;
330 bool use_staging_buffer = false;
331 bool use_xlib = false;
332 bool separate_present_queue = false;
333 int32_t gpu_number = 0;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600334
335 vk::Instance inst;
Charles Giessen74f007d2022-02-08 14:04:45 -0700336 vk::DebugUtilsMessengerEXT debug_messenger;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600337 vk::PhysicalDevice gpu;
338 vk::Device device;
339 vk::Queue graphics_queue;
340 vk::Queue present_queue;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700341 uint32_t graphics_queue_family_index = 0;
342 uint32_t present_queue_family_index = 0;
343 std::array<vk::Semaphore, FRAME_LAG> image_acquired_semaphores;
344 std::array<vk::Semaphore, FRAME_LAG> draw_complete_semaphores;
345 std::array<vk::Semaphore, FRAME_LAG> image_ownership_semaphores;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600346 vk::PhysicalDeviceProperties gpu_props;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700347 std::vector<vk::QueueFamilyProperties> queue_props;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600348 vk::PhysicalDeviceMemoryProperties memory_properties;
349
Charles Giessen87dd88d2022-02-03 13:46:29 -0700350 std::vector<const char *> enabled_instance_extensions;
351 std::vector<const char *> enabled_layers;
352 std::vector<const char *> enabled_device_extensions;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600353
Charles Giessen3bcefe52022-02-21 11:57:16 -0700354 uint32_t width = 0;
355 uint32_t height = 0;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600356 vk::Format format;
357 vk::ColorSpaceKHR color_space;
358
Joey Bzdekbaf66472017-06-07 09:37:37 -0600359 vk::SwapchainKHR swapchain;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700360 std::vector<SwapchainImageResources> swapchain_image_resources;
361 vk::PresentModeKHR presentMode = vk::PresentModeKHR::eFifo;
362 std::array<vk::Fence, FRAME_LAG> fences;
363 uint32_t frame_index = 0;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600364
365 vk::CommandPool cmd_pool;
366 vk::CommandPool present_cmd_pool;
367
368 struct {
369 vk::Format format;
370 vk::Image image;
371 vk::MemoryAllocateInfo mem_alloc;
372 vk::DeviceMemory mem;
373 vk::ImageView view;
374 } depth;
375
376 static int32_t const texture_count = 1;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700377 std::array<texture_object, texture_count> textures;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600378 texture_object staging_texture;
379
380 struct {
381 vk::Buffer buf;
382 vk::MemoryAllocateInfo mem_alloc;
383 vk::DeviceMemory mem;
384 vk::DescriptorBufferInfo buffer_info;
385 } uniform_data;
386
387 vk::CommandBuffer cmd; // Buffer for initialization commands
388 vk::PipelineLayout pipeline_layout;
389 vk::DescriptorSetLayout desc_layout;
390 vk::PipelineCache pipelineCache;
391 vk::RenderPass render_pass;
392 vk::Pipeline pipeline;
393
Charles Giessenc2f1a942022-02-06 23:38:39 -0700394 mat4x4 projection_matrix = {};
395 mat4x4 view_matrix = {};
396 mat4x4 model_matrix = {};
Joey Bzdekbaf66472017-06-07 09:37:37 -0600397
Charles Giessen87dd88d2022-02-03 13:46:29 -0700398 float spin_angle = 0.0f;
399 float spin_increment = 0.0f;
400 bool pause = false;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600401
402 vk::ShaderModule vert_shader_module;
403 vk::ShaderModule frag_shader_module;
404
405 vk::DescriptorPool desc_pool;
406 vk::DescriptorSet desc_set;
407
Charles Giessen87dd88d2022-02-03 13:46:29 -0700408 std::vector<vk::Framebuffer> framebuffers;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600409
Charles Giessen87dd88d2022-02-03 13:46:29 -0700410 bool quit = false;
411 uint32_t curFrame = 0;
412 uint32_t frameCount = 0;
413 bool validate = false;
Charles Giessen74f007d2022-02-08 14:04:45 -0700414 bool in_callback = false;
415 bool use_debug_messenger = false;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700416 bool use_break = false;
417 bool suppress_popups = false;
418 bool force_errors = false;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600419
Charles Giessen87dd88d2022-02-03 13:46:29 -0700420 uint32_t current_buffer = 0;
Joey Bzdekbaf66472017-06-07 09:37:37 -0600421};
422
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600423#ifdef _WIN32
424// MS-Windows event handling function:
425LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
426#endif
427
Karl Schultz23cc2182016-11-23 17:15:17 -0700428#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
Joey Bzdek15eb0702017-06-07 09:40:36 -0600429static void pointer_handle_enter(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface, wl_fixed_t sx,
430 wl_fixed_t sy) {}
Karl Schultz23cc2182016-11-23 17:15:17 -0700431
Joey Bzdek15eb0702017-06-07 09:40:36 -0600432static void pointer_handle_leave(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface) {}
Karl Schultz23cc2182016-11-23 17:15:17 -0700433
Joey Bzdek15eb0702017-06-07 09:40:36 -0600434static void pointer_handle_motion(void *data, struct wl_pointer *pointer, uint32_t time, wl_fixed_t sx, wl_fixed_t sy) {}
435
436static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer, uint32_t serial, uint32_t time, uint32_t button,
437 uint32_t state) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700438 Demo &demo = *static_cast<Demo *>(data);
Joey Bzdek15eb0702017-06-07 09:40:36 -0600439 if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700440 xdg_toplevel_move(demo.window_toplevel, demo.seat, serial);
Joey Bzdek15eb0702017-06-07 09:40:36 -0600441 }
442}
443
444static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer, uint32_t time, uint32_t axis, wl_fixed_t value) {}
445
446static const struct wl_pointer_listener pointer_listener = {
447 pointer_handle_enter, pointer_handle_leave, pointer_handle_motion, pointer_handle_button, pointer_handle_axis,
448};
449
450static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) {}
451
452static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface,
453 struct wl_array *keys) {}
454
455static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) {}
456
457static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key,
458 uint32_t state) {
459 if (state != WL_KEYBOARD_KEY_STATE_RELEASED) return;
Charles Giessen3bcefe52022-02-21 11:57:16 -0700460 Demo &demo = *static_cast<Demo *>(data);
Joey Bzdek15eb0702017-06-07 09:40:36 -0600461 switch (key) {
462 case KEY_ESC: // Escape
Charles Giessen3bcefe52022-02-21 11:57:16 -0700463 demo.quit = true;
Joey Bzdek15eb0702017-06-07 09:40:36 -0600464 break;
465 case KEY_LEFT: // left arrow key
Charles Giessen3bcefe52022-02-21 11:57:16 -0700466 demo.spin_angle -= demo.spin_increment;
Joey Bzdek15eb0702017-06-07 09:40:36 -0600467 break;
468 case KEY_RIGHT: // right arrow key
Charles Giessen3bcefe52022-02-21 11:57:16 -0700469 demo.spin_angle += demo.spin_increment;
Joey Bzdek15eb0702017-06-07 09:40:36 -0600470 break;
471 case KEY_SPACE: // space bar
Charles Giessen3bcefe52022-02-21 11:57:16 -0700472 demo.pause = !demo.pause;
Joey Bzdek15eb0702017-06-07 09:40:36 -0600473 break;
474 }
475}
476
477static void keyboard_handle_modifiers(void *data, wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed,
478 uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {}
479
480static const struct wl_keyboard_listener keyboard_listener = {
481 keyboard_handle_keymap, keyboard_handle_enter, keyboard_handle_leave, keyboard_handle_key, keyboard_handle_modifiers,
482};
483
484static void seat_handle_capabilities(void *data, wl_seat *seat, uint32_t caps) {
485 // Subscribe to pointer events
Charles Giessen3bcefe52022-02-21 11:57:16 -0700486 Demo &demo = *static_cast<Demo *>(data);
487 if ((caps & WL_SEAT_CAPABILITY_POINTER) && !demo.pointer) {
488 demo.pointer = wl_seat_get_pointer(seat);
489 wl_pointer_add_listener(demo.pointer, &pointer_listener, demo);
490 } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && demo.pointer) {
491 wl_pointer_destroy(demo.pointer);
492 demo.pointer = nullptr;
Joey Bzdek15eb0702017-06-07 09:40:36 -0600493 }
494 // Subscribe to keyboard events
495 if (caps & WL_SEAT_CAPABILITY_KEYBOARD) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700496 demo.keyboard = wl_seat_get_keyboard(seat);
497 wl_keyboard_add_listener(demo.keyboard, &keyboard_listener, demo);
Joey Bzdek15eb0702017-06-07 09:40:36 -0600498 } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700499 wl_keyboard_destroy(demo.keyboard);
500 demo.keyboard = nullptr;
Joey Bzdek15eb0702017-06-07 09:40:36 -0600501 }
502}
503
504static const wl_seat_listener seat_listener = {
505 seat_handle_capabilities,
506};
507
Manuel Stoecklac939332019-06-26 20:55:53 -0400508static void wm_base_ping(void *data, xdg_wm_base *xdg_wm_base, uint32_t serial) { xdg_wm_base_pong(xdg_wm_base, serial); }
509
510static const struct xdg_wm_base_listener wm_base_listener = {wm_base_ping};
511
Joey Bzdek15eb0702017-06-07 09:40:36 -0600512static void registry_handle_global(void *data, wl_registry *registry, uint32_t id, const char *interface, uint32_t version) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700513 Demo &demo = *static_cast<Demo *>(data);
Joey Bzdek15eb0702017-06-07 09:40:36 -0600514 // pickup wayland objects when they appear
Manuel Stoecklac939332019-06-26 20:55:53 -0400515 if (strcmp(interface, wl_compositor_interface.name) == 0) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700516 demo.compositor = (wl_compositor *)wl_registry_bind(registry, id, &wl_compositor_interface, 1);
Manuel Stoecklac939332019-06-26 20:55:53 -0400517 } else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700518 demo.wm_base = (xdg_wm_base *)wl_registry_bind(registry, id, &xdg_wm_base_interface, 1);
519 xdg_wm_base_add_listener(demo.wm_base, &wm_base_listener, nullptr);
Manuel Stoecklac939332019-06-26 20:55:53 -0400520 } else if (strcmp(interface, wl_seat_interface.name) == 0) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700521 demo.seat = (wl_seat *)wl_registry_bind(registry, id, &wl_seat_interface, 1);
522 wl_seat_add_listener(demo.seat, &seat_listener, demo);
Manuel Stoecklac939332019-06-26 20:55:53 -0400523 } else if (strcmp(interface, zxdg_decoration_manager_v1_interface.name) == 0) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700524 demo.xdg_decoration_mgr =
Manuel Stoecklac939332019-06-26 20:55:53 -0400525 (zxdg_decoration_manager_v1 *)wl_registry_bind(registry, id, &zxdg_decoration_manager_v1_interface, 1);
Joey Bzdek15eb0702017-06-07 09:40:36 -0600526 }
527}
528
529static void registry_handle_global_remove(void *data, wl_registry *registry, uint32_t name) {}
530
531static const wl_registry_listener registry_listener = {registry_handle_global, registry_handle_global_remove};
Karl Schultz23cc2182016-11-23 17:15:17 -0700532#endif
533
Charles Giessenc2f1a942022-02-06 23:38:39 -0700534void Demo::build_image_ownership_cmd(const SwapchainImageResources &swapchain_image_resource) {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700535 auto result = swapchain_image_resource.graphics_to_present_cmd.begin(
536 vk::CommandBufferBeginInfo().setFlags(vk::CommandBufferUsageFlagBits::eSimultaneousUse));
Dave Houlton5fa47912018-02-16 11:02:26 -0700537 VERIFY(result == vk::Result::eSuccess);
538
539 auto const image_ownership_barrier =
540 vk::ImageMemoryBarrier()
541 .setSrcAccessMask(vk::AccessFlags())
Tony-LunarG4ba65cd2018-05-30 14:53:14 -0600542 .setDstAccessMask(vk::AccessFlags())
Dave Houlton5fa47912018-02-16 11:02:26 -0700543 .setOldLayout(vk::ImageLayout::ePresentSrcKHR)
544 .setNewLayout(vk::ImageLayout::ePresentSrcKHR)
545 .setSrcQueueFamilyIndex(graphics_queue_family_index)
546 .setDstQueueFamilyIndex(present_queue_family_index)
Charles Giessen87dd88d2022-02-03 13:46:29 -0700547 .setImage(swapchain_image_resource.image)
Dave Houlton5fa47912018-02-16 11:02:26 -0700548 .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
549
Charles Giessen87dd88d2022-02-03 13:46:29 -0700550 swapchain_image_resource.graphics_to_present_cmd.pipelineBarrier(vk::PipelineStageFlagBits::eBottomOfPipe,
551 vk::PipelineStageFlagBits::eBottomOfPipe,
552 vk::DependencyFlagBits(), {}, {}, image_ownership_barrier);
Dave Houlton5fa47912018-02-16 11:02:26 -0700553
Charles Giessen87dd88d2022-02-03 13:46:29 -0700554 result = swapchain_image_resource.graphics_to_present_cmd.end();
Dave Houlton5fa47912018-02-16 11:02:26 -0700555 VERIFY(result == vk::Result::eSuccess);
556}
557
Charles Giessen87dd88d2022-02-03 13:46:29 -0700558vk::Bool32 Demo::check_layers(const std::vector<const char *> &check_names, const std::vector<vk::LayerProperties> &layers) {
559 for (const auto &name : check_names) {
Dave Houlton5fa47912018-02-16 11:02:26 -0700560 vk::Bool32 found = VK_FALSE;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700561 for (const auto &layer : layers) {
562 if (!strcmp(name, layer.layerName)) {
Dave Houlton5fa47912018-02-16 11:02:26 -0700563 found = VK_TRUE;
564 break;
565 }
566 }
567 if (!found) {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700568 fprintf(stderr, "Cannot find layer: %s\n", name);
Dave Houlton5fa47912018-02-16 11:02:26 -0700569 return 0;
570 }
571 }
572 return VK_TRUE;
573}
574
575void Demo::cleanup() {
576 prepared = false;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700577 auto result = device.waitIdle();
578 VERIFY(result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -0700579
Charles Giessen87dd88d2022-02-03 13:46:29 -0700580 destroy_swapchain_related_resources();
Dave Houlton5fa47912018-02-16 11:02:26 -0700581 // Wait for fences from present operations
582 for (uint32_t i = 0; i < FRAME_LAG; i++) {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700583 device.destroyFence(fences[i]);
584 device.destroySemaphore(image_acquired_semaphores[i]);
585 device.destroySemaphore(draw_complete_semaphores[i]);
Dave Houlton5fa47912018-02-16 11:02:26 -0700586 if (separate_present_queue) {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700587 device.destroySemaphore(image_ownership_semaphores[i]);
Dave Houlton5fa47912018-02-16 11:02:26 -0700588 }
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600589 }
590
Charles Giessen87dd88d2022-02-03 13:46:29 -0700591 device.destroySwapchainKHR(swapchain);
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600592
Charles Giessen87dd88d2022-02-03 13:46:29 -0700593 device.destroy();
594 inst.destroySurfaceKHR(surface);
Dave Houlton5fa47912018-02-16 11:02:26 -0700595
596#if defined(VK_USE_PLATFORM_XLIB_KHR)
597 XDestroyWindow(display, xlib_window);
598 XCloseDisplay(display);
599#elif defined(VK_USE_PLATFORM_XCB_KHR)
600 xcb_destroy_window(connection, xcb_window);
601 xcb_disconnect(connection);
602 free(atom_wm_delete_window);
603#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
604 wl_keyboard_destroy(keyboard);
605 wl_pointer_destroy(pointer);
606 wl_seat_destroy(seat);
Manuel Stoecklac939332019-06-26 20:55:53 -0400607 xdg_toplevel_destroy(window_toplevel);
608 xdg_surface_destroy(window_surface);
Dave Houlton5fa47912018-02-16 11:02:26 -0700609 wl_surface_destroy(window);
Manuel Stoecklac939332019-06-26 20:55:53 -0400610 xdg_wm_base_destroy(wm_base);
611 if (xdg_decoration_mgr) {
612 zxdg_toplevel_decoration_v1_destroy(toplevel_decoration);
613 zxdg_decoration_manager_v1_destroy(xdg_decoration_mgr);
614 }
Dave Houlton5fa47912018-02-16 11:02:26 -0700615 wl_compositor_destroy(compositor);
616 wl_registry_destroy(registry);
617 wl_display_disconnect(display);
Nicolas Caramellic8be8c82020-07-13 17:22:09 +0200618#elif defined(VK_USE_PLATFORM_DIRECTFB_EXT)
619 event_buffer->Release(event_buffer);
620 window->Release(window);
621 dfb->Release(dfb);
Dave Houlton5fa47912018-02-16 11:02:26 -0700622#endif
Charles Giessen74f007d2022-02-08 14:04:45 -0700623 if (use_debug_messenger) {
624 inst.destroyDebugUtilsMessengerEXT(debug_messenger);
625 }
Charles Giessen87dd88d2022-02-03 13:46:29 -0700626 inst.destroy();
Dave Houlton5fa47912018-02-16 11:02:26 -0700627}
628
629void Demo::create_device() {
Charles Giessenc2f1a942022-02-06 23:38:39 -0700630 float priorities = 0.0;
Dave Houlton5fa47912018-02-16 11:02:26 -0700631
Charles Giessen87dd88d2022-02-03 13:46:29 -0700632 std::vector<vk::DeviceQueueCreateInfo> queues;
633 queues.push_back(vk::DeviceQueueCreateInfo().setQueueFamilyIndex(graphics_queue_family_index).setQueuePriorities(priorities));
Dave Houlton5fa47912018-02-16 11:02:26 -0700634
635 if (separate_present_queue) {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700636 queues.push_back(
637 vk::DeviceQueueCreateInfo().setQueueFamilyIndex(present_queue_family_index).setQueuePriorities(priorities));
Dave Houlton5fa47912018-02-16 11:02:26 -0700638 }
639
Charles Giessen87dd88d2022-02-03 13:46:29 -0700640 auto deviceInfo = vk::DeviceCreateInfo().setQueueCreateInfos(queues).setPEnabledExtensionNames(enabled_device_extensions);
641 auto device_return = gpu.createDevice(deviceInfo);
642 VERIFY(device_return.result == vk::Result::eSuccess);
643 device = device_return.value;
Dave Houlton5fa47912018-02-16 11:02:26 -0700644}
645
Charles Giessen87dd88d2022-02-03 13:46:29 -0700646void Demo::destroy_texture(texture_object &tex_objs) {
Dave Houlton5fa47912018-02-16 11:02:26 -0700647 // clean up staging resources
Charles Giessen87dd88d2022-02-03 13:46:29 -0700648 device.freeMemory(tex_objs.mem);
649 if (tex_objs.image) device.destroyImage(tex_objs.image);
650 if (tex_objs.buffer) device.destroyBuffer(tex_objs.buffer);
Dave Houlton5fa47912018-02-16 11:02:26 -0700651}
652
653void Demo::draw() {
654 // Ensure no more than FRAME_LAG renderings are outstanding
Charles Giessen87dd88d2022-02-03 13:46:29 -0700655 device.waitForFences(fences[frame_index], VK_TRUE, UINT64_MAX);
Mike Schuchardt7bcbfd32020-05-07 15:33:52 -0700656 device.resetFences({fences[frame_index]});
Dave Houlton5fa47912018-02-16 11:02:26 -0700657
Charles Giessenc2f1a942022-02-06 23:38:39 -0700658 vk::Result acquire_result;
Dave Houlton5fa47912018-02-16 11:02:26 -0700659 do {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700660 acquire_result =
Dave Houlton5fa47912018-02-16 11:02:26 -0700661 device.acquireNextImageKHR(swapchain, UINT64_MAX, image_acquired_semaphores[frame_index], vk::Fence(), &current_buffer);
Charles Giessen87dd88d2022-02-03 13:46:29 -0700662 if (acquire_result == vk::Result::eErrorOutOfDateKHR) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700663 // demo.swapchain is out of date (e.g. the window was resized) and
Dave Houlton5fa47912018-02-16 11:02:26 -0700664 // must be recreated:
665 resize();
Charles Giessen87dd88d2022-02-03 13:46:29 -0700666 } else if (acquire_result == vk::Result::eSuboptimalKHR) {
Dave Houlton5fa47912018-02-16 11:02:26 -0700667 // swapchain is not as optimal as it could be, but the platform's
668 // presentation engine will still present the image correctly.
669 break;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700670 } else if (acquire_result == vk::Result::eErrorSurfaceLostKHR) {
671 inst.destroySurfaceKHR(surface);
Tony-LunarG6cebf142019-09-11 14:32:23 -0600672 create_surface();
673 resize();
Dave Houlton5fa47912018-02-16 11:02:26 -0700674 } else {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700675 VERIFY(acquire_result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -0700676 }
Charles Giessen87dd88d2022-02-03 13:46:29 -0700677 } while (acquire_result != vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -0700678
679 update_data_buffer();
680
681 // Wait for the image acquired semaphore to be signaled to ensure
682 // that the image won't be rendered to until the presentation
683 // engine has fully released ownership to the application, and it is
684 // okay to render to the image.
685 vk::PipelineStageFlags const pipe_stage_flags = vk::PipelineStageFlagBits::eColorAttachmentOutput;
Dave Houlton5fa47912018-02-16 11:02:26 -0700686
Charles Giessen87dd88d2022-02-03 13:46:29 -0700687 auto submit_result = graphics_queue.submit(vk::SubmitInfo()
688 .setWaitDstStageMask(pipe_stage_flags)
689 .setWaitSemaphores(image_acquired_semaphores[frame_index])
690 .setCommandBuffers(swapchain_image_resources[current_buffer].cmd)
691 .setSignalSemaphores(draw_complete_semaphores[frame_index]),
692 fences[frame_index]);
693 VERIFY(submit_result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -0700694
695 if (separate_present_queue) {
696 // If we are using separate queues, change image ownership to the
697 // present queue before presenting, waiting for the draw complete
698 // semaphore and signalling the ownership released semaphore when
699 // finished
Charles Giessen87dd88d2022-02-03 13:46:29 -0700700 auto change_owner_result =
701 present_queue.submit(vk::SubmitInfo()
702 .setWaitDstStageMask(pipe_stage_flags)
703 .setWaitSemaphores(draw_complete_semaphores[frame_index])
704 .setCommandBuffers(swapchain_image_resources[current_buffer].graphics_to_present_cmd)
705 .setSignalSemaphores(image_ownership_semaphores[frame_index]));
706 VERIFY(change_owner_result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -0700707 }
708
709 // If we are using separate queues we have to wait for image ownership,
710 // otherwise wait for draw complete
Charles Giessen87dd88d2022-02-03 13:46:29 -0700711 auto present_result =
712 present_queue.presentKHR(vk::PresentInfoKHR()
713 .setWaitSemaphores(separate_present_queue ? image_ownership_semaphores[frame_index]
714 : draw_complete_semaphores[frame_index])
715 .setSwapchains(swapchain)
716 .setImageIndices(current_buffer));
Dave Houlton5fa47912018-02-16 11:02:26 -0700717 frame_index += 1;
718 frame_index %= FRAME_LAG;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700719 if (present_result == vk::Result::eErrorOutOfDateKHR) {
Dave Houlton5fa47912018-02-16 11:02:26 -0700720 // swapchain is out of date (e.g. the window was resized) and
721 // must be recreated:
722 resize();
Charles Giessen87dd88d2022-02-03 13:46:29 -0700723 } else if (present_result == vk::Result::eSuboptimalKHR) {
Tony-LunarGa8e96342021-06-04 15:12:55 -0600724 // SUBOPTIMAL could be due to resize
725 vk::SurfaceCapabilitiesKHR surfCapabilities;
Charles Giessen87dd88d2022-02-03 13:46:29 -0700726 auto caps_result = gpu.getSurfaceCapabilitiesKHR(surface, &surfCapabilities);
727 VERIFY(caps_result == vk::Result::eSuccess);
Charles Giessen3bcefe52022-02-21 11:57:16 -0700728 if (surfCapabilities.currentExtent.width != width || surfCapabilities.currentExtent.height != height) {
Tony-LunarGa8e96342021-06-04 15:12:55 -0600729 resize();
730 }
Charles Giessen87dd88d2022-02-03 13:46:29 -0700731 } else if (present_result == vk::Result::eErrorSurfaceLostKHR) {
732 inst.destroySurfaceKHR(surface);
Tony-LunarG6cebf142019-09-11 14:32:23 -0600733 create_surface();
734 resize();
Dave Houlton5fa47912018-02-16 11:02:26 -0700735 } else {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700736 VERIFY(present_result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -0700737 }
738}
739
Charles Giessen87dd88d2022-02-03 13:46:29 -0700740void Demo::draw_build_cmd(const SwapchainImageResources &swapchain_image_resource) {
741 const auto commandBuffer = swapchain_image_resource.cmd;
Dave Houlton5fa47912018-02-16 11:02:26 -0700742 vk::ClearValue const clearValues[2] = {vk::ClearColorValue(std::array<float, 4>({{0.2f, 0.2f, 0.2f, 0.2f}})),
743 vk::ClearDepthStencilValue(1.0f, 0u)};
744
Charles Giessen87dd88d2022-02-03 13:46:29 -0700745 auto result = commandBuffer.begin(vk::CommandBufferBeginInfo().setFlags(vk::CommandBufferUsageFlagBits::eSimultaneousUse));
Dave Houlton5fa47912018-02-16 11:02:26 -0700746 VERIFY(result == vk::Result::eSuccess);
747
Charles Giessen87dd88d2022-02-03 13:46:29 -0700748 commandBuffer.beginRenderPass(vk::RenderPassBeginInfo()
749 .setRenderPass(render_pass)
750 .setFramebuffer(swapchain_image_resource.framebuffer)
Charles Giessen3bcefe52022-02-21 11:57:16 -0700751 .setRenderArea(vk::Rect2D(vk::Offset2D{}, vk::Extent2D(width, height)))
Charles Giessen87dd88d2022-02-03 13:46:29 -0700752 .setClearValueCount(2)
753 .setPClearValues(clearValues),
754 vk::SubpassContents::eInline);
755
Dave Houlton5fa47912018-02-16 11:02:26 -0700756 commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline);
Charles Giessen87dd88d2022-02-03 13:46:29 -0700757 commandBuffer.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline_layout, 0, swapchain_image_resource.descriptor_set,
Charles Giessenc2f1a942022-02-06 23:38:39 -0700758 {});
Jeremy Kniager979b5312019-11-22 14:55:57 -0700759 float viewport_dimension;
760 float viewport_x = 0.0f;
761 float viewport_y = 0.0f;
762 if (width < height) {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700763 viewport_dimension = static_cast<float>(width);
Jeremy Kniager979b5312019-11-22 14:55:57 -0700764 viewport_y = (height - width) / 2.0f;
765 } else {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700766 viewport_dimension = static_cast<float>(height);
Jeremy Kniager979b5312019-11-22 14:55:57 -0700767 viewport_x = (width - height) / 2.0f;
768 }
Dave Houlton5fa47912018-02-16 11:02:26 -0700769
Charles Giessen87dd88d2022-02-03 13:46:29 -0700770 commandBuffer.setViewport(0, vk::Viewport()
771 .setX(viewport_x)
772 .setY(viewport_y)
Charles Giessenc2f1a942022-02-06 23:38:39 -0700773 .setWidth(viewport_dimension)
774 .setHeight(viewport_dimension)
775 .setMinDepth(0.0f)
776 .setMaxDepth(1.0f));
Charles Giessen87dd88d2022-02-03 13:46:29 -0700777
Charles Giessen3bcefe52022-02-21 11:57:16 -0700778 commandBuffer.setScissor(0, vk::Rect2D(vk::Offset2D{}, vk::Extent2D(width, height)));
Dave Houlton5fa47912018-02-16 11:02:26 -0700779 commandBuffer.draw(12 * 3, 1, 0, 0);
780 // Note that ending the renderpass changes the image's layout from
781 // COLOR_ATTACHMENT_OPTIMAL to PRESENT_SRC_KHR
782 commandBuffer.endRenderPass();
783
784 if (separate_present_queue) {
785 // We have to transfer ownership from the graphics queue family to
786 // the
787 // present queue family to be able to present. Note that we don't
788 // have
789 // to transfer from present queue family back to graphics queue
790 // family at
791 // the start of the next frame because we don't care about the
792 // image's
793 // contents at that point.
Charles Giessen87dd88d2022-02-03 13:46:29 -0700794 commandBuffer.pipelineBarrier(
795 vk::PipelineStageFlagBits::eBottomOfPipe, vk::PipelineStageFlagBits::eBottomOfPipe, vk::DependencyFlagBits(), {}, {},
Jeremy Hayes9d304782016-10-09 11:48:12 -0600796 vk::ImageMemoryBarrier()
797 .setSrcAccessMask(vk::AccessFlags())
Tony-LunarG4ba65cd2018-05-30 14:53:14 -0600798 .setDstAccessMask(vk::AccessFlags())
Jeremy Hayes9d304782016-10-09 11:48:12 -0600799 .setOldLayout(vk::ImageLayout::ePresentSrcKHR)
800 .setNewLayout(vk::ImageLayout::ePresentSrcKHR)
801 .setSrcQueueFamilyIndex(graphics_queue_family_index)
802 .setDstQueueFamilyIndex(present_queue_family_index)
Charles Giessen87dd88d2022-02-03 13:46:29 -0700803 .setImage(swapchain_image_resource.image)
804 .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1)));
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600805 }
806
Dave Houlton5fa47912018-02-16 11:02:26 -0700807 result = commandBuffer.end();
808 VERIFY(result == vk::Result::eSuccess);
809}
810
Charles Giessen87dd88d2022-02-03 13:46:29 -0700811void Demo::prepare_init_cmd() {
812 auto cmd_pool_return = device.createCommandPool(vk::CommandPoolCreateInfo().setQueueFamilyIndex(graphics_queue_family_index));
813 VERIFY(cmd_pool_return.result == vk::Result::eSuccess);
814 cmd_pool = cmd_pool_return.value;
815
816 auto cmd_return = device.allocateCommandBuffers(vk::CommandBufferAllocateInfo()
817 .setCommandPool(cmd_pool)
818 .setLevel(vk::CommandBufferLevel::ePrimary)
819 .setCommandBufferCount(1));
820 VERIFY(cmd_return.result == vk::Result::eSuccess);
821 cmd = cmd_return.value[0];
822
823 auto result = cmd.begin(vk::CommandBufferBeginInfo());
824 VERIFY(result == vk::Result::eSuccess);
825}
826
Dave Houlton5fa47912018-02-16 11:02:26 -0700827void Demo::flush_init_cmd() {
Dave Houlton5fa47912018-02-16 11:02:26 -0700828 auto result = cmd.end();
829 VERIFY(result == vk::Result::eSuccess);
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600830
Mark Young43c08f82021-11-30 16:38:25 -0700831 auto fenceInfo = vk::FenceCreateInfo();
832 if (force_errors) {
833 // Remove sType to intentionally force validation layer errors.
834 fenceInfo.sType = vk::StructureType::eRenderPassBeginInfo;
835 }
Charles Giessen87dd88d2022-02-03 13:46:29 -0700836 auto fence_return = device.createFence(fenceInfo);
837 VERIFY(fence_return.result == vk::Result::eSuccess);
838 auto fence = fence_return.value;
839
840 result = graphics_queue.submit(vk::SubmitInfo().setCommandBuffers(cmd), fence);
Dave Houlton5fa47912018-02-16 11:02:26 -0700841 VERIFY(result == vk::Result::eSuccess);
842
Charles Giessen87dd88d2022-02-03 13:46:29 -0700843 result = device.waitForFences(fence, VK_TRUE, UINT64_MAX);
Dave Houlton5fa47912018-02-16 11:02:26 -0700844 VERIFY(result == vk::Result::eSuccess);
845
Charles Giessen87dd88d2022-02-03 13:46:29 -0700846 device.freeCommandBuffers(cmd_pool, cmd);
847 device.destroyFence(fence);
Dave Houlton5fa47912018-02-16 11:02:26 -0700848}
849
850void Demo::init(int argc, char **argv) {
851 vec3 eye = {0.0f, 3.0f, 5.0f};
852 vec3 origin = {0, 0, 0};
853 vec3 up = {0.0f, 1.0f, 0.0};
854
855 presentMode = vk::PresentModeKHR::eFifo;
856 frameCount = UINT32_MAX;
Nicolas Caramelli7c25ce92021-01-08 17:46:07 +0100857 width = 500;
858 height = 500;
Dave Houlton5fa47912018-02-16 11:02:26 -0700859 use_xlib = false;
Witold Baryluka3b988f2021-01-07 19:03:02 +0000860 /* Autodetect suitable / best GPU by default */
861 gpu_number = -1;
Tony-LunarG6cebf142019-09-11 14:32:23 -0600862
Dave Houlton5fa47912018-02-16 11:02:26 -0700863 for (int i = 1; i < argc; i++) {
864 if (strcmp(argv[i], "--use_staging") == 0) {
865 use_staging_buffer = true;
866 continue;
867 }
868 if ((strcmp(argv[i], "--present_mode") == 0) && (i < argc - 1)) {
Charles Giessen3bcefe52022-02-21 11:57:16 -0700869 presentMode = static_cast<vk::PresentModeKHR>(atoi(argv[i + 1]));
Dave Houlton5fa47912018-02-16 11:02:26 -0700870 i++;
871 continue;
872 }
873 if (strcmp(argv[i], "--break") == 0) {
874 use_break = true;
875 continue;
876 }
877 if (strcmp(argv[i], "--validate") == 0) {
878 validate = true;
879 continue;
880 }
881 if (strcmp(argv[i], "--xlib") == 0) {
882 fprintf(stderr, "--xlib is deprecated and no longer does anything");
883 continue;
884 }
885 if (strcmp(argv[i], "--c") == 0 && frameCount == UINT32_MAX && i < argc - 1 &&
886 sscanf(argv[i + 1], "%" SCNu32, &frameCount) == 1) {
887 i++;
888 continue;
889 }
Charles Giessen3bcefe52022-02-21 11:57:16 -0700890 if (strcmp(argv[i], "--width") == 0 && i < argc - 1 && sscanf(argv[i + 1], "%" SCNu32, &width) == 1) {
Nicolas Caramelli7c25ce92021-01-08 17:46:07 +0100891 i++;
892 continue;
893 }
Charles Giessen3bcefe52022-02-21 11:57:16 -0700894 if (strcmp(argv[i], "--height") == 0 && i < argc - 1 && sscanf(argv[i + 1], "%" SCNu32, &height) == 1) {
Nicolas Caramelli7c25ce92021-01-08 17:46:07 +0100895 i++;
896 continue;
897 }
Dave Houlton5fa47912018-02-16 11:02:26 -0700898 if (strcmp(argv[i], "--suppress_popups") == 0) {
899 suppress_popups = true;
900 continue;
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600901 }
Tony-LunarG50e737c2020-07-16 14:26:03 -0600902 if ((strcmp(argv[i], "--gpu_number") == 0) && (i < argc - 1)) {
903 gpu_number = atoi(argv[i + 1]);
Witold Baryluka3b988f2021-01-07 19:03:02 +0000904 assert(gpu_number >= 0);
Tony-LunarG50e737c2020-07-16 14:26:03 -0600905 i++;
906 continue;
907 }
Mark Young43c08f82021-11-30 16:38:25 -0700908 if (strcmp(argv[i], "--force_errors") == 0) {
909 force_errors = true;
910 continue;
911 }
Tony-LunarGd74734f2019-06-04 14:11:43 -0600912 std::stringstream usage;
913 usage << "Usage:\n " << APP_SHORT_NAME << "\t[--use_staging] [--validate]\n"
914 << "\t[--break] [--c <framecount>] [--suppress_popups]\n"
Tony-LunarG50e737c2020-07-16 14:26:03 -0600915 << "\t[--gpu_number <index of physical device>]\n"
Tony-LunarGd74734f2019-06-04 14:11:43 -0600916 << "\t[--present_mode <present mode enum>]\n"
Nicolas Caramelli7c25ce92021-01-08 17:46:07 +0100917 << "\t[--width <width>] [--height <height>]\n"
Mark Young43c08f82021-11-30 16:38:25 -0700918 << "\t[--force_errors]\n"
Tony-LunarGd74734f2019-06-04 14:11:43 -0600919 << "\t<present_mode_enum>\n"
920 << "\t\tVK_PRESENT_MODE_IMMEDIATE_KHR = " << VK_PRESENT_MODE_IMMEDIATE_KHR << "\n"
921 << "\t\tVK_PRESENT_MODE_MAILBOX_KHR = " << VK_PRESENT_MODE_MAILBOX_KHR << "\n"
922 << "\t\tVK_PRESENT_MODE_FIFO_KHR = " << VK_PRESENT_MODE_FIFO_KHR << "\n"
Witold Baryluka3b988f2021-01-07 19:03:02 +0000923 << "\t\tVK_PRESENT_MODE_FIFO_RELAXED_KHR = " << VK_PRESENT_MODE_FIFO_RELAXED_KHR << "\n";
Tony-LunarGd74734f2019-06-04 14:11:43 -0600924
925#if defined(_WIN32)
Charles Giessenc2f1a942022-02-06 23:38:39 -0700926 if (!suppress_popups) MessageBox(nullptr, usage.str().c_str(), "Usage Error", MB_OK);
Tony-LunarGd74734f2019-06-04 14:11:43 -0600927#else
928 std::cerr << usage.str();
929 std::cerr.flush();
930#endif
Dave Houlton5fa47912018-02-16 11:02:26 -0700931 exit(1);
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600932 }
933
Dave Houlton5fa47912018-02-16 11:02:26 -0700934 if (!use_xlib) {
935 init_connection();
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600936 }
937
Dave Houlton5fa47912018-02-16 11:02:26 -0700938 init_vk();
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600939
Dave Houlton5fa47912018-02-16 11:02:26 -0700940 spin_angle = 4.0f;
941 spin_increment = 0.2f;
942 pause = false;
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600943
Charles Giessen87dd88d2022-02-03 13:46:29 -0700944 mat4x4_perspective(projection_matrix, static_cast<float>(degreesToRadians(45.0f)), 1.0f, 0.1f, 100.0f);
Dave Houlton5fa47912018-02-16 11:02:26 -0700945 mat4x4_look_at(view_matrix, eye, origin, up);
946 mat4x4_identity(model_matrix);
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600947
Dave Houlton5fa47912018-02-16 11:02:26 -0700948 projection_matrix[1][1] *= -1; // Flip projection matrix from GL to Vulkan orientation.
949}
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600950
Dave Houlton5fa47912018-02-16 11:02:26 -0700951void Demo::init_connection() {
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600952#if defined(VK_USE_PLATFORM_XCB_KHR)
Dave Houlton5fa47912018-02-16 11:02:26 -0700953 const xcb_setup_t *setup;
954 xcb_screen_iterator_t iter;
955 int scr;
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600956
Dave Houlton5fa47912018-02-16 11:02:26 -0700957 const char *display_envar = getenv("DISPLAY");
958 if (display_envar == nullptr || display_envar[0] == '\0') {
959 printf("Environment variable DISPLAY requires a valid value.\nExiting ...\n");
960 fflush(stdout);
961 exit(1);
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600962 }
963
Dave Houlton5fa47912018-02-16 11:02:26 -0700964 connection = xcb_connect(nullptr, &scr);
965 if (xcb_connection_has_error(connection) > 0) {
C Stout05c61712021-08-20 13:19:01 -0700966 printf("Cannot connect to XCB.\nExiting ...\n");
Dave Houlton5fa47912018-02-16 11:02:26 -0700967 fflush(stdout);
968 exit(1);
969 }
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600970
Dave Houlton5fa47912018-02-16 11:02:26 -0700971 setup = xcb_get_setup(connection);
972 iter = xcb_setup_roots_iterator(setup);
973 while (scr-- > 0) xcb_screen_next(&iter);
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600974
Dave Houlton5fa47912018-02-16 11:02:26 -0700975 screen = iter.data;
976#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
977 display = wl_display_connect(nullptr);
Jeremy Hayesf56427a2016-09-07 15:55:11 -0600978
Dave Houlton5fa47912018-02-16 11:02:26 -0700979 if (display == nullptr) {
C Stout05c61712021-08-20 13:19:01 -0700980 printf("Cannot connect to wayland.\nExiting ...\n");
Dave Houlton5fa47912018-02-16 11:02:26 -0700981 fflush(stdout);
982 exit(1);
983 }
984
985 registry = wl_display_get_registry(display);
986 wl_registry_add_listener(registry, &registry_listener, this);
987 wl_display_dispatch(display);
Dave Houlton5fa47912018-02-16 11:02:26 -0700988#endif
989}
Tony-LunarG27c21242021-03-11 16:28:19 -0700990#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
Charles Giessen87dd88d2022-02-03 13:46:29 -0700991int find_display_gpu(int gpu_number, const std::vector<vk::PhysicalDevice> &physical_devices) {
Tony-LunarG27c21242021-03-11 16:28:19 -0700992 uint32_t display_count = 0;
Tony-LunarG27c21242021-03-11 16:28:19 -0700993 int gpu_return = gpu_number;
994 if (gpu_number >= 0) {
Charles Giessenc2f1a942022-02-06 23:38:39 -0700995 auto display_props_return = physical_devices[gpu_number].getDisplayPropertiesKHR();
996 VERIFY(display_props_return.result == vk::Result::eSuccess);
Charles Giessen431f3b52022-03-30 16:17:29 -0600997 display_count = display_props_return.value.size();
Tony-LunarG27c21242021-03-11 16:28:19 -0700998 } else {
Charles Giessen87dd88d2022-02-03 13:46:29 -0700999 for (uint32_t i = 0; i < physical_devices.size(); i++) {
Charles Giessenc2f1a942022-02-06 23:38:39 -07001000 auto display_props_return = physical_devices[i].getDisplayPropertiesKHR();
1001 VERIFY(display_props_return.result == vk::Result::eSuccess);
1002 if (display_props_return.value.size() > 0) {
Charles Giessen431f3b52022-03-30 16:17:29 -06001003 display_count = display_props_return.value.size();
Tony-LunarG27c21242021-03-11 16:28:19 -07001004 gpu_return = i;
1005 break;
1006 }
1007 }
1008 }
1009 if (display_count > 0)
1010 return gpu_return;
1011 else
1012 return -1;
1013}
1014#endif
Charles Giessen74f007d2022-02-08 14:04:45 -07001015VKAPI_ATTR VkBool32 VKAPI_CALL Demo::debug_messenger_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
1016 VkDebugUtilsMessageTypeFlagsEXT messageType,
1017 const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData,
1018 void *pUserData) {
1019 std::ostringstream message;
1020 Demo &demo = *static_cast<Demo *>(pUserData);
1021
1022 if (demo.use_break) {
1023#ifndef WIN32
1024 raise(SIGTRAP);
1025#else
1026 DebugBreak();
1027#endif
1028 }
1029 message << vk::to_string(vk::DebugUtilsMessageSeverityFlagBitsEXT(messageSeverity));
1030 message << " : " + vk::to_string(vk::DebugUtilsMessageTypeFlagsEXT(messageType));
1031
1032 if (vk::DebugUtilsMessageTypeFlagsEXT(messageType) & vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation) {
1033 validation_error = 1;
1034 }
1035
1036 message << " - Message Id Number: " << std::to_string(pCallbackData->messageIdNumber);
1037 message << " | Message Id Name: " << pCallbackData->pMessageIdName << "\n\t" << pCallbackData->pMessage << "\n";
1038
1039 if (pCallbackData->objectCount > 0) {
1040 message << "\n\tObjects - " << pCallbackData->objectCount << "\n";
1041 for (uint32_t object = 0; object < pCallbackData->objectCount; ++object) {
1042 if (NULL != pCallbackData->pObjects[object].pObjectName && strlen(pCallbackData->pObjects[object].pObjectName) > 0) {
1043 message << "\t\tObject[" << object << "] - "
1044 << vk::to_string(vk::ObjectType(pCallbackData->pObjects[object].objectType)) << ", Handle "
1045 << pCallbackData->pObjects[object].objectHandle << ", Name \""
1046 << pCallbackData->pObjects[object].pObjectName << "\"\n";
1047 } else {
1048 message << "\t\tObject[" << object << "] - "
1049 << vk::to_string(vk::ObjectType(pCallbackData->pObjects[object].objectType)) << ", Handle "
1050 << pCallbackData->pObjects[object].objectHandle << "\n";
1051 }
1052 }
1053 }
1054 if (pCallbackData->cmdBufLabelCount > 0) {
1055 message << "\n\tCommand Buffer Labels - " << pCallbackData->cmdBufLabelCount << "\n";
1056 for (uint32_t cmd_buf_label = 0; cmd_buf_label < pCallbackData->cmdBufLabelCount; ++cmd_buf_label) {
1057 message << "\t\tLabel[" << cmd_buf_label << "] - " << pCallbackData->pCmdBufLabels[cmd_buf_label].pLabelName << " { "
1058 << pCallbackData->pCmdBufLabels[cmd_buf_label].color[0] << ", "
1059 << pCallbackData->pCmdBufLabels[cmd_buf_label].color[1] << ", "
1060 << pCallbackData->pCmdBufLabels[cmd_buf_label].color[2] << ", "
1061 << pCallbackData->pCmdBufLabels[cmd_buf_label].color[2] << "}\n";
1062 }
1063 }
1064
1065#ifdef _WIN32
1066
1067 if (!demo.suppress_popups) {
1068 demo.in_callback = true;
1069 auto message_string = message.str();
1070 MessageBox(NULL, message_string.c_str(), "Alert", MB_OK);
1071 demo.in_callback = false;
1072 }
1073
1074#elif defined(ANDROID)
1075
1076 if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
1077 __android_log_print(ANDROID_LOG_INFO, APP_SHORT_NAME, "%s", message.str());
1078 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
1079 __android_log_print(ANDROID_LOG_WARN, APP_SHORT_NAME, "%s", message.str());
1080 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
1081 __android_log_print(ANDROID_LOG_ERROR, APP_SHORT_NAME, "%s", message.str());
1082 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
1083 __android_log_print(ANDROID_LOG_VERBOSE, APP_SHORT_NAME, "%s", message.str());
1084 } else {
1085 __android_log_print(ANDROID_LOG_INFO, APP_SHORT_NAME, "%s", message.str());
1086 }
1087
1088#else
1089 std::cout << message.str() << std::endl; // use endl to force a flush
1090#endif
1091 return false; // Don't bail out, but keep going.
1092}
1093
Dave Houlton5fa47912018-02-16 11:02:26 -07001094void Demo::init_vk() {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001095 std::vector<char const *> instance_validation_layers = {"VK_LAYER_KHRONOS_validation"};
Dave Houlton5fa47912018-02-16 11:02:26 -07001096
Dave Houlton5fa47912018-02-16 11:02:26 -07001097 // Look for validation layers
1098 vk::Bool32 validation_found = VK_FALSE;
1099 if (validate) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001100 auto layers = vk::enumerateInstanceLayerProperties();
1101 VERIFY(layers.result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -07001102
Charles Giessen87dd88d2022-02-03 13:46:29 -07001103 validation_found = check_layers(instance_validation_layers, layers.value);
1104 if (validation_found) {
1105 enabled_layers.push_back("VK_LAYER_KHRONOS_validation");
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001106 }
1107
Charles Giessen87dd88d2022-02-03 13:46:29 -07001108 else {
Mark Lobodzinski85dbd822017-01-26 13:34:13 -07001109 ERR_EXIT(
Dave Houlton5fa47912018-02-16 11:02:26 -07001110 "vkEnumerateInstanceLayerProperties failed to find required validation layer.\n\n"
1111 "Please look at the Getting Started guide for additional information.\n",
Mark Lobodzinski85dbd822017-01-26 13:34:13 -07001112 "vkCreateInstance Failure");
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001113 }
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001114 }
1115
Dave Houlton5fa47912018-02-16 11:02:26 -07001116 /* Look for instance extensions */
1117 vk::Bool32 surfaceExtFound = VK_FALSE;
1118 vk::Bool32 platformSurfaceExtFound = VK_FALSE;
Dave Houlton5fa47912018-02-16 11:02:26 -07001119
Charles Giessen87dd88d2022-02-03 13:46:29 -07001120 auto instance_extensions_return = vk::enumerateInstanceExtensionProperties();
1121 VERIFY(instance_extensions_return.result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -07001122
Charles Giessen87dd88d2022-02-03 13:46:29 -07001123 for (const auto &extension : instance_extensions_return.value) {
1124 if (!strcmp(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, extension.extensionName)) {
1125 enabled_instance_extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
Charles Giessen74f007d2022-02-08 14:04:45 -07001126 } else if (!strcmp(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, extension.extensionName)) {
1127 use_debug_messenger = true;
1128 enabled_instance_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
Charles Giessenc2f1a942022-02-06 23:38:39 -07001129 } else if (!strcmp(VK_KHR_SURFACE_EXTENSION_NAME, extension.extensionName)) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001130 surfaceExtFound = 1;
1131 enabled_instance_extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
1132 }
1133#if defined(VK_USE_PLATFORM_WIN32_KHR)
Charles Giessenc2f1a942022-02-06 23:38:39 -07001134 else if (!strcmp(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, extension.extensionName)) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001135 platformSurfaceExtFound = 1;
1136 enabled_instance_extensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
1137 }
1138#elif defined(VK_USE_PLATFORM_XLIB_KHR)
Charles Giessenc2f1a942022-02-06 23:38:39 -07001139 else if (!strcmp(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, extension.extensionName)) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001140 platformSurfaceExtFound = 1;
1141 enabled_instance_extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
1142 }
1143#elif defined(VK_USE_PLATFORM_XCB_KHR)
Charles Giessenc2f1a942022-02-06 23:38:39 -07001144 else if (!strcmp(VK_KHR_XCB_SURFACE_EXTENSION_NAME, extension.extensionName)) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001145 platformSurfaceExtFound = 1;
1146 enabled_instance_extensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
1147 }
1148#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
Charles Giessenc2f1a942022-02-06 23:38:39 -07001149 else if (!strcmp(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, extension.extensionName)) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001150 platformSurfaceExtFound = 1;
1151 enabled_instance_extensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
1152 }
1153#elif defined(VK_USE_PLATFORM_DIRECTFB_EXT)
Charles Giessenc2f1a942022-02-06 23:38:39 -07001154 else if (!strcmp(VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME, extension.extensionName)) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001155 platformSurfaceExtFound = 1;
1156 enabled_instance_extensions.push_back(VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME);
1157 }
1158#elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
Charles Giessenc2f1a942022-02-06 23:38:39 -07001159 else if (!strcmp(VK_KHR_DISPLAY_EXTENSION_NAME, extension.extensionName)) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001160 platformSurfaceExtFound = 1;
1161 enabled_instance_extensions.push_back(VK_KHR_DISPLAY_EXTENSION_NAME);
1162 }
1163#elif defined(VK_USE_PLATFORM_METAL_EXT)
Charles Giessenc2f1a942022-02-06 23:38:39 -07001164 else if (!strcmp(VK_EXT_METAL_SURFACE_EXTENSION_NAME, extension.extensionName)) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001165 platformSurfaceExtFound = 1;
1166 enabled_instance_extensions.push_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
1167 }
1168#endif
Dave Houlton5fa47912018-02-16 11:02:26 -07001169 }
1170
1171 if (!surfaceExtFound) {
1172 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_SURFACE_EXTENSION_NAME
1173 " extension.\n\n"
1174 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
1175 "Please look at the Getting Started guide for additional information.\n",
1176 "vkCreateInstance Failure");
1177 }
1178
1179 if (!platformSurfaceExtFound) {
1180#if defined(VK_USE_PLATFORM_WIN32_KHR)
1181 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WIN32_SURFACE_EXTENSION_NAME
1182 " extension.\n\n"
1183 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
1184 "Please look at the Getting Started guide for additional information.\n",
1185 "vkCreateInstance Failure");
1186#elif defined(VK_USE_PLATFORM_XCB_KHR)
1187 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XCB_SURFACE_EXTENSION_NAME
1188 " extension.\n\n"
1189 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
1190 "Please look at the Getting Started guide for additional information.\n",
1191 "vkCreateInstance Failure");
1192#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
1193 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME
1194 " extension.\n\n"
1195 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
1196 "Please look at the Getting Started guide for additional information.\n",
1197 "vkCreateInstance Failure");
Tony Barbour153cb062016-12-07 13:43:36 -07001198#elif defined(VK_USE_PLATFORM_XLIB_KHR)
Dave Houlton5fa47912018-02-16 11:02:26 -07001199 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XLIB_SURFACE_EXTENSION_NAME
1200 " extension.\n\n"
1201 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
1202 "Please look at the Getting Started guide for additional information.\n",
1203 "vkCreateInstance Failure");
Nicolas Caramellic8be8c82020-07-13 17:22:09 +02001204#elif defined(VK_USE_PLATFORM_DIRECTFB_EXT)
1205 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME
1206 " extension.\n\n"
1207 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
1208 "Please look at the Getting Started guide for additional information.\n",
1209 "vkCreateInstance Failure");
Damien Leone600c3052017-01-31 10:26:07 -07001210#elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
Dave Houlton5fa47912018-02-16 11:02:26 -07001211 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_DISPLAY_EXTENSION_NAME
1212 " extension.\n\n"
1213 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
1214 "Please look at the Getting Started guide for additional information.\n",
1215 "vkCreateInstance Failure");
Bill Hollings0a0625a2019-07-15 17:39:18 -04001216#elif defined(VK_USE_PLATFORM_METAL_EXT)
1217 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_EXT_METAL_SURFACE_EXTENSION_NAME
Karl Schultz9ceac062017-12-12 10:33:01 -05001218 " extension.\n\nDo you have a compatible "
1219 "Vulkan installable client driver (ICD) installed?\nPlease "
1220 "look at the Getting Started guide for additional "
1221 "information.\n",
1222 "vkCreateInstance Failure");
Tony Barbour153cb062016-12-07 13:43:36 -07001223#endif
Dave Houlton5fa47912018-02-16 11:02:26 -07001224 }
Charles Giessen74f007d2022-02-08 14:04:45 -07001225
1226 vk::DebugUtilsMessageSeverityFlagsEXT severityFlags(vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning |
1227 vk::DebugUtilsMessageSeverityFlagBitsEXT::eError);
1228 vk::DebugUtilsMessageTypeFlagsEXT messageTypeFlags(vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral |
1229 vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance |
1230 vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation);
1231 auto debug_utils_create_info = vk::DebugUtilsMessengerCreateInfoEXT({}, severityFlags, messageTypeFlags,
1232 &debug_messenger_callback, static_cast<void *>(this));
1233
Dave Houlton5fa47912018-02-16 11:02:26 -07001234 auto const app = vk::ApplicationInfo()
1235 .setPApplicationName(APP_SHORT_NAME)
1236 .setApplicationVersion(0)
1237 .setPEngineName(APP_SHORT_NAME)
Charles Giessen87dd88d2022-02-03 13:46:29 -07001238 .setEngineVersion(0);
Dave Houlton5fa47912018-02-16 11:02:26 -07001239 auto const inst_info = vk::InstanceCreateInfo()
Charles Giessen74f007d2022-02-08 14:04:45 -07001240 .setPNext((use_debug_messenger && validate) ? &debug_utils_create_info : nullptr)
Dave Houlton5fa47912018-02-16 11:02:26 -07001241 .setPApplicationInfo(&app)
Charles Giessen87dd88d2022-02-03 13:46:29 -07001242 .setPEnabledLayerNames(enabled_layers)
1243 .setPEnabledExtensionNames(enabled_instance_extensions);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001244
Charles Giessen87dd88d2022-02-03 13:46:29 -07001245 auto instance_result = vk::createInstance(inst_info);
1246 if (instance_result.result == vk::Result::eErrorIncompatibleDriver) {
Dave Houlton5fa47912018-02-16 11:02:26 -07001247 ERR_EXIT(
1248 "Cannot find a compatible Vulkan installable client driver (ICD).\n\n"
1249 "Please look at the Getting Started guide for additional information.\n",
1250 "vkCreateInstance Failure");
Charles Giessen87dd88d2022-02-03 13:46:29 -07001251 } else if (instance_result.result == vk::Result::eErrorExtensionNotPresent) {
Dave Houlton5fa47912018-02-16 11:02:26 -07001252 ERR_EXIT(
1253 "Cannot find a specified extension library.\n"
1254 "Make sure your layers path is set appropriately.\n",
1255 "vkCreateInstance Failure");
Charles Giessen87dd88d2022-02-03 13:46:29 -07001256 } else if (instance_result.result != vk::Result::eSuccess) {
Dave Houlton5fa47912018-02-16 11:02:26 -07001257 ERR_EXIT(
1258 "vkCreateInstance failed.\n\n"
1259 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
1260 "Please look at the Getting Started guide for additional information.\n",
1261 "vkCreateInstance Failure");
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001262 }
Charles Giessen87dd88d2022-02-03 13:46:29 -07001263 inst = instance_result.value;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001264
Charles Giessen74f007d2022-02-08 14:04:45 -07001265 if (use_debug_messenger) {
1266 pfnVkCreateDebugUtilsMessengerEXT =
1267 reinterpret_cast<PFN_vkCreateDebugUtilsMessengerEXT>(inst.getProcAddr("vkCreateDebugUtilsMessengerEXT"));
1268 pfnVkDestroyDebugUtilsMessengerEXT =
1269 reinterpret_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(inst.getProcAddr("vkDestroyDebugUtilsMessengerEXT"));
1270 VERIFY(pfnVkCreateDebugUtilsMessengerEXT != nullptr && pfnVkDestroyDebugUtilsMessengerEXT != nullptr);
1271 auto create_debug_messenger_return = inst.createDebugUtilsMessengerEXT(debug_utils_create_info);
1272 VERIFY(create_debug_messenger_return.result == vk::Result::eSuccess);
1273 debug_messenger = create_debug_messenger_return.value;
1274 }
1275
Charles Giessen87dd88d2022-02-03 13:46:29 -07001276 auto physical_device_return = inst.enumeratePhysicalDevices();
1277 VERIFY(physical_device_return.result == vk::Result::eSuccess);
1278 auto physical_devices = physical_device_return.value;
Dave Houlton5fa47912018-02-16 11:02:26 -07001279
Charles Giessen87dd88d2022-02-03 13:46:29 -07001280 if (physical_devices.size() <= 0) {
Dave Houlton5fa47912018-02-16 11:02:26 -07001281 ERR_EXIT(
1282 "vkEnumeratePhysicalDevices reported zero accessible devices.\n\n"
1283 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
1284 "Please look at the Getting Started guide for additional information.\n",
1285 "vkEnumeratePhysicalDevices Failure");
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001286 }
1287
Charles Giessen87dd88d2022-02-03 13:46:29 -07001288 if (gpu_number >= 0 && !(static_cast<uint32_t>(gpu_number) < physical_devices.size())) {
1289 fprintf(stderr, "GPU %d specified is not present, GPU count = %zu\n", gpu_number, physical_devices.size());
Witold Baryluka3b988f2021-01-07 19:03:02 +00001290 ERR_EXIT("Specified GPU number is not present", "User Error");
1291 }
Tony-LunarG27c21242021-03-11 16:28:19 -07001292#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
Charles Giessen87dd88d2022-02-03 13:46:29 -07001293 gpu_number = find_display_gpu(gpu_number, physical_devices);
Tony-LunarG27c21242021-03-11 16:28:19 -07001294 if (gpu_number < 0) {
1295 printf("Cannot find any display!\n");
1296 fflush(stdout);
1297 exit(1);
1298 }
1299#else
Witold Baryluka3b988f2021-01-07 19:03:02 +00001300 /* Try to auto select most suitable device */
1301 if (gpu_number == -1) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001302 constexpr uint32_t device_type_count = static_cast<uint32_t>(vk::PhysicalDeviceType::eCpu) + 1;
1303 std::array<uint32_t, device_type_count> count_device_type{};
Witold Baryluka3b988f2021-01-07 19:03:02 +00001304
Charles Giessen87dd88d2022-02-03 13:46:29 -07001305 for (uint32_t i = 0; i < physical_devices.size(); i++) {
Witold Baryluka3b988f2021-01-07 19:03:02 +00001306 const auto physicalDeviceProperties = physical_devices[i].getProperties();
Charles Giessen87dd88d2022-02-03 13:46:29 -07001307 assert(physicalDeviceProperties.deviceType <= vk::PhysicalDeviceType::eCpu);
Witold Baryluka3b988f2021-01-07 19:03:02 +00001308 count_device_type[static_cast<int>(physicalDeviceProperties.deviceType)]++;
1309 }
1310
Charles Giessen87dd88d2022-02-03 13:46:29 -07001311 std::array<vk::PhysicalDeviceType, device_type_count> const device_type_preference = {
Witold Baryluka3b988f2021-01-07 19:03:02 +00001312 vk::PhysicalDeviceType::eDiscreteGpu, vk::PhysicalDeviceType::eIntegratedGpu, vk::PhysicalDeviceType::eVirtualGpu,
1313 vk::PhysicalDeviceType::eCpu, vk::PhysicalDeviceType::eOther};
Charles Giessen87dd88d2022-02-03 13:46:29 -07001314
Witold Baryluka3b988f2021-01-07 19:03:02 +00001315 vk::PhysicalDeviceType search_for_device_type = vk::PhysicalDeviceType::eDiscreteGpu;
1316 for (uint32_t i = 0; i < sizeof(device_type_preference) / sizeof(vk::PhysicalDeviceType); i++) {
1317 if (count_device_type[static_cast<int>(device_type_preference[i])]) {
1318 search_for_device_type = device_type_preference[i];
1319 break;
1320 }
1321 }
1322
Charles Giessen87dd88d2022-02-03 13:46:29 -07001323 for (uint32_t i = 0; i < physical_devices.size(); i++) {
Witold Baryluka3b988f2021-01-07 19:03:02 +00001324 const auto physicalDeviceProperties = physical_devices[i].getProperties();
1325 if (physicalDeviceProperties.deviceType == search_for_device_type) {
1326 gpu_number = i;
1327 break;
1328 }
1329 }
1330 }
Tony-LunarG27c21242021-03-11 16:28:19 -07001331#endif
Witold Baryluka3b988f2021-01-07 19:03:02 +00001332 assert(gpu_number >= 0);
1333 gpu = physical_devices[gpu_number];
1334 {
1335 auto physicalDeviceProperties = gpu.getProperties();
1336 fprintf(stderr, "Selected GPU %d: %s, type: %s\n", gpu_number, physicalDeviceProperties.deviceName.data(),
1337 to_string(physicalDeviceProperties.deviceType).c_str());
1338 }
Witold Baryluka3b988f2021-01-07 19:03:02 +00001339
Dave Houlton5fa47912018-02-16 11:02:26 -07001340 /* Look for device extensions */
Dave Houlton5fa47912018-02-16 11:02:26 -07001341 vk::Bool32 swapchainExtFound = VK_FALSE;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001342
Charles Giessen87dd88d2022-02-03 13:46:29 -07001343 auto device_extension_return = gpu.enumerateDeviceExtensionProperties();
1344 VERIFY(device_extension_return.result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -07001345
Charles Giessen87dd88d2022-02-03 13:46:29 -07001346 for (const auto &extension : device_extension_return.value) {
1347 if (!strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, extension.extensionName)) {
1348 swapchainExtFound = 1;
1349 enabled_device_extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
Charles Giessenc2f1a942022-02-06 23:38:39 -07001350 } else if (!strcmp("VK_KHR_portability_subset", extension.extensionName)) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001351 enabled_device_extensions.push_back("VK_KHR_portability_subset");
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001352 }
Dave Houlton5fa47912018-02-16 11:02:26 -07001353 }
Jeremy Hayes6ae1f8a2016-11-16 14:47:13 -07001354
Dave Houlton5fa47912018-02-16 11:02:26 -07001355 if (!swapchainExtFound) {
1356 ERR_EXIT("vkEnumerateDeviceExtensionProperties failed to find the " VK_KHR_SWAPCHAIN_EXTENSION_NAME
1357 " extension.\n\n"
1358 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
1359 "Please look at the Getting Started guide for additional information.\n",
1360 "vkCreateInstance Failure");
1361 }
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001362
Dave Houlton5fa47912018-02-16 11:02:26 -07001363 gpu.getProperties(&gpu_props);
Jeremy Hayes00399e32017-06-14 15:07:32 -06001364
Dave Houlton5fa47912018-02-16 11:02:26 -07001365 /* Call with nullptr data to get count */
Charles Giessen87dd88d2022-02-03 13:46:29 -07001366 queue_props = gpu.getQueueFamilyProperties();
1367 assert(queue_props.size() >= 1);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001368
Dave Houlton5fa47912018-02-16 11:02:26 -07001369 // Query fine-grained feature support for this device.
1370 // If app has specific feature requirements it should check supported
1371 // features based on this query
1372 vk::PhysicalDeviceFeatures physDevFeatures;
1373 gpu.getFeatures(&physDevFeatures);
1374}
1375
Tony-LunarG6cebf142019-09-11 14:32:23 -06001376void Demo::create_surface() {
Dave Houlton5fa47912018-02-16 11:02:26 -07001377// Create a WSI surface for the window:
1378#if defined(VK_USE_PLATFORM_WIN32_KHR)
1379 {
1380 auto const createInfo = vk::Win32SurfaceCreateInfoKHR().setHinstance(connection).setHwnd(window);
1381
1382 auto result = inst.createWin32SurfaceKHR(&createInfo, nullptr, &surface);
1383 VERIFY(result == vk::Result::eSuccess);
1384 }
1385#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
1386 {
1387 auto const createInfo = vk::WaylandSurfaceCreateInfoKHR().setDisplay(display).setSurface(window);
1388
1389 auto result = inst.createWaylandSurfaceKHR(&createInfo, nullptr, &surface);
1390 VERIFY(result == vk::Result::eSuccess);
1391 }
Dave Houlton5fa47912018-02-16 11:02:26 -07001392#elif defined(VK_USE_PLATFORM_XLIB_KHR)
1393 {
1394 auto const createInfo = vk::XlibSurfaceCreateInfoKHR().setDpy(display).setWindow(xlib_window);
1395
1396 auto result = inst.createXlibSurfaceKHR(&createInfo, nullptr, &surface);
1397 VERIFY(result == vk::Result::eSuccess);
1398 }
1399#elif defined(VK_USE_PLATFORM_XCB_KHR)
1400 {
1401 auto const createInfo = vk::XcbSurfaceCreateInfoKHR().setConnection(connection).setWindow(xcb_window);
1402
1403 auto result = inst.createXcbSurfaceKHR(&createInfo, nullptr, &surface);
1404 VERIFY(result == vk::Result::eSuccess);
1405 }
Nicolas Caramellic8be8c82020-07-13 17:22:09 +02001406#elif defined(VK_USE_PLATFORM_DIRECTFB_EXT)
1407 {
1408 auto const createInfo = vk::DirectFBSurfaceCreateInfoEXT().setDfb(dfb).setSurface(window);
1409
1410 auto result = inst.createDirectFBSurfaceEXT(&createInfo, nullptr, &surface);
1411 VERIFY(result == vk::Result::eSuccess);
1412 }
Bill Hollings0a0625a2019-07-15 17:39:18 -04001413#elif defined(VK_USE_PLATFORM_METAL_EXT)
Karl Schultz9ceac062017-12-12 10:33:01 -05001414 {
Bill Hollings0a0625a2019-07-15 17:39:18 -04001415 auto const createInfo = vk::MetalSurfaceCreateInfoEXT().setPLayer(static_cast<CAMetalLayer *>(caMetalLayer));
Karl Schultz9ceac062017-12-12 10:33:01 -05001416
Bill Hollings0a0625a2019-07-15 17:39:18 -04001417 auto result = inst.createMetalSurfaceEXT(&createInfo, nullptr, &surface);
Karl Schultz9ceac062017-12-12 10:33:01 -05001418 VERIFY(result == vk::Result::eSuccess);
1419 }
Dave Houlton5fa47912018-02-16 11:02:26 -07001420#elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
1421 {
1422 auto result = create_display_surface();
1423 VERIFY(result == vk::Result::eSuccess);
1424 }
1425#endif
Tony-LunarG6cebf142019-09-11 14:32:23 -06001426}
1427
1428void Demo::init_vk_swapchain() {
1429 create_surface();
Dave Houlton5fa47912018-02-16 11:02:26 -07001430 // Iterate over each queue to learn whether it supports presenting:
Charles Giessenc2f1a942022-02-06 23:38:39 -07001431 std::vector<vk::Bool32> supportsPresent;
1432 for (uint32_t i = 0; i < static_cast<uint32_t>(queue_props.size()); i++) {
1433 auto supports = gpu.getSurfaceSupportKHR(i, surface);
1434 VERIFY(supports.result == vk::Result::eSuccess);
1435 supportsPresent.push_back(supports.value);
Dave Houlton5fa47912018-02-16 11:02:26 -07001436 }
1437
1438 uint32_t graphicsQueueFamilyIndex = UINT32_MAX;
1439 uint32_t presentQueueFamilyIndex = UINT32_MAX;
Charles Giessenc2f1a942022-02-06 23:38:39 -07001440 for (uint32_t i = 0; i < static_cast<uint32_t>(queue_props.size()); i++) {
Dave Houlton5fa47912018-02-16 11:02:26 -07001441 if (queue_props[i].queueFlags & vk::QueueFlagBits::eGraphics) {
1442 if (graphicsQueueFamilyIndex == UINT32_MAX) {
1443 graphicsQueueFamilyIndex = i;
1444 }
1445
1446 if (supportsPresent[i] == VK_TRUE) {
1447 graphicsQueueFamilyIndex = i;
1448 presentQueueFamilyIndex = i;
Jeremy Hayes00399e32017-06-14 15:07:32 -06001449 break;
1450 }
1451 }
Dave Houlton5fa47912018-02-16 11:02:26 -07001452 }
Jeremy Hayes00399e32017-06-14 15:07:32 -06001453
Dave Houlton5fa47912018-02-16 11:02:26 -07001454 if (presentQueueFamilyIndex == UINT32_MAX) {
1455 // If didn't find a queue that supports both graphics and present,
1456 // then
1457 // find a separate present queue.
Charles Giessen87dd88d2022-02-03 13:46:29 -07001458 for (uint32_t i = 0; i < queue_props.size(); ++i) {
Dave Houlton5fa47912018-02-16 11:02:26 -07001459 if (supportsPresent[i] == VK_TRUE) {
1460 presentQueueFamilyIndex = i;
1461 break;
1462 }
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001463 }
1464 }
1465
Dave Houlton5fa47912018-02-16 11:02:26 -07001466 // Generate error if could not find both a graphics and a present queue
1467 if (graphicsQueueFamilyIndex == UINT32_MAX || presentQueueFamilyIndex == UINT32_MAX) {
1468 ERR_EXIT("Could not find both graphics and present queues\n", "Swapchain Initialization Failure");
1469 }
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001470
Dave Houlton5fa47912018-02-16 11:02:26 -07001471 graphics_queue_family_index = graphicsQueueFamilyIndex;
1472 present_queue_family_index = presentQueueFamilyIndex;
1473 separate_present_queue = (graphics_queue_family_index != present_queue_family_index);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001474
Dave Houlton5fa47912018-02-16 11:02:26 -07001475 create_device();
Jeremy Hayes00399e32017-06-14 15:07:32 -06001476
Charles Giessenc2f1a942022-02-06 23:38:39 -07001477 graphics_queue = device.getQueue(graphics_queue_family_index, 0);
Dave Houlton5fa47912018-02-16 11:02:26 -07001478 if (!separate_present_queue) {
1479 present_queue = graphics_queue;
1480 } else {
Charles Giessenc2f1a942022-02-06 23:38:39 -07001481 present_queue = device.getQueue(present_queue_family_index, 0);
Dave Houlton5fa47912018-02-16 11:02:26 -07001482 }
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001483
Dave Houlton5fa47912018-02-16 11:02:26 -07001484 // Get the list of VkFormat's that are supported:
Charles Giessen87dd88d2022-02-03 13:46:29 -07001485 auto surface_formats_return = gpu.getSurfaceFormatsKHR(surface);
1486 VERIFY(surface_formats_return.result == vk::Result::eSuccess);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001487
Charles Giessen7dc2dd52022-02-03 13:55:48 -07001488 vk::SurfaceFormatKHR surfaceFormat = pick_surface_format(surface_formats_return.value);
1489 format = surfaceFormat.format;
1490 color_space = surfaceFormat.colorSpace;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001491
Dave Houlton5fa47912018-02-16 11:02:26 -07001492 quit = false;
1493 curFrame = 0;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001494
Dave Houlton5fa47912018-02-16 11:02:26 -07001495 // Create semaphores to synchronize acquiring presentable buffers before
1496 // rendering and waiting for drawing to be complete before presenting
1497 auto const semaphoreCreateInfo = vk::SemaphoreCreateInfo();
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001498
Dave Houlton5fa47912018-02-16 11:02:26 -07001499 // Create fences that we can use to throttle if we get too far
1500 // ahead of the image presents
1501 auto const fence_ci = vk::FenceCreateInfo().setFlags(vk::FenceCreateFlagBits::eSignaled);
1502 for (uint32_t i = 0; i < FRAME_LAG; i++) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001503 vk::Result result = device.createFence(&fence_ci, nullptr, &fences[i]);
Dave Houlton5fa47912018-02-16 11:02:26 -07001504 VERIFY(result == vk::Result::eSuccess);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001505
Dave Houlton5fa47912018-02-16 11:02:26 -07001506 result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &image_acquired_semaphores[i]);
1507 VERIFY(result == vk::Result::eSuccess);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001508
Dave Houlton5fa47912018-02-16 11:02:26 -07001509 result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &draw_complete_semaphores[i]);
1510 VERIFY(result == vk::Result::eSuccess);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001511
Dave Houlton5fa47912018-02-16 11:02:26 -07001512 if (separate_present_queue) {
1513 result = device.createSemaphore(&semaphoreCreateInfo, nullptr, &image_ownership_semaphores[i]);
Jeremy Hayes00399e32017-06-14 15:07:32 -06001514 VERIFY(result == vk::Result::eSuccess);
1515 }
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001516 }
Dave Houlton5fa47912018-02-16 11:02:26 -07001517 frame_index = 0;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001518
Dave Houlton5fa47912018-02-16 11:02:26 -07001519 // Get Memory information and properties
Charles Giessen87dd88d2022-02-03 13:46:29 -07001520 memory_properties = gpu.getMemoryProperties();
Dave Houlton5fa47912018-02-16 11:02:26 -07001521}
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001522
Dave Houlton5fa47912018-02-16 11:02:26 -07001523void Demo::prepare() {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001524 prepare_init_cmd();
Dave Houlton5fa47912018-02-16 11:02:26 -07001525
1526 prepare_buffers();
1527 prepare_depth();
1528 prepare_textures();
1529 prepare_cube_data_buffers();
1530
1531 prepare_descriptor_layout();
1532 prepare_render_pass();
1533 prepare_pipeline();
1534
Charles Giessen87dd88d2022-02-03 13:46:29 -07001535 for (auto &swapchain_image_resource : swapchain_image_resources) {
1536 auto alloc_return = device.allocateCommandBuffers(vk::CommandBufferAllocateInfo()
1537 .setCommandPool(cmd_pool)
1538 .setLevel(vk::CommandBufferLevel::ePrimary)
1539 .setCommandBufferCount(1));
1540 VERIFY(alloc_return.result == vk::Result::eSuccess);
1541 swapchain_image_resource.cmd = alloc_return.value[0];
Dave Houlton5fa47912018-02-16 11:02:26 -07001542 }
1543
1544 if (separate_present_queue) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001545 auto present_cmd_pool_return =
1546 device.createCommandPool(vk::CommandPoolCreateInfo().setQueueFamilyIndex(present_queue_family_index));
1547 VERIFY(present_cmd_pool_return.result == vk::Result::eSuccess);
1548 present_cmd_pool = present_cmd_pool_return.value;
Dave Houlton5fa47912018-02-16 11:02:26 -07001549
Charles Giessen87dd88d2022-02-03 13:46:29 -07001550 for (auto &swapchain_image_resource : swapchain_image_resources) {
1551 auto alloc_cmd_return = device.allocateCommandBuffers(vk::CommandBufferAllocateInfo()
1552 .setCommandPool(present_cmd_pool)
1553 .setLevel(vk::CommandBufferLevel::ePrimary)
1554 .setCommandBufferCount(1));
1555 VERIFY(alloc_cmd_return.result == vk::Result::eSuccess);
1556 swapchain_image_resource.graphics_to_present_cmd = alloc_cmd_return.value[0];
1557 build_image_ownership_cmd(swapchain_image_resource);
Dave Houlton5fa47912018-02-16 11:02:26 -07001558 }
1559 }
1560
1561 prepare_descriptor_pool();
1562 prepare_descriptor_set();
1563
1564 prepare_framebuffers();
1565
Charles Giessen87dd88d2022-02-03 13:46:29 -07001566 for (const auto &swapchain_image_resource : swapchain_image_resources) {
1567 draw_build_cmd(swapchain_image_resource);
Dave Houlton5fa47912018-02-16 11:02:26 -07001568 }
1569
1570 /*
1571 * Prepare functions above may generate pipeline commands
1572 * that need to be flushed before beginning the render loop.
1573 */
1574 flush_init_cmd();
Tony-LunarGbc9fc052018-09-21 13:47:06 -06001575 if (staging_texture.buffer) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001576 destroy_texture(staging_texture);
Dave Houlton5fa47912018-02-16 11:02:26 -07001577 }
1578
1579 current_buffer = 0;
1580 prepared = true;
1581}
1582
1583void Demo::prepare_buffers() {
1584 vk::SwapchainKHR oldSwapchain = swapchain;
1585
1586 // Check the surface capabilities and formats
Charles Giessen87dd88d2022-02-03 13:46:29 -07001587 auto surface_capabilities_return = gpu.getSurfaceCapabilitiesKHR(surface);
1588 VERIFY(surface_capabilities_return.result == vk::Result::eSuccess);
1589 auto surfCapabilities = surface_capabilities_return.value;
Dave Houlton5fa47912018-02-16 11:02:26 -07001590
Charles Giessen87dd88d2022-02-03 13:46:29 -07001591 auto present_modes_return = gpu.getSurfacePresentModesKHR(surface);
1592 VERIFY(present_modes_return.result == vk::Result::eSuccess);
1593 auto present_modes = present_modes_return.value;
Dave Houlton5fa47912018-02-16 11:02:26 -07001594
1595 vk::Extent2D swapchainExtent;
1596 // width and height are either both -1, or both not -1.
Charles Giessen87dd88d2022-02-03 13:46:29 -07001597 if (surfCapabilities.currentExtent.width == static_cast<uint32_t>(-1)) {
Dave Houlton5fa47912018-02-16 11:02:26 -07001598 // If the surface size is undefined, the size is set to
1599 // the size of the images requested.
1600 swapchainExtent.width = width;
1601 swapchainExtent.height = height;
1602 } else {
1603 // If the surface size is defined, the swap chain size must match
1604 swapchainExtent = surfCapabilities.currentExtent;
1605 width = surfCapabilities.currentExtent.width;
1606 height = surfCapabilities.currentExtent.height;
1607 }
1608
1609 // The FIFO present mode is guaranteed by the spec to be supported
1610 // and to have no tearing. It's a great default present mode to use.
1611 vk::PresentModeKHR swapchainPresentMode = vk::PresentModeKHR::eFifo;
1612
1613 // There are times when you may wish to use another present mode. The
1614 // following code shows how to select them, and the comments provide some
1615 // reasons you may wish to use them.
1616 //
1617 // It should be noted that Vulkan 1.0 doesn't provide a method for
1618 // synchronizing rendering with the presentation engine's display. There
1619 // is a method provided for throttling rendering with the display, but
1620 // there are some presentation engines for which this method will not work.
1621 // If an application doesn't throttle its rendering, and if it renders much
1622 // faster than the refresh rate of the display, this can waste power on
1623 // mobile devices. That is because power is being spent rendering images
1624 // that may never be seen.
1625
1626 // VK_PRESENT_MODE_IMMEDIATE_KHR is for applications that don't care
1627 // about
1628 // tearing, or have some way of synchronizing their rendering with the
1629 // display.
1630 // VK_PRESENT_MODE_MAILBOX_KHR may be useful for applications that
1631 // generally render a new presentable image every refresh cycle, but are
1632 // occasionally early. In this case, the application wants the new
1633 // image
1634 // to be displayed instead of the previously-queued-for-presentation
1635 // image
1636 // that has not yet been displayed.
1637 // VK_PRESENT_MODE_FIFO_RELAXED_KHR is for applications that generally
1638 // render a new presentable image every refresh cycle, but are
1639 // occasionally
1640 // late. In this case (perhaps because of stuttering/latency concerns),
1641 // the application wants the late image to be immediately displayed,
1642 // even
1643 // though that may mean some tearing.
1644
1645 if (presentMode != swapchainPresentMode) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001646 for (const auto &mode : present_modes) {
1647 if (mode == presentMode) {
1648 swapchainPresentMode = mode;
Dave Houlton5fa47912018-02-16 11:02:26 -07001649 break;
1650 }
1651 }
1652 }
1653
1654 if (swapchainPresentMode != presentMode) {
1655 ERR_EXIT("Present mode specified is not supported\n", "Present mode unsupported");
1656 }
1657
1658 // Determine the number of VkImages to use in the swap chain.
1659 // Application desires to acquire 3 images at a time for triple
1660 // buffering
1661 uint32_t desiredNumOfSwapchainImages = 3;
1662 if (desiredNumOfSwapchainImages < surfCapabilities.minImageCount) {
1663 desiredNumOfSwapchainImages = surfCapabilities.minImageCount;
1664 }
1665
1666 // If maxImageCount is 0, we can ask for as many images as we want,
1667 // otherwise
1668 // we're limited to maxImageCount
1669 if ((surfCapabilities.maxImageCount > 0) && (desiredNumOfSwapchainImages > surfCapabilities.maxImageCount)) {
1670 // Application must settle for fewer images than desired:
1671 desiredNumOfSwapchainImages = surfCapabilities.maxImageCount;
1672 }
1673
1674 vk::SurfaceTransformFlagBitsKHR preTransform;
1675 if (surfCapabilities.supportedTransforms & vk::SurfaceTransformFlagBitsKHR::eIdentity) {
1676 preTransform = vk::SurfaceTransformFlagBitsKHR::eIdentity;
1677 } else {
1678 preTransform = surfCapabilities.currentTransform;
1679 }
1680
1681 // Find a supported composite alpha mode - one of these is guaranteed to be set
1682 vk::CompositeAlphaFlagBitsKHR compositeAlpha = vk::CompositeAlphaFlagBitsKHR::eOpaque;
Charles Giessenc2f1a942022-02-06 23:38:39 -07001683 std::array<vk::CompositeAlphaFlagBitsKHR, 4> compositeAlphaFlags = {
Dave Houlton5fa47912018-02-16 11:02:26 -07001684 vk::CompositeAlphaFlagBitsKHR::eOpaque,
1685 vk::CompositeAlphaFlagBitsKHR::ePreMultiplied,
1686 vk::CompositeAlphaFlagBitsKHR::ePostMultiplied,
1687 vk::CompositeAlphaFlagBitsKHR::eInherit,
1688 };
Charles Giessenc2f1a942022-02-06 23:38:39 -07001689 for (const auto &compositeAlphaFlag : compositeAlphaFlags) {
1690 if (surfCapabilities.supportedCompositeAlpha & compositeAlphaFlag) {
1691 compositeAlpha = compositeAlphaFlag;
Dave Houlton5fa47912018-02-16 11:02:26 -07001692 break;
1693 }
1694 }
1695
Charles Giessen87dd88d2022-02-03 13:46:29 -07001696 auto swapchain_return = device.createSwapchainKHR(vk::SwapchainCreateInfoKHR()
1697 .setSurface(surface)
1698 .setMinImageCount(desiredNumOfSwapchainImages)
1699 .setImageFormat(format)
1700 .setImageColorSpace(color_space)
1701 .setImageExtent({swapchainExtent.width, swapchainExtent.height})
1702 .setImageArrayLayers(1)
1703 .setImageUsage(vk::ImageUsageFlagBits::eColorAttachment)
1704 .setImageSharingMode(vk::SharingMode::eExclusive)
1705 .setPreTransform(preTransform)
1706 .setCompositeAlpha(compositeAlpha)
1707 .setPresentMode(swapchainPresentMode)
1708 .setClipped(true)
1709 .setOldSwapchain(oldSwapchain));
1710 VERIFY(swapchain_return.result == vk::Result::eSuccess);
1711 swapchain = swapchain_return.value;
Dave Houlton5fa47912018-02-16 11:02:26 -07001712
1713 // If we just re-created an existing swapchain, we should destroy the
1714 // old
1715 // swapchain at this point.
1716 // Note: destroying the swapchain also cleans up all its associated
1717 // presentable images once the platform is done with them.
1718 if (oldSwapchain) {
Charles Giessenc2f1a942022-02-06 23:38:39 -07001719 device.destroySwapchainKHR(oldSwapchain);
Dave Houlton5fa47912018-02-16 11:02:26 -07001720 }
1721
Charles Giessen87dd88d2022-02-03 13:46:29 -07001722 auto swapchain_images_return = device.getSwapchainImagesKHR(swapchain);
1723 VERIFY(swapchain_images_return.result == vk::Result::eSuccess);
1724 swapchain_image_resources.resize(swapchain_images_return.value.size());
Dave Houlton5fa47912018-02-16 11:02:26 -07001725
Charles Giessen87dd88d2022-02-03 13:46:29 -07001726 for (uint32_t i = 0; i < swapchain_image_resources.size(); ++i) {
Dave Houlton5fa47912018-02-16 11:02:26 -07001727 auto color_image_view = vk::ImageViewCreateInfo()
1728 .setViewType(vk::ImageViewType::e2D)
1729 .setFormat(format)
1730 .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
1731
Charles Giessen87dd88d2022-02-03 13:46:29 -07001732 swapchain_image_resources[i].image = swapchain_images_return.value[i];
Dave Houlton5fa47912018-02-16 11:02:26 -07001733
1734 color_image_view.image = swapchain_image_resources[i].image;
1735
Charles Giessen87dd88d2022-02-03 13:46:29 -07001736 auto image_view_return = device.createImageView(color_image_view);
1737 VERIFY(image_view_return.result == vk::Result::eSuccess);
1738 swapchain_image_resources[i].view = image_view_return.value;
Dave Houlton5fa47912018-02-16 11:02:26 -07001739 }
1740}
1741
1742void Demo::prepare_cube_data_buffers() {
1743 mat4x4 VP;
1744 mat4x4_mul(VP, projection_matrix, view_matrix);
1745
1746 mat4x4 MVP;
1747 mat4x4_mul(MVP, VP, model_matrix);
1748
1749 vktexcube_vs_uniform data;
1750 memcpy(data.mvp, MVP, sizeof(MVP));
1751 // dumpMatrix("MVP", MVP)
1752
1753 for (int32_t i = 0; i < 12 * 3; i++) {
1754 data.position[i][0] = g_vertex_buffer_data[i * 3];
1755 data.position[i][1] = g_vertex_buffer_data[i * 3 + 1];
1756 data.position[i][2] = g_vertex_buffer_data[i * 3 + 2];
1757 data.position[i][3] = 1.0f;
1758 data.attr[i][0] = g_uv_buffer_data[2 * i];
1759 data.attr[i][1] = g_uv_buffer_data[2 * i + 1];
1760 data.attr[i][2] = 0;
1761 data.attr[i][3] = 0;
1762 }
1763
1764 auto const buf_info = vk::BufferCreateInfo().setSize(sizeof(data)).setUsage(vk::BufferUsageFlagBits::eUniformBuffer);
1765
Charles Giessen87dd88d2022-02-03 13:46:29 -07001766 for (auto &swapchain_image_resource : swapchain_image_resources) {
1767 auto result = device.createBuffer(&buf_info, nullptr, &swapchain_image_resource.uniform_buffer);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001768 VERIFY(result == vk::Result::eSuccess);
1769
1770 vk::MemoryRequirements mem_reqs;
Charles Giessen87dd88d2022-02-03 13:46:29 -07001771 device.getBufferMemoryRequirements(swapchain_image_resource.uniform_buffer, &mem_reqs);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001772
Dave Houlton5fa47912018-02-16 11:02:26 -07001773 auto mem_alloc = vk::MemoryAllocateInfo().setAllocationSize(mem_reqs.size).setMemoryTypeIndex(0);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001774
Dave Houlton5fa47912018-02-16 11:02:26 -07001775 bool const pass = memory_type_from_properties(
1776 mem_reqs.memoryTypeBits, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent,
Charles Giessen87dd88d2022-02-03 13:46:29 -07001777 mem_alloc.memoryTypeIndex);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001778 VERIFY(pass);
1779
Charles Giessen87dd88d2022-02-03 13:46:29 -07001780 result = device.allocateMemory(&mem_alloc, nullptr, &swapchain_image_resource.uniform_memory);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001781 VERIFY(result == vk::Result::eSuccess);
1782
Charles Giessen87dd88d2022-02-03 13:46:29 -07001783 result = device.mapMemory(swapchain_image_resource.uniform_memory, 0, VK_WHOLE_SIZE, vk::MemoryMapFlags(),
1784 &swapchain_image_resource.uniform_memory_ptr);
Tony-LunarG37af49f2019-12-19 12:04:19 -07001785 VERIFY(result == vk::Result::eSuccess);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001786
Charles Giessen87dd88d2022-02-03 13:46:29 -07001787 memcpy(swapchain_image_resource.uniform_memory_ptr, &data, sizeof data);
Dave Houlton5fa47912018-02-16 11:02:26 -07001788
Charles Giessen87dd88d2022-02-03 13:46:29 -07001789 result = device.bindBufferMemory(swapchain_image_resource.uniform_buffer, swapchain_image_resource.uniform_memory, 0);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001790 VERIFY(result == vk::Result::eSuccess);
1791 }
Dave Houlton5fa47912018-02-16 11:02:26 -07001792}
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001793
Dave Houlton5fa47912018-02-16 11:02:26 -07001794void Demo::prepare_depth() {
1795 depth.format = vk::Format::eD16Unorm;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001796
Dave Houlton5fa47912018-02-16 11:02:26 -07001797 auto const image = vk::ImageCreateInfo()
1798 .setImageType(vk::ImageType::e2D)
1799 .setFormat(depth.format)
Charles Giessen3bcefe52022-02-21 11:57:16 -07001800 .setExtent({width, height, 1})
Dave Houlton5fa47912018-02-16 11:02:26 -07001801 .setMipLevels(1)
1802 .setArrayLayers(1)
1803 .setSamples(vk::SampleCountFlagBits::e1)
1804 .setTiling(vk::ImageTiling::eOptimal)
1805 .setUsage(vk::ImageUsageFlagBits::eDepthStencilAttachment)
1806 .setSharingMode(vk::SharingMode::eExclusive)
Dave Houlton5fa47912018-02-16 11:02:26 -07001807 .setInitialLayout(vk::ImageLayout::eUndefined);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001808
Dave Houlton5fa47912018-02-16 11:02:26 -07001809 auto result = device.createImage(&image, nullptr, &depth.image);
1810 VERIFY(result == vk::Result::eSuccess);
1811
1812 vk::MemoryRequirements mem_reqs;
1813 device.getImageMemoryRequirements(depth.image, &mem_reqs);
1814
1815 depth.mem_alloc.setAllocationSize(mem_reqs.size);
1816 depth.mem_alloc.setMemoryTypeIndex(0);
1817
1818 auto const pass = memory_type_from_properties(mem_reqs.memoryTypeBits, vk::MemoryPropertyFlagBits::eDeviceLocal,
Charles Giessen87dd88d2022-02-03 13:46:29 -07001819 depth.mem_alloc.memoryTypeIndex);
Dave Houlton5fa47912018-02-16 11:02:26 -07001820 VERIFY(pass);
1821
1822 result = device.allocateMemory(&depth.mem_alloc, nullptr, &depth.mem);
1823 VERIFY(result == vk::Result::eSuccess);
1824
1825 result = device.bindImageMemory(depth.image, depth.mem, 0);
1826 VERIFY(result == vk::Result::eSuccess);
1827
Mark Young43c08f82021-11-30 16:38:25 -07001828 auto view = vk::ImageViewCreateInfo()
Charles Giessen87dd88d2022-02-03 13:46:29 -07001829 .setImage(depth.image)
1830 .setViewType(vk::ImageViewType::e2D)
1831 .setFormat(depth.format)
1832 .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eDepth, 0, 1, 0, 1));
Mark Young43c08f82021-11-30 16:38:25 -07001833 if (force_errors) {
1834 // Intentionally force a bad pNext value to generate a validation layer error
1835 view.pNext = &image;
1836 }
Dave Houlton5fa47912018-02-16 11:02:26 -07001837 result = device.createImageView(&view, nullptr, &depth.view);
1838 VERIFY(result == vk::Result::eSuccess);
1839}
1840
1841void Demo::prepare_descriptor_layout() {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001842 std::array<vk::DescriptorSetLayoutBinding, 2> const layout_bindings = {
1843 vk::DescriptorSetLayoutBinding()
1844 .setBinding(0)
1845 .setDescriptorType(vk::DescriptorType::eUniformBuffer)
1846 .setDescriptorCount(1)
1847 .setStageFlags(vk::ShaderStageFlagBits::eVertex)
1848 .setPImmutableSamplers(nullptr),
1849 vk::DescriptorSetLayoutBinding()
1850 .setBinding(1)
1851 .setDescriptorType(vk::DescriptorType::eCombinedImageSampler)
1852 .setDescriptorCount(texture_count)
1853 .setStageFlags(vk::ShaderStageFlagBits::eFragment)
1854 .setPImmutableSamplers(nullptr)};
Dave Houlton5fa47912018-02-16 11:02:26 -07001855
Charles Giessen87dd88d2022-02-03 13:46:29 -07001856 auto const descriptor_layout = vk::DescriptorSetLayoutCreateInfo().setBindings(layout_bindings);
Dave Houlton5fa47912018-02-16 11:02:26 -07001857
1858 auto result = device.createDescriptorSetLayout(&descriptor_layout, nullptr, &desc_layout);
1859 VERIFY(result == vk::Result::eSuccess);
1860
Charles Giessen87dd88d2022-02-03 13:46:29 -07001861 auto const pPipelineLayoutCreateInfo = vk::PipelineLayoutCreateInfo().setSetLayouts(desc_layout);
Dave Houlton5fa47912018-02-16 11:02:26 -07001862
1863 result = device.createPipelineLayout(&pPipelineLayoutCreateInfo, nullptr, &pipeline_layout);
1864 VERIFY(result == vk::Result::eSuccess);
1865}
1866
1867void Demo::prepare_descriptor_pool() {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001868 std::array<vk::DescriptorPoolSize, 2> const poolSizes = {
1869 vk::DescriptorPoolSize()
1870 .setType(vk::DescriptorType::eUniformBuffer)
1871 .setDescriptorCount(static_cast<uint32_t>(swapchain_image_resources.size())),
Dave Houlton5fa47912018-02-16 11:02:26 -07001872 vk::DescriptorPoolSize()
1873 .setType(vk::DescriptorType::eCombinedImageSampler)
Charles Giessen87dd88d2022-02-03 13:46:29 -07001874 .setDescriptorCount(static_cast<uint32_t>(swapchain_image_resources.size()) * texture_count)};
Dave Houlton5fa47912018-02-16 11:02:26 -07001875
1876 auto const descriptor_pool =
Charles Giessen87dd88d2022-02-03 13:46:29 -07001877 vk::DescriptorPoolCreateInfo().setMaxSets(static_cast<uint32_t>(swapchain_image_resources.size())).setPoolSizes(poolSizes);
Dave Houlton5fa47912018-02-16 11:02:26 -07001878
1879 auto result = device.createDescriptorPool(&descriptor_pool, nullptr, &desc_pool);
1880 VERIFY(result == vk::Result::eSuccess);
1881}
1882
1883void Demo::prepare_descriptor_set() {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001884 auto const alloc_info = vk::DescriptorSetAllocateInfo().setDescriptorPool(desc_pool).setSetLayouts(desc_layout);
Dave Houlton5fa47912018-02-16 11:02:26 -07001885
Charles Giessen87dd88d2022-02-03 13:46:29 -07001886 auto buffer_info = vk::DescriptorBufferInfo().setOffset(0).setRange(sizeof(vktexcube_vs_uniform));
Dave Houlton5fa47912018-02-16 11:02:26 -07001887
Charles Giessen87dd88d2022-02-03 13:46:29 -07001888 std::array<vk::DescriptorImageInfo, texture_count> tex_descs;
Dave Houlton5fa47912018-02-16 11:02:26 -07001889 for (uint32_t i = 0; i < texture_count; i++) {
1890 tex_descs[i].setSampler(textures[i].sampler);
1891 tex_descs[i].setImageView(textures[i].view);
Karl Schultze88bc842018-09-11 16:23:14 -06001892 tex_descs[i].setImageLayout(vk::ImageLayout::eShaderReadOnlyOptimal);
Dave Houlton5fa47912018-02-16 11:02:26 -07001893 }
1894
Charles Giessenc2f1a942022-02-06 23:38:39 -07001895 std::array<vk::WriteDescriptorSet, 2> writes;
Charles Giessen87dd88d2022-02-03 13:46:29 -07001896 writes[0].setDescriptorCount(1).setDescriptorType(vk::DescriptorType::eUniformBuffer).setPBufferInfo(&buffer_info);
Charles Giessen87dd88d2022-02-03 13:46:29 -07001897 writes[1]
1898 .setDstBinding(1)
1899 .setDescriptorCount(texture_count)
1900 .setDescriptorType(vk::DescriptorType::eCombinedImageSampler)
1901 .setImageInfo(tex_descs);
Dave Houlton5fa47912018-02-16 11:02:26 -07001902
Charles Giessen87dd88d2022-02-03 13:46:29 -07001903 for (auto &swapchain_image_resource : swapchain_image_resources) {
1904 auto result = device.allocateDescriptorSets(&alloc_info, &swapchain_image_resource.descriptor_set);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001905 VERIFY(result == vk::Result::eSuccess);
1906
Charles Giessen87dd88d2022-02-03 13:46:29 -07001907 buffer_info.setBuffer(swapchain_image_resource.uniform_buffer);
1908 writes[0].setDstSet(swapchain_image_resource.descriptor_set);
1909 writes[1].setDstSet(swapchain_image_resource.descriptor_set);
Charles Giessenc2f1a942022-02-06 23:38:39 -07001910 device.updateDescriptorSets(writes, {});
Dave Houlton5fa47912018-02-16 11:02:26 -07001911 }
1912}
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001913
Dave Houlton5fa47912018-02-16 11:02:26 -07001914void Demo::prepare_framebuffers() {
Charles Giessen87dd88d2022-02-03 13:46:29 -07001915 std::array<vk::ImageView, 2> attachments;
Dave Houlton5fa47912018-02-16 11:02:26 -07001916 attachments[1] = depth.view;
1917
Charles Giessen87dd88d2022-02-03 13:46:29 -07001918 for (auto &swapchain_image_resource : swapchain_image_resources) {
1919 attachments[0] = swapchain_image_resource.view;
1920 auto const framebuffer_return = device.createFramebuffer(vk::FramebufferCreateInfo()
1921 .setRenderPass(render_pass)
1922 .setAttachments(attachments)
Charles Giessen3bcefe52022-02-21 11:57:16 -07001923 .setWidth(width)
1924 .setHeight(height)
Charles Giessen87dd88d2022-02-03 13:46:29 -07001925 .setLayers(1));
1926 VERIFY(framebuffer_return.result == vk::Result::eSuccess);
1927 swapchain_image_resource.framebuffer = framebuffer_return.value;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001928 }
Dave Houlton5fa47912018-02-16 11:02:26 -07001929}
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001930
Dave Houlton5fa47912018-02-16 11:02:26 -07001931vk::ShaderModule Demo::prepare_fs() {
1932 const uint32_t fragShaderCode[] = {
Petr Kraus9a4eb6a2017-11-30 14:49:20 +01001933#include "cube.frag.inc"
Dave Houlton5fa47912018-02-16 11:02:26 -07001934 };
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001935
Dave Houlton5fa47912018-02-16 11:02:26 -07001936 frag_shader_module = prepare_shader_module(fragShaderCode, sizeof(fragShaderCode));
Jeremy Hayesf56427a2016-09-07 15:55:11 -06001937
Dave Houlton5fa47912018-02-16 11:02:26 -07001938 return frag_shader_module;
1939}
1940
1941void Demo::prepare_pipeline() {
1942 vk::PipelineCacheCreateInfo const pipelineCacheInfo;
1943 auto result = device.createPipelineCache(&pipelineCacheInfo, nullptr, &pipelineCache);
1944 VERIFY(result == vk::Result::eSuccess);
1945
Charles Giessen87dd88d2022-02-03 13:46:29 -07001946 std::array<vk::PipelineShaderStageCreateInfo, 2> const shaderStageInfo = {
Dave Houlton5fa47912018-02-16 11:02:26 -07001947 vk::PipelineShaderStageCreateInfo().setStage(vk::ShaderStageFlagBits::eVertex).setModule(prepare_vs()).setPName("main"),
1948 vk::PipelineShaderStageCreateInfo().setStage(vk::ShaderStageFlagBits::eFragment).setModule(prepare_fs()).setPName("main")};
1949
1950 vk::PipelineVertexInputStateCreateInfo const vertexInputInfo;
1951
1952 auto const inputAssemblyInfo = vk::PipelineInputAssemblyStateCreateInfo().setTopology(vk::PrimitiveTopology::eTriangleList);
1953
1954 // TODO: Where are pViewports and pScissors set?
1955 auto const viewportInfo = vk::PipelineViewportStateCreateInfo().setViewportCount(1).setScissorCount(1);
1956
1957 auto const rasterizationInfo = vk::PipelineRasterizationStateCreateInfo()
1958 .setDepthClampEnable(VK_FALSE)
1959 .setRasterizerDiscardEnable(VK_FALSE)
1960 .setPolygonMode(vk::PolygonMode::eFill)
1961 .setCullMode(vk::CullModeFlagBits::eBack)
1962 .setFrontFace(vk::FrontFace::eCounterClockwise)
1963 .setDepthBiasEnable(VK_FALSE)
1964 .setLineWidth(1.0f);
1965
1966 auto const multisampleInfo = vk::PipelineMultisampleStateCreateInfo();
1967
1968 auto const stencilOp =
1969 vk::StencilOpState().setFailOp(vk::StencilOp::eKeep).setPassOp(vk::StencilOp::eKeep).setCompareOp(vk::CompareOp::eAlways);
1970
1971 auto const depthStencilInfo = vk::PipelineDepthStencilStateCreateInfo()
1972 .setDepthTestEnable(VK_TRUE)
1973 .setDepthWriteEnable(VK_TRUE)
1974 .setDepthCompareOp(vk::CompareOp::eLessOrEqual)
1975 .setDepthBoundsTestEnable(VK_FALSE)
1976 .setStencilTestEnable(VK_FALSE)
1977 .setFront(stencilOp)
1978 .setBack(stencilOp);
1979
Charles Giessen87dd88d2022-02-03 13:46:29 -07001980 std::array<vk::PipelineColorBlendAttachmentState, 1> const colorBlendAttachments = {
Dave Houlton5fa47912018-02-16 11:02:26 -07001981 vk::PipelineColorBlendAttachmentState().setColorWriteMask(vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG |
1982 vk::ColorComponentFlagBits::eB | vk::ColorComponentFlagBits::eA)};
1983
Charles Giessen87dd88d2022-02-03 13:46:29 -07001984 auto const colorBlendInfo = vk::PipelineColorBlendStateCreateInfo().setAttachments(colorBlendAttachments);
Dave Houlton5fa47912018-02-16 11:02:26 -07001985
Charles Giessen87dd88d2022-02-03 13:46:29 -07001986 std::array<vk::DynamicState, 2> const dynamicStates = {vk::DynamicState::eViewport, vk::DynamicState::eScissor};
Dave Houlton5fa47912018-02-16 11:02:26 -07001987
Charles Giessen87dd88d2022-02-03 13:46:29 -07001988 auto const dynamicStateInfo = vk::PipelineDynamicStateCreateInfo().setDynamicStates(dynamicStates);
Dave Houlton5fa47912018-02-16 11:02:26 -07001989
Charles Giessenc2f1a942022-02-06 23:38:39 -07001990 auto pipline_return = device.createGraphicsPipelines(pipelineCache, vk::GraphicsPipelineCreateInfo()
1991 .setStages(shaderStageInfo)
1992 .setPVertexInputState(&vertexInputInfo)
1993 .setPInputAssemblyState(&inputAssemblyInfo)
1994 .setPViewportState(&viewportInfo)
1995 .setPRasterizationState(&rasterizationInfo)
1996 .setPMultisampleState(&multisampleInfo)
1997 .setPDepthStencilState(&depthStencilInfo)
1998 .setPColorBlendState(&colorBlendInfo)
1999 .setPDynamicState(&dynamicStateInfo)
2000 .setLayout(pipeline_layout)
2001 .setRenderPass(render_pass));
Dave Houlton5fa47912018-02-16 11:02:26 -07002002 VERIFY(result == vk::Result::eSuccess);
Charles Giessenc2f1a942022-02-06 23:38:39 -07002003 pipeline = pipline_return.value.at(0);
Dave Houlton5fa47912018-02-16 11:02:26 -07002004
Charles Giessenc2f1a942022-02-06 23:38:39 -07002005 device.destroyShaderModule(frag_shader_module);
2006 device.destroyShaderModule(vert_shader_module);
Dave Houlton5fa47912018-02-16 11:02:26 -07002007}
2008
2009void Demo::prepare_render_pass() {
2010 // The initial layout for the color and depth attachments will be LAYOUT_UNDEFINED
2011 // because at the start of the renderpass, we don't care about their contents.
2012 // At the start of the subpass, the color attachment's layout will be transitioned
2013 // to LAYOUT_COLOR_ATTACHMENT_OPTIMAL and the depth stencil attachment's layout
2014 // will be transitioned to LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL. At the end of
2015 // the renderpass, the color attachment's layout will be transitioned to
2016 // LAYOUT_PRESENT_SRC_KHR to be ready to present. This is all done as part of
2017 // the renderpass, no barriers are necessary.
Charles Giessen87dd88d2022-02-03 13:46:29 -07002018 std::array<vk::AttachmentDescription, 2> const attachments = {
2019 vk::AttachmentDescription()
2020 .setFormat(format)
2021 .setSamples(vk::SampleCountFlagBits::e1)
2022 .setLoadOp(vk::AttachmentLoadOp::eClear)
2023 .setStoreOp(vk::AttachmentStoreOp::eStore)
2024 .setStencilLoadOp(vk::AttachmentLoadOp::eDontCare)
2025 .setStencilStoreOp(vk::AttachmentStoreOp::eDontCare)
2026 .setInitialLayout(vk::ImageLayout::eUndefined)
2027 .setFinalLayout(vk::ImageLayout::ePresentSrcKHR),
2028 vk::AttachmentDescription()
2029 .setFormat(depth.format)
2030 .setSamples(vk::SampleCountFlagBits::e1)
2031 .setLoadOp(vk::AttachmentLoadOp::eClear)
2032 .setStoreOp(vk::AttachmentStoreOp::eDontCare)
2033 .setStencilLoadOp(vk::AttachmentLoadOp::eDontCare)
2034 .setStencilStoreOp(vk::AttachmentStoreOp::eDontCare)
2035 .setInitialLayout(vk::ImageLayout::eUndefined)
2036 .setFinalLayout(vk::ImageLayout::eDepthStencilAttachmentOptimal)};
Dave Houlton5fa47912018-02-16 11:02:26 -07002037
2038 auto const color_reference = vk::AttachmentReference().setAttachment(0).setLayout(vk::ImageLayout::eColorAttachmentOptimal);
2039
2040 auto const depth_reference =
2041 vk::AttachmentReference().setAttachment(1).setLayout(vk::ImageLayout::eDepthStencilAttachmentOptimal);
2042
2043 auto const subpass = vk::SubpassDescription()
2044 .setPipelineBindPoint(vk::PipelineBindPoint::eGraphics)
Charles Giessen87dd88d2022-02-03 13:46:29 -07002045 .setColorAttachments(color_reference)
2046 .setPDepthStencilAttachment(&depth_reference);
Dave Houlton5fa47912018-02-16 11:02:26 -07002047
Tony-LunarG495604b2019-06-13 15:32:05 -06002048 vk::PipelineStageFlags stages = vk::PipelineStageFlagBits::eEarlyFragmentTests | vk::PipelineStageFlagBits::eLateFragmentTests;
Charles Giessen87dd88d2022-02-03 13:46:29 -07002049 std::array<vk::SubpassDependency, 2> const dependencies = {
Tony-LunarG495604b2019-06-13 15:32:05 -06002050 vk::SubpassDependency() // Depth buffer is shared between swapchain images
2051 .setSrcSubpass(VK_SUBPASS_EXTERNAL)
2052 .setDstSubpass(0)
2053 .setSrcStageMask(stages)
2054 .setDstStageMask(stages)
2055 .setSrcAccessMask(vk::AccessFlagBits::eDepthStencilAttachmentWrite)
2056 .setDstAccessMask(vk::AccessFlagBits::eDepthStencilAttachmentRead | vk::AccessFlagBits::eDepthStencilAttachmentWrite)
2057 .setDependencyFlags(vk::DependencyFlags()),
2058 vk::SubpassDependency() // Image layout transition
2059 .setSrcSubpass(VK_SUBPASS_EXTERNAL)
2060 .setDstSubpass(0)
2061 .setSrcStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
2062 .setDstStageMask(vk::PipelineStageFlagBits::eColorAttachmentOutput)
2063 .setSrcAccessMask(vk::AccessFlagBits())
2064 .setDstAccessMask(vk::AccessFlagBits::eColorAttachmentWrite | vk::AccessFlagBits::eColorAttachmentRead)
2065 .setDependencyFlags(vk::DependencyFlags()),
2066 };
2067
Charles Giessen87dd88d2022-02-03 13:46:29 -07002068 const auto render_pass_result = device.createRenderPass(
2069 vk::RenderPassCreateInfo().setAttachments(attachments).setSubpasses(subpass).setDependencies(dependencies));
2070 VERIFY(render_pass_result.result == vk::Result::eSuccess);
2071 render_pass = render_pass_result.value;
Dave Houlton5fa47912018-02-16 11:02:26 -07002072}
2073
2074vk::ShaderModule Demo::prepare_shader_module(const uint32_t *code, size_t size) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07002075 const auto shader_module_return = device.createShaderModule(vk::ShaderModuleCreateInfo().setCodeSize(size).setPCode(code));
2076 VERIFY(shader_module_return.result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -07002077
Charles Giessen87dd88d2022-02-03 13:46:29 -07002078 return shader_module_return.value;
Dave Houlton5fa47912018-02-16 11:02:26 -07002079}
2080
Charles Giessen87dd88d2022-02-03 13:46:29 -07002081void Demo::prepare_texture_buffer(const char *filename, texture_object &tex_obj) {
2082 vk::SubresourceLayout tex_layout;
Charles Giessen3bcefe52022-02-21 11:57:16 -07002083
2084 if (!loadTexture(filename, nullptr, tex_layout, tex_obj.tex_width, tex_obj.tex_height)) {
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002085 ERR_EXIT("Failed to load textures", "Load Texture Failure");
2086 }
2087
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002088 auto const buffer_create_info = vk::BufferCreateInfo()
Charles Giessen3bcefe52022-02-21 11:57:16 -07002089 .setSize(tex_obj.tex_width * tex_obj.tex_height * 4)
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002090 .setUsage(vk::BufferUsageFlagBits::eTransferSrc)
Charles Giessen87dd88d2022-02-03 13:46:29 -07002091 .setSharingMode(vk::SharingMode::eExclusive);
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002092
Charles Giessen87dd88d2022-02-03 13:46:29 -07002093 auto result = device.createBuffer(&buffer_create_info, nullptr, &tex_obj.buffer);
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002094 VERIFY(result == vk::Result::eSuccess);
2095
2096 vk::MemoryRequirements mem_reqs;
Charles Giessen87dd88d2022-02-03 13:46:29 -07002097 device.getBufferMemoryRequirements(tex_obj.buffer, &mem_reqs);
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002098
Charles Giessen87dd88d2022-02-03 13:46:29 -07002099 tex_obj.mem_alloc.setAllocationSize(mem_reqs.size);
2100 tex_obj.mem_alloc.setMemoryTypeIndex(0);
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002101
2102 vk::MemoryPropertyFlags requirements = vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent;
Charles Giessen87dd88d2022-02-03 13:46:29 -07002103 auto pass = memory_type_from_properties(mem_reqs.memoryTypeBits, requirements, tex_obj.mem_alloc.memoryTypeIndex);
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002104 VERIFY(pass == true);
2105
Charles Giessen87dd88d2022-02-03 13:46:29 -07002106 result = device.allocateMemory(&tex_obj.mem_alloc, nullptr, &(tex_obj.mem));
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002107 VERIFY(result == vk::Result::eSuccess);
2108
Charles Giessen87dd88d2022-02-03 13:46:29 -07002109 result = device.bindBufferMemory(tex_obj.buffer, tex_obj.mem, 0);
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002110 VERIFY(result == vk::Result::eSuccess);
2111
2112 vk::SubresourceLayout layout;
Charles Giessen3bcefe52022-02-21 11:57:16 -07002113 layout.rowPitch = tex_obj.tex_width * 4;
Charles Giessen87dd88d2022-02-03 13:46:29 -07002114 auto data = device.mapMemory(tex_obj.mem, 0, tex_obj.mem_alloc.allocationSize);
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002115 VERIFY(data.result == vk::Result::eSuccess);
2116
Charles Giessen3bcefe52022-02-21 11:57:16 -07002117 if (!loadTexture(filename, (uint8_t *)data.value, layout, tex_obj.tex_width, tex_obj.tex_height)) {
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002118 fprintf(stderr, "Error loading texture: %s\n", filename);
2119 }
2120
Charles Giessen87dd88d2022-02-03 13:46:29 -07002121 device.unmapMemory(tex_obj.mem);
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002122}
2123
Charles Giessen87dd88d2022-02-03 13:46:29 -07002124void Demo::prepare_texture_image(const char *filename, texture_object &tex_obj, vk::ImageTiling tiling, vk::ImageUsageFlags usage,
Dave Houlton5fa47912018-02-16 11:02:26 -07002125 vk::MemoryPropertyFlags required_props) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07002126 vk::SubresourceLayout tex_layout;
Charles Giessen3bcefe52022-02-21 11:57:16 -07002127 if (!loadTexture(filename, nullptr, tex_layout, tex_obj.tex_width, tex_obj.tex_height)) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002128 ERR_EXIT("Failed to load textures", "Load Texture Failure");
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002129 }
2130
Dave Houlton5fa47912018-02-16 11:02:26 -07002131 auto const image_create_info = vk::ImageCreateInfo()
2132 .setImageType(vk::ImageType::e2D)
2133 .setFormat(vk::Format::eR8G8B8A8Unorm)
Charles Giessen3bcefe52022-02-21 11:57:16 -07002134 .setExtent({tex_obj.tex_width, tex_obj.tex_height, 1})
Dave Houlton5fa47912018-02-16 11:02:26 -07002135 .setMipLevels(1)
2136 .setArrayLayers(1)
2137 .setSamples(vk::SampleCountFlagBits::e1)
2138 .setTiling(tiling)
2139 .setUsage(usage)
2140 .setSharingMode(vk::SharingMode::eExclusive)
Dave Houlton5fa47912018-02-16 11:02:26 -07002141 .setInitialLayout(vk::ImageLayout::ePreinitialized);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002142
Charles Giessen87dd88d2022-02-03 13:46:29 -07002143 auto result = device.createImage(&image_create_info, nullptr, &tex_obj.image);
Dave Houlton5fa47912018-02-16 11:02:26 -07002144 VERIFY(result == vk::Result::eSuccess);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002145
Dave Houlton5fa47912018-02-16 11:02:26 -07002146 vk::MemoryRequirements mem_reqs;
Charles Giessen87dd88d2022-02-03 13:46:29 -07002147 device.getImageMemoryRequirements(tex_obj.image, &mem_reqs);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002148
Charles Giessen87dd88d2022-02-03 13:46:29 -07002149 tex_obj.mem_alloc.setAllocationSize(mem_reqs.size);
2150 tex_obj.mem_alloc.setMemoryTypeIndex(0);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002151
Charles Giessen87dd88d2022-02-03 13:46:29 -07002152 auto pass = memory_type_from_properties(mem_reqs.memoryTypeBits, required_props, tex_obj.mem_alloc.memoryTypeIndex);
Dave Houlton5fa47912018-02-16 11:02:26 -07002153 VERIFY(pass == true);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002154
Charles Giessen87dd88d2022-02-03 13:46:29 -07002155 result = device.allocateMemory(&tex_obj.mem_alloc, nullptr, &tex_obj.mem);
Dave Houlton5fa47912018-02-16 11:02:26 -07002156 VERIFY(result == vk::Result::eSuccess);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002157
Charles Giessen87dd88d2022-02-03 13:46:29 -07002158 result = device.bindImageMemory(tex_obj.image, tex_obj.mem, 0);
Dave Houlton5fa47912018-02-16 11:02:26 -07002159 VERIFY(result == vk::Result::eSuccess);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002160
Dave Houlton5fa47912018-02-16 11:02:26 -07002161 if (required_props & vk::MemoryPropertyFlagBits::eHostVisible) {
2162 auto const subres = vk::ImageSubresource().setAspectMask(vk::ImageAspectFlagBits::eColor).setMipLevel(0).setArrayLayer(0);
2163 vk::SubresourceLayout layout;
Charles Giessen87dd88d2022-02-03 13:46:29 -07002164 device.getImageSubresourceLayout(tex_obj.image, &subres, &layout);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002165
Charles Giessen87dd88d2022-02-03 13:46:29 -07002166 auto data = device.mapMemory(tex_obj.mem, 0, tex_obj.mem_alloc.allocationSize);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002167 VERIFY(data.result == vk::Result::eSuccess);
2168
Charles Giessen3bcefe52022-02-21 11:57:16 -07002169 if (!loadTexture(filename, (uint8_t *)data.value, layout, tex_obj.tex_width, tex_obj.tex_height)) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002170 fprintf(stderr, "Error loading texture: %s\n", filename);
2171 }
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002172
Charles Giessen87dd88d2022-02-03 13:46:29 -07002173 device.unmapMemory(tex_obj.mem);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002174 }
2175
Charles Giessen87dd88d2022-02-03 13:46:29 -07002176 tex_obj.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
Dave Houlton5fa47912018-02-16 11:02:26 -07002177}
2178
2179void Demo::prepare_textures() {
2180 vk::Format const tex_format = vk::Format::eR8G8B8A8Unorm;
2181 vk::FormatProperties props;
2182 gpu.getFormatProperties(tex_format, &props);
2183
2184 for (uint32_t i = 0; i < texture_count; i++) {
2185 if ((props.linearTilingFeatures & vk::FormatFeatureFlagBits::eSampledImage) && !use_staging_buffer) {
2186 /* Device can texture using linear textures */
Charles Giessen87dd88d2022-02-03 13:46:29 -07002187 prepare_texture_image(tex_files[i], textures[i], vk::ImageTiling::eLinear, vk::ImageUsageFlagBits::eSampled,
Dave Houlton5fa47912018-02-16 11:02:26 -07002188 vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent);
2189 // Nothing in the pipeline needs to be complete to start, and don't allow fragment
2190 // shader to run until layout transition completes
2191 set_image_layout(textures[i].image, vk::ImageAspectFlagBits::eColor, vk::ImageLayout::ePreinitialized,
2192 textures[i].imageLayout, vk::AccessFlagBits(), vk::PipelineStageFlagBits::eTopOfPipe,
2193 vk::PipelineStageFlagBits::eFragmentShader);
2194 staging_texture.image = vk::Image();
2195 } else if (props.optimalTilingFeatures & vk::FormatFeatureFlagBits::eSampledImage) {
2196 /* Must use staging buffer to copy linear texture to optimized */
2197
Charles Giessen87dd88d2022-02-03 13:46:29 -07002198 prepare_texture_buffer(tex_files[i], staging_texture);
Dave Houlton5fa47912018-02-16 11:02:26 -07002199
Charles Giessen87dd88d2022-02-03 13:46:29 -07002200 prepare_texture_image(tex_files[i], textures[i], vk::ImageTiling::eOptimal,
Dave Houlton5fa47912018-02-16 11:02:26 -07002201 vk::ImageUsageFlagBits::eTransferDst | vk::ImageUsageFlagBits::eSampled,
2202 vk::MemoryPropertyFlagBits::eDeviceLocal);
2203
Dave Houlton5fa47912018-02-16 11:02:26 -07002204 set_image_layout(textures[i].image, vk::ImageAspectFlagBits::eColor, vk::ImageLayout::ePreinitialized,
2205 vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits(), vk::PipelineStageFlagBits::eTopOfPipe,
2206 vk::PipelineStageFlagBits::eTransfer);
2207
2208 auto const subresource = vk::ImageSubresourceLayers()
2209 .setAspectMask(vk::ImageAspectFlagBits::eColor)
2210 .setMipLevel(0)
2211 .setBaseArrayLayer(0)
2212 .setLayerCount(1);
2213
Charles Giessen87dd88d2022-02-03 13:46:29 -07002214 auto const copy_region = vk::BufferImageCopy()
2215 .setBufferOffset(0)
2216 .setBufferRowLength(staging_texture.tex_width)
2217 .setBufferImageHeight(staging_texture.tex_height)
2218 .setImageSubresource(subresource)
2219 .setImageOffset({0, 0, 0})
Charles Giessen3bcefe52022-02-21 11:57:16 -07002220 .setImageExtent({staging_texture.tex_width, staging_texture.tex_height, 1});
Dave Houlton5fa47912018-02-16 11:02:26 -07002221
Tony-LunarGbc9fc052018-09-21 13:47:06 -06002222 cmd.copyBufferToImage(staging_texture.buffer, textures[i].image, vk::ImageLayout::eTransferDstOptimal, 1, &copy_region);
Dave Houlton5fa47912018-02-16 11:02:26 -07002223
2224 set_image_layout(textures[i].image, vk::ImageAspectFlagBits::eColor, vk::ImageLayout::eTransferDstOptimal,
2225 textures[i].imageLayout, vk::AccessFlagBits::eTransferWrite, vk::PipelineStageFlagBits::eTransfer,
2226 vk::PipelineStageFlagBits::eFragmentShader);
2227 } else {
2228 assert(!"No support for R8G8B8A8_UNORM as texture image format");
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002229 }
2230
Dave Houlton5fa47912018-02-16 11:02:26 -07002231 auto const samplerInfo = vk::SamplerCreateInfo()
2232 .setMagFilter(vk::Filter::eNearest)
2233 .setMinFilter(vk::Filter::eNearest)
2234 .setMipmapMode(vk::SamplerMipmapMode::eNearest)
2235 .setAddressModeU(vk::SamplerAddressMode::eClampToEdge)
2236 .setAddressModeV(vk::SamplerAddressMode::eClampToEdge)
2237 .setAddressModeW(vk::SamplerAddressMode::eClampToEdge)
2238 .setMipLodBias(0.0f)
2239 .setAnisotropyEnable(VK_FALSE)
2240 .setMaxAnisotropy(1)
2241 .setCompareEnable(VK_FALSE)
2242 .setCompareOp(vk::CompareOp::eNever)
2243 .setMinLod(0.0f)
2244 .setMaxLod(0.0f)
2245 .setBorderColor(vk::BorderColor::eFloatOpaqueWhite)
2246 .setUnnormalizedCoordinates(VK_FALSE);
2247
2248 auto result = device.createSampler(&samplerInfo, nullptr, &textures[i].sampler);
2249 VERIFY(result == vk::Result::eSuccess);
2250
2251 auto const viewInfo = vk::ImageViewCreateInfo()
2252 .setImage(textures[i].image)
2253 .setViewType(vk::ImageViewType::e2D)
2254 .setFormat(tex_format)
2255 .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));
2256
2257 result = device.createImageView(&viewInfo, nullptr, &textures[i].view);
2258 VERIFY(result == vk::Result::eSuccess);
2259 }
2260}
2261
2262vk::ShaderModule Demo::prepare_vs() {
2263 const uint32_t vertShaderCode[] = {
2264#include "cube.vert.inc"
2265 };
2266
2267 vert_shader_module = prepare_shader_module(vertShaderCode, sizeof(vertShaderCode));
2268
2269 return vert_shader_module;
2270}
2271
Charles Giessen87dd88d2022-02-03 13:46:29 -07002272void Demo::destroy_swapchain_related_resources() {
2273 device.destroyDescriptorPool(desc_pool);
Dave Houlton5fa47912018-02-16 11:02:26 -07002274
Charles Giessen87dd88d2022-02-03 13:46:29 -07002275 device.destroyPipeline(pipeline);
2276 device.destroyPipelineCache(pipelineCache);
2277 device.destroyRenderPass(render_pass);
2278 device.destroyPipelineLayout(pipeline_layout);
2279 device.destroyDescriptorSetLayout(desc_layout);
2280
2281 for (const auto &tex : textures) {
2282 device.destroyImageView(tex.view);
2283 device.destroyImage(tex.image);
2284 device.freeMemory(tex.mem);
2285 device.destroySampler(tex.sampler);
2286 }
2287
2288 device.destroyImageView(depth.view);
2289 device.destroyImage(depth.image);
2290 device.freeMemory(depth.mem);
2291
2292 for (const auto &resource : swapchain_image_resources) {
2293 device.destroyFramebuffer(resource.framebuffer);
2294 device.destroyImageView(resource.view);
2295 device.freeCommandBuffers(cmd_pool, {resource.cmd});
2296 device.destroyBuffer(resource.uniform_buffer);
2297 device.unmapMemory(resource.uniform_memory);
2298 device.freeMemory(resource.uniform_memory);
2299 }
2300
2301 device.destroyCommandPool(cmd_pool);
2302 if (separate_present_queue) {
2303 device.destroyCommandPool(present_cmd_pool);
2304 }
2305}
2306
2307void Demo::resize() {
Dave Houlton5fa47912018-02-16 11:02:26 -07002308 // Don't react to resize until after first initialization.
2309 if (!prepared) {
2310 return;
2311 }
2312
2313 // In order to properly resize the window, we must re-create the
2314 // swapchain
2315 // AND redo the command buffers, etc.
2316 //
2317 // First, perform part of the cleanup() function:
2318 prepared = false;
2319 auto result = device.waitIdle();
2320 VERIFY(result == vk::Result::eSuccess);
Charles Giessen87dd88d2022-02-03 13:46:29 -07002321 destroy_swapchain_related_resources();
Dave Houlton5fa47912018-02-16 11:02:26 -07002322
2323 // Second, re-perform the prepare() function, which will re-create the
2324 // swapchain.
2325 prepare();
2326}
2327
2328void Demo::set_image_layout(vk::Image image, vk::ImageAspectFlags aspectMask, vk::ImageLayout oldLayout, vk::ImageLayout newLayout,
2329 vk::AccessFlags srcAccessMask, vk::PipelineStageFlags src_stages, vk::PipelineStageFlags dest_stages) {
2330 assert(cmd);
2331
2332 auto DstAccessMask = [](vk::ImageLayout const &layout) {
2333 vk::AccessFlags flags;
2334
2335 switch (layout) {
2336 case vk::ImageLayout::eTransferDstOptimal:
2337 // Make sure anything that was copying from this image has
2338 // completed
2339 flags = vk::AccessFlagBits::eTransferWrite;
2340 break;
2341 case vk::ImageLayout::eColorAttachmentOptimal:
2342 flags = vk::AccessFlagBits::eColorAttachmentWrite;
2343 break;
2344 case vk::ImageLayout::eDepthStencilAttachmentOptimal:
2345 flags = vk::AccessFlagBits::eDepthStencilAttachmentWrite;
2346 break;
2347 case vk::ImageLayout::eShaderReadOnlyOptimal:
2348 // Make sure any Copy or CPU writes to image are flushed
2349 flags = vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eInputAttachmentRead;
2350 break;
2351 case vk::ImageLayout::eTransferSrcOptimal:
2352 flags = vk::AccessFlagBits::eTransferRead;
2353 break;
2354 case vk::ImageLayout::ePresentSrcKHR:
2355 flags = vk::AccessFlagBits::eMemoryRead;
2356 break;
2357 default:
2358 break;
2359 }
2360
2361 return flags;
2362 };
2363
Charles Giessen87dd88d2022-02-03 13:46:29 -07002364 cmd.pipelineBarrier(src_stages, dest_stages, vk::DependencyFlagBits(), {}, {},
2365 vk::ImageMemoryBarrier()
2366 .setSrcAccessMask(srcAccessMask)
2367 .setDstAccessMask(DstAccessMask(newLayout))
2368 .setOldLayout(oldLayout)
2369 .setNewLayout(newLayout)
2370 .setSrcQueueFamilyIndex(VK_QUEUE_FAMILY_IGNORED)
2371 .setDstQueueFamilyIndex(VK_QUEUE_FAMILY_IGNORED)
2372 .setImage(image)
2373 .setSubresourceRange(vk::ImageSubresourceRange(aspectMask, 0, 1, 0, 1)));
Dave Houlton5fa47912018-02-16 11:02:26 -07002374}
2375
2376void Demo::update_data_buffer() {
2377 mat4x4 VP;
2378 mat4x4_mul(VP, projection_matrix, view_matrix);
2379
2380 // Rotate around the Y axis
2381 mat4x4 Model;
2382 mat4x4_dup(Model, model_matrix);
Charles Giessen87dd88d2022-02-03 13:46:29 -07002383 mat4x4_rotate_Y(model_matrix, Model, static_cast<float>(degreesToRadians(spin_angle)));
Arman Uguray3ae08892021-05-25 00:07:24 -07002384 mat4x4_orthonormalize(model_matrix, model_matrix);
Dave Houlton5fa47912018-02-16 11:02:26 -07002385
2386 mat4x4 MVP;
2387 mat4x4_mul(MVP, VP, model_matrix);
2388
Tony-LunarG37af49f2019-12-19 12:04:19 -07002389 memcpy(swapchain_image_resources[current_buffer].uniform_memory_ptr, (const void *)&MVP[0][0], sizeof(MVP));
Dave Houlton5fa47912018-02-16 11:02:26 -07002390}
2391
Karl Schultzb7940402018-05-29 13:09:22 -06002392/* Convert ppm image data from header file into RGBA texture image */
2393#include "lunarg.ppm.h"
Charles Giessen3bcefe52022-02-21 11:57:16 -07002394bool Demo::loadTexture(const char *filename, uint8_t *rgba_data, vk::SubresourceLayout &layout, uint32_t &width, uint32_t &height) {
Karl Schultzb7940402018-05-29 13:09:22 -06002395 (void)filename;
2396 char *cPtr;
2397 cPtr = (char *)lunarg_ppm;
2398 if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "P6\n", 3)) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002399 return false;
2400 }
Karl Schultzb7940402018-05-29 13:09:22 -06002401 while (strncmp(cPtr++, "\n", 1))
2402 ;
Charles Giessen87dd88d2022-02-03 13:46:29 -07002403 sscanf(cPtr, "%u %u", &width, &height);
Charles Giessenc2f1a942022-02-06 23:38:39 -07002404 if (rgba_data == nullptr) {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002405 return true;
2406 }
Karl Schultzb7940402018-05-29 13:09:22 -06002407 while (strncmp(cPtr++, "\n", 1))
2408 ;
2409 if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "255\n", 4)) {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002410 return false;
2411 }
Karl Schultzb7940402018-05-29 13:09:22 -06002412 while (strncmp(cPtr++, "\n", 1))
2413 ;
Charles Giessen3bcefe52022-02-21 11:57:16 -07002414 for (uint32_t y = 0; y < height; y++) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002415 uint8_t *rowPtr = rgba_data;
Charles Giessen3bcefe52022-02-21 11:57:16 -07002416 for (uint32_t x = 0; x < width; x++) {
Karl Schultzb7940402018-05-29 13:09:22 -06002417 memcpy(rowPtr, cPtr, 3);
Dave Houlton5fa47912018-02-16 11:02:26 -07002418 rowPtr[3] = 255; /* Alpha of 1 */
2419 rowPtr += 4;
Karl Schultzb7940402018-05-29 13:09:22 -06002420 cPtr += 3;
Dave Houlton5fa47912018-02-16 11:02:26 -07002421 }
Charles Giessen87dd88d2022-02-03 13:46:29 -07002422 rgba_data += layout.rowPitch;
Dave Houlton5fa47912018-02-16 11:02:26 -07002423 }
Dave Houlton5fa47912018-02-16 11:02:26 -07002424 return true;
2425}
2426
Charles Giessen87dd88d2022-02-03 13:46:29 -07002427bool Demo::memory_type_from_properties(uint32_t typeBits, vk::MemoryPropertyFlags requirements_mask, uint32_t &typeIndex) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002428 // Search memtypes to find first index with those properties
2429 for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
2430 if ((typeBits & 1) == 1) {
2431 // Type is available, does it match user properties?
2432 if ((memory_properties.memoryTypes[i].propertyFlags & requirements_mask) == requirements_mask) {
Charles Giessen87dd88d2022-02-03 13:46:29 -07002433 typeIndex = i;
Dave Houlton5fa47912018-02-16 11:02:26 -07002434 return true;
2435 }
2436 }
2437 typeBits >>= 1;
2438 }
2439
2440 // No memory types matched, return failure
2441 return false;
2442}
2443
Charles Giessen7dc2dd52022-02-03 13:55:48 -07002444vk::SurfaceFormatKHR Demo::pick_surface_format(const std::vector<vk::SurfaceFormatKHR> &surface_formats) {
2445 // Prefer non-SRGB formats...
2446 for (const auto &surface_format : surface_formats) {
2447 const vk::Format format = surface_format.format;
2448
2449 if (format == vk::Format::eR8G8B8A8Unorm || format == vk::Format::eB8G8R8A8Unorm ||
2450 format == vk::Format::eA2B10G10R10UnormPack32 || format == vk::Format::eA2R10G10B10UnormPack32 ||
2451 format == vk::Format::eR16G16B16A16Sfloat) {
2452 return surface_format;
2453 }
2454 }
2455
2456 printf("Can't find our preferred formats... Falling back to first exposed format. Rendering may be incorrect.\n");
2457
2458 assert(surface_formats.size() >= 1);
2459 return surface_formats[0];
2460}
2461
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002462#if defined(VK_USE_PLATFORM_WIN32_KHR)
Dave Houlton5fa47912018-02-16 11:02:26 -07002463void Demo::run() {
2464 if (!prepared) {
2465 return;
2466 }
2467
2468 draw();
2469 curFrame++;
2470
Petr Krausd88e4e52019-01-23 18:45:04 +01002471 if (frameCount != UINT32_MAX && curFrame == frameCount) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002472 PostQuitMessage(validation_error);
2473 }
2474}
2475
2476void Demo::create_window() {
2477 WNDCLASSEX win_class;
2478
2479 // Initialize the window class structure:
2480 win_class.cbSize = sizeof(WNDCLASSEX);
2481 win_class.style = CS_HREDRAW | CS_VREDRAW;
2482 win_class.lpfnWndProc = WndProc;
2483 win_class.cbClsExtra = 0;
2484 win_class.cbWndExtra = 0;
2485 win_class.hInstance = connection; // hInstance
2486 win_class.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
2487 win_class.hCursor = LoadCursor(nullptr, IDC_ARROW);
2488 win_class.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
2489 win_class.lpszMenuName = nullptr;
Charles Giessen87dd88d2022-02-03 13:46:29 -07002490 win_class.lpszClassName = name.c_str();
Dave Houlton5fa47912018-02-16 11:02:26 -07002491 win_class.hIconSm = LoadIcon(nullptr, IDI_WINLOGO);
2492
2493 // Register window class:
2494 if (!RegisterClassEx(&win_class)) {
2495 // It didn't work, so try to give a useful error:
2496 printf("Unexpected error trying to start the application!\n");
2497 fflush(stdout);
2498 exit(1);
2499 }
2500
2501 // Create window with the registered class:
2502 RECT wr = {0, 0, static_cast<LONG>(width), static_cast<LONG>(height)};
2503 AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
2504 window = CreateWindowEx(0,
Charles Giessen87dd88d2022-02-03 13:46:29 -07002505 name.c_str(), // class name
2506 name.c_str(), // app name
Dave Houlton5fa47912018-02-16 11:02:26 -07002507 WS_OVERLAPPEDWINDOW | // window style
2508 WS_VISIBLE | WS_SYSMENU,
2509 100, 100, // x/y coords
2510 wr.right - wr.left, // width
2511 wr.bottom - wr.top, // height
2512 nullptr, // handle to parent
2513 nullptr, // handle to menu
2514 connection, // hInstance
2515 nullptr); // no extra parameters
2516
2517 if (!window) {
2518 // It didn't work, so try to give a useful error:
2519 printf("Cannot create a window in which to draw!\n");
2520 fflush(stdout);
2521 exit(1);
2522 }
2523
2524 // Window client area size must be at least 1 pixel high, to prevent
2525 // crash.
2526 minsize.x = GetSystemMetrics(SM_CXMINTRACK);
2527 minsize.y = GetSystemMetrics(SM_CYMINTRACK) + 1;
2528}
2529#elif defined(VK_USE_PLATFORM_XLIB_KHR)
2530
2531void Demo::create_xlib_window() {
2532 const char *display_envar = getenv("DISPLAY");
2533 if (display_envar == nullptr || display_envar[0] == '\0') {
2534 printf("Environment variable DISPLAY requires a valid value.\nExiting ...\n");
2535 fflush(stdout);
2536 exit(1);
2537 }
2538
2539 XInitThreads();
2540 display = XOpenDisplay(nullptr);
2541 long visualMask = VisualScreenMask;
2542 int numberOfVisuals;
2543 XVisualInfo vInfoTemplate = {};
2544 vInfoTemplate.screen = DefaultScreen(display);
2545 XVisualInfo *visualInfo = XGetVisualInfo(display, visualMask, &vInfoTemplate, &numberOfVisuals);
2546
2547 Colormap colormap = XCreateColormap(display, RootWindow(display, vInfoTemplate.screen), visualInfo->visual, AllocNone);
2548
2549 XSetWindowAttributes windowAttributes = {};
2550 windowAttributes.colormap = colormap;
2551 windowAttributes.background_pixel = 0xFFFFFFFF;
2552 windowAttributes.border_pixel = 0;
2553 windowAttributes.event_mask = KeyPressMask | KeyReleaseMask | StructureNotifyMask | ExposureMask;
2554
2555 xlib_window =
2556 XCreateWindow(display, RootWindow(display, vInfoTemplate.screen), 0, 0, width, height, 0, visualInfo->depth, InputOutput,
2557 visualInfo->visual, CWBackPixel | CWBorderPixel | CWEventMask | CWColormap, &windowAttributes);
2558
2559 XSelectInput(display, xlib_window, ExposureMask | KeyPressMask);
2560 XMapWindow(display, xlib_window);
2561 XFlush(display);
2562 xlib_wm_delete_window = XInternAtom(display, "WM_DELETE_WINDOW", False);
2563}
2564
2565void Demo::handle_xlib_event(const XEvent *event) {
2566 switch (event->type) {
2567 case ClientMessage:
2568 if ((Atom)event->xclient.data.l[0] == xlib_wm_delete_window) {
2569 quit = true;
2570 }
2571 break;
2572 case KeyPress:
2573 switch (event->xkey.keycode) {
2574 case 0x9: // Escape
2575 quit = true;
2576 break;
2577 case 0x71: // left arrow key
2578 spin_angle -= spin_increment;
2579 break;
2580 case 0x72: // right arrow key
2581 spin_angle += spin_increment;
2582 break;
2583 case 0x41: // space bar
2584 pause = !pause;
2585 break;
2586 }
2587 break;
2588 case ConfigureNotify:
2589 if (((int32_t)width != event->xconfigure.width) || ((int32_t)height != event->xconfigure.height)) {
2590 width = event->xconfigure.width;
2591 height = event->xconfigure.height;
2592 resize();
2593 }
2594 break;
2595 default:
2596 break;
2597 }
2598}
2599
2600void Demo::run_xlib() {
2601 while (!quit) {
2602 XEvent event;
2603
2604 if (pause) {
2605 XNextEvent(display, &event);
2606 handle_xlib_event(&event);
2607 }
2608 while (XPending(display) > 0) {
2609 XNextEvent(display, &event);
2610 handle_xlib_event(&event);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002611 }
2612
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002613 draw();
2614 curFrame++;
2615
Dave Houlton5fa47912018-02-16 11:02:26 -07002616 if (frameCount != UINT32_MAX && curFrame == frameCount) {
2617 quit = true;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002618 }
2619 }
Dave Houlton5fa47912018-02-16 11:02:26 -07002620}
Tony Barbour153cb062016-12-07 13:43:36 -07002621#elif defined(VK_USE_PLATFORM_XCB_KHR)
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002622
Dave Houlton5fa47912018-02-16 11:02:26 -07002623void Demo::handle_xcb_event(const xcb_generic_event_t *event) {
2624 uint8_t event_code = event->response_type & 0x7f;
2625 switch (event_code) {
2626 case XCB_EXPOSE:
2627 // TODO: Resize window
2628 break;
2629 case XCB_CLIENT_MESSAGE:
2630 if ((*(xcb_client_message_event_t *)event).data.data32[0] == (*atom_wm_delete_window).atom) {
2631 quit = true;
2632 }
2633 break;
2634 case XCB_KEY_RELEASE: {
2635 const xcb_key_release_event_t *key = (const xcb_key_release_event_t *)event;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002636
Dave Houlton5fa47912018-02-16 11:02:26 -07002637 switch (key->detail) {
2638 case 0x9: // Escape
2639 quit = true;
2640 break;
2641 case 0x71: // left arrow key
2642 spin_angle -= spin_increment;
2643 break;
2644 case 0x72: // right arrow key
2645 spin_angle += spin_increment;
2646 break;
2647 case 0x41: // space bar
2648 pause = !pause;
2649 break;
2650 }
2651 } break;
2652 case XCB_CONFIGURE_NOTIFY: {
2653 const xcb_configure_notify_event_t *cfg = (const xcb_configure_notify_event_t *)event;
2654 if ((width != cfg->width) || (height != cfg->height)) {
2655 width = cfg->width;
2656 height = cfg->height;
2657 resize();
2658 }
2659 } break;
2660 default:
2661 break;
2662 }
2663}
2664
2665void Demo::run_xcb() {
2666 xcb_flush(connection);
2667
2668 while (!quit) {
2669 xcb_generic_event_t *event;
2670
2671 if (pause) {
2672 event = xcb_wait_for_event(connection);
2673 } else {
2674 event = xcb_poll_for_event(connection);
2675 }
2676 while (event) {
2677 handle_xcb_event(event);
2678 free(event);
2679 event = xcb_poll_for_event(connection);
2680 }
2681
2682 draw();
2683 curFrame++;
2684 if (frameCount != UINT32_MAX && curFrame == frameCount) {
2685 quit = true;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002686 }
2687 }
Dave Houlton5fa47912018-02-16 11:02:26 -07002688}
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002689
Dave Houlton5fa47912018-02-16 11:02:26 -07002690void Demo::create_xcb_window() {
2691 uint32_t value_mask, value_list[32];
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002692
Dave Houlton5fa47912018-02-16 11:02:26 -07002693 xcb_window = xcb_generate_id(connection);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002694
Dave Houlton5fa47912018-02-16 11:02:26 -07002695 value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
2696 value_list[0] = screen->black_pixel;
2697 value_list[1] = XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002698
Dave Houlton5fa47912018-02-16 11:02:26 -07002699 xcb_create_window(connection, XCB_COPY_FROM_PARENT, xcb_window, screen->root, 0, 0, width, height, 0,
2700 XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual, value_mask, value_list);
2701
2702 /* Magic code that will send notification when window is destroyed */
2703 xcb_intern_atom_cookie_t cookie = xcb_intern_atom(connection, 1, 12, "WM_PROTOCOLS");
2704 xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(connection, cookie, 0);
2705
2706 xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(connection, 0, 16, "WM_DELETE_WINDOW");
2707 atom_wm_delete_window = xcb_intern_atom_reply(connection, cookie2, 0);
2708
2709 xcb_change_property(connection, XCB_PROP_MODE_REPLACE, xcb_window, (*reply).atom, 4, 32, 1, &(*atom_wm_delete_window).atom);
2710
2711 free(reply);
2712
2713 xcb_map_window(connection, xcb_window);
2714
2715 // Force the x/y coordinates to 100,100 results are identical in
2716 // consecutive
2717 // runs
Charles Giessen87dd88d2022-02-03 13:46:29 -07002718 std::array<uint32_t, 2> const coords = {100, 100};
2719 xcb_configure_window(connection, xcb_window, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, coords.data());
Dave Houlton5fa47912018-02-16 11:02:26 -07002720}
2721#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
2722
2723void Demo::run() {
2724 while (!quit) {
2725 if (pause) {
2726 wl_display_dispatch(display);
2727 } else {
2728 wl_display_dispatch_pending(display);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002729 draw();
2730 curFrame++;
Jeremy Hayes9d304782016-10-09 11:48:12 -06002731 if (frameCount != UINT32_MAX && curFrame == frameCount) {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002732 quit = true;
2733 }
2734 }
2735 }
Dave Houlton5fa47912018-02-16 11:02:26 -07002736}
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002737
Manuel Stoecklac939332019-06-26 20:55:53 -04002738static void handle_surface_configure(void *data, xdg_surface *xdg_surface, uint32_t serial) {
Charles Giessen3bcefe52022-02-21 11:57:16 -07002739 Demo &demo = *static_cast<Demo *>(data);
Manuel Stoecklac939332019-06-26 20:55:53 -04002740 xdg_surface_ack_configure(xdg_surface, serial);
Charles Giessen3bcefe52022-02-21 11:57:16 -07002741 if (demo.xdg_surface_has_been_configured) {
2742 demo.resize();
Manuel Stoecklac939332019-06-26 20:55:53 -04002743 }
Charles Giessen3bcefe52022-02-21 11:57:16 -07002744 demo.xdg_surface_has_been_configured = true;
Manuel Stoecklac939332019-06-26 20:55:53 -04002745}
2746
2747static const xdg_surface_listener surface_listener = {handle_surface_configure};
2748
2749static void handle_toplevel_configure(void *data, xdg_toplevel *xdg_toplevel, int32_t width, int32_t height,
2750 struct wl_array *states) {
Charles Giessen3bcefe52022-02-21 11:57:16 -07002751 Demo &demo = *static_cast<Demo *>(data);
Manuel Stoecklac939332019-06-26 20:55:53 -04002752 /* zero values imply the program may choose its own size, so in that case
2753 * stay with the existing value (which on startup is the default) */
2754 if (width > 0) {
Charles Giessen3bcefe52022-02-21 11:57:16 -07002755 demo.width = static_cast<uint32_t>(width);
Manuel Stoecklac939332019-06-26 20:55:53 -04002756 }
2757 if (height > 0) {
Charles Giessen3bcefe52022-02-21 11:57:16 -07002758 demo.height = static_cast<uint32_t>(height);
Manuel Stoecklac939332019-06-26 20:55:53 -04002759 }
2760 // This will be followed by a surface configure
2761}
2762
2763static void handle_toplevel_close(void *data, xdg_toplevel *xdg_toplevel) {
Charles Giessen3bcefe52022-02-21 11:57:16 -07002764 Demo &demo = *static_cast<Demo *>(data);
2765 demo.quit = true;
Manuel Stoecklac939332019-06-26 20:55:53 -04002766}
2767
2768static const xdg_toplevel_listener toplevel_listener = {handle_toplevel_configure, handle_toplevel_close};
2769
Dave Houlton5fa47912018-02-16 11:02:26 -07002770void Demo::create_window() {
Manuel Stoecklac939332019-06-26 20:55:53 -04002771 if (!wm_base) {
2772 printf("Compositor did not provide the standard protocol xdg-wm-base\n");
2773 fflush(stdout);
2774 exit(1);
2775 }
2776
Dave Houlton5fa47912018-02-16 11:02:26 -07002777 window = wl_compositor_create_surface(compositor);
2778 if (!window) {
2779 printf("Can not create wayland_surface from compositor!\n");
2780 fflush(stdout);
2781 exit(1);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002782 }
2783
Manuel Stoecklac939332019-06-26 20:55:53 -04002784 window_surface = xdg_wm_base_get_xdg_surface(wm_base, window);
2785 if (!window_surface) {
2786 printf("Can not get xdg_surface from wayland_surface!\n");
Dave Houlton5fa47912018-02-16 11:02:26 -07002787 fflush(stdout);
2788 exit(1);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002789 }
Manuel Stoecklac939332019-06-26 20:55:53 -04002790 window_toplevel = xdg_surface_get_toplevel(window_surface);
2791 if (!window_toplevel) {
2792 printf("Can not allocate xdg_toplevel for xdg_surface!\n");
2793 fflush(stdout);
2794 exit(1);
2795 }
2796 xdg_surface_add_listener(window_surface, &surface_listener, this);
2797 xdg_toplevel_add_listener(window_toplevel, &toplevel_listener, this);
2798 xdg_toplevel_set_title(window_toplevel, APP_SHORT_NAME);
2799 if (xdg_decoration_mgr) {
2800 // if supported, let the compositor render titlebars for us
2801 toplevel_decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(xdg_decoration_mgr, window_toplevel);
2802 zxdg_toplevel_decoration_v1_set_mode(toplevel_decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
2803 }
Dave Houlton5fa47912018-02-16 11:02:26 -07002804
Manuel Stoecklac939332019-06-26 20:55:53 -04002805 wl_surface_commit(window);
Dave Houlton5fa47912018-02-16 11:02:26 -07002806}
Nicolas Caramellic8be8c82020-07-13 17:22:09 +02002807#elif defined(VK_USE_PLATFORM_DIRECTFB_EXT)
2808
2809void Demo::handle_directfb_event(const DFBInputEvent *event) {
2810 if (event->type != DIET_KEYPRESS) return;
2811 switch (event->key_symbol) {
2812 case DIKS_ESCAPE: // Escape
2813 quit = true;
2814 break;
2815 case DIKS_CURSOR_LEFT: // left arrow key
2816 spin_angle -= spin_increment;
2817 break;
2818 case DIKS_CURSOR_RIGHT: // right arrow key
2819 spin_angle += spin_increment;
2820 break;
2821 case DIKS_SPACE: // space bar
2822 pause = !pause;
2823 break;
2824 default:
2825 break;
2826 }
2827}
2828
2829void Demo::run_directfb() {
2830 while (!quit) {
2831 DFBInputEvent event;
2832
2833 if (pause) {
2834 event_buffer->WaitForEvent(event_buffer);
Nicolas Caramelli6d4f1c62020-07-13 18:10:07 +02002835 if (!event_buffer->GetEvent(event_buffer, DFB_EVENT(&event))) handle_directfb_event(&event);
Nicolas Caramellic8be8c82020-07-13 17:22:09 +02002836 } else {
Nicolas Caramelli6d4f1c62020-07-13 18:10:07 +02002837 if (!event_buffer->GetEvent(event_buffer, DFB_EVENT(&event))) handle_directfb_event(&event);
Nicolas Caramellic8be8c82020-07-13 17:22:09 +02002838
2839 draw();
2840 curFrame++;
2841 if (frameCount != UINT32_MAX && curFrame == frameCount) {
2842 quit = true;
2843 }
2844 }
2845 }
2846}
2847
2848void Demo::create_directfb_window() {
2849 DFBResult ret;
2850
Charles Giessenc2f1a942022-02-06 23:38:39 -07002851 ret = DirectFBInit(nullptr, nullptr);
Nicolas Caramellic8be8c82020-07-13 17:22:09 +02002852 if (ret) {
2853 printf("DirectFBInit failed to initialize DirectFB!\n");
2854 fflush(stdout);
2855 exit(1);
2856 }
2857
2858 ret = DirectFBCreate(&dfb);
2859 if (ret) {
2860 printf("DirectFBCreate failed to create main interface of DirectFB!\n");
2861 fflush(stdout);
2862 exit(1);
2863 }
2864
2865 DFBSurfaceDescription desc;
2866 desc.flags = (DFBSurfaceDescriptionFlags)(DSDESC_CAPS | DSDESC_WIDTH | DSDESC_HEIGHT);
2867 desc.caps = DSCAPS_PRIMARY;
Nicolas Caramelli6d4f1c62020-07-13 18:10:07 +02002868 desc.width = width;
Nicolas Caramellic8be8c82020-07-13 17:22:09 +02002869 desc.height = height;
2870 ret = dfb->CreateSurface(dfb, &desc, &window);
2871 if (ret) {
2872 printf("CreateSurface failed to create DirectFB surface interface!\n");
2873 fflush(stdout);
2874 exit(1);
2875 }
2876
2877 ret = dfb->CreateInputEventBuffer(dfb, DICAPS_KEYS, DFB_FALSE, &event_buffer);
2878 if (ret) {
2879 printf("CreateInputEventBuffer failed to create DirectFB event buffer interface!\n");
2880 fflush(stdout);
2881 exit(1);
2882 }
2883}
Bill Hollings0a0625a2019-07-15 17:39:18 -04002884#elif defined(VK_USE_PLATFORM_METAL_EXT)
Karl Schultz206b1c52018-04-13 18:02:07 -06002885void Demo::run() {
2886 draw();
2887 curFrame++;
2888 if (frameCount != UINT32_MAX && curFrame == frameCount) {
2889 quit = true;
2890 }
2891}
Damien Leone600c3052017-01-31 10:26:07 -07002892#elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
2893
Dave Houlton5fa47912018-02-16 11:02:26 -07002894vk::Result Demo::create_display_surface() {
Charles Giessenc2f1a942022-02-06 23:38:39 -07002895 auto display_properties_return = gpu.getDisplayPropertiesKHR();
2896 VERIFY((display_properties_return.result == vk::Result::eSuccess) ||
2897 (display_properties_return.result == vk::Result::eIncomplete));
Damien Leone600c3052017-01-31 10:26:07 -07002898
Charles Giessenc2f1a942022-02-06 23:38:39 -07002899 auto display = display_properties_return.value.at(0).display;
Dave Houlton5fa47912018-02-16 11:02:26 -07002900
Charles Giessenc2f1a942022-02-06 23:38:39 -07002901 auto display_mode_props_return = gpu.getDisplayModePropertiesKHR(display);
2902 VERIFY(display_mode_props_return.result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -07002903
Charles Giessenc2f1a942022-02-06 23:38:39 -07002904 if (display_mode_props_return.value.size() == 0) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002905 printf("Cannot find any mode for the display!\n");
2906 fflush(stdout);
2907 exit(1);
2908 }
Charles Giessenc2f1a942022-02-06 23:38:39 -07002909 auto display_mode_prop = display_mode_props_return.value.at(0);
Dave Houlton5fa47912018-02-16 11:02:26 -07002910
2911 // Get the list of planes
Charles Giessenc2f1a942022-02-06 23:38:39 -07002912 auto display_plane_props_return = gpu.getDisplayPlanePropertiesKHR();
2913 VERIFY(display_plane_props_return.result == vk::Result::eSuccess);
Dave Houlton5fa47912018-02-16 11:02:26 -07002914
Charles Giessenc2f1a942022-02-06 23:38:39 -07002915 if (display_plane_props_return.value.size() == 0) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002916 printf("Cannot find any plane!\n");
2917 fflush(stdout);
2918 exit(1);
2919 }
Charles Giessen431f3b52022-03-30 16:17:29 -06002920 auto display_plane_props = display_plane_props_return.value;
Dave Houlton5fa47912018-02-16 11:02:26 -07002921
Charles Giessenc2f1a942022-02-06 23:38:39 -07002922 vk::Bool32 found_plane = VK_FALSE;
Charles Giessen431f3b52022-03-30 16:17:29 -06002923 uint32_t plane_found = 0;
Dave Houlton5fa47912018-02-16 11:02:26 -07002924 // Find a plane compatible with the display
Charles Giessen431f3b52022-03-30 16:17:29 -06002925 for (uint32_t plane_index = 0; plane_index < display_plane_props.size(); plane_index++) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002926 // Disqualify planes that are bound to a different display
Charles Giessen431f3b52022-03-30 16:17:29 -06002927 if (display_plane_props[plane_index].currentDisplay && (display_plane_props[plane_index].currentDisplay != display)) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002928 continue;
Damien Leone600c3052017-01-31 10:26:07 -07002929 }
2930
Charles Giessenc2f1a942022-02-06 23:38:39 -07002931 auto display_plane_supported_displays_return = gpu.getDisplayPlaneSupportedDisplaysKHR(plane_index);
2932 VERIFY(display_plane_supported_displays_return.result == vk::Result::eSuccess);
Damien Leone600c3052017-01-31 10:26:07 -07002933
Charles Giessenc2f1a942022-02-06 23:38:39 -07002934 if (display_plane_supported_displays_return.value.size() == 0) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002935 continue;
Damien Leone600c3052017-01-31 10:26:07 -07002936 }
2937
Charles Giessenc2f1a942022-02-06 23:38:39 -07002938 for (const auto &supported_display : display_plane_supported_displays_return.value) {
2939 if (supported_display == display) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002940 found_plane = VK_TRUE;
Charles Giessen431f3b52022-03-30 16:17:29 -06002941 plane_found = plane_index;
Damien Leone600c3052017-01-31 10:26:07 -07002942 break;
2943 }
2944 }
2945
Dave Houlton5fa47912018-02-16 11:02:26 -07002946 if (found_plane) {
2947 break;
Damien Leone600c3052017-01-31 10:26:07 -07002948 }
2949 }
Dave Houlton5fa47912018-02-16 11:02:26 -07002950
2951 if (!found_plane) {
2952 printf("Cannot find a plane compatible with the display!\n");
2953 fflush(stdout);
2954 exit(1);
2955 }
2956
Charles Giessen431f3b52022-03-30 16:17:29 -06002957 vk::DisplayPlaneCapabilitiesKHR planeCaps = gpu.getDisplayPlaneCapabilitiesKHR(display_mode_prop.displayMode, plane_found);
Dave Houlton5fa47912018-02-16 11:02:26 -07002958 // Find a supported alpha mode
2959 vk::DisplayPlaneAlphaFlagBitsKHR alphaMode = vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque;
Charles Giessen87dd88d2022-02-03 13:46:29 -07002960 std::array<vk::DisplayPlaneAlphaFlagBitsKHR, 4> alphaModes = {
Dave Houlton5fa47912018-02-16 11:02:26 -07002961 vk::DisplayPlaneAlphaFlagBitsKHR::eOpaque,
2962 vk::DisplayPlaneAlphaFlagBitsKHR::eGlobal,
2963 vk::DisplayPlaneAlphaFlagBitsKHR::ePerPixel,
2964 vk::DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied,
2965 };
Charles Giessen87dd88d2022-02-03 13:46:29 -07002966 for (const auto &alpha_mode : alphaModes) {
2967 if (planeCaps.supportedAlpha & alpha_mode) {
2968 alphaMode = alpha_mode;
Dave Houlton5fa47912018-02-16 11:02:26 -07002969 break;
2970 }
2971 }
2972
Charles Giessenc2f1a942022-02-06 23:38:39 -07002973 vk::Extent2D image_extent{};
Charles Giessen431f3b52022-03-30 16:17:29 -06002974 image_extent.setWidth(display_mode_prop.parameters.visibleRegion.width)
2975 .setHeight(display_mode_prop.parameters.visibleRegion.height);
Dave Houlton5fa47912018-02-16 11:02:26 -07002976
2977 auto const createInfo = vk::DisplaySurfaceCreateInfoKHR()
Charles Giessen431f3b52022-03-30 16:17:29 -06002978 .setDisplayMode(display_mode_prop.displayMode)
2979 .setPlaneIndex(plane_found)
2980 .setPlaneStackIndex(display_plane_props[plane_found].currentStackIndex)
Dave Houlton5fa47912018-02-16 11:02:26 -07002981 .setGlobalAlpha(1.0f)
2982 .setAlphaMode(alphaMode)
2983 .setImageExtent(image_extent);
2984
2985 return inst.createDisplayPlaneSurfaceKHR(&createInfo, nullptr, &surface);
2986}
2987
2988void Demo::run_display() {
2989 while (!quit) {
2990 draw();
2991 curFrame++;
2992
Petr Krausd88e4e52019-01-23 18:45:04 +01002993 if (frameCount != UINT32_MAX && curFrame == frameCount) {
Dave Houlton5fa47912018-02-16 11:02:26 -07002994 quit = true;
2995 }
2996 }
2997}
Jeremy Hayesf56427a2016-09-07 15:55:11 -06002998#endif
2999
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003000#if _WIN32
3001// Include header required for parsing the command line options.
3002#include <shellapi.h>
3003
3004Demo demo;
3005
3006// MS-Windows event handling function:
Jeremy Hayes9d304782016-10-09 11:48:12 -06003007LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
3008 switch (uMsg) {
Mark Lobodzinski85dbd822017-01-26 13:34:13 -07003009 case WM_CLOSE:
3010 PostQuitMessage(validation_error);
3011 break;
3012 case WM_PAINT:
Charles Giessen74f007d2022-02-08 14:04:45 -07003013 if (!demo.in_callback) {
3014 demo.run();
3015 }
Mark Lobodzinski85dbd822017-01-26 13:34:13 -07003016 break;
3017 case WM_GETMINMAXINFO: // set window's minimum size
3018 ((MINMAXINFO *)lParam)->ptMinTrackSize = demo.minsize;
3019 return 0;
Aaron Hagan500b9c32018-10-03 21:56:29 -04003020 case WM_ERASEBKGND:
3021 return 1;
Mark Lobodzinski85dbd822017-01-26 13:34:13 -07003022 case WM_SIZE:
3023 // Resize the application to the new window size, except when
3024 // it was minimized. Vulkan doesn't support images or swapchains
3025 // with width=0 and height=0.
3026 if (wParam != SIZE_MINIMIZED) {
3027 demo.width = lParam & 0xffff;
3028 demo.height = (lParam & 0xffff0000) >> 16;
3029 demo.resize();
3030 }
3031 break;
Petr Krausd88e4e52019-01-23 18:45:04 +01003032 case WM_KEYDOWN:
3033 switch (wParam) {
3034 case VK_ESCAPE:
3035 PostQuitMessage(validation_error);
3036 break;
3037 case VK_LEFT:
3038 demo.spin_angle -= demo.spin_increment;
3039 break;
3040 case VK_RIGHT:
3041 demo.spin_angle += demo.spin_increment;
3042 break;
3043 case VK_SPACE:
3044 demo.pause = !demo.pause;
3045 break;
3046 }
3047 return 0;
Mark Lobodzinski85dbd822017-01-26 13:34:13 -07003048 default:
3049 break;
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003050 }
3051
3052 return (DefWindowProc(hWnd, uMsg, wParam, lParam));
3053}
3054
Mark Lobodzinski2dbc2662017-01-26 12:16:30 -07003055int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR pCmdLine, int nCmdShow) {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003056 // TODO: Gah.. refactor. This isn't 1989.
Mark Lobodzinski85dbd822017-01-26 13:34:13 -07003057 MSG msg; // message
3058 bool done; // flag saying when app is complete
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003059 int argc;
3060 char **argv;
3061
Jamie Madillb2ff6502017-03-15 16:17:46 -04003062 // Ensure wParam is initialized.
3063 msg.wParam = 0;
3064
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003065 // Use the CommandLine functions to get the command line arguments.
3066 // Unfortunately, Microsoft outputs
3067 // this information as wide characters for Unicode, and we simply want the
3068 // Ascii version to be compatible
3069 // with the non-Windows side. So, we have to convert the information to
3070 // Ascii character strings.
3071 LPWSTR *commandLineArgs = CommandLineToArgvW(GetCommandLineW(), &argc);
Jeremy Hayes9d304782016-10-09 11:48:12 -06003072 if (nullptr == commandLineArgs) {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003073 argc = 0;
3074 }
3075
Jeremy Hayes9d304782016-10-09 11:48:12 -06003076 if (argc > 0) {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003077 argv = (char **)malloc(sizeof(char *) * argc);
Jeremy Hayes9d304782016-10-09 11:48:12 -06003078 if (argv == nullptr) {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003079 argc = 0;
Jeremy Hayes9d304782016-10-09 11:48:12 -06003080 } else {
3081 for (int iii = 0; iii < argc; iii++) {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003082 size_t wideCharLen = wcslen(commandLineArgs[iii]);
3083 size_t numConverted = 0;
3084
3085 argv[iii] = (char *)malloc(sizeof(char) * (wideCharLen + 1));
Jeremy Hayes9d304782016-10-09 11:48:12 -06003086 if (argv[iii] != nullptr) {
Mark Lobodzinski2dbc2662017-01-26 12:16:30 -07003087 wcstombs_s(&numConverted, argv[iii], wideCharLen + 1, commandLineArgs[iii], wideCharLen + 1);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003088 }
3089 }
3090 }
Jeremy Hayes9d304782016-10-09 11:48:12 -06003091 } else {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003092 argv = nullptr;
3093 }
3094
3095 demo.init(argc, argv);
3096
3097 // Free up the items we had to allocate for the command line arguments.
Jeremy Hayes9d304782016-10-09 11:48:12 -06003098 if (argc > 0 && argv != nullptr) {
3099 for (int iii = 0; iii < argc; iii++) {
3100 if (argv[iii] != nullptr) {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003101 free(argv[iii]);
3102 }
3103 }
3104 free(argv);
3105 }
3106
3107 demo.connection = hInstance;
Charles Giessen87dd88d2022-02-03 13:46:29 -07003108 demo.name = "Vulkan Cube";
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003109 demo.create_window();
3110 demo.init_vk_swapchain();
3111
3112 demo.prepare();
3113
Mark Lobodzinski85dbd822017-01-26 13:34:13 -07003114 done = false; // initialize loop condition variable
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003115
3116 // main message loop
Jeremy Hayes9d304782016-10-09 11:48:12 -06003117 while (!done) {
Petr Krausd88e4e52019-01-23 18:45:04 +01003118 if (demo.pause) {
3119 const BOOL succ = WaitMessage();
3120
3121 if (!succ) {
3122 const auto &suppress_popups = demo.suppress_popups;
3123 ERR_EXIT("WaitMessage() failed on paused demo", "event loop error");
3124 }
3125 }
3126
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003127 PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE);
Mark Lobodzinski85dbd822017-01-26 13:34:13 -07003128 if (msg.message == WM_QUIT) // check for a quit message
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003129 {
Mark Lobodzinski85dbd822017-01-26 13:34:13 -07003130 done = true; // if found, quit app
Jeremy Hayes9d304782016-10-09 11:48:12 -06003131 } else {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003132 /* Translate and dispatch to event queue*/
3133 TranslateMessage(&msg);
3134 DispatchMessage(&msg);
3135 }
3136 RedrawWindow(demo.window, nullptr, nullptr, RDW_INTERNALPAINT);
3137 }
3138
3139 demo.cleanup();
3140
Charles Giessen87dd88d2022-02-03 13:46:29 -07003141 return static_cast<int>(msg.wParam);
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003142}
3143
Eleni Maria Stea8b86fba2021-07-03 17:12:30 +03003144#elif defined(__linux__) || defined(__FreeBSD__)
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003145
Jeremy Hayes9d304782016-10-09 11:48:12 -06003146int main(int argc, char **argv) {
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003147 Demo demo;
3148
3149 demo.init(argc, argv);
3150
Tony Barbour153cb062016-12-07 13:43:36 -07003151#if defined(VK_USE_PLATFORM_XCB_KHR)
Jeremy Hayes9d304782016-10-09 11:48:12 -06003152 demo.create_xcb_window();
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003153#elif defined(VK_USE_PLATFORM_XLIB_KHR)
Tony Barbour78d6b572016-11-14 14:46:33 -07003154 demo.use_xlib = true;
Jeremy Hayes9d304782016-10-09 11:48:12 -06003155 demo.create_xlib_window();
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003156#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
Jeremy Hayes9d304782016-10-09 11:48:12 -06003157 demo.create_window();
Nicolas Caramellic8be8c82020-07-13 17:22:09 +02003158#elif defined(VK_USE_PLATFORM_DIRECTFB_EXT)
3159 demo.create_directfb_window();
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003160#endif
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003161
3162 demo.init_vk_swapchain();
3163
3164 demo.prepare();
3165
Tony Barbour153cb062016-12-07 13:43:36 -07003166#if defined(VK_USE_PLATFORM_XCB_KHR)
Mark Lobodzinski2dbc2662017-01-26 12:16:30 -07003167 demo.run_xcb();
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003168#elif defined(VK_USE_PLATFORM_XLIB_KHR)
Mark Lobodzinski2dbc2662017-01-26 12:16:30 -07003169 demo.run_xlib();
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003170#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
Mark Lobodzinski2dbc2662017-01-26 12:16:30 -07003171 demo.run();
Nicolas Caramellic8be8c82020-07-13 17:22:09 +02003172#elif defined(VK_USE_PLATFORM_DIRECTFB_EXT)
3173 demo.run_directfb();
Damien Leone600c3052017-01-31 10:26:07 -07003174#elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
3175 demo.run_display();
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003176#endif
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003177
3178 demo.cleanup();
3179
3180 return validation_error;
3181}
3182
Bill Hollings0a0625a2019-07-15 17:39:18 -04003183#elif defined(VK_USE_PLATFORM_METAL_EXT)
Karl Schultz9ceac062017-12-12 10:33:01 -05003184
3185// Global function invoked from NS or UI views and controllers to create demo
Charles Giessen87dd88d2022-02-03 13:46:29 -07003186static void demo_main(Demo &demo, void *caMetalLayer, int argc, const char *argv[]) {
Karl Schultz9ceac062017-12-12 10:33:01 -05003187 demo.init(argc, (char **)argv);
Bill Hollings0a0625a2019-07-15 17:39:18 -04003188 demo.caMetalLayer = caMetalLayer;
Karl Schultz9ceac062017-12-12 10:33:01 -05003189 demo.init_vk_swapchain();
3190 demo.prepare();
3191 demo.spin_angle = 0.4f;
3192}
3193
Jeremy Hayesf56427a2016-09-07 15:55:11 -06003194#else
3195#error "Platform not supported"
3196#endif