blob: 7cb7057724d60061eda294798f1c077bc98ce530 [file] [log] [blame]
Ian Elliotta748eaf2015-04-28 15:50:36 -06001/*
2 * Vulkan
3 *
4 * Copyright (C) 2014-2015 LunarG, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -060024#define _GNU_SOURCE
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060025#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <stdbool.h>
29#include <assert.h>
30
Ian Elliott639ca472015-04-16 15:23:05 -060031#ifdef _WIN32
32#pragma comment(linker, "/subsystem:windows")
33#include <windows.h>
34#define APP_NAME_STR_LEN 80
35#else // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060036#include <xcb/xcb.h>
Ian Elliott639ca472015-04-16 15:23:05 -060037#endif // _WIN32
38
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -060039#include <vulkan.h>
Ian Elliotta0781972015-08-21 15:09:33 -060040#include <vk_ext_khr_swapchain.h>
41#include <vk_ext_khr_device_swapchain.h>
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -060042#include "vk_debug_report_lunarg.h"
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060043
Cody Northropfe3d8bc2015-03-17 14:54:35 -060044#include "icd-spv.h"
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060045
Mark Lobodzinskif871f772015-09-01 09:00:16 -060046#include "vk_sdk_platform.h"
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -060047#include "linmath.h"
48
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060049#define DEMO_TEXTURE_COUNT 1
Ian Elliott44e33f72015-04-28 10:52:52 -060050#define APP_SHORT_NAME "cube"
51#define APP_LONG_NAME "The Vulkan Cube Demo Program"
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060052
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -060053#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
54
Tony Barbourfdc2d352015-04-22 09:02:32 -060055#if defined(NDEBUG) && defined(__GNUC__)
56#define U_ASSERT_ONLY __attribute__((unused))
57#else
58#define U_ASSERT_ONLY
59#endif
60
Ian Elliott07264132015-04-28 11:35:02 -060061#ifdef _WIN32
62#define ERR_EXIT(err_msg, err_class) \
63 do { \
64 MessageBox(NULL, err_msg, err_class, MB_OK); \
65 exit(1); \
66 } while (0)
67
Ian Elliott07264132015-04-28 11:35:02 -060068#else // _WIN32
69
70#define ERR_EXIT(err_msg, err_class) \
71 do { \
72 printf(err_msg); \
73 fflush(stdout); \
74 exit(1); \
75 } while (0)
76#endif // _WIN32
77
Ian Elliottaaae5352015-07-06 14:27:58 -060078#define GET_INSTANCE_PROC_ADDR(inst, entrypoint) \
79{ \
80 demo->fp##entrypoint = (PFN_vk##entrypoint) vkGetInstanceProcAddr(inst, "vk"#entrypoint); \
81 if (demo->fp##entrypoint == NULL) { \
82 ERR_EXIT("vkGetInstanceProcAddr failed to find vk"#entrypoint, \
83 "vkGetInstanceProcAddr Failure"); \
84 } \
85}
86
Jon Ashburn7d8342c2015-10-08 15:58:23 -060087static PFN_vkGetDeviceProcAddr g_gdpa = NULL;
88
Ian Elliott673898b2015-06-22 15:07:49 -060089#define GET_DEVICE_PROC_ADDR(dev, entrypoint) \
90{ \
Jon Ashburn7d8342c2015-10-08 15:58:23 -060091 if(!g_gdpa) \
92 g_gdpa = (PFN_vkGetDeviceProcAddr) vkGetInstanceProcAddr(demo->inst, "vkGetDeviceProcAddr"); \
93 demo->fp##entrypoint = (PFN_vk##entrypoint) g_gdpa(dev, "vk"#entrypoint); \
Ian Elliott673898b2015-06-22 15:07:49 -060094 if (demo->fp##entrypoint == NULL) { \
95 ERR_EXIT("vkGetDeviceProcAddr failed to find vk"#entrypoint, \
96 "vkGetDeviceProcAddr Failure"); \
97 } \
98}
99
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -0600100/*
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700101 * structure to track all objects related to a texture.
102 */
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600103struct texture_object {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600104 VkSampler sampler;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700105
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600106 VkImage image;
107 VkImageLayout imageLayout;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600108
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200109 VkMemoryAllocInfo mem_alloc;
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500110 VkDeviceMemory mem;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600111 VkImageView view;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700112 int32_t tex_width, tex_height;
113};
114
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600115static char *tex_files[] = {
Tony Barbour1a86d032015-09-21 15:17:33 -0600116 "lunarg.ppm"
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600117};
118
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600119struct vkcube_vs_uniform {
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600120 // Must start with MVP
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600121 float mvp[4][4];
122 float position[12*3][4];
123 float color[12*3][4];
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600124};
125
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600126struct vktexcube_vs_uniform {
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600127 // Must start with MVP
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600128 float mvp[4][4];
129 float position[12*3][4];
130 float attr[12*3][4];
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600131};
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600132
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600133//--------------------------------------------------------------------------------------
134// Mesh and VertexFormat Data
135//--------------------------------------------------------------------------------------
136struct Vertex
137{
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600138 float posX, posY, posZ, posW; // Position data
139 float r, g, b, a; // Color
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600140};
141
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600142struct VertexPosTex
143{
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600144 float posX, posY, posZ, posW; // Position data
145 float u, v, s, t; // Texcoord
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600146};
147
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600148#define XYZ1(_x_, _y_, _z_) (_x_), (_y_), (_z_), 1.f
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600149#define UV(_u_, _v_) (_u_), (_v_), 0.f, 1.f
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600150
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600151static const float g_vertex_buffer_data[] = {
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800152 -1.0f,-1.0f,-1.0f, // -X side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600153 -1.0f,-1.0f, 1.0f,
154 -1.0f, 1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800155 -1.0f, 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600156 -1.0f, 1.0f,-1.0f,
157 -1.0f,-1.0f,-1.0f,
158
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800159 -1.0f,-1.0f,-1.0f, // -Z side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600160 1.0f, 1.0f,-1.0f,
161 1.0f,-1.0f,-1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800162 -1.0f,-1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600163 -1.0f, 1.0f,-1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600164 1.0f, 1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600165
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800166 -1.0f,-1.0f,-1.0f, // -Y side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600167 1.0f,-1.0f,-1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600168 1.0f,-1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800169 -1.0f,-1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600170 1.0f,-1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600171 -1.0f,-1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600172
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800173 -1.0f, 1.0f,-1.0f, // +Y side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600174 -1.0f, 1.0f, 1.0f,
175 1.0f, 1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800176 -1.0f, 1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600177 1.0f, 1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600178 1.0f, 1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600179
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800180 1.0f, 1.0f,-1.0f, // +X side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600181 1.0f, 1.0f, 1.0f,
182 1.0f,-1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800183 1.0f,-1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600184 1.0f,-1.0f,-1.0f,
185 1.0f, 1.0f,-1.0f,
186
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800187 -1.0f, 1.0f, 1.0f, // +Z side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600188 -1.0f,-1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600189 1.0f, 1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800190 -1.0f,-1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600191 1.0f,-1.0f, 1.0f,
192 1.0f, 1.0f, 1.0f,
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600193};
194
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600195static const float g_uv_buffer_data[] = {
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800196 0.0f, 0.0f, // -X side
197 1.0f, 0.0f,
198 1.0f, 1.0f,
199 1.0f, 1.0f,
200 0.0f, 1.0f,
201 0.0f, 0.0f,
202
203 1.0f, 0.0f, // -Z side
204 0.0f, 1.0f,
205 0.0f, 0.0f,
206 1.0f, 0.0f,
207 1.0f, 1.0f,
208 0.0f, 1.0f,
209
210 1.0f, 1.0f, // -Y side
211 1.0f, 0.0f,
212 0.0f, 0.0f,
213 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600214 0.0f, 0.0f,
215 0.0f, 1.0f,
216
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800217 1.0f, 1.0f, // +Y side
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -0600218 0.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800219 0.0f, 0.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600220 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600221 0.0f, 0.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600222 1.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600223
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800224 1.0f, 1.0f, // +X side
225 0.0f, 1.0f,
226 0.0f, 0.0f,
227 0.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600228 1.0f, 0.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600229 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600230
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800231 0.0f, 1.0f, // +Z side
232 0.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600233 1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600234 0.0f, 0.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800235 1.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600236 1.0f, 1.0f,
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600237};
238
239void dumpMatrix(const char *note, mat4x4 MVP)
240{
241 int i;
242
243 printf("%s: \n", note);
244 for (i=0; i<4; i++) {
245 printf("%f, %f, %f, %f\n", MVP[i][0], MVP[i][1], MVP[i][2], MVP[i][3]);
246 }
247 printf("\n");
248 fflush(stdout);
249}
250
251void dumpVec4(const char *note, vec4 vector)
252{
253 printf("%s: \n", note);
254 printf("%f, %f, %f, %f\n", vector[0], vector[1], vector[2], vector[3]);
255 printf("\n");
256 fflush(stdout);
257}
258
Courtney Goeltzenleuchterab328192015-09-04 13:52:24 -0600259VkBool32 dbgFunc(
Tony Barbour155cce82015-07-03 10:33:54 -0600260 VkFlags msgFlags,
261 VkDbgObjectType objType,
262 uint64_t srcObject,
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600263 size_t location,
264 int32_t msgCode,
265 const char* pLayerPrefix,
266 const char* pMsg,
267 void* pUserData)
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600268{
269 char *message = (char *) malloc(strlen(pMsg)+100);
270
271 assert (message);
272
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600273 if (msgFlags & VK_DBG_REPORT_ERROR_BIT) {
274 sprintf(message,"ERROR: [%s] Code %d : %s", pLayerPrefix, msgCode, pMsg);
275 } else if (msgFlags & VK_DBG_REPORT_WARN_BIT) {
Tony Barbourd70b42c2015-06-30 14:14:19 -0600276 // We know that we're submitting queues without fences, ignore this warning
277 if (strstr(pMsg, "vkQueueSubmit parameter, VkFence fence, is null pointer")){
Courtney Goeltzenleuchterab328192015-09-04 13:52:24 -0600278 return false;
Tony Barbourd70b42c2015-06-30 14:14:19 -0600279 }
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600280 sprintf(message,"WARNING: [%s] Code %d : %s", pLayerPrefix, msgCode, pMsg);
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600281 } else {
Courtney Goeltzenleuchterab328192015-09-04 13:52:24 -0600282 return false;
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600283 }
284
285#ifdef _WIN32
286 MessageBox(NULL, message, "Alert", MB_OK);
287#else
288 printf("%s\n",message);
289 fflush(stdout);
290#endif
291 free(message);
Courtney Goeltzenleuchterab328192015-09-04 13:52:24 -0600292
Courtney Goeltzenleuchter8cda44e2015-09-08 16:57:22 -0600293 /*
294 * false indicates that layer should not bail-out of an
295 * API call that had validation failures. This may mean that the
296 * app dies inside the driver due to invalid parameter(s).
297 * That's what would happen without validation layers, so we'll
298 * keep that behavior here.
299 */
300 return false;
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600301}
302
Ian Elliotta0781972015-08-21 15:09:33 -0600303typedef struct _SwapchainBuffers {
Ian Elliottaaae5352015-07-06 14:27:58 -0600304 VkImage image;
305 VkCmdBuffer cmd;
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600306 VkImageView view;
Ian Elliotta0781972015-08-21 15:09:33 -0600307} SwapchainBuffers;
Ian Elliottaaae5352015-07-06 14:27:58 -0600308
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600309struct demo {
Ian Elliott639ca472015-04-16 15:23:05 -0600310#ifdef _WIN32
311#define APP_NAME_STR_LEN 80
312 HINSTANCE connection; // hInstance - Windows Instance
313 char name[APP_NAME_STR_LEN]; // Name to put on the window/icon
314 HWND window; // hWnd - window handle
315#else // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600316 xcb_connection_t *connection;
317 xcb_screen_t *screen;
Chia-I Wucbb564e2015-04-16 22:02:10 +0800318 xcb_window_t window;
319 xcb_intern_atom_reply_t *atom_wm_delete_window;
Ian Elliotta0781972015-08-21 15:09:33 -0600320 VkPlatformHandleXcbKHR platform_handle_xcb;
Tony Barbour6839bec2015-07-13 16:37:21 -0600321#endif // _WIN32
Cody Northrop1fedb212015-05-28 11:27:16 -0600322 bool prepared;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700323 bool use_staging_buffer;
Cody Northrop1fedb212015-05-28 11:27:16 -0600324 bool use_glsl;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600325
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600326 VkInstance inst;
Tony Barbour72304ef2015-04-16 15:59:00 -0600327 VkPhysicalDevice gpu;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600328 VkDevice device;
329 VkQueue queue;
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -0700330 uint32_t graphics_queue_node_index;
Tony Barbourecf1b2b2015-06-24 16:06:58 -0600331 VkPhysicalDeviceProperties gpu_props;
Cody Northrop4d3c11d2015-08-03 17:04:53 -0600332 VkQueueFamilyProperties *queue_props;
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600333 VkPhysicalDeviceMemoryProperties memory_properties;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600334
335 int width, height;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600336 VkFormat format;
Ian Elliotta0781972015-08-21 15:09:33 -0600337 VkColorSpaceKHR color_space;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600338
Ian Elliotta0781972015-08-21 15:09:33 -0600339 PFN_vkGetPhysicalDeviceSurfaceSupportKHR fpGetPhysicalDeviceSurfaceSupportKHR;
340 PFN_vkGetSurfacePropertiesKHR fpGetSurfacePropertiesKHR;
341 PFN_vkGetSurfaceFormatsKHR fpGetSurfaceFormatsKHR;
342 PFN_vkGetSurfacePresentModesKHR fpGetSurfacePresentModesKHR;
343 PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
344 PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
345 PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
346 PFN_vkAcquireNextImageKHR fpAcquireNextImageKHR;
347 PFN_vkQueuePresentKHR fpQueuePresentKHR;
348 VkSurfaceDescriptionWindowKHR surface_description;
349 uint32_t swapchainImageCount;
350 VkSwapchainKHR swap_chain;
351 SwapchainBuffers *buffers;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600352
Ian Elliottaaae5352015-07-06 14:27:58 -0600353 VkCmdPool cmd_pool;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600354
355 struct {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600356 VkFormat format;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600357
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600358 VkImage image;
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200359 VkMemoryAllocInfo mem_alloc;
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500360 VkDeviceMemory mem;
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600361 VkImageView view;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600362 } depth;
363
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600364 struct texture_object textures[DEMO_TEXTURE_COUNT];
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600365
366 struct {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600367 VkBuffer buf;
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200368 VkMemoryAllocInfo mem_alloc;
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500369 VkDeviceMemory mem;
Chia-I Wuae721ba2015-05-25 16:27:55 +0800370 VkDescriptorInfo desc;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600371 } uniform_data;
372
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600373 VkCmdBuffer cmd; // Buffer for initialization commands
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -0500374 VkPipelineLayout pipeline_layout;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600375 VkDescriptorSetLayout desc_layout;
Jon Ashburnc4ab7af2015-07-09 15:02:25 -0600376 VkPipelineCache pipelineCache;
Chia-I Wuf973e322015-07-08 13:34:24 +0800377 VkRenderPass render_pass;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600378 VkPipeline pipeline;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600379
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600380 mat4x4 projection_matrix;
381 mat4x4 view_matrix;
382 mat4x4 model_matrix;
383
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600384 float spin_angle;
385 float spin_increment;
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -0600386 bool pause;
387
Tony Barbourb6dba5c2015-07-21 09:04:41 -0600388 VkShaderModule vert_shader_module;
389 VkShaderModule frag_shader_module;
390
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600391 VkDescriptorPool desc_pool;
392 VkDescriptorSet desc_set;
Chia-I Wu6a3c8972015-01-04 16:27:24 +0800393
Tony Barbourd8e504f2015-10-08 14:26:24 -0600394 VkFramebuffer *framebuffers;
Chia-I Wuf973e322015-07-08 13:34:24 +0800395
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600396 bool quit;
David Pinedo2bb7c932015-06-18 17:03:14 -0600397 int32_t curFrame;
398 int32_t frameCount;
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600399 bool validate;
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -0600400 bool use_break;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600401 PFN_vkDbgCreateMsgCallback dbgCreateMsgCallback;
Tony Barbourd70b42c2015-06-30 14:14:19 -0600402 PFN_vkDbgDestroyMsgCallback dbgDestroyMsgCallback;
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -0600403 PFN_vkDbgMsgCallback dbgBreakCallback;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600404 VkDbgMsgCallback msg_callback;
405
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600406 uint32_t current_buffer;
Courtney Goeltzenleuchterfe95fca2015-07-15 17:40:20 -0600407 uint32_t queue_count;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600408};
409
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600410static bool memory_type_from_properties(struct demo *demo, uint32_t typeBits, VkFlags requirements_mask, uint32_t *typeIndex)
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600411{
412 // Search memtypes to find first index with those properties
413 for (uint32_t i = 0; i < 32; i++) {
414 if ((typeBits & 1) == 1) {
415 // Type is available, does it match user properties?
Tony Barbour8a9f62a2015-10-15 12:42:56 -0600416 if ((demo->memory_properties.memoryTypes[i].propertyFlags & requirements_mask) == requirements_mask) {
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600417 *typeIndex = i;
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600418 return true;
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600419 }
420 }
421 typeBits >>= 1;
422 }
423 // No memory types matched, return failure
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600424 return false;
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600425}
426
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600427static void demo_flush_init_cmd(struct demo *demo)
428{
Tony Barbourfdc2d352015-04-22 09:02:32 -0600429 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600430
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600431 if (demo->cmd == VK_NULL_HANDLE)
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600432 return;
433
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600434 err = vkEndCommandBuffer(demo->cmd);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600435 assert(!err);
436
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600437 const VkCmdBuffer cmd_bufs[] = { demo->cmd };
Tony Barbour155cce82015-07-03 10:33:54 -0600438 VkFence nullFence = { VK_NULL_HANDLE };
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600439 VkSubmitInfo submit_info = {
440 .waitSemCount = 0,
441 .pWaitSemaphores = NULL,
442 .cmdBufferCount = 1,
443 .pCommandBuffers = cmd_bufs,
444 .signalSemCount = 0,
445 .pSignalSemaphores = NULL
446 };
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600447
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600448 err = vkQueueSubmit(demo->queue, 1, &submit_info, nullFence);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600449 assert(!err);
450
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600451 err = vkQueueWaitIdle(demo->queue);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600452 assert(!err);
453
Tony Barbour155cce82015-07-03 10:33:54 -0600454 vkDestroyCommandBuffer(demo->device, demo->cmd);
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600455 demo->cmd = VK_NULL_HANDLE;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600456}
457
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600458static void demo_set_image_layout(
459 struct demo *demo,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600460 VkImage image,
Cody Northrop0e951672015-09-14 13:48:12 -0600461 VkImageAspectFlags aspectMask,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600462 VkImageLayout old_image_layout,
463 VkImageLayout new_image_layout)
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600464{
Tony Barbourfdc2d352015-04-22 09:02:32 -0600465 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600466
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600467 if (demo->cmd == VK_NULL_HANDLE) {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600468 const VkCmdBufferCreateInfo cmd = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600469 .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600470 .pNext = NULL,
Cody Northrop91e221b2015-07-09 18:08:32 -0600471 .cmdPool = demo->cmd_pool,
Chia-I Wu57b23b42015-06-26 15:34:39 +0800472 .level = VK_CMD_BUFFER_LEVEL_PRIMARY,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600473 .flags = 0,
474 };
475
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600476 err = vkCreateCommandBuffer(demo->device, &cmd, &demo->cmd);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600477 assert(!err);
478
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600479 VkCmdBufferBeginInfo cmd_buf_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600480 .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600481 .pNext = NULL,
Tony Barbour72304ef2015-04-16 15:59:00 -0600482 .flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600483 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT,
Courtney Goeltzenleuchterdc093ab2015-08-26 14:48:00 -0600484 .renderPass = { VK_NULL_HANDLE },
Cody Northropa0a178c2015-08-11 11:35:58 -0600485 .subpass = 0,
Courtney Goeltzenleuchterdc093ab2015-08-26 14:48:00 -0600486 .framebuffer = { VK_NULL_HANDLE },
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600487 };
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600488 err = vkBeginCommandBuffer(demo->cmd, &cmd_buf_info);
Tony Barbourcb59a5d2015-10-23 10:53:30 -0600489 assert(!err);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600490 }
491
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600492 VkImageMemoryBarrier image_memory_barrier = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600493 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600494 .pNext = NULL,
495 .outputMask = 0,
496 .inputMask = 0,
497 .oldLayout = old_image_layout,
498 .newLayout = new_image_layout,
499 .image = image,
Cody Northrop0e951672015-09-14 13:48:12 -0600500 .subresourceRange = { aspectMask, 0, 1, 0, 0 }
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600501 };
502
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600503 if (new_image_layout == VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL) {
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600504 /* Make sure anything that was copying from this image has completed */
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -0600505 image_memory_barrier.inputMask = VK_MEMORY_INPUT_TRANSFER_BIT;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600506 }
507
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600508 if (new_image_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600509 /* Make sure any Copy or CPU writes to image are flushed */
Courtney Goeltzenleuchter2bda8332015-04-29 17:16:21 -0600510 image_memory_barrier.outputMask = VK_MEMORY_OUTPUT_HOST_WRITE_BIT | VK_MEMORY_OUTPUT_TRANSFER_BIT;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600511 }
512
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600513 VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600514
Tony Barbour50bbca42015-06-29 16:20:35 -0600515 VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
516 VkPipelineStageFlags dest_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600517
Courtney Goeltzenleuchter0cab2fb2015-07-12 13:07:46 -0600518 vkCmdPipelineBarrier(demo->cmd, src_stages, dest_stages, false, 1, (const void * const*)&pmemory_barrier);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600519}
520
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600521static void demo_draw_build_cmd(struct demo *demo, VkCmdBuffer cmd_buf)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600522{
Chia-I Wuf973e322015-07-08 13:34:24 +0800523 const VkCmdBufferBeginInfo cmd_buf_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600524 .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
Courtney Goeltzenleuchter53968d82015-04-03 15:25:24 -0600525 .pNext = NULL,
Courtney Goeltzenleuchtera8df1c02015-07-28 08:59:17 -0600526 .flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT,
Courtney Goeltzenleuchterdc093ab2015-08-26 14:48:00 -0600527 .renderPass = { VK_NULL_HANDLE },
Cody Northropa0a178c2015-08-11 11:35:58 -0600528 .subpass = 0,
Courtney Goeltzenleuchterdc093ab2015-08-26 14:48:00 -0600529 .framebuffer = { VK_NULL_HANDLE },
Jon Ashburn60ccfbe2014-12-31 17:08:35 -0700530 };
Chia-I Wua74c5b22015-07-07 11:50:03 +0800531 const VkClearValue clear_values[2] = {
Cody Northrop55745922015-08-25 15:26:38 -0600532 [0] = { .color.float32 = { 0.2f, 0.2f, 0.2f, 0.2f } },
533 [1] = { .depthStencil = { 1.0f, 0 } },
Chia-I Wua74c5b22015-07-07 11:50:03 +0800534 };
535 const VkRenderPassBeginInfo rp_begin = {
536 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
537 .pNext = NULL,
Chia-I Wuf973e322015-07-08 13:34:24 +0800538 .renderPass = demo->render_pass,
539 .framebuffer = demo->framebuffers[demo->current_buffer],
Chia-I Wua74c5b22015-07-07 11:50:03 +0800540 .renderArea.offset.x = 0,
541 .renderArea.offset.y = 0,
542 .renderArea.extent.width = demo->width,
543 .renderArea.extent.height = demo->height,
Cody Northrop372bbae2015-08-04 11:51:03 -0600544 .clearValueCount = 2,
545 .pClearValues = clear_values,
Jon Ashburn08f6eb92015-01-02 18:24:05 -0700546 };
Chia-I Wuf973e322015-07-08 13:34:24 +0800547 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600548
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600549 err = vkBeginCommandBuffer(cmd_buf, &cmd_buf_info);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600550 assert(!err);
551
Chia-I Wua74c5b22015-07-07 11:50:03 +0800552 vkCmdBeginRenderPass(cmd_buf, &rp_begin, VK_RENDER_PASS_CONTENTS_INLINE);
553
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600554 vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600555 demo->pipeline);
Mark Lobodzinskic6e8b3d2015-06-15 13:21:21 -0600556 vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout,
Cody Northropfb5185a2015-04-16 13:41:56 -0600557 0, 1, &demo->desc_set, 0, NULL);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600558
Courtney Goeltzenleuchter4cbf78b2015-09-17 15:06:17 -0600559 VkViewport viewport;
560 memset(&viewport, 0, sizeof(viewport));
561 viewport.height = (float) demo->height;
562 viewport.width = (float) demo->width;
563 viewport.minDepth = (float) 0.0f;
564 viewport.maxDepth = (float) 1.0f;
Courtney Goeltzenleuchterd6217bc2015-09-21 11:44:06 -0600565 vkCmdSetViewport(cmd_buf, 1, &viewport);
Courtney Goeltzenleuchter4cbf78b2015-09-17 15:06:17 -0600566
567 VkRect2D scissor;
568 memset(&scissor, 0, sizeof(scissor));
569 scissor.extent.width = demo->width;
570 scissor.extent.height = demo->height;
571 scissor.offset.x = 0;
572 scissor.offset.y = 0;
Courtney Goeltzenleuchterd6217bc2015-09-21 11:44:06 -0600573 vkCmdSetScissor(cmd_buf, 1, &scissor);
Courtney Goeltzenleuchter4cbf78b2015-09-17 15:06:17 -0600574
Courtney Goeltzenleuchter332a3672015-09-23 12:31:50 -0600575 vkCmdDraw(cmd_buf, 12 * 3, 1, 0, 0);
Chia-I Wu57b23b42015-06-26 15:34:39 +0800576 vkCmdEndRenderPass(cmd_buf);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600577
Tony Barbour15a4ef62015-10-21 10:14:48 -0600578 VkImageMemoryBarrier prePresentBarrier = {
579 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
580 .pNext = NULL,
581 .outputMask = VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT,
582 .inputMask = 0,
583 .oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
584 .newLayout = VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR,
585 .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
586 .destQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
587 .subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }
588 };
589
590 prePresentBarrier.image = demo->buffers[demo->current_buffer].image;
591 VkImageMemoryBarrier *pmemory_barrier = &prePresentBarrier;
592 vkCmdPipelineBarrier(cmd_buf, VK_PIPELINE_STAGE_ALL_GPU_COMMANDS, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
593 VK_FALSE, 1, (const void * const*)&pmemory_barrier);
594
595
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600596 err = vkEndCommandBuffer(cmd_buf);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600597 assert(!err);
598}
599
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600600
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -0600601void demo_update_data_buffer(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600602{
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600603 mat4x4 MVP, Model, VP;
604 int matrixSize = sizeof(MVP);
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600605 uint8_t *pData;
Tony Barbourfdc2d352015-04-22 09:02:32 -0600606 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600607
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600608 mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600609
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600610 // Rotate 22.5 degrees around the Y axis
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600611 mat4x4_dup(Model, demo->model_matrix);
Piers Daniell735ee532015-02-23 16:23:13 -0700612 mat4x4_rotate(demo->model_matrix, Model, 0.0f, 1.0f, 0.0f, (float)degreesToRadians(demo->spin_angle));
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600613 mat4x4_mul(MVP, VP, demo->model_matrix);
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600614
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200615 err = vkMapMemory(demo->device, demo->uniform_data.mem, 0, demo->uniform_data.mem_alloc.allocationSize, 0, (void **) &pData);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600616 assert(!err);
617
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600618 memcpy(pData, (const void*) &MVP[0][0], matrixSize);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600619
Mark Lobodzinskie4c92a62015-09-07 13:59:43 -0600620 vkUnmapMemory(demo->device, demo->uniform_data.mem);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600621}
622
623static void demo_draw(struct demo *demo)
624{
Tony Barbourfdc2d352015-04-22 09:02:32 -0600625 VkResult U_ASSERT_ONLY err;
Ian Elliottaaae5352015-07-06 14:27:58 -0600626 VkSemaphore presentCompleteSemaphore;
627 VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = {
628 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
629 .pNext = NULL,
Mark Lobodzinskie7ba7f12015-10-08 10:44:07 -0600630 .flags = 0,
Ian Elliottaaae5352015-07-06 14:27:58 -0600631 };
Tony Barbour155cce82015-07-03 10:33:54 -0600632 VkFence nullFence = { VK_NULL_HANDLE };
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600633
Ian Elliottaaae5352015-07-06 14:27:58 -0600634 err = vkCreateSemaphore(demo->device,
635 &presentCompleteSemaphoreCreateInfo,
636 &presentCompleteSemaphore);
637 assert(!err);
638
639 // Get the index of the next available swapchain image:
Ian Elliotta0781972015-08-21 15:09:33 -0600640 err = demo->fpAcquireNextImageKHR(demo->device, demo->swap_chain,
Ian Elliottaaae5352015-07-06 14:27:58 -0600641 UINT64_MAX,
642 presentCompleteSemaphore,
643 &demo->current_buffer);
Ian Elliotta0781972015-08-21 15:09:33 -0600644 // TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
Ian Elliottaaae5352015-07-06 14:27:58 -0600645 // return codes
646 assert(!err);
647
Tony Barbour15a4ef62015-10-21 10:14:48 -0600648 // Assume the command buffer has been run on current_buffer before so
649 // we need to set the image layout back to COLOR_ATTACHMENT_OPTIMAL
650 demo_set_image_layout(demo, demo->buffers[demo->current_buffer].image,
651 VK_IMAGE_ASPECT_COLOR_BIT,
652 VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR,
653 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
654 demo_flush_init_cmd(demo);
655
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600656 // Wait for the present complete semaphore to be signaled to ensure
657 // that the image won't be rendered to until the presentation
658 // engine has fully released ownership to the application, and it is
659 // okay to render to the image.
660
Ian Elliotta0781972015-08-21 15:09:33 -0600661// FIXME/TODO: DEAL WITH VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600662 VkSubmitInfo submit_info = {
663 .waitSemCount = 1,
664 .pWaitSemaphores = &presentCompleteSemaphore,
665 .cmdBufferCount = 1,
666 .pCommandBuffers = &demo->buffers[demo->current_buffer].cmd,
667 .signalSemCount = 0,
668 .pSignalSemaphores = NULL
669 };
670
671 err = vkQueueSubmit(demo->queue, 1, &submit_info, nullFence);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600672 assert(!err);
673
Ian Elliotta0781972015-08-21 15:09:33 -0600674 VkPresentInfoKHR present = {
675 .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
Ian Elliottaaae5352015-07-06 14:27:58 -0600676 .pNext = NULL,
Ian Elliotta0781972015-08-21 15:09:33 -0600677 .swapchainCount = 1,
678 .swapchains = &demo->swap_chain,
Ian Elliottaaae5352015-07-06 14:27:58 -0600679 .imageIndices = &demo->current_buffer,
680 };
681
682// TBD/TODO: SHOULD THE "present" PARAMETER BE "const" IN THE HEADER?
Ian Elliotta0781972015-08-21 15:09:33 -0600683 err = demo->fpQueuePresentKHR(demo->queue, &present);
684 // TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
Ian Elliottaaae5352015-07-06 14:27:58 -0600685 // return codes
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600686 assert(!err);
687
Chia-I Wucbb564e2015-04-16 22:02:10 +0800688 err = vkQueueWaitIdle(demo->queue);
689 assert(err == VK_SUCCESS);
Mike Stroyan15fed6b2015-08-28 10:58:06 -0600690
Mark Lobodzinskie4c92a62015-09-07 13:59:43 -0600691 vkDestroySemaphore(demo->device, presentCompleteSemaphore);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600692}
693
694static void demo_prepare_buffers(struct demo *demo)
695{
Ian Elliottaaae5352015-07-06 14:27:58 -0600696 VkResult U_ASSERT_ONLY err;
697
698 // Check the surface properties and formats
Ian Elliotta0781972015-08-21 15:09:33 -0600699 VkSurfacePropertiesKHR surfProperties;
700 err = demo->fpGetSurfacePropertiesKHR(demo->device,
701 (const VkSurfaceDescriptionKHR *)&demo->surface_description,
Ian Elliott8528eff2015-08-07 15:56:59 -0600702 &surfProperties);
Ian Elliottaaae5352015-07-06 14:27:58 -0600703 assert(!err);
704
Ian Elliott8528eff2015-08-07 15:56:59 -0600705 uint32_t presentModeCount;
Ian Elliotta0781972015-08-21 15:09:33 -0600706 err = demo->fpGetSurfacePresentModesKHR(demo->device,
707 (const VkSurfaceDescriptionKHR *)&demo->surface_description,
Ian Elliott8528eff2015-08-07 15:56:59 -0600708 &presentModeCount, NULL);
Ian Elliottaaae5352015-07-06 14:27:58 -0600709 assert(!err);
Ian Elliotta0781972015-08-21 15:09:33 -0600710 VkPresentModeKHR *presentModes =
711 (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
Ian Elliott8528eff2015-08-07 15:56:59 -0600712 assert(presentModes);
Ian Elliotta0781972015-08-21 15:09:33 -0600713 err = demo->fpGetSurfacePresentModesKHR(demo->device,
714 (const VkSurfaceDescriptionKHR *)&demo->surface_description,
Ian Elliott8528eff2015-08-07 15:56:59 -0600715 &presentModeCount, presentModes);
Ian Elliottaaae5352015-07-06 14:27:58 -0600716 assert(!err);
717
Ian Elliotta0781972015-08-21 15:09:33 -0600718 VkExtent2D swapchainExtent;
Ian Elliottaaae5352015-07-06 14:27:58 -0600719 // width and height are either both -1, or both not -1.
Ian Elliott8528eff2015-08-07 15:56:59 -0600720 if (surfProperties.currentExtent.width == -1)
Ian Elliottaaae5352015-07-06 14:27:58 -0600721 {
722 // If the surface size is undefined, the size is set to
723 // the size of the images requested.
Ian Elliotta0781972015-08-21 15:09:33 -0600724 swapchainExtent.width = demo->width;
725 swapchainExtent.height = demo->height;
Ian Elliottaaae5352015-07-06 14:27:58 -0600726 }
727 else
728 {
729 // If the surface size is defined, the swap chain size must match
Ian Elliotta0781972015-08-21 15:09:33 -0600730 swapchainExtent = surfProperties.currentExtent;
Ian Elliottaaae5352015-07-06 14:27:58 -0600731 }
732
733 // If mailbox mode is available, use it, as is the lowest-latency non-
Ian Elliott3ebce342015-07-27 13:53:11 -0600734 // tearing mode. If not, try IMMEDIATE which will usually be available,
735 // and is fastest (though it tears). If not, fall back to FIFO which is
736 // always available.
Ian Elliotta0781972015-08-21 15:09:33 -0600737 VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
Ian Elliottaaae5352015-07-06 14:27:58 -0600738 for (size_t i = 0; i < presentModeCount; i++) {
Ian Elliotta0781972015-08-21 15:09:33 -0600739 if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
740 swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
Ian Elliottaaae5352015-07-06 14:27:58 -0600741 break;
742 }
Ian Elliotta0781972015-08-21 15:09:33 -0600743 if ((swapchainPresentMode != VK_PRESENT_MODE_MAILBOX_KHR) &&
744 (presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR)) {
745 swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
Ian Elliott3ebce342015-07-27 13:53:11 -0600746 }
Ian Elliottaaae5352015-07-06 14:27:58 -0600747 }
748
749 // Determine the number of VkImage's to use in the swap chain (we desire to
750 // own only 1 image at a time, besides the images being displayed and
751 // queued for display):
Ian Elliotta0781972015-08-21 15:09:33 -0600752 uint32_t desiredNumberOfSwapchainImages = surfProperties.minImageCount + 1;
Ian Elliott8528eff2015-08-07 15:56:59 -0600753 if ((surfProperties.maxImageCount > 0) &&
Ian Elliotta0781972015-08-21 15:09:33 -0600754 (desiredNumberOfSwapchainImages > surfProperties.maxImageCount))
Ian Elliottaaae5352015-07-06 14:27:58 -0600755 {
756 // Application must settle for fewer images than desired:
Ian Elliotta0781972015-08-21 15:09:33 -0600757 desiredNumberOfSwapchainImages = surfProperties.maxImageCount;
Ian Elliottaaae5352015-07-06 14:27:58 -0600758 }
759
Tony Barbour9fd6d352015-09-16 15:01:32 -0600760 VkSurfaceTransformFlagsKHR preTransform;
Ian Elliotta0781972015-08-21 15:09:33 -0600761 if (surfProperties.supportedTransforms & VK_SURFACE_TRANSFORM_NONE_BIT_KHR) {
762 preTransform = VK_SURFACE_TRANSFORM_NONE_KHR;
Ian Elliottaaae5352015-07-06 14:27:58 -0600763 } else {
Ian Elliott8528eff2015-08-07 15:56:59 -0600764 preTransform = surfProperties.currentTransform;
Ian Elliottaaae5352015-07-06 14:27:58 -0600765 }
766
Ian Elliotta0781972015-08-21 15:09:33 -0600767 const VkSwapchainCreateInfoKHR swap_chain = {
Ian Elliott5b97eae2015-09-22 10:20:23 -0600768 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
Chia-I Wucbb564e2015-04-16 22:02:10 +0800769 .pNext = NULL,
Ian Elliotta0781972015-08-21 15:09:33 -0600770 .pSurfaceDescription = (const VkSurfaceDescriptionKHR *)&demo->surface_description,
771 .minImageCount = desiredNumberOfSwapchainImages,
Chia-I Wucbb564e2015-04-16 22:02:10 +0800772 .imageFormat = demo->format,
Ian Elliott8528eff2015-08-07 15:56:59 -0600773 .imageColorSpace = demo->color_space,
Chia-I Wucbb564e2015-04-16 22:02:10 +0800774 .imageExtent = {
Ian Elliotta0781972015-08-21 15:09:33 -0600775 .width = swapchainExtent.width,
776 .height = swapchainExtent.height,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600777 },
Cody Northrop11b48d02015-08-28 16:22:48 -0600778 .imageUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
Ian Elliottaaae5352015-07-06 14:27:58 -0600779 .preTransform = preTransform,
Chia-I Wucbb564e2015-04-16 22:02:10 +0800780 .imageArraySize = 1,
Ian Elliott8528eff2015-08-07 15:56:59 -0600781 .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
782 .queueFamilyCount = 0,
783 .pQueueFamilyIndices = NULL,
Ian Elliotta0781972015-08-21 15:09:33 -0600784 .presentMode = swapchainPresentMode,
785 .oldSwapchain.handle = 0,
Ian Elliottaaae5352015-07-06 14:27:58 -0600786 .clipped = true,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600787 };
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600788 uint32_t i;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600789
Ian Elliotta0781972015-08-21 15:09:33 -0600790 err = demo->fpCreateSwapchainKHR(demo->device, &swap_chain, &demo->swap_chain);
Chia-I Wucbb564e2015-04-16 22:02:10 +0800791 assert(!err);
792
Ian Elliotta0781972015-08-21 15:09:33 -0600793 err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swap_chain,
794 &demo->swapchainImageCount, NULL);
Ian Elliottaaae5352015-07-06 14:27:58 -0600795 assert(!err);
Chia-I Wucbb564e2015-04-16 22:02:10 +0800796
Ian Elliotta0781972015-08-21 15:09:33 -0600797 VkImage* swapchainImages =
798 (VkImage*)malloc(demo->swapchainImageCount * sizeof(VkImage));
799 assert(swapchainImages);
800 err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swap_chain,
801 &demo->swapchainImageCount,
802 swapchainImages);
Ian Elliottaaae5352015-07-06 14:27:58 -0600803 assert(!err);
Ian Elliottaaae5352015-07-06 14:27:58 -0600804
Ian Elliotta0781972015-08-21 15:09:33 -0600805 demo->buffers = (SwapchainBuffers*)malloc(sizeof(SwapchainBuffers)*demo->swapchainImageCount);
Ian Elliottaaae5352015-07-06 14:27:58 -0600806 assert(demo->buffers);
807
Ian Elliotta0781972015-08-21 15:09:33 -0600808 for (i = 0; i < demo->swapchainImageCount; i++) {
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600809 VkImageViewCreateInfo color_image_view = {
810 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600811 .pNext = NULL,
812 .format = demo->format,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600813 .channels = {
814 .r = VK_CHANNEL_SWIZZLE_R,
815 .g = VK_CHANNEL_SWIZZLE_G,
816 .b = VK_CHANNEL_SWIZZLE_B,
817 .a = VK_CHANNEL_SWIZZLE_A,
818 },
819 .subresourceRange = {
Cody Northrop0e951672015-09-14 13:48:12 -0600820 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600821 .baseMipLevel = 0,
822 .mipLevels = 1,
Courtney Goeltzenleuchterfc465b82015-09-10 16:38:41 -0600823 .baseArrayLayer = 0,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600824 .arraySize = 1
825 },
826 .viewType = VK_IMAGE_VIEW_TYPE_2D,
827 .flags = 0,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600828 };
829
Ian Elliotta0781972015-08-21 15:09:33 -0600830 demo->buffers[i].image = swapchainImages[i];
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600831
Tony Barbour15a4ef62015-10-21 10:14:48 -0600832 // Render loop will expect image to have been used before and in VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR
833 // layout and will change to COLOR_ATTACHMENT_OPTIMAL, so init the image to that state
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600834 demo_set_image_layout(demo, demo->buffers[i].image,
Tony Barbourc99f2942015-10-12 11:07:58 -0600835 VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600836 VK_IMAGE_LAYOUT_UNDEFINED,
Tony Barbour15a4ef62015-10-21 10:14:48 -0600837 VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600838
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600839 color_image_view.image = demo->buffers[i].image;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600840
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600841 err = vkCreateImageView(demo->device,
842 &color_image_view, &demo->buffers[i].view);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600843 assert(!err);
844 }
845}
846
847static void demo_prepare_depth(struct demo *demo)
848{
Tony Barbour72304ef2015-04-16 15:59:00 -0600849 const VkFormat depth_format = VK_FORMAT_D16_UNORM;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600850 const VkImageCreateInfo image = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600851 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600852 .pNext = NULL,
Tony Barbour72304ef2015-04-16 15:59:00 -0600853 .imageType = VK_IMAGE_TYPE_2D,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600854 .format = depth_format,
855 .extent = { demo->width, demo->height, 1 },
856 .mipLevels = 1,
857 .arraySize = 1,
858 .samples = 1,
Tony Barbour72304ef2015-04-16 15:59:00 -0600859 .tiling = VK_IMAGE_TILING_OPTIMAL,
Courtney Goeltzenleuchter4e368ee2015-09-10 14:14:11 -0600860 .usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600861 .flags = 0,
862 };
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200863
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600864 VkImageViewCreateInfo view = {
865 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600866 .pNext = NULL,
Tony Barbour155cce82015-07-03 10:33:54 -0600867 .image.handle = VK_NULL_HANDLE,
Courtney Goeltzenleuchter556ee322015-07-15 17:41:38 -0600868 .format = depth_format,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600869 .subresourceRange = {
Cody Northrop0e951672015-09-14 13:48:12 -0600870 .aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600871 .baseMipLevel = 0,
872 .mipLevels = 1,
Courtney Goeltzenleuchterfc465b82015-09-10 16:38:41 -0600873 .baseArrayLayer = 0,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600874 .arraySize = 1
875 },
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600876 .flags = 0,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600877 .viewType = VK_IMAGE_VIEW_TYPE_2D,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600878 };
Mike Stroyanebae8322015-04-17 12:36:38 -0600879
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500880 VkMemoryRequirements mem_reqs;
Tony Barbourfdc2d352015-04-22 09:02:32 -0600881 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600882 bool U_ASSERT_ONLY pass;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600883
884 demo->depth.format = depth_format;
885
886 /* create image */
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600887 err = vkCreateImage(demo->device, &image,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600888 &demo->depth.image);
889 assert(!err);
890
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -0600891 vkGetImageMemoryRequirements(demo->device,
Tony Barbour155cce82015-07-03 10:33:54 -0600892 demo->depth.image, &mem_reqs);
Tony Barbourcb59a5d2015-10-23 10:53:30 -0600893 assert(!err);
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600894
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200895 demo->depth.mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
896 demo->depth.mem_alloc.pNext = NULL;
897 demo->depth.mem_alloc.allocationSize = mem_reqs.size;
898 demo->depth.mem_alloc.memoryTypeIndex = 0;
899
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600900 pass = memory_type_from_properties(demo,
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600901 mem_reqs.memoryTypeBits,
Tony Barbour8a9f62a2015-10-15 12:42:56 -0600902 0, /* No requirements */
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200903 &demo->depth.mem_alloc.memoryTypeIndex);
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600904 assert(pass);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600905
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500906 /* allocate memory */
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200907 err = vkAllocMemory(demo->device, &demo->depth.mem_alloc, &demo->depth.mem);
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500908 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600909
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500910 /* bind memory */
Tony Barbour155cce82015-07-03 10:33:54 -0600911 err = vkBindImageMemory(demo->device, demo->depth.image,
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500912 demo->depth.mem, 0);
913 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600914
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600915 demo_set_image_layout(demo, demo->depth.image,
Cody Northrop0e951672015-09-14 13:48:12 -0600916 VK_IMAGE_ASPECT_DEPTH_BIT,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600917 VK_IMAGE_LAYOUT_UNDEFINED,
918 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600919
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600920 /* create image view */
921 view.image = demo->depth.image;
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600922 err = vkCreateImageView(demo->device, &view, &demo->depth.view);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600923 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600924}
925
Tony Barbour1a86d032015-09-21 15:17:33 -0600926/* Load a ppm file into memory */
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700927bool loadTexture(const char *filename, uint8_t *rgba_data,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600928 VkSubresourceLayout *layout,
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600929 int32_t *width, int32_t *height)
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600930{
Tony Barbour1a86d032015-09-21 15:17:33 -0600931 FILE *fPtr = fopen(filename,"rb");
932 char header[256], *cPtr;
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600933
Tony Barbour1a86d032015-09-21 15:17:33 -0600934 if (!fPtr)
935 return false;
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600936
Tony Barbour1a86d032015-09-21 15:17:33 -0600937 cPtr = fgets(header, 256, fPtr); // P6
938 if (cPtr == NULL || strncmp(header, "P6\n", 3))
939 return false;
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600940
Tony Barbour1a86d032015-09-21 15:17:33 -0600941 do {
942 cPtr = fgets(header, 256, fPtr);
943 if (cPtr == NULL)
944 return false;
945 } while ( !strncmp(header, "#", 1) );
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600946
Tony Barbour1a86d032015-09-21 15:17:33 -0600947 sscanf(header, "%u %u", height, width);
948 if (rgba_data == NULL)
949 return true;
950 fgets(header, 256, fPtr); // Format
951 if (cPtr == NULL || strncmp(header, "255\n", 3))
952 return false;
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600953
Tony Barbour1a86d032015-09-21 15:17:33 -0600954 for(int y = 0; y < *height; y++)
955 {
956 uint8_t *rowPtr = rgba_data;
957 for(int x = 0; x < *width; x++)
958 {
959 fread(rowPtr, 3, 1, fPtr);
960 rowPtr[3] = 255; /* Alpha of 1 */
961 rowPtr += 4;
962 }
963 rgba_data += layout->rowPitch;
964 }
965 fclose(fPtr);
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600966 return true;
967}
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600968
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700969static void demo_prepare_texture_image(struct demo *demo,
970 const char *filename,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600971 struct texture_object *tex_obj,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600972 VkImageTiling tiling,
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -0600973 VkImageUsageFlags usage,
Tony Barbour8a9f62a2015-10-15 12:42:56 -0600974 VkFlags required_props)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600975{
Mike Stroyan8b89e072015-06-15 14:21:03 -0600976 const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600977 int32_t tex_width;
978 int32_t tex_height;
Tony Barbourfdc2d352015-04-22 09:02:32 -0600979 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600980 bool U_ASSERT_ONLY pass;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700981
David Pinedo30bd71d2015-04-23 08:16:57 -0600982 if (!loadTexture(filename, NULL, NULL, &tex_width, &tex_height))
983 {
984 printf("Failed to load textures\n");
985 fflush(stdout);
986 exit(1);
987 }
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700988
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600989 tex_obj->tex_width = tex_width;
990 tex_obj->tex_height = tex_height;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700991
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600992 const VkImageCreateInfo image_create_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600993 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700994 .pNext = NULL,
Tony Barbour72304ef2015-04-16 15:59:00 -0600995 .imageType = VK_IMAGE_TYPE_2D,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700996 .format = tex_format,
997 .extent = { tex_width, tex_height, 1 },
998 .mipLevels = 1,
999 .arraySize = 1,
1000 .samples = 1,
1001 .tiling = tiling,
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -06001002 .usage = usage,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001003 .flags = 0,
1004 };
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001005
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001006 VkMemoryRequirements mem_reqs;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001007
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001008 err = vkCreateImage(demo->device, &image_create_info,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001009 &tex_obj->image);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001010 assert(!err);
1011
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06001012 vkGetImageMemoryRequirements(demo->device, tex_obj->image, &mem_reqs);
Piers Daniell735ee532015-02-23 16:23:13 -07001013
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001014 tex_obj->mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
1015 tex_obj->mem_alloc.pNext = NULL;
1016 tex_obj->mem_alloc.allocationSize = mem_reqs.size;
1017 tex_obj->mem_alloc.memoryTypeIndex = 0;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001018
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -06001019 pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, required_props, &tex_obj->mem_alloc.memoryTypeIndex);
1020 assert(pass);
Mark Lobodzinskieadf9982015-07-02 16:49:40 -06001021
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001022 /* allocate memory */
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001023 err = vkAllocMemory(demo->device, &tex_obj->mem_alloc,
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001024 &(tex_obj->mem));
1025 assert(!err);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001026
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001027 /* bind memory */
Tony Barbour155cce82015-07-03 10:33:54 -06001028 err = vkBindImageMemory(demo->device, tex_obj->image,
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001029 tex_obj->mem, 0);
1030 assert(!err);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001031
Tony Barbour8a9f62a2015-10-15 12:42:56 -06001032 if (required_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001033 const VkImageSubresource subres = {
Courtney Goeltzenleuchter51041262015-10-21 17:00:51 -06001034 .aspect = VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001035 .mipLevel = 0,
Courtney Goeltzenleuchterfc465b82015-09-10 16:38:41 -06001036 .arrayLayer = 0,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001037 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001038 VkSubresourceLayout layout;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001039 void *data;
1040
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06001041 vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001042
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001043 err = vkMapMemory(demo->device, tex_obj->mem, 0, tex_obj->mem_alloc.allocationSize, 0, &data);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001044 assert(!err);
1045
1046 if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) {
1047 fprintf(stderr, "Error loading texture: %s\n", filename);
1048 }
1049
Mark Lobodzinskie4c92a62015-09-07 13:59:43 -06001050 vkUnmapMemory(demo->device, tex_obj->mem);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001051 }
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001052
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001053 tex_obj->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001054 demo_set_image_layout(demo, tex_obj->image,
Tony Barbourc99f2942015-10-12 11:07:58 -06001055 VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001056 VK_IMAGE_LAYOUT_UNDEFINED,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001057 tex_obj->imageLayout);
1058 /* setting the image layout does not reference the actual memory so no need to add a mem ref */
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001059}
1060
Mark Lobodzinskida9b1092015-04-16 11:44:05 -05001061static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_objs)
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001062{
1063 /* clean up staging resources */
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001064 vkFreeMemory(demo->device, tex_objs->mem);
Tony Barbour155cce82015-07-03 10:33:54 -06001065 vkDestroyImage(demo->device, tex_objs->image);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001066}
1067
1068static void demo_prepare_textures(struct demo *demo)
1069{
Tony Barbour72304ef2015-04-16 15:59:00 -06001070 const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001071 VkFormatProperties props;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001072 uint32_t i;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001073
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06001074 vkGetPhysicalDeviceFormatProperties(demo->gpu, tex_format, &props);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001075
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001076 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06001077 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001078
FslNopper6a7e50e2015-05-06 21:42:01 +02001079 if ((props.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) && !demo->use_staging_buffer) {
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001080 /* Device can texture using linear textures */
1081 demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i],
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -06001082 VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_SAMPLED_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
Tony Barbour72304ef2015-04-16 15:59:00 -06001083 } else if (props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001084 /* Must use staging buffer to copy linear texture to optimized */
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001085 struct texture_object staging_texture;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001086
1087 memset(&staging_texture, 0, sizeof(staging_texture));
1088 demo_prepare_texture_image(demo, tex_files[i], &staging_texture,
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -06001089 VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001090
1091 demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i],
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -06001092 VK_IMAGE_TILING_OPTIMAL,
1093 (VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),
1094 VK_MEMORY_PROPERTY_DEVICE_ONLY);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001095
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001096 demo_set_image_layout(demo, staging_texture.image,
Tony Barbourc99f2942015-10-12 11:07:58 -06001097 VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001098 staging_texture.imageLayout,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001099 VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001100
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001101 demo_set_image_layout(demo, demo->textures[i].image,
Tony Barbourc99f2942015-10-12 11:07:58 -06001102 VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001103 demo->textures[i].imageLayout,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001104 VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001105
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001106 VkImageCopy copy_region = {
Courtney Goeltzenleuchter51041262015-10-21 17:00:51 -06001107 .srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0 },
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001108 .srcOffset = { 0, 0, 0 },
Courtney Goeltzenleuchter51041262015-10-21 17:00:51 -06001109 .destSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0 },
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001110 .destOffset = { 0, 0, 0 },
1111 .extent = { staging_texture.tex_width, staging_texture.tex_height, 1 },
1112 };
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001113 vkCmdCopyImage(demo->cmd,
1114 staging_texture.image, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
1115 demo->textures[i].image, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
Courtney Goeltzenleuchter8e89a312015-03-25 11:25:10 -06001116 1, &copy_region);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001117
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001118 demo_set_image_layout(demo, demo->textures[i].image,
Tony Barbourc99f2942015-10-12 11:07:58 -06001119 VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001120 VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001121 demo->textures[i].imageLayout);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001122
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001123 demo_flush_init_cmd(demo);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001124
Courtney Goeltzenleuchterf3aeb2b2015-04-21 09:30:03 -06001125 demo_destroy_texture_image(demo, &staging_texture);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001126 } else {
Mike Stroyan8b89e072015-06-15 14:21:03 -06001127 /* Can't support VK_FORMAT_R8G8B8A8_UNORM !? */
1128 assert(!"No support for R8G8B8A8_UNORM as texture image format");
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001129 }
1130
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001131 const VkSamplerCreateInfo sampler = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001132 .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001133 .pNext = NULL,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001134 .magFilter = VK_TEX_FILTER_NEAREST,
1135 .minFilter = VK_TEX_FILTER_NEAREST,
Tony Barbour72304ef2015-04-16 15:59:00 -06001136 .mipMode = VK_TEX_MIPMAP_MODE_BASE,
Courtney Goeltzenleuchter781da8a2015-09-10 14:08:50 -06001137 .addressModeU = VK_TEX_ADDRESS_MODE_CLAMP,
1138 .addressModeV = VK_TEX_ADDRESS_MODE_CLAMP,
1139 .addressModeW = VK_TEX_ADDRESS_MODE_CLAMP,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001140 .mipLodBias = 0.0f,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001141 .maxAnisotropy = 1,
Tony Barbour72304ef2015-04-16 15:59:00 -06001142 .compareOp = VK_COMPARE_OP_NEVER,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001143 .minLod = 0.0f,
1144 .maxLod = 0.0f,
Tony Barbourcb530c72015-06-25 16:56:44 -06001145 .borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
Mark Lobodzinski644dc492015-09-01 15:42:56 -06001146 .unnormalizedCoordinates = VK_FALSE,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001147 };
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001148
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001149 VkImageViewCreateInfo view = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001150 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001151 .pNext = NULL,
Tony Barbour155cce82015-07-03 10:33:54 -06001152 .image.handle = VK_NULL_HANDLE,
Tony Barbour72304ef2015-04-16 15:59:00 -06001153 .viewType = VK_IMAGE_VIEW_TYPE_2D,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001154 .format = tex_format,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001155 .channels = { VK_CHANNEL_SWIZZLE_R,
1156 VK_CHANNEL_SWIZZLE_G,
1157 VK_CHANNEL_SWIZZLE_B,
1158 VK_CHANNEL_SWIZZLE_A, },
Cody Northrop0e951672015-09-14 13:48:12 -06001159 .subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 },
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -06001160 .flags = 0,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001161 };
Jon Ashburnb2a66652015-01-16 09:37:43 -07001162
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001163 /* create sampler */
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001164 err = vkCreateSampler(demo->device, &sampler,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001165 &demo->textures[i].sampler);
1166 assert(!err);
1167
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001168 /* create image view */
1169 view.image = demo->textures[i].image;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001170 err = vkCreateImageView(demo->device, &view,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001171 &demo->textures[i].view);
1172 assert(!err);
1173 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001174}
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001175
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001176void demo_prepare_cube_data_buffer(struct demo *demo)
1177{
Courtney Goeltzenleuchter28c4d5f2015-04-14 18:48:46 -06001178 VkBufferCreateInfo buf_info;
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001179 VkMemoryRequirements mem_reqs;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001180 uint8_t *pData;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001181 int i;
1182 mat4x4 MVP, VP;
Tony Barbourfdc2d352015-04-22 09:02:32 -06001183 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -06001184 bool U_ASSERT_ONLY pass;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001185 struct vktexcube_vs_uniform data;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001186
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001187 mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001188 mat4x4_mul(MVP, VP, demo->model_matrix);
1189 memcpy(data.mvp, MVP, sizeof(MVP));
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001190// dumpMatrix("MVP", MVP);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001191
1192 for (i=0; i<12*3; i++) {
1193 data.position[i][0] = g_vertex_buffer_data[i*3];
1194 data.position[i][1] = g_vertex_buffer_data[i*3+1];
1195 data.position[i][2] = g_vertex_buffer_data[i*3+2];
1196 data.position[i][3] = 1.0f;
1197 data.attr[i][0] = g_uv_buffer_data[2*i];
1198 data.attr[i][1] = g_uv_buffer_data[2*i + 1];
1199 data.attr[i][2] = 0;
1200 data.attr[i][3] = 0;
1201 }
1202
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001203 memset(&buf_info, 0, sizeof(buf_info));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001204 buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -06001205 buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
Cody Northrop91807302015-07-16 10:29:32 -06001206 buf_info.size = sizeof(data);
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001207 err = vkCreateBuffer(demo->device, &buf_info, &demo->uniform_data.buf);
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001208 assert(!err);
1209
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06001210 vkGetBufferMemoryRequirements(demo->device, demo->uniform_data.buf, &mem_reqs);
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001211
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001212 demo->uniform_data.mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
1213 demo->uniform_data.mem_alloc.pNext = NULL;
1214 demo->uniform_data.mem_alloc.allocationSize = mem_reqs.size;
1215 demo->uniform_data.mem_alloc.memoryTypeIndex = 0;
1216
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -06001217 pass = memory_type_from_properties(demo,
Mark Lobodzinskieadf9982015-07-02 16:49:40 -06001218 mem_reqs.memoryTypeBits,
1219 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001220 &demo->uniform_data.mem_alloc.memoryTypeIndex);
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -06001221 assert(pass);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001222
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001223 err = vkAllocMemory(demo->device, &demo->uniform_data.mem_alloc, &(demo->uniform_data.mem));
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001224 assert(!err);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001225
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001226 err = vkMapMemory(demo->device, demo->uniform_data.mem, 0, demo->uniform_data.mem_alloc.allocationSize, 0, (void **) &pData);
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001227 assert(!err);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001228
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001229 memcpy(pData, &data, sizeof data);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001230
Mark Lobodzinskie4c92a62015-09-07 13:59:43 -06001231 vkUnmapMemory(demo->device, demo->uniform_data.mem);
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001232
Tony Barbour155cce82015-07-03 10:33:54 -06001233 err = vkBindBufferMemory(demo->device,
1234 demo->uniform_data.buf,
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001235 demo->uniform_data.mem, 0);
1236 assert(!err);
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001237
Courtney Goeltzenleuchter94415342015-09-14 14:14:21 -06001238 demo->uniform_data.desc.bufferInfo.buffer = demo->uniform_data.buf;
1239 demo->uniform_data.desc.bufferInfo.offset = 0;
1240 demo->uniform_data.desc.bufferInfo.range = sizeof(data);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001241}
1242
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001243static void demo_prepare_descriptor_layout(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001244{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001245 const VkDescriptorSetLayoutBinding layout_bindings[2] = {
Chia-I Wua2aa8632015-03-26 15:04:41 +08001246 [0] = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001247 .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
Chia-I Wu6d29a412015-05-25 16:22:52 +08001248 .arraySize = 1,
Tony Barbour72304ef2015-04-16 15:59:00 -06001249 .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
Chia-I Wu91e8e212015-03-27 12:56:09 +08001250 .pImmutableSamplers = NULL,
Chia-I Wua2aa8632015-03-26 15:04:41 +08001251 },
1252 [1] = {
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -06001253 .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
Chia-I Wu6d29a412015-05-25 16:22:52 +08001254 .arraySize = DEMO_TEXTURE_COUNT,
Tony Barbour72304ef2015-04-16 15:59:00 -06001255 .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
Chia-I Wu91e8e212015-03-27 12:56:09 +08001256 .pImmutableSamplers = NULL,
Chia-I Wua2aa8632015-03-26 15:04:41 +08001257 },
1258 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001259 const VkDescriptorSetLayoutCreateInfo descriptor_layout = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001260 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001261 .pNext = NULL,
Chia-I Wua2aa8632015-03-26 15:04:41 +08001262 .count = 2,
1263 .pBinding = layout_bindings,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001264 };
Tony Barbourfdc2d352015-04-22 09:02:32 -06001265 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001266
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001267 err = vkCreateDescriptorSetLayout(demo->device,
Chia-I Wub58c24a2015-03-26 15:27:55 +08001268 &descriptor_layout, &demo->desc_layout);
1269 assert(!err);
1270
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -05001271 const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
1272 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
1273 .pNext = NULL,
1274 .descriptorSetCount = 1,
1275 .pSetLayouts = &demo->desc_layout,
1276 };
1277
1278 err = vkCreatePipelineLayout(demo->device,
1279 &pPipelineLayoutCreateInfo,
1280 &demo->pipeline_layout);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001281 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001282}
1283
Chia-I Wuf973e322015-07-08 13:34:24 +08001284static void demo_prepare_render_pass(struct demo *demo)
1285{
Chia-I Wua74c5b22015-07-07 11:50:03 +08001286 const VkAttachmentDescription attachments[2] = {
1287 [0] = {
1288 .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION,
1289 .pNext = NULL,
1290 .format = demo->format,
1291 .samples = 1,
1292 .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
1293 .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
1294 .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1295 .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1296 .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1297 .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1298 },
1299 [1] = {
1300 .sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION,
1301 .pNext = NULL,
1302 .format = demo->depth.format,
1303 .samples = 1,
1304 .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
1305 .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1306 .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1307 .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1308 .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1309 .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1310 },
Chia-I Wuf973e322015-07-08 13:34:24 +08001311 };
Chia-I Wua74c5b22015-07-07 11:50:03 +08001312 const VkAttachmentReference color_reference = {
1313 .attachment = 0,
1314 .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1315 };
1316 const VkSubpassDescription subpass = {
1317 .sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION,
1318 .pNext = NULL,
1319 .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
1320 .flags = 0,
1321 .inputCount = 0,
Cody Northrop945bb832015-08-04 11:16:41 -06001322 .pInputAttachments = NULL,
Chia-I Wua74c5b22015-07-07 11:50:03 +08001323 .colorCount = 1,
Cody Northrop945bb832015-08-04 11:16:41 -06001324 .pColorAttachments = &color_reference,
1325 .pResolveAttachments = NULL,
Chia-I Wua74c5b22015-07-07 11:50:03 +08001326 .depthStencilAttachment = {
1327 .attachment = 1,
1328 .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1329 },
1330 .preserveCount = 0,
Cody Northrop945bb832015-08-04 11:16:41 -06001331 .pPreserveAttachments = NULL,
Chia-I Wua74c5b22015-07-07 11:50:03 +08001332 };
Chia-I Wuf973e322015-07-08 13:34:24 +08001333 const VkRenderPassCreateInfo rp_info = {
1334 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
1335 .pNext = NULL,
Chia-I Wua74c5b22015-07-07 11:50:03 +08001336 .attachmentCount = 2,
1337 .pAttachments = attachments,
1338 .subpassCount = 1,
1339 .pSubpasses = &subpass,
1340 .dependencyCount = 0,
1341 .pDependencies = NULL,
Chia-I Wuf973e322015-07-08 13:34:24 +08001342 };
Chia-I Wua74c5b22015-07-07 11:50:03 +08001343 VkResult U_ASSERT_ONLY err;
Chia-I Wuf973e322015-07-08 13:34:24 +08001344
1345 err = vkCreateRenderPass(demo->device, &rp_info, &demo->render_pass);
1346 assert(!err);
1347}
1348
Tobin Ehlisd1f17ac2015-07-02 11:02:49 -06001349static VkShader demo_prepare_shader(struct demo* demo,
Courtney Goeltzenleuchter34d57d52015-10-21 17:08:06 -06001350 VkShaderStageFlagBits stage,
Tony Barbourb6dba5c2015-07-21 09:04:41 -06001351 VkShaderModule* pShaderModule,
Tobin Ehlisd1f17ac2015-07-02 11:02:49 -06001352 const void* code,
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001353 size_t size)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001354{
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001355 VkShaderModuleCreateInfo moduleCreateInfo;
1356 VkShaderCreateInfo shaderCreateInfo;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001357 VkShader shader;
1358 VkResult err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001359
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001360
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001361 moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
1362 moduleCreateInfo.pNext = NULL;
1363
1364 shaderCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
1365 shaderCreateInfo.pNext = NULL;
Tobin Ehlisd1f17ac2015-07-02 11:02:49 -06001366 shaderCreateInfo.pName = "main";
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001367
Cody Northrop1fedb212015-05-28 11:27:16 -06001368 if (!demo->use_glsl) {
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001369 moduleCreateInfo.codeSize = size;
1370 moduleCreateInfo.pCode = code;
1371 moduleCreateInfo.flags = 0;
Tony Barbourb6dba5c2015-07-21 09:04:41 -06001372 err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
Courtney Goeltzenleuchter874eb8d2015-09-24 17:16:48 -06001373 assert(!err);
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001374
1375 shaderCreateInfo.flags = 0;
Tony Barbourb6dba5c2015-07-21 09:04:41 -06001376 shaderCreateInfo.module = *pShaderModule;
Piers Daniell8611f132015-07-16 09:35:35 -06001377 shaderCreateInfo.pName = "main";
Cody Northropa9e21942015-08-24 15:11:10 -06001378 shaderCreateInfo.stage = stage;
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001379 err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
Tony Barbourcb59a5d2015-10-23 10:53:30 -06001380 assert(!err);
Cody Northrop1fedb212015-05-28 11:27:16 -06001381 } else {
1382 // Create fake SPV structure to feed GLSL
1383 // to the driver "under the covers"
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001384 moduleCreateInfo.codeSize = 3 * sizeof(uint32_t) + size + 1;
1385 moduleCreateInfo.pCode = malloc(moduleCreateInfo.codeSize);
1386 moduleCreateInfo.flags = 0;
Cody Northrop1fedb212015-05-28 11:27:16 -06001387
1388 /* try version 0 first: VkShaderStage followed by GLSL */
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001389 ((uint32_t *) moduleCreateInfo.pCode)[0] = ICD_SPV_MAGIC;
1390 ((uint32_t *) moduleCreateInfo.pCode)[1] = 0;
1391 ((uint32_t *) moduleCreateInfo.pCode)[2] = stage;
1392 memcpy(((uint32_t *) moduleCreateInfo.pCode + 3), code, size + 1);
Cody Northrop1fedb212015-05-28 11:27:16 -06001393
Tony Barbourb6dba5c2015-07-21 09:04:41 -06001394 err = vkCreateShaderModule(demo->device, &moduleCreateInfo, pShaderModule);
Cody Northrop1fedb212015-05-28 11:27:16 -06001395 if (err) {
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001396 free((void *) moduleCreateInfo.pCode);
Cody Northrop1fedb212015-05-28 11:27:16 -06001397 }
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001398
1399 shaderCreateInfo.flags = 0;
Tony Barbourb6dba5c2015-07-21 09:04:41 -06001400 shaderCreateInfo.module = *pShaderModule;
Piers Daniell8611f132015-07-16 09:35:35 -06001401 shaderCreateInfo.pName = "main";
Cody Northropa9e21942015-08-24 15:11:10 -06001402 shaderCreateInfo.stage = stage;
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001403 err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
Tony Barbourcb59a5d2015-10-23 10:53:30 -06001404 assert(!err);
Courtney Goeltzenleuchter874eb8d2015-09-24 17:16:48 -06001405 free((void *) moduleCreateInfo.pCode);
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001406 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001407 return shader;
1408}
1409
Cody Northrop8b12a1f2015-03-17 15:55:58 -06001410char *demo_read_spv(const char *filename, size_t *psize)
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001411{
1412 long int size;
Tony Barbourf9921732015-04-22 11:36:22 -06001413 size_t U_ASSERT_ONLY retval;
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001414 void *shader_code;
1415
1416 FILE *fp = fopen(filename, "rb");
1417 if (!fp) return NULL;
1418
1419 fseek(fp, 0L, SEEK_END);
1420 size = ftell(fp);
1421
1422 fseek(fp, 0L, SEEK_SET);
1423
1424 shader_code = malloc(size);
Tony Barbourfdc2d352015-04-22 09:02:32 -06001425 retval = fread(shader_code, size, 1, fp);
1426 assert(retval == 1);
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001427
1428 *psize = size;
1429
1430 return shader_code;
1431}
1432
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001433static VkShader demo_prepare_vs(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001434{
Cody Northrop1fedb212015-05-28 11:27:16 -06001435 if (!demo->use_glsl) {
Courtney Goeltzenleuchter874eb8d2015-09-24 17:16:48 -06001436 VkShader shader;
Cody Northrop1fedb212015-05-28 11:27:16 -06001437 void *vertShaderCode;
1438 size_t size;
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001439
Cody Northrop1fedb212015-05-28 11:27:16 -06001440 vertShaderCode = demo_read_spv("cube-vert.spv", &size);
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001441
Courtney Goeltzenleuchter34d57d52015-10-21 17:08:06 -06001442 shader = demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX_BIT, &demo->vert_shader_module,
Courtney Goeltzenleuchter874eb8d2015-09-24 17:16:48 -06001443 vertShaderCode, size);
1444 free(vertShaderCode);
1445 return shader;
Cody Northrop1fedb212015-05-28 11:27:16 -06001446 } else {
1447 static const char *vertShaderText =
1448 "#version 140\n"
1449 "#extension GL_ARB_separate_shader_objects : enable\n"
1450 "#extension GL_ARB_shading_language_420pack : enable\n"
1451 "\n"
1452 "layout(binding = 0) uniform buf {\n"
1453 " mat4 MVP;\n"
1454 " vec4 position[12*3];\n"
1455 " vec4 attr[12*3];\n"
1456 "} ubuf;\n"
1457 "\n"
1458 "layout (location = 0) out vec4 texcoord;\n"
1459 "\n"
1460 "void main() \n"
1461 "{\n"
1462 " texcoord = ubuf.attr[gl_VertexID];\n"
1463 " gl_Position = ubuf.MVP * ubuf.position[gl_VertexID];\n"
1464 "\n"
1465 " // GL->VK conventions\n"
1466 " gl_Position.y = -gl_Position.y;\n"
1467 " gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0;\n"
1468 "}\n";
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001469
Courtney Goeltzenleuchter34d57d52015-10-21 17:08:06 -06001470 return demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX_BIT, &demo->vert_shader_module,
Cody Northrop1fedb212015-05-28 11:27:16 -06001471 (const void *) vertShaderText,
1472 strlen(vertShaderText));
1473 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001474}
1475
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001476static VkShader demo_prepare_fs(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001477{
Cody Northrop1fedb212015-05-28 11:27:16 -06001478 if (!demo->use_glsl) {
Courtney Goeltzenleuchter874eb8d2015-09-24 17:16:48 -06001479 VkShader shader;
Cody Northrop1fedb212015-05-28 11:27:16 -06001480 void *fragShaderCode;
1481 size_t size;
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001482
Cody Northrop1fedb212015-05-28 11:27:16 -06001483 fragShaderCode = demo_read_spv("cube-frag.spv", &size);
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001484
Courtney Goeltzenleuchter34d57d52015-10-21 17:08:06 -06001485 shader = demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT_BIT, &demo->frag_shader_module,
Courtney Goeltzenleuchter874eb8d2015-09-24 17:16:48 -06001486 fragShaderCode, size);
1487 free(fragShaderCode);
1488 return shader;
Cody Northrop1fedb212015-05-28 11:27:16 -06001489 } else {
1490 static const char *fragShaderText =
1491 "#version 140\n"
1492 "#extension GL_ARB_separate_shader_objects : enable\n"
1493 "#extension GL_ARB_shading_language_420pack : enable\n"
1494 "layout (binding = 1) uniform sampler2D tex;\n"
1495 "\n"
1496 "layout (location = 0) in vec4 texcoord;\n"
1497 "layout (location = 0) out vec4 uFragColor;\n"
1498 "void main() {\n"
1499 " uFragColor = texture(tex, texcoord.xy);\n"
1500 "}\n";
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001501
Courtney Goeltzenleuchter34d57d52015-10-21 17:08:06 -06001502 return demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT_BIT, &demo->frag_shader_module,
Cody Northrop1fedb212015-05-28 11:27:16 -06001503 (const void *) fragShaderText,
1504 strlen(fragShaderText));
1505 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001506}
1507
1508static void demo_prepare_pipeline(struct demo *demo)
1509{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001510 VkGraphicsPipelineCreateInfo pipeline;
Jon Ashburnc4ab7af2015-07-09 15:02:25 -06001511 VkPipelineCacheCreateInfo pipelineCache;
Tony Barbour194bf282015-07-10 15:29:03 -06001512 VkPipelineInputAssemblyStateCreateInfo ia;
1513 VkPipelineRasterStateCreateInfo rs;
1514 VkPipelineColorBlendStateCreateInfo cb;
1515 VkPipelineDepthStencilStateCreateInfo ds;
1516 VkPipelineViewportStateCreateInfo vp;
1517 VkPipelineMultisampleStateCreateInfo ms;
Piers Daniellba839d12015-09-29 13:01:09 -06001518 VkDynamicState dynamicStateEnables[VK_DYNAMIC_STATE_NUM];
1519 VkPipelineDynamicStateCreateInfo dynamicState;
Tony Barbourfdc2d352015-04-22 09:02:32 -06001520 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001521
Piers Daniellba839d12015-09-29 13:01:09 -06001522 memset(dynamicStateEnables, 0, sizeof dynamicStateEnables);
1523 memset(&dynamicState, 0, sizeof dynamicState);
1524 dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
1525 dynamicState.pDynamicStates = dynamicStateEnables;
1526
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001527 memset(&pipeline, 0, sizeof(pipeline));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001528 pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -05001529 pipeline.layout = demo->pipeline_layout;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001530
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001531 memset(&ia, 0, sizeof(ia));
Tony Barbour194bf282015-07-10 15:29:03 -06001532 ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
Tony Barbour72304ef2015-04-16 15:59:00 -06001533 ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001534
1535 memset(&rs, 0, sizeof(rs));
Tony Barbour194bf282015-07-10 15:29:03 -06001536 rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO;
Tony Barbour72304ef2015-04-16 15:59:00 -06001537 rs.fillMode = VK_FILL_MODE_SOLID;
1538 rs.cullMode = VK_CULL_MODE_BACK;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001539 rs.frontFace = VK_FRONT_FACE_CCW;
Courtney Goeltzenleuchter0db2c912015-10-15 12:57:38 -06001540 rs.depthClampEnable = VK_FALSE;
Cody Northrop709c1742015-08-17 11:10:49 -06001541 rs.rasterizerDiscardEnable = VK_FALSE;
1542 rs.depthBiasEnable = VK_FALSE;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001543
1544 memset(&cb, 0, sizeof(cb));
Tony Barbour194bf282015-07-10 15:29:03 -06001545 cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
1546 VkPipelineColorBlendAttachmentState att_state[1];
Tony Barbour29645d02015-01-16 14:27:35 -07001547 memset(att_state, 0, sizeof(att_state));
Tony Barbour29645d02015-01-16 14:27:35 -07001548 att_state[0].channelWriteMask = 0xf;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001549 att_state[0].blendEnable = VK_FALSE;
Tony Barbour29645d02015-01-16 14:27:35 -07001550 cb.attachmentCount = 1;
1551 cb.pAttachments = att_state;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001552
Tony Barbour29645d02015-01-16 14:27:35 -07001553 memset(&vp, 0, sizeof(vp));
Tony Barbour194bf282015-07-10 15:29:03 -06001554 vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
Tony Barbour72304ef2015-04-16 15:59:00 -06001555 vp.viewportCount = 1;
Piers Daniellba839d12015-09-29 13:01:09 -06001556 dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_VIEWPORT;
1557 vp.scissorCount = 1;
1558 dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_SCISSOR;
Tony Barbour29645d02015-01-16 14:27:35 -07001559
1560 memset(&ds, 0, sizeof(ds));
Tony Barbour194bf282015-07-10 15:29:03 -06001561 ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001562 ds.depthTestEnable = VK_TRUE;
1563 ds.depthWriteEnable = VK_TRUE;
Tony Barbour72304ef2015-04-16 15:59:00 -06001564 ds.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
Cody Northrop5e4125d2015-08-26 10:01:32 -06001565 ds.depthBoundsTestEnable = VK_FALSE;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001566 ds.back.stencilFailOp = VK_STENCIL_OP_KEEP;
1567 ds.back.stencilPassOp = VK_STENCIL_OP_KEEP;
Tony Barbour72304ef2015-04-16 15:59:00 -06001568 ds.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001569 ds.stencilTestEnable = VK_FALSE;
Tony Barbour29645d02015-01-16 14:27:35 -07001570 ds.front = ds.back;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001571
Tony Barbour29645d02015-01-16 14:27:35 -07001572 memset(&ms, 0, sizeof(ms));
Tony Barbour194bf282015-07-10 15:29:03 -06001573 ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
Cody Northrop011546b2015-08-04 14:34:54 -06001574 ms.pSampleMask = NULL;
Tony Barbour3ca22502015-06-26 10:18:34 -06001575 ms.rasterSamples = 1;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001576
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001577 // Two stages: vs and fs
1578 pipeline.stageCount = 2;
1579 VkPipelineShaderStageCreateInfo shaderStages[2];
1580 memset(&shaderStages, 0, 2 * sizeof(VkPipelineShaderStageCreateInfo));
1581
1582 shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
Courtney Goeltzenleuchter34d57d52015-10-21 17:08:06 -06001583 shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001584 shaderStages[0].shader = demo_prepare_vs(demo);
1585
1586 shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
Courtney Goeltzenleuchter34d57d52015-10-21 17:08:06 -06001587 shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001588 shaderStages[1].shader = demo_prepare_fs(demo);
1589
Jon Ashburnc4ab7af2015-07-09 15:02:25 -06001590 memset(&pipelineCache, 0, sizeof(pipelineCache));
1591 pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001592
Jon Ashburnc4ab7af2015-07-09 15:02:25 -06001593 err = vkCreatePipelineCache(demo->device, &pipelineCache, &demo->pipelineCache);
1594 assert(!err);
Tony Barbour194bf282015-07-10 15:29:03 -06001595
1596 pipeline.pVertexInputState = NULL;
1597 pipeline.pInputAssemblyState = &ia;
1598 pipeline.pRasterState = &rs;
1599 pipeline.pColorBlendState = &cb;
1600 pipeline.pMultisampleState = &ms;
1601 pipeline.pViewportState = &vp;
1602 pipeline.pDepthStencilState = &ds;
1603 pipeline.pStages = shaderStages;
Tony Barbour13ed3222015-08-06 14:32:54 -06001604 pipeline.renderPass = demo->render_pass;
Piers Daniellba839d12015-09-29 13:01:09 -06001605 pipeline.pDynamicState = &dynamicState;
Tony Barbour194bf282015-07-10 15:29:03 -06001606
Courtney Goeltzenleuchterd311fd02015-08-13 16:55:04 -06001607 pipeline.renderPass = demo->render_pass;
1608
Jon Ashburnc4ab7af2015-07-09 15:02:25 -06001609 err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, &demo->pipeline);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001610 assert(!err);
1611
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001612 for (uint32_t i = 0; i < pipeline.stageCount; i++) {
Tony Barbour155cce82015-07-03 10:33:54 -06001613 vkDestroyShader(demo->device, shaderStages[i].shader);
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001614 }
Tony Barbourb6dba5c2015-07-21 09:04:41 -06001615 vkDestroyShaderModule(demo->device, demo->frag_shader_module);
1616 vkDestroyShaderModule(demo->device, demo->vert_shader_module);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001617}
1618
Chia-I Wu63ea9262015-03-26 13:14:16 +08001619static void demo_prepare_descriptor_pool(struct demo *demo)
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001620{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001621 const VkDescriptorTypeCount type_counts[2] = {
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001622 [0] = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001623 .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001624 .count = 1,
1625 },
1626 [1] = {
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -06001627 .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001628 .count = DEMO_TEXTURE_COUNT,
1629 },
1630 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001631 const VkDescriptorPoolCreateInfo descriptor_pool = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001632 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001633 .pNext = NULL,
Courtney Goeltzenleuchtercf92aa42015-09-16 16:12:45 -06001634 .poolUsage = VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT,
1635 .maxSets = 1,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001636 .count = 2,
1637 .pTypeCount = type_counts,
1638 };
Tony Barbourfdc2d352015-04-22 09:02:32 -06001639 VkResult U_ASSERT_ONLY err;
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001640
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001641 err = vkCreateDescriptorPool(demo->device,
Chia-I Wu63ea9262015-03-26 13:14:16 +08001642 &descriptor_pool, &demo->desc_pool);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001643 assert(!err);
1644}
1645
1646static void demo_prepare_descriptor_set(struct demo *demo)
1647{
Chia-I Wuae721ba2015-05-25 16:27:55 +08001648 VkDescriptorInfo tex_descs[DEMO_TEXTURE_COUNT];
1649 VkWriteDescriptorSet writes[2];
Tony Barbourfdc2d352015-04-22 09:02:32 -06001650 VkResult U_ASSERT_ONLY err;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001651 uint32_t i;
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001652
Mike Stroyanebae8322015-04-17 12:36:38 -06001653 err = vkAllocDescriptorSets(demo->device, demo->desc_pool,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001654 VK_DESCRIPTOR_SET_USAGE_STATIC,
Chia-I Wu87544e72015-02-23 10:41:08 -07001655 1, &demo->desc_layout,
Cody Northrop15954692015-08-03 12:47:29 -06001656 &demo->desc_set);
1657 assert(!err);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001658
Chia-I Wuae721ba2015-05-25 16:27:55 +08001659 memset(&tex_descs, 0, sizeof(tex_descs));
1660 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
1661 tex_descs[i].sampler = demo->textures[i].sampler;
1662 tex_descs[i].imageView = demo->textures[i].view;
1663 tex_descs[i].imageLayout = VK_IMAGE_LAYOUT_GENERAL;
1664 }
1665
1666 memset(&writes, 0, sizeof(writes));
1667
1668 writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
1669 writes[0].destSet = demo->desc_set;
1670 writes[0].count = 1;
1671 writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
1672 writes[0].pDescriptors = &demo->uniform_data.desc;
1673
1674 writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
1675 writes[1].destSet = demo->desc_set;
1676 writes[1].destBinding = 1;
1677 writes[1].count = DEMO_TEXTURE_COUNT;
1678 writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
1679 writes[1].pDescriptors = tex_descs;
1680
Mark Lobodzinskie4c92a62015-09-07 13:59:43 -06001681 vkUpdateDescriptorSets(demo->device, 2, writes, 0, NULL);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001682}
1683
Chia-I Wuf973e322015-07-08 13:34:24 +08001684static void demo_prepare_framebuffers(struct demo *demo)
1685{
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -06001686 VkImageView attachments[2];
Cody Northrop2e11cad2015-08-04 10:47:08 -06001687 attachments[1] = demo->depth.view;
1688
Chia-I Wuf973e322015-07-08 13:34:24 +08001689 const VkFramebufferCreateInfo fb_info = {
1690 .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
1691 .pNext = NULL,
Chia-I Wua74c5b22015-07-07 11:50:03 +08001692 .renderPass = demo->render_pass,
1693 .attachmentCount = 2,
1694 .pAttachments = attachments,
Chia-I Wuf973e322015-07-08 13:34:24 +08001695 .width = demo->width,
1696 .height = demo->height,
1697 .layers = 1,
1698 };
1699 VkResult U_ASSERT_ONLY err;
1700 uint32_t i;
1701
Tony Barbourd8e504f2015-10-08 14:26:24 -06001702 demo->framebuffers = (VkFramebuffer *)malloc(demo->swapchainImageCount * sizeof(VkFramebuffer));
1703 assert(demo->framebuffers);
1704
1705 for (i = 0; i < demo->swapchainImageCount; i++) {
Cody Northrop2e11cad2015-08-04 10:47:08 -06001706 attachments[0] = demo->buffers[i].view;
Chia-I Wuf973e322015-07-08 13:34:24 +08001707 err = vkCreateFramebuffer(demo->device, &fb_info, &demo->framebuffers[i]);
1708 assert(!err);
1709 }
1710}
1711
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001712static void demo_prepare(struct demo *demo)
1713{
Cody Northrop91e221b2015-07-09 18:08:32 -06001714 VkResult U_ASSERT_ONLY err;
1715
1716 const VkCmdPoolCreateInfo cmd_pool_info = {
1717 .sType = VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO,
1718 .pNext = NULL,
1719 .queueFamilyIndex = demo->graphics_queue_node_index,
1720 .flags = 0,
1721 };
1722 err = vkCreateCommandPool(demo->device, &cmd_pool_info, &demo->cmd_pool);
1723 assert(!err);
1724
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001725 const VkCmdBufferCreateInfo cmd = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001726 .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001727 .pNext = NULL,
Cody Northrop91e221b2015-07-09 18:08:32 -06001728 .cmdPool = demo->cmd_pool,
Chia-I Wu57b23b42015-06-26 15:34:39 +08001729 .level = VK_CMD_BUFFER_LEVEL_PRIMARY,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001730 .flags = 0,
1731 };
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001732
1733 demo_prepare_buffers(demo);
1734 demo_prepare_depth(demo);
1735 demo_prepare_textures(demo);
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001736 demo_prepare_cube_data_buffer(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001737
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001738 demo_prepare_descriptor_layout(demo);
Chia-I Wuf973e322015-07-08 13:34:24 +08001739 demo_prepare_render_pass(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001740 demo_prepare_pipeline(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001741
Ian Elliotta0781972015-08-21 15:09:33 -06001742 for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001743 err = vkCreateCommandBuffer(demo->device, &cmd, &demo->buffers[i].cmd);
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001744 assert(!err);
1745 }
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001746
Chia-I Wu63ea9262015-03-26 13:14:16 +08001747 demo_prepare_descriptor_pool(demo);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001748 demo_prepare_descriptor_set(demo);
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001749
Chia-I Wuf973e322015-07-08 13:34:24 +08001750 demo_prepare_framebuffers(demo);
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001751
Ian Elliotta0781972015-08-21 15:09:33 -06001752 for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001753 demo->current_buffer = i;
1754 demo_draw_build_cmd(demo, demo->buffers[i].cmd);
1755 }
1756
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001757 /*
1758 * Prepare functions above may generate pipeline commands
1759 * that need to be flushed before beginning the render loop.
1760 */
1761 demo_flush_init_cmd(demo);
1762
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001763 demo->current_buffer = 0;
Jon Ashburn8d26c062015-04-24 09:46:24 -07001764 demo->prepared = true;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001765}
1766
David Pinedo2bb7c932015-06-18 17:03:14 -06001767static void demo_cleanup(struct demo *demo)
1768{
1769 uint32_t i;
1770
1771 demo->prepared = false;
1772
Tony Barbourd8e504f2015-10-08 14:26:24 -06001773 for (i = 0; i < demo->swapchainImageCount; i++) {
Tony Barbour155cce82015-07-03 10:33:54 -06001774 vkDestroyFramebuffer(demo->device, demo->framebuffers[i]);
1775 }
Tony Barbourd8e504f2015-10-08 14:26:24 -06001776 free(demo->framebuffers);
Tony Barbour155cce82015-07-03 10:33:54 -06001777 vkDestroyDescriptorPool(demo->device, demo->desc_pool);
Chia-I Wuf973e322015-07-08 13:34:24 +08001778
Tony Barbour155cce82015-07-03 10:33:54 -06001779 vkDestroyPipeline(demo->device, demo->pipeline);
Jon Ashburnc4ab7af2015-07-09 15:02:25 -06001780 vkDestroyPipelineCache(demo->device, demo->pipelineCache);
Tony Barbour155cce82015-07-03 10:33:54 -06001781 vkDestroyRenderPass(demo->device, demo->render_pass);
1782 vkDestroyPipelineLayout(demo->device, demo->pipeline_layout);
1783 vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout);
David Pinedo2bb7c932015-06-18 17:03:14 -06001784
1785 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
Tony Barbour155cce82015-07-03 10:33:54 -06001786 vkDestroyImageView(demo->device, demo->textures[i].view);
1787 vkDestroyImage(demo->device, demo->textures[i].image);
David Pinedo2bb7c932015-06-18 17:03:14 -06001788 vkFreeMemory(demo->device, demo->textures[i].mem);
Tony Barbour155cce82015-07-03 10:33:54 -06001789 vkDestroySampler(demo->device, demo->textures[i].sampler);
David Pinedo2bb7c932015-06-18 17:03:14 -06001790 }
Ian Elliotta0781972015-08-21 15:09:33 -06001791 demo->fpDestroySwapchainKHR(demo->device, demo->swap_chain);
David Pinedo2bb7c932015-06-18 17:03:14 -06001792
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -06001793 vkDestroyImageView(demo->device, demo->depth.view);
Tony Barbour155cce82015-07-03 10:33:54 -06001794 vkDestroyImage(demo->device, demo->depth.image);
David Pinedo2bb7c932015-06-18 17:03:14 -06001795 vkFreeMemory(demo->device, demo->depth.mem);
1796
Tony Barbour155cce82015-07-03 10:33:54 -06001797 vkDestroyBuffer(demo->device, demo->uniform_data.buf);
David Pinedo2bb7c932015-06-18 17:03:14 -06001798 vkFreeMemory(demo->device, demo->uniform_data.mem);
1799
Ian Elliotta0781972015-08-21 15:09:33 -06001800 for (i = 0; i < demo->swapchainImageCount; i++) {
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -06001801 vkDestroyImageView(demo->device, demo->buffers[i].view);
Tony Barbour155cce82015-07-03 10:33:54 -06001802 vkDestroyCommandBuffer(demo->device, demo->buffers[i].cmd);
David Pinedo2bb7c932015-06-18 17:03:14 -06001803 }
Ian Elliottaaae5352015-07-06 14:27:58 -06001804 free(demo->buffers);
David Pinedo2bb7c932015-06-18 17:03:14 -06001805
Courtney Goeltzenleuchter874eb8d2015-09-24 17:16:48 -06001806 free(demo->queue_props);
1807
Cody Northrop91e221b2015-07-09 18:08:32 -06001808 vkDestroyCommandPool(demo->device, demo->cmd_pool);
David Pinedo2bb7c932015-06-18 17:03:14 -06001809 vkDestroyDevice(demo->device);
Tony Barbourd70b42c2015-06-30 14:14:19 -06001810 if (demo->validate) {
1811 demo->dbgDestroyMsgCallback(demo->inst, demo->msg_callback);
1812 }
David Pinedo2bb7c932015-06-18 17:03:14 -06001813 vkDestroyInstance(demo->inst);
1814
1815#ifndef _WIN32
1816 xcb_destroy_window(demo->connection, demo->window);
1817 xcb_disconnect(demo->connection);
Courtney Goeltzenleuchter874eb8d2015-09-24 17:16:48 -06001818 free(demo->atom_wm_delete_window);
David Pinedo2bb7c932015-06-18 17:03:14 -06001819#endif // _WIN32
1820}
1821
1822// On MS-Windows, make this a global, so it's available to WndProc()
1823struct demo demo;
1824
Ian Elliott639ca472015-04-16 15:23:05 -06001825#ifdef _WIN32
1826static void demo_run(struct demo *demo)
1827{
Courtney Goeltzenleuchterb7e22702015-04-27 14:56:34 -06001828 if (!demo->prepared)
1829 return;
Ian Elliott639ca472015-04-16 15:23:05 -06001830 // Wait for work to finish before updating MVP.
1831 vkDeviceWaitIdle(demo->device);
1832 demo_update_data_buffer(demo);
1833
1834 demo_draw(demo);
1835
1836 // Wait for work to finish before updating MVP.
1837 vkDeviceWaitIdle(demo->device);
Ian Elliott639ca472015-04-16 15:23:05 -06001838
David Pinedo2bb7c932015-06-18 17:03:14 -06001839 demo->curFrame++;
1840
1841 if (demo->frameCount != INT_MAX && demo->curFrame == demo->frameCount)
1842 {
1843 demo->quit=true;
1844 demo_cleanup(demo);
1845 ExitProcess(0);
1846 }
1847
1848}
Ian Elliott639ca472015-04-16 15:23:05 -06001849
1850// MS-Windows event handling function:
1851LRESULT CALLBACK WndProc(HWND hWnd,
1852 UINT uMsg,
1853 WPARAM wParam,
1854 LPARAM lParam)
1855{
Ian Elliott639ca472015-04-16 15:23:05 -06001856 switch(uMsg)
1857 {
Ian Elliottaaae5352015-07-06 14:27:58 -06001858 case WM_CLOSE:
Ian Elliott639ca472015-04-16 15:23:05 -06001859 PostQuitMessage(0);
Tony Barbour3dddd5d2015-04-29 16:19:20 -06001860 break;
Ian Elliottaaae5352015-07-06 14:27:58 -06001861 case WM_PAINT:
Ian Elliott639ca472015-04-16 15:23:05 -06001862 demo_run(&demo);
Tony Barbourc8a59892015-10-20 12:49:46 -06001863 break;
Ian Elliott639ca472015-04-16 15:23:05 -06001864 default:
1865 break;
1866 }
1867 return (DefWindowProc(hWnd, uMsg, wParam, lParam));
1868}
1869
1870static void demo_create_window(struct demo *demo)
1871{
1872 WNDCLASSEX win_class;
1873
1874 // Initialize the window class structure:
1875 win_class.cbSize = sizeof(WNDCLASSEX);
1876 win_class.style = CS_HREDRAW | CS_VREDRAW;
1877 win_class.lpfnWndProc = WndProc;
1878 win_class.cbClsExtra = 0;
1879 win_class.cbWndExtra = 0;
1880 win_class.hInstance = demo->connection; // hInstance
1881 win_class.hIcon = LoadIcon(NULL, IDI_APPLICATION);
1882 win_class.hCursor = LoadCursor(NULL, IDC_ARROW);
1883 win_class.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
1884 win_class.lpszMenuName = NULL;
1885 win_class.lpszClassName = demo->name;
1886 win_class.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
1887 // Register window class:
1888 if (!RegisterClassEx(&win_class)) {
1889 // It didn't work, so try to give a useful error:
1890 printf("Unexpected error trying to start the application!\n");
1891 fflush(stdout);
1892 exit(1);
1893 }
1894 // Create window with the registered class:
Mike Stroyanb46779e2015-06-15 14:20:13 -06001895 RECT wr = { 0, 0, demo->width, demo->height };
1896 AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
Ian Elliott639ca472015-04-16 15:23:05 -06001897 demo->window = CreateWindowEx(0,
1898 demo->name, // class name
1899 demo->name, // app name
1900 WS_OVERLAPPEDWINDOW | // window style
1901 WS_VISIBLE |
1902 WS_SYSMENU,
1903 100,100, // x/y coords
Mike Stroyanb46779e2015-06-15 14:20:13 -06001904 wr.right-wr.left, // width
1905 wr.bottom-wr.top, // height
Ian Elliott639ca472015-04-16 15:23:05 -06001906 NULL, // handle to parent
1907 NULL, // handle to menu
1908 demo->connection, // hInstance
1909 NULL); // no extra parameters
1910 if (!demo->window) {
1911 // It didn't work, so try to give a useful error:
1912 printf("Cannot create a window in which to draw!\n");
1913 fflush(stdout);
1914 exit(1);
1915 }
1916}
1917#else // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001918static void demo_handle_event(struct demo *demo,
1919 const xcb_generic_event_t *event)
1920{
Piers Daniell735ee532015-02-23 16:23:13 -07001921 uint8_t event_code = event->response_type & 0x7f;
Courtney Goeltzenleuchter98cb2cb2014-11-06 14:27:52 -07001922 switch (event_code) {
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001923 case XCB_EXPOSE:
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07001924 // TODO: Resize window
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001925 break;
Courtney Goeltzenleuchter98cb2cb2014-11-06 14:27:52 -07001926 case XCB_CLIENT_MESSAGE:
1927 if((*(xcb_client_message_event_t*)event).data.data32[0] ==
1928 (*demo->atom_wm_delete_window).atom) {
1929 demo->quit = true;
1930 }
1931 break;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001932 case XCB_KEY_RELEASE:
1933 {
1934 const xcb_key_release_event_t *key =
1935 (const xcb_key_release_event_t *) event;
1936
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001937 switch (key->detail) {
1938 case 0x9: // Escape
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001939 demo->quit = true;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001940 break;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001941 case 0x71: // left arrow key
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001942 demo->spin_angle += demo->spin_increment;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001943 break;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001944 case 0x72: // right arrow key
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001945 demo->spin_angle -= demo->spin_increment;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001946 break;
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001947 case 0x41:
1948 demo->pause = !demo->pause;
Piers Daniell735ee532015-02-23 16:23:13 -07001949 break;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001950 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001951 }
1952 break;
1953 default:
1954 break;
1955 }
1956}
1957
1958static void demo_run(struct demo *demo)
1959{
1960 xcb_flush(demo->connection);
1961
1962 while (!demo->quit) {
1963 xcb_generic_event_t *event;
1964
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07001965 if (demo->pause) {
1966 event = xcb_wait_for_event(demo->connection);
1967 } else {
1968 event = xcb_poll_for_event(demo->connection);
1969 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001970 if (event) {
1971 demo_handle_event(demo, event);
1972 free(event);
Courtney Goeltzenleuchter98085552014-11-10 11:13:13 -07001973 }
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07001974
1975 // Wait for work to finish before updating MVP.
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001976 vkDeviceWaitIdle(demo->device);
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07001977 demo_update_data_buffer(demo);
1978
Courtney Goeltzenleuchter98085552014-11-10 11:13:13 -07001979 demo_draw(demo);
Courtney Goeltzenleuchter1454f3c2014-11-18 11:28:09 -07001980
Courtney Goeltzenleuchter98085552014-11-10 11:13:13 -07001981 // Wait for work to finish before updating MVP.
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001982 vkDeviceWaitIdle(demo->device);
David Pinedo2bb7c932015-06-18 17:03:14 -06001983 demo->curFrame++;
Tony Barbour1a86d032015-09-21 15:17:33 -06001984 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount)
David Pinedo2bb7c932015-06-18 17:03:14 -06001985 demo->quit = true;
1986
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001987 }
1988}
1989
1990static void demo_create_window(struct demo *demo)
1991{
1992 uint32_t value_mask, value_list[32];
1993
1994 demo->window = xcb_generate_id(demo->connection);
1995
1996 value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
1997 value_list[0] = demo->screen->black_pixel;
1998 value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |
1999 XCB_EVENT_MASK_EXPOSURE;
2000
2001 xcb_create_window(demo->connection,
2002 XCB_COPY_FROM_PARENT,
2003 demo->window, demo->screen->root,
2004 0, 0, demo->width, demo->height, 0,
2005 XCB_WINDOW_CLASS_INPUT_OUTPUT,
2006 demo->screen->root_visual,
2007 value_mask, value_list);
2008
Courtney Goeltzenleuchter98cb2cb2014-11-06 14:27:52 -07002009 /* Magic code that will send notification when window is destroyed */
2010 xcb_intern_atom_cookie_t cookie = xcb_intern_atom(demo->connection, 1, 12,
2011 "WM_PROTOCOLS");
2012 xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(demo->connection, cookie, 0);
2013
2014 xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(demo->connection, 0, 16, "WM_DELETE_WINDOW");
2015 demo->atom_wm_delete_window = xcb_intern_atom_reply(demo->connection, cookie2, 0);
2016
2017 xcb_change_property(demo->connection, XCB_PROP_MODE_REPLACE,
2018 demo->window, (*reply).atom, 4, 32, 1,
2019 &(*demo->atom_wm_delete_window).atom);
2020 free(reply);
2021
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002022 xcb_map_window(demo->connection, demo->window);
David Pinedo2bb7c932015-06-18 17:03:14 -06002023
2024 // Force the x/y coordinates to 100,100 results are identical in consecutive runs
2025 const uint32_t coords[] = {100, 100};
2026 xcb_configure_window(demo->connection, demo->window,
2027 XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, coords);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002028}
Ian Elliott639ca472015-04-16 15:23:05 -06002029#endif // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002030
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002031/*
2032 * Return 1 (true) if all layer names specified in check_names
2033 * can be found in given layer properties.
2034 */
Courtney Goeltzenleuchterc88ce512015-07-09 11:44:38 -06002035static VkBool32 demo_check_layers(uint32_t check_count, char **check_names,
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002036 uint32_t layer_count, VkLayerProperties *layers)
2037{
2038 for (uint32_t i = 0; i < check_count; i++) {
Courtney Goeltzenleuchterc88ce512015-07-09 11:44:38 -06002039 VkBool32 found = 0;
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002040 for (uint32_t j = 0; j < layer_count; j++) {
2041 if (!strcmp(check_names[i], layers[j].layerName)) {
2042 found = 1;
2043 }
2044 }
2045 if (!found) {
2046 fprintf(stderr, "Cannot find layer: %s\n", check_names[i]);
2047 return 0;
2048 }
2049 }
2050 return 1;
2051}
2052
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002053static void demo_init_vk(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002054{
Tobin Ehlis99239dc2015-04-16 18:04:57 -06002055 VkResult err;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002056 char *extension_names[64];
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002057 VkExtensionProperties *instance_extensions;
Tobin Ehlis8a724d82015-09-07 15:16:39 -06002058 VkPhysicalDevice *physical_devices;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002059 VkLayerProperties *instance_layers;
2060 VkLayerProperties *device_layers;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002061 uint32_t instance_extension_count = 0;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002062 uint32_t instance_layer_count = 0;
2063 uint32_t enabled_extension_count = 0;
2064 uint32_t enabled_layer_count = 0;
2065
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002066 char *instance_validation_layers[] = {
Tony Barbourb6dba5c2015-07-21 09:04:41 -06002067 "Threading",
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002068 "MemTracker",
Tony Barbourb6dba5c2015-07-21 09:04:41 -06002069 "ObjectTracker",
2070 "DrawState",
2071 "ParamChecker",
2072 "ShaderChecker",
Ian Elliottd0c74cf2015-09-22 10:51:24 -06002073 "Swapchain",
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002074 "DeviceLimits",
2075 "Image",
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002076 };
2077
2078 char *device_validation_layers[] = {
Tony Barbourb6dba5c2015-07-21 09:04:41 -06002079 "Threading",
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002080 "MemTracker",
Tony Barbourb6dba5c2015-07-21 09:04:41 -06002081 "ObjectTracker",
2082 "DrawState",
2083 "ParamChecker",
2084 "ShaderChecker",
Ian Elliottd0c74cf2015-09-22 10:51:24 -06002085 "Swapchain",
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002086 "DeviceLimits",
2087 "Image",
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002088 };
2089
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002090 /* Look for validation layers */
Courtney Goeltzenleuchterc88ce512015-07-09 11:44:38 -06002091 VkBool32 validation_found = 0;
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002092 err = vkEnumerateInstanceLayerProperties(&instance_layer_count, NULL);
Tobin Ehlis99239dc2015-04-16 18:04:57 -06002093 assert(!err);
2094
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002095 instance_layers = malloc(sizeof(VkLayerProperties) * instance_layer_count);
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002096 err = vkEnumerateInstanceLayerProperties(&instance_layer_count, instance_layers);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002097 assert(!err);
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002098
2099 if (demo->validate) {
2100 validation_found = demo_check_layers(ARRAY_SIZE(instance_validation_layers), instance_validation_layers,
2101 instance_layer_count, instance_layers);
2102 if (!validation_found) {
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002103 ERR_EXIT("vkEnumerateInstanceLayerProperties failed to find"
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002104 "required validation layer.\n\n"
2105 "Please look at the Getting Started guide for additional "
2106 "information.\n",
2107 "vkCreateInstance Failure");
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002108 }
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002109 enabled_layer_count = ARRAY_SIZE(instance_validation_layers);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002110 }
2111
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002112 err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, NULL);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002113 assert(!err);
2114
Tony Barbourcc69f452015-10-08 13:59:42 -06002115 VkBool32 swapchainExtFound = 0;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002116 memset(extension_names, 0, sizeof(extension_names));
2117 instance_extensions = malloc(sizeof(VkExtensionProperties) * instance_extension_count);
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002118 err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, instance_extensions);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002119 assert(!err);
2120 for (uint32_t i = 0; i < instance_extension_count; i++) {
Ian Elliotta0781972015-08-21 15:09:33 -06002121 if (!strcmp("VK_EXT_KHR_swapchain", instance_extensions[i].extName)) {
Tony Barbourcc69f452015-10-08 13:59:42 -06002122 swapchainExtFound = 1;
Ian Elliotta0781972015-08-21 15:09:33 -06002123 extension_names[enabled_extension_count++] = "VK_EXT_KHR_swapchain";
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002124 }
Courtney Goeltzenleuchtera59efa72015-07-30 11:32:46 -06002125 if (!strcmp(VK_DEBUG_REPORT_EXTENSION_NAME, instance_extensions[i].extName)) {
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002126 if (demo->validate) {
Courtney Goeltzenleuchtera59efa72015-07-30 11:32:46 -06002127 extension_names[enabled_extension_count++] = VK_DEBUG_REPORT_EXTENSION_NAME;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002128 }
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002129 }
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002130 assert(enabled_extension_count < 64);
Tobin Ehlis99239dc2015-04-16 18:04:57 -06002131 }
Tony Barbourcc69f452015-10-08 13:59:42 -06002132 if (!swapchainExtFound) {
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002133 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the "
Ian Elliotta0781972015-08-21 15:09:33 -06002134 "\"VK_EXT_KHR_swapchain\" extension.\n\nDo you have a compatible "
Ian Elliott65152912015-04-28 13:22:33 -06002135 "Vulkan installable client driver (ICD) installed?\nPlease "
2136 "look at the Getting Started guide for additional "
2137 "information.\n",
2138 "vkCreateInstance Failure");
2139 }
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06002140 const VkApplicationInfo app = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002141 .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002142 .pNext = NULL,
Ian Elliott44e33f72015-04-28 10:52:52 -06002143 .pAppName = APP_SHORT_NAME,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002144 .appVersion = 0,
Ian Elliott44e33f72015-04-28 10:52:52 -06002145 .pEngineName = APP_SHORT_NAME,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002146 .engineVersion = 0,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002147 .apiVersion = VK_API_VERSION,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002148 };
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002149 VkInstanceCreateInfo inst_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002150 .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
Jon Ashburnab46b362015-04-04 14:52:07 -06002151 .pNext = NULL,
2152 .pAppInfo = &app,
2153 .pAllocCb = NULL,
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002154 .layerCount = enabled_layer_count,
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002155 .ppEnabledLayerNames = (const char *const*) ((demo->validate) ? instance_validation_layers : NULL),
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002156 .extensionCount = enabled_extension_count,
2157 .ppEnabledExtensionNames = (const char *const*) extension_names,
Jon Ashburnab46b362015-04-04 14:52:07 -06002158 };
Ian Elliott097d9f32015-04-28 11:35:02 -06002159
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06002160 uint32_t gpu_count;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002161
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002162 err = vkCreateInstance(&inst_info, &demo->inst);
Ian Elliott07264132015-04-28 11:35:02 -06002163 if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
2164 ERR_EXIT("Cannot find a compatible Vulkan installable client driver "
Ian Elliott65152912015-04-28 13:22:33 -06002165 "(ICD).\n\nPlease look at the Getting Started guide for "
Ian Elliott07264132015-04-28 11:35:02 -06002166 "additional information.\n",
2167 "vkCreateInstance Failure");
Courtney Goeltzenleuchter1e47e4b2015-09-14 18:01:17 -06002168 } else if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002169 ERR_EXIT("Cannot find a specified extension library"
2170 ".\nMake sure your layers path is set appropriately\n",
2171 "vkCreateInstance Failure");
Ian Elliott07264132015-04-28 11:35:02 -06002172 } else if (err) {
Ian Elliott65152912015-04-28 13:22:33 -06002173 ERR_EXIT("vkCreateInstance failed.\n\nDo you have a compatible Vulkan "
2174 "installable client driver (ICD) installed?\nPlease look at "
Ian Elliott07264132015-04-28 11:35:02 -06002175 "the Getting Started guide for additional information.\n",
2176 "vkCreateInstance Failure");
Ian Elliott3979e282015-04-03 15:24:55 -06002177 }
Jon Ashburnab46b362015-04-04 14:52:07 -06002178
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002179 free(instance_layers);
2180 free(instance_extensions);
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002181
Tobin Ehlis8a724d82015-09-07 15:16:39 -06002182 /* Make initial call to query gpu_count, then second call for gpu info*/
2183 err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, NULL);
2184 assert(!err && gpu_count > 0);
2185 physical_devices = malloc(sizeof(VkPhysicalDevice) * gpu_count);
2186 err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, physical_devices);
2187 assert(!err);
2188 /* For cube demo we just grab the first physical device */
2189 demo->gpu = physical_devices[0];
2190 free(physical_devices);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002191
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002192 /* Look for validation layers */
2193 validation_found = 0;
2194 enabled_layer_count = 0;
2195 uint32_t device_layer_count = 0;
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002196 err = vkEnumerateDeviceLayerProperties(demo->gpu, &device_layer_count, NULL);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002197 assert(!err);
2198
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002199 device_layers = malloc(sizeof(VkLayerProperties) * device_layer_count);
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002200 err = vkEnumerateDeviceLayerProperties(demo->gpu, &device_layer_count, device_layers);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002201 assert(!err);
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002202
2203 if (demo->validate) {
2204 validation_found = demo_check_layers(ARRAY_SIZE(device_validation_layers), device_validation_layers,
2205 device_layer_count, device_layers);
2206 if (!validation_found) {
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002207 ERR_EXIT("vkEnumerateDeviceLayerProperties failed to find"
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002208 "a required validation layer.\n\n"
2209 "Please look at the Getting Started guide for additional "
2210 "information.\n",
2211 "vkCreateDevice Failure");
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002212 }
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002213 enabled_layer_count = ARRAY_SIZE(device_validation_layers);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002214 }
2215
2216 uint32_t device_extension_count = 0;
2217 VkExtensionProperties *device_extensions = NULL;
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002218 err = vkEnumerateDeviceExtensionProperties(
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002219 demo->gpu, NULL, &device_extension_count, NULL);
2220 assert(!err);
2221
Tony Barbourcc69f452015-10-08 13:59:42 -06002222 swapchainExtFound = 0;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002223 enabled_extension_count = 0;
2224 memset(extension_names, 0, sizeof(extension_names));
2225 device_extensions = malloc(sizeof(VkExtensionProperties) * device_extension_count);
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002226 err = vkEnumerateDeviceExtensionProperties(
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002227 demo->gpu, NULL, &device_extension_count, device_extensions);
2228 assert(!err);
Ian Elliottaaae5352015-07-06 14:27:58 -06002229
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002230 for (uint32_t i = 0; i < device_extension_count; i++) {
Ian Elliotta0781972015-08-21 15:09:33 -06002231 if (!strcmp("VK_EXT_KHR_device_swapchain", device_extensions[i].extName)) {
Tony Barbourcc69f452015-10-08 13:59:42 -06002232 swapchainExtFound = 1;
Ian Elliotta0781972015-08-21 15:09:33 -06002233 extension_names[enabled_extension_count++] = "VK_EXT_KHR_device_swapchain";
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002234 }
2235 assert(enabled_extension_count < 64);
2236 }
Tony Barbourcc69f452015-10-08 13:59:42 -06002237 if (!swapchainExtFound) {
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002238 ERR_EXIT("vkEnumerateDeviceExtensionProperties failed to find the "
Ian Elliotta0781972015-08-21 15:09:33 -06002239 "\"VK_EXT_KHR_device_swapchain\" extension.\n\nDo you have a compatible "
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002240 "Vulkan installable client driver (ICD) installed?\nPlease "
2241 "look at the Getting Started guide for additional "
2242 "information.\n",
2243 "vkCreateInstance Failure");
2244 }
2245
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002246 if (demo->validate) {
Courtney Goeltzenleuchter47610632015-07-12 14:35:22 -06002247 demo->dbgCreateMsgCallback = (PFN_vkDbgCreateMsgCallback) vkGetInstanceProcAddr(demo->inst, "vkDbgCreateMsgCallback");
2248 demo->dbgDestroyMsgCallback = (PFN_vkDbgDestroyMsgCallback) vkGetInstanceProcAddr(demo->inst, "vkDbgDestroyMsgCallback");
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002249 if (!demo->dbgCreateMsgCallback) {
2250 ERR_EXIT("GetProcAddr: Unable to find vkDbgCreateMsgCallback\n",
2251 "vkGetProcAddr Failure");
2252 }
Tony Barbourd70b42c2015-06-30 14:14:19 -06002253 if (!demo->dbgDestroyMsgCallback) {
2254 ERR_EXIT("GetProcAddr: Unable to find vkDbgDestroyMsgCallback\n",
2255 "vkGetProcAddr Failure");
2256 }
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -06002257 demo->dbgBreakCallback = (PFN_vkDbgMsgCallback) vkGetInstanceProcAddr(demo->inst, "vkDbgBreakCallback");
2258 if (!demo->dbgBreakCallback) {
2259 ERR_EXIT("GetProcAddr: Unable to find vkDbgBreakCallback\n",
2260 "vkGetProcAddr Failure");
2261 }
2262
2263 PFN_vkDbgMsgCallback callback;
2264
2265 if (!demo->use_break) {
2266 callback = dbgFunc;
2267 } else {
2268 callback = demo->dbgBreakCallback;
2269 }
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002270 err = demo->dbgCreateMsgCallback(
2271 demo->inst,
2272 VK_DBG_REPORT_ERROR_BIT | VK_DBG_REPORT_WARN_BIT,
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -06002273 callback, NULL,
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002274 &demo->msg_callback);
2275 switch (err) {
2276 case VK_SUCCESS:
2277 break;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002278 case VK_ERROR_OUT_OF_HOST_MEMORY:
2279 ERR_EXIT("dbgCreateMsgCallback: out of host memory\n",
2280 "dbgCreateMsgCallback Failure");
2281 break;
2282 default:
2283 ERR_EXIT("dbgCreateMsgCallback: unknown failure\n",
2284 "dbgCreateMsgCallback Failure");
2285 break;
2286 }
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002287 }
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002288 vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002289
2290 /* Call with NULL data to get count */
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002291 vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, NULL);
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002292 assert(demo->queue_count >= 1);
2293
2294 demo->queue_props = (VkQueueFamilyProperties *) malloc(demo->queue_count * sizeof(VkQueueFamilyProperties));
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002295 vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, demo->queue_props);
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002296 // Find a queue that supports gfx
2297 uint32_t gfx_queue_idx = 0;
2298 for (gfx_queue_idx = 0; gfx_queue_idx<demo->queue_count; gfx_queue_idx++) {
2299 if (demo->queue_props[gfx_queue_idx].queueFlags & VK_QUEUE_GRAPHICS_BIT)
2300 break;
2301 }
2302 assert(gfx_queue_idx < demo->queue_count);
Tobin Ehlisbf3020e2015-09-24 15:18:22 -06002303 // Query fine-grained feature support for this device.
2304 // If app has specific feature requirements it should check supported features based on this query
Tobin Ehlis8d03b7c2015-09-29 11:22:37 -06002305 VkPhysicalDeviceFeatures physDevFeatures;
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002306 vkGetPhysicalDeviceFeatures(demo->gpu, &physDevFeatures);
Tobin Ehlisbf3020e2015-09-24 15:18:22 -06002307
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002308 const VkDeviceQueueCreateInfo queue = {
2309 .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
2310 .pNext = NULL,
2311 .queueFamilyIndex = gfx_queue_idx,
2312 .queueCount = 1,
2313 };
2314
2315 VkDeviceCreateInfo device = {
2316 .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
2317 .pNext = NULL,
Courtney Goeltzenleuchter8ab618c2015-10-15 16:58:44 -06002318 .requestedQueueCount = 1,
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002319 .pRequestedQueues = &queue,
2320 .layerCount = enabled_layer_count,
2321 .ppEnabledLayerNames = (const char *const*) ((demo->validate) ? device_validation_layers : NULL),
2322 .extensionCount = enabled_extension_count,
2323 .ppEnabledExtensionNames = (const char *const*) extension_names,
Tobin Ehlisbf3020e2015-09-24 15:18:22 -06002324 .pEnabledFeatures = NULL, // If specific features are required, pass them in here
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002325 };
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002326
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002327 err = vkCreateDevice(demo->gpu, &device, &demo->device);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002328 assert(!err);
2329
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002330 free(device_layers);
2331
Ian Elliotta0781972015-08-21 15:09:33 -06002332 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
2333 GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePropertiesKHR);
2334 GET_DEVICE_PROC_ADDR(demo->device, GetSurfaceFormatsKHR);
2335 GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePresentModesKHR);
2336 GET_DEVICE_PROC_ADDR(demo->device, CreateSwapchainKHR);
Ian Elliotta0781972015-08-21 15:09:33 -06002337 GET_DEVICE_PROC_ADDR(demo->device, DestroySwapchainKHR);
2338 GET_DEVICE_PROC_ADDR(demo->device, GetSwapchainImagesKHR);
2339 GET_DEVICE_PROC_ADDR(demo->device, AcquireNextImageKHR);
2340 GET_DEVICE_PROC_ADDR(demo->device, QueuePresentKHR);
Courtney Goeltzenleuchter3a35c822015-07-15 17:45:38 -06002341}
2342
Tony Barbourcc69f452015-10-08 13:59:42 -06002343static void demo_init_vk_swapchain(struct demo *demo)
Courtney Goeltzenleuchter3a35c822015-07-15 17:45:38 -06002344{
2345 VkResult err;
2346 uint32_t i;
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07002347
Tony Barbourcc69f452015-10-08 13:59:42 -06002348 // Construct the surface description:
Ian Elliotta0781972015-08-21 15:09:33 -06002349 demo->surface_description.sType = VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR;
Ian Elliottaaae5352015-07-06 14:27:58 -06002350 demo->surface_description.pNext = NULL;
2351#ifdef _WIN32
Ian Elliotta0781972015-08-21 15:09:33 -06002352 demo->surface_description.platform = VK_PLATFORM_WIN32_KHR;
Ian Elliottaaae5352015-07-06 14:27:58 -06002353 demo->surface_description.pPlatformHandle = demo->connection;
2354 demo->surface_description.pPlatformWindow = demo->window;
2355#else // _WIN32
2356 demo->platform_handle_xcb.connection = demo->connection;
2357 demo->platform_handle_xcb.root = demo->screen->root;
Ian Elliotta0781972015-08-21 15:09:33 -06002358 demo->surface_description.platform = VK_PLATFORM_XCB_KHR;
Ian Elliottaaae5352015-07-06 14:27:58 -06002359 demo->surface_description.pPlatformHandle = &demo->platform_handle_xcb;
2360 demo->surface_description.pPlatformWindow = &demo->window;
2361#endif // _WIN32
2362
Tony Barbourcc69f452015-10-08 13:59:42 -06002363 // Iterate over each queue to learn whether it supports presenting:
Courtney Goeltzenleuchterfe95fca2015-07-15 17:40:20 -06002364 VkBool32* supportsPresent = (VkBool32 *)malloc(demo->queue_count * sizeof(VkBool32));
2365 for (i = 0; i < demo->queue_count; i++) {
Ian Elliotta0781972015-08-21 15:09:33 -06002366 demo->fpGetPhysicalDeviceSurfaceSupportKHR(demo->gpu, i,
2367 (VkSurfaceDescriptionKHR *) &demo->surface_description,
Ian Elliottaaae5352015-07-06 14:27:58 -06002368 &supportsPresent[i]);
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07002369 }
Ian Elliottaaae5352015-07-06 14:27:58 -06002370
2371 // Search for a graphics and a present queue in the array of queue
2372 // families, try to find one that supports both
2373 uint32_t graphicsQueueNodeIndex = UINT32_MAX;
2374 uint32_t presentQueueNodeIndex = UINT32_MAX;
Courtney Goeltzenleuchterfe95fca2015-07-15 17:40:20 -06002375 for (i = 0; i < demo->queue_count; i++) {
Ian Elliottaaae5352015-07-06 14:27:58 -06002376 if ((demo->queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) {
2377 if (graphicsQueueNodeIndex == UINT32_MAX) {
2378 graphicsQueueNodeIndex = i;
2379 }
2380
2381 if (supportsPresent[i] == VK_TRUE) {
2382 graphicsQueueNodeIndex = i;
2383 presentQueueNodeIndex = i;
2384 break;
2385 }
2386 }
2387 }
2388 if (presentQueueNodeIndex == UINT32_MAX) {
2389 // If didn't find a queue that supports both graphics and present, then
2390 // find a separate present queue.
Courtney Goeltzenleuchterfe95fca2015-07-15 17:40:20 -06002391 for (uint32_t i = 0; i < demo->queue_count; ++i) {
Ian Elliottaaae5352015-07-06 14:27:58 -06002392 if (supportsPresent[i] == VK_TRUE) {
2393 presentQueueNodeIndex = i;
2394 break;
2395 }
2396 }
2397 }
2398 free(supportsPresent);
2399
2400 // Generate error if could not find both a graphics and a present queue
2401 if (graphicsQueueNodeIndex == UINT32_MAX || presentQueueNodeIndex == UINT32_MAX) {
2402 ERR_EXIT("Could not find a graphics and a present queue\n",
Tony Barbourcc69f452015-10-08 13:59:42 -06002403 "Swapchain Initialization Failure");
Ian Elliottaaae5352015-07-06 14:27:58 -06002404 }
2405
2406 // TODO: Add support for separate queues, including presentation,
2407 // synchronization, and appropriate tracking for QueueSubmit
2408 // While it is possible for an application to use a separate graphics and a
2409 // present queues, this demo program assumes it is only using one:
2410 if (graphicsQueueNodeIndex != presentQueueNodeIndex) {
2411 ERR_EXIT("Could not find a common graphics and a present queue\n",
Tony Barbourcc69f452015-10-08 13:59:42 -06002412 "Swapchain Initialization Failure");
Ian Elliottaaae5352015-07-06 14:27:58 -06002413 }
2414
2415 demo->graphics_queue_node_index = graphicsQueueNodeIndex;
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07002416
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002417 vkGetDeviceQueue(demo->device, demo->graphics_queue_node_index,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002418 0, &demo->queue);
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002419
Ian Elliottaaae5352015-07-06 14:27:58 -06002420 // Get the list of VkFormat's that are supported:
Ian Elliott8528eff2015-08-07 15:56:59 -06002421 uint32_t formatCount;
Ian Elliotta0781972015-08-21 15:09:33 -06002422 err = demo->fpGetSurfaceFormatsKHR(demo->device,
2423 (VkSurfaceDescriptionKHR *) &demo->surface_description,
Ian Elliott8528eff2015-08-07 15:56:59 -06002424 &formatCount, NULL);
Ian Elliottaaae5352015-07-06 14:27:58 -06002425 assert(!err);
Ian Elliotta0781972015-08-21 15:09:33 -06002426 VkSurfaceFormatKHR *surfFormats =
2427 (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
2428 err = demo->fpGetSurfaceFormatsKHR(demo->device,
2429 (VkSurfaceDescriptionKHR *) &demo->surface_description,
Ian Elliott8528eff2015-08-07 15:56:59 -06002430 &formatCount, surfFormats);
Ian Elliottaaae5352015-07-06 14:27:58 -06002431 assert(!err);
2432 // If the format list includes just one entry of VK_FORMAT_UNDEFINED,
2433 // the surface has no preferred format. Otherwise, at least one
2434 // supported format will be returned.
Ian Elliottaaae5352015-07-06 14:27:58 -06002435 if (formatCount == 1 && surfFormats[0].format == VK_FORMAT_UNDEFINED)
2436 {
2437 demo->format = VK_FORMAT_B8G8R8A8_UNORM;
2438 }
2439 else
2440 {
2441 assert(formatCount >= 1);
2442 demo->format = surfFormats[0].format;
2443 }
Ian Elliott8528eff2015-08-07 15:56:59 -06002444 demo->color_space = surfFormats[0].colorSpace;
Ian Elliotte4602cd2015-04-21 16:41:02 -06002445
David Pinedo2bb7c932015-06-18 17:03:14 -06002446 demo->quit = false;
2447 demo->curFrame = 0;
Mark Lobodzinskieadf9982015-07-02 16:49:40 -06002448
2449 // Get Memory information and properties
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002450 vkGetPhysicalDeviceMemoryProperties(demo->gpu, &demo->memory_properties);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002451}
2452
2453static void demo_init_connection(struct demo *demo)
2454{
Ian Elliott639ca472015-04-16 15:23:05 -06002455#ifndef _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002456 const xcb_setup_t *setup;
2457 xcb_screen_iterator_t iter;
2458 int scr;
2459
2460 demo->connection = xcb_connect(NULL, &scr);
Ian Elliott3979e282015-04-03 15:24:55 -06002461 if (demo->connection == NULL) {
2462 printf("Cannot find a compatible Vulkan installable client driver "
2463 "(ICD).\nExiting ...\n");
2464 fflush(stdout);
2465 exit(1);
2466 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002467
2468 setup = xcb_get_setup(demo->connection);
2469 iter = xcb_setup_roots_iterator(setup);
2470 while (scr-- > 0)
2471 xcb_screen_next(&iter);
2472
2473 demo->screen = iter.data;
Ian Elliott639ca472015-04-16 15:23:05 -06002474#endif // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002475}
2476
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002477static void demo_init(struct demo *demo, int argc, char **argv)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002478{
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002479 vec3 eye = {0.0f, 3.0f, 5.0f};
2480 vec3 origin = {0, 0, 0};
Chia-I Wuae3b55d2015-04-22 14:56:17 +08002481 vec3 up = {0.0f, 1.0f, 0.0};
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002482
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002483 memset(demo, 0, sizeof(*demo));
Tony Barbour1a86d032015-09-21 15:17:33 -06002484 demo->frameCount = INT32_MAX;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002485
Piers Daniell735ee532015-02-23 16:23:13 -07002486 for (int i = 1; i < argc; i++) {
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002487 if (strcmp(argv[i], "--use_staging") == 0) {
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002488 demo->use_staging_buffer = true;
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002489 continue;
Ian Elliott639ca472015-04-16 15:23:05 -06002490 }
Cody Northrop1fedb212015-05-28 11:27:16 -06002491 if (strcmp(argv[i], "--use_glsl") == 0) {
2492 demo->use_glsl = true;
2493 continue;
2494 }
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -06002495 if (strcmp(argv[i], "--break") == 0) {
2496 demo->use_break = true;
2497 continue;
2498 }
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002499 if (strcmp(argv[i], "--validate") == 0) {
2500 demo->validate = true;
2501 continue;
2502 }
David Pinedo2bb7c932015-06-18 17:03:14 -06002503 if (strcmp(argv[i], "--c") == 0 &&
Tony Barbour1a86d032015-09-21 15:17:33 -06002504 demo->frameCount == INT32_MAX &&
David Pinedo2bb7c932015-06-18 17:03:14 -06002505 i < argc-1 &&
2506 sscanf(argv[i+1],"%d", &demo->frameCount) == 1 &&
2507 demo->frameCount >= 0)
2508 {
2509 i++;
2510 continue;
2511 }
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002512
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -06002513 fprintf(stderr, "Usage:\n %s [--use_staging] [--validate] [--break] [--c <framecount>]\n", APP_SHORT_NAME);
Ian Elliott639ca472015-04-16 15:23:05 -06002514 fflush(stderr);
2515 exit(1);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002516 }
2517
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002518 demo_init_connection(demo);
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002519 demo_init_vk(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002520
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002521 demo->width = 500;
2522 demo->height = 500;
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002523
2524 demo->spin_angle = 0.01f;
2525 demo->spin_increment = 0.01f;
2526 demo->pause = false;
2527
Piers Daniell735ee532015-02-23 16:23:13 -07002528 mat4x4_perspective(demo->projection_matrix, (float)degreesToRadians(45.0f), 1.0f, 0.1f, 100.0f);
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002529 mat4x4_look_at(demo->view_matrix, eye, origin, up);
2530 mat4x4_identity(demo->model_matrix);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002531}
2532
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002533
Ian Elliott639ca472015-04-16 15:23:05 -06002534#ifdef _WIN32
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002535extern int __getmainargs(
2536 int * _Argc,
2537 char *** _Argv,
2538 char *** _Env,
2539 int _DoWildCard,
2540 int * new_mode);
Ian Elliottf9cf78c2015-04-28 10:33:11 -06002541
Ian Elliotta748eaf2015-04-28 15:50:36 -06002542int WINAPI WinMain(HINSTANCE hInstance,
2543 HINSTANCE hPrevInstance,
2544 LPSTR pCmdLine,
2545 int nCmdShow)
Ian Elliott639ca472015-04-16 15:23:05 -06002546{
2547 MSG msg; // message
2548 bool done; // flag saying when app is complete
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002549 int argc;
2550 char** argv;
2551 char** env;
2552 int new_mode = 0;
Ian Elliott639ca472015-04-16 15:23:05 -06002553
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002554 __getmainargs(&argc,&argv,&env,0,&new_mode);
2555
2556 demo_init(&demo, argc, argv);
2557 demo.connection = hInstance;
2558 strncpy(demo.name, "cube", APP_NAME_STR_LEN);
Ian Elliott639ca472015-04-16 15:23:05 -06002559 demo_create_window(&demo);
Tony Barbourcc69f452015-10-08 13:59:42 -06002560 demo_init_vk_swapchain(&demo);
Ian Elliott639ca472015-04-16 15:23:05 -06002561
2562 demo_prepare(&demo);
2563
2564 done = false; //initialize loop condition variable
2565 /* main message loop*/
2566 while(!done)
2567 {
Ian Elliotta748eaf2015-04-28 15:50:36 -06002568 PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
Ian Elliott639ca472015-04-16 15:23:05 -06002569 if (msg.message == WM_QUIT) //check for a quit message
2570 {
2571 done = true; //if found, quit app
2572 }
2573 else
2574 {
2575 /* Translate and dispatch to event queue*/
2576 TranslateMessage(&msg);
2577 DispatchMessage(&msg);
2578 }
Tony Barbourc8a59892015-10-20 12:49:46 -06002579 RedrawWindow(demo.window, NULL, NULL, RDW_INTERNALPAINT);
Ian Elliott639ca472015-04-16 15:23:05 -06002580 }
2581
2582 demo_cleanup(&demo);
2583
Tony Barbourf9921732015-04-22 11:36:22 -06002584 return (int) msg.wParam;
Ian Elliott639ca472015-04-16 15:23:05 -06002585}
2586#else // _WIN32
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002587int main(int argc, char **argv)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002588{
2589 struct demo demo;
2590
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002591 demo_init(&demo, argc, argv);
Chia-I Wucbb564e2015-04-16 22:02:10 +08002592 demo_create_window(&demo);
Tony Barbourcc69f452015-10-08 13:59:42 -06002593 demo_init_vk_swapchain(&demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002594
2595 demo_prepare(&demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002596 demo_run(&demo);
2597
2598 demo_cleanup(&demo);
2599
2600 return 0;
2601}
Ian Elliott639ca472015-04-16 15:23:05 -06002602#endif // _WIN32