{

this->settings.validation = enableValidation;

// Validation can also be forced via a define

#if defined(_VALIDATION)

this->settings.validation = true;

#endif

VkApplicationInfo appInfo = {};

appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;

appInfo.pApplicationName = name.c_str();

appInfo.pEngineName = name.c_str();

appInfo.apiVersion = VK_API_VERSION_1_0;

std::vector<const char*> instanceExtensions = { VK_KHR_SURFACE_EXTENSION_NAME };

// Enable surface extensions depending on os

#if defined(_WIN32)

instanceExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);

#elif defined(__ANDROID__)

instanceExtensions.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);

#elif defined(_DIRECT2DISPLAY)

instanceExtensions.push_back(VK_KHR_DISPLAY_EXTENSION_NAME);

#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)

instanceExtensions.push_back(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);

#elif defined(__linux__)

instanceExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);

#elif defined(VK_USE_PLATFORM_IOS_MVK)

instanceExtensions.push_back(VK_MVK_IOS_SURFACE_EXTENSION_NAME);

#elif defined(VK_USE_PLATFORM_MACOS_MVK)

instanceExtensions.push_back(VK_MVK_MACOS_SURFACE_EXTENSION_NAME);

#endif

VkInstanceCreateInfo instanceCreateInfo = {};

instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;

instanceCreateInfo.pNext = NULL;

instanceCreateInfo.pApplicationInfo = &appInfo;

if (instanceExtensions.size() > 0)

{

if (settings.validation)

{

instanceExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);

}

instanceCreateInfo.enabledExtensionCount = (uint32_t)instanceExtensions.size();

instanceCreateInfo.ppEnabledExtensionNames = instanceExtensions.data();

}

if (settings.validation)

{

instanceCreateInfo.enabledLayerCount = vks::debug::validationLayerCount;

instanceCreateInfo.ppEnabledLayerNames = vks::debug::validationLayerNames;

}

return vkCreateInstance(&instanceCreateInfo, nullptr, &instance);

{

std::string device(deviceProperties.deviceName);

std::string windowTitle;

windowTitle = title + " - " + device;

if (!enableTextOverlay)

{

windowTitle += " - " + std::to_string(frameCounter) + " fps";

}

return windowTitle;

{

#if defined(__ANDROID__)

return "";

#else

return "./../data/";

#endif

{

for (auto& cmdBuffer : drawCmdBuffers)

{

if (cmdBuffer == VK_NULL_HANDLE)

{

return false;

}

}

return true;

{

// Create one command buffer for each swap chain image and reuse for rendering

drawCmdBuffers.resize(swapChain.imageCount);

VkCommandBufferAllocateInfo cmdBufAllocateInfo =

vks::initializers::commandBufferAllocateInfo(

cmdPool,

VK_COMMAND_BUFFER_LEVEL_PRIMARY,

static_cast<uint32_t>(drawCmdBuffers.size()));

VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, drawCmdBuffers.data()));

{

VkCommandBuffer cmdBuffer;

VkCommandBufferAllocateInfo cmdBufAllocateInfo =

vks::initializers::commandBufferAllocateInfo(

cmdPool,

level,

1);

VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmdBufAllocateInfo, &cmdBuffer));

// If requested, also start the new command buffer

if (begin)

{

VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();

VK_CHECK_RESULT(vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo));

}

return cmdBuffer;

{

if (commandBuffer == VK_NULL_HANDLE)

{

return;

}

VK_CHECK_RESULT(vkEndCommandBuffer(commandBuffer));

VkSubmitInfo submitInfo = {};

submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;

submitInfo.commandBufferCount = 1;

submitInfo.pCommandBuffers = &commandBuffer;

VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));

VK_CHECK_RESULT(vkQueueWaitIdle(queue));

if (free)

{

vkFreeCommandBuffers(device, cmdPool, 1, &commandBuffer);

}

