blob: 18bf12ecc4812160e41a026f40f264563b3c729e [file] [log] [blame]
Ian Elliotta748eaf2015-04-28 15:50:36 -06001/*
Ian Elliotta748eaf2015-04-28 15:50:36 -06002 *
Courtney Goeltzenleuchterbb387b72015-10-29 13:50:34 -06003 * Copyright (C) 2015 Valve Corporation
Courtney Goeltzenleuchter24df6832015-12-02 14:53:22 -07004 * Copyright (C) 2015 Google Inc.
Ian Elliotta748eaf2015-04-28 15:50:36 -06005 *
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.
Courtney Goeltzenleuchter37328982015-10-30 11:14:30 -060023 *
24 * Author: Chia-I Wu <olv@lunarg.com>
25 * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
26 * Author: Ian Elliott <ian@LunarG.com>
27 * Author: Jon Ashburn <jon@lunarg.com>
Ian Elliotta748eaf2015-04-28 15:50:36 -060028 */
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -060029#define _GNU_SOURCE
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060030#include <stdio.h>
31#include <stdlib.h>
32#include <string.h>
33#include <stdbool.h>
34#include <assert.h>
Courtney Goeltzenleuchteraf1951c2015-12-01 14:11:38 -070035#include <signal.h>
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060036
Ian Elliott639ca472015-04-16 15:23:05 -060037#ifdef _WIN32
38#pragma comment(linker, "/subsystem:windows")
Ian Elliott639ca472015-04-16 15:23:05 -060039#define APP_NAME_STR_LEN 80
Ian Elliott639ca472015-04-16 15:23:05 -060040#endif // _WIN32
41
David Pinedoc5193c12015-11-06 12:54:48 -070042#include <vulkan/vulkan.h>
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -070043#include <vulkan/vk_ext_debug_report.h>
Ian Elliottb08e0d92015-11-20 11:55:46 -070044
David Pinedo541526f2015-11-24 09:00:24 -070045#include <vulkan/vk_sdk_platform.h>
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -060046#include "linmath.h"
47
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060048#define DEMO_TEXTURE_COUNT 1
Ian Elliott44e33f72015-04-28 10:52:52 -060049#define APP_SHORT_NAME "cube"
50#define APP_LONG_NAME "The Vulkan Cube Demo Program"
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060051
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -060052#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
53
Tony Barbourfdc2d352015-04-22 09:02:32 -060054#if defined(NDEBUG) && defined(__GNUC__)
55#define U_ASSERT_ONLY __attribute__((unused))
56#else
57#define U_ASSERT_ONLY
58#endif
59
Ian Elliott07264132015-04-28 11:35:02 -060060#ifdef _WIN32
61#define ERR_EXIT(err_msg, err_class) \
62 do { \
63 MessageBox(NULL, err_msg, err_class, MB_OK); \
64 exit(1); \
65 } while (0)
66
Ian Elliott07264132015-04-28 11:35:02 -060067#else // _WIN32
68
69#define ERR_EXIT(err_msg, err_class) \
70 do { \
71 printf(err_msg); \
72 fflush(stdout); \
73 exit(1); \
74 } while (0)
75#endif // _WIN32
76
Ian Elliottaaae5352015-07-06 14:27:58 -060077#define GET_INSTANCE_PROC_ADDR(inst, entrypoint) \
78{ \
79 demo->fp##entrypoint = (PFN_vk##entrypoint) vkGetInstanceProcAddr(inst, "vk"#entrypoint); \
80 if (demo->fp##entrypoint == NULL) { \
81 ERR_EXIT("vkGetInstanceProcAddr failed to find vk"#entrypoint, \
82 "vkGetInstanceProcAddr Failure"); \
83 } \
84}
85
Jon Ashburn7d8342c2015-10-08 15:58:23 -060086static PFN_vkGetDeviceProcAddr g_gdpa = NULL;
87
Ian Elliott673898b2015-06-22 15:07:49 -060088#define GET_DEVICE_PROC_ADDR(dev, entrypoint) \
89{ \
Jon Ashburn7d8342c2015-10-08 15:58:23 -060090 if(!g_gdpa) \
91 g_gdpa = (PFN_vkGetDeviceProcAddr) vkGetInstanceProcAddr(demo->inst, "vkGetDeviceProcAddr"); \
92 demo->fp##entrypoint = (PFN_vk##entrypoint) g_gdpa(dev, "vk"#entrypoint); \
Ian Elliott673898b2015-06-22 15:07:49 -060093 if (demo->fp##entrypoint == NULL) { \
94 ERR_EXIT("vkGetDeviceProcAddr failed to find vk"#entrypoint, \
95 "vkGetDeviceProcAddr Failure"); \
96 } \
97}
98
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -060099/*
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700100 * structure to track all objects related to a texture.
101 */
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600102struct texture_object {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600103 VkSampler sampler;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700104
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600105 VkImage image;
106 VkImageLayout imageLayout;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600107
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800108 VkMemoryAllocateInfo mem_alloc;
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500109 VkDeviceMemory mem;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600110 VkImageView view;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700111 int32_t tex_width, tex_height;
112};
113
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600114static char *tex_files[] = {
Tony Barbour1a86d032015-09-21 15:17:33 -0600115 "lunarg.ppm"
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600116};
117
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600118struct vkcube_vs_uniform {
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600119 // Must start with MVP
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600120 float mvp[4][4];
121 float position[12*3][4];
122 float color[12*3][4];
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600123};
124
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600125struct vktexcube_vs_uniform {
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600126 // Must start with MVP
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600127 float mvp[4][4];
128 float position[12*3][4];
129 float attr[12*3][4];
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600130};
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600131
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600132//--------------------------------------------------------------------------------------
133// Mesh and VertexFormat Data
134//--------------------------------------------------------------------------------------
135struct Vertex
136{
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600137 float posX, posY, posZ, posW; // Position data
138 float r, g, b, a; // Color
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600139};
140
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600141struct VertexPosTex
142{
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600143 float posX, posY, posZ, posW; // Position data
144 float u, v, s, t; // Texcoord
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600145};
146
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600147#define XYZ1(_x_, _y_, _z_) (_x_), (_y_), (_z_), 1.f
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600148#define UV(_u_, _v_) (_u_), (_v_), 0.f, 1.f
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600149
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600150static const float g_vertex_buffer_data[] = {
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800151 -1.0f,-1.0f,-1.0f, // -X side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600152 -1.0f,-1.0f, 1.0f,
153 -1.0f, 1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800154 -1.0f, 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600155 -1.0f, 1.0f,-1.0f,
156 -1.0f,-1.0f,-1.0f,
157
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800158 -1.0f,-1.0f,-1.0f, // -Z side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600159 1.0f, 1.0f,-1.0f,
160 1.0f,-1.0f,-1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800161 -1.0f,-1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600162 -1.0f, 1.0f,-1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600163 1.0f, 1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600164
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800165 -1.0f,-1.0f,-1.0f, // -Y side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600166 1.0f,-1.0f,-1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600167 1.0f,-1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800168 -1.0f,-1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600169 1.0f,-1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600170 -1.0f,-1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600171
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800172 -1.0f, 1.0f,-1.0f, // +Y side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600173 -1.0f, 1.0f, 1.0f,
174 1.0f, 1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800175 -1.0f, 1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600176 1.0f, 1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600177 1.0f, 1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600178
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800179 1.0f, 1.0f,-1.0f, // +X side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600180 1.0f, 1.0f, 1.0f,
181 1.0f,-1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800182 1.0f,-1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600183 1.0f,-1.0f,-1.0f,
184 1.0f, 1.0f,-1.0f,
185
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800186 -1.0f, 1.0f, 1.0f, // +Z side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600187 -1.0f,-1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600188 1.0f, 1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800189 -1.0f,-1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600190 1.0f,-1.0f, 1.0f,
191 1.0f, 1.0f, 1.0f,
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600192};
193
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600194static const float g_uv_buffer_data[] = {
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800195 0.0f, 0.0f, // -X side
196 1.0f, 0.0f,
197 1.0f, 1.0f,
198 1.0f, 1.0f,
199 0.0f, 1.0f,
200 0.0f, 0.0f,
201
202 1.0f, 0.0f, // -Z side
203 0.0f, 1.0f,
204 0.0f, 0.0f,
205 1.0f, 0.0f,
206 1.0f, 1.0f,
207 0.0f, 1.0f,
208
209 1.0f, 1.0f, // -Y side
210 1.0f, 0.0f,
211 0.0f, 0.0f,
212 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600213 0.0f, 0.0f,
214 0.0f, 1.0f,
215
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800216 1.0f, 1.0f, // +Y side
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -0600217 0.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800218 0.0f, 0.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600219 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600220 0.0f, 0.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600221 1.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600222
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800223 1.0f, 1.0f, // +X side
224 0.0f, 1.0f,
225 0.0f, 0.0f,
226 0.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600227 1.0f, 0.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600228 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600229
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800230 0.0f, 1.0f, // +Z side
231 0.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600232 1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600233 0.0f, 0.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800234 1.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600235 1.0f, 1.0f,
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600236};
237
238void dumpMatrix(const char *note, mat4x4 MVP)
239{
240 int i;
241
242 printf("%s: \n", note);
243 for (i=0; i<4; i++) {
244 printf("%f, %f, %f, %f\n", MVP[i][0], MVP[i][1], MVP[i][2], MVP[i][3]);
245 }
246 printf("\n");
247 fflush(stdout);
248}
249
250void dumpVec4(const char *note, vec4 vector)
251{
252 printf("%s: \n", note);
253 printf("%f, %f, %f, %f\n", vector[0], vector[1], vector[2], vector[3]);
254 printf("\n");
255 fflush(stdout);
256}
257
Mark Youngcda9d842016-01-13 13:47:16 -0700258VKAPI_ATTR VkBool32 VKAPI_CALL dbgFunc(
Tony Barbour155cce82015-07-03 10:33:54 -0600259 VkFlags msgFlags,
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -0700260 VkDebugReportObjectTypeEXT objType,
Tony Barbour155cce82015-07-03 10:33:54 -0600261 uint64_t srcObject,
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600262 size_t location,
263 int32_t msgCode,
264 const char* pLayerPrefix,
265 const char* pMsg,
Courtney Goeltzenleuchtera5a167a2016-01-18 17:42:08 -0700266 void* pUserData)
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600267{
268 char *message = (char *) malloc(strlen(pMsg)+100);
269
270 assert (message);
271
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -0700272 if (msgFlags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600273 sprintf(message,"ERROR: [%s] Code %d : %s", pLayerPrefix, msgCode, pMsg);
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -0700274 } else if (msgFlags & VK_DEBUG_REPORT_WARN_BIT_EXT) {
Tony Barbourd70b42c2015-06-30 14:14:19 -0600275 // We know that we're submitting queues without fences, ignore this warning
276 if (strstr(pMsg, "vkQueueSubmit parameter, VkFence fence, is null pointer")){
Courtney Goeltzenleuchterab328192015-09-04 13:52:24 -0600277 return false;
Tony Barbourd70b42c2015-06-30 14:14:19 -0600278 }
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600279 sprintf(message,"WARNING: [%s] Code %d : %s", pLayerPrefix, msgCode, pMsg);
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600280 } else {
Courtney Goeltzenleuchterab328192015-09-04 13:52:24 -0600281 return false;
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600282 }
283
284#ifdef _WIN32
285 MessageBox(NULL, message, "Alert", MB_OK);
286#else
287 printf("%s\n",message);
288 fflush(stdout);
289#endif
290 free(message);
Courtney Goeltzenleuchterab328192015-09-04 13:52:24 -0600291
Courtney Goeltzenleuchter8cda44e2015-09-08 16:57:22 -0600292 /*
293 * false indicates that layer should not bail-out of an
294 * API call that had validation failures. This may mean that the
295 * app dies inside the driver due to invalid parameter(s).
296 * That's what would happen without validation layers, so we'll
297 * keep that behavior here.
298 */
299 return false;
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600300}
301
Courtney Goeltzenleuchteraf1951c2015-12-01 14:11:38 -0700302VkBool32 BreakCallback(
303 VkFlags msgFlags,
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -0700304 VkDebugReportObjectTypeEXT objType,
Courtney Goeltzenleuchteraf1951c2015-12-01 14:11:38 -0700305 uint64_t srcObject,
306 size_t location,
307 int32_t msgCode,
308 const char* pLayerPrefix,
309 const char* pMsg,
Courtney Goeltzenleuchtera5a167a2016-01-18 17:42:08 -0700310 void* pUserData)
Courtney Goeltzenleuchteraf1951c2015-12-01 14:11:38 -0700311{
312#ifndef WIN32
313 raise(SIGTRAP);
314#else
315 DebugBreak();
316#endif
317
318 return false;
319}
320
Ian Elliotta0781972015-08-21 15:09:33 -0600321typedef struct _SwapchainBuffers {
Ian Elliottaaae5352015-07-06 14:27:58 -0600322 VkImage image;
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800323 VkCommandBuffer cmd;
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600324 VkImageView view;
Ian Elliotta0781972015-08-21 15:09:33 -0600325} SwapchainBuffers;
Ian Elliottaaae5352015-07-06 14:27:58 -0600326
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600327struct demo {
Ian Elliott639ca472015-04-16 15:23:05 -0600328#ifdef _WIN32
329#define APP_NAME_STR_LEN 80
330 HINSTANCE connection; // hInstance - Windows Instance
331 char name[APP_NAME_STR_LEN]; // Name to put on the window/icon
332 HWND window; // hWnd - window handle
333#else // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600334 xcb_connection_t *connection;
335 xcb_screen_t *screen;
Chia-I Wucbb564e2015-04-16 22:02:10 +0800336 xcb_window_t window;
337 xcb_intern_atom_reply_t *atom_wm_delete_window;
Tony Barbour6839bec2015-07-13 16:37:21 -0600338#endif // _WIN32
Ian Elliottb08e0d92015-11-20 11:55:46 -0700339 VkSurfaceKHR surface;
Cody Northrop1fedb212015-05-28 11:27:16 -0600340 bool prepared;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700341 bool use_staging_buffer;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600342
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600343 VkInstance inst;
Tony Barbour72304ef2015-04-16 15:59:00 -0600344 VkPhysicalDevice gpu;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600345 VkDevice device;
346 VkQueue queue;
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -0700347 uint32_t graphics_queue_node_index;
Tony Barbourecf1b2b2015-06-24 16:06:58 -0600348 VkPhysicalDeviceProperties gpu_props;
Cody Northrop4d3c11d2015-08-03 17:04:53 -0600349 VkQueueFamilyProperties *queue_props;
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600350 VkPhysicalDeviceMemoryProperties memory_properties;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600351
Tony Barbourda2bad52016-01-22 14:36:40 -0700352 uint32_t enabled_extension_count;
353 uint32_t enabled_layer_count;
354 char *extension_names[64];
355 char *device_validation_layers[64];
356
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600357 int width, height;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600358 VkFormat format;
Ian Elliotta0781972015-08-21 15:09:33 -0600359 VkColorSpaceKHR color_space;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600360
Ian Elliotta0781972015-08-21 15:09:33 -0600361 PFN_vkGetPhysicalDeviceSurfaceSupportKHR fpGetPhysicalDeviceSurfaceSupportKHR;
Ian Elliottf4a4e442015-11-17 17:29:40 -0700362 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fpGetPhysicalDeviceSurfaceCapabilitiesKHR;
363 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fpGetPhysicalDeviceSurfaceFormatsKHR;
364 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fpGetPhysicalDeviceSurfacePresentModesKHR;
Ian Elliotta0781972015-08-21 15:09:33 -0600365 PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
366 PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
367 PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
368 PFN_vkAcquireNextImageKHR fpAcquireNextImageKHR;
369 PFN_vkQueuePresentKHR fpQueuePresentKHR;
Ian Elliotta0781972015-08-21 15:09:33 -0600370 uint32_t swapchainImageCount;
Ian Elliottcf074d32015-10-16 18:02:43 -0600371 VkSwapchainKHR swapchain;
Ian Elliotta0781972015-08-21 15:09:33 -0600372 SwapchainBuffers *buffers;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600373
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800374 VkCommandPool cmd_pool;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600375
376 struct {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600377 VkFormat format;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600378
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600379 VkImage image;
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800380 VkMemoryAllocateInfo mem_alloc;
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500381 VkDeviceMemory mem;
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600382 VkImageView view;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600383 } depth;
384
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600385 struct texture_object textures[DEMO_TEXTURE_COUNT];
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600386
387 struct {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600388 VkBuffer buf;
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800389 VkMemoryAllocateInfo mem_alloc;
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500390 VkDeviceMemory mem;
Courtney Goeltzenleuchterc3ad65e2015-10-23 13:38:14 -0600391 VkDescriptorBufferInfo buffer_info;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600392 } uniform_data;
393
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800394 VkCommandBuffer cmd; // Buffer for initialization commands
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -0500395 VkPipelineLayout pipeline_layout;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600396 VkDescriptorSetLayout desc_layout;
Jon Ashburnc4ab7af2015-07-09 15:02:25 -0600397 VkPipelineCache pipelineCache;
Chia-I Wuf973e322015-07-08 13:34:24 +0800398 VkRenderPass render_pass;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600399 VkPipeline pipeline;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600400
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600401 mat4x4 projection_matrix;
402 mat4x4 view_matrix;
403 mat4x4 model_matrix;
404
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600405 float spin_angle;
406 float spin_increment;
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -0600407 bool pause;
408
Tony Barbourb6dba5c2015-07-21 09:04:41 -0600409 VkShaderModule vert_shader_module;
410 VkShaderModule frag_shader_module;
411
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600412 VkDescriptorPool desc_pool;
413 VkDescriptorSet desc_set;
Chia-I Wu6a3c8972015-01-04 16:27:24 +0800414
Tony Barbourd8e504f2015-10-08 14:26:24 -0600415 VkFramebuffer *framebuffers;
Chia-I Wuf973e322015-07-08 13:34:24 +0800416
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600417 bool quit;
David Pinedo2bb7c932015-06-18 17:03:14 -0600418 int32_t curFrame;
419 int32_t frameCount;
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600420 bool validate;
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -0600421 bool use_break;
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -0700422 PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallback;
423 PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallback;
424 VkDebugReportCallbackEXT msg_callback;
425 PFN_vkDebugReportMessageEXT DebugReportMessage;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600426
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600427 uint32_t current_buffer;
Courtney Goeltzenleuchterfe95fca2015-07-15 17:40:20 -0600428 uint32_t queue_count;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600429};
430
Ian Elliottcf074d32015-10-16 18:02:43 -0600431// Forward declaration:
432static void demo_resize(struct demo *demo);
433
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600434static bool memory_type_from_properties(struct demo *demo, uint32_t typeBits, VkFlags requirements_mask, uint32_t *typeIndex)
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600435{
436 // Search memtypes to find first index with those properties
437 for (uint32_t i = 0; i < 32; i++) {
438 if ((typeBits & 1) == 1) {
439 // Type is available, does it match user properties?
Tony Barbour8a9f62a2015-10-15 12:42:56 -0600440 if ((demo->memory_properties.memoryTypes[i].propertyFlags & requirements_mask) == requirements_mask) {
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600441 *typeIndex = i;
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600442 return true;
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600443 }
444 }
445 typeBits >>= 1;
446 }
447 // No memory types matched, return failure
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600448 return false;
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600449}
450
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600451static void demo_flush_init_cmd(struct demo *demo)
452{
Tony Barbourfdc2d352015-04-22 09:02:32 -0600453 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600454
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600455 if (demo->cmd == VK_NULL_HANDLE)
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600456 return;
457
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600458 err = vkEndCommandBuffer(demo->cmd);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600459 assert(!err);
460
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800461 const VkCommandBuffer cmd_bufs[] = { demo->cmd };
Chia-I Wu1c4086a2015-10-26 20:04:44 +0800462 VkFence nullFence = VK_NULL_HANDLE;
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600463 VkSubmitInfo submit_info = {
Chia-I Wu4176d7b2015-10-26 20:37:06 +0800464 .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
465 .pNext = NULL,
Chia-I Wu3dfc1342015-10-26 20:48:51 +0800466 .waitSemaphoreCount = 0,
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600467 .pWaitSemaphores = NULL,
Jon Ashburn244c6d02015-12-30 16:42:50 -0700468 .pWaitDstStageMask = NULL,
Chia-I Wu3dfc1342015-10-26 20:48:51 +0800469 .commandBufferCount = 1,
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600470 .pCommandBuffers = cmd_bufs,
Chia-I Wu3dfc1342015-10-26 20:48:51 +0800471 .signalSemaphoreCount = 0,
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600472 .pSignalSemaphores = NULL
473 };
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600474
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600475 err = vkQueueSubmit(demo->queue, 1, &submit_info, nullFence);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600476 assert(!err);
477
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600478 err = vkQueueWaitIdle(demo->queue);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600479 assert(!err);
480
Courtney Goeltzenleuchter014ded82015-10-23 14:21:05 -0600481 vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, cmd_bufs);
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600482 demo->cmd = VK_NULL_HANDLE;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600483}
484
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600485static void demo_set_image_layout(
486 struct demo *demo,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600487 VkImage image,
Cody Northrop0e951672015-09-14 13:48:12 -0600488 VkImageAspectFlags aspectMask,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600489 VkImageLayout old_image_layout,
490 VkImageLayout new_image_layout)
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600491{
Tony Barbourfdc2d352015-04-22 09:02:32 -0600492 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600493
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600494 if (demo->cmd == VK_NULL_HANDLE) {
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800495 const VkCommandBufferAllocateInfo cmd = {
Chia-I Wuf48700b2015-11-10 16:21:09 +0800496 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600497 .pNext = NULL,
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800498 .commandPool = demo->cmd_pool,
499 .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
Jon Ashburn0bec67e2016-01-11 13:12:43 -0700500 .commandBufferCount = 1,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600501 };
502
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800503 err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->cmd);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600504 assert(!err);
505
Jon Ashburn0bec67e2016-01-11 13:12:43 -0700506 VkCommandBufferInheritanceInfo cmd_buf_hinfo = {
507 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600508 .pNext = NULL,
Chia-I Wu1c4086a2015-10-26 20:04:44 +0800509 .renderPass = VK_NULL_HANDLE,
Cody Northropa0a178c2015-08-11 11:35:58 -0600510 .subpass = 0,
Chia-I Wu1c4086a2015-10-26 20:04:44 +0800511 .framebuffer = VK_NULL_HANDLE,
Chia-I Wu4ac4a8b2015-11-11 10:18:12 +0800512 .occlusionQueryEnable = VK_FALSE,
513 .queryFlags = 0,
514 .pipelineStatistics = 0,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600515 };
Jon Ashburn0bec67e2016-01-11 13:12:43 -0700516 VkCommandBufferBeginInfo cmd_buf_info = {
517 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
518 .pNext = NULL,
519 .flags = 0,
520 .pInheritanceInfo = &cmd_buf_hinfo,
521 };
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600522 err = vkBeginCommandBuffer(demo->cmd, &cmd_buf_info);
Tony Barbourcb59a5d2015-10-23 10:53:30 -0600523 assert(!err);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600524 }
525
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600526 VkImageMemoryBarrier image_memory_barrier = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600527 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600528 .pNext = NULL,
Chia-I Wu19574622015-10-27 19:54:37 +0800529 .srcAccessMask = 0,
530 .dstAccessMask = 0,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600531 .oldLayout = old_image_layout,
532 .newLayout = new_image_layout,
533 .image = image,
Jeremy Hayes105ca502015-11-17 18:19:55 -0700534 .subresourceRange = { aspectMask, 0, 1, 0, 1 }
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600535 };
536
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800537 if (new_image_layout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600538 /* Make sure anything that was copying from this image has completed */
Chia-I Wu19574622015-10-27 19:54:37 +0800539 image_memory_barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600540 }
541
Mark Lobodzinski9e0be702015-11-04 13:49:48 -0700542 if (new_image_layout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) {
Mark Lobodzinskid51e5a92015-12-03 15:42:32 -0700543 image_memory_barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
Mark Lobodzinski9e0be702015-11-04 13:49:48 -0700544 }
545
546 if (new_image_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
Mark Lobodzinskid51e5a92015-12-03 15:42:32 -0700547 image_memory_barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
Mark Lobodzinski9e0be702015-11-04 13:49:48 -0700548 }
549
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600550 if (new_image_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600551 /* Make sure any Copy or CPU writes to image are flushed */
Mark Lobodzinski9e0be702015-11-04 13:49:48 -0700552 image_memory_barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600553 }
554
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600555 VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600556
Tony Barbour50bbca42015-06-29 16:20:35 -0600557 VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
558 VkPipelineStageFlags dest_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600559
Jon Ashburn0bec67e2016-01-11 13:12:43 -0700560 vkCmdPipelineBarrier(demo->cmd, src_stages, dest_stages, 0, 0, NULL, 0, NULL, 1, pmemory_barrier);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600561}
562
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800563static void demo_draw_build_cmd(struct demo *demo, VkCommandBuffer cmd_buf)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600564{
Jon Ashburn0bec67e2016-01-11 13:12:43 -0700565 VkCommandBufferInheritanceInfo cmd_buf_hinfo = {
566 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
Courtney Goeltzenleuchter53968d82015-04-03 15:25:24 -0600567 .pNext = NULL,
Chia-I Wu1c4086a2015-10-26 20:04:44 +0800568 .renderPass = VK_NULL_HANDLE,
Cody Northropa0a178c2015-08-11 11:35:58 -0600569 .subpass = 0,
Chia-I Wu1c4086a2015-10-26 20:04:44 +0800570 .framebuffer = VK_NULL_HANDLE,
Chia-I Wu4ac4a8b2015-11-11 10:18:12 +0800571 .occlusionQueryEnable = VK_FALSE,
572 .queryFlags = 0,
573 .pipelineStatistics = 0,
Jon Ashburn60ccfbe2014-12-31 17:08:35 -0700574 };
Jon Ashburn0bec67e2016-01-11 13:12:43 -0700575 const VkCommandBufferBeginInfo cmd_buf_info = {
576 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
577 .pNext = NULL,
578 .flags = 0,
579 .pInheritanceInfo = &cmd_buf_hinfo,
580 };
Chia-I Wua74c5b22015-07-07 11:50:03 +0800581 const VkClearValue clear_values[2] = {
Cody Northrop55745922015-08-25 15:26:38 -0600582 [0] = { .color.float32 = { 0.2f, 0.2f, 0.2f, 0.2f } },
583 [1] = { .depthStencil = { 1.0f, 0 } },
Chia-I Wua74c5b22015-07-07 11:50:03 +0800584 };
585 const VkRenderPassBeginInfo rp_begin = {
586 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
587 .pNext = NULL,
Chia-I Wuf973e322015-07-08 13:34:24 +0800588 .renderPass = demo->render_pass,
589 .framebuffer = demo->framebuffers[demo->current_buffer],
Chia-I Wua74c5b22015-07-07 11:50:03 +0800590 .renderArea.offset.x = 0,
591 .renderArea.offset.y = 0,
592 .renderArea.extent.width = demo->width,
593 .renderArea.extent.height = demo->height,
Cody Northrop372bbae2015-08-04 11:51:03 -0600594 .clearValueCount = 2,
595 .pClearValues = clear_values,
Jon Ashburn08f6eb92015-01-02 18:24:05 -0700596 };
Chia-I Wuf973e322015-07-08 13:34:24 +0800597 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600598
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600599 err = vkBeginCommandBuffer(cmd_buf, &cmd_buf_info);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600600 assert(!err);
601
Chia-I Wuf051d262015-10-27 19:25:11 +0800602 vkCmdBeginRenderPass(cmd_buf, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
Chia-I Wua74c5b22015-07-07 11:50:03 +0800603
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600604 vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600605 demo->pipeline);
Mark Lobodzinskic6e8b3d2015-06-15 13:21:21 -0600606 vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout,
Cody Northropfb5185a2015-04-16 13:41:56 -0600607 0, 1, &demo->desc_set, 0, NULL);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600608
Courtney Goeltzenleuchter4cbf78b2015-09-17 15:06:17 -0600609 VkViewport viewport;
610 memset(&viewport, 0, sizeof(viewport));
611 viewport.height = (float) demo->height;
612 viewport.width = (float) demo->width;
613 viewport.minDepth = (float) 0.0f;
614 viewport.maxDepth = (float) 1.0f;
Jon Ashburn19255f82015-12-30 14:06:55 -0700615 vkCmdSetViewport(cmd_buf, 0, 1, &viewport);
Courtney Goeltzenleuchter4cbf78b2015-09-17 15:06:17 -0600616
617 VkRect2D scissor;
618 memset(&scissor, 0, sizeof(scissor));
619 scissor.extent.width = demo->width;
620 scissor.extent.height = demo->height;
621 scissor.offset.x = 0;
622 scissor.offset.y = 0;
Jon Ashburn19255f82015-12-30 14:06:55 -0700623 vkCmdSetScissor(cmd_buf, 0, 1, &scissor);
Courtney Goeltzenleuchter4cbf78b2015-09-17 15:06:17 -0600624
Courtney Goeltzenleuchter332a3672015-09-23 12:31:50 -0600625 vkCmdDraw(cmd_buf, 12 * 3, 1, 0, 0);
Chia-I Wu57b23b42015-06-26 15:34:39 +0800626 vkCmdEndRenderPass(cmd_buf);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600627
Tony Barbour15a4ef62015-10-21 10:14:48 -0600628 VkImageMemoryBarrier prePresentBarrier = {
629 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
630 .pNext = NULL,
Chia-I Wu19574622015-10-27 19:54:37 +0800631 .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
Tony Barboure5af5392016-01-05 09:59:05 -0700632 .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT,
Tony Barbour15a4ef62015-10-21 10:14:48 -0600633 .oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
Ian Elliottf4a4e442015-11-17 17:29:40 -0700634 .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
Tony Barbour15a4ef62015-10-21 10:14:48 -0600635 .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800636 .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
Tony Barbour15a4ef62015-10-21 10:14:48 -0600637 .subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }
638 };
639
640 prePresentBarrier.image = demo->buffers[demo->current_buffer].image;
641 VkImageMemoryBarrier *pmemory_barrier = &prePresentBarrier;
Tony Barboure5af5392016-01-05 09:59:05 -0700642 vkCmdPipelineBarrier(cmd_buf, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
Jon Ashburn0bec67e2016-01-11 13:12:43 -0700643 0, 0, NULL, 0, NULL, 1, pmemory_barrier);
Tony Barbour15a4ef62015-10-21 10:14:48 -0600644
645
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600646 err = vkEndCommandBuffer(cmd_buf);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600647 assert(!err);
648}
649
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600650
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -0600651void demo_update_data_buffer(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600652{
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600653 mat4x4 MVP, Model, VP;
654 int matrixSize = sizeof(MVP);
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600655 uint8_t *pData;
Tony Barbourfdc2d352015-04-22 09:02:32 -0600656 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600657
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600658 mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600659
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600660 // Rotate 22.5 degrees around the Y axis
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600661 mat4x4_dup(Model, demo->model_matrix);
Piers Daniell735ee532015-02-23 16:23:13 -0700662 mat4x4_rotate(demo->model_matrix, Model, 0.0f, 1.0f, 0.0f, (float)degreesToRadians(demo->spin_angle));
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600663 mat4x4_mul(MVP, VP, demo->model_matrix);
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600664
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200665 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 -0600666 assert(!err);
667
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600668 memcpy(pData, (const void*) &MVP[0][0], matrixSize);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600669
Mark Lobodzinskie4c92a62015-09-07 13:59:43 -0600670 vkUnmapMemory(demo->device, demo->uniform_data.mem);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600671}
672
673static void demo_draw(struct demo *demo)
674{
Tony Barbourfdc2d352015-04-22 09:02:32 -0600675 VkResult U_ASSERT_ONLY err;
Ian Elliottaaae5352015-07-06 14:27:58 -0600676 VkSemaphore presentCompleteSemaphore;
677 VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = {
678 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
679 .pNext = NULL,
Mark Lobodzinskie7ba7f12015-10-08 10:44:07 -0600680 .flags = 0,
Ian Elliottaaae5352015-07-06 14:27:58 -0600681 };
Chia-I Wu1c4086a2015-10-26 20:04:44 +0800682 VkFence nullFence = VK_NULL_HANDLE;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600683
Ian Elliottaaae5352015-07-06 14:27:58 -0600684 err = vkCreateSemaphore(demo->device,
685 &presentCompleteSemaphoreCreateInfo,
Chia-I Wu63636062015-10-26 21:10:41 +0800686 NULL,
Ian Elliottaaae5352015-07-06 14:27:58 -0600687 &presentCompleteSemaphore);
688 assert(!err);
689
690 // Get the index of the next available swapchain image:
Ian Elliottcf074d32015-10-16 18:02:43 -0600691 err = demo->fpAcquireNextImageKHR(demo->device, demo->swapchain,
Ian Elliottaaae5352015-07-06 14:27:58 -0600692 UINT64_MAX,
693 presentCompleteSemaphore,
Mark Youngcda9d842016-01-13 13:47:16 -0700694 (VkFence)0,// TODO: Show use of fence
Ian Elliottaaae5352015-07-06 14:27:58 -0600695 &demo->current_buffer);
Ian Elliottcf074d32015-10-16 18:02:43 -0600696 if (err == VK_ERROR_OUT_OF_DATE_KHR) {
697 // demo->swapchain is out of date (e.g. the window was resized) and
698 // must be recreated:
699 demo_resize(demo);
700 demo_draw(demo);
Chia-I Wu63636062015-10-26 21:10:41 +0800701 vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
Ian Elliottcf074d32015-10-16 18:02:43 -0600702 return;
703 } else if (err == VK_SUBOPTIMAL_KHR) {
704 // demo->swapchain is not as optimal as it could be, but the platform's
705 // presentation engine will still present the image correctly.
706 } else {
707 assert(!err);
708 }
Ian Elliottaaae5352015-07-06 14:27:58 -0600709
Tony Barbour15a4ef62015-10-21 10:14:48 -0600710 // Assume the command buffer has been run on current_buffer before so
711 // we need to set the image layout back to COLOR_ATTACHMENT_OPTIMAL
712 demo_set_image_layout(demo, demo->buffers[demo->current_buffer].image,
713 VK_IMAGE_ASPECT_COLOR_BIT,
Ian Elliottf4a4e442015-11-17 17:29:40 -0700714 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
Tony Barbour15a4ef62015-10-21 10:14:48 -0600715 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
716 demo_flush_init_cmd(demo);
717
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600718 // Wait for the present complete semaphore to be signaled to ensure
719 // that the image won't be rendered to until the presentation
720 // engine has fully released ownership to the application, and it is
721 // okay to render to the image.
722
Ian Elliottf4a4e442015-11-17 17:29:40 -0700723// FIXME/TODO: DEAL WITH VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
Jon Ashburn08ba3032015-12-31 12:32:16 -0700724 VkPipelineStageFlags pipe_stage_flags = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600725 VkSubmitInfo submit_info = {
Chia-I Wu4176d7b2015-10-26 20:37:06 +0800726 .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
727 .pNext = NULL,
Chia-I Wu3dfc1342015-10-26 20:48:51 +0800728 .waitSemaphoreCount = 1,
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600729 .pWaitSemaphores = &presentCompleteSemaphore,
Jon Ashburn244c6d02015-12-30 16:42:50 -0700730 .pWaitDstStageMask = &pipe_stage_flags,
Chia-I Wu3dfc1342015-10-26 20:48:51 +0800731 .commandBufferCount = 1,
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600732 .pCommandBuffers = &demo->buffers[demo->current_buffer].cmd,
Chia-I Wu3dfc1342015-10-26 20:48:51 +0800733 .signalSemaphoreCount = 0,
Courtney Goeltzenleuchter5fa898d2015-10-20 18:04:07 -0600734 .pSignalSemaphores = NULL
735 };
736
737 err = vkQueueSubmit(demo->queue, 1, &submit_info, nullFence);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600738 assert(!err);
739
Ian Elliotta0781972015-08-21 15:09:33 -0600740 VkPresentInfoKHR present = {
741 .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
Ian Elliottaaae5352015-07-06 14:27:58 -0600742 .pNext = NULL,
Ian Elliotta0781972015-08-21 15:09:33 -0600743 .swapchainCount = 1,
Ian Elliottb08e0d92015-11-20 11:55:46 -0700744 .pSwapchains = &demo->swapchain,
745 .pImageIndices = &demo->current_buffer,
Ian Elliottaaae5352015-07-06 14:27:58 -0600746 };
747
748// TBD/TODO: SHOULD THE "present" PARAMETER BE "const" IN THE HEADER?
Ian Elliotta0781972015-08-21 15:09:33 -0600749 err = demo->fpQueuePresentKHR(demo->queue, &present);
Ian Elliottcf074d32015-10-16 18:02:43 -0600750 if (err == VK_ERROR_OUT_OF_DATE_KHR) {
751 // demo->swapchain is out of date (e.g. the window was resized) and
752 // must be recreated:
753 demo_resize(demo);
754 } else if (err == VK_SUBOPTIMAL_KHR) {
755 // demo->swapchain is not as optimal as it could be, but the platform's
756 // presentation engine will still present the image correctly.
757 } else {
758 assert(!err);
759 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600760
Chia-I Wucbb564e2015-04-16 22:02:10 +0800761 err = vkQueueWaitIdle(demo->queue);
762 assert(err == VK_SUCCESS);
Mike Stroyan15fed6b2015-08-28 10:58:06 -0600763
Chia-I Wu63636062015-10-26 21:10:41 +0800764 vkDestroySemaphore(demo->device, presentCompleteSemaphore, NULL);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600765}
766
767static void demo_prepare_buffers(struct demo *demo)
768{
Ian Elliottaaae5352015-07-06 14:27:58 -0600769 VkResult U_ASSERT_ONLY err;
Ian Elliottcf074d32015-10-16 18:02:43 -0600770 VkSwapchainKHR oldSwapchain = demo->swapchain;
Ian Elliottaaae5352015-07-06 14:27:58 -0600771
Ian Elliottb08e0d92015-11-20 11:55:46 -0700772 // Check the surface capabilities and formats
773 VkSurfaceCapabilitiesKHR surfCapabilities;
774 err = demo->fpGetPhysicalDeviceSurfaceCapabilitiesKHR(demo->gpu,
775 demo->surface,
776 &surfCapabilities);
Ian Elliottaaae5352015-07-06 14:27:58 -0600777 assert(!err);
778
Ian Elliott8528eff2015-08-07 15:56:59 -0600779 uint32_t presentModeCount;
Ian Elliottb08e0d92015-11-20 11:55:46 -0700780 err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->gpu,
781 demo->surface,
Ian Elliott8528eff2015-08-07 15:56:59 -0600782 &presentModeCount, NULL);
Ian Elliottaaae5352015-07-06 14:27:58 -0600783 assert(!err);
Ian Elliotta0781972015-08-21 15:09:33 -0600784 VkPresentModeKHR *presentModes =
785 (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
Ian Elliott8528eff2015-08-07 15:56:59 -0600786 assert(presentModes);
Ian Elliottb08e0d92015-11-20 11:55:46 -0700787 err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->gpu,
788 demo->surface,
Ian Elliott8528eff2015-08-07 15:56:59 -0600789 &presentModeCount, presentModes);
Ian Elliottaaae5352015-07-06 14:27:58 -0600790 assert(!err);
791
Ian Elliotta0781972015-08-21 15:09:33 -0600792 VkExtent2D swapchainExtent;
Ian Elliottaaae5352015-07-06 14:27:58 -0600793 // width and height are either both -1, or both not -1.
Jon Ashburn0bec67e2016-01-11 13:12:43 -0700794 if (surfCapabilities.currentExtent.width == (uint32_t) -1)
Ian Elliottaaae5352015-07-06 14:27:58 -0600795 {
796 // If the surface size is undefined, the size is set to
797 // the size of the images requested.
Ian Elliotta0781972015-08-21 15:09:33 -0600798 swapchainExtent.width = demo->width;
799 swapchainExtent.height = demo->height;
Ian Elliottaaae5352015-07-06 14:27:58 -0600800 }
801 else
802 {
803 // If the surface size is defined, the swap chain size must match
Ian Elliottb08e0d92015-11-20 11:55:46 -0700804 swapchainExtent = surfCapabilities.currentExtent;
805 demo->width = surfCapabilities.currentExtent.width;
806 demo->height = surfCapabilities.currentExtent.height;
Ian Elliottaaae5352015-07-06 14:27:58 -0600807 }
808
809 // If mailbox mode is available, use it, as is the lowest-latency non-
Ian Elliott3ebce342015-07-27 13:53:11 -0600810 // tearing mode. If not, try IMMEDIATE which will usually be available,
811 // and is fastest (though it tears). If not, fall back to FIFO which is
812 // always available.
Ian Elliotta0781972015-08-21 15:09:33 -0600813 VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
Ian Elliottaaae5352015-07-06 14:27:58 -0600814 for (size_t i = 0; i < presentModeCount; i++) {
Ian Elliotta0781972015-08-21 15:09:33 -0600815 if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
816 swapchainPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
Ian Elliottaaae5352015-07-06 14:27:58 -0600817 break;
818 }
Ian Elliotta0781972015-08-21 15:09:33 -0600819 if ((swapchainPresentMode != VK_PRESENT_MODE_MAILBOX_KHR) &&
820 (presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR)) {
821 swapchainPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
Ian Elliott3ebce342015-07-27 13:53:11 -0600822 }
Ian Elliottaaae5352015-07-06 14:27:58 -0600823 }
824
825 // Determine the number of VkImage's to use in the swap chain (we desire to
826 // own only 1 image at a time, besides the images being displayed and
827 // queued for display):
Ian Elliottb08e0d92015-11-20 11:55:46 -0700828 uint32_t desiredNumberOfSwapchainImages = surfCapabilities.minImageCount + 1;
829 if ((surfCapabilities.maxImageCount > 0) &&
830 (desiredNumberOfSwapchainImages > surfCapabilities.maxImageCount))
Ian Elliottaaae5352015-07-06 14:27:58 -0600831 {
832 // Application must settle for fewer images than desired:
Ian Elliottb08e0d92015-11-20 11:55:46 -0700833 desiredNumberOfSwapchainImages = surfCapabilities.maxImageCount;
Ian Elliottaaae5352015-07-06 14:27:58 -0600834 }
835
Tony Barbour9fd6d352015-09-16 15:01:32 -0600836 VkSurfaceTransformFlagsKHR preTransform;
Ian Elliotta7a731c2015-12-11 15:52:12 -0700837 if (surfCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
838 preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
Ian Elliottaaae5352015-07-06 14:27:58 -0600839 } else {
Ian Elliottb08e0d92015-11-20 11:55:46 -0700840 preTransform = surfCapabilities.currentTransform;
Ian Elliottaaae5352015-07-06 14:27:58 -0600841 }
842
Ian Elliottcf074d32015-10-16 18:02:43 -0600843 const VkSwapchainCreateInfoKHR swapchain = {
Ian Elliott5b97eae2015-09-22 10:20:23 -0600844 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
Chia-I Wucbb564e2015-04-16 22:02:10 +0800845 .pNext = NULL,
Ian Elliottb08e0d92015-11-20 11:55:46 -0700846 .surface = demo->surface,
Ian Elliotta0781972015-08-21 15:09:33 -0600847 .minImageCount = desiredNumberOfSwapchainImages,
Chia-I Wucbb564e2015-04-16 22:02:10 +0800848 .imageFormat = demo->format,
Ian Elliott8528eff2015-08-07 15:56:59 -0600849 .imageColorSpace = demo->color_space,
Chia-I Wucbb564e2015-04-16 22:02:10 +0800850 .imageExtent = {
Ian Elliotta0781972015-08-21 15:09:33 -0600851 .width = swapchainExtent.width,
852 .height = swapchainExtent.height,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600853 },
Ian Elliottb08e0d92015-11-20 11:55:46 -0700854 .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
Ian Elliottaaae5352015-07-06 14:27:58 -0600855 .preTransform = preTransform,
Ian Elliott86f29a82015-12-28 15:25:33 -0700856 .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
Ian Elliottb08e0d92015-11-20 11:55:46 -0700857 .imageArrayLayers = 1,
858 .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
859 .queueFamilyIndexCount = 0,
Ian Elliott8528eff2015-08-07 15:56:59 -0600860 .pQueueFamilyIndices = NULL,
Ian Elliotta0781972015-08-21 15:09:33 -0600861 .presentMode = swapchainPresentMode,
Ian Elliottcf074d32015-10-16 18:02:43 -0600862 .oldSwapchain = oldSwapchain,
Ian Elliottaaae5352015-07-06 14:27:58 -0600863 .clipped = true,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600864 };
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600865 uint32_t i;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600866
Ian Elliottb08e0d92015-11-20 11:55:46 -0700867 err = demo->fpCreateSwapchainKHR(demo->device, &swapchain, NULL, &demo->swapchain);
Chia-I Wucbb564e2015-04-16 22:02:10 +0800868 assert(!err);
869
Ian Elliottcf074d32015-10-16 18:02:43 -0600870 // If we just re-created an existing swapchain, we should destroy the old
871 // swapchain at this point.
872 // Note: destroying the swapchain also cleans up all its associated
873 // presentable images once the platform is done with them.
Chia-I Wu1c4086a2015-10-26 20:04:44 +0800874 if (oldSwapchain != VK_NULL_HANDLE) {
Ian Elliottb08e0d92015-11-20 11:55:46 -0700875 demo->fpDestroySwapchainKHR(demo->device, oldSwapchain, NULL);
Ian Elliottcf074d32015-10-16 18:02:43 -0600876 }
877
878 err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swapchain,
Ian Elliotta0781972015-08-21 15:09:33 -0600879 &demo->swapchainImageCount, NULL);
Ian Elliottaaae5352015-07-06 14:27:58 -0600880 assert(!err);
Chia-I Wucbb564e2015-04-16 22:02:10 +0800881
Ian Elliotta0781972015-08-21 15:09:33 -0600882 VkImage* swapchainImages =
883 (VkImage*)malloc(demo->swapchainImageCount * sizeof(VkImage));
884 assert(swapchainImages);
Ian Elliottcf074d32015-10-16 18:02:43 -0600885 err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swapchain,
Ian Elliotta0781972015-08-21 15:09:33 -0600886 &demo->swapchainImageCount,
887 swapchainImages);
Ian Elliottaaae5352015-07-06 14:27:58 -0600888 assert(!err);
Ian Elliottaaae5352015-07-06 14:27:58 -0600889
Ian Elliotta0781972015-08-21 15:09:33 -0600890 demo->buffers = (SwapchainBuffers*)malloc(sizeof(SwapchainBuffers)*demo->swapchainImageCount);
Ian Elliottaaae5352015-07-06 14:27:58 -0600891 assert(demo->buffers);
892
Ian Elliotta0781972015-08-21 15:09:33 -0600893 for (i = 0; i < demo->swapchainImageCount; i++) {
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600894 VkImageViewCreateInfo color_image_view = {
895 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600896 .pNext = NULL,
897 .format = demo->format,
Chia-I Wub6d30c62015-10-27 19:00:15 +0800898 .components = {
Chia-I Wuf051d262015-10-27 19:25:11 +0800899 .r = VK_COMPONENT_SWIZZLE_R,
900 .g = VK_COMPONENT_SWIZZLE_G,
901 .b = VK_COMPONENT_SWIZZLE_B,
902 .a = VK_COMPONENT_SWIZZLE_A,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600903 },
904 .subresourceRange = {
Cody Northrop0e951672015-09-14 13:48:12 -0600905 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600906 .baseMipLevel = 0,
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800907 .levelCount = 1,
Courtney Goeltzenleuchterfc465b82015-09-10 16:38:41 -0600908 .baseArrayLayer = 0,
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800909 .layerCount = 1
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600910 },
911 .viewType = VK_IMAGE_VIEW_TYPE_2D,
912 .flags = 0,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600913 };
914
Ian Elliotta0781972015-08-21 15:09:33 -0600915 demo->buffers[i].image = swapchainImages[i];
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600916
Ian Elliottf4a4e442015-11-17 17:29:40 -0700917 // Render loop will expect image to have been used before and in VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
Tony Barbour15a4ef62015-10-21 10:14:48 -0600918 // layout and will change to COLOR_ATTACHMENT_OPTIMAL, so init the image to that state
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600919 demo_set_image_layout(demo, demo->buffers[i].image,
Tony Barbourc99f2942015-10-12 11:07:58 -0600920 VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600921 VK_IMAGE_LAYOUT_UNDEFINED,
Ian Elliottf4a4e442015-11-17 17:29:40 -0700922 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600923
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600924 color_image_view.image = demo->buffers[i].image;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600925
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600926 err = vkCreateImageView(demo->device,
Chia-I Wu63636062015-10-26 21:10:41 +0800927 &color_image_view, NULL, &demo->buffers[i].view);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600928 assert(!err);
929 }
930}
931
932static void demo_prepare_depth(struct demo *demo)
933{
Tony Barbour72304ef2015-04-16 15:59:00 -0600934 const VkFormat depth_format = VK_FORMAT_D16_UNORM;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600935 const VkImageCreateInfo image = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600936 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600937 .pNext = NULL,
Tony Barbour72304ef2015-04-16 15:59:00 -0600938 .imageType = VK_IMAGE_TYPE_2D,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600939 .format = depth_format,
940 .extent = { demo->width, demo->height, 1 },
941 .mipLevels = 1,
Courtney Goeltzenleuchterdff021f2015-10-21 17:57:31 -0600942 .arrayLayers = 1,
Chia-I Wu3ede9462015-10-31 00:31:16 +0800943 .samples = VK_SAMPLE_COUNT_1_BIT,
Tony Barbour72304ef2015-04-16 15:59:00 -0600944 .tiling = VK_IMAGE_TILING_OPTIMAL,
Courtney Goeltzenleuchter4e368ee2015-09-10 14:14:11 -0600945 .usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600946 .flags = 0,
947 };
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200948
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600949 VkImageViewCreateInfo view = {
950 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600951 .pNext = NULL,
Chia-I Wu1c4086a2015-10-26 20:04:44 +0800952 .image = VK_NULL_HANDLE,
Courtney Goeltzenleuchter556ee322015-07-15 17:41:38 -0600953 .format = depth_format,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600954 .subresourceRange = {
Cody Northrop0e951672015-09-14 13:48:12 -0600955 .aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600956 .baseMipLevel = 0,
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800957 .levelCount = 1,
Courtney Goeltzenleuchterfc465b82015-09-10 16:38:41 -0600958 .baseArrayLayer = 0,
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800959 .layerCount = 1
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600960 },
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600961 .flags = 0,
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -0600962 .viewType = VK_IMAGE_VIEW_TYPE_2D,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600963 };
Mike Stroyanebae8322015-04-17 12:36:38 -0600964
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500965 VkMemoryRequirements mem_reqs;
Tony Barbourfdc2d352015-04-22 09:02:32 -0600966 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600967 bool U_ASSERT_ONLY pass;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600968
969 demo->depth.format = depth_format;
970
971 /* create image */
Chia-I Wu63636062015-10-26 21:10:41 +0800972 err = vkCreateImage(demo->device, &image, NULL,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600973 &demo->depth.image);
974 assert(!err);
975
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -0600976 vkGetImageMemoryRequirements(demo->device,
Tony Barbour155cce82015-07-03 10:33:54 -0600977 demo->depth.image, &mem_reqs);
Tony Barbourcb59a5d2015-10-23 10:53:30 -0600978 assert(!err);
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600979
Chia-I Wuf48700b2015-11-10 16:21:09 +0800980 demo->depth.mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200981 demo->depth.mem_alloc.pNext = NULL;
982 demo->depth.mem_alloc.allocationSize = mem_reqs.size;
983 demo->depth.mem_alloc.memoryTypeIndex = 0;
984
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600985 pass = memory_type_from_properties(demo,
Mark Lobodzinskieadf9982015-07-02 16:49:40 -0600986 mem_reqs.memoryTypeBits,
Tony Barbour8a9f62a2015-10-15 12:42:56 -0600987 0, /* No requirements */
Dominik Witczak2fe1c702015-09-22 18:25:33 +0200988 &demo->depth.mem_alloc.memoryTypeIndex);
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -0600989 assert(pass);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600990
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500991 /* allocate memory */
Chia-I Wua8fe78a2015-10-27 18:04:07 +0800992 err = vkAllocateMemory(demo->device, &demo->depth.mem_alloc,
Chia-I Wu63636062015-10-26 21:10:41 +0800993 NULL, &demo->depth.mem);
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500994 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600995
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500996 /* bind memory */
Tony Barbour155cce82015-07-03 10:33:54 -0600997 err = vkBindImageMemory(demo->device, demo->depth.image,
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500998 demo->depth.mem, 0);
999 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001000
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001001 demo_set_image_layout(demo, demo->depth.image,
Cody Northrop0e951672015-09-14 13:48:12 -06001002 VK_IMAGE_ASPECT_DEPTH_BIT,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001003 VK_IMAGE_LAYOUT_UNDEFINED,
1004 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001005
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001006 /* create image view */
1007 view.image = demo->depth.image;
Chia-I Wu63636062015-10-26 21:10:41 +08001008 err = vkCreateImageView(demo->device, &view, NULL, &demo->depth.view);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001009 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001010}
1011
Tony Barbour1a86d032015-09-21 15:17:33 -06001012/* Load a ppm file into memory */
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001013bool loadTexture(const char *filename, uint8_t *rgba_data,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001014 VkSubresourceLayout *layout,
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001015 int32_t *width, int32_t *height)
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001016{
Tony Barbour1a86d032015-09-21 15:17:33 -06001017 FILE *fPtr = fopen(filename,"rb");
Courtney Goeltzenleuchterd3cdaaf2015-12-17 09:53:29 -07001018 char header[256], *cPtr, *tmp;
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001019
Tony Barbour1a86d032015-09-21 15:17:33 -06001020 if (!fPtr)
1021 return false;
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001022
Tony Barbour1a86d032015-09-21 15:17:33 -06001023 cPtr = fgets(header, 256, fPtr); // P6
Mike Stroyan9e9792a2015-10-28 11:15:46 -06001024 if (cPtr == NULL || strncmp(header, "P6\n", 3)) {
1025 fclose(fPtr);
Tony Barbour1a86d032015-09-21 15:17:33 -06001026 return false;
Mike Stroyan9e9792a2015-10-28 11:15:46 -06001027 }
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001028
Tony Barbour1a86d032015-09-21 15:17:33 -06001029 do {
1030 cPtr = fgets(header, 256, fPtr);
Mike Stroyan9e9792a2015-10-28 11:15:46 -06001031 if (cPtr == NULL) {
1032 fclose(fPtr);
Tony Barbour1a86d032015-09-21 15:17:33 -06001033 return false;
Mike Stroyan9e9792a2015-10-28 11:15:46 -06001034 }
Tony Barbour1a86d032015-09-21 15:17:33 -06001035 } while ( !strncmp(header, "#", 1) );
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001036
Tony Barbour1a86d032015-09-21 15:17:33 -06001037 sscanf(header, "%u %u", height, width);
Mike Stroyan9e9792a2015-10-28 11:15:46 -06001038 if (rgba_data == NULL) {
1039 fclose(fPtr);
Tony Barbour1a86d032015-09-21 15:17:33 -06001040 return true;
Mike Stroyan9e9792a2015-10-28 11:15:46 -06001041 }
Courtney Goeltzenleuchterd3cdaaf2015-12-17 09:53:29 -07001042 tmp = fgets(header, 256, fPtr); // Format
1043 (void) tmp;
Mike Stroyan9e9792a2015-10-28 11:15:46 -06001044 if (cPtr == NULL || strncmp(header, "255\n", 3)) {
1045 fclose(fPtr);
Tony Barbour1a86d032015-09-21 15:17:33 -06001046 return false;
Mike Stroyan9e9792a2015-10-28 11:15:46 -06001047 }
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001048
Tony Barbour1a86d032015-09-21 15:17:33 -06001049 for(int y = 0; y < *height; y++)
1050 {
1051 uint8_t *rowPtr = rgba_data;
1052 for(int x = 0; x < *width; x++)
1053 {
Courtney Goeltzenleuchterd3cdaaf2015-12-17 09:53:29 -07001054 size_t s = fread(rowPtr, 3, 1, fPtr);
1055 (void) s;
Tony Barbour1a86d032015-09-21 15:17:33 -06001056 rowPtr[3] = 255; /* Alpha of 1 */
1057 rowPtr += 4;
1058 }
1059 rgba_data += layout->rowPitch;
1060 }
1061 fclose(fPtr);
Mike Stroyan9e9792a2015-10-28 11:15:46 -06001062 return true;
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001063}
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001064
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001065static void demo_prepare_texture_image(struct demo *demo,
1066 const char *filename,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001067 struct texture_object *tex_obj,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001068 VkImageTiling tiling,
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -06001069 VkImageUsageFlags usage,
Tony Barbour8a9f62a2015-10-15 12:42:56 -06001070 VkFlags required_props)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001071{
Mike Stroyan8b89e072015-06-15 14:21:03 -06001072 const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001073 int32_t tex_width;
1074 int32_t tex_height;
Tony Barbourfdc2d352015-04-22 09:02:32 -06001075 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -06001076 bool U_ASSERT_ONLY pass;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001077
David Pinedo30bd71d2015-04-23 08:16:57 -06001078 if (!loadTexture(filename, NULL, NULL, &tex_width, &tex_height))
1079 {
1080 printf("Failed to load textures\n");
1081 fflush(stdout);
1082 exit(1);
1083 }
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001084
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001085 tex_obj->tex_width = tex_width;
1086 tex_obj->tex_height = tex_height;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001087
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001088 const VkImageCreateInfo image_create_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001089 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001090 .pNext = NULL,
Tony Barbour72304ef2015-04-16 15:59:00 -06001091 .imageType = VK_IMAGE_TYPE_2D,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001092 .format = tex_format,
1093 .extent = { tex_width, tex_height, 1 },
1094 .mipLevels = 1,
Courtney Goeltzenleuchterdff021f2015-10-21 17:57:31 -06001095 .arrayLayers = 1,
Chia-I Wu3ede9462015-10-31 00:31:16 +08001096 .samples = VK_SAMPLE_COUNT_1_BIT,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001097 .tiling = tiling,
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -06001098 .usage = usage,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001099 .flags = 0,
1100 };
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001101
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001102 VkMemoryRequirements mem_reqs;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001103
Chia-I Wu63636062015-10-26 21:10:41 +08001104 err = vkCreateImage(demo->device, &image_create_info, NULL,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001105 &tex_obj->image);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001106 assert(!err);
1107
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06001108 vkGetImageMemoryRequirements(demo->device, tex_obj->image, &mem_reqs);
Piers Daniell735ee532015-02-23 16:23:13 -07001109
Chia-I Wuf48700b2015-11-10 16:21:09 +08001110 tex_obj->mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001111 tex_obj->mem_alloc.pNext = NULL;
1112 tex_obj->mem_alloc.allocationSize = mem_reqs.size;
1113 tex_obj->mem_alloc.memoryTypeIndex = 0;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001114
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -06001115 pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, required_props, &tex_obj->mem_alloc.memoryTypeIndex);
1116 assert(pass);
Mark Lobodzinskieadf9982015-07-02 16:49:40 -06001117
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001118 /* allocate memory */
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001119 err = vkAllocateMemory(demo->device, &tex_obj->mem_alloc, NULL,
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001120 &(tex_obj->mem));
1121 assert(!err);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001122
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001123 /* bind memory */
Tony Barbour155cce82015-07-03 10:33:54 -06001124 err = vkBindImageMemory(demo->device, tex_obj->image,
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001125 tex_obj->mem, 0);
1126 assert(!err);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001127
Tony Barbour8a9f62a2015-10-15 12:42:56 -06001128 if (required_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001129 const VkImageSubresource subres = {
Chia-I Wua0141432015-10-27 19:55:05 +08001130 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001131 .mipLevel = 0,
Courtney Goeltzenleuchterfc465b82015-09-10 16:38:41 -06001132 .arrayLayer = 0,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001133 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001134 VkSubresourceLayout layout;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001135 void *data;
1136
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06001137 vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001138
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001139 err = vkMapMemory(demo->device, tex_obj->mem, 0, tex_obj->mem_alloc.allocationSize, 0, &data);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001140 assert(!err);
1141
1142 if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) {
1143 fprintf(stderr, "Error loading texture: %s\n", filename);
1144 }
1145
Mark Lobodzinskie4c92a62015-09-07 13:59:43 -06001146 vkUnmapMemory(demo->device, tex_obj->mem);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001147 }
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001148
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001149 tex_obj->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001150 demo_set_image_layout(demo, tex_obj->image,
Tony Barbourc99f2942015-10-12 11:07:58 -06001151 VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001152 VK_IMAGE_LAYOUT_UNDEFINED,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001153 tex_obj->imageLayout);
1154 /* 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 -07001155}
1156
Mark Lobodzinskida9b1092015-04-16 11:44:05 -05001157static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_objs)
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001158{
1159 /* clean up staging resources */
Chia-I Wu63636062015-10-26 21:10:41 +08001160 vkFreeMemory(demo->device, tex_objs->mem, NULL);
1161 vkDestroyImage(demo->device, tex_objs->image, NULL);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001162}
1163
1164static void demo_prepare_textures(struct demo *demo)
1165{
Tony Barbour72304ef2015-04-16 15:59:00 -06001166 const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001167 VkFormatProperties props;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001168 uint32_t i;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001169
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06001170 vkGetPhysicalDeviceFormatProperties(demo->gpu, tex_format, &props);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001171
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001172 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06001173 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001174
FslNopper6a7e50e2015-05-06 21:42:01 +02001175 if ((props.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) && !demo->use_staging_buffer) {
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001176 /* Device can texture using linear textures */
1177 demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i],
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -06001178 VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_SAMPLED_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
Tony Barbour72304ef2015-04-16 15:59:00 -06001179 } else if (props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001180 /* Must use staging buffer to copy linear texture to optimized */
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001181 struct texture_object staging_texture;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001182
1183 memset(&staging_texture, 0, sizeof(staging_texture));
1184 demo_prepare_texture_image(demo, tex_files[i], &staging_texture,
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001185 VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001186
1187 demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i],
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -06001188 VK_IMAGE_TILING_OPTIMAL,
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001189 (VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),
Chia-I Wuc42afd72015-10-27 18:53:22 +08001190 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001191
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001192 demo_set_image_layout(demo, staging_texture.image,
Tony Barbourc99f2942015-10-12 11:07:58 -06001193 VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001194 staging_texture.imageLayout,
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001195 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001196
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001197 demo_set_image_layout(demo, demo->textures[i].image,
Tony Barbourc99f2942015-10-12 11:07:58 -06001198 VK_IMAGE_ASPECT_COLOR_BIT,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001199 demo->textures[i].imageLayout,
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001200 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001201
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001202 VkImageCopy copy_region = {
Tony Barbour466f0012015-11-02 11:47:51 -07001203 .srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 },
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001204 .srcOffset = { 0, 0, 0 },
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001205 .dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 },
1206 .dstOffset = { 0, 0, 0 },
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001207 .extent = { staging_texture.tex_width, staging_texture.tex_height, 1 },
1208 };
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001209 vkCmdCopyImage(demo->cmd,
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001210 staging_texture.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1211 demo->textures[i].image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
Courtney Goeltzenleuchter8e89a312015-03-25 11:25:10 -06001212 1, &copy_region);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001213
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001214 demo_set_image_layout(demo, demo->textures[i].image,
Tony Barbourc99f2942015-10-12 11:07:58 -06001215 VK_IMAGE_ASPECT_COLOR_BIT,
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001216 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001217 demo->textures[i].imageLayout);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001218
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001219 demo_flush_init_cmd(demo);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001220
Courtney Goeltzenleuchterf3aeb2b2015-04-21 09:30:03 -06001221 demo_destroy_texture_image(demo, &staging_texture);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001222 } else {
Mike Stroyan8b89e072015-06-15 14:21:03 -06001223 /* Can't support VK_FORMAT_R8G8B8A8_UNORM !? */
1224 assert(!"No support for R8G8B8A8_UNORM as texture image format");
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001225 }
1226
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001227 const VkSamplerCreateInfo sampler = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001228 .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001229 .pNext = NULL,
Chia-I Wu6ef8c3b2015-10-26 16:49:32 +08001230 .magFilter = VK_FILTER_NEAREST,
1231 .minFilter = VK_FILTER_NEAREST,
Jon Ashburn0bec67e2016-01-11 13:12:43 -07001232 .mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST,
Chia-I Wu6555f3f2015-10-26 17:32:47 +08001233 .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1234 .addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1235 .addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001236 .mipLodBias = 0.0f,
Jon Ashburn55e3fb02015-12-14 14:59:20 -07001237 .anisotropyEnable = VK_FALSE,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001238 .maxAnisotropy = 1,
Tony Barbour72304ef2015-04-16 15:59:00 -06001239 .compareOp = VK_COMPARE_OP_NEVER,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001240 .minLod = 0.0f,
1241 .maxLod = 0.0f,
Tony Barbourcb530c72015-06-25 16:56:44 -06001242 .borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
Mark Lobodzinski644dc492015-09-01 15:42:56 -06001243 .unnormalizedCoordinates = VK_FALSE,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001244 };
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001245
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001246 VkImageViewCreateInfo view = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001247 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001248 .pNext = NULL,
Chia-I Wu1c4086a2015-10-26 20:04:44 +08001249 .image = VK_NULL_HANDLE,
Tony Barbour72304ef2015-04-16 15:59:00 -06001250 .viewType = VK_IMAGE_VIEW_TYPE_2D,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001251 .format = tex_format,
Chia-I Wub6d30c62015-10-27 19:00:15 +08001252 .components = { VK_COMPONENT_SWIZZLE_R,
Chia-I Wuf051d262015-10-27 19:25:11 +08001253 VK_COMPONENT_SWIZZLE_G,
1254 VK_COMPONENT_SWIZZLE_B,
1255 VK_COMPONENT_SWIZZLE_A, },
Cody Northrop0e951672015-09-14 13:48:12 -06001256 .subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 },
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -06001257 .flags = 0,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001258 };
Jon Ashburnb2a66652015-01-16 09:37:43 -07001259
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001260 /* create sampler */
Chia-I Wu63636062015-10-26 21:10:41 +08001261 err = vkCreateSampler(demo->device, &sampler, NULL,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001262 &demo->textures[i].sampler);
1263 assert(!err);
1264
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001265 /* create image view */
1266 view.image = demo->textures[i].image;
Chia-I Wu63636062015-10-26 21:10:41 +08001267 err = vkCreateImageView(demo->device, &view, NULL,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001268 &demo->textures[i].view);
1269 assert(!err);
1270 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001271}
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001272
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001273void demo_prepare_cube_data_buffer(struct demo *demo)
1274{
Courtney Goeltzenleuchter28c4d5f2015-04-14 18:48:46 -06001275 VkBufferCreateInfo buf_info;
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001276 VkMemoryRequirements mem_reqs;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001277 uint8_t *pData;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001278 int i;
1279 mat4x4 MVP, VP;
Tony Barbourfdc2d352015-04-22 09:02:32 -06001280 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -06001281 bool U_ASSERT_ONLY pass;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001282 struct vktexcube_vs_uniform data;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001283
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001284 mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001285 mat4x4_mul(MVP, VP, demo->model_matrix);
1286 memcpy(data.mvp, MVP, sizeof(MVP));
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001287// dumpMatrix("MVP", MVP);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001288
1289 for (i=0; i<12*3; i++) {
1290 data.position[i][0] = g_vertex_buffer_data[i*3];
1291 data.position[i][1] = g_vertex_buffer_data[i*3+1];
1292 data.position[i][2] = g_vertex_buffer_data[i*3+2];
1293 data.position[i][3] = 1.0f;
1294 data.attr[i][0] = g_uv_buffer_data[2*i];
1295 data.attr[i][1] = g_uv_buffer_data[2*i + 1];
1296 data.attr[i][2] = 0;
1297 data.attr[i][3] = 0;
1298 }
1299
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001300 memset(&buf_info, 0, sizeof(buf_info));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001301 buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -06001302 buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
Cody Northrop91807302015-07-16 10:29:32 -06001303 buf_info.size = sizeof(data);
Chia-I Wu63636062015-10-26 21:10:41 +08001304 err = vkCreateBuffer(demo->device, &buf_info, NULL,
1305 &demo->uniform_data.buf);
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001306 assert(!err);
1307
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06001308 vkGetBufferMemoryRequirements(demo->device, demo->uniform_data.buf, &mem_reqs);
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001309
Chia-I Wuf48700b2015-11-10 16:21:09 +08001310 demo->uniform_data.mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001311 demo->uniform_data.mem_alloc.pNext = NULL;
1312 demo->uniform_data.mem_alloc.allocationSize = mem_reqs.size;
1313 demo->uniform_data.mem_alloc.memoryTypeIndex = 0;
1314
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -06001315 pass = memory_type_from_properties(demo,
Mark Lobodzinskieadf9982015-07-02 16:49:40 -06001316 mem_reqs.memoryTypeBits,
1317 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001318 &demo->uniform_data.mem_alloc.memoryTypeIndex);
Courtney Goeltzenleuchter87a0ef02015-10-22 11:03:31 -06001319 assert(pass);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001320
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001321 err = vkAllocateMemory(demo->device, &demo->uniform_data.mem_alloc,
Chia-I Wu63636062015-10-26 21:10:41 +08001322 NULL, &(demo->uniform_data.mem));
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001323 assert(!err);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001324
Dominik Witczak2fe1c702015-09-22 18:25:33 +02001325 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 -05001326 assert(!err);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001327
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001328 memcpy(pData, &data, sizeof data);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001329
Mark Lobodzinskie4c92a62015-09-07 13:59:43 -06001330 vkUnmapMemory(demo->device, demo->uniform_data.mem);
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001331
Tony Barbour155cce82015-07-03 10:33:54 -06001332 err = vkBindBufferMemory(demo->device,
1333 demo->uniform_data.buf,
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001334 demo->uniform_data.mem, 0);
1335 assert(!err);
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001336
Courtney Goeltzenleuchterc3ad65e2015-10-23 13:38:14 -06001337 demo->uniform_data.buffer_info.buffer = demo->uniform_data.buf;
1338 demo->uniform_data.buffer_info.offset = 0;
1339 demo->uniform_data.buffer_info.range = sizeof(data);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001340}
1341
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001342static void demo_prepare_descriptor_layout(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001343{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001344 const VkDescriptorSetLayoutBinding layout_bindings[2] = {
Chia-I Wua2aa8632015-03-26 15:04:41 +08001345 [0] = {
Chia-I Wued577562015-10-31 00:31:16 +08001346 .binding = 0,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001347 .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
Chia-I Wu8b497442015-11-06 06:42:02 +08001348 .descriptorCount = 1,
Tony Barbour72304ef2015-04-16 15:59:00 -06001349 .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
Chia-I Wu91e8e212015-03-27 12:56:09 +08001350 .pImmutableSamplers = NULL,
Chia-I Wua2aa8632015-03-26 15:04:41 +08001351 },
1352 [1] = {
Chia-I Wued577562015-10-31 00:31:16 +08001353 .binding = 1,
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -06001354 .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
Chia-I Wu8b497442015-11-06 06:42:02 +08001355 .descriptorCount = DEMO_TEXTURE_COUNT,
Tony Barbour72304ef2015-04-16 15:59:00 -06001356 .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
Chia-I Wu91e8e212015-03-27 12:56:09 +08001357 .pImmutableSamplers = NULL,
Chia-I Wua2aa8632015-03-26 15:04:41 +08001358 },
1359 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001360 const VkDescriptorSetLayoutCreateInfo descriptor_layout = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001361 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001362 .pNext = NULL,
Chia-I Wu3dfc1342015-10-26 20:48:51 +08001363 .bindingCount = 2,
Jon Ashburn238f3432015-12-30 18:01:16 -07001364 .pBindings = layout_bindings,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001365 };
Tony Barbourfdc2d352015-04-22 09:02:32 -06001366 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001367
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001368 err = vkCreateDescriptorSetLayout(demo->device,
Chia-I Wu63636062015-10-26 21:10:41 +08001369 &descriptor_layout, NULL, &demo->desc_layout);
Chia-I Wub58c24a2015-03-26 15:27:55 +08001370 assert(!err);
1371
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -05001372 const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
1373 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
1374 .pNext = NULL,
Chia-I Wu3dfc1342015-10-26 20:48:51 +08001375 .setLayoutCount = 1,
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -05001376 .pSetLayouts = &demo->desc_layout,
1377 };
1378
1379 err = vkCreatePipelineLayout(demo->device,
1380 &pPipelineLayoutCreateInfo,
Chia-I Wu63636062015-10-26 21:10:41 +08001381 NULL,
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -05001382 &demo->pipeline_layout);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001383 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001384}
1385
Chia-I Wuf973e322015-07-08 13:34:24 +08001386static void demo_prepare_render_pass(struct demo *demo)
1387{
Chia-I Wua74c5b22015-07-07 11:50:03 +08001388 const VkAttachmentDescription attachments[2] = {
1389 [0] = {
Chia-I Wua74c5b22015-07-07 11:50:03 +08001390 .format = demo->format,
Chia-I Wu3ede9462015-10-31 00:31:16 +08001391 .samples = VK_SAMPLE_COUNT_1_BIT,
Chia-I Wua74c5b22015-07-07 11:50:03 +08001392 .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
1393 .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
1394 .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1395 .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1396 .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1397 .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1398 },
1399 [1] = {
Chia-I Wua74c5b22015-07-07 11:50:03 +08001400 .format = demo->depth.format,
Chia-I Wu3ede9462015-10-31 00:31:16 +08001401 .samples = VK_SAMPLE_COUNT_1_BIT,
Chia-I Wua74c5b22015-07-07 11:50:03 +08001402 .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
1403 .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1404 .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1405 .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1406 .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1407 .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1408 },
Chia-I Wuf973e322015-07-08 13:34:24 +08001409 };
Chia-I Wua74c5b22015-07-07 11:50:03 +08001410 const VkAttachmentReference color_reference = {
1411 .attachment = 0,
1412 .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1413 };
Chia-I Wu6555f3f2015-10-26 17:32:47 +08001414 const VkAttachmentReference depth_reference = {
1415 .attachment = 1,
1416 .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1417 };
Chia-I Wua74c5b22015-07-07 11:50:03 +08001418 const VkSubpassDescription subpass = {
Chia-I Wua74c5b22015-07-07 11:50:03 +08001419 .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
1420 .flags = 0,
Chia-I Wu3dfc1342015-10-26 20:48:51 +08001421 .inputAttachmentCount = 0,
Cody Northrop945bb832015-08-04 11:16:41 -06001422 .pInputAttachments = NULL,
Chia-I Wu3dfc1342015-10-26 20:48:51 +08001423 .colorAttachmentCount = 1,
Cody Northrop945bb832015-08-04 11:16:41 -06001424 .pColorAttachments = &color_reference,
1425 .pResolveAttachments = NULL,
Chia-I Wu6555f3f2015-10-26 17:32:47 +08001426 .pDepthStencilAttachment = &depth_reference,
Chia-I Wu3dfc1342015-10-26 20:48:51 +08001427 .preserveAttachmentCount = 0,
Cody Northrop945bb832015-08-04 11:16:41 -06001428 .pPreserveAttachments = NULL,
Chia-I Wua74c5b22015-07-07 11:50:03 +08001429 };
Chia-I Wuf973e322015-07-08 13:34:24 +08001430 const VkRenderPassCreateInfo rp_info = {
1431 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
1432 .pNext = NULL,
Chia-I Wua74c5b22015-07-07 11:50:03 +08001433 .attachmentCount = 2,
1434 .pAttachments = attachments,
1435 .subpassCount = 1,
1436 .pSubpasses = &subpass,
1437 .dependencyCount = 0,
1438 .pDependencies = NULL,
Chia-I Wuf973e322015-07-08 13:34:24 +08001439 };
Chia-I Wua74c5b22015-07-07 11:50:03 +08001440 VkResult U_ASSERT_ONLY err;
Chia-I Wuf973e322015-07-08 13:34:24 +08001441
Chia-I Wu63636062015-10-26 21:10:41 +08001442 err = vkCreateRenderPass(demo->device, &rp_info, NULL, &demo->render_pass);
Chia-I Wuf973e322015-07-08 13:34:24 +08001443 assert(!err);
1444}
1445
Chia-I Wu46176f12015-10-31 00:31:16 +08001446static VkShaderModule demo_prepare_shader_module(struct demo* demo,
Chia-I Wu46176f12015-10-31 00:31:16 +08001447 const void* code,
1448 size_t size)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001449{
Chia-I Wu46176f12015-10-31 00:31:16 +08001450 VkShaderModule module;
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001451 VkShaderModuleCreateInfo moduleCreateInfo;
Courtney Goeltzenleuchterd3cdaaf2015-12-17 09:53:29 -07001452 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001453
Courtney Goeltzenleuchtera80a1a92015-06-24 18:24:19 -06001454 moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
1455 moduleCreateInfo.pNext = NULL;
1456
Courtney Goeltzenleuchtera95e3052015-10-30 15:19:27 -06001457 moduleCreateInfo.codeSize = size;
1458 moduleCreateInfo.pCode = code;
1459 moduleCreateInfo.flags = 0;
1460 err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, &module);
1461 assert(!err);
Chia-I Wu46176f12015-10-31 00:31:16 +08001462
1463 return module;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001464}
1465
Cody Northrop8b12a1f2015-03-17 15:55:58 -06001466char *demo_read_spv(const char *filename, size_t *psize)
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001467{
1468 long int size;
Tony Barbourf9921732015-04-22 11:36:22 -06001469 size_t U_ASSERT_ONLY retval;
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001470 void *shader_code;
1471
1472 FILE *fp = fopen(filename, "rb");
1473 if (!fp) return NULL;
1474
1475 fseek(fp, 0L, SEEK_END);
1476 size = ftell(fp);
1477
1478 fseek(fp, 0L, SEEK_SET);
1479
1480 shader_code = malloc(size);
Tony Barbourfdc2d352015-04-22 09:02:32 -06001481 retval = fread(shader_code, size, 1, fp);
1482 assert(retval == 1);
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001483
1484 *psize = size;
1485
Mike Stroyan9e9792a2015-10-28 11:15:46 -06001486 fclose(fp);
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001487 return shader_code;
1488}
1489
Chia-I Wu46176f12015-10-31 00:31:16 +08001490static VkShaderModule demo_prepare_vs(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001491{
Courtney Goeltzenleuchtera95e3052015-10-30 15:19:27 -06001492 void *vertShaderCode;
1493 size_t size;
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001494
Courtney Goeltzenleuchtera95e3052015-10-30 15:19:27 -06001495 vertShaderCode = demo_read_spv("cube-vert.spv", &size);
1496
Tony Barbourf331eb32015-11-06 10:10:37 -07001497 demo->vert_shader_module = demo_prepare_shader_module(demo, vertShaderCode, size);
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001498
Courtney Goeltzenleuchtera95e3052015-10-30 15:19:27 -06001499 free(vertShaderCode);
Chia-I Wu46176f12015-10-31 00:31:16 +08001500
1501 return demo->vert_shader_module;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001502}
1503
Chia-I Wu46176f12015-10-31 00:31:16 +08001504static VkShaderModule demo_prepare_fs(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001505{
Courtney Goeltzenleuchtera95e3052015-10-30 15:19:27 -06001506 void *fragShaderCode;
1507 size_t size;
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001508
Courtney Goeltzenleuchtera95e3052015-10-30 15:19:27 -06001509 fragShaderCode = demo_read_spv("cube-frag.spv", &size);
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001510
Tony Barbourf331eb32015-11-06 10:10:37 -07001511 demo->frag_shader_module = demo_prepare_shader_module(demo, fragShaderCode, size);
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001512
Courtney Goeltzenleuchtera95e3052015-10-30 15:19:27 -06001513 free(fragShaderCode);
Chia-I Wu46176f12015-10-31 00:31:16 +08001514
1515 return demo->frag_shader_module;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001516}
1517
1518static void demo_prepare_pipeline(struct demo *demo)
1519{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001520 VkGraphicsPipelineCreateInfo pipeline;
Jon Ashburnc4ab7af2015-07-09 15:02:25 -06001521 VkPipelineCacheCreateInfo pipelineCache;
Jason Ekstrand515b7ae2015-10-15 17:15:25 -07001522 VkPipelineVertexInputStateCreateInfo vi;
Tony Barbour194bf282015-07-10 15:29:03 -06001523 VkPipelineInputAssemblyStateCreateInfo ia;
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001524 VkPipelineRasterizationStateCreateInfo rs;
Tony Barbour194bf282015-07-10 15:29:03 -06001525 VkPipelineColorBlendStateCreateInfo cb;
1526 VkPipelineDepthStencilStateCreateInfo ds;
1527 VkPipelineViewportStateCreateInfo vp;
1528 VkPipelineMultisampleStateCreateInfo ms;
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001529 VkDynamicState dynamicStateEnables[VK_DYNAMIC_STATE_RANGE_SIZE];
Piers Daniellba839d12015-09-29 13:01:09 -06001530 VkPipelineDynamicStateCreateInfo dynamicState;
Tony Barbourfdc2d352015-04-22 09:02:32 -06001531 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001532
Piers Daniellba839d12015-09-29 13:01:09 -06001533 memset(dynamicStateEnables, 0, sizeof dynamicStateEnables);
1534 memset(&dynamicState, 0, sizeof dynamicState);
1535 dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
1536 dynamicState.pDynamicStates = dynamicStateEnables;
1537
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001538 memset(&pipeline, 0, sizeof(pipeline));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001539 pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -05001540 pipeline.layout = demo->pipeline_layout;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001541
Jason Ekstrand515b7ae2015-10-15 17:15:25 -07001542 memset(&vi, 0, sizeof(vi));
1543 vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
1544
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001545 memset(&ia, 0, sizeof(ia));
Tony Barbour194bf282015-07-10 15:29:03 -06001546 ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
Tony Barbour72304ef2015-04-16 15:59:00 -06001547 ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001548
1549 memset(&rs, 0, sizeof(rs));
Chia-I Wuf051d262015-10-27 19:25:11 +08001550 rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
1551 rs.polygonMode = VK_POLYGON_MODE_FILL;
Chia-I Wu6555f3f2015-10-26 17:32:47 +08001552 rs.cullMode = VK_CULL_MODE_BACK_BIT;
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001553 rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
Courtney Goeltzenleuchter0db2c912015-10-15 12:57:38 -06001554 rs.depthClampEnable = VK_FALSE;
Cody Northrop709c1742015-08-17 11:10:49 -06001555 rs.rasterizerDiscardEnable = VK_FALSE;
1556 rs.depthBiasEnable = VK_FALSE;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001557
1558 memset(&cb, 0, sizeof(cb));
Tony Barbour194bf282015-07-10 15:29:03 -06001559 cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
1560 VkPipelineColorBlendAttachmentState att_state[1];
Tony Barbour29645d02015-01-16 14:27:35 -07001561 memset(att_state, 0, sizeof(att_state));
Chia-I Wuf051d262015-10-27 19:25:11 +08001562 att_state[0].colorWriteMask = 0xf;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001563 att_state[0].blendEnable = VK_FALSE;
Tony Barbour29645d02015-01-16 14:27:35 -07001564 cb.attachmentCount = 1;
1565 cb.pAttachments = att_state;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001566
Tony Barbour29645d02015-01-16 14:27:35 -07001567 memset(&vp, 0, sizeof(vp));
Tony Barbour194bf282015-07-10 15:29:03 -06001568 vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
Tony Barbour72304ef2015-04-16 15:59:00 -06001569 vp.viewportCount = 1;
Piers Daniellba839d12015-09-29 13:01:09 -06001570 dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_VIEWPORT;
1571 vp.scissorCount = 1;
1572 dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_SCISSOR;
Tony Barbour29645d02015-01-16 14:27:35 -07001573
1574 memset(&ds, 0, sizeof(ds));
Tony Barbour194bf282015-07-10 15:29:03 -06001575 ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001576 ds.depthTestEnable = VK_TRUE;
1577 ds.depthWriteEnable = VK_TRUE;
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001578 ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
Cody Northrop5e4125d2015-08-26 10:01:32 -06001579 ds.depthBoundsTestEnable = VK_FALSE;
Chia-I Wuf051d262015-10-27 19:25:11 +08001580 ds.back.failOp = VK_STENCIL_OP_KEEP;
1581 ds.back.passOp = VK_STENCIL_OP_KEEP;
1582 ds.back.compareOp = VK_COMPARE_OP_ALWAYS;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001583 ds.stencilTestEnable = VK_FALSE;
Tony Barbour29645d02015-01-16 14:27:35 -07001584 ds.front = ds.back;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001585
Tony Barbour29645d02015-01-16 14:27:35 -07001586 memset(&ms, 0, sizeof(ms));
Tony Barbour194bf282015-07-10 15:29:03 -06001587 ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
Cody Northrop011546b2015-08-04 14:34:54 -06001588 ms.pSampleMask = NULL;
Chia-I Wu3ede9462015-10-31 00:31:16 +08001589 ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001590
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001591 // Two stages: vs and fs
1592 pipeline.stageCount = 2;
1593 VkPipelineShaderStageCreateInfo shaderStages[2];
1594 memset(&shaderStages, 0, 2 * sizeof(VkPipelineShaderStageCreateInfo));
1595
1596 shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
Chia-I Wu46176f12015-10-31 00:31:16 +08001597 shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
1598 shaderStages[0].module = demo_prepare_vs(demo);
1599 shaderStages[0].pName = "main";
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001600
1601 shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
Chia-I Wu46176f12015-10-31 00:31:16 +08001602 shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
1603 shaderStages[1].module = demo_prepare_fs(demo);
1604 shaderStages[1].pName = "main";
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001605
Jon Ashburnc4ab7af2015-07-09 15:02:25 -06001606 memset(&pipelineCache, 0, sizeof(pipelineCache));
1607 pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001608
Chia-I Wu63636062015-10-26 21:10:41 +08001609 err = vkCreatePipelineCache(demo->device, &pipelineCache, NULL, &demo->pipelineCache);
Jon Ashburnc4ab7af2015-07-09 15:02:25 -06001610 assert(!err);
Tony Barbour194bf282015-07-10 15:29:03 -06001611
Jason Ekstrand515b7ae2015-10-15 17:15:25 -07001612 pipeline.pVertexInputState = &vi;
Tony Barbour194bf282015-07-10 15:29:03 -06001613 pipeline.pInputAssemblyState = &ia;
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001614 pipeline.pRasterizationState = &rs;
Tony Barbour194bf282015-07-10 15:29:03 -06001615 pipeline.pColorBlendState = &cb;
1616 pipeline.pMultisampleState = &ms;
1617 pipeline.pViewportState = &vp;
1618 pipeline.pDepthStencilState = &ds;
1619 pipeline.pStages = shaderStages;
Tony Barbour13ed3222015-08-06 14:32:54 -06001620 pipeline.renderPass = demo->render_pass;
Piers Daniellba839d12015-09-29 13:01:09 -06001621 pipeline.pDynamicState = &dynamicState;
Tony Barbour194bf282015-07-10 15:29:03 -06001622
Courtney Goeltzenleuchterd311fd02015-08-13 16:55:04 -06001623 pipeline.renderPass = demo->render_pass;
1624
Chia-I Wu63636062015-10-26 21:10:41 +08001625 err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache,
1626 1, &pipeline, NULL, &demo->pipeline);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001627 assert(!err);
1628
Chia-I Wu63636062015-10-26 21:10:41 +08001629 vkDestroyShaderModule(demo->device, demo->frag_shader_module, NULL);
1630 vkDestroyShaderModule(demo->device, demo->vert_shader_module, NULL);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001631}
1632
Chia-I Wu63ea9262015-03-26 13:14:16 +08001633static void demo_prepare_descriptor_pool(struct demo *demo)
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001634{
Chia-I Wuf051d262015-10-27 19:25:11 +08001635 const VkDescriptorPoolSize type_counts[2] = {
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001636 [0] = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001637 .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
Chia-I Wu3dfc1342015-10-26 20:48:51 +08001638 .descriptorCount = 1,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001639 },
1640 [1] = {
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -06001641 .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
Chia-I Wu3dfc1342015-10-26 20:48:51 +08001642 .descriptorCount = DEMO_TEXTURE_COUNT,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001643 },
1644 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001645 const VkDescriptorPoolCreateInfo descriptor_pool = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001646 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001647 .pNext = NULL,
Courtney Goeltzenleuchtercf92aa42015-09-16 16:12:45 -06001648 .maxSets = 1,
Chia-I Wuf051d262015-10-27 19:25:11 +08001649 .poolSizeCount = 2,
1650 .pPoolSizes = type_counts,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001651 };
Tony Barbourfdc2d352015-04-22 09:02:32 -06001652 VkResult U_ASSERT_ONLY err;
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001653
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001654 err = vkCreateDescriptorPool(demo->device,
Chia-I Wu63636062015-10-26 21:10:41 +08001655 &descriptor_pool, NULL, &demo->desc_pool);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001656 assert(!err);
1657}
1658
1659static void demo_prepare_descriptor_set(struct demo *demo)
1660{
Courtney Goeltzenleuchterc3ad65e2015-10-23 13:38:14 -06001661 VkDescriptorImageInfo tex_descs[DEMO_TEXTURE_COUNT];
Chia-I Wuae721ba2015-05-25 16:27:55 +08001662 VkWriteDescriptorSet writes[2];
Tony Barbourfdc2d352015-04-22 09:02:32 -06001663 VkResult U_ASSERT_ONLY err;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001664 uint32_t i;
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001665
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001666 VkDescriptorSetAllocateInfo alloc_info = {
Chia-I Wuf48700b2015-11-10 16:21:09 +08001667 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
Courtney Goeltzenleuchter014ded82015-10-23 14:21:05 -06001668 .pNext = NULL,
1669 .descriptorPool = demo->desc_pool,
Jon Ashburn0bec67e2016-01-11 13:12:43 -07001670 .descriptorSetCount = 1,
Courtney Goeltzenleuchter014ded82015-10-23 14:21:05 -06001671 .pSetLayouts = &demo->desc_layout
1672 };
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001673 err = vkAllocateDescriptorSets(demo->device, &alloc_info, &demo->desc_set);
Cody Northrop15954692015-08-03 12:47:29 -06001674 assert(!err);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001675
Chia-I Wuae721ba2015-05-25 16:27:55 +08001676 memset(&tex_descs, 0, sizeof(tex_descs));
1677 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
Courtney Goeltzenleuchterc3ad65e2015-10-23 13:38:14 -06001678 tex_descs[i].sampler = demo->textures[i].sampler;
1679 tex_descs[i].imageView = demo->textures[i].view;
1680 tex_descs[i].imageLayout = VK_IMAGE_LAYOUT_GENERAL;
Chia-I Wuae721ba2015-05-25 16:27:55 +08001681 }
1682
1683 memset(&writes, 0, sizeof(writes));
1684
1685 writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001686 writes[0].dstSet = demo->desc_set;
Chia-I Wu3dfc1342015-10-26 20:48:51 +08001687 writes[0].descriptorCount = 1;
Chia-I Wuae721ba2015-05-25 16:27:55 +08001688 writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
Courtney Goeltzenleuchterc3ad65e2015-10-23 13:38:14 -06001689 writes[0].pBufferInfo = &demo->uniform_data.buffer_info;
Chia-I Wuae721ba2015-05-25 16:27:55 +08001690
1691 writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001692 writes[1].dstSet = demo->desc_set;
1693 writes[1].dstBinding = 1;
Chia-I Wu3dfc1342015-10-26 20:48:51 +08001694 writes[1].descriptorCount = DEMO_TEXTURE_COUNT;
Chia-I Wuae721ba2015-05-25 16:27:55 +08001695 writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
Courtney Goeltzenleuchterc3ad65e2015-10-23 13:38:14 -06001696 writes[1].pImageInfo = tex_descs;
Chia-I Wuae721ba2015-05-25 16:27:55 +08001697
Mark Lobodzinskie4c92a62015-09-07 13:59:43 -06001698 vkUpdateDescriptorSets(demo->device, 2, writes, 0, NULL);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001699}
1700
Chia-I Wuf973e322015-07-08 13:34:24 +08001701static void demo_prepare_framebuffers(struct demo *demo)
1702{
Courtney Goeltzenleuchter41866db2015-09-01 17:30:39 -06001703 VkImageView attachments[2];
Cody Northrop2e11cad2015-08-04 10:47:08 -06001704 attachments[1] = demo->depth.view;
1705
Chia-I Wuf973e322015-07-08 13:34:24 +08001706 const VkFramebufferCreateInfo fb_info = {
1707 .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
1708 .pNext = NULL,
Chia-I Wua74c5b22015-07-07 11:50:03 +08001709 .renderPass = demo->render_pass,
1710 .attachmentCount = 2,
1711 .pAttachments = attachments,
Chia-I Wuf973e322015-07-08 13:34:24 +08001712 .width = demo->width,
1713 .height = demo->height,
1714 .layers = 1,
1715 };
1716 VkResult U_ASSERT_ONLY err;
1717 uint32_t i;
1718
Tony Barbourd8e504f2015-10-08 14:26:24 -06001719 demo->framebuffers = (VkFramebuffer *)malloc(demo->swapchainImageCount * sizeof(VkFramebuffer));
1720 assert(demo->framebuffers);
1721
1722 for (i = 0; i < demo->swapchainImageCount; i++) {
Cody Northrop2e11cad2015-08-04 10:47:08 -06001723 attachments[0] = demo->buffers[i].view;
Chia-I Wu63636062015-10-26 21:10:41 +08001724 err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->framebuffers[i]);
Chia-I Wuf973e322015-07-08 13:34:24 +08001725 assert(!err);
1726 }
1727}
1728
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001729static void demo_prepare(struct demo *demo)
1730{
Cody Northrop91e221b2015-07-09 18:08:32 -06001731 VkResult U_ASSERT_ONLY err;
1732
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001733 const VkCommandPoolCreateInfo cmd_pool_info = {
1734 .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
Cody Northrop91e221b2015-07-09 18:08:32 -06001735 .pNext = NULL,
1736 .queueFamilyIndex = demo->graphics_queue_node_index,
1737 .flags = 0,
1738 };
Chia-I Wu63636062015-10-26 21:10:41 +08001739 err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool);
Cody Northrop91e221b2015-07-09 18:08:32 -06001740 assert(!err);
1741
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001742 const VkCommandBufferAllocateInfo cmd = {
Chia-I Wuf48700b2015-11-10 16:21:09 +08001743 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001744 .pNext = NULL,
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001745 .commandPool = demo->cmd_pool,
1746 .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
Jon Ashburn0bec67e2016-01-11 13:12:43 -07001747 .commandBufferCount = 1,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001748 };
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001749
1750 demo_prepare_buffers(demo);
1751 demo_prepare_depth(demo);
1752 demo_prepare_textures(demo);
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001753 demo_prepare_cube_data_buffer(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001754
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001755 demo_prepare_descriptor_layout(demo);
Chia-I Wuf973e322015-07-08 13:34:24 +08001756 demo_prepare_render_pass(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001757 demo_prepare_pipeline(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001758
Ian Elliotta0781972015-08-21 15:09:33 -06001759 for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
Chia-I Wua8fe78a2015-10-27 18:04:07 +08001760 err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->buffers[i].cmd);
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001761 assert(!err);
1762 }
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001763
Chia-I Wu63ea9262015-03-26 13:14:16 +08001764 demo_prepare_descriptor_pool(demo);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001765 demo_prepare_descriptor_set(demo);
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001766
Chia-I Wuf973e322015-07-08 13:34:24 +08001767 demo_prepare_framebuffers(demo);
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001768
Ian Elliotta0781972015-08-21 15:09:33 -06001769 for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001770 demo->current_buffer = i;
1771 demo_draw_build_cmd(demo, demo->buffers[i].cmd);
1772 }
1773
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001774 /*
1775 * Prepare functions above may generate pipeline commands
1776 * that need to be flushed before beginning the render loop.
1777 */
1778 demo_flush_init_cmd(demo);
1779
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001780 demo->current_buffer = 0;
Mike Stroyanbb60b382015-10-28 09:46:57 -06001781 demo->prepared = true;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001782}
1783
David Pinedo2bb7c932015-06-18 17:03:14 -06001784static void demo_cleanup(struct demo *demo)
1785{
1786 uint32_t i;
1787
1788 demo->prepared = false;
1789
Tony Barbourd8e504f2015-10-08 14:26:24 -06001790 for (i = 0; i < demo->swapchainImageCount; i++) {
Chia-I Wu63636062015-10-26 21:10:41 +08001791 vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
Tony Barbour155cce82015-07-03 10:33:54 -06001792 }
Tony Barbourd8e504f2015-10-08 14:26:24 -06001793 free(demo->framebuffers);
Chia-I Wu63636062015-10-26 21:10:41 +08001794 vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
Chia-I Wuf973e322015-07-08 13:34:24 +08001795
Chia-I Wu63636062015-10-26 21:10:41 +08001796 vkDestroyPipeline(demo->device, demo->pipeline, NULL);
1797 vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
1798 vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
1799 vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
1800 vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
David Pinedo2bb7c932015-06-18 17:03:14 -06001801
1802 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
Chia-I Wu63636062015-10-26 21:10:41 +08001803 vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
1804 vkDestroyImage(demo->device, demo->textures[i].image, NULL);
1805 vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
1806 vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
David Pinedo2bb7c932015-06-18 17:03:14 -06001807 }
Ian Elliottb08e0d92015-11-20 11:55:46 -07001808 demo->fpDestroySwapchainKHR(demo->device, demo->swapchain, NULL);
David Pinedo2bb7c932015-06-18 17:03:14 -06001809
Chia-I Wu63636062015-10-26 21:10:41 +08001810 vkDestroyImageView(demo->device, demo->depth.view, NULL);
1811 vkDestroyImage(demo->device, demo->depth.image, NULL);
1812 vkFreeMemory(demo->device, demo->depth.mem, NULL);
David Pinedo2bb7c932015-06-18 17:03:14 -06001813
Chia-I Wu63636062015-10-26 21:10:41 +08001814 vkDestroyBuffer(demo->device, demo->uniform_data.buf, NULL);
1815 vkFreeMemory(demo->device, demo->uniform_data.mem, NULL);
David Pinedo2bb7c932015-06-18 17:03:14 -06001816
Ian Elliotta0781972015-08-21 15:09:33 -06001817 for (i = 0; i < demo->swapchainImageCount; i++) {
Chia-I Wu63636062015-10-26 21:10:41 +08001818 vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
Courtney Goeltzenleuchter014ded82015-10-23 14:21:05 -06001819 vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->buffers[i].cmd);
David Pinedo2bb7c932015-06-18 17:03:14 -06001820 }
Ian Elliottaaae5352015-07-06 14:27:58 -06001821 free(demo->buffers);
David Pinedo2bb7c932015-06-18 17:03:14 -06001822
Courtney Goeltzenleuchter874eb8d2015-09-24 17:16:48 -06001823 free(demo->queue_props);
1824
Chia-I Wu63636062015-10-26 21:10:41 +08001825 vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
1826 vkDestroyDevice(demo->device, NULL);
Tony Barbourd70b42c2015-06-30 14:14:19 -06001827 if (demo->validate) {
Courtney Goeltzenleuchter2dafae42015-11-30 12:13:14 -07001828 demo->DestroyDebugReportCallback(demo->inst, demo->msg_callback, NULL);
Tony Barbourd70b42c2015-06-30 14:14:19 -06001829 }
Ian Elliottb08e0d92015-11-20 11:55:46 -07001830 vkDestroySurfaceKHR(demo->inst, demo->surface, NULL);
Chia-I Wu63636062015-10-26 21:10:41 +08001831 vkDestroyInstance(demo->inst, NULL);
David Pinedo2bb7c932015-06-18 17:03:14 -06001832
1833#ifndef _WIN32
1834 xcb_destroy_window(demo->connection, demo->window);
1835 xcb_disconnect(demo->connection);
Courtney Goeltzenleuchter874eb8d2015-09-24 17:16:48 -06001836 free(demo->atom_wm_delete_window);
David Pinedo2bb7c932015-06-18 17:03:14 -06001837#endif // _WIN32
1838}
1839
Ian Elliottcf074d32015-10-16 18:02:43 -06001840static void demo_resize(struct demo *demo)
1841{
1842 uint32_t i;
1843
Mike Stroyanbb60b382015-10-28 09:46:57 -06001844 // Don't react to resize until after first initialization.
1845 if (!demo->prepared) {
1846 return;
1847 }
Ian Elliottcf074d32015-10-16 18:02:43 -06001848 // In order to properly resize the window, we must re-create the swapchain
1849 // AND redo the command buffers, etc.
1850 //
1851 // First, perform part of the demo_cleanup() function:
1852 demo->prepared = false;
1853
1854 for (i = 0; i < demo->swapchainImageCount; i++) {
Chia-I Wu63636062015-10-26 21:10:41 +08001855 vkDestroyFramebuffer(demo->device, demo->framebuffers[i], NULL);
Ian Elliottcf074d32015-10-16 18:02:43 -06001856 }
1857 free(demo->framebuffers);
Chia-I Wu63636062015-10-26 21:10:41 +08001858 vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
Ian Elliottcf074d32015-10-16 18:02:43 -06001859
Chia-I Wu63636062015-10-26 21:10:41 +08001860 vkDestroyPipeline(demo->device, demo->pipeline, NULL);
1861 vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
1862 vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
1863 vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
1864 vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
Ian Elliottcf074d32015-10-16 18:02:43 -06001865
1866 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
Chia-I Wu63636062015-10-26 21:10:41 +08001867 vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
1868 vkDestroyImage(demo->device, demo->textures[i].image, NULL);
1869 vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
1870 vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
Ian Elliottcf074d32015-10-16 18:02:43 -06001871 }
Ian Elliottcf074d32015-10-16 18:02:43 -06001872
Chia-I Wu63636062015-10-26 21:10:41 +08001873 vkDestroyImageView(demo->device, demo->depth.view, NULL);
1874 vkDestroyImage(demo->device, demo->depth.image, NULL);
1875 vkFreeMemory(demo->device, demo->depth.mem, NULL);
Ian Elliottcf074d32015-10-16 18:02:43 -06001876
Chia-I Wu63636062015-10-26 21:10:41 +08001877 vkDestroyBuffer(demo->device, demo->uniform_data.buf, NULL);
1878 vkFreeMemory(demo->device, demo->uniform_data.mem, NULL);
Ian Elliottcf074d32015-10-16 18:02:43 -06001879
1880 for (i = 0; i < demo->swapchainImageCount; i++) {
Chia-I Wu63636062015-10-26 21:10:41 +08001881 vkDestroyImageView(demo->device, demo->buffers[i].view, NULL);
Ian Elliott55234c42015-10-27 11:06:33 -06001882 vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->buffers[i].cmd);
Ian Elliottcf074d32015-10-16 18:02:43 -06001883 }
Chia-I Wu63636062015-10-26 21:10:41 +08001884 vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
Ian Elliottcf074d32015-10-16 18:02:43 -06001885 free(demo->buffers);
1886
Ian Elliottcf074d32015-10-16 18:02:43 -06001887 // Second, re-perform the demo_prepare() function, which will re-create the
1888 // swapchain:
1889 demo_prepare(demo);
1890}
1891
David Pinedo2bb7c932015-06-18 17:03:14 -06001892// On MS-Windows, make this a global, so it's available to WndProc()
1893struct demo demo;
1894
Ian Elliott639ca472015-04-16 15:23:05 -06001895#ifdef _WIN32
1896static void demo_run(struct demo *demo)
1897{
Courtney Goeltzenleuchterb7e22702015-04-27 14:56:34 -06001898 if (!demo->prepared)
1899 return;
Ian Elliott639ca472015-04-16 15:23:05 -06001900 // Wait for work to finish before updating MVP.
1901 vkDeviceWaitIdle(demo->device);
1902 demo_update_data_buffer(demo);
1903
1904 demo_draw(demo);
1905
1906 // Wait for work to finish before updating MVP.
1907 vkDeviceWaitIdle(demo->device);
Ian Elliott639ca472015-04-16 15:23:05 -06001908
David Pinedo2bb7c932015-06-18 17:03:14 -06001909 demo->curFrame++;
1910
1911 if (demo->frameCount != INT_MAX && demo->curFrame == demo->frameCount)
1912 {
1913 demo->quit=true;
1914 demo_cleanup(demo);
1915 ExitProcess(0);
1916 }
1917
1918}
Ian Elliott639ca472015-04-16 15:23:05 -06001919
1920// MS-Windows event handling function:
1921LRESULT CALLBACK WndProc(HWND hWnd,
1922 UINT uMsg,
1923 WPARAM wParam,
1924 LPARAM lParam)
1925{
Ian Elliott639ca472015-04-16 15:23:05 -06001926 switch(uMsg)
1927 {
Ian Elliottaaae5352015-07-06 14:27:58 -06001928 case WM_CLOSE:
Ian Elliott639ca472015-04-16 15:23:05 -06001929 PostQuitMessage(0);
Tony Barbour3dddd5d2015-04-29 16:19:20 -06001930 break;
Ian Elliottaaae5352015-07-06 14:27:58 -06001931 case WM_PAINT:
Ian Elliott639ca472015-04-16 15:23:05 -06001932 demo_run(&demo);
Tony Barbourc8a59892015-10-20 12:49:46 -06001933 break;
Ian Elliott5ef45e92015-10-21 15:14:07 -06001934 case WM_SIZE:
Mike Stroyanbb60b382015-10-28 09:46:57 -06001935 demo.width = lParam & 0xffff;
1936 demo.height = lParam & 0xffff0000 >> 16;
Ian Elliott5ef45e92015-10-21 15:14:07 -06001937 demo_resize(&demo);
1938 break;
Ian Elliott639ca472015-04-16 15:23:05 -06001939 default:
1940 break;
1941 }
1942 return (DefWindowProc(hWnd, uMsg, wParam, lParam));
1943}
1944
1945static void demo_create_window(struct demo *demo)
1946{
1947 WNDCLASSEX win_class;
1948
1949 // Initialize the window class structure:
1950 win_class.cbSize = sizeof(WNDCLASSEX);
1951 win_class.style = CS_HREDRAW | CS_VREDRAW;
1952 win_class.lpfnWndProc = WndProc;
1953 win_class.cbClsExtra = 0;
1954 win_class.cbWndExtra = 0;
1955 win_class.hInstance = demo->connection; // hInstance
1956 win_class.hIcon = LoadIcon(NULL, IDI_APPLICATION);
1957 win_class.hCursor = LoadCursor(NULL, IDC_ARROW);
1958 win_class.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
1959 win_class.lpszMenuName = NULL;
1960 win_class.lpszClassName = demo->name;
1961 win_class.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
1962 // Register window class:
1963 if (!RegisterClassEx(&win_class)) {
1964 // It didn't work, so try to give a useful error:
1965 printf("Unexpected error trying to start the application!\n");
1966 fflush(stdout);
1967 exit(1);
1968 }
1969 // Create window with the registered class:
Mike Stroyanb46779e2015-06-15 14:20:13 -06001970 RECT wr = { 0, 0, demo->width, demo->height };
1971 AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
Ian Elliott639ca472015-04-16 15:23:05 -06001972 demo->window = CreateWindowEx(0,
1973 demo->name, // class name
1974 demo->name, // app name
1975 WS_OVERLAPPEDWINDOW | // window style
1976 WS_VISIBLE |
1977 WS_SYSMENU,
1978 100,100, // x/y coords
Mike Stroyanb46779e2015-06-15 14:20:13 -06001979 wr.right-wr.left, // width
1980 wr.bottom-wr.top, // height
Ian Elliott639ca472015-04-16 15:23:05 -06001981 NULL, // handle to parent
1982 NULL, // handle to menu
1983 demo->connection, // hInstance
1984 NULL); // no extra parameters
1985 if (!demo->window) {
1986 // It didn't work, so try to give a useful error:
1987 printf("Cannot create a window in which to draw!\n");
1988 fflush(stdout);
1989 exit(1);
1990 }
1991}
1992#else // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001993static void demo_handle_event(struct demo *demo,
1994 const xcb_generic_event_t *event)
1995{
Piers Daniell735ee532015-02-23 16:23:13 -07001996 uint8_t event_code = event->response_type & 0x7f;
Courtney Goeltzenleuchter98cb2cb2014-11-06 14:27:52 -07001997 switch (event_code) {
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001998 case XCB_EXPOSE:
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07001999 // TODO: Resize window
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002000 break;
Courtney Goeltzenleuchter98cb2cb2014-11-06 14:27:52 -07002001 case XCB_CLIENT_MESSAGE:
2002 if((*(xcb_client_message_event_t*)event).data.data32[0] ==
2003 (*demo->atom_wm_delete_window).atom) {
2004 demo->quit = true;
2005 }
2006 break;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002007 case XCB_KEY_RELEASE:
2008 {
2009 const xcb_key_release_event_t *key =
2010 (const xcb_key_release_event_t *) event;
2011
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06002012 switch (key->detail) {
2013 case 0x9: // Escape
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002014 demo->quit = true;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06002015 break;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06002016 case 0x71: // left arrow key
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002017 demo->spin_angle += demo->spin_increment;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06002018 break;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06002019 case 0x72: // right arrow key
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002020 demo->spin_angle -= demo->spin_increment;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06002021 break;
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002022 case 0x41:
2023 demo->pause = !demo->pause;
Piers Daniell735ee532015-02-23 16:23:13 -07002024 break;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06002025 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002026 }
2027 break;
Ian Elliottcf074d32015-10-16 18:02:43 -06002028 case XCB_CONFIGURE_NOTIFY:
2029 {
2030 const xcb_configure_notify_event_t *cfg =
2031 (const xcb_configure_notify_event_t *) event;
2032 if ((demo->width != cfg->width) || (demo->height != cfg->height)) {
2033 demo_resize(demo);
2034 }
2035 }
2036 break;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002037 default:
2038 break;
2039 }
2040}
2041
2042static void demo_run(struct demo *demo)
2043{
2044 xcb_flush(demo->connection);
2045
2046 while (!demo->quit) {
2047 xcb_generic_event_t *event;
2048
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07002049 if (demo->pause) {
2050 event = xcb_wait_for_event(demo->connection);
2051 } else {
2052 event = xcb_poll_for_event(demo->connection);
2053 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002054 if (event) {
2055 demo_handle_event(demo, event);
2056 free(event);
Courtney Goeltzenleuchter98085552014-11-10 11:13:13 -07002057 }
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07002058
2059 // Wait for work to finish before updating MVP.
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002060 vkDeviceWaitIdle(demo->device);
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07002061 demo_update_data_buffer(demo);
2062
Courtney Goeltzenleuchter98085552014-11-10 11:13:13 -07002063 demo_draw(demo);
Courtney Goeltzenleuchter1454f3c2014-11-18 11:28:09 -07002064
Courtney Goeltzenleuchter98085552014-11-10 11:13:13 -07002065 // Wait for work to finish before updating MVP.
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002066 vkDeviceWaitIdle(demo->device);
David Pinedo2bb7c932015-06-18 17:03:14 -06002067 demo->curFrame++;
Tony Barbour1a86d032015-09-21 15:17:33 -06002068 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount)
David Pinedo2bb7c932015-06-18 17:03:14 -06002069 demo->quit = true;
2070
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002071 }
2072}
2073
2074static void demo_create_window(struct demo *demo)
2075{
2076 uint32_t value_mask, value_list[32];
2077
2078 demo->window = xcb_generate_id(demo->connection);
2079
2080 value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
2081 value_list[0] = demo->screen->black_pixel;
2082 value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |
Ian Elliottcf074d32015-10-16 18:02:43 -06002083 XCB_EVENT_MASK_EXPOSURE |
2084 XCB_EVENT_MASK_STRUCTURE_NOTIFY;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002085
2086 xcb_create_window(demo->connection,
2087 XCB_COPY_FROM_PARENT,
2088 demo->window, demo->screen->root,
2089 0, 0, demo->width, demo->height, 0,
2090 XCB_WINDOW_CLASS_INPUT_OUTPUT,
2091 demo->screen->root_visual,
2092 value_mask, value_list);
2093
Courtney Goeltzenleuchter98cb2cb2014-11-06 14:27:52 -07002094 /* Magic code that will send notification when window is destroyed */
2095 xcb_intern_atom_cookie_t cookie = xcb_intern_atom(demo->connection, 1, 12,
2096 "WM_PROTOCOLS");
2097 xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(demo->connection, cookie, 0);
2098
2099 xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(demo->connection, 0, 16, "WM_DELETE_WINDOW");
2100 demo->atom_wm_delete_window = xcb_intern_atom_reply(demo->connection, cookie2, 0);
2101
2102 xcb_change_property(demo->connection, XCB_PROP_MODE_REPLACE,
2103 demo->window, (*reply).atom, 4, 32, 1,
2104 &(*demo->atom_wm_delete_window).atom);
2105 free(reply);
2106
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002107 xcb_map_window(demo->connection, demo->window);
David Pinedo2bb7c932015-06-18 17:03:14 -06002108
2109 // Force the x/y coordinates to 100,100 results are identical in consecutive runs
2110 const uint32_t coords[] = {100, 100};
2111 xcb_configure_window(demo->connection, demo->window,
2112 XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, coords);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002113}
Ian Elliott639ca472015-04-16 15:23:05 -06002114#endif // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002115
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002116/*
2117 * Return 1 (true) if all layer names specified in check_names
2118 * can be found in given layer properties.
2119 */
Courtney Goeltzenleuchterc88ce512015-07-09 11:44:38 -06002120static VkBool32 demo_check_layers(uint32_t check_count, char **check_names,
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002121 uint32_t layer_count, VkLayerProperties *layers)
2122{
2123 for (uint32_t i = 0; i < check_count; i++) {
Courtney Goeltzenleuchterc88ce512015-07-09 11:44:38 -06002124 VkBool32 found = 0;
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002125 for (uint32_t j = 0; j < layer_count; j++) {
2126 if (!strcmp(check_names[i], layers[j].layerName)) {
2127 found = 1;
2128 }
2129 }
2130 if (!found) {
2131 fprintf(stderr, "Cannot find layer: %s\n", check_names[i]);
2132 return 0;
2133 }
2134 }
2135 return 1;
2136}
2137
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002138static void demo_init_vk(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002139{
Tobin Ehlis99239dc2015-04-16 18:04:57 -06002140 VkResult err;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002141 char *extension_names[64];
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002142 VkExtensionProperties *instance_extensions;
Tobin Ehlis8a724d82015-09-07 15:16:39 -06002143 VkPhysicalDevice *physical_devices;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002144 VkLayerProperties *instance_layers;
2145 VkLayerProperties *device_layers;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002146 uint32_t instance_extension_count = 0;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002147 uint32_t instance_layer_count = 0;
Tony Barbourda2bad52016-01-22 14:36:40 -07002148 uint32_t device_validation_layer_count = 0;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002149 uint32_t enabled_extension_count = 0;
2150 uint32_t enabled_layer_count = 0;
2151
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002152 char *instance_validation_layers[] = {
Mark Lobodzinski7ce1eb52015-12-30 08:16:12 -07002153 "VK_LAYER_LUNARG_threading",
2154 "VK_LAYER_LUNARG_mem_tracker",
2155 "VK_LAYER_LUNARG_object_tracker",
2156 "VK_LAYER_LUNARG_draw_state",
2157 "VK_LAYER_LUNARG_param_checker",
2158 "VK_LAYER_LUNARG_swapchain",
2159 "VK_LAYER_LUNARG_device_limits",
2160 "VK_LAYER_LUNARG_image",
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002161 };
2162
Tony Barbourda2bad52016-01-22 14:36:40 -07002163 demo->device_validation_layers[0] = "VK_LAYER_LUNARG_threading";
2164 demo->device_validation_layers[1] = "VK_LAYER_LUNARG_mem_tracker";
2165 demo->device_validation_layers[2] = "VK_LAYER_LUNARG_object_tracker",
2166 demo->device_validation_layers[3] = "VK_LAYER_LUNARG_draw_state",
2167 demo->device_validation_layers[4] = "VK_LAYER_LUNARG_param_checker",
2168 demo->device_validation_layers[5] = "VK_LAYER_LUNARG_swapchain",
2169 demo->device_validation_layers[6] = "VK_LAYER_LUNARG_device_limits",
2170 demo->device_validation_layers[7] = "VK_LAYER_LUNARG_image",
2171 device_validation_layer_count = 8;
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002172
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002173 /* Look for validation layers */
Courtney Goeltzenleuchterc88ce512015-07-09 11:44:38 -06002174 VkBool32 validation_found = 0;
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002175 err = vkEnumerateInstanceLayerProperties(&instance_layer_count, NULL);
Tobin Ehlis99239dc2015-04-16 18:04:57 -06002176 assert(!err);
2177
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002178 instance_layers = malloc(sizeof(VkLayerProperties) * instance_layer_count);
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002179 err = vkEnumerateInstanceLayerProperties(&instance_layer_count, instance_layers);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002180 assert(!err);
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002181
2182 if (demo->validate) {
2183 validation_found = demo_check_layers(ARRAY_SIZE(instance_validation_layers), instance_validation_layers,
2184 instance_layer_count, instance_layers);
2185 if (!validation_found) {
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002186 ERR_EXIT("vkEnumerateInstanceLayerProperties failed to find"
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002187 "required validation layer.\n\n"
2188 "Please look at the Getting Started guide for additional "
2189 "information.\n",
2190 "vkCreateInstance Failure");
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002191 }
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002192 enabled_layer_count = ARRAY_SIZE(instance_validation_layers);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002193 }
2194
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002195 err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, NULL);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002196 assert(!err);
2197
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002198 VkBool32 surfaceExtFound = 0;
2199 VkBool32 platformSurfaceExtFound = 0;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002200 memset(extension_names, 0, sizeof(extension_names));
2201 instance_extensions = malloc(sizeof(VkExtensionProperties) * instance_extension_count);
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002202 err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, instance_extensions);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002203 assert(!err);
2204 for (uint32_t i = 0; i < instance_extension_count; i++) {
Ian Elliottf4a4e442015-11-17 17:29:40 -07002205 if (!strcmp(VK_KHR_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002206 surfaceExtFound = 1;
Ian Elliottf4a4e442015-11-17 17:29:40 -07002207 extension_names[enabled_extension_count++] = VK_KHR_SURFACE_EXTENSION_NAME;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002208 }
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002209#ifdef _WIN32
2210 if (!strcmp(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2211 platformSurfaceExtFound = 1;
2212 extension_names[enabled_extension_count++] = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
2213 }
2214#else // _WIN32
2215 if (!strcmp(VK_KHR_XCB_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2216 platformSurfaceExtFound = 1;
2217 extension_names[enabled_extension_count++] = VK_KHR_XCB_SURFACE_EXTENSION_NAME;
2218 }
2219#endif // _WIN32
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -07002220 if (!strcmp(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, instance_extensions[i].extensionName)) {
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002221 if (demo->validate) {
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -07002222 extension_names[enabled_extension_count++] = VK_EXT_DEBUG_REPORT_EXTENSION_NAME;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002223 }
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002224 }
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002225 assert(enabled_extension_count < 64);
Tobin Ehlis99239dc2015-04-16 18:04:57 -06002226 }
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002227 if (!surfaceExtFound) {
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002228 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the "
Ian Elliottf4a4e442015-11-17 17:29:40 -07002229 VK_KHR_SURFACE_EXTENSION_NAME" extension.\n\nDo you have a compatible "
Ian Elliott65152912015-04-28 13:22:33 -06002230 "Vulkan installable client driver (ICD) installed?\nPlease "
2231 "look at the Getting Started guide for additional "
2232 "information.\n",
2233 "vkCreateInstance Failure");
2234 }
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002235 if (!platformSurfaceExtFound) {
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002236#ifdef _WIN32
Mark Lobodzinski6f7a6032015-11-24 12:04:15 -07002237 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the "
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002238 VK_KHR_WIN32_SURFACE_EXTENSION_NAME" extension.\n\nDo you have a compatible "
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002239 "Vulkan installable client driver (ICD) installed?\nPlease "
2240 "look at the Getting Started guide for additional "
2241 "information.\n",
2242 "vkCreateInstance Failure");
Mark Lobodzinski6f7a6032015-11-24 12:04:15 -07002243#else // _WIN32
2244 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the "
2245 VK_KHR_XCB_SURFACE_EXTENSION_NAME" extension.\n\nDo you have a compatible "
2246 "Vulkan installable client driver (ICD) installed?\nPlease "
2247 "look at the Getting Started guide for additional "
2248 "information.\n",
2249 "vkCreateInstance Failure");
2250#endif // _WIN32
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002251 }
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06002252 const VkApplicationInfo app = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002253 .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002254 .pNext = NULL,
Chia-I Wua8fe78a2015-10-27 18:04:07 +08002255 .pApplicationName = APP_SHORT_NAME,
2256 .applicationVersion = 0,
Ian Elliott44e33f72015-04-28 10:52:52 -06002257 .pEngineName = APP_SHORT_NAME,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002258 .engineVersion = 0,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002259 .apiVersion = VK_API_VERSION,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002260 };
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002261 VkInstanceCreateInfo inst_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002262 .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
Jon Ashburnab46b362015-04-04 14:52:07 -06002263 .pNext = NULL,
Chia-I Wua8fe78a2015-10-27 18:04:07 +08002264 .pApplicationInfo = &app,
Jon Ashburn0bec67e2016-01-11 13:12:43 -07002265 .enabledLayerCount = enabled_layer_count,
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002266 .ppEnabledLayerNames = (const char *const*) ((demo->validate) ? instance_validation_layers : NULL),
Jon Ashburn0bec67e2016-01-11 13:12:43 -07002267 .enabledExtensionCount = enabled_extension_count,
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002268 .ppEnabledExtensionNames = (const char *const*) extension_names,
Jon Ashburnab46b362015-04-04 14:52:07 -06002269 };
Ian Elliott097d9f32015-04-28 11:35:02 -06002270
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06002271 uint32_t gpu_count;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002272
Chia-I Wu63636062015-10-26 21:10:41 +08002273 err = vkCreateInstance(&inst_info, NULL, &demo->inst);
Ian Elliott07264132015-04-28 11:35:02 -06002274 if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
2275 ERR_EXIT("Cannot find a compatible Vulkan installable client driver "
Ian Elliott65152912015-04-28 13:22:33 -06002276 "(ICD).\n\nPlease look at the Getting Started guide for "
Ian Elliott07264132015-04-28 11:35:02 -06002277 "additional information.\n",
2278 "vkCreateInstance Failure");
Courtney Goeltzenleuchter1e47e4b2015-09-14 18:01:17 -06002279 } else if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002280 ERR_EXIT("Cannot find a specified extension library"
2281 ".\nMake sure your layers path is set appropriately\n",
2282 "vkCreateInstance Failure");
Ian Elliott07264132015-04-28 11:35:02 -06002283 } else if (err) {
Ian Elliott65152912015-04-28 13:22:33 -06002284 ERR_EXIT("vkCreateInstance failed.\n\nDo you have a compatible Vulkan "
2285 "installable client driver (ICD) installed?\nPlease look at "
Ian Elliott07264132015-04-28 11:35:02 -06002286 "the Getting Started guide for additional information.\n",
2287 "vkCreateInstance Failure");
Ian Elliott3979e282015-04-03 15:24:55 -06002288 }
Jon Ashburnab46b362015-04-04 14:52:07 -06002289
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002290 free(instance_layers);
2291 free(instance_extensions);
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002292
Tobin Ehlis8a724d82015-09-07 15:16:39 -06002293 /* Make initial call to query gpu_count, then second call for gpu info*/
2294 err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, NULL);
2295 assert(!err && gpu_count > 0);
2296 physical_devices = malloc(sizeof(VkPhysicalDevice) * gpu_count);
2297 err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, physical_devices);
2298 assert(!err);
2299 /* For cube demo we just grab the first physical device */
2300 demo->gpu = physical_devices[0];
2301 free(physical_devices);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002302
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002303 /* Look for validation layers */
2304 validation_found = 0;
Tony Barbourda2bad52016-01-22 14:36:40 -07002305 demo->enabled_layer_count = 0;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002306 uint32_t device_layer_count = 0;
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002307 err = vkEnumerateDeviceLayerProperties(demo->gpu, &device_layer_count, NULL);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002308 assert(!err);
2309
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002310 device_layers = malloc(sizeof(VkLayerProperties) * device_layer_count);
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002311 err = vkEnumerateDeviceLayerProperties(demo->gpu, &device_layer_count, device_layers);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002312 assert(!err);
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002313
2314 if (demo->validate) {
Tony Barbourda2bad52016-01-22 14:36:40 -07002315 validation_found = demo_check_layers(device_validation_layer_count, demo->device_validation_layers,
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002316 device_layer_count, device_layers);
2317 if (!validation_found) {
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002318 ERR_EXIT("vkEnumerateDeviceLayerProperties failed to find"
Courtney Goeltzenleuchter886f76c2015-07-06 17:46:11 -06002319 "a required validation layer.\n\n"
2320 "Please look at the Getting Started guide for additional "
2321 "information.\n",
2322 "vkCreateDevice Failure");
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002323 }
Tony Barbourda2bad52016-01-22 14:36:40 -07002324 demo->enabled_layer_count = device_validation_layer_count;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002325 }
2326
2327 uint32_t device_extension_count = 0;
2328 VkExtensionProperties *device_extensions = NULL;
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002329 err = vkEnumerateDeviceExtensionProperties(
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002330 demo->gpu, NULL, &device_extension_count, NULL);
2331 assert(!err);
2332
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002333 VkBool32 swapchainExtFound = 0;
Tony Barbourda2bad52016-01-22 14:36:40 -07002334 demo->enabled_extension_count = 0;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002335 memset(extension_names, 0, sizeof(extension_names));
2336 device_extensions = malloc(sizeof(VkExtensionProperties) * device_extension_count);
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002337 err = vkEnumerateDeviceExtensionProperties(
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002338 demo->gpu, NULL, &device_extension_count, device_extensions);
2339 assert(!err);
Ian Elliottaaae5352015-07-06 14:27:58 -06002340
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002341 for (uint32_t i = 0; i < device_extension_count; i++) {
Ian Elliottf4a4e442015-11-17 17:29:40 -07002342 if (!strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, device_extensions[i].extensionName)) {
Tony Barbourcc69f452015-10-08 13:59:42 -06002343 swapchainExtFound = 1;
Tony Barbourda2bad52016-01-22 14:36:40 -07002344 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002345 }
Tony Barbourda2bad52016-01-22 14:36:40 -07002346 assert(demo->enabled_extension_count < 64);
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002347 }
Tony Barbourcc69f452015-10-08 13:59:42 -06002348 if (!swapchainExtFound) {
Courtney Goeltzenleuchtere06f1192015-09-14 17:22:16 -06002349 ERR_EXIT("vkEnumerateDeviceExtensionProperties failed to find the "
Ian Elliottf4a4e442015-11-17 17:29:40 -07002350 VK_KHR_SWAPCHAIN_EXTENSION_NAME" extension.\n\nDo you have a compatible "
Courtney Goeltzenleuchterbe103362015-06-29 15:39:26 -06002351 "Vulkan installable client driver (ICD) installed?\nPlease "
2352 "look at the Getting Started guide for additional "
2353 "information.\n",
2354 "vkCreateInstance Failure");
2355 }
2356
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002357 if (demo->validate) {
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -07002358 demo->CreateDebugReportCallback = (PFN_vkCreateDebugReportCallbackEXT) vkGetInstanceProcAddr(demo->inst, "vkCreateDebugReportCallbackEXT");
2359 demo->DestroyDebugReportCallback = (PFN_vkDestroyDebugReportCallbackEXT) vkGetInstanceProcAddr(demo->inst, "vkDestroyDebugReportCallbackEXT");
Courtney Goeltzenleuchter2dafae42015-11-30 12:13:14 -07002360 if (!demo->CreateDebugReportCallback) {
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -07002361 ERR_EXIT("GetProcAddr: Unable to find vkCreateDebugReportCallbackEXT\n",
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002362 "vkGetProcAddr Failure");
2363 }
Courtney Goeltzenleuchter2dafae42015-11-30 12:13:14 -07002364 if (!demo->DestroyDebugReportCallback) {
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -07002365 ERR_EXIT("GetProcAddr: Unable to find vkDestroyDebugReportCallbackEXT\n",
Tony Barbourd70b42c2015-06-30 14:14:19 -06002366 "vkGetProcAddr Failure");
2367 }
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -07002368 demo->DebugReportMessage = (PFN_vkDebugReportMessageEXT) vkGetInstanceProcAddr(demo->inst, "vkDebugReportMessageEXT");
Courtney Goeltzenleuchteraf1951c2015-12-01 14:11:38 -07002369 if (!demo->DebugReportMessage) {
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -07002370 ERR_EXIT("GetProcAddr: Unable to find vkDebugReportMessageEXT\n",
Courtney Goeltzenleuchteraf1951c2015-12-01 14:11:38 -07002371 "vkGetProcAddr Failure");
2372 }
Jon Ashburn9549c8e2015-12-15 08:47:46 -07002373
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -07002374 PFN_vkDebugReportCallbackEXT callback;
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -06002375
2376 if (!demo->use_break) {
2377 callback = dbgFunc;
2378 } else {
Jon Ashburn9549c8e2015-12-15 08:47:46 -07002379 callback = dbgFunc;
2380 // TODO add a break callback defined locally since there is no longer
2381 // one included in the loader
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -06002382 }
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -07002383 VkDebugReportCallbackCreateInfoEXT dbgCreateInfo;
2384 dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
Courtney Goeltzenleuchter2dafae42015-11-30 12:13:14 -07002385 dbgCreateInfo.pNext = NULL;
2386 dbgCreateInfo.pfnCallback = callback;
2387 dbgCreateInfo.pUserData = NULL;
Courtney Goeltzenleuchter0f060df2015-12-09 15:48:16 -07002388 dbgCreateInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARN_BIT_EXT;
Courtney Goeltzenleuchter2dafae42015-11-30 12:13:14 -07002389 err = demo->CreateDebugReportCallback(
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002390 demo->inst,
Courtney Goeltzenleuchter2dafae42015-11-30 12:13:14 -07002391 &dbgCreateInfo,
2392 NULL,
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002393 &demo->msg_callback);
2394 switch (err) {
2395 case VK_SUCCESS:
2396 break;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002397 case VK_ERROR_OUT_OF_HOST_MEMORY:
Courtney Goeltzenleuchter2dafae42015-11-30 12:13:14 -07002398 ERR_EXIT("CreateDebugReportCallback: out of host memory\n",
2399 "CreateDebugReportCallback Failure");
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002400 break;
2401 default:
Courtney Goeltzenleuchter2dafae42015-11-30 12:13:14 -07002402 ERR_EXIT("CreateDebugReportCallback: unknown failure\n",
2403 "CreateDebugReportCallback Failure");
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06002404 break;
2405 }
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002406 }
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002407 vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002408
2409 /* Call with NULL data to get count */
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002410 vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, NULL);
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002411 assert(demo->queue_count >= 1);
2412
2413 demo->queue_props = (VkQueueFamilyProperties *) malloc(demo->queue_count * sizeof(VkQueueFamilyProperties));
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002414 vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_count, demo->queue_props);
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002415 // Find a queue that supports gfx
2416 uint32_t gfx_queue_idx = 0;
2417 for (gfx_queue_idx = 0; gfx_queue_idx<demo->queue_count; gfx_queue_idx++) {
2418 if (demo->queue_props[gfx_queue_idx].queueFlags & VK_QUEUE_GRAPHICS_BIT)
2419 break;
2420 }
2421 assert(gfx_queue_idx < demo->queue_count);
Tobin Ehlisbf3020e2015-09-24 15:18:22 -06002422 // Query fine-grained feature support for this device.
2423 // If app has specific feature requirements it should check supported features based on this query
Tobin Ehlis8d03b7c2015-09-29 11:22:37 -06002424 VkPhysicalDeviceFeatures physDevFeatures;
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002425 vkGetPhysicalDeviceFeatures(demo->gpu, &physDevFeatures);
Tobin Ehlisbf3020e2015-09-24 15:18:22 -06002426
Tony Barbourda2bad52016-01-22 14:36:40 -07002427 free(device_layers);
2428
2429 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
2430 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceCapabilitiesKHR);
2431 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceFormatsKHR);
2432 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfacePresentModesKHR);
2433 GET_INSTANCE_PROC_ADDR(demo->inst, GetSwapchainImagesKHR);
2434}
2435
2436static void demo_create_device(struct demo *demo)
2437{
2438 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter2aff13f2015-10-23 10:37:02 -06002439 float queue_priorities[1] = { 0.0 };
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002440 const VkDeviceQueueCreateInfo queue = {
2441 .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
2442 .pNext = NULL,
Tony Barbourda2bad52016-01-22 14:36:40 -07002443 .queueFamilyIndex = demo->graphics_queue_node_index,
Chia-I Wu8b497442015-11-06 06:42:02 +08002444 .queueCount = 1,
Courtney Goeltzenleuchter2aff13f2015-10-23 10:37:02 -06002445 .pQueuePriorities = queue_priorities
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002446 };
2447
2448 VkDeviceCreateInfo device = {
2449 .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
2450 .pNext = NULL,
Chia-I Wu8b497442015-11-06 06:42:02 +08002451 .queueCreateInfoCount = 1,
2452 .pQueueCreateInfos = &queue,
Tony Barbourda2bad52016-01-22 14:36:40 -07002453 .enabledLayerCount = demo->enabled_layer_count,
2454 .ppEnabledLayerNames = (const char *const*) ((demo->validate) ? demo->device_validation_layers : NULL),
2455 .enabledExtensionCount = demo->enabled_extension_count,
2456 .ppEnabledExtensionNames = (const char *const*) demo->extension_names,
Tobin Ehlisbf3020e2015-09-24 15:18:22 -06002457 .pEnabledFeatures = NULL, // If specific features are required, pass them in here
Tobin Ehlis9626ba62015-09-22 13:52:37 -06002458 };
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002459
Chia-I Wu63636062015-10-26 21:10:41 +08002460 err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002461 assert(!err);
2462
Courtney Goeltzenleuchter3a35c822015-07-15 17:45:38 -06002463}
2464
Tony Barbourcc69f452015-10-08 13:59:42 -06002465static void demo_init_vk_swapchain(struct demo *demo)
Courtney Goeltzenleuchter3a35c822015-07-15 17:45:38 -06002466{
Courtney Goeltzenleuchterd3cdaaf2015-12-17 09:53:29 -07002467 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter3a35c822015-07-15 17:45:38 -06002468 uint32_t i;
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07002469
Ian Elliottb08e0d92015-11-20 11:55:46 -07002470 // Create a WSI surface for the window:
Ian Elliottaaae5352015-07-06 14:27:58 -06002471#ifdef _WIN32
Ian Elliotta7a731c2015-12-11 15:52:12 -07002472 VkWin32SurfaceCreateInfoKHR createInfo;
2473 createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
2474 createInfo.pNext = NULL;
2475 createInfo.flags = 0;
Jon Ashburnb90f50d2015-12-24 17:08:01 -07002476 createInfo.hinstance = demo->connection;
2477 createInfo.hwnd = demo->window;
Ian Elliotta7a731c2015-12-11 15:52:12 -07002478
2479 err = vkCreateWin32SurfaceKHR(demo->inst, &createInfo,
Ian Elliottb08e0d92015-11-20 11:55:46 -07002480 NULL, &demo->surface);
2481
Ian Elliottaaae5352015-07-06 14:27:58 -06002482#else // _WIN32
Ian Elliotta7a731c2015-12-11 15:52:12 -07002483 VkXcbSurfaceCreateInfoKHR createInfo;
2484 createInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
2485 createInfo.pNext = NULL;
2486 createInfo.flags = 0;
2487 createInfo.connection = demo->connection;
2488 createInfo.window = demo->window;
2489
2490 err = vkCreateXcbSurfaceKHR(demo->inst, &createInfo,
Ian Elliottb08e0d92015-11-20 11:55:46 -07002491 NULL, &demo->surface);
Ian Elliottaaae5352015-07-06 14:27:58 -06002492#endif // _WIN32
2493
Tony Barbourcc69f452015-10-08 13:59:42 -06002494 // Iterate over each queue to learn whether it supports presenting:
Courtney Goeltzenleuchterfe95fca2015-07-15 17:40:20 -06002495 VkBool32* supportsPresent = (VkBool32 *)malloc(demo->queue_count * sizeof(VkBool32));
2496 for (i = 0; i < demo->queue_count; i++) {
Ian Elliotta0781972015-08-21 15:09:33 -06002497 demo->fpGetPhysicalDeviceSurfaceSupportKHR(demo->gpu, i,
Ian Elliottb08e0d92015-11-20 11:55:46 -07002498 demo->surface,
Ian Elliottaaae5352015-07-06 14:27:58 -06002499 &supportsPresent[i]);
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07002500 }
Ian Elliottaaae5352015-07-06 14:27:58 -06002501
2502 // Search for a graphics and a present queue in the array of queue
2503 // families, try to find one that supports both
2504 uint32_t graphicsQueueNodeIndex = UINT32_MAX;
2505 uint32_t presentQueueNodeIndex = UINT32_MAX;
Courtney Goeltzenleuchterfe95fca2015-07-15 17:40:20 -06002506 for (i = 0; i < demo->queue_count; i++) {
Ian Elliottaaae5352015-07-06 14:27:58 -06002507 if ((demo->queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) {
2508 if (graphicsQueueNodeIndex == UINT32_MAX) {
2509 graphicsQueueNodeIndex = i;
2510 }
2511
2512 if (supportsPresent[i] == VK_TRUE) {
2513 graphicsQueueNodeIndex = i;
2514 presentQueueNodeIndex = i;
2515 break;
2516 }
2517 }
2518 }
2519 if (presentQueueNodeIndex == UINT32_MAX) {
2520 // If didn't find a queue that supports both graphics and present, then
2521 // find a separate present queue.
Courtney Goeltzenleuchterfe95fca2015-07-15 17:40:20 -06002522 for (uint32_t i = 0; i < demo->queue_count; ++i) {
Ian Elliottaaae5352015-07-06 14:27:58 -06002523 if (supportsPresent[i] == VK_TRUE) {
2524 presentQueueNodeIndex = i;
2525 break;
2526 }
2527 }
2528 }
2529 free(supportsPresent);
2530
2531 // Generate error if could not find both a graphics and a present queue
2532 if (graphicsQueueNodeIndex == UINT32_MAX || presentQueueNodeIndex == UINT32_MAX) {
2533 ERR_EXIT("Could not find a graphics and a present queue\n",
Tony Barbourcc69f452015-10-08 13:59:42 -06002534 "Swapchain Initialization Failure");
Ian Elliottaaae5352015-07-06 14:27:58 -06002535 }
2536
2537 // TODO: Add support for separate queues, including presentation,
Ian Elliottf2ff8022015-11-23 12:48:15 -07002538 // synchronization, and appropriate tracking for QueueSubmit.
2539 // NOTE: While it is possible for an application to use a separate graphics
2540 // and a present queues, this demo program assumes it is only using
2541 // one:
Ian Elliottaaae5352015-07-06 14:27:58 -06002542 if (graphicsQueueNodeIndex != presentQueueNodeIndex) {
2543 ERR_EXIT("Could not find a common graphics and a present queue\n",
Tony Barbourcc69f452015-10-08 13:59:42 -06002544 "Swapchain Initialization Failure");
Ian Elliottaaae5352015-07-06 14:27:58 -06002545 }
2546
2547 demo->graphics_queue_node_index = graphicsQueueNodeIndex;
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07002548
Tony Barbourda2bad52016-01-22 14:36:40 -07002549 demo_create_device(demo);
2550
2551 GET_DEVICE_PROC_ADDR(demo->device, CreateSwapchainKHR);
2552 GET_DEVICE_PROC_ADDR(demo->device, DestroySwapchainKHR);
2553 GET_DEVICE_PROC_ADDR(demo->device, GetSwapchainImagesKHR);
2554 GET_DEVICE_PROC_ADDR(demo->device, AcquireNextImageKHR);
2555 GET_DEVICE_PROC_ADDR(demo->device, QueuePresentKHR);
2556
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002557 vkGetDeviceQueue(demo->device, demo->graphics_queue_node_index,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002558 0, &demo->queue);
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002559
Ian Elliottaaae5352015-07-06 14:27:58 -06002560 // Get the list of VkFormat's that are supported:
Ian Elliott8528eff2015-08-07 15:56:59 -06002561 uint32_t formatCount;
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002562 err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu,
Ian Elliottf2ff8022015-11-23 12:48:15 -07002563 demo->surface,
2564 &formatCount, NULL);
Ian Elliottaaae5352015-07-06 14:27:58 -06002565 assert(!err);
Ian Elliotta0781972015-08-21 15:09:33 -06002566 VkSurfaceFormatKHR *surfFormats =
2567 (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
Ian Elliottd3f7dcc2015-11-20 13:08:34 -07002568 err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu,
Ian Elliottf2ff8022015-11-23 12:48:15 -07002569 demo->surface,
2570 &formatCount, surfFormats);
Ian Elliottaaae5352015-07-06 14:27:58 -06002571 assert(!err);
2572 // If the format list includes just one entry of VK_FORMAT_UNDEFINED,
2573 // the surface has no preferred format. Otherwise, at least one
2574 // supported format will be returned.
Ian Elliottaaae5352015-07-06 14:27:58 -06002575 if (formatCount == 1 && surfFormats[0].format == VK_FORMAT_UNDEFINED)
2576 {
2577 demo->format = VK_FORMAT_B8G8R8A8_UNORM;
2578 }
2579 else
2580 {
2581 assert(formatCount >= 1);
2582 demo->format = surfFormats[0].format;
2583 }
Ian Elliott8528eff2015-08-07 15:56:59 -06002584 demo->color_space = surfFormats[0].colorSpace;
Ian Elliotte4602cd2015-04-21 16:41:02 -06002585
David Pinedo2bb7c932015-06-18 17:03:14 -06002586 demo->quit = false;
2587 demo->curFrame = 0;
Mark Lobodzinskieadf9982015-07-02 16:49:40 -06002588
2589 // Get Memory information and properties
Courtney Goeltzenleuchterbd5c1742015-10-20 16:40:38 -06002590 vkGetPhysicalDeviceMemoryProperties(demo->gpu, &demo->memory_properties);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002591}
2592
2593static void demo_init_connection(struct demo *demo)
2594{
Ian Elliott639ca472015-04-16 15:23:05 -06002595#ifndef _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002596 const xcb_setup_t *setup;
2597 xcb_screen_iterator_t iter;
2598 int scr;
2599
2600 demo->connection = xcb_connect(NULL, &scr);
Ian Elliott3979e282015-04-03 15:24:55 -06002601 if (demo->connection == NULL) {
2602 printf("Cannot find a compatible Vulkan installable client driver "
2603 "(ICD).\nExiting ...\n");
2604 fflush(stdout);
2605 exit(1);
2606 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002607
2608 setup = xcb_get_setup(demo->connection);
2609 iter = xcb_setup_roots_iterator(setup);
2610 while (scr-- > 0)
2611 xcb_screen_next(&iter);
2612
2613 demo->screen = iter.data;
Ian Elliott639ca472015-04-16 15:23:05 -06002614#endif // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002615}
2616
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002617static void demo_init(struct demo *demo, int argc, char **argv)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002618{
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002619 vec3 eye = {0.0f, 3.0f, 5.0f};
2620 vec3 origin = {0, 0, 0};
Chia-I Wuae3b55d2015-04-22 14:56:17 +08002621 vec3 up = {0.0f, 1.0f, 0.0};
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002622
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002623 memset(demo, 0, sizeof(*demo));
Tony Barbour1a86d032015-09-21 15:17:33 -06002624 demo->frameCount = INT32_MAX;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002625
Piers Daniell735ee532015-02-23 16:23:13 -07002626 for (int i = 1; i < argc; i++) {
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002627 if (strcmp(argv[i], "--use_staging") == 0) {
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002628 demo->use_staging_buffer = true;
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002629 continue;
Ian Elliott639ca472015-04-16 15:23:05 -06002630 }
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -06002631 if (strcmp(argv[i], "--break") == 0) {
2632 demo->use_break = true;
2633 continue;
2634 }
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002635 if (strcmp(argv[i], "--validate") == 0) {
2636 demo->validate = true;
2637 continue;
2638 }
David Pinedo2bb7c932015-06-18 17:03:14 -06002639 if (strcmp(argv[i], "--c") == 0 &&
Tony Barbour1a86d032015-09-21 15:17:33 -06002640 demo->frameCount == INT32_MAX &&
David Pinedo2bb7c932015-06-18 17:03:14 -06002641 i < argc-1 &&
2642 sscanf(argv[i+1],"%d", &demo->frameCount) == 1 &&
2643 demo->frameCount >= 0)
2644 {
2645 i++;
2646 continue;
2647 }
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002648
Courtney Goeltzenleuchter03f4b772015-07-22 11:03:51 -06002649 fprintf(stderr, "Usage:\n %s [--use_staging] [--validate] [--break] [--c <framecount>]\n", APP_SHORT_NAME);
Ian Elliott639ca472015-04-16 15:23:05 -06002650 fflush(stderr);
2651 exit(1);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002652 }
2653
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002654 demo_init_connection(demo);
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002655 demo_init_vk(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002656
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002657 demo->width = 500;
2658 demo->height = 500;
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002659
2660 demo->spin_angle = 0.01f;
2661 demo->spin_increment = 0.01f;
2662 demo->pause = false;
2663
Piers Daniell735ee532015-02-23 16:23:13 -07002664 mat4x4_perspective(demo->projection_matrix, (float)degreesToRadians(45.0f), 1.0f, 0.1f, 100.0f);
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002665 mat4x4_look_at(demo->view_matrix, eye, origin, up);
2666 mat4x4_identity(demo->model_matrix);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002667}
2668
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002669
Ian Elliott639ca472015-04-16 15:23:05 -06002670#ifdef _WIN32
Mark Young418b9d12016-01-06 14:26:04 -07002671// Include header required for parsing the command line options.
2672#include <shellapi.h>
Ian Elliottf9cf78c2015-04-28 10:33:11 -06002673
Ian Elliotta748eaf2015-04-28 15:50:36 -06002674int WINAPI WinMain(HINSTANCE hInstance,
2675 HINSTANCE hPrevInstance,
2676 LPSTR pCmdLine,
2677 int nCmdShow)
Ian Elliott639ca472015-04-16 15:23:05 -06002678{
2679 MSG msg; // message
Mark Young418b9d12016-01-06 14:26:04 -07002680 bool done; // flag saying when app is complete
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002681 int argc;
2682 char** argv;
Ian Elliott639ca472015-04-16 15:23:05 -06002683
Mark Young418b9d12016-01-06 14:26:04 -07002684 // Use the CommandLine functions to get the command line arguments. Unfortunately, Microsoft outputs
2685 // this information as wide characters for Unicode, and we simply want the Ascii version to be compatible
2686 // with the non-Windows side. So, we have to convert the information to Ascii character strings.
2687 LPWSTR* commandLineArgs = CommandLineToArgvW(GetCommandLineW(), &argc);
2688 if (NULL == commandLineArgs)
2689 {
2690 argc = 0;
2691 }
2692
2693 if (argc > 0)
2694 {
2695 argv = (char**)malloc(sizeof(char*) * argc);
2696 if (argv == NULL)
2697 {
2698 argc = 0;
2699 }
2700 else
2701 {
2702 for (int iii = 0; iii < argc; iii++)
2703 {
2704 size_t wideCharLen = wcslen(commandLineArgs[iii]);
2705 size_t numConverted = 0;
2706
2707 argv[iii] = (char*)malloc(sizeof(char) * (wideCharLen + 1));
2708 if (argv[iii] != NULL)
2709 {
2710 wcstombs_s(&numConverted, argv[iii], wideCharLen + 1, commandLineArgs[iii], wideCharLen + 1);
2711 }
2712 }
2713 }
2714 }
2715 else
2716 {
2717 argv = NULL;
2718 }
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002719
2720 demo_init(&demo, argc, argv);
Mark Young418b9d12016-01-06 14:26:04 -07002721
2722 // Free up the items we had to allocate for the command line arguments.
2723 if (argc > 0 && argv != NULL)
2724 {
2725 for (int iii = 0; iii < argc; iii++)
2726 {
2727 if (argv[iii] != NULL)
2728 {
2729 free(argv[iii]);
2730 }
2731 }
2732 free(argv);
2733 }
2734
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002735 demo.connection = hInstance;
2736 strncpy(demo.name, "cube", APP_NAME_STR_LEN);
Ian Elliott639ca472015-04-16 15:23:05 -06002737 demo_create_window(&demo);
Tony Barbourcc69f452015-10-08 13:59:42 -06002738 demo_init_vk_swapchain(&demo);
Ian Elliott639ca472015-04-16 15:23:05 -06002739
2740 demo_prepare(&demo);
2741
2742 done = false; //initialize loop condition variable
Mark Young418b9d12016-01-06 14:26:04 -07002743
2744 // main message loop
Ian Elliott639ca472015-04-16 15:23:05 -06002745 while(!done)
2746 {
Ian Elliotta748eaf2015-04-28 15:50:36 -06002747 PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
Ian Elliott639ca472015-04-16 15:23:05 -06002748 if (msg.message == WM_QUIT) //check for a quit message
2749 {
2750 done = true; //if found, quit app
2751 }
2752 else
2753 {
2754 /* Translate and dispatch to event queue*/
2755 TranslateMessage(&msg);
2756 DispatchMessage(&msg);
2757 }
Tony Barbourc8a59892015-10-20 12:49:46 -06002758 RedrawWindow(demo.window, NULL, NULL, RDW_INTERNALPAINT);
Ian Elliott639ca472015-04-16 15:23:05 -06002759 }
2760
2761 demo_cleanup(&demo);
2762
Tony Barbourf9921732015-04-22 11:36:22 -06002763 return (int) msg.wParam;
Ian Elliott639ca472015-04-16 15:23:05 -06002764}
2765#else // _WIN32
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002766int main(int argc, char **argv)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002767{
2768 struct demo demo;
2769
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002770 demo_init(&demo, argc, argv);
Chia-I Wucbb564e2015-04-16 22:02:10 +08002771 demo_create_window(&demo);
Tony Barbourcc69f452015-10-08 13:59:42 -06002772 demo_init_vk_swapchain(&demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002773
2774 demo_prepare(&demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002775 demo_run(&demo);
2776
2777 demo_cleanup(&demo);
2778
2779 return 0;
2780}
Ian Elliott639ca472015-04-16 15:23:05 -06002781#endif // _WIN32