blob: 13fbbbe145bc4deada93d120b339a319979f49dd [file] [log] [blame]
Ian Elliotta748eaf2015-04-28 15:50:36 -06001/*
2 * Vulkan
3 *
4 * Copyright (C) 2014-2015 LunarG, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -060024#define _GNU_SOURCE
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060025#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <stdbool.h>
29#include <assert.h>
30
Ian Elliott639ca472015-04-16 15:23:05 -060031#ifdef _WIN32
32#pragma comment(linker, "/subsystem:windows")
33#include <windows.h>
34#define APP_NAME_STR_LEN 80
35#else // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060036#include <xcb/xcb.h>
Ian Elliott639ca472015-04-16 15:23:05 -060037#endif // _WIN32
38
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -060039#include <vulkan.h>
Chia-I Wucbb564e2015-04-16 22:02:10 +080040#include <vk_wsi_lunarg.h>
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -060041#include "vk_debug_report_lunarg.h"
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060042
Cody Northropfe3d8bc2015-03-17 14:54:35 -060043#include "icd-spv.h"
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060044
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -060045#include "linmath.h"
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -060046#include <png.h>
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -060047
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060048#define DEMO_BUFFER_COUNT 2
49#define DEMO_TEXTURE_COUNT 1
Ian Elliott44e33f72015-04-28 10:52:52 -060050#define APP_SHORT_NAME "cube"
51#define APP_LONG_NAME "The Vulkan Cube Demo Program"
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -060052
Tony Barbourfdc2d352015-04-22 09:02:32 -060053#if defined(NDEBUG) && defined(__GNUC__)
54#define U_ASSERT_ONLY __attribute__((unused))
55#else
56#define U_ASSERT_ONLY
57#endif
58
Ian Elliott07264132015-04-28 11:35:02 -060059#ifdef _WIN32
60#define ERR_EXIT(err_msg, err_class) \
61 do { \
62 MessageBox(NULL, err_msg, err_class, MB_OK); \
63 exit(1); \
64 } while (0)
65
66// NOTE: If the following values (copied from "loader_platform.h") change, they
67// need to change here as well:
68#define LAYER_NAMES_ENV "VK_LAYER_NAMES"
69#define LAYER_NAMES_REGISTRY_VALUE "VK_LAYER_NAMES"
70
71#else // _WIN32
72
73#define ERR_EXIT(err_msg, err_class) \
74 do { \
75 printf(err_msg); \
76 fflush(stdout); \
77 exit(1); \
78 } while (0)
79#endif // _WIN32
80
Ian Elliott673898b2015-06-22 15:07:49 -060081#define GET_DEVICE_PROC_ADDR(dev, entrypoint) \
82{ \
83 demo->fp##entrypoint = vkGetDeviceProcAddr(dev, "vk"#entrypoint); \
84 if (demo->fp##entrypoint == NULL) { \
85 ERR_EXIT("vkGetDeviceProcAddr failed to find vk"#entrypoint, \
86 "vkGetDeviceProcAddr Failure"); \
87 } \
88}
89
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -060090/*
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -070091 * structure to track all objects related to a texture.
92 */
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -060093struct texture_object {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -060094 VkSampler sampler;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -070095
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -060096 VkImage image;
97 VkImageLayout imageLayout;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -060098
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -050099 VkDeviceMemory mem;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600100 VkImageView view;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700101 int32_t tex_width, tex_height;
102};
103
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600104static char *tex_files[] = {
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -0600105 "lunarg-logo-256x256-solid.png"
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600106};
107
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600108struct vkcube_vs_uniform {
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600109 // Must start with MVP
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600110 float mvp[4][4];
111 float position[12*3][4];
112 float color[12*3][4];
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600113};
114
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600115struct vktexcube_vs_uniform {
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600116 // Must start with MVP
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600117 float mvp[4][4];
118 float position[12*3][4];
119 float attr[12*3][4];
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600120};
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600121
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600122//--------------------------------------------------------------------------------------
123// Mesh and VertexFormat Data
124//--------------------------------------------------------------------------------------
125struct Vertex
126{
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600127 float posX, posY, posZ, posW; // Position data
128 float r, g, b, a; // Color
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600129};
130
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600131struct VertexPosTex
132{
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600133 float posX, posY, posZ, posW; // Position data
134 float u, v, s, t; // Texcoord
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600135};
136
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600137#define XYZ1(_x_, _y_, _z_) (_x_), (_y_), (_z_), 1.f
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600138#define UV(_u_, _v_) (_u_), (_v_), 0.f, 1.f
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600139
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600140static const float g_vertex_buffer_data[] = {
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800141 -1.0f,-1.0f,-1.0f, // -X side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600142 -1.0f,-1.0f, 1.0f,
143 -1.0f, 1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800144 -1.0f, 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600145 -1.0f, 1.0f,-1.0f,
146 -1.0f,-1.0f,-1.0f,
147
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800148 -1.0f,-1.0f,-1.0f, // -Z side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600149 1.0f, 1.0f,-1.0f,
150 1.0f,-1.0f,-1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800151 -1.0f,-1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600152 -1.0f, 1.0f,-1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600153 1.0f, 1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600154
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800155 -1.0f,-1.0f,-1.0f, // -Y side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600156 1.0f,-1.0f,-1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600157 1.0f,-1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800158 -1.0f,-1.0f,-1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600159 1.0f,-1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600160 -1.0f,-1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600161
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800162 -1.0f, 1.0f,-1.0f, // +Y side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600163 -1.0f, 1.0f, 1.0f,
164 1.0f, 1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800165 -1.0f, 1.0f,-1.0f,
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,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600168
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800169 1.0f, 1.0f,-1.0f, // +X side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600170 1.0f, 1.0f, 1.0f,
171 1.0f,-1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800172 1.0f,-1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600173 1.0f,-1.0f,-1.0f,
174 1.0f, 1.0f,-1.0f,
175
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800176 -1.0f, 1.0f, 1.0f, // +Z side
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600177 -1.0f,-1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600178 1.0f, 1.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800179 -1.0f,-1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600180 1.0f,-1.0f, 1.0f,
181 1.0f, 1.0f, 1.0f,
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600182};
183
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600184static const float g_uv_buffer_data[] = {
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800185 0.0f, 0.0f, // -X side
186 1.0f, 0.0f,
187 1.0f, 1.0f,
188 1.0f, 1.0f,
189 0.0f, 1.0f,
190 0.0f, 0.0f,
191
192 1.0f, 0.0f, // -Z side
193 0.0f, 1.0f,
194 0.0f, 0.0f,
195 1.0f, 0.0f,
196 1.0f, 1.0f,
197 0.0f, 1.0f,
198
199 1.0f, 1.0f, // -Y side
200 1.0f, 0.0f,
201 0.0f, 0.0f,
202 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600203 0.0f, 0.0f,
204 0.0f, 1.0f,
205
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800206 1.0f, 1.0f, // +Y side
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -0600207 0.0f, 1.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800208 0.0f, 0.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600209 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600210 0.0f, 0.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600211 1.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600212
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800213 1.0f, 1.0f, // +X side
214 0.0f, 1.0f,
215 0.0f, 0.0f,
216 0.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600217 1.0f, 0.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600218 1.0f, 1.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600219
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800220 0.0f, 1.0f, // +Z side
221 0.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600222 1.0f, 1.0f,
Mike Stroyan16b3d982015-03-19 14:29:04 -0600223 0.0f, 0.0f,
Chia-I Wuae3b55d2015-04-22 14:56:17 +0800224 1.0f, 0.0f,
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600225 1.0f, 1.0f,
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600226};
227
228void dumpMatrix(const char *note, mat4x4 MVP)
229{
230 int i;
231
232 printf("%s: \n", note);
233 for (i=0; i<4; i++) {
234 printf("%f, %f, %f, %f\n", MVP[i][0], MVP[i][1], MVP[i][2], MVP[i][3]);
235 }
236 printf("\n");
237 fflush(stdout);
238}
239
240void dumpVec4(const char *note, vec4 vector)
241{
242 printf("%s: \n", note);
243 printf("%f, %f, %f, %f\n", vector[0], vector[1], vector[2], vector[3]);
244 printf("\n");
245 fflush(stdout);
246}
247
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600248void dbgFunc(
249 VkFlags msgFlags,
250 VkObjectType objType,
251 VkObject srcObject,
252 size_t location,
253 int32_t msgCode,
254 const char* pLayerPrefix,
255 const char* pMsg,
256 void* pUserData)
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600257{
258 char *message = (char *) malloc(strlen(pMsg)+100);
259
260 assert (message);
261
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600262 if (msgFlags & VK_DBG_REPORT_ERROR_BIT) {
263 sprintf(message,"ERROR: [%s] Code %d : %s", pLayerPrefix, msgCode, pMsg);
264 } else if (msgFlags & VK_DBG_REPORT_WARN_BIT) {
265 sprintf(message,"WARNING: [%s] Code %d : %s", pLayerPrefix, msgCode, pMsg);
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600266 } else {
267 return;
268 }
269
270#ifdef _WIN32
271 MessageBox(NULL, message, "Alert", MB_OK);
272#else
273 printf("%s\n",message);
274 fflush(stdout);
275#endif
276 free(message);
277}
278
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600279struct demo {
Ian Elliott639ca472015-04-16 15:23:05 -0600280#ifdef _WIN32
281#define APP_NAME_STR_LEN 80
282 HINSTANCE connection; // hInstance - Windows Instance
283 char name[APP_NAME_STR_LEN]; // Name to put on the window/icon
284 HWND window; // hWnd - window handle
285#else // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600286 xcb_connection_t *connection;
287 xcb_screen_t *screen;
Chia-I Wucbb564e2015-04-16 22:02:10 +0800288 xcb_window_t window;
289 xcb_intern_atom_reply_t *atom_wm_delete_window;
Ian Elliott639ca472015-04-16 15:23:05 -0600290#endif // _WIN32
Cody Northrop1fedb212015-05-28 11:27:16 -0600291 bool prepared;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700292 bool use_staging_buffer;
Cody Northrop1fedb212015-05-28 11:27:16 -0600293 bool use_glsl;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600294
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600295 VkInstance inst;
Tony Barbour72304ef2015-04-16 15:59:00 -0600296 VkPhysicalDevice gpu;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600297 VkDevice device;
298 VkQueue queue;
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -0700299 uint32_t graphics_queue_node_index;
Tony Barbourecf1b2b2015-06-24 16:06:58 -0600300 VkPhysicalDeviceProperties gpu_props;
Tony Barbour72304ef2015-04-16 15:59:00 -0600301 VkPhysicalDeviceQueueProperties *queue_props;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600302
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600303 VkFramebuffer framebuffer;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600304 int width, height;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600305 VkFormat format;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600306
Jon Ashburn0b85d052015-05-21 18:13:33 -0600307 PFN_vkCreateSwapChainWSI fpCreateSwapChainWSI;
308 PFN_vkDestroySwapChainWSI fpDestroySwapChainWSI;
309 PFN_vkGetSwapChainInfoWSI fpGetSwapChainInfoWSI;
310 PFN_vkQueuePresentWSI fpQueuePresentWSI;
Chia-I Wucbb564e2015-04-16 22:02:10 +0800311 VkSwapChainWSI swap_chain;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600312 struct {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600313 VkImage image;
Tony Barbour72304ef2015-04-16 15:59:00 -0600314 VkDeviceMemory mem;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600315 VkCmdBuffer cmd;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600316
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600317 VkColorAttachmentView view;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600318 } buffers[DEMO_BUFFER_COUNT];
319
320 struct {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600321 VkFormat format;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600322
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600323 VkImage image;
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500324 VkDeviceMemory mem;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600325 VkDepthStencilView view;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600326 } depth;
327
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600328 struct texture_object textures[DEMO_TEXTURE_COUNT];
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600329
330 struct {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600331 VkBuffer buf;
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500332 VkDeviceMemory mem;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600333 VkBufferView view;
Chia-I Wuae721ba2015-05-25 16:27:55 +0800334 VkDescriptorInfo desc;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600335 } uniform_data;
336
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600337 VkCmdBuffer cmd; // Buffer for initialization commands
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -0500338 VkPipelineLayout pipeline_layout;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600339 VkDescriptorSetLayout desc_layout;
340 VkPipeline pipeline;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600341
Courtney Goeltzenleuchter5e6d1e92015-04-10 16:24:50 -0600342 VkDynamicVpState viewport;
343 VkDynamicRsState raster;
344 VkDynamicCbState color_blend;
345 VkDynamicDsState depth_stencil;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600346
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600347 mat4x4 projection_matrix;
348 mat4x4 view_matrix;
349 mat4x4 model_matrix;
350
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600351 float spin_angle;
352 float spin_increment;
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -0600353 bool pause;
354
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600355 VkDescriptorPool desc_pool;
356 VkDescriptorSet desc_set;
Chia-I Wu6a3c8972015-01-04 16:27:24 +0800357
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600358 bool quit;
David Pinedo2bb7c932015-06-18 17:03:14 -0600359 int32_t curFrame;
360 int32_t frameCount;
Tony Barbour3dddd5d2015-04-29 16:19:20 -0600361 bool validate;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -0600362 PFN_vkDbgCreateMsgCallback dbgCreateMsgCallback;
363 VkDbgMsgCallback msg_callback;
364
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600365 uint32_t current_buffer;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600366};
367
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600368static void demo_flush_init_cmd(struct demo *demo)
369{
Tony Barbourfdc2d352015-04-22 09:02:32 -0600370 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600371
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600372 if (demo->cmd == VK_NULL_HANDLE)
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600373 return;
374
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600375 err = vkEndCommandBuffer(demo->cmd);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600376 assert(!err);
377
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600378 const VkCmdBuffer cmd_bufs[] = { demo->cmd };
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600379
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600380 err = vkQueueSubmit(demo->queue, 1, cmd_bufs, VK_NULL_HANDLE);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600381 assert(!err);
382
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600383 err = vkQueueWaitIdle(demo->queue);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600384 assert(!err);
385
Mike Stroyanebae8322015-04-17 12:36:38 -0600386 vkDestroyObject(demo->device, VK_OBJECT_TYPE_COMMAND_BUFFER, demo->cmd);
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600387 demo->cmd = VK_NULL_HANDLE;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600388}
389
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600390static void demo_set_image_layout(
391 struct demo *demo,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600392 VkImage image,
malnasseeb25d3f2015-06-03 17:28:38 -0400393 VkImageAspect aspect,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600394 VkImageLayout old_image_layout,
395 VkImageLayout new_image_layout)
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600396{
Tony Barbourfdc2d352015-04-22 09:02:32 -0600397 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600398
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600399 if (demo->cmd == VK_NULL_HANDLE) {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600400 const VkCmdBufferCreateInfo cmd = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600401 .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600402 .pNext = NULL,
403 .queueNodeIndex = demo->graphics_queue_node_index,
404 .flags = 0,
405 };
406
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600407 err = vkCreateCommandBuffer(demo->device, &cmd, &demo->cmd);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600408 assert(!err);
409
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600410 VkCmdBufferBeginInfo cmd_buf_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600411 .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600412 .pNext = NULL,
Tony Barbour72304ef2015-04-16 15:59:00 -0600413 .flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600414 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600415 };
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600416 err = vkBeginCommandBuffer(demo->cmd, &cmd_buf_info);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600417 }
418
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600419 VkImageMemoryBarrier image_memory_barrier = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600420 .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600421 .pNext = NULL,
422 .outputMask = 0,
423 .inputMask = 0,
424 .oldLayout = old_image_layout,
425 .newLayout = new_image_layout,
426 .image = image,
malnasseeb25d3f2015-06-03 17:28:38 -0400427 .subresourceRange = { aspect, 0, 1, 0, 0 }
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600428 };
429
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600430 if (new_image_layout == VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL) {
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600431 /* Make sure anything that was copying from this image has completed */
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -0600432 image_memory_barrier.inputMask = VK_MEMORY_INPUT_TRANSFER_BIT;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600433 }
434
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600435 if (new_image_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600436 /* Make sure any Copy or CPU writes to image are flushed */
Courtney Goeltzenleuchter2bda8332015-04-29 17:16:21 -0600437 image_memory_barrier.outputMask = VK_MEMORY_OUTPUT_HOST_WRITE_BIT | VK_MEMORY_OUTPUT_TRANSFER_BIT;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600438 }
439
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600440 VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600441
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600442 VkPipeEvent set_events[] = { VK_PIPE_EVENT_TOP_OF_PIPE };
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600443
Tony Barbour72304ef2015-04-16 15:59:00 -0600444 vkCmdPipelineBarrier(demo->cmd, VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&pmemory_barrier);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600445}
446
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600447static void demo_draw_build_cmd(struct demo *demo, VkCmdBuffer cmd_buf)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600448{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600449 const VkColorAttachmentBindInfo color_attachment = {
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600450 .view = demo->buffers[demo->current_buffer].view,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600451 .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600452 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600453 const VkDepthStencilBindInfo depth_stencil = {
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600454 .view = demo->depth.view,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600455 .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600456 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600457 const VkClearColor clear_color = {
Courtney Goeltzenleuchter374553c2015-04-03 16:35:32 -0600458 .color.floatColor = { 0.2f, 0.2f, 0.2f, 0.2f },
459 .useRawValue = false,
460 };
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600461 const float clear_depth = 1.0f;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600462 VkImageSubresourceRange clear_range;
463 VkCmdBufferBeginInfo cmd_buf_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600464 .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
Courtney Goeltzenleuchter53968d82015-04-03 15:25:24 -0600465 .pNext = NULL,
Tony Barbour72304ef2015-04-16 15:59:00 -0600466 .flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600467 VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT,
Jon Ashburn60ccfbe2014-12-31 17:08:35 -0700468 };
Tony Barbourfdc2d352015-04-22 09:02:32 -0600469 VkResult U_ASSERT_ONLY err;
Chris Forbes40a71562015-06-17 11:36:12 +1200470 VkAttachmentLoadOp load_op = VK_ATTACHMENT_LOAD_OP_CLEAR;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600471 VkAttachmentStoreOp store_op = VK_ATTACHMENT_STORE_OP_DONT_CARE;
472 const VkFramebufferCreateInfo fb_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600473 .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
Jon Ashburn08f6eb92015-01-02 18:24:05 -0700474 .pNext = NULL,
475 .colorAttachmentCount = 1,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600476 .pColorAttachments = (VkColorAttachmentBindInfo*) &color_attachment,
477 .pDepthStencilAttachment = (VkDepthStencilBindInfo*) &depth_stencil,
Jon Ashburn08f6eb92015-01-02 18:24:05 -0700478 .sampleCount = 1,
Mark Lobodzinskic06b7412015-01-27 13:24:03 -0600479 .width = demo->width,
480 .height = demo->height,
481 .layers = 1,
Jon Ashburn08f6eb92015-01-02 18:24:05 -0700482 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600483 VkRenderPassCreateInfo rp_info;
484 VkRenderPassBegin rp_begin;
Jon Ashburn08f6eb92015-01-02 18:24:05 -0700485
486 memset(&rp_info, 0 , sizeof(rp_info));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600487 err = vkCreateFramebuffer(demo->device, &fb_info, &rp_begin.framebuffer);
Jon Ashburn08f6eb92015-01-02 18:24:05 -0700488 assert(!err);
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600489 rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
Jon Ashburn08f6eb92015-01-02 18:24:05 -0700490 rp_info.renderArea.extent.width = demo->width;
491 rp_info.renderArea.extent.height = demo->height;
Courtney Goeltzenleuchter53968d82015-04-03 15:25:24 -0600492 rp_info.colorAttachmentCount = fb_info.colorAttachmentCount;
493 rp_info.pColorFormats = &demo->format;
494 rp_info.pColorLayouts = &color_attachment.layout;
Jon Ashburn08f6eb92015-01-02 18:24:05 -0700495 rp_info.pColorLoadOps = &load_op;
496 rp_info.pColorStoreOps = &store_op;
Courtney Goeltzenleuchter53968d82015-04-03 15:25:24 -0600497 rp_info.pColorLoadClearValues = &clear_color;
Tony Barbour72304ef2015-04-16 15:59:00 -0600498 rp_info.depthStencilFormat = VK_FORMAT_D16_UNORM;
Courtney Goeltzenleuchter53968d82015-04-03 15:25:24 -0600499 rp_info.depthStencilLayout = depth_stencil.layout;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600500 rp_info.depthLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
Courtney Goeltzenleuchter53968d82015-04-03 15:25:24 -0600501 rp_info.depthLoadClearValue = clear_depth;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600502 rp_info.depthStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
503 rp_info.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
Courtney Goeltzenleuchter53968d82015-04-03 15:25:24 -0600504 rp_info.stencilLoadClearValue = 0;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600505 rp_info.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
506 err = vkCreateRenderPass(demo->device, &rp_info, &rp_begin.renderPass);
Jon Ashburn08f6eb92015-01-02 18:24:05 -0700507 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600508
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600509 err = vkBeginCommandBuffer(cmd_buf, &cmd_buf_info);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600510 assert(!err);
511
Tobin Ehlis080219d2015-06-24 15:53:07 -0600512 vkCmdBeginRenderPass(cmd_buf, &rp_begin);
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600513 vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600514 demo->pipeline);
Mark Lobodzinskic6e8b3d2015-06-15 13:21:21 -0600515 vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout,
Cody Northropfb5185a2015-04-16 13:41:56 -0600516 0, 1, &demo->desc_set, 0, NULL);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600517
Tony Barbour72304ef2015-04-16 15:59:00 -0600518 vkCmdBindDynamicStateObject(cmd_buf, VK_STATE_BIND_POINT_VIEWPORT, demo->viewport);
519 vkCmdBindDynamicStateObject(cmd_buf, VK_STATE_BIND_POINT_RASTER, demo->raster);
520 vkCmdBindDynamicStateObject(cmd_buf, VK_STATE_BIND_POINT_COLOR_BLEND,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600521 demo->color_blend);
Tony Barbour72304ef2015-04-16 15:59:00 -0600522 vkCmdBindDynamicStateObject(cmd_buf, VK_STATE_BIND_POINT_DEPTH_STENCIL,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600523 demo->depth_stencil);
524
Chris Forbes40a71562015-06-17 11:36:12 +1200525 clear_range.aspect = VK_IMAGE_ASPECT_DEPTH;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600526 clear_range.baseMipLevel = 0;
527 clear_range.mipLevels = 1;
528 clear_range.baseArraySlice = 0;
529 clear_range.arraySize = 1;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600530
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600531 vkCmdClearDepthStencil(cmd_buf, demo->depth.image,
532 VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600533 clear_depth, 0, 1, &clear_range);
534
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600535 vkCmdDraw(cmd_buf, 0, 12 * 3, 0, 1);
536 vkCmdEndRenderPass(cmd_buf, rp_begin.renderPass);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600537
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600538 err = vkEndCommandBuffer(cmd_buf);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600539 assert(!err);
Courtney Goeltzenleuchter94901dc2015-02-25 17:53:18 -0700540
Mike Stroyanebae8322015-04-17 12:36:38 -0600541 vkDestroyObject(demo->device, VK_OBJECT_TYPE_RENDER_PASS, rp_begin.renderPass);
542 vkDestroyObject(demo->device, VK_OBJECT_TYPE_FRAMEBUFFER, rp_begin.framebuffer);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600543}
544
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600545
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -0600546void demo_update_data_buffer(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600547{
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600548 mat4x4 MVP, Model, VP;
549 int matrixSize = sizeof(MVP);
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600550 uint8_t *pData;
Tony Barbourfdc2d352015-04-22 09:02:32 -0600551 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600552
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600553 mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600554
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600555 // Rotate 22.5 degrees around the Y axis
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600556 mat4x4_dup(Model, demo->model_matrix);
Piers Daniell735ee532015-02-23 16:23:13 -0700557 mat4x4_rotate(demo->model_matrix, Model, 0.0f, 1.0f, 0.0f, (float)degreesToRadians(demo->spin_angle));
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -0600558 mat4x4_mul(MVP, VP, demo->model_matrix);
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600559
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500560 err = vkMapMemory(demo->device, demo->uniform_data.mem, 0, 0, 0, (void **) &pData);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600561 assert(!err);
562
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -0600563 memcpy(pData, (const void*) &MVP[0][0], matrixSize);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600564
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500565 err = vkUnmapMemory(demo->device, demo->uniform_data.mem);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600566 assert(!err);
567}
568
569static void demo_draw(struct demo *demo)
570{
Chia-I Wucbb564e2015-04-16 22:02:10 +0800571 const VkPresentInfoWSI present = {
572 .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_WSI,
573 .pNext = NULL,
574 .image = demo->buffers[demo->current_buffer].image,
575 .flipInterval = 0,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600576 };
Tony Barbourfdc2d352015-04-22 09:02:32 -0600577 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600578
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600579 err = vkQueueSubmit(demo->queue, 1, &demo->buffers[demo->current_buffer].cmd,
580 VK_NULL_HANDLE);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600581 assert(!err);
582
Jon Ashburn0b85d052015-05-21 18:13:33 -0600583 err = demo->fpQueuePresentWSI(demo->queue, &present);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600584 assert(!err);
585
586 demo->current_buffer = (demo->current_buffer + 1) % DEMO_BUFFER_COUNT;
Chia-I Wucbb564e2015-04-16 22:02:10 +0800587
588 err = vkQueueWaitIdle(demo->queue);
589 assert(err == VK_SUCCESS);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600590}
591
592static void demo_prepare_buffers(struct demo *demo)
593{
Chia-I Wucbb564e2015-04-16 22:02:10 +0800594 const VkSwapChainCreateInfoWSI swap_chain = {
595 .sType = VK_STRUCTURE_TYPE_SWAP_CHAIN_CREATE_INFO_WSI,
596 .pNext = NULL,
597 .pNativeWindowSystemHandle = demo->connection,
598 .pNativeWindowHandle = (void *) (intptr_t) demo->window,
Ian Elliotte4602cd2015-04-21 16:41:02 -0600599 .displayCount = 1,
Chia-I Wucbb564e2015-04-16 22:02:10 +0800600 .imageCount = DEMO_BUFFER_COUNT,
601 .imageFormat = demo->format,
602 .imageExtent = {
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600603 .width = demo->width,
604 .height = demo->height,
605 },
Chia-I Wucbb564e2015-04-16 22:02:10 +0800606 .imageArraySize = 1,
607 .imageUsageFlags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600608 };
Chia-I Wucbb564e2015-04-16 22:02:10 +0800609 VkSwapChainImageInfoWSI images[DEMO_BUFFER_COUNT];
610 size_t images_size = sizeof(images);
Tony Barbourfdc2d352015-04-22 09:02:32 -0600611 VkResult U_ASSERT_ONLY err;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600612 uint32_t i;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600613
Jon Ashburn0b85d052015-05-21 18:13:33 -0600614 err = demo->fpCreateSwapChainWSI(demo->device, &swap_chain, &demo->swap_chain);
Chia-I Wucbb564e2015-04-16 22:02:10 +0800615 assert(!err);
616
Jon Ashburn0b85d052015-05-21 18:13:33 -0600617 err = demo->fpGetSwapChainInfoWSI(demo->swap_chain,
Chia-I Wucbb564e2015-04-16 22:02:10 +0800618 VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI,
619 &images_size, images);
620 assert(!err && images_size == sizeof(images));
621
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600622 for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600623 VkColorAttachmentViewCreateInfo color_attachment_view = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600624 .sType = VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600625 .pNext = NULL,
626 .format = demo->format,
627 .mipLevel = 0,
628 .baseArraySlice = 0,
629 .arraySize = 1,
630 };
631
Chia-I Wucbb564e2015-04-16 22:02:10 +0800632 demo->buffers[i].image = images[i].image;
633 demo->buffers[i].mem = images[i].memory;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600634
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600635 demo_set_image_layout(demo, demo->buffers[i].image,
malnasseeb25d3f2015-06-03 17:28:38 -0400636 VK_IMAGE_ASPECT_COLOR,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600637 VK_IMAGE_LAYOUT_UNDEFINED,
638 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600639
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600640 color_attachment_view.image = demo->buffers[i].image;
641
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600642 err = vkCreateColorAttachmentView(demo->device,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600643 &color_attachment_view, &demo->buffers[i].view);
644 assert(!err);
645 }
646}
647
648static void demo_prepare_depth(struct demo *demo)
649{
Tony Barbour72304ef2015-04-16 15:59:00 -0600650 const VkFormat depth_format = VK_FORMAT_D16_UNORM;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600651 const VkImageCreateInfo image = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600652 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600653 .pNext = NULL,
Tony Barbour72304ef2015-04-16 15:59:00 -0600654 .imageType = VK_IMAGE_TYPE_2D,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600655 .format = depth_format,
656 .extent = { demo->width, demo->height, 1 },
657 .mipLevels = 1,
658 .arraySize = 1,
659 .samples = 1,
Tony Barbour72304ef2015-04-16 15:59:00 -0600660 .tiling = VK_IMAGE_TILING_OPTIMAL,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600661 .usage = VK_IMAGE_USAGE_DEPTH_STENCIL_BIT,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600662 .flags = 0,
663 };
Courtney Goeltzenleuchter28c4d5f2015-04-14 18:48:46 -0600664 VkMemoryAllocInfo mem_alloc = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600665 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
Mark Lobodzinskia6907f72015-04-16 08:52:00 -0500666 .pNext = NULL,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600667 .allocationSize = 0,
Tony Barbour72304ef2015-04-16 15:59:00 -0600668 .memProps = VK_MEMORY_PROPERTY_DEVICE_ONLY,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600669 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600670 VkDepthStencilViewCreateInfo view = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600671 .sType = VK_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600672 .pNext = NULL,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600673 .image = VK_NULL_HANDLE,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600674 .mipLevel = 0,
675 .baseArraySlice = 0,
676 .arraySize = 1,
677 .flags = 0,
678 };
Mike Stroyanebae8322015-04-17 12:36:38 -0600679
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500680 VkMemoryRequirements mem_reqs;
Tony Barbourfdc2d352015-04-22 09:02:32 -0600681 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600682
683 demo->depth.format = depth_format;
684
685 /* create image */
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600686 err = vkCreateImage(demo->device, &image,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600687 &demo->depth.image);
688 assert(!err);
689
Tony Barbourecf1b2b2015-06-24 16:06:58 -0600690 err = vkGetObjectMemoryRequirements(demo->device,
691 VK_OBJECT_TYPE_IMAGE, demo->depth.image, &mem_reqs);
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500692 mem_alloc.allocationSize = mem_reqs.size;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600693
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500694 /* allocate memory */
695 err = vkAllocMemory(demo->device, &mem_alloc, &demo->depth.mem);
696 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600697
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500698 /* bind memory */
699 err = vkBindObjectMemory(demo->device,
700 VK_OBJECT_TYPE_IMAGE, demo->depth.image,
701 demo->depth.mem, 0);
702 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600703
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600704 demo_set_image_layout(demo, demo->depth.image,
malnasseeb25d3f2015-06-03 17:28:38 -0400705 VK_IMAGE_ASPECT_DEPTH,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600706 VK_IMAGE_LAYOUT_UNDEFINED,
707 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600708
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600709 /* create image view */
710 view.image = demo->depth.image;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600711 err = vkCreateDepthStencilView(demo->device, &view,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600712 &demo->depth.view);
713 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600714}
715
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600716/** loadTexture
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -0600717 * loads a png file into an memory object, using cstdio , libpng.
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600718 *
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -0600719 * \param demo : Needed to access VK calls
720 * \param filename : the png file to be loaded
721 * \param width : width of png, to be updated as a side effect of this function
722 * \param height : height of png, to be updated as a side effect of this function
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600723 *
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -0600724 * \return bool : an opengl texture id. true if successful?,
725 * should be validated by the client of this function.
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600726 *
727 * Source: http://en.wikibooks.org/wiki/OpenGL_Programming/Intermediate/Textures
728 * Modified to copy image to memory
729 *
730 */
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700731bool loadTexture(const char *filename, uint8_t *rgba_data,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600732 VkSubresourceLayout *layout,
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600733 int32_t *width, int32_t *height)
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600734{
735 //header for testing if it is a png
736 png_byte header[8];
Tony Barbourf9921732015-04-22 11:36:22 -0600737 int is_png, bit_depth, color_type, rowbytes;
738 size_t retval;
Ian Elliott1e42dff2015-02-13 14:29:21 -0700739 png_uint_32 i, twidth, theight;
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600740 png_structp png_ptr;
741 png_infop info_ptr, end_info;
742 png_byte *image_data;
743 png_bytep *row_pointers;
744
745 //open file as binary
746 FILE *fp = fopen(filename, "rb");
747 if (!fp) {
748 return false;
749 }
750
751 //read the header
Tony Barbourfdc2d352015-04-22 09:02:32 -0600752 retval = fread(header, 1, 8, fp);
753 if (retval != 8) {
754 fclose(fp);
755 return false;
756 }
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600757
758 //test if png
759 is_png = !png_sig_cmp(header, 0, 8);
760 if (!is_png) {
761 fclose(fp);
762 return false;
763 }
764
765 //create png struct
766 png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
767 NULL, NULL);
768 if (!png_ptr) {
769 fclose(fp);
770 return (false);
771 }
772
773 //create png info struct
774 info_ptr = png_create_info_struct(png_ptr);
775 if (!info_ptr) {
776 png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
777 fclose(fp);
778 return (false);
779 }
780
781 //create png info struct
782 end_info = png_create_info_struct(png_ptr);
783 if (!end_info) {
784 png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);
785 fclose(fp);
786 return (false);
787 }
788
789 //png error stuff, not sure libpng man suggests this.
790 if (setjmp(png_jmpbuf(png_ptr))) {
791 png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
792 fclose(fp);
793 return (false);
794 }
795
796 //init png reading
797 png_init_io(png_ptr, fp);
798
799 //let libpng know you already read the first 8 bytes
800 png_set_sig_bytes(png_ptr, 8);
801
802 // read all the info up to the image data
803 png_read_info(png_ptr, info_ptr);
804
805 // get info about png
806 png_get_IHDR(png_ptr, info_ptr, &twidth, &theight, &bit_depth, &color_type,
807 NULL, NULL, NULL);
808
809 //update width and height based on png info
810 *width = twidth;
811 *height = theight;
812
813 // Require that incoming texture be 8bits per color component
814 // and 4 components (RGBA).
815 if (png_get_bit_depth(png_ptr, info_ptr) != 8 ||
816 png_get_channels(png_ptr, info_ptr) != 4) {
817 return false;
818 }
819
820 if (rgba_data == NULL) {
821 // If data pointer is null, we just want the width & height
822 // clean up memory and close stuff
823 png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
824 fclose(fp);
825
826 return true;
827 }
828
829 // Update the png info struct.
830 png_read_update_info(png_ptr, info_ptr);
831
832 // Row size in bytes.
833 rowbytes = png_get_rowbytes(png_ptr, info_ptr);
834
835 // Allocate the image_data as a big block, to be given to opengl
836 image_data = (png_byte *)malloc(rowbytes * theight * sizeof(png_byte));
837 if (!image_data) {
838 //clean up memory and close stuff
839 png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
840 fclose(fp);
841 return false;
842 }
843
844 // row_pointers is for pointing to image_data for reading the png with libpng
845 row_pointers = (png_bytep *)malloc(theight * sizeof(png_bytep));
846 if (!row_pointers) {
847 //clean up memory and close stuff
848 png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
849 // delete[] image_data;
850 fclose(fp);
851 return false;
852 }
853 // set the individual row_pointers to point at the correct offsets of image_data
854 for (i = 0; i < theight; ++i)
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700855 row_pointers[theight - 1 - i] = rgba_data + i * layout->rowPitch;
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600856
857 // read the png into image_data through row_pointers
858 png_read_image(png_ptr, row_pointers);
859
860 // clean up memory and close stuff
861 png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
862 free(row_pointers);
863 free(image_data);
864 fclose(fp);
865
866 return true;
867}
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -0600868
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700869static void demo_prepare_texture_image(struct demo *demo,
870 const char *filename,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600871 struct texture_object *tex_obj,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600872 VkImageTiling tiling,
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -0600873 VkImageUsageFlags usage,
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600874 VkFlags mem_props)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600875{
Mike Stroyan8b89e072015-06-15 14:21:03 -0600876 const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600877 int32_t tex_width;
878 int32_t tex_height;
Tony Barbourfdc2d352015-04-22 09:02:32 -0600879 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700880
David Pinedo30bd71d2015-04-23 08:16:57 -0600881 if (!loadTexture(filename, NULL, NULL, &tex_width, &tex_height))
882 {
883 printf("Failed to load textures\n");
884 fflush(stdout);
885 exit(1);
886 }
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700887
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600888 tex_obj->tex_width = tex_width;
889 tex_obj->tex_height = tex_height;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700890
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600891 const VkImageCreateInfo image_create_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600892 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700893 .pNext = NULL,
Tony Barbour72304ef2015-04-16 15:59:00 -0600894 .imageType = VK_IMAGE_TYPE_2D,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700895 .format = tex_format,
896 .extent = { tex_width, tex_height, 1 },
897 .mipLevels = 1,
898 .arraySize = 1,
899 .samples = 1,
900 .tiling = tiling,
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -0600901 .usage = usage,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700902 .flags = 0,
903 };
Courtney Goeltzenleuchter28c4d5f2015-04-14 18:48:46 -0600904 VkMemoryAllocInfo mem_alloc = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600905 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
Mark Lobodzinskia6907f72015-04-16 08:52:00 -0500906 .pNext = NULL,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700907 .allocationSize = 0,
908 .memProps = mem_props,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700909 };
910
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500911 VkMemoryRequirements mem_reqs;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700912
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600913 err = vkCreateImage(demo->device, &image_create_info,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600914 &tex_obj->image);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700915 assert(!err);
916
Tony Barbourecf1b2b2015-06-24 16:06:58 -0600917 err = vkGetObjectMemoryRequirements(demo->device,
918 VK_OBJECT_TYPE_IMAGE, tex_obj->image, &mem_reqs);
919 assert(!err);
Piers Daniell735ee532015-02-23 16:23:13 -0700920
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500921 mem_alloc.allocationSize = mem_reqs.size;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700922
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500923 /* allocate memory */
924 err = vkAllocMemory(demo->device, &mem_alloc,
925 &(tex_obj->mem));
926 assert(!err);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700927
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500928 /* bind memory */
929 err = vkBindObjectMemory(demo->device,
930 VK_OBJECT_TYPE_IMAGE, tex_obj->image,
931 tex_obj->mem, 0);
932 assert(!err);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700933
Tony Barbour72304ef2015-04-16 15:59:00 -0600934 if (mem_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600935 const VkImageSubresource subres = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600936 .aspect = VK_IMAGE_ASPECT_COLOR,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700937 .mipLevel = 0,
938 .arraySlice = 0,
939 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600940 VkSubresourceLayout layout;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700941 void *data;
942
Tony Barbourecf1b2b2015-06-24 16:06:58 -0600943 err = vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
944 assert(!err);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700945
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500946 err = vkMapMemory(demo->device, tex_obj->mem, 0, 0, 0, &data);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700947 assert(!err);
948
949 if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) {
950 fprintf(stderr, "Error loading texture: %s\n", filename);
951 }
952
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500953 err = vkUnmapMemory(demo->device, tex_obj->mem);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700954 assert(!err);
955 }
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600956
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600957 tex_obj->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600958 demo_set_image_layout(demo, tex_obj->image,
malnasseeb25d3f2015-06-03 17:28:38 -0400959 VK_IMAGE_ASPECT_COLOR,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -0600960 VK_IMAGE_LAYOUT_UNDEFINED,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600961 tex_obj->imageLayout);
962 /* 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 -0700963}
964
Mark Lobodzinskida9b1092015-04-16 11:44:05 -0500965static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_objs)
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700966{
967 /* clean up staging resources */
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -0500968 vkFreeMemory(demo->device, tex_objs->mem);
Mike Stroyanebae8322015-04-17 12:36:38 -0600969 vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, tex_objs->image);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700970}
971
972static void demo_prepare_textures(struct demo *demo)
973{
Tony Barbour72304ef2015-04-16 15:59:00 -0600974 const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -0600975 VkFormatProperties props;
Tony Barbourfdc2d352015-04-22 09:02:32 -0600976 VkResult U_ASSERT_ONLY err;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -0600977 uint32_t i;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600978
Chris Forbesf576a3e2015-06-21 22:55:02 +1200979 err = vkGetPhysicalDeviceFormatInfo(demo->gpu, tex_format, &props);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700980 assert(!err);
981
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -0600982 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700983
FslNopper6a7e50e2015-05-06 21:42:01 +0200984 if ((props.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) && !demo->use_staging_buffer) {
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700985 /* Device can texture using linear textures */
986 demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i],
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -0600987 VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_SAMPLED_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
Tony Barbour72304ef2015-04-16 15:59:00 -0600988 } else if (props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700989 /* Must use staging buffer to copy linear texture to optimized */
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -0600990 struct texture_object staging_texture;
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700991
992 memset(&staging_texture, 0, sizeof(staging_texture));
993 demo_prepare_texture_image(demo, tex_files[i], &staging_texture,
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -0600994 VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -0700995
996 demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i],
Courtney Goeltzenleuchterc56c36a2015-04-21 09:31:23 -0600997 VK_IMAGE_TILING_OPTIMAL,
998 (VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),
999 VK_MEMORY_PROPERTY_DEVICE_ONLY);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001000
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001001 demo_set_image_layout(demo, staging_texture.image,
malnasseeb25d3f2015-06-03 17:28:38 -04001002 VK_IMAGE_ASPECT_COLOR,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001003 staging_texture.imageLayout,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001004 VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001005
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001006 demo_set_image_layout(demo, demo->textures[i].image,
malnasseeb25d3f2015-06-03 17:28:38 -04001007 VK_IMAGE_ASPECT_COLOR,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001008 demo->textures[i].imageLayout,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001009 VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001010
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001011 VkImageCopy copy_region = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001012 .srcSubresource = { VK_IMAGE_ASPECT_COLOR, 0, 0 },
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001013 .srcOffset = { 0, 0, 0 },
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001014 .destSubresource = { VK_IMAGE_ASPECT_COLOR, 0, 0 },
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001015 .destOffset = { 0, 0, 0 },
1016 .extent = { staging_texture.tex_width, staging_texture.tex_height, 1 },
1017 };
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001018 vkCmdCopyImage(demo->cmd,
1019 staging_texture.image, VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL,
1020 demo->textures[i].image, VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
Courtney Goeltzenleuchter8e89a312015-03-25 11:25:10 -06001021 1, &copy_region);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001022
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001023 demo_set_image_layout(demo, demo->textures[i].image,
malnasseeb25d3f2015-06-03 17:28:38 -04001024 VK_IMAGE_ASPECT_COLOR,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001025 VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL,
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001026 demo->textures[i].imageLayout);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001027
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001028 demo_flush_init_cmd(demo);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001029
Courtney Goeltzenleuchterf3aeb2b2015-04-21 09:30:03 -06001030 demo_destroy_texture_image(demo, &staging_texture);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001031 } else {
Mike Stroyan8b89e072015-06-15 14:21:03 -06001032 /* Can't support VK_FORMAT_R8G8B8A8_UNORM !? */
1033 assert(!"No support for R8G8B8A8_UNORM as texture image format");
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001034 }
1035
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001036 const VkSamplerCreateInfo sampler = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001037 .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001038 .pNext = NULL,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001039 .magFilter = VK_TEX_FILTER_NEAREST,
1040 .minFilter = VK_TEX_FILTER_NEAREST,
Tony Barbour72304ef2015-04-16 15:59:00 -06001041 .mipMode = VK_TEX_MIPMAP_MODE_BASE,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001042 .addressU = VK_TEX_ADDRESS_CLAMP,
1043 .addressV = VK_TEX_ADDRESS_CLAMP,
1044 .addressW = VK_TEX_ADDRESS_CLAMP,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001045 .mipLodBias = 0.0f,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001046 .maxAnisotropy = 1,
Tony Barbour72304ef2015-04-16 15:59:00 -06001047 .compareOp = VK_COMPARE_OP_NEVER,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001048 .minLod = 0.0f,
1049 .maxLod = 0.0f,
Tony Barbour72304ef2015-04-16 15:59:00 -06001050 .borderColor = VK_BORDER_COLOR_OPAQUE_WHITE,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001051 };
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001052
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001053 VkImageViewCreateInfo view = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001054 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001055 .pNext = NULL,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001056 .image = VK_NULL_HANDLE,
Tony Barbour72304ef2015-04-16 15:59:00 -06001057 .viewType = VK_IMAGE_VIEW_TYPE_2D,
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07001058 .format = tex_format,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001059 .channels = { VK_CHANNEL_SWIZZLE_R,
1060 VK_CHANNEL_SWIZZLE_G,
1061 VK_CHANNEL_SWIZZLE_B,
1062 VK_CHANNEL_SWIZZLE_A, },
1063 .subresourceRange = { VK_IMAGE_ASPECT_COLOR, 0, 1, 0, 1 },
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001064 };
Jon Ashburnb2a66652015-01-16 09:37:43 -07001065
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001066 /* create sampler */
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001067 err = vkCreateSampler(demo->device, &sampler,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001068 &demo->textures[i].sampler);
1069 assert(!err);
1070
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001071 /* create image view */
1072 view.image = demo->textures[i].image;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001073 err = vkCreateImageView(demo->device, &view,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001074 &demo->textures[i].view);
1075 assert(!err);
1076 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001077}
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001078
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001079void demo_prepare_cube_data_buffer(struct demo *demo)
1080{
Courtney Goeltzenleuchter28c4d5f2015-04-14 18:48:46 -06001081 VkBufferCreateInfo buf_info;
1082 VkBufferViewCreateInfo view_info;
Courtney Goeltzenleuchter28c4d5f2015-04-14 18:48:46 -06001083 VkMemoryAllocInfo alloc_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001084 .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
Mark Lobodzinskia6907f72015-04-16 08:52:00 -05001085 .pNext = NULL,
Jon Ashburnae7c21c2015-01-19 15:00:26 -07001086 .allocationSize = 0,
Tony Barbour72304ef2015-04-16 15:59:00 -06001087 .memProps = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
Jon Ashburnae7c21c2015-01-19 15:00:26 -07001088 };
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001089 VkMemoryRequirements mem_reqs;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001090 size_t mem_reqs_size = sizeof(VkMemoryRequirements);
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001091 uint8_t *pData;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001092 int i;
1093 mat4x4 MVP, VP;
Tony Barbourfdc2d352015-04-22 09:02:32 -06001094 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001095 struct vktexcube_vs_uniform data;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001096
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001097 mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001098 mat4x4_mul(MVP, VP, demo->model_matrix);
1099 memcpy(data.mvp, MVP, sizeof(MVP));
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001100// dumpMatrix("MVP", MVP);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001101
1102 for (i=0; i<12*3; i++) {
1103 data.position[i][0] = g_vertex_buffer_data[i*3];
1104 data.position[i][1] = g_vertex_buffer_data[i*3+1];
1105 data.position[i][2] = g_vertex_buffer_data[i*3+2];
1106 data.position[i][3] = 1.0f;
1107 data.attr[i][0] = g_uv_buffer_data[2*i];
1108 data.attr[i][1] = g_uv_buffer_data[2*i + 1];
1109 data.attr[i][2] = 0;
1110 data.attr[i][3] = 0;
1111 }
1112
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001113 memset(&buf_info, 0, sizeof(buf_info));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001114 buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -06001115 buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001116 err = vkCreateBuffer(demo->device, &buf_info, &demo->uniform_data.buf);
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001117 assert(!err);
1118
Tony Barbourecf1b2b2015-06-24 16:06:58 -06001119 err = vkGetObjectMemoryRequirements(demo->device,
1120 VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf, &mem_reqs);
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001121 assert(!err && mem_reqs_size == sizeof(mem_reqs));
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001122
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001123 alloc_info.allocationSize = mem_reqs.size;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001124
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001125 err = vkAllocMemory(demo->device, &alloc_info, &(demo->uniform_data.mem));
1126 assert(!err);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001127
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001128 err = vkMapMemory(demo->device, demo->uniform_data.mem, 0, 0, 0, (void **) &pData);
1129 assert(!err);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001130
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001131 memcpy(pData, &data, sizeof data);
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001132
Mark Lobodzinski2dcdfd72015-05-29 09:32:35 -05001133 err = vkUnmapMemory(demo->device, demo->uniform_data.mem);
1134 assert(!err);
1135
1136 err = vkBindObjectMemory(demo->device,
1137 VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf,
1138 demo->uniform_data.mem, 0);
1139 assert(!err);
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001140
1141 memset(&view_info, 0, sizeof(view_info));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001142 view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001143 view_info.buffer = demo->uniform_data.buf;
Tony Barbour72304ef2015-04-16 15:59:00 -06001144 view_info.viewType = VK_BUFFER_VIEW_TYPE_RAW;
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001145 view_info.offset = 0;
1146 view_info.range = sizeof(data);
1147
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001148 err = vkCreateBufferView(demo->device, &view_info, &demo->uniform_data.view);
Chia-I Wu8ea21c72015-01-01 07:55:04 +08001149 assert(!err);
1150
Chia-I Wuae721ba2015-05-25 16:27:55 +08001151 demo->uniform_data.desc.bufferView = demo->uniform_data.view;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001152}
1153
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001154static void demo_prepare_descriptor_layout(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001155{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001156 const VkDescriptorSetLayoutBinding layout_bindings[2] = {
Chia-I Wua2aa8632015-03-26 15:04:41 +08001157 [0] = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001158 .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
Chia-I Wu6d29a412015-05-25 16:22:52 +08001159 .arraySize = 1,
Tony Barbour72304ef2015-04-16 15:59:00 -06001160 .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
Chia-I Wu91e8e212015-03-27 12:56:09 +08001161 .pImmutableSamplers = NULL,
Chia-I Wua2aa8632015-03-26 15:04:41 +08001162 },
1163 [1] = {
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -06001164 .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
Chia-I Wu6d29a412015-05-25 16:22:52 +08001165 .arraySize = DEMO_TEXTURE_COUNT,
Tony Barbour72304ef2015-04-16 15:59:00 -06001166 .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
Chia-I Wu91e8e212015-03-27 12:56:09 +08001167 .pImmutableSamplers = NULL,
Chia-I Wua2aa8632015-03-26 15:04:41 +08001168 },
1169 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001170 const VkDescriptorSetLayoutCreateInfo descriptor_layout = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001171 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001172 .pNext = NULL,
Chia-I Wua2aa8632015-03-26 15:04:41 +08001173 .count = 2,
1174 .pBinding = layout_bindings,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001175 };
Tony Barbourfdc2d352015-04-22 09:02:32 -06001176 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001177
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001178 err = vkCreateDescriptorSetLayout(demo->device,
Chia-I Wub58c24a2015-03-26 15:27:55 +08001179 &descriptor_layout, &demo->desc_layout);
1180 assert(!err);
1181
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -05001182 const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
1183 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
1184 .pNext = NULL,
1185 .descriptorSetCount = 1,
1186 .pSetLayouts = &demo->desc_layout,
1187 };
1188
1189 err = vkCreatePipelineLayout(demo->device,
1190 &pPipelineLayoutCreateInfo,
1191 &demo->pipeline_layout);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001192 assert(!err);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001193}
1194
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001195static VkShader demo_prepare_shader(struct demo *demo,
Tony Barbour72304ef2015-04-16 15:59:00 -06001196 VkShaderStage stage,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001197 const void *code,
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001198 size_t size)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001199{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001200 VkShaderCreateInfo createInfo;
1201 VkShader shader;
1202 VkResult err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001203
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001204
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001205 createInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001206 createInfo.pNext = NULL;
1207
Cody Northrop1fedb212015-05-28 11:27:16 -06001208 if (!demo->use_glsl) {
1209 createInfo.codeSize = size;
1210 createInfo.pCode = code;
1211 createInfo.flags = 0;
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001212
Cody Northrop1fedb212015-05-28 11:27:16 -06001213 err = vkCreateShader(demo->device, &createInfo, &shader);
1214 if (err) {
1215 free((void *) createInfo.pCode);
1216 }
1217 } else {
1218 // Create fake SPV structure to feed GLSL
1219 // to the driver "under the covers"
1220 createInfo.codeSize = 3 * sizeof(uint32_t) + size + 1;
1221 createInfo.pCode = malloc(createInfo.codeSize);
1222 createInfo.flags = 0;
1223
1224 /* try version 0 first: VkShaderStage followed by GLSL */
1225 ((uint32_t *) createInfo.pCode)[0] = ICD_SPV_MAGIC;
1226 ((uint32_t *) createInfo.pCode)[1] = 0;
1227 ((uint32_t *) createInfo.pCode)[2] = stage;
1228 memcpy(((uint32_t *) createInfo.pCode + 3), code, size + 1);
1229
1230 err = vkCreateShader(demo->device, &createInfo, &shader);
1231 if (err) {
1232 free((void *) createInfo.pCode);
1233 return (VkShader) VK_NULL_HANDLE;
1234 }
Courtney Goeltzenleuchter68369392014-10-29 15:59:49 -06001235 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001236 return shader;
1237}
1238
Cody Northrop8b12a1f2015-03-17 15:55:58 -06001239char *demo_read_spv(const char *filename, size_t *psize)
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001240{
1241 long int size;
Tony Barbourf9921732015-04-22 11:36:22 -06001242 size_t U_ASSERT_ONLY retval;
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001243 void *shader_code;
1244
1245 FILE *fp = fopen(filename, "rb");
1246 if (!fp) return NULL;
1247
1248 fseek(fp, 0L, SEEK_END);
1249 size = ftell(fp);
1250
1251 fseek(fp, 0L, SEEK_SET);
1252
1253 shader_code = malloc(size);
Tony Barbourfdc2d352015-04-22 09:02:32 -06001254 retval = fread(shader_code, size, 1, fp);
1255 assert(retval == 1);
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001256
1257 *psize = size;
1258
1259 return shader_code;
1260}
1261
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001262static VkShader demo_prepare_vs(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001263{
Cody Northrop1fedb212015-05-28 11:27:16 -06001264 if (!demo->use_glsl) {
1265 void *vertShaderCode;
1266 size_t size;
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001267
Cody Northrop1fedb212015-05-28 11:27:16 -06001268 vertShaderCode = demo_read_spv("cube-vert.spv", &size);
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001269
Cody Northrop1fedb212015-05-28 11:27:16 -06001270 return demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX,
1271 vertShaderCode, size);
1272 } else {
1273 static const char *vertShaderText =
1274 "#version 140\n"
1275 "#extension GL_ARB_separate_shader_objects : enable\n"
1276 "#extension GL_ARB_shading_language_420pack : enable\n"
1277 "\n"
1278 "layout(binding = 0) uniform buf {\n"
1279 " mat4 MVP;\n"
1280 " vec4 position[12*3];\n"
1281 " vec4 attr[12*3];\n"
1282 "} ubuf;\n"
1283 "\n"
1284 "layout (location = 0) out vec4 texcoord;\n"
1285 "\n"
1286 "void main() \n"
1287 "{\n"
1288 " texcoord = ubuf.attr[gl_VertexID];\n"
1289 " gl_Position = ubuf.MVP * ubuf.position[gl_VertexID];\n"
1290 "\n"
1291 " // GL->VK conventions\n"
1292 " gl_Position.y = -gl_Position.y;\n"
1293 " gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0;\n"
1294 "}\n";
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001295
Cody Northrop1fedb212015-05-28 11:27:16 -06001296 return demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX,
1297 (const void *) vertShaderText,
1298 strlen(vertShaderText));
1299 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001300}
1301
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001302static VkShader demo_prepare_fs(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001303{
Cody Northrop1fedb212015-05-28 11:27:16 -06001304 if (!demo->use_glsl) {
1305 void *fragShaderCode;
1306 size_t size;
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001307
Cody Northrop1fedb212015-05-28 11:27:16 -06001308 fragShaderCode = demo_read_spv("cube-frag.spv", &size);
Courtney Goeltzenleuchter97db1c12014-10-30 15:14:16 -06001309
Cody Northrop1fedb212015-05-28 11:27:16 -06001310 return demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT,
1311 fragShaderCode, size);
1312 } else {
1313 static const char *fragShaderText =
1314 "#version 140\n"
1315 "#extension GL_ARB_separate_shader_objects : enable\n"
1316 "#extension GL_ARB_shading_language_420pack : enable\n"
1317 "layout (binding = 1) uniform sampler2D tex;\n"
1318 "\n"
1319 "layout (location = 0) in vec4 texcoord;\n"
1320 "layout (location = 0) out vec4 uFragColor;\n"
1321 "void main() {\n"
1322 " uFragColor = texture(tex, texcoord.xy);\n"
1323 "}\n";
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001324
Cody Northrop1fedb212015-05-28 11:27:16 -06001325 return demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT,
1326 (const void *) fragShaderText,
1327 strlen(fragShaderText));
1328 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001329}
1330
1331static void demo_prepare_pipeline(struct demo *demo)
1332{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001333 VkGraphicsPipelineCreateInfo pipeline;
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001334
1335 VkPipelineVertexInputStateCreateInfo vi;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001336 VkPipelineIaStateCreateInfo ia;
1337 VkPipelineRsStateCreateInfo rs;
1338 VkPipelineCbStateCreateInfo cb;
1339 VkPipelineDsStateCreateInfo ds;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001340 VkPipelineVpStateCreateInfo vp;
1341 VkPipelineMsStateCreateInfo ms;
Tony Barbourfdc2d352015-04-22 09:02:32 -06001342 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001343
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001344 memset(&vi, 0, sizeof(vi));
1345
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001346 memset(&pipeline, 0, sizeof(pipeline));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001347 pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
Mark Lobodzinski1cfc7722015-04-17 14:11:39 -05001348 pipeline.layout = demo->pipeline_layout;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001349
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001350 memset(&ia, 0, sizeof(ia));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001351 ia.sType = VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO;
Tony Barbour72304ef2015-04-16 15:59:00 -06001352 ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001353
1354 memset(&rs, 0, sizeof(rs));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001355 rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO;
Tony Barbour72304ef2015-04-16 15:59:00 -06001356 rs.fillMode = VK_FILL_MODE_SOLID;
1357 rs.cullMode = VK_CULL_MODE_BACK;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001358 rs.frontFace = VK_FRONT_FACE_CCW;
Chia-I Wubb67e6e2015-04-22 14:20:52 +08001359 rs.depthClipEnable = VK_TRUE;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001360
1361 memset(&cb, 0, sizeof(cb));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001362 cb.sType = VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001363 VkPipelineCbAttachmentState att_state[1];
Tony Barbour29645d02015-01-16 14:27:35 -07001364 memset(att_state, 0, sizeof(att_state));
1365 att_state[0].format = demo->format;
1366 att_state[0].channelWriteMask = 0xf;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001367 att_state[0].blendEnable = VK_FALSE;
Tony Barbour29645d02015-01-16 14:27:35 -07001368 cb.attachmentCount = 1;
1369 cb.pAttachments = att_state;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001370
Tony Barbour29645d02015-01-16 14:27:35 -07001371 memset(&vp, 0, sizeof(vp));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001372 vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VP_STATE_CREATE_INFO;
Tony Barbour72304ef2015-04-16 15:59:00 -06001373 vp.viewportCount = 1;
Tony Barbour29645d02015-01-16 14:27:35 -07001374
1375 memset(&ds, 0, sizeof(ds));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001376 ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
Tony Barbour29645d02015-01-16 14:27:35 -07001377 ds.format = demo->depth.format;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001378 ds.depthTestEnable = VK_TRUE;
1379 ds.depthWriteEnable = VK_TRUE;
Tony Barbour72304ef2015-04-16 15:59:00 -06001380 ds.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001381 ds.depthBoundsEnable = VK_FALSE;
1382 ds.back.stencilFailOp = VK_STENCIL_OP_KEEP;
1383 ds.back.stencilPassOp = VK_STENCIL_OP_KEEP;
Tony Barbour72304ef2015-04-16 15:59:00 -06001384 ds.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001385 ds.stencilTestEnable = VK_FALSE;
Tony Barbour29645d02015-01-16 14:27:35 -07001386 ds.front = ds.back;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001387
Tony Barbour29645d02015-01-16 14:27:35 -07001388 memset(&ms, 0, sizeof(ms));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001389 ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO;
Tony Barbour29645d02015-01-16 14:27:35 -07001390 ms.sampleMask = 1;
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001391 ms.multisampleEnable = VK_FALSE;
Tony Barbour29645d02015-01-16 14:27:35 -07001392 ms.samples = 1;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001393
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001394 // Two stages: vs and fs
1395 pipeline.stageCount = 2;
1396 VkPipelineShaderStageCreateInfo shaderStages[2];
1397 memset(&shaderStages, 0, 2 * sizeof(VkPipelineShaderStageCreateInfo));
1398
1399 shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
1400 shaderStages[0].stage = VK_SHADER_STAGE_VERTEX;
1401 shaderStages[0].shader = demo_prepare_vs(demo);
1402
1403 shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
1404 shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT;
1405 shaderStages[1].shader = demo_prepare_fs(demo);
1406
1407 pipeline.pVertexInputState = &vi;
1408 pipeline.pIaState = &ia;
1409 pipeline.pRsState = &rs;
1410 pipeline.pCbState = &cb;
1411 pipeline.pMsState = &ms;
1412 pipeline.pVpState = &vp;
1413 pipeline.pDsState = &ds;
1414 pipeline.pStages = shaderStages;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001415
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001416 err = vkCreateGraphicsPipeline(demo->device, &pipeline, &demo->pipeline);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001417 assert(!err);
1418
Mark Lobodzinski521d7762015-06-23 15:11:57 -06001419 for (uint32_t i = 0; i < pipeline.stageCount; i++) {
1420 vkDestroyObject(demo->device, VK_OBJECT_TYPE_SHADER, shaderStages[i].shader);
1421 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001422}
1423
1424static void demo_prepare_dynamic_states(struct demo *demo)
1425{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001426 VkDynamicVpStateCreateInfo viewport_create;
1427 VkDynamicRsStateCreateInfo raster;
1428 VkDynamicCbStateCreateInfo color_blend;
1429 VkDynamicDsStateCreateInfo depth_stencil;
Tony Barbourfdc2d352015-04-22 09:02:32 -06001430 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001431
Tony Barbour29645d02015-01-16 14:27:35 -07001432 memset(&viewport_create, 0, sizeof(viewport_create));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001433 viewport_create.sType = VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
Courtney Goeltzenleuchter1710d8d2015-02-11 14:13:34 -07001434 viewport_create.viewportAndScissorCount = 1;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001435 VkViewport viewport;
Piers Daniell735ee532015-02-23 16:23:13 -07001436 memset(&viewport, 0, sizeof(viewport));
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001437 viewport.height = (float) demo->height;
1438 viewport.width = (float) demo->width;
1439 viewport.minDepth = (float) 0.0f;
1440 viewport.maxDepth = (float) 1.0f;
Piers Daniell735ee532015-02-23 16:23:13 -07001441 viewport_create.pViewports = &viewport;
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001442 VkRect scissor;
Piers Daniell735ee532015-02-23 16:23:13 -07001443 memset(&scissor, 0, sizeof(scissor));
Courtney Goeltzenleuchter1710d8d2015-02-11 14:13:34 -07001444 scissor.extent.width = demo->width;
1445 scissor.extent.height = demo->height;
1446 scissor.offset.x = 0;
1447 scissor.offset.y = 0;
Courtney Goeltzenleuchter1710d8d2015-02-11 14:13:34 -07001448 viewport_create.pScissors = &scissor;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001449
1450 memset(&raster, 0, sizeof(raster));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001451 raster.sType = VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
Piers Daniell735ee532015-02-23 16:23:13 -07001452 raster.lineWidth = 1.0;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001453
1454 memset(&color_blend, 0, sizeof(color_blend));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001455 color_blend.sType = VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
Piers Daniell735ee532015-02-23 16:23:13 -07001456 color_blend.blendConst[0] = 1.0f;
1457 color_blend.blendConst[1] = 1.0f;
1458 color_blend.blendConst[2] = 1.0f;
1459 color_blend.blendConst[3] = 1.0f;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001460
1461 memset(&depth_stencil, 0, sizeof(depth_stencil));
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001462 depth_stencil.sType = VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
Mark Lobodzinski89d32b12015-06-12 11:14:17 -06001463 depth_stencil.minDepthBounds = 0.0f;
1464 depth_stencil.maxDepthBounds = 1.0f;
Tony Barbour29645d02015-01-16 14:27:35 -07001465 depth_stencil.stencilBackRef = 0;
1466 depth_stencil.stencilFrontRef = 0;
1467 depth_stencil.stencilReadMask = 0xff;
1468 depth_stencil.stencilWriteMask = 0xff;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001469
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001470 err = vkCreateDynamicViewportState(demo->device, &viewport_create, &demo->viewport);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001471 assert(!err);
1472
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001473 err = vkCreateDynamicRasterState(demo->device, &raster, &demo->raster);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001474 assert(!err);
1475
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001476 err = vkCreateDynamicColorBlendState(demo->device,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001477 &color_blend, &demo->color_blend);
1478 assert(!err);
1479
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001480 err = vkCreateDynamicDepthStencilState(demo->device,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001481 &depth_stencil, &demo->depth_stencil);
1482 assert(!err);
1483}
1484
Chia-I Wu63ea9262015-03-26 13:14:16 +08001485static void demo_prepare_descriptor_pool(struct demo *demo)
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001486{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001487 const VkDescriptorTypeCount type_counts[2] = {
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001488 [0] = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001489 .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001490 .count = 1,
1491 },
1492 [1] = {
Courtney Goeltzenleuchter42a078d2015-04-15 15:29:59 -06001493 .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001494 .count = DEMO_TEXTURE_COUNT,
1495 },
1496 };
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001497 const VkDescriptorPoolCreateInfo descriptor_pool = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001498 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001499 .pNext = NULL,
1500 .count = 2,
1501 .pTypeCount = type_counts,
1502 };
Tony Barbourfdc2d352015-04-22 09:02:32 -06001503 VkResult U_ASSERT_ONLY err;
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001504
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001505 err = vkCreateDescriptorPool(demo->device,
1506 VK_DESCRIPTOR_POOL_USAGE_ONE_SHOT, 1,
Chia-I Wu63ea9262015-03-26 13:14:16 +08001507 &descriptor_pool, &demo->desc_pool);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001508 assert(!err);
1509}
1510
1511static void demo_prepare_descriptor_set(struct demo *demo)
1512{
Chia-I Wuae721ba2015-05-25 16:27:55 +08001513 VkDescriptorInfo tex_descs[DEMO_TEXTURE_COUNT];
1514 VkWriteDescriptorSet writes[2];
Tony Barbourfdc2d352015-04-22 09:02:32 -06001515 VkResult U_ASSERT_ONLY err;
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001516 uint32_t count;
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001517 uint32_t i;
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001518
Mike Stroyanebae8322015-04-17 12:36:38 -06001519 err = vkAllocDescriptorSets(demo->device, demo->desc_pool,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001520 VK_DESCRIPTOR_SET_USAGE_STATIC,
Chia-I Wu87544e72015-02-23 10:41:08 -07001521 1, &demo->desc_layout,
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001522 &demo->desc_set, &count);
1523 assert(!err && count == 1);
1524
Chia-I Wuae721ba2015-05-25 16:27:55 +08001525 memset(&tex_descs, 0, sizeof(tex_descs));
1526 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
1527 tex_descs[i].sampler = demo->textures[i].sampler;
1528 tex_descs[i].imageView = demo->textures[i].view;
1529 tex_descs[i].imageLayout = VK_IMAGE_LAYOUT_GENERAL;
1530 }
1531
1532 memset(&writes, 0, sizeof(writes));
1533
1534 writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
1535 writes[0].destSet = demo->desc_set;
1536 writes[0].count = 1;
1537 writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
1538 writes[0].pDescriptors = &demo->uniform_data.desc;
1539
1540 writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
1541 writes[1].destSet = demo->desc_set;
1542 writes[1].destBinding = 1;
1543 writes[1].count = DEMO_TEXTURE_COUNT;
1544 writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
1545 writes[1].pDescriptors = tex_descs;
1546
1547 err = vkUpdateDescriptorSets(demo->device, 2, writes, 0, NULL);
1548 assert(!err);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001549}
1550
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001551static void demo_prepare(struct demo *demo)
1552{
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001553 const VkCmdBufferCreateInfo cmd = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001554 .sType = VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001555 .pNext = NULL,
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07001556 .queueNodeIndex = demo->graphics_queue_node_index,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001557 .flags = 0,
1558 };
Tony Barbourfdc2d352015-04-22 09:02:32 -06001559 VkResult U_ASSERT_ONLY err;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001560
1561 demo_prepare_buffers(demo);
1562 demo_prepare_depth(demo);
1563 demo_prepare_textures(demo);
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001564 demo_prepare_cube_data_buffer(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001565
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001566 demo_prepare_descriptor_layout(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001567 demo_prepare_pipeline(demo);
1568 demo_prepare_dynamic_states(demo);
1569
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001570 for (int i = 0; i < DEMO_BUFFER_COUNT; i++) {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001571 err = vkCreateCommandBuffer(demo->device, &cmd, &demo->buffers[i].cmd);
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001572 assert(!err);
1573 }
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001574
Chia-I Wu63ea9262015-03-26 13:14:16 +08001575 demo_prepare_descriptor_pool(demo);
Chia-I Wu6a3c8972015-01-04 16:27:24 +08001576 demo_prepare_descriptor_set(demo);
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001577
1578
1579 for (int i = 0; i < DEMO_BUFFER_COUNT; i++) {
1580 demo->current_buffer = i;
1581 demo_draw_build_cmd(demo, demo->buffers[i].cmd);
1582 }
1583
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001584 /*
1585 * Prepare functions above may generate pipeline commands
1586 * that need to be flushed before beginning the render loop.
1587 */
1588 demo_flush_init_cmd(demo);
1589
Courtney Goeltzenleuchterefc58ae2015-02-17 09:48:44 -07001590 demo->current_buffer = 0;
Jon Ashburn8d26c062015-04-24 09:46:24 -07001591 demo->prepared = true;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001592}
1593
David Pinedo2bb7c932015-06-18 17:03:14 -06001594static void demo_cleanup(struct demo *demo)
1595{
1596 uint32_t i;
1597
1598 demo->prepared = false;
1599
1600 vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_SET, demo->desc_set);
1601 vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_POOL, demo->desc_pool);
1602
1603 vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_VP_STATE, demo->viewport);
1604 vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_RS_STATE, demo->raster);
1605 vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_CB_STATE, demo->color_blend);
1606 vkDestroyObject(demo->device, VK_OBJECT_TYPE_DYNAMIC_DS_STATE, demo->depth_stencil);
1607
1608 vkDestroyObject(demo->device, VK_OBJECT_TYPE_PIPELINE, demo->pipeline);
1609 vkDestroyObject(demo->device, VK_OBJECT_TYPE_PIPELINE_LAYOUT, demo->pipeline_layout);
1610 vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, demo->desc_layout);
1611
1612 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
1613 vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE_VIEW, demo->textures[i].view);
1614 vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image);
1615 vkFreeMemory(demo->device, demo->textures[i].mem);
1616 vkDestroyObject(demo->device, VK_OBJECT_TYPE_SAMPLER, demo->textures[i].sampler);
1617 }
1618 demo->fpDestroySwapChainWSI(demo->swap_chain);
1619
1620 vkDestroyObject(demo->device, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW, demo->depth.view);
1621 vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image);
1622 vkFreeMemory(demo->device, demo->depth.mem);
1623
1624 vkDestroyObject(demo->device, VK_OBJECT_TYPE_BUFFER_VIEW, demo->uniform_data.view);
1625 vkDestroyObject(demo->device, VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf);
1626 vkFreeMemory(demo->device, demo->uniform_data.mem);
1627
1628 for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
1629 vkDestroyObject(demo->device, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, demo->buffers[i].view);
1630 vkDestroyObject(demo->device, VK_OBJECT_TYPE_COMMAND_BUFFER, demo->buffers[i].cmd);
1631 }
1632
1633 vkDestroyDevice(demo->device);
1634 vkDestroyInstance(demo->inst);
1635
1636#ifndef _WIN32
1637 xcb_destroy_window(demo->connection, demo->window);
1638 xcb_disconnect(demo->connection);
1639#endif // _WIN32
1640}
1641
1642// On MS-Windows, make this a global, so it's available to WndProc()
1643struct demo demo;
1644
Ian Elliott639ca472015-04-16 15:23:05 -06001645#ifdef _WIN32
1646static void demo_run(struct demo *demo)
1647{
Courtney Goeltzenleuchterb7e22702015-04-27 14:56:34 -06001648 if (!demo->prepared)
1649 return;
Ian Elliott639ca472015-04-16 15:23:05 -06001650 // Wait for work to finish before updating MVP.
1651 vkDeviceWaitIdle(demo->device);
1652 demo_update_data_buffer(demo);
1653
1654 demo_draw(demo);
1655
1656 // Wait for work to finish before updating MVP.
1657 vkDeviceWaitIdle(demo->device);
Ian Elliott639ca472015-04-16 15:23:05 -06001658
David Pinedo2bb7c932015-06-18 17:03:14 -06001659 demo->curFrame++;
1660
1661 if (demo->frameCount != INT_MAX && demo->curFrame == demo->frameCount)
1662 {
1663 demo->quit=true;
1664 demo_cleanup(demo);
1665 ExitProcess(0);
1666 }
1667
1668}
Ian Elliott639ca472015-04-16 15:23:05 -06001669
1670// MS-Windows event handling function:
1671LRESULT CALLBACK WndProc(HWND hWnd,
1672 UINT uMsg,
1673 WPARAM wParam,
1674 LPARAM lParam)
1675{
Ian Elliott639ca472015-04-16 15:23:05 -06001676 switch(uMsg)
1677 {
Ian Elliott639ca472015-04-16 15:23:05 -06001678 case WM_CLOSE:
1679 PostQuitMessage(0);
Tony Barbour3dddd5d2015-04-29 16:19:20 -06001680 break;
Ian Elliott639ca472015-04-16 15:23:05 -06001681 case WM_PAINT:
1682 demo_run(&demo);
1683 return 0;
1684 default:
1685 break;
1686 }
1687 return (DefWindowProc(hWnd, uMsg, wParam, lParam));
1688}
1689
1690static void demo_create_window(struct demo *demo)
1691{
1692 WNDCLASSEX win_class;
1693
1694 // Initialize the window class structure:
1695 win_class.cbSize = sizeof(WNDCLASSEX);
1696 win_class.style = CS_HREDRAW | CS_VREDRAW;
1697 win_class.lpfnWndProc = WndProc;
1698 win_class.cbClsExtra = 0;
1699 win_class.cbWndExtra = 0;
1700 win_class.hInstance = demo->connection; // hInstance
1701 win_class.hIcon = LoadIcon(NULL, IDI_APPLICATION);
1702 win_class.hCursor = LoadCursor(NULL, IDC_ARROW);
1703 win_class.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
1704 win_class.lpszMenuName = NULL;
1705 win_class.lpszClassName = demo->name;
1706 win_class.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
1707 // Register window class:
1708 if (!RegisterClassEx(&win_class)) {
1709 // It didn't work, so try to give a useful error:
1710 printf("Unexpected error trying to start the application!\n");
1711 fflush(stdout);
1712 exit(1);
1713 }
1714 // Create window with the registered class:
Mike Stroyanb46779e2015-06-15 14:20:13 -06001715 RECT wr = { 0, 0, demo->width, demo->height };
1716 AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
Ian Elliott639ca472015-04-16 15:23:05 -06001717 demo->window = CreateWindowEx(0,
1718 demo->name, // class name
1719 demo->name, // app name
1720 WS_OVERLAPPEDWINDOW | // window style
1721 WS_VISIBLE |
1722 WS_SYSMENU,
1723 100,100, // x/y coords
Mike Stroyanb46779e2015-06-15 14:20:13 -06001724 wr.right-wr.left, // width
1725 wr.bottom-wr.top, // height
Ian Elliott639ca472015-04-16 15:23:05 -06001726 NULL, // handle to parent
1727 NULL, // handle to menu
1728 demo->connection, // hInstance
1729 NULL); // no extra parameters
1730 if (!demo->window) {
1731 // It didn't work, so try to give a useful error:
1732 printf("Cannot create a window in which to draw!\n");
1733 fflush(stdout);
1734 exit(1);
1735 }
1736}
1737#else // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001738static void demo_handle_event(struct demo *demo,
1739 const xcb_generic_event_t *event)
1740{
Piers Daniell735ee532015-02-23 16:23:13 -07001741 uint8_t event_code = event->response_type & 0x7f;
Courtney Goeltzenleuchter98cb2cb2014-11-06 14:27:52 -07001742 switch (event_code) {
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001743 case XCB_EXPOSE:
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07001744 // TODO: Resize window
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001745 break;
Courtney Goeltzenleuchter98cb2cb2014-11-06 14:27:52 -07001746 case XCB_CLIENT_MESSAGE:
1747 if((*(xcb_client_message_event_t*)event).data.data32[0] ==
1748 (*demo->atom_wm_delete_window).atom) {
1749 demo->quit = true;
1750 }
1751 break;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001752 case XCB_KEY_RELEASE:
1753 {
1754 const xcb_key_release_event_t *key =
1755 (const xcb_key_release_event_t *) event;
1756
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001757 switch (key->detail) {
1758 case 0x9: // Escape
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001759 demo->quit = true;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001760 break;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001761 case 0x71: // left arrow key
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001762 demo->spin_angle += demo->spin_increment;
Courtney Goeltzenleuchter4984d152014-10-28 14:50:30 -06001763 break;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001764 case 0x72: // right arrow key
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001765 demo->spin_angle -= demo->spin_increment;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001766 break;
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06001767 case 0x41:
1768 demo->pause = !demo->pause;
Piers Daniell735ee532015-02-23 16:23:13 -07001769 break;
Courtney Goeltzenleuchterfc3b9532014-10-28 10:32:57 -06001770 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001771 }
1772 break;
1773 default:
1774 break;
1775 }
1776}
1777
1778static void demo_run(struct demo *demo)
1779{
1780 xcb_flush(demo->connection);
1781
1782 while (!demo->quit) {
1783 xcb_generic_event_t *event;
1784
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07001785 if (demo->pause) {
1786 event = xcb_wait_for_event(demo->connection);
1787 } else {
1788 event = xcb_poll_for_event(demo->connection);
1789 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001790 if (event) {
1791 demo_handle_event(demo, event);
1792 free(event);
Courtney Goeltzenleuchter98085552014-11-10 11:13:13 -07001793 }
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07001794
1795 // Wait for work to finish before updating MVP.
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001796 vkDeviceWaitIdle(demo->device);
Courtney Goeltzenleuchterc465d6c2014-11-18 11:28:09 -07001797 demo_update_data_buffer(demo);
1798
Courtney Goeltzenleuchter98085552014-11-10 11:13:13 -07001799 demo_draw(demo);
Courtney Goeltzenleuchter1454f3c2014-11-18 11:28:09 -07001800
Courtney Goeltzenleuchter98085552014-11-10 11:13:13 -07001801 // Wait for work to finish before updating MVP.
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001802 vkDeviceWaitIdle(demo->device);
David Pinedo2bb7c932015-06-18 17:03:14 -06001803 demo->curFrame++;
1804 if (demo->frameCount != INT_MAX && demo->curFrame == demo->frameCount)
1805 demo->quit = true;
1806
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001807 }
1808}
1809
1810static void demo_create_window(struct demo *demo)
1811{
1812 uint32_t value_mask, value_list[32];
1813
1814 demo->window = xcb_generate_id(demo->connection);
1815
1816 value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
1817 value_list[0] = demo->screen->black_pixel;
1818 value_list[1] = XCB_EVENT_MASK_KEY_RELEASE |
1819 XCB_EVENT_MASK_EXPOSURE;
1820
1821 xcb_create_window(demo->connection,
1822 XCB_COPY_FROM_PARENT,
1823 demo->window, demo->screen->root,
1824 0, 0, demo->width, demo->height, 0,
1825 XCB_WINDOW_CLASS_INPUT_OUTPUT,
1826 demo->screen->root_visual,
1827 value_mask, value_list);
1828
Courtney Goeltzenleuchter98cb2cb2014-11-06 14:27:52 -07001829 /* Magic code that will send notification when window is destroyed */
1830 xcb_intern_atom_cookie_t cookie = xcb_intern_atom(demo->connection, 1, 12,
1831 "WM_PROTOCOLS");
1832 xcb_intern_atom_reply_t* reply = xcb_intern_atom_reply(demo->connection, cookie, 0);
1833
1834 xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(demo->connection, 0, 16, "WM_DELETE_WINDOW");
1835 demo->atom_wm_delete_window = xcb_intern_atom_reply(demo->connection, cookie2, 0);
1836
1837 xcb_change_property(demo->connection, XCB_PROP_MODE_REPLACE,
1838 demo->window, (*reply).atom, 4, 32, 1,
1839 &(*demo->atom_wm_delete_window).atom);
1840 free(reply);
1841
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001842 xcb_map_window(demo->connection, demo->window);
David Pinedo2bb7c932015-06-18 17:03:14 -06001843
1844 // Force the x/y coordinates to 100,100 results are identical in consecutive runs
1845 const uint32_t coords[] = {100, 100};
1846 xcb_configure_window(demo->connection, demo->window,
1847 XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, coords);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001848}
Ian Elliott639ca472015-04-16 15:23:05 -06001849#endif // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001850
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001851static void demo_init_vk(struct demo *demo)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001852{
Tobin Ehlis99239dc2015-04-16 18:04:57 -06001853 VkResult err;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001854 VkExtensionProperties *instance_extensions;
1855 uint32_t instance_extension_count = 0;
1856 VkExtensionProperties *device_extensions;
1857 uint32_t device_extension_count = 0;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001858 uint32_t total_extension_count = 0;
Tony Barbourecf1b2b2015-06-24 16:06:58 -06001859 err = vkGetGlobalExtensionCount(&total_extension_count);
Tobin Ehlis99239dc2015-04-16 18:04:57 -06001860 assert(!err);
1861
1862 VkExtensionProperties extProp;
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001863 bool32_t WSIextFound = 0;
1864 instance_extensions = malloc(sizeof(VkExtensionProperties) * total_extension_count);
1865 device_extensions = malloc(sizeof(VkExtensionProperties) * total_extension_count);
1866 for (uint32_t i = 0; i < total_extension_count; i++) {
Tony Barbourecf1b2b2015-06-24 16:06:58 -06001867 err = vkGetGlobalExtensionProperties(i, &extProp);
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001868 if (!strcmp("VK_WSI_LunarG", extProp.name)) {
1869 WSIextFound = 1;
1870 memcpy(&instance_extensions[instance_extension_count++], &extProp, sizeof(VkExtensionProperties));
1871 memcpy(&device_extensions[device_extension_count++], &extProp, sizeof(VkExtensionProperties));
1872 }
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001873 if (!strcmp(DEBUG_REPORT_EXTENSION_NAME, extProp.name)) {
1874 memcpy(&instance_extensions[instance_extension_count++], &extProp, sizeof(VkExtensionProperties));
1875 }
Tobin Ehlis99239dc2015-04-16 18:04:57 -06001876 }
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001877 if (!WSIextFound) {
Tony Barbourecf1b2b2015-06-24 16:06:58 -06001878 ERR_EXIT("vkGetGlobalExtensionProperties failed to find the "
Ian Elliott65152912015-04-28 13:22:33 -06001879 "\"VK_WSI_LunarG\" extension.\n\nDo you have a compatible "
1880 "Vulkan installable client driver (ICD) installed?\nPlease "
1881 "look at the Getting Started guide for additional "
1882 "information.\n",
1883 "vkCreateInstance Failure");
1884 }
Courtney Goeltzenleuchter78351a62015-04-10 08:34:15 -06001885 const VkApplicationInfo app = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001886 .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001887 .pNext = NULL,
Ian Elliott44e33f72015-04-28 10:52:52 -06001888 .pAppName = APP_SHORT_NAME,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001889 .appVersion = 0,
Ian Elliott44e33f72015-04-28 10:52:52 -06001890 .pEngineName = APP_SHORT_NAME,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001891 .engineVersion = 0,
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001892 .apiVersion = VK_API_VERSION,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001893 };
Tony Barbour3dddd5d2015-04-29 16:19:20 -06001894 VkInstanceCreateInfo inst_info = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001895 .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
Jon Ashburnab46b362015-04-04 14:52:07 -06001896 .pNext = NULL,
1897 .pAppInfo = &app,
1898 .pAllocCb = NULL,
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001899 .extensionCount = instance_extension_count,
1900 .pEnabledExtensions = instance_extensions,
Jon Ashburnab46b362015-04-04 14:52:07 -06001901 };
Courtney Goeltzenleuchter28c4d5f2015-04-14 18:48:46 -06001902 const VkDeviceQueueCreateInfo queue = {
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001903 .queueNodeIndex = 0,
1904 .queueCount = 1,
1905 };
Ian Elliott097d9f32015-04-28 11:35:02 -06001906
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001907 VkDeviceCreateInfo device = {
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001908 .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001909 .pNext = NULL,
1910 .queueRecordCount = 1,
1911 .pRequestedQueues = &queue,
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001912 .extensionCount = device_extension_count,
1913 .pEnabledExtensions = device_extensions,
Jon Ashburn7842d522015-05-18 09:06:15 -06001914 .flags = 0,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001915 };
Mark Lobodzinskic4fffc72015-01-29 08:55:56 -06001916 uint32_t gpu_count;
1917 uint32_t i;
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07001918 uint32_t queue_count;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001919
Tony Barbour3dddd5d2015-04-29 16:19:20 -06001920 if (demo->validate) {
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001921 inst_info.extensionCount = 3;
1922 device.extensionCount = 3;
Tony Barbour3dddd5d2015-04-29 16:19:20 -06001923 }
1924
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001925 err = vkCreateInstance(&inst_info, &demo->inst);
Ian Elliott07264132015-04-28 11:35:02 -06001926 if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
1927 ERR_EXIT("Cannot find a compatible Vulkan installable client driver "
Ian Elliott65152912015-04-28 13:22:33 -06001928 "(ICD).\n\nPlease look at the Getting Started guide for "
Ian Elliott07264132015-04-28 11:35:02 -06001929 "additional information.\n",
1930 "vkCreateInstance Failure");
Tony Barbour3dddd5d2015-04-29 16:19:20 -06001931 } else if (err == VK_ERROR_INVALID_EXTENSION) {
1932 ERR_EXIT("Cannot find a specified extension library"
1933 ".\nMake sure your layers path is set appropriately\n",
1934 "vkCreateInstance Failure");
Ian Elliott07264132015-04-28 11:35:02 -06001935 } else if (err) {
Ian Elliott65152912015-04-28 13:22:33 -06001936 ERR_EXIT("vkCreateInstance failed.\n\nDo you have a compatible Vulkan "
1937 "installable client driver (ICD) installed?\nPlease look at "
Ian Elliott07264132015-04-28 11:35:02 -06001938 "the Getting Started guide for additional information.\n",
1939 "vkCreateInstance Failure");
Ian Elliott3979e282015-04-03 15:24:55 -06001940 }
Jon Ashburnab46b362015-04-04 14:52:07 -06001941
Tony Barbour3dddd5d2015-04-29 16:19:20 -06001942
Jon Ashburn07c0c0c2015-04-15 11:31:12 -06001943 gpu_count = 1;
1944 err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, &demo->gpu);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001945 assert(!err && gpu_count == 1);
1946
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001947
Tony Barbour3dddd5d2015-04-29 16:19:20 -06001948 if (demo->validate) {
Courtney Goeltzenleuchter922a0fa2015-06-10 17:39:03 -06001949 demo->dbgCreateMsgCallback = vkGetInstanceProcAddr((VkPhysicalDevice) NULL, "vkDbgCreateMsgCallback");
1950 if (!demo->dbgCreateMsgCallback) {
1951 ERR_EXIT("GetProcAddr: Unable to find vkDbgCreateMsgCallback\n",
1952 "vkGetProcAddr Failure");
1953 }
1954 err = demo->dbgCreateMsgCallback(
1955 demo->inst,
1956 VK_DBG_REPORT_ERROR_BIT | VK_DBG_REPORT_WARN_BIT,
1957 dbgFunc, NULL,
1958 &demo->msg_callback);
1959 switch (err) {
1960 case VK_SUCCESS:
1961 break;
1962 case VK_ERROR_INVALID_POINTER:
1963 ERR_EXIT("dbgCreateMsgCallback: Invalid pointer\n",
1964 "dbgCreateMsgCallback Failure");
1965 break;
1966 case VK_ERROR_OUT_OF_HOST_MEMORY:
1967 ERR_EXIT("dbgCreateMsgCallback: out of host memory\n",
1968 "dbgCreateMsgCallback Failure");
1969 break;
1970 default:
1971 ERR_EXIT("dbgCreateMsgCallback: unknown failure\n",
1972 "dbgCreateMsgCallback Failure");
1973 break;
1974 }
Tony Barbour3dddd5d2015-04-29 16:19:20 -06001975 }
1976
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06001977 err = vkCreateDevice(demo->gpu, &device, &demo->device);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06001978 assert(!err);
1979
Ian Elliott673898b2015-06-22 15:07:49 -06001980 GET_DEVICE_PROC_ADDR(demo->device, CreateSwapChainWSI);
1981 GET_DEVICE_PROC_ADDR(demo->device, CreateSwapChainWSI);
1982 GET_DEVICE_PROC_ADDR(demo->device, DestroySwapChainWSI);
1983 GET_DEVICE_PROC_ADDR(demo->device, GetSwapChainInfoWSI);
1984 GET_DEVICE_PROC_ADDR(demo->device, QueuePresentWSI);
Jon Ashburn0b85d052015-05-21 18:13:33 -06001985
Tony Barbourecf1b2b2015-06-24 16:06:58 -06001986 err = vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001987 assert(!err);
1988
Tony Barbourecf1b2b2015-06-24 16:06:58 -06001989 err = vkGetPhysicalDeviceQueueCount(demo->gpu, &queue_count);
Courtney Goeltzenleuchter752eb8e2015-03-25 13:36:41 -06001990 assert(!err);
1991
Tony Barbourecf1b2b2015-06-24 16:06:58 -06001992 demo->queue_props = (VkPhysicalDeviceQueueProperties *) malloc(queue_count * sizeof(VkPhysicalDeviceQueueProperties));
1993 err = vkGetPhysicalDeviceQueueProperties(demo->gpu, queue_count, demo->queue_props);
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07001994 assert(!err);
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07001995 assert(queue_count >= 1);
1996
Mark Lobodzinskida9b1092015-04-16 11:44:05 -05001997 // Graphics queue and MemMgr queue can be separate.
1998 // TODO: Add support for separate queues, including synchronization,
Mark Lobodzinski6baaec72015-05-11 17:21:15 -05001999 // and appropriate tracking for QueueSubmit
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07002000 for (i = 0; i < queue_count; i++) {
Mark Lobodzinski6baaec72015-05-11 17:21:15 -05002001 if (demo->queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
Courtney Goeltzenleuchtered667a52015-03-05 18:09:39 -07002002 break;
2003 }
2004 assert(i < queue_count);
2005 demo->graphics_queue_node_index = i;
2006
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002007 err = vkGetDeviceQueue(demo->device, demo->graphics_queue_node_index,
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002008 0, &demo->queue);
2009 assert(!err);
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002010
Jon Ashburnd7130cb2015-06-16 12:44:51 -06002011 // for now hardcode format till get WSI support
2012 demo->format = VK_FORMAT_B8G8R8A8_UNORM;
Ian Elliotte4602cd2015-04-21 16:41:02 -06002013
David Pinedo2bb7c932015-06-18 17:03:14 -06002014 demo->quit = false;
2015 demo->curFrame = 0;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002016}
2017
2018static void demo_init_connection(struct demo *demo)
2019{
Ian Elliott639ca472015-04-16 15:23:05 -06002020#ifndef _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002021 const xcb_setup_t *setup;
2022 xcb_screen_iterator_t iter;
2023 int scr;
2024
2025 demo->connection = xcb_connect(NULL, &scr);
Ian Elliott3979e282015-04-03 15:24:55 -06002026 if (demo->connection == NULL) {
2027 printf("Cannot find a compatible Vulkan installable client driver "
2028 "(ICD).\nExiting ...\n");
2029 fflush(stdout);
2030 exit(1);
2031 }
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002032
2033 setup = xcb_get_setup(demo->connection);
2034 iter = xcb_setup_roots_iterator(setup);
2035 while (scr-- > 0)
2036 xcb_screen_next(&iter);
2037
2038 demo->screen = iter.data;
Ian Elliott639ca472015-04-16 15:23:05 -06002039#endif // _WIN32
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002040}
2041
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002042static void demo_init(struct demo *demo, int argc, char **argv)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002043{
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002044 vec3 eye = {0.0f, 3.0f, 5.0f};
2045 vec3 origin = {0, 0, 0};
Chia-I Wuae3b55d2015-04-22 14:56:17 +08002046 vec3 up = {0.0f, 1.0f, 0.0};
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002047
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002048 memset(demo, 0, sizeof(*demo));
David Pinedo2bb7c932015-06-18 17:03:14 -06002049 demo->frameCount = INT_MAX;
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002050
Piers Daniell735ee532015-02-23 16:23:13 -07002051 for (int i = 1; i < argc; i++) {
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002052 if (strcmp(argv[i], "--use_staging") == 0) {
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002053 demo->use_staging_buffer = true;
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002054 continue;
Ian Elliott639ca472015-04-16 15:23:05 -06002055 }
Cody Northrop1fedb212015-05-28 11:27:16 -06002056 if (strcmp(argv[i], "--use_glsl") == 0) {
2057 demo->use_glsl = true;
2058 continue;
2059 }
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002060 if (strcmp(argv[i], "--validate") == 0) {
2061 demo->validate = true;
2062 continue;
2063 }
David Pinedo2bb7c932015-06-18 17:03:14 -06002064 if (strcmp(argv[i], "--c") == 0 &&
2065 demo->frameCount == INT_MAX &&
2066 i < argc-1 &&
2067 sscanf(argv[i+1],"%d", &demo->frameCount) == 1 &&
2068 demo->frameCount >= 0)
2069 {
2070 i++;
2071 continue;
2072 }
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002073
David Pinedo2bb7c932015-06-18 17:03:14 -06002074 fprintf(stderr, "Usage:\n %s [--use_staging] [--validate] [--c <framecount>]\n", APP_SHORT_NAME);
Ian Elliott639ca472015-04-16 15:23:05 -06002075 fflush(stderr);
2076 exit(1);
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002077 }
2078
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002079 demo_init_connection(demo);
Courtney Goeltzenleuchtera4131c42015-04-08 15:36:08 -06002080 demo_init_vk(demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002081
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002082 demo->width = 500;
2083 demo->height = 500;
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002084
2085 demo->spin_angle = 0.01f;
2086 demo->spin_increment = 0.01f;
2087 demo->pause = false;
2088
Piers Daniell735ee532015-02-23 16:23:13 -07002089 mat4x4_perspective(demo->projection_matrix, (float)degreesToRadians(45.0f), 1.0f, 0.1f, 100.0f);
Courtney Goeltzenleuchter8879d3a2014-10-29 08:29:35 -06002090 mat4x4_look_at(demo->view_matrix, eye, origin, up);
2091 mat4x4_identity(demo->model_matrix);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002092}
2093
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002094
Ian Elliott639ca472015-04-16 15:23:05 -06002095#ifdef _WIN32
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002096extern int __getmainargs(
2097 int * _Argc,
2098 char *** _Argv,
2099 char *** _Env,
2100 int _DoWildCard,
2101 int * new_mode);
Ian Elliottf9cf78c2015-04-28 10:33:11 -06002102
Ian Elliotta748eaf2015-04-28 15:50:36 -06002103int WINAPI WinMain(HINSTANCE hInstance,
2104 HINSTANCE hPrevInstance,
2105 LPSTR pCmdLine,
2106 int nCmdShow)
Ian Elliott639ca472015-04-16 15:23:05 -06002107{
2108 MSG msg; // message
2109 bool done; // flag saying when app is complete
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002110 int argc;
2111 char** argv;
2112 char** env;
2113 int new_mode = 0;
Ian Elliott639ca472015-04-16 15:23:05 -06002114
Tony Barbour3dddd5d2015-04-29 16:19:20 -06002115 __getmainargs(&argc,&argv,&env,0,&new_mode);
2116
2117 demo_init(&demo, argc, argv);
2118 demo.connection = hInstance;
2119 strncpy(demo.name, "cube", APP_NAME_STR_LEN);
Ian Elliott639ca472015-04-16 15:23:05 -06002120 demo_create_window(&demo);
2121
2122 demo_prepare(&demo);
2123
2124 done = false; //initialize loop condition variable
2125 /* main message loop*/
2126 while(!done)
2127 {
Ian Elliotta748eaf2015-04-28 15:50:36 -06002128 PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
Ian Elliott639ca472015-04-16 15:23:05 -06002129 if (msg.message == WM_QUIT) //check for a quit message
2130 {
2131 done = true; //if found, quit app
2132 }
2133 else
2134 {
2135 /* Translate and dispatch to event queue*/
2136 TranslateMessage(&msg);
2137 DispatchMessage(&msg);
2138 }
2139 }
2140
2141 demo_cleanup(&demo);
2142
Tony Barbourf9921732015-04-22 11:36:22 -06002143 return (int) msg.wParam;
Ian Elliott639ca472015-04-16 15:23:05 -06002144}
2145#else // _WIN32
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002146int main(int argc, char **argv)
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002147{
2148 struct demo demo;
2149
Courtney Goeltzenleuchterb4fc0072015-02-17 12:54:31 -07002150 demo_init(&demo, argc, argv);
Chia-I Wucbb564e2015-04-16 22:02:10 +08002151 demo_create_window(&demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002152
2153 demo_prepare(&demo);
Courtney Goeltzenleuchter7be88a82014-10-23 13:16:59 -06002154 demo_run(&demo);
2155
2156 demo_cleanup(&demo);
2157
2158 return 0;
2159}
Ian Elliott639ca472015-04-16 15:23:05 -06002160#endif // _WIN32