claude_code/procedural-3d-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Code cleanup, use VK_USE_PLATFORM_ defines where available

Browse source
This commit is contained in:
saschawillems 2017-07-02 11:57:47 +02:00
parent 18df00c7b4
commit fd439a59e2
1 changed files with 35 additions and 78 deletions
Download patch file Download diff file Expand all files Collapse all files

113
base/VulkanSwapChain.hpp
View file

@ -3,7 +3,7 @@
* *
* A swap chain is a collection of framebuffers used for rendering and presentation to the windowing system * A swap chain is a collection of framebuffers used for rendering and presentation to the windowing system
* *
* Copyright (C) 2016 by Sascha Willems - www.saschawillems.de * Copyright (C) 2016-2017 by Sascha Willems - www.saschawillems.de
* *
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT) * This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
*/ */
@ -12,16 +12,9 @@
#include <stdlib.h> #include <stdlib.h>
#include <string> #include <string>
#include <fstream>
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <vector> #include <vector>
#ifdef _WIN32
#include <windows.h>
#include <fcntl.h>
#include <io.h>
#else
#endif
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>
#include "VulkanTools.h" #include "VulkanTools.h"
@ -80,102 +73,66 @@ public:
uint32_t imageCount; uint32_t imageCount;
std::vector<VkImage> images; std::vector<VkImage> images;
std::vector<SwapChainBuffer> buffers; std::vector<SwapChainBuffer> buffers;
// Index of the deteced graphics and presenting device queue
/** @brief Queue family index of the detected graphics and presenting device queue */ /** @brief Queue family index of the detected graphics and presenting device queue */
uint32_t queueNodeIndex = UINT32_MAX; uint32_t queueNodeIndex = UINT32_MAX;
// Creates an os specific surface /** @brief Creates the platform specific surface abstraction of the native platform window used for presentation */
/** #if defined(VK_USE_PLATFORM_WIN32_KHR)
* Create the surface object, an abstraction for the native platform window void initSurface(void* platformHandle, void* platformWindow)
* #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
* @pre Windows void initSurface(ANativeWindow* window)
* @param platformHandle HINSTANCE of the window to create the surface for #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
* @param platformWindow HWND of the window to create the surface for void initSurface(wl_display *display, wl_surface *window)
* #elif defined(VK_USE_PLATFORM_XCB_KHR)
* @pre Android void initSurface(xcb_connection_t* connection, xcb_window_t window)
* @param window A native platform window #elif (defined(VK_USE_PLATFORM_IOS_MVK) || defined(VK_USE_PLATFORM_MACOS_MVK))
* void initSurface(void* view)
* @pre Linux (XCB) #elif defined(_DIRECT2DISPLAY)
* @param connection xcb connection to the X Server void initSurface(uint32_t width, uint32_t height)
* @param window The xcb window to create the surface for
* @note Targets other than XCB ar not yet supported
*/
void initSurface(
#ifdef _WIN32
void* platformHandle, void* platformWindow
#else
#ifdef __ANDROID__
ANativeWindow* window
#else
#if (defined(VK_USE_PLATFORM_IOS_MVK) || defined(VK_USE_PLATFORM_MACOS_MVK))
void* view
#else
#ifdef _DIRECT2DISPLAY
uint32_t width, uint32_t height
#else
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
wl_display *display, wl_surface *window
#else
xcb_connection_t* connection, xcb_window_t window
#endif #endif
#endif
#endif
#endif
#endif
)
{ {
VkResult err = VK_SUCCESS; VkResult err = VK_SUCCESS;
// Create the os-specific surface // Create the os-specific surface
#ifdef _WIN32 #if defined(VK_USE_PLATFORM_WIN32_KHR)
VkWin32SurfaceCreateInfoKHR surfaceCreateInfo = {}; VkWin32SurfaceCreateInfoKHR surfaceCreateInfo = {};
surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
surfaceCreateInfo.hinstance = (HINSTANCE)platformHandle; surfaceCreateInfo.hinstance = (HINSTANCE)platformHandle;
surfaceCreateInfo.hwnd = (HWND)platformWindow; surfaceCreateInfo.hwnd = (HWND)platformWindow;
err = vkCreateWin32SurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface); err = vkCreateWin32SurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
#else #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
#ifdef __ANDROID__
VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo = {}; VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo = {};
surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
surfaceCreateInfo.window = window; surfaceCreateInfo.window = window;
err = vkCreateAndroidSurfaceKHR(instance, &surfaceCreateInfo, NULL, &surface); err = vkCreateAndroidSurfaceKHR(instance, &surfaceCreateInfo, NULL, &surface);
#else #elif defined(VK_USE_PLATFORM_IOS_MVK)
#ifdef VK_USE_PLATFORM_IOS_MVK VkIOSSurfaceCreateInfoMVK surfaceCreateInfo = {};
VkIOSSurfaceCreateInfoMVK surfaceCreateInfo = {}; surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK; surfaceCreateInfo.pNext = NULL;
surfaceCreateInfo.pNext = NULL; surfaceCreateInfo.flags = 0;
surfaceCreateInfo.flags = 0; surfaceCreateInfo.pView = view;
surfaceCreateInfo.pView = view; err = vkCreateIOSSurfaceMVK(instance, &surfaceCreateInfo, nullptr, &surface);
err = vkCreateIOSSurfaceMVK(instance, &surfaceCreateInfo, nullptr, &surface); #elif defined(VK_USE_PLATFORM_MACOS_MVK)
#else VkMacOSSurfaceCreateInfoMVK surfaceCreateInfo = {};
#ifdef VK_USE_PLATFORM_MACOS_MVK surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
VkMacOSSurfaceCreateInfoMVK surfaceCreateInfo = {}; surfaceCreateInfo.pNext = NULL;
surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK; surfaceCreateInfo.flags = 0;
surfaceCreateInfo.pNext = NULL; surfaceCreateInfo.pView = view;
surfaceCreateInfo.flags = 0; err = vkCreateMacOSSurfaceMVK(instance, &surfaceCreateInfo, NULL, &surface);
surfaceCreateInfo.pView = view; #elif defined(_DIRECT2DISPLAY)
err = vkCreateMacOSSurfaceMVK(instance, &surfaceCreateInfo, NULL, &surface);
#else
#if defined(_DIRECT2DISPLAY)
createDirect2DisplaySurface(width, height); createDirect2DisplaySurface(width, height);
#else #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
VkWaylandSurfaceCreateInfoKHR surfaceCreateInfo = {}; VkWaylandSurfaceCreateInfoKHR surfaceCreateInfo = {};
surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
surfaceCreateInfo.display = display; surfaceCreateInfo.display = display;
surfaceCreateInfo.surface = window; surfaceCreateInfo.surface = window;
err = vkCreateWaylandSurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface); err = vkCreateWaylandSurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
#else #elif defined(VK_USE_PLATFORM_XCB_KHR)
VkXcbSurfaceCreateInfoKHR surfaceCreateInfo = {}; VkXcbSurfaceCreateInfoKHR surfaceCreateInfo = {};
surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
surfaceCreateInfo.connection = connection; surfaceCreateInfo.connection = connection;
surfaceCreateInfo.window = window; surfaceCreateInfo.window = window;
err = vkCreateXcbSurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface); err = vkCreateXcbSurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
#endif
#endif
#endif
#endif
#endif
#endif #endif
if (err != VK_SUCCESS) { if (err != VK_SUCCESS) {
@ -578,8 +535,8 @@ public:
VkDisplayModePropertiesKHR* pModeProperties; VkDisplayModePropertiesKHR* pModeProperties;
bool foundMode = false; bool foundMode = false;
for(uint32_t i = 0; i < displayPropertyCount;++i) for(uint32_t i = 0; i < displayPropertyCount;++i)
{ {
display = pDisplayProperties[i].display; display = pDisplayProperties[i].display;
uint32_t modeCount; uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, display, &modeCount, NULL); vkGetDisplayModePropertiesKHR(physicalDevice, display, &modeCount, NULL);