{

VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {};

pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;

VK_CHECK_RESULT(vkCreatePipelineCache(device, &pipelineCacheCreateInfo, nullptr, &pipelineCache));

{

if (vulkanDevice->enableDebugMarkers)

{

vks::debugmarker::setup(device);

}

createCommandPool();

setupSwapChain();

createCommandBuffers();

setupDepthStencil();

setupRenderPass();

createPipelineCache();

setupFrameBuffer();

if (enableTextOverlay)

{

// Load the text rendering shaders

std::vector<VkPipelineShaderStageCreateInfo> shaderStages;

shaderStages.push_back(loadShader(getAssetPath() + "shaders/base/textoverlay.vert.spv", VK_SHADER_STAGE_VERTEX_BIT));

shaderStages.push_back(loadShader(getAssetPath() + "shaders/base/textoverlay.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT));

textOverlay = new VulkanTextOverlay(

vulkanDevice,

queue,

frameBuffers,

swapChain.colorFormat,

depthFormat,

&width,

&height,

shaderStages

);

updateTextOverlay();

}

{

VkPipelineShaderStageCreateInfo shaderStage = {};

shaderStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;

shaderStage.stage = stage;

#if defined(__ANDROID__)

shaderStage.module = vks::tools::loadShader(androidApp->activity->assetManager, fileName.c_str(), device);

#else

shaderStage.module = vks::tools::loadShader(fileName.c_str(), device);

#endif

shaderStage.pName = "main"; // todo : make param

assert(shaderStage.module != VK_NULL_HANDLE);

shaderModules.push_back(shaderStage.module);

return shaderStage;

{

#if (defined(VK_USE_PLATFORM_IOS_MVK) || defined(VK_USE_PLATFORM_MACOS_MVK))

auto tStart = std::chrono::high_resolution_clock::now();

if (viewUpdated)

{

viewUpdated = false;

viewChanged();

}

render();

frameCounter++;

auto tEnd = std::chrono::high_resolution_clock::now();

auto tDiff = std::chrono::duration<double, std::milli>(tEnd - tStart).count();

frameTimer = tDiff / 1000.0f;

camera.update(frameTimer);

if (camera.moving())

{

viewUpdated = true;

}

// Convert to clamped timer value

if (!paused)

{

timer += timerSpeed * frameTimer;

if (timer > 1.0)

{

timer -= 1.0f;

}

}

fpsTimer += (float)tDiff;

if (fpsTimer > 1000.0f)

{

lastFPS = frameCounter;

updateTextOverlay();

fpsTimer = 0.0f;

frameCounter = 0;

}

#endif

{

destWidth = width;

destHeight = height;

#if defined(_WIN32)

MSG msg;

bool quitMessageReceived = false;

while (!quitMessageReceived)

{

auto tStart = std::chrono::high_resolution_clock::now();

if (viewUpdated)

{

viewUpdated = false;

viewChanged();

}

while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))

{

TranslateMessage(&msg);

DispatchMessage(&msg);

if (msg.message == WM_QUIT)

{

quitMessageReceived = true;

break;

}

}

render();

frameCounter++;

auto tEnd = std::chrono::high_resolution_clock::now();

auto tDiff = std::chrono::duration<double, std::milli>(tEnd - tStart).count();

frameTimer = (float)tDiff / 1000.0f;

camera.update(frameTimer);

if (camera.moving())

{

viewUpdated = true;

}

// Convert to clamped timer value

if (!paused)

{

timer += timerSpeed * frameTimer;

if (timer > 1.0)

{

timer -= 1.0f;

}

}

fpsTimer += (float)tDiff;

if (fpsTimer > 1000.0f)

{

if (!enableTextOverlay)

{

std::string windowTitle = getWindowTitle();

SetWindowText(window, windowTitle.c_str());

}

lastFPS = static_cast<uint32_t>(1.0f / frameTimer);

updateTextOverlay();

fpsTimer = 0.0f;

frameCounter = 0;

}

}

#elif defined(__ANDROID__)

while (1)

{

int ident;

int events;

struct android_poll_source* source;

bool destroy = false;

focused = true;

while ((ident = ALooper_pollAll(focused ? 0 : -1, NULL, &events, (void**)&source)) >= 0)

{

if (source != NULL)

{

source->process(androidApp, source);

}

if (androidApp->destroyRequested != 0)

{

LOGD("Android app destroy requested");

destroy = true;

break;

}

}

// App destruction requested

// Exit loop, example will be destroyed in application main

if (destroy)

{

break;

}

// Render frame

if (prepared)

{

auto tStart = std::chrono::high_resolution_clock::now();

render();

frameCounter++;

auto tEnd = std::chrono::high_resolution_clock::now();

auto tDiff = std::chrono::duration<double, std::milli>(tEnd - tStart).count();

frameTimer = tDiff / 1000.0f;

camera.update(frameTimer);

// Convert to clamped timer value

if (!paused)

{

timer += timerSpeed * frameTimer;

if (timer > 1.0)

{

timer -= 1.0f;

}

}

fpsTimer += (float)tDiff;

if (fpsTimer > 1000.0f)

{

lastFPS = frameCounter;

updateTextOverlay();

fpsTimer = 0.0f;

frameCounter = 0;

}

bool updateView = false;

// Check touch state (for movement)

if (touchDown) {

touchTimer += frameTimer;

}

if (touchTimer >= 1.0) {

camera.keys.up = true;

viewChanged();

}

// Check gamepad state

const float deadZone = 0.0015f;

// todo : check if gamepad is present

// todo : time based and relative axis positions

if (camera.type != Camera::CameraType::firstperson)

{

// Rotate

if (std::abs(gamePadState.axisLeft.x) > deadZone)

{

rotation.y += gamePadState.axisLeft.x * 0.5f * rotationSpeed;

camera.rotate(glm::vec3(0.0f, gamePadState.axisLeft.x * 0.5f, 0.0f));

updateView = true;

}

if (std::abs(gamePadState.axisLeft.y) > deadZone)

{

rotation.x -= gamePadState.axisLeft.y * 0.5f * rotationSpeed;

camera.rotate(glm::vec3(gamePadState.axisLeft.y * 0.5f, 0.0f, 0.0f));

updateView = true;

}

// Zoom

if (std::abs(gamePadState.axisRight.y) > deadZone)

{

zoom -= gamePadState.axisRight.y * 0.01f * zoomSpeed;

updateView = true;

}

if (updateView)

{

viewChanged();

}

}

else

{

updateView = camera.updatePad(gamePadState.axisLeft, gamePadState.axisRight, frameTimer);

if (updateView)

{

viewChanged();

}

}

}

}

#elif defined(_DIRECT2DISPLAY)

while (!quit)

{

auto tStart = std::chrono::high_resolution_clock::now();

if (viewUpdated)

{

viewUpdated = false;

viewChanged();

}

render();

frameCounter++;

auto tEnd = std::chrono::high_resolution_clock::now();

auto tDiff = std::chrono::duration<double, std::milli>(tEnd - tStart).count();

frameTimer = tDiff / 1000.0f;

camera.update(frameTimer);

if (camera.moving())

{

viewUpdated = true;

}

// Convert to clamped timer value

if (!paused)

{

timer += timerSpeed * frameTimer;

if (timer > 1.0)

{

timer -= 1.0f;

}

}

fpsTimer += (float)tDiff;

if (fpsTimer > 1000.0f)

{

lastFPS = frameCounter;

updateTextOverlay();

fpsTimer = 0.0f;

frameCounter = 0;

}

}

#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)

while (!quit)

{

auto tStart = std::chrono::high_resolution_clock::now();

if (viewUpdated)

{

viewUpdated = false;

viewChanged();

}

while (wl_display_prepare_read(display) != 0)

wl_display_dispatch_pending(display);

wl_display_flush(display);

wl_display_read_events(display);

wl_display_dispatch_pending(display);

render();

frameCounter++;

auto tEnd = std::chrono::high_resolution_clock::now();

auto tDiff = std::chrono::duration<double, std::milli>(tEnd - tStart).count();

frameTimer = tDiff / 1000.0f;

camera.update(frameTimer);

if (camera.moving())

{

viewUpdated = true;

}

// Convert to clamped timer value

if (!paused)

{

timer += timerSpeed * frameTimer;

if (timer > 1.0)

{

timer -= 1.0f;

}

}

fpsTimer += (float)tDiff;

if (fpsTimer > 1000.0f)

{

if (!enableTextOverlay)

{

std::string windowTitle = getWindowTitle();

wl_shell_surface_set_title(shell_surface, windowTitle.c_str());

}

lastFPS = frameCounter;

updateTextOverlay();

fpsTimer = 0.0f;

frameCounter = 0;

}

}

#elif defined(__linux__)

xcb_flush(connection);

while (!quit)

{

auto tStart = std::chrono::high_resolution_clock::now();

if (viewUpdated)

{

viewUpdated = false;

viewChanged();

}

xcb_generic_event_t *event;

while ((event = xcb_poll_for_event(connection)))

{

handleEvent(event);

free(event);

}

render();

frameCounter++;

auto tEnd = std::chrono::high_resolution_clock::now();

auto tDiff = std::chrono::duration<double, std::milli>(tEnd - tStart).count();

frameTimer = tDiff / 1000.0f;

camera.update(frameTimer);

if (camera.moving())

{

viewUpdated = true;

}

// Convert to clamped timer value

if (!paused)

{

timer += timerSpeed * frameTimer;

if (timer > 1.0)

{

timer -= 1.0f;

}

}

fpsTimer += (float)tDiff;

if (fpsTimer > 1000.0f)

{

if (!enableTextOverlay)

{

std::string windowTitle = getWindowTitle();

xcb_change_property(connection, XCB_PROP_MODE_REPLACE,

window, XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8,

windowTitle.size(), windowTitle.c_str());

}

lastFPS = frameCounter;

updateTextOverlay();

fpsTimer = 0.0f;

frameCounter = 0;

}

}

#endif

// Flush device to make sure all resources can be freed

vkDeviceWaitIdle(device);

{

if (!enableTextOverlay)

return;

textOverlay->beginTextUpdate();

textOverlay->addText(title, 5.0f, 5.0f, VulkanTextOverlay::alignLeft);

std::stringstream ss;

ss << std::fixed << std::setprecision(3) << (frameTimer * 1000.0f) << "ms (" << lastFPS << " fps)";

textOverlay->addText(ss.str(), 5.0f, 25.0f, VulkanTextOverlay::alignLeft);

std::string deviceName(deviceProperties.deviceName);

#if defined(__ANDROID__)

deviceName += " (" + androidProduct + ")";

#endif

textOverlay->addText(deviceName, 5.0f, 45.0f, VulkanTextOverlay::alignLeft);

getOverlayText(textOverlay);

textOverlay->endTextUpdate();

{

// Acquire the next image from the swap chain

VkResult err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);

// Recreate the swapchain if it's no longer compatible with the surface (OUT_OF_DATE) or no longer optimal for presentation (SUBOPTIMAL)

if ((err == VK_ERROR_OUT_OF_DATE_KHR) || (err == VK_SUBOPTIMAL_KHR)) {

windowResize();

}

else {

VK_CHECK_RESULT(err);

}

{

bool submitTextOverlay = enableTextOverlay && textOverlay->visible;

if (submitTextOverlay)

{

// Wait for color attachment output to finish before rendering the text overlay

VkPipelineStageFlags stageFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;

submitInfo.pWaitDstStageMask = &stageFlags;

// Set semaphores

// Wait for render complete semaphore

submitInfo.waitSemaphoreCount = 1;

submitInfo.pWaitSemaphores = &semaphores.renderComplete;

// Signal ready with text overlay complete semaphpre

submitInfo.signalSemaphoreCount = 1;

submitInfo.pSignalSemaphores = &semaphores.textOverlayComplete;

// Submit current text overlay command buffer

submitInfo.commandBufferCount = 1;

submitInfo.pCommandBuffers = &textOverlay->cmdBuffers[currentBuffer];

VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));

// Reset stage mask

submitInfo.pWaitDstStageMask = &submitPipelineStages;

// Reset wait and signal semaphores for rendering next frame

// Wait for swap chain presentation to finish

submitInfo.waitSemaphoreCount = 1;

submitInfo.pWaitSemaphores = &semaphores.presentComplete;

// Signal ready with offscreen semaphore

submitInfo.signalSemaphoreCount = 1;

submitInfo.pSignalSemaphores = &semaphores.renderComplete;

}

VK_CHECK_RESULT(swapChain.queuePresent(queue, currentBuffer, submitTextOverlay ? semaphores.textOverlayComplete : semaphores.renderComplete));

VK_CHECK_RESULT(vkQueueWaitIdle(queue));

{

#if !defined(__ANDROID__)

// Check for a valid asset path

struct stat info;

if (stat(getAssetPath().c_str(), &info) != 0)

{

#if defined(_WIN32)

std::string msg = "Could not locate asset path in \"" + getAssetPath() + "\" !";

MessageBox(NULL, msg.c_str(), "Fatal error", MB_OK | MB_ICONERROR);

#else

std::cerr << "Error: Could not find asset path in " << getAssetPath() << std::endl;

#endif

exit(-1);

}

#endif

settings.validation = enableValidation;

// Parse command line arguments

for (size_t i = 0; i < args.size(); i++)

{

if (args[i] == std::string("-validation"))

{

settings.validation = true;

}

if (args[i] == std::string("-vsync"))

{

settings.vsync = true;

}

if (args[i] == std::string("-fullscreen"))

{

settings.fullscreen = true;

}

if ((args[i] == std::string("-w")) || (args[i] == std::string("-width")))

{

char* endptr;

uint32_t w = strtol(args[i + 1], &endptr, 10);

if (endptr != args[i + 1]) { width = w; };

}

if ((args[i] == std::string("-h")) || (args[i] == std::string("-height")))

{

char* endptr;

uint32_t h = strtol(args[i + 1], &endptr, 10);

if (endptr != args[i + 1]) { height = h; };

}

}

#if defined(__ANDROID__)

// Vulkan library is loaded dynamically on Android

bool libLoaded = vks::android::loadVulkanLibrary();

assert(libLoaded);

#elif defined(_DIRECT2DISPLAY)

#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)

initWaylandConnection();

#elif defined(__linux__)

initxcbConnection();

#endif

#if defined(_WIN32)

// Enable console if validation is active

// Debug message callback will output to it

if (this->settings.validation)

{

setupConsole("Vulkan validation output");

}

#endif

{

VkResult err;

// Vulkan instance

err = createInstance(settings.validation);

if (err)

{

vks::tools::exitFatal("Could not create Vulkan instance : \n" + vks::tools::errorString(err), "Fatal error");

}

#if defined(__ANDROID__)

vks::android::loadVulkanFunctions(instance);

#endif

// If requested, we enable the default validation layers for debugging

if (settings.validation)

{

// The report flags determine what type of messages for the layers will be displayed

// For validating (debugging) an appplication the error and warning bits should suffice

VkDebugReportFlagsEXT debugReportFlags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;

// Additional flags include performance info, loader and layer debug messages, etc.

vks::debug::setupDebugging(instance, debugReportFlags, VK_NULL_HANDLE);

}

// Physical device

uint32_t gpuCount = 0;

// Get number of available physical devices

VK_CHECK_RESULT(vkEnumeratePhysicalDevices(instance, &gpuCount, nullptr));

assert(gpuCount > 0);

// Enumerate devices

std::vector<VkPhysicalDevice> physicalDevices(gpuCount);

err = vkEnumeratePhysicalDevices(instance, &gpuCount, physicalDevices.data());

if (err)

{

vks::tools::exitFatal("Could not enumerate physical devices : \n" + vks::tools::errorString(err), "Fatal error");

}

// GPU selection

// Select physical device to be used for the Vulkan example

// Defaults to the first device unless specified by command line

uint32_t selectedDevice = 0;

#if !defined(__ANDROID__)

// GPU selection via command line argument

for (size_t i = 0; i < args.size(); i++)

{

// Select GPU

if ((args[i] == std::string("-g")) || (args[i] == std::string("-gpu")))

{

char* endptr;

uint32_t index = strtol(args[i + 1], &endptr, 10);

if (endptr != args[i + 1])

{

if (index > gpuCount - 1)

{

std::cerr << "Selected device index " << index << " is out of range, reverting to device 0 (use -listgpus to show available Vulkan devices)" << std::endl;

}

else

{

std::cout << "Selected Vulkan device " << index << std::endl;

selectedDevice = index;

}

};

break;

}

// List available GPUs

if (args[i] == std::string("-listgpus"))

{

uint32_t gpuCount = 0;

VK_CHECK_RESULT(vkEnumeratePhysicalDevices(instance, &gpuCount, nullptr));

if (gpuCount == 0)

{

std::cerr << "No Vulkan devices found!" << std::endl;

}

else

{

// Enumerate devices

std::cout << "Available Vulkan devices" << std::endl;

std::vector<VkPhysicalDevice> devices(gpuCount);

VK_CHECK_RESULT(vkEnumeratePhysicalDevices(instance, &gpuCount, devices.data()));

for (uint32_t i = 0; i < gpuCount; i++) {

VkPhysicalDeviceProperties deviceProperties;

vkGetPhysicalDeviceProperties(devices[i], &deviceProperties);

std::cout << "Device [" << i << "] : " << deviceProperties.deviceName << std::endl;

std::cout << " Type: " << vks::tools::physicalDeviceTypeString(deviceProperties.deviceType) << std::endl;

std::cout << " API: " << (deviceProperties.apiVersion >> 22) << "." << ((deviceProperties.apiVersion >> 12) & 0x3ff) << "." << (deviceProperties.apiVersion & 0xfff) << std::endl;

}

}

}

}

#endif

physicalDevice = physicalDevices[selectedDevice];

// Store properties (including limits), features and memory properties of the phyiscal device (so that examples can check against them)

vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);

vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures);

vkGetPhysicalDeviceMemoryProperties(physicalDevice, &deviceMemoryProperties);

// Derived examples can override this to set actual features (based on above readings) to enable for logical device creation

getEnabledFeatures();

// Vulkan device creation

// This is handled by a separate class that gets a logical device representation

// and encapsulates functions related to a device

vulkanDevice = new vks::VulkanDevice(physicalDevice);

VkResult res = vulkanDevice->createLogicalDevice(enabledFeatures, enabledExtensions);

if (res != VK_SUCCESS) {

vks::tools::exitFatal("Could not create Vulkan device: \n" + vks::tools::errorString(res), "Fatal error");

}

device = vulkanDevice->logicalDevice;

// Get a graphics queue from the device

vkGetDeviceQueue(device, vulkanDevice->queueFamilyIndices.graphics, 0, &queue);

// Find a suitable depth format

VkBool32 validDepthFormat = vks::tools::getSupportedDepthFormat(physicalDevice, &depthFormat);

assert(validDepthFormat);

swapChain.connect(instance, physicalDevice, device);

// Create synchronization objects

VkSemaphoreCreateInfo semaphoreCreateInfo = vks::initializers::semaphoreCreateInfo();

// Create a semaphore used to synchronize image presentation

// Ensures that the image is displayed before we start submitting new commands to the queu

VK_CHECK_RESULT(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.presentComplete));

// Create a semaphore used to synchronize command submission

// Ensures that the image is not presented until all commands have been sumbitted and executed

VK_CHECK_RESULT(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.renderComplete));

// Create a semaphore used to synchronize command submission

// Ensures that the image is not presented until all commands for the text overlay have been sumbitted and executed

// Will be inserted after the render complete semaphore if the text overlay is enabled

VK_CHECK_RESULT(vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.textOverlayComplete));

// Set up submit info structure

// Semaphores will stay the same during application lifetime

// Command buffer submission info is set by each example

submitInfo = vks::initializers::submitInfo();

submitInfo.pWaitDstStageMask = &submitPipelineStages;

submitInfo.waitSemaphoreCount = 1;

submitInfo.pWaitSemaphores = &semaphores.presentComplete;

submitInfo.signalSemaphoreCount = 1;

submitInfo.pSignalSemaphores = &semaphores.renderComplete;

#if defined(__ANDROID__)

// Get Android device name and manufacturer (to display along GPU name)

androidProduct = "";

char prop[PROP_VALUE_MAX+1];

int len = __system_property_get("ro.product.manufacturer", prop);

if (len > 0) {

androidProduct += std::string(prop) + " ";

};

len = __system_property_get("ro.product.model", prop);

if (len > 0) {

androidProduct += std::string(prop);

};

LOGD("androidProduct = %s", androidProduct.c_str());

#endif

{

AllocConsole();

AttachConsole(GetCurrentProcessId());

FILE *stream;

freopen_s(&stream, "CONOUT$", "w+", stdout);

freopen_s(&stream, "CONOUT$", "w+", stderr);

SetConsoleTitle(TEXT(title.c_str()));

{

this->windowInstance = hinstance;

WNDCLASSEX wndClass;

wndClass.cbSize = sizeof(WNDCLASSEX);

wndClass.style = CS_HREDRAW | CS_VREDRAW;

wndClass.lpfnWndProc = wndproc;

wndClass.cbClsExtra = 0;

wndClass.cbWndExtra = 0;

wndClass.hInstance = hinstance;

wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);

wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);

wndClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);

wndClass.lpszMenuName = NULL;

wndClass.lpszClassName = name.c_str();

wndClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO);

if (!RegisterClassEx(&wndClass))

{

std::cout << "Could not register window class!\n";

fflush(stdout);

exit(1);

}

int screenWidth = GetSystemMetrics(SM_CXSCREEN);

int screenHeight = GetSystemMetrics(SM_CYSCREEN);

if (settings.fullscreen)

{

DEVMODE dmScreenSettings;

memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));