mirror of
https://github.com/Toastconcern/FrameStudio.git
synced 2026-10-29 04:02:56 +01:00
ToastconcernandClaude Opus 5.5
f7345a5ac3
Frame Studio now builds for Windows (x64, x86, ARM64), Linux (x64, x86, ARM64)
and macOS (Apple Silicon, Intel):
- studio/platform.h with Win32 and POSIX implementations (dialogs through
tinyfiledialogs on Linux/macOS), a GLFW window beside the Win32 one, and a
platform-neutral frame pacer
- MoltenVK support in the renderer (portability enumeration) and bundled in
the macOS app
- 32-bit builds: large-address-aware, LZMA packing within a 32-bit address space
- unaligned file reads in the loaders go through loadUnaligned (no UB)
- scripts/build-studio.sh, studio/build_windows.bat [x64|x86|arm64],
cmake/llvm-mingw.cmake, and a GitHub Actions workflow building every target
Frame Home installs without Studio: frame/install-frame-home.{sh,ps1} and
"Install Frame Home.bat" (packaged as FrameHome-installer.zip).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
343 lines
15 KiB
C
343 lines
15 KiB
C
#ifndef VULKAN_WIN32_H_
|
|
#define VULKAN_WIN32_H_ 1
|
|
|
|
/*
|
|
** Copyright 2015-2024 The Khronos Group Inc.
|
|
**
|
|
** SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/*
|
|
** This header is generated from the Khronos Vulkan XML API Registry.
|
|
**
|
|
*/
|
|
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
|
|
|
|
// VK_KHR_win32_surface is a preprocessor guard. Do not pass it to API calls.
|
|
#define VK_KHR_win32_surface 1
|
|
#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
|
|
#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
|
|
typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
|
|
typedef struct VkWin32SurfaceCreateInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
VkWin32SurfaceCreateFlagsKHR flags;
|
|
HINSTANCE hinstance;
|
|
HWND hwnd;
|
|
} VkWin32SurfaceCreateInfoKHR;
|
|
|
|
typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
|
|
typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
|
|
|
|
#ifndef VK_NO_PROTOTYPES
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
|
|
VkInstance instance,
|
|
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkSurfaceKHR* pSurface);
|
|
|
|
VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t queueFamilyIndex);
|
|
#endif
|
|
|
|
|
|
// VK_KHR_external_memory_win32 is a preprocessor guard. Do not pass it to API calls.
|
|
#define VK_KHR_external_memory_win32 1
|
|
#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
|
|
#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
|
|
typedef struct VkImportMemoryWin32HandleInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
VkExternalMemoryHandleTypeFlagBits handleType;
|
|
HANDLE handle;
|
|
LPCWSTR name;
|
|
} VkImportMemoryWin32HandleInfoKHR;
|
|
|
|
typedef struct VkExportMemoryWin32HandleInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
const SECURITY_ATTRIBUTES* pAttributes;
|
|
DWORD dwAccess;
|
|
LPCWSTR name;
|
|
} VkExportMemoryWin32HandleInfoKHR;
|
|
|
|
typedef struct VkMemoryWin32HandlePropertiesKHR {
|
|
VkStructureType sType;
|
|
void* pNext;
|
|
uint32_t memoryTypeBits;
|
|
} VkMemoryWin32HandlePropertiesKHR;
|
|
|
|
typedef struct VkMemoryGetWin32HandleInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
VkDeviceMemory memory;
|
|
VkExternalMemoryHandleTypeFlagBits handleType;
|
|
} VkMemoryGetWin32HandleInfoKHR;
|
|
|
|
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
|
|
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
|
|
|
|
#ifndef VK_NO_PROTOTYPES
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
|
HANDLE* pHandle);
|
|
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
|
|
VkDevice device,
|
|
VkExternalMemoryHandleTypeFlagBits handleType,
|
|
HANDLE handle,
|
|
VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
|
|
#endif
|
|
|
|
|
|
// VK_KHR_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls.
|
|
#define VK_KHR_win32_keyed_mutex 1
|
|
#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
|
|
#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
|
|
typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
uint32_t acquireCount;
|
|
const VkDeviceMemory* pAcquireSyncs;
|
|
const uint64_t* pAcquireKeys;
|
|
const uint32_t* pAcquireTimeouts;
|
|
uint32_t releaseCount;
|
|
const VkDeviceMemory* pReleaseSyncs;
|
|
const uint64_t* pReleaseKeys;
|
|
} VkWin32KeyedMutexAcquireReleaseInfoKHR;
|
|
|
|
|
|
|
|
// VK_KHR_external_semaphore_win32 is a preprocessor guard. Do not pass it to API calls.
|
|
#define VK_KHR_external_semaphore_win32 1
|
|
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
|
|
#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
|
|
typedef struct VkImportSemaphoreWin32HandleInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
VkSemaphore semaphore;
|
|
VkSemaphoreImportFlags flags;
|
|
VkExternalSemaphoreHandleTypeFlagBits handleType;
|
|
HANDLE handle;
|
|
LPCWSTR name;
|
|
} VkImportSemaphoreWin32HandleInfoKHR;
|
|
|
|
typedef struct VkExportSemaphoreWin32HandleInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
const SECURITY_ATTRIBUTES* pAttributes;
|
|
DWORD dwAccess;
|
|
LPCWSTR name;
|
|
} VkExportSemaphoreWin32HandleInfoKHR;
|
|
|
|
typedef struct VkD3D12FenceSubmitInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
uint32_t waitSemaphoreValuesCount;
|
|
const uint64_t* pWaitSemaphoreValues;
|
|
uint32_t signalSemaphoreValuesCount;
|
|
const uint64_t* pSignalSemaphoreValues;
|
|
} VkD3D12FenceSubmitInfoKHR;
|
|
|
|
typedef struct VkSemaphoreGetWin32HandleInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
VkSemaphore semaphore;
|
|
VkExternalSemaphoreHandleTypeFlagBits handleType;
|
|
} VkSemaphoreGetWin32HandleInfoKHR;
|
|
|
|
typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
|
|
typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
|
|
|
|
#ifndef VK_NO_PROTOTYPES
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
|
|
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
|
HANDLE* pHandle);
|
|
#endif
|
|
|
|
|
|
// VK_KHR_external_fence_win32 is a preprocessor guard. Do not pass it to API calls.
|
|
#define VK_KHR_external_fence_win32 1
|
|
#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
|
|
#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
|
|
typedef struct VkImportFenceWin32HandleInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
VkFence fence;
|
|
VkFenceImportFlags flags;
|
|
VkExternalFenceHandleTypeFlagBits handleType;
|
|
HANDLE handle;
|
|
LPCWSTR name;
|
|
} VkImportFenceWin32HandleInfoKHR;
|
|
|
|
typedef struct VkExportFenceWin32HandleInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
const SECURITY_ATTRIBUTES* pAttributes;
|
|
DWORD dwAccess;
|
|
LPCWSTR name;
|
|
} VkExportFenceWin32HandleInfoKHR;
|
|
|
|
typedef struct VkFenceGetWin32HandleInfoKHR {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
VkFence fence;
|
|
VkExternalFenceHandleTypeFlagBits handleType;
|
|
} VkFenceGetWin32HandleInfoKHR;
|
|
|
|
typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
|
|
typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
|
|
|
|
#ifndef VK_NO_PROTOTYPES
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
|
|
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
|
|
VkDevice device,
|
|
const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
|
|
HANDLE* pHandle);
|
|
#endif
|
|
|
|
|
|
// VK_NV_external_memory_win32 is a preprocessor guard. Do not pass it to API calls.
|
|
#define VK_NV_external_memory_win32 1
|
|
#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
|
|
#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
|
|
typedef struct VkImportMemoryWin32HandleInfoNV {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
VkExternalMemoryHandleTypeFlagsNV handleType;
|
|
HANDLE handle;
|
|
} VkImportMemoryWin32HandleInfoNV;
|
|
|
|
typedef struct VkExportMemoryWin32HandleInfoNV {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
const SECURITY_ATTRIBUTES* pAttributes;
|
|
DWORD dwAccess;
|
|
} VkExportMemoryWin32HandleInfoNV;
|
|
|
|
typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
|
|
|
|
#ifndef VK_NO_PROTOTYPES
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
|
|
VkDevice device,
|
|
VkDeviceMemory memory,
|
|
VkExternalMemoryHandleTypeFlagsNV handleType,
|
|
HANDLE* pHandle);
|
|
#endif
|
|
|
|
|
|
// VK_NV_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls.
|
|
#define VK_NV_win32_keyed_mutex 1
|
|
#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2
|
|
#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
|
|
typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
uint32_t acquireCount;
|
|
const VkDeviceMemory* pAcquireSyncs;
|
|
const uint64_t* pAcquireKeys;
|
|
const uint32_t* pAcquireTimeoutMilliseconds;
|
|
uint32_t releaseCount;
|
|
const VkDeviceMemory* pReleaseSyncs;
|
|
const uint64_t* pReleaseKeys;
|
|
} VkWin32KeyedMutexAcquireReleaseInfoNV;
|
|
|
|
|
|
|
|
// VK_EXT_full_screen_exclusive is a preprocessor guard. Do not pass it to API calls.
|
|
#define VK_EXT_full_screen_exclusive 1
|
|
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4
|
|
#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive"
|
|
|
|
typedef enum VkFullScreenExclusiveEXT {
|
|
VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0,
|
|
VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1,
|
|
VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2,
|
|
VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3,
|
|
VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF
|
|
} VkFullScreenExclusiveEXT;
|
|
typedef struct VkSurfaceFullScreenExclusiveInfoEXT {
|
|
VkStructureType sType;
|
|
void* pNext;
|
|
VkFullScreenExclusiveEXT fullScreenExclusive;
|
|
} VkSurfaceFullScreenExclusiveInfoEXT;
|
|
|
|
typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
|
|
VkStructureType sType;
|
|
void* pNext;
|
|
VkBool32 fullScreenExclusiveSupported;
|
|
} VkSurfaceCapabilitiesFullScreenExclusiveEXT;
|
|
|
|
typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
|
|
VkStructureType sType;
|
|
const void* pNext;
|
|
HMONITOR hmonitor;
|
|
} VkSurfaceFullScreenExclusiveWin32InfoEXT;
|
|
|
|
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
|
|
typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
|
|
typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain);
|
|
typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes);
|
|
|
|
#ifndef VK_NO_PROTOTYPES
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT(
|
|
VkPhysicalDevice physicalDevice,
|
|
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
|
uint32_t* pPresentModeCount,
|
|
VkPresentModeKHR* pPresentModes);
|
|
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain);
|
|
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT(
|
|
VkDevice device,
|
|
VkSwapchainKHR swapchain);
|
|
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT(
|
|
VkDevice device,
|
|
const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
|
|
VkDeviceGroupPresentModeFlagsKHR* pModes);
|
|
#endif
|
|
|
|
|
|
// VK_NV_acquire_winrt_display is a preprocessor guard. Do not pass it to API calls.
|
|
#define VK_NV_acquire_winrt_display 1
|
|
#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1
|
|
#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display"
|
|
typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
|
|
typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay);
|
|
|
|
#ifndef VK_NO_PROTOTYPES
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(
|
|
VkPhysicalDevice physicalDevice,
|
|
VkDisplayKHR display);
|
|
|
|
VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(
|
|
VkPhysicalDevice physicalDevice,
|
|
uint32_t deviceRelativeId,
|
|
VkDisplayKHR* pDisplay);
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|