mirror of
https://github.com/KhronosGroup/OpenCL-CTS.git
synced 2026-03-19 06:09:01 +00:00
Add external semaphore tests. (#1645)
* Add external semaphore tests. Added basic test to check the functionality of cl_ext_external_semaphore_test extension. Tests rely on Vulkan API as the producer of the external semaphore functionality. The Vulkan wrapper has been copied from the Vulkan CTS tests and minor changes have been introduced. A separate copy of the Vulkan wrapper is for breaking any dependencies between different CTS modules and thus make the build system simpler. Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com> * Fix clang-format Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com> * Move vulkan wrapper to a separate library. Vulkan wrapper is extracted as a separate module and can be used in different CTS tests as a shared library. Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com> * Add cl_ext_external_samaphore tests based on cl_khr_semaphore tests. Added cl_khr_semaphore adjusted to creating semaphores in Vulkan context and importing them through export semaphore functionality in OpenCL (cl_ext_external_samaphore). Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com> * Cleanup. Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com> * Fix build issues. * Add missing directories for build cl_ext_external_semaphore. Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com> * Set Vulkan lib directory. Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com> * Change extension directory name. Changed extensions directory name from cl_ext_external_semaphore to cl_khr_external_semaphore. Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com> * Remove unneeded compile options. Removed VK_USE_PLATFORM_WIN32_KHR option from cl_khr_external_semaphore compilation arguments. Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com> --------- Signed-off-by: Paweł Jastrzębski <p.k.jastrzebski@gmail.com>
This commit is contained in:
Paweł Jastrzębski
committed by
GitHub
GitHub
parent
b7f2dd58e9
commit
63b0f441f1
@@ -1,12 +1,12 @@
|
||||
set (MODULE_NAME VULKAN)
|
||||
|
||||
if(WIN32)
|
||||
list(APPEND CLConform_LIBRARIES vulkan-1)
|
||||
list(APPEND CLConform_LIBRARIES vulkan-1 vulkan_wrapper)
|
||||
else(WIN32)
|
||||
list(APPEND CLConform_LIBRARIES vulkan dl)
|
||||
list(APPEND CLConform_LIBRARIES vulkan dl vulkan_wrapper)
|
||||
endif(WIN32)
|
||||
set(CMAKE_CXX_FLAGS "-fpermissive")
|
||||
if(WIN32)
|
||||
if(WIN32)
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVK_USE_PLATFORM_WIN32_KHR")
|
||||
endif(WIN32)
|
||||
|
||||
@@ -26,11 +26,7 @@ set (${MODULE_NAME}_SOURCES
|
||||
test_vulkan_interop_image.cpp
|
||||
test_vulkan_api_consistency.cpp
|
||||
test_vulkan_platform_device_info.cpp
|
||||
vulkan_interop_common/vulkan_wrapper.cpp
|
||||
vulkan_interop_common/vulkan_interop_common.cpp
|
||||
vulkan_interop_common/opencl_vulkan_wrapper.cpp
|
||||
vulkan_interop_common/vulkan_utility.cpp
|
||||
vulkan_interop_common/vulkan_list_map.cpp
|
||||
vulkan_interop_common.cpp
|
||||
../../test_common/harness/genericThread.cpp
|
||||
../../test_common/harness/errorHelpers.cpp
|
||||
../../test_common/harness/testHarness.cpp
|
||||
@@ -45,6 +41,6 @@ set (${MODULE_NAME}_SOURCES
|
||||
set_source_files_properties(
|
||||
${${MODULE_NAME}_SOURCES}
|
||||
PROPERTIES LANGUAGE CXX)
|
||||
include_directories("./vulkan_interop_common/")
|
||||
include_directories("../common/vulkan_wrapper")
|
||||
|
||||
include(../CMakeCommon.txt)
|
||||
|
||||
@@ -1,853 +0,0 @@
|
||||
//
|
||||
// Copyright (c) 2022 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#include <CL/cl_ext.h>
|
||||
#include "opencl_vulkan_wrapper.hpp"
|
||||
#include "vulkan_wrapper.hpp"
|
||||
#include "harness/errorHelpers.h"
|
||||
#include "harness/deviceInfo.h"
|
||||
#include <assert.h>
|
||||
#include <iostream>
|
||||
#include <stdexcept>
|
||||
|
||||
#define ASSERT(x) assert((x))
|
||||
#define GB(x) ((unsigned long long)(x) << 30)
|
||||
|
||||
pfnclCreateSemaphoreWithPropertiesKHR clCreateSemaphoreWithPropertiesKHRptr;
|
||||
pfnclEnqueueWaitSemaphoresKHR clEnqueueWaitSemaphoresKHRptr;
|
||||
pfnclEnqueueSignalSemaphoresKHR clEnqueueSignalSemaphoresKHRptr;
|
||||
pfnclEnqueueAcquireExternalMemObjectsKHR
|
||||
clEnqueueAcquireExternalMemObjectsKHRptr;
|
||||
pfnclEnqueueReleaseExternalMemObjectsKHR
|
||||
clEnqueueReleaseExternalMemObjectsKHRptr;
|
||||
pfnclReleaseSemaphoreKHR clReleaseSemaphoreKHRptr;
|
||||
|
||||
void init_cl_vk_ext(cl_platform_id opencl_platform)
|
||||
{
|
||||
clEnqueueWaitSemaphoresKHRptr =
|
||||
(pfnclEnqueueWaitSemaphoresKHR)clGetExtensionFunctionAddressForPlatform(
|
||||
opencl_platform, "clEnqueueWaitSemaphoresKHR");
|
||||
if (NULL == clEnqueueWaitSemaphoresKHRptr)
|
||||
{
|
||||
throw std::runtime_error("Failed to get the function pointer of "
|
||||
"clEnqueueWaitSemaphoresKHRptr!");
|
||||
}
|
||||
clEnqueueSignalSemaphoresKHRptr = (pfnclEnqueueSignalSemaphoresKHR)
|
||||
clGetExtensionFunctionAddressForPlatform(
|
||||
opencl_platform, "clEnqueueSignalSemaphoresKHR");
|
||||
if (NULL == clEnqueueSignalSemaphoresKHRptr)
|
||||
{
|
||||
throw std::runtime_error("Failed to get the function pointer of "
|
||||
"clEnqueueSignalSemaphoresKHRptr!");
|
||||
}
|
||||
clReleaseSemaphoreKHRptr =
|
||||
(pfnclReleaseSemaphoreKHR)clGetExtensionFunctionAddressForPlatform(
|
||||
opencl_platform, "clReleaseSemaphoreKHR");
|
||||
if (NULL == clReleaseSemaphoreKHRptr)
|
||||
{
|
||||
throw std::runtime_error("Failed to get the function pointer of "
|
||||
"clReleaseSemaphoreKHRptr!");
|
||||
}
|
||||
clCreateSemaphoreWithPropertiesKHRptr =
|
||||
(pfnclCreateSemaphoreWithPropertiesKHR)
|
||||
clGetExtensionFunctionAddressForPlatform(
|
||||
opencl_platform, "clCreateSemaphoreWithPropertiesKHR");
|
||||
if (NULL == clCreateSemaphoreWithPropertiesKHRptr)
|
||||
{
|
||||
throw std::runtime_error("Failed to get the function pointer of "
|
||||
"clCreateSemaphoreWithPropertiesKHRptr!");
|
||||
}
|
||||
}
|
||||
|
||||
cl_int setMaxImageDimensions(cl_device_id deviceID, size_t &max_width,
|
||||
size_t &max_height)
|
||||
{
|
||||
cl_int result = CL_SUCCESS;
|
||||
cl_ulong val;
|
||||
size_t paramSize;
|
||||
|
||||
result = clGetDeviceInfo(deviceID, CL_DEVICE_GLOBAL_MEM_SIZE,
|
||||
sizeof(cl_ulong), &val, ¶mSize);
|
||||
|
||||
if (result != CL_SUCCESS)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
|
||||
if (val < GB(4))
|
||||
{
|
||||
max_width = 256;
|
||||
max_height = 256;
|
||||
}
|
||||
else if (val < GB(8))
|
||||
{
|
||||
max_width = 512;
|
||||
max_height = 256;
|
||||
}
|
||||
else
|
||||
{
|
||||
max_width = 1024;
|
||||
max_height = 512;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
cl_int getCLFormatFromVkFormat(VkFormat vkFormat,
|
||||
cl_image_format *clImageFormat)
|
||||
{
|
||||
cl_int result = CL_SUCCESS;
|
||||
switch (vkFormat)
|
||||
{
|
||||
case VK_FORMAT_R8G8B8A8_UNORM:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_INT8;
|
||||
break;
|
||||
case VK_FORMAT_B8G8R8A8_UNORM:
|
||||
clImageFormat->image_channel_order = CL_BGRA;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16G16B16A16_UNORM:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R8G8B8A8_SINT:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_SIGNED_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16G16B16A16_SINT:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_SIGNED_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R32G32B32A32_SINT:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_SIGNED_INT32;
|
||||
break;
|
||||
case VK_FORMAT_R8G8B8A8_UINT:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16G16B16A16_UINT:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R32G32B32A32_UINT:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT32;
|
||||
break;
|
||||
case VK_FORMAT_R16G16B16A16_SFLOAT:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_HALF_FLOAT;
|
||||
break;
|
||||
case VK_FORMAT_R32G32B32A32_SFLOAT:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_FLOAT;
|
||||
break;
|
||||
case VK_FORMAT_R8_SNORM:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_SNORM_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16_SNORM:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_SNORM_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R8_UNORM:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16_UNORM:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R8_SINT:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_SIGNED_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16_SINT:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_SIGNED_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R32_SINT:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_SIGNED_INT32;
|
||||
break;
|
||||
case VK_FORMAT_R8_UINT:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16_UINT:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R32_UINT:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT32;
|
||||
break;
|
||||
case VK_FORMAT_R16_SFLOAT:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_HALF_FLOAT;
|
||||
break;
|
||||
case VK_FORMAT_R32_SFLOAT:
|
||||
clImageFormat->image_channel_order = CL_R;
|
||||
clImageFormat->image_channel_data_type = CL_FLOAT;
|
||||
break;
|
||||
case VK_FORMAT_R8G8_SNORM:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_SNORM_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16G16_SNORM:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_SNORM_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R8G8_UNORM:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16G16_UNORM:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R8G8_SINT:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_SIGNED_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16G16_SINT:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_SIGNED_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R32G32_SINT:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_SIGNED_INT32;
|
||||
break;
|
||||
case VK_FORMAT_R8G8_UINT:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16G16_UINT:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT16;
|
||||
break;
|
||||
case VK_FORMAT_R32G32_UINT:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT32;
|
||||
break;
|
||||
case VK_FORMAT_R16G16_SFLOAT:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_HALF_FLOAT;
|
||||
break;
|
||||
case VK_FORMAT_R32G32_SFLOAT:
|
||||
clImageFormat->image_channel_order = CL_RG;
|
||||
clImageFormat->image_channel_data_type = CL_FLOAT;
|
||||
break;
|
||||
case VK_FORMAT_R5G6B5_UNORM_PACK16:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_SHORT_565;
|
||||
break;
|
||||
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_SHORT_555;
|
||||
break;
|
||||
case VK_FORMAT_R8G8B8A8_SNORM:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_SNORM_INT8;
|
||||
break;
|
||||
case VK_FORMAT_R16G16B16A16_SNORM:
|
||||
clImageFormat->image_channel_order = CL_RGBA;
|
||||
clImageFormat->image_channel_data_type = CL_SNORM_INT16;
|
||||
break;
|
||||
case VK_FORMAT_B8G8R8A8_SNORM:
|
||||
clImageFormat->image_channel_order = CL_BGRA;
|
||||
clImageFormat->image_channel_data_type = CL_SNORM_INT8;
|
||||
break;
|
||||
case VK_FORMAT_B5G6R5_UNORM_PACK16:
|
||||
clImageFormat->image_channel_order = CL_BGRA;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_SHORT_565;
|
||||
break;
|
||||
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
|
||||
clImageFormat->image_channel_order = CL_BGRA;
|
||||
clImageFormat->image_channel_data_type = CL_UNORM_SHORT_555;
|
||||
break;
|
||||
case VK_FORMAT_B8G8R8A8_SINT:
|
||||
clImageFormat->image_channel_order = CL_BGRA;
|
||||
clImageFormat->image_channel_data_type = CL_SIGNED_INT8;
|
||||
break;
|
||||
case VK_FORMAT_B8G8R8A8_UINT:
|
||||
clImageFormat->image_channel_order = CL_BGRA;
|
||||
clImageFormat->image_channel_data_type = CL_UNSIGNED_INT8;
|
||||
break;
|
||||
case VK_FORMAT_A8B8G8R8_SNORM_PACK32: result = CL_INVALID_VALUE; break;
|
||||
case VK_FORMAT_A8B8G8R8_UNORM_PACK32: result = CL_INVALID_VALUE; break;
|
||||
case VK_FORMAT_A8B8G8R8_SINT_PACK32: result = CL_INVALID_VALUE; break;
|
||||
case VK_FORMAT_A8B8G8R8_UINT_PACK32: result = CL_INVALID_VALUE; break;
|
||||
default:
|
||||
log_error("Unsupported format\n");
|
||||
ASSERT(0);
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
cl_mem_object_type getImageTypeFromVk(VkImageType imageType)
|
||||
{
|
||||
cl_mem_object_type cl_image_type = CL_INVALID_VALUE;
|
||||
switch (imageType)
|
||||
{
|
||||
case VK_IMAGE_TYPE_1D: cl_image_type = CL_MEM_OBJECT_IMAGE1D; break;
|
||||
case VK_IMAGE_TYPE_2D: cl_image_type = CL_MEM_OBJECT_IMAGE2D; break;
|
||||
case VK_IMAGE_TYPE_3D: cl_image_type = CL_MEM_OBJECT_IMAGE3D; break;
|
||||
default: break;
|
||||
}
|
||||
return cl_image_type;
|
||||
}
|
||||
|
||||
size_t GetElementNBytes(const cl_image_format *format)
|
||||
{
|
||||
size_t result;
|
||||
|
||||
switch (format->image_channel_order)
|
||||
{
|
||||
case CL_R:
|
||||
case CL_A:
|
||||
case CL_INTENSITY:
|
||||
case CL_LUMINANCE:
|
||||
case CL_DEPTH: result = 1; break;
|
||||
case CL_RG:
|
||||
case CL_RA: result = 2; break;
|
||||
case CL_RGB: result = 3; break;
|
||||
case CL_RGBA:
|
||||
case CL_ARGB:
|
||||
case CL_BGRA:
|
||||
case CL_sRGBA: result = 4; break;
|
||||
default: result = 0; break;
|
||||
}
|
||||
|
||||
switch (format->image_channel_data_type)
|
||||
{
|
||||
case CL_SNORM_INT8:
|
||||
case CL_UNORM_INT8:
|
||||
case CL_SIGNED_INT8:
|
||||
case CL_UNSIGNED_INT8:
|
||||
// result *= 1;
|
||||
break;
|
||||
|
||||
case CL_SNORM_INT16:
|
||||
case CL_UNORM_INT16:
|
||||
case CL_SIGNED_INT16:
|
||||
case CL_UNSIGNED_INT16:
|
||||
case CL_HALF_FLOAT: result *= 2; break;
|
||||
|
||||
case CL_SIGNED_INT32:
|
||||
case CL_UNSIGNED_INT32:
|
||||
case CL_FLOAT: result *= 4; break;
|
||||
|
||||
case CL_UNORM_SHORT_565:
|
||||
case CL_UNORM_SHORT_555:
|
||||
if (result == 3)
|
||||
{
|
||||
result = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case CL_UNORM_INT_101010:
|
||||
if (result == 3)
|
||||
{
|
||||
result = 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
result = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
default: result = 0; break;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
cl_int get2DImageDimensions(const VkImageCreateInfo *VulkanImageCreateInfo,
|
||||
cl_image_format *img_fmt, size_t totalImageSize,
|
||||
size_t &width, size_t &height)
|
||||
{
|
||||
cl_int result = CL_SUCCESS;
|
||||
if (totalImageSize == 0)
|
||||
{
|
||||
result = CL_INVALID_VALUE;
|
||||
}
|
||||
size_t element_size = GetElementNBytes(img_fmt);
|
||||
size_t row_pitch = element_size * VulkanImageCreateInfo->extent.width;
|
||||
row_pitch = row_pitch % 64 == 0 ? row_pitch : ((row_pitch / 64) + 1) * 64;
|
||||
|
||||
width = row_pitch / element_size;
|
||||
height = totalImageSize / row_pitch;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
cl_int
|
||||
getCLImageInfoFromVkImageInfo(const VkImageCreateInfo *VulkanImageCreateInfo,
|
||||
size_t totalImageSize, cl_image_format *img_fmt,
|
||||
cl_image_desc *img_desc)
|
||||
{
|
||||
cl_int result = CL_SUCCESS;
|
||||
|
||||
cl_image_format clImgFormat = { 0 };
|
||||
result =
|
||||
getCLFormatFromVkFormat(VulkanImageCreateInfo->format, &clImgFormat);
|
||||
if (CL_SUCCESS != result)
|
||||
{
|
||||
return result;
|
||||
}
|
||||
memcpy(img_fmt, &clImgFormat, sizeof(cl_image_format));
|
||||
|
||||
img_desc->image_type = getImageTypeFromVk(VulkanImageCreateInfo->imageType);
|
||||
if (CL_INVALID_VALUE == img_desc->image_type)
|
||||
{
|
||||
return CL_INVALID_VALUE;
|
||||
}
|
||||
|
||||
result =
|
||||
get2DImageDimensions(VulkanImageCreateInfo, img_fmt, totalImageSize,
|
||||
img_desc->image_width, img_desc->image_height);
|
||||
if (CL_SUCCESS != result)
|
||||
{
|
||||
throw std::runtime_error("get2DImageDimensions failed!!!");
|
||||
}
|
||||
|
||||
img_desc->image_depth = 0; // VulkanImageCreateInfo->extent.depth;
|
||||
img_desc->image_array_size = 0;
|
||||
img_desc->image_row_pitch = 0; // Row pitch set to zero as host_ptr is NULL
|
||||
img_desc->image_slice_pitch =
|
||||
img_desc->image_row_pitch * img_desc->image_height;
|
||||
img_desc->num_mip_levels = 1;
|
||||
img_desc->num_samples = 0;
|
||||
img_desc->buffer = NULL;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
cl_int check_external_memory_handle_type(
|
||||
cl_device_id deviceID,
|
||||
cl_external_memory_handle_type_khr requiredHandleType)
|
||||
{
|
||||
unsigned int i;
|
||||
cl_external_memory_handle_type_khr *handle_type;
|
||||
size_t handle_type_size = 0;
|
||||
|
||||
cl_int errNum = CL_SUCCESS;
|
||||
|
||||
errNum = clGetDeviceInfo(deviceID,
|
||||
CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR,
|
||||
0, NULL, &handle_type_size);
|
||||
handle_type =
|
||||
(cl_external_memory_handle_type_khr *)malloc(handle_type_size);
|
||||
|
||||
errNum = clGetDeviceInfo(deviceID,
|
||||
CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR,
|
||||
handle_type_size, handle_type, NULL);
|
||||
|
||||
test_error(
|
||||
errNum,
|
||||
"Unable to query CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR \n");
|
||||
|
||||
for (i = 0; i < handle_type_size; i++)
|
||||
{
|
||||
if (requiredHandleType == handle_type[i])
|
||||
{
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
}
|
||||
log_error("cl_khr_external_memory extension is missing support for %d\n",
|
||||
requiredHandleType);
|
||||
|
||||
return CL_INVALID_VALUE;
|
||||
}
|
||||
|
||||
cl_int check_external_semaphore_handle_type(
|
||||
cl_device_id deviceID,
|
||||
cl_external_semaphore_handle_type_khr requiredHandleType)
|
||||
{
|
||||
unsigned int i;
|
||||
cl_external_semaphore_handle_type_khr *handle_type;
|
||||
size_t handle_type_size = 0;
|
||||
cl_int errNum = CL_SUCCESS;
|
||||
|
||||
errNum =
|
||||
clGetDeviceInfo(deviceID, CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR,
|
||||
0, NULL, &handle_type_size);
|
||||
handle_type =
|
||||
(cl_external_semaphore_handle_type_khr *)malloc(handle_type_size);
|
||||
|
||||
errNum =
|
||||
clGetDeviceInfo(deviceID, CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR,
|
||||
handle_type_size, handle_type, NULL);
|
||||
|
||||
test_error(
|
||||
errNum,
|
||||
"Unable to query CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR \n");
|
||||
|
||||
for (i = 0; i < handle_type_size; i++)
|
||||
{
|
||||
if (requiredHandleType == handle_type[i])
|
||||
{
|
||||
return CL_SUCCESS;
|
||||
}
|
||||
}
|
||||
log_error("cl_khr_external_semaphore extension is missing support for %d\n",
|
||||
requiredHandleType);
|
||||
|
||||
return CL_INVALID_VALUE;
|
||||
}
|
||||
clExternalMemory::clExternalMemory() {}
|
||||
|
||||
clExternalMemory::clExternalMemory(const clExternalMemory &externalMemory)
|
||||
: m_externalMemory(externalMemory.m_externalMemory)
|
||||
{}
|
||||
|
||||
clExternalMemory::clExternalMemory(
|
||||
const VulkanDeviceMemory *deviceMemory,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType, uint64_t offset,
|
||||
uint64_t size, cl_context context, cl_device_id deviceId)
|
||||
{
|
||||
int err = 0;
|
||||
m_externalMemory = NULL;
|
||||
cl_device_id devList[] = { deviceId, NULL };
|
||||
std::vector<cl_mem_properties> extMemProperties;
|
||||
#ifdef _WIN32
|
||||
if (!is_extension_available(devList[0], "cl_khr_external_memory_win32"))
|
||||
{
|
||||
throw std::runtime_error(
|
||||
"Device does not support cl_khr_external_memory_win32 extension\n");
|
||||
}
|
||||
#else
|
||||
if (!is_extension_available(devList[0], "cl_khr_external_memory_opaque_fd"))
|
||||
{
|
||||
throw std::runtime_error(
|
||||
"Device does not support cl_khr_external_memory_opaque_fd "
|
||||
"extension \n");
|
||||
}
|
||||
#endif
|
||||
|
||||
switch (externalMemoryHandleType)
|
||||
{
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
|
||||
#ifdef _WIN32
|
||||
ASSERT(0);
|
||||
#endif
|
||||
log_info("Opaque file descriptors are not supported on Windows\n");
|
||||
fd = (int)deviceMemory->getHandle(externalMemoryHandleType);
|
||||
err = check_external_memory_handle_type(
|
||||
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
|
||||
extMemProperties.push_back(
|
||||
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
|
||||
extMemProperties.push_back((cl_mem_properties)fd);
|
||||
break;
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
|
||||
#ifndef _WIN32
|
||||
ASSERT(0);
|
||||
#else
|
||||
log_info(" Opaque NT handles are only supported on Windows\n");
|
||||
handle = deviceMemory->getHandle(externalMemoryHandleType);
|
||||
err = check_external_memory_handle_type(
|
||||
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
|
||||
extMemProperties.push_back(
|
||||
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
|
||||
extMemProperties.push_back((cl_mem_properties)handle);
|
||||
#endif
|
||||
break;
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
|
||||
#ifndef _WIN32
|
||||
ASSERT(0);
|
||||
#else
|
||||
log_info("Opaque D3DKMT handles are only supported on Windows\n");
|
||||
handle = deviceMemory->getHandle(externalMemoryHandleType);
|
||||
err = check_external_memory_handle_type(
|
||||
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
|
||||
extMemProperties.push_back(
|
||||
(cl_mem_properties)
|
||||
CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
|
||||
extMemProperties.push_back((cl_mem_properties)handle);
|
||||
#endif
|
||||
break;
|
||||
default:
|
||||
ASSERT(0);
|
||||
log_error("Unsupported external memory handle type\n");
|
||||
break;
|
||||
}
|
||||
if (CL_SUCCESS != err)
|
||||
{
|
||||
throw std::runtime_error("Unsupported external memory type\n ");
|
||||
}
|
||||
|
||||
extMemProperties.push_back((cl_mem_properties)CL_DEVICE_HANDLE_LIST_KHR);
|
||||
extMemProperties.push_back((cl_mem_properties)devList[0]);
|
||||
extMemProperties.push_back(
|
||||
(cl_mem_properties)CL_DEVICE_HANDLE_LIST_END_KHR);
|
||||
extMemProperties.push_back(0);
|
||||
|
||||
m_externalMemory = clCreateBufferWithProperties(
|
||||
context, extMemProperties.data(), 1, size, NULL, &err);
|
||||
if (CL_SUCCESS != err)
|
||||
{
|
||||
log_error("clCreateBufferWithProperties failed with %d\n", err);
|
||||
throw std::runtime_error("clCreateBufferWithProperties failed ");
|
||||
}
|
||||
}
|
||||
clExternalMemoryImage::clExternalMemoryImage(
|
||||
const VulkanDeviceMemory &deviceMemory,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType, cl_context context,
|
||||
size_t totalImageMemSize, size_t imageWidth, size_t imageHeight,
|
||||
size_t totalSize, const VulkanImage2D &image2D, cl_device_id deviceId)
|
||||
{
|
||||
cl_int errcode_ret = 0;
|
||||
std::vector<cl_mem_properties> extMemProperties1;
|
||||
cl_device_id devList[] = { deviceId, NULL };
|
||||
|
||||
#ifdef _WIN32
|
||||
if (!is_extension_available(devList[0], "cl_khr_external_memory_win32"))
|
||||
{
|
||||
throw std::runtime_error("Device does not support "
|
||||
"cl_khr_external_memory_win32 extension \n");
|
||||
}
|
||||
#elif !defined(__APPLE__)
|
||||
if (!is_extension_available(devList[0], "cl_khr_external_memory_opaque_fd"))
|
||||
{
|
||||
throw std::runtime_error(
|
||||
"Device does not support cl_khr_external_memory_opaque_fd "
|
||||
"extension\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
switch (externalMemoryHandleType)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
|
||||
log_info("Opaque NT handles are only supported on Windows\n");
|
||||
handle = deviceMemory.getHandle(externalMemoryHandleType);
|
||||
errcode_ret = check_external_memory_handle_type(
|
||||
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
|
||||
extMemProperties1.push_back(
|
||||
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR);
|
||||
extMemProperties1.push_back((cl_mem_properties)handle);
|
||||
break;
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
|
||||
log_info("Opaque D3DKMT handles are only supported on Windows\n");
|
||||
handle = deviceMemory.getHandle(externalMemoryHandleType);
|
||||
errcode_ret = check_external_memory_handle_type(
|
||||
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
|
||||
extMemProperties1.push_back(
|
||||
(cl_mem_properties)
|
||||
CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR);
|
||||
extMemProperties1.push_back((cl_mem_properties)handle);
|
||||
break;
|
||||
#elif !defined(__APPLE__)
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
|
||||
log_info(" Opaque file descriptors are not supported on Windows\n");
|
||||
fd = (int)deviceMemory.getHandle(externalMemoryHandleType);
|
||||
errcode_ret = check_external_memory_handle_type(
|
||||
devList[0], CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
|
||||
extMemProperties1.push_back(
|
||||
(cl_mem_properties)CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR);
|
||||
extMemProperties1.push_back((cl_mem_properties)fd);
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
ASSERT(0);
|
||||
log_error("Unsupported external memory handle type\n");
|
||||
break;
|
||||
}
|
||||
if (CL_SUCCESS != errcode_ret)
|
||||
{
|
||||
throw std::runtime_error("Unsupported external memory type\n ");
|
||||
}
|
||||
// Set cl_image_desc
|
||||
size_t clImageFormatSize;
|
||||
cl_image_desc image_desc;
|
||||
memset(&image_desc, 0x0, sizeof(cl_image_desc));
|
||||
cl_image_format img_format = { 0 };
|
||||
const VkImageCreateInfo VulkanImageCreateInfo =
|
||||
image2D.getVkImageCreateInfo();
|
||||
|
||||
errcode_ret = getCLImageInfoFromVkImageInfo(
|
||||
&VulkanImageCreateInfo, image2D.getSize(), &img_format, &image_desc);
|
||||
if (CL_SUCCESS != errcode_ret)
|
||||
{
|
||||
throw std::runtime_error("getCLImageInfoFromVkImageInfo failed!!!");
|
||||
}
|
||||
|
||||
extMemProperties1.push_back((cl_mem_properties)CL_DEVICE_HANDLE_LIST_KHR);
|
||||
extMemProperties1.push_back((cl_mem_properties)devList[0]);
|
||||
extMemProperties1.push_back(
|
||||
(cl_mem_properties)CL_DEVICE_HANDLE_LIST_END_KHR);
|
||||
extMemProperties1.push_back(0);
|
||||
m_externalMemory = clCreateImageWithProperties(
|
||||
context, extMemProperties1.data(), CL_MEM_READ_WRITE, &img_format,
|
||||
&image_desc, NULL, &errcode_ret);
|
||||
if (CL_SUCCESS != errcode_ret)
|
||||
{
|
||||
throw std::runtime_error("clCreateImageWithProperties failed!!!");
|
||||
}
|
||||
}
|
||||
|
||||
cl_mem clExternalMemory::getExternalMemoryBuffer() { return m_externalMemory; }
|
||||
|
||||
cl_mem clExternalMemoryImage::getExternalMemoryImage()
|
||||
{
|
||||
return m_externalMemory;
|
||||
}
|
||||
|
||||
clExternalMemoryImage::~clExternalMemoryImage()
|
||||
{
|
||||
clReleaseMemObject(m_externalMemory);
|
||||
}
|
||||
|
||||
clExternalMemory::~clExternalMemory() { clReleaseMemObject(m_externalMemory); }
|
||||
|
||||
clExternalMemoryImage::clExternalMemoryImage() {}
|
||||
|
||||
|
||||
//////////////////////////////////////////
|
||||
// clExternalSemaphore implementation //
|
||||
//////////////////////////////////////////
|
||||
|
||||
clExternalSemaphore::clExternalSemaphore(
|
||||
const clExternalSemaphore &externalSemaphore)
|
||||
: m_externalSemaphore(externalSemaphore.m_externalSemaphore)
|
||||
{}
|
||||
|
||||
clExternalSemaphore::clExternalSemaphore(
|
||||
const VulkanSemaphore &semaphore, cl_context context,
|
||||
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType,
|
||||
cl_device_id deviceId)
|
||||
{
|
||||
|
||||
cl_int err = 0;
|
||||
cl_device_id devList[] = { deviceId, NULL };
|
||||
|
||||
#ifdef _WIN32
|
||||
if (!is_extension_available(devList[0], "cl_khr_external_semaphore_win32"))
|
||||
{
|
||||
throw std::runtime_error("Device does not support "
|
||||
"cl_khr_external_semaphore_win32 extension\n");
|
||||
}
|
||||
#elif !defined(__APPLE__)
|
||||
if (!is_extension_available(devList[0],
|
||||
"cl_khr_external_semaphore_opaque_fd"))
|
||||
{
|
||||
throw std::runtime_error(
|
||||
"Device does not support cl_khr_external_semaphore_opaque_fd "
|
||||
"extension \n");
|
||||
}
|
||||
#endif
|
||||
|
||||
std::vector<cl_semaphore_properties_khr> sema_props{
|
||||
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_KHR,
|
||||
(cl_semaphore_properties_khr)CL_SEMAPHORE_TYPE_BINARY_KHR,
|
||||
};
|
||||
switch (externalSemaphoreHandleType)
|
||||
{
|
||||
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
|
||||
#ifdef _WIN32
|
||||
ASSERT(0);
|
||||
#else
|
||||
log_info(" Opaque file descriptors are not supported on Windows\n");
|
||||
fd = (int)semaphore.getHandle(externalSemaphoreHandleType);
|
||||
err = check_external_semaphore_handle_type(
|
||||
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
|
||||
sema_props.push_back(
|
||||
(cl_semaphore_properties_khr)CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR);
|
||||
sema_props.push_back((cl_semaphore_properties_khr)fd);
|
||||
#endif
|
||||
break;
|
||||
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
|
||||
#ifndef _WIN32
|
||||
ASSERT(0);
|
||||
#else
|
||||
log_info(" Opaque NT handles are only supported on Windows\n");
|
||||
handle = semaphore.getName().size()
|
||||
? NULL
|
||||
: semaphore.getHandle(externalSemaphoreHandleType);
|
||||
err = check_external_semaphore_handle_type(
|
||||
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
|
||||
sema_props.push_back((cl_semaphore_properties_khr)
|
||||
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR);
|
||||
sema_props.push_back((cl_semaphore_properties_khr)handle);
|
||||
#endif
|
||||
break;
|
||||
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
|
||||
#ifndef _WIN32
|
||||
ASSERT(0);
|
||||
#else
|
||||
log_info(" Opaque D3DKMT handles are only supported on Windows\n");
|
||||
handle = semaphore.getHandle(externalSemaphoreHandleType);
|
||||
err = check_external_semaphore_handle_type(
|
||||
devList[0], CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
|
||||
sema_props.push_back((cl_semaphore_properties_khr)
|
||||
CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR);
|
||||
sema_props.push_back((cl_semaphore_properties_khr)handle);
|
||||
#endif
|
||||
break;
|
||||
default:
|
||||
ASSERT(0);
|
||||
log_error("Unsupported external memory handle type\n");
|
||||
break;
|
||||
}
|
||||
if (CL_SUCCESS != err)
|
||||
{
|
||||
throw std::runtime_error(
|
||||
"Unsupported external sempahore handle type\n ");
|
||||
}
|
||||
|
||||
sema_props.push_back(
|
||||
(cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_KHR);
|
||||
sema_props.push_back((cl_semaphore_properties_khr)devList[0]);
|
||||
sema_props.push_back(
|
||||
(cl_semaphore_properties_khr)CL_DEVICE_HANDLE_LIST_END_KHR);
|
||||
sema_props.push_back(0);
|
||||
m_externalSemaphore =
|
||||
clCreateSemaphoreWithPropertiesKHRptr(context, sema_props.data(), &err);
|
||||
if (CL_SUCCESS != err)
|
||||
{
|
||||
log_error("clCreateSemaphoreWithPropertiesKHRptr failed with %d\n",
|
||||
err);
|
||||
throw std::runtime_error(
|
||||
"clCreateSemaphoreWithPropertiesKHRptr failed! ");
|
||||
}
|
||||
}
|
||||
|
||||
clExternalSemaphore::~clExternalSemaphore()
|
||||
{
|
||||
cl_int err = clReleaseSemaphoreKHRptr(m_externalSemaphore);
|
||||
if (err != CL_SUCCESS)
|
||||
{
|
||||
throw std::runtime_error("clReleaseSemaphoreKHR failed!");
|
||||
}
|
||||
}
|
||||
|
||||
void clExternalSemaphore::signal(cl_command_queue cmd_queue)
|
||||
{
|
||||
clEnqueueSignalSemaphoresKHRptr(cmd_queue, 1, &m_externalSemaphore, NULL, 0,
|
||||
NULL, NULL);
|
||||
}
|
||||
|
||||
void clExternalSemaphore::wait(cl_command_queue cmd_queue)
|
||||
{
|
||||
clEnqueueWaitSemaphoresKHRptr(cmd_queue, 1, &m_externalSemaphore, NULL, 0,
|
||||
NULL, NULL);
|
||||
}
|
||||
@@ -1,131 +0,0 @@
|
||||
//
|
||||
// Copyright (c) 2022 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
#ifndef _opencl_vulkan_wrapper_hpp_
|
||||
#define _opencl_vulkan_wrapper_hpp_
|
||||
|
||||
#include "vulkan_wrapper.hpp"
|
||||
|
||||
#if !defined(__APPLE__)
|
||||
#include <CL/cl.h>
|
||||
#include <CL/cl_ext.h>
|
||||
#else
|
||||
#include <OpenCL/cl.h>
|
||||
#include <OpenCL/cl_ext.h>
|
||||
#endif
|
||||
|
||||
typedef cl_semaphore_khr (*pfnclCreateSemaphoreWithPropertiesKHR)(
|
||||
cl_context context, cl_semaphore_properties_khr *sema_props,
|
||||
cl_int *errcode_ret);
|
||||
typedef cl_int (*pfnclEnqueueWaitSemaphoresKHR)(
|
||||
cl_command_queue command_queue, cl_uint num_semaphores,
|
||||
const cl_semaphore_khr *sema_list,
|
||||
const cl_semaphore_payload_khr *sema_payload_list,
|
||||
cl_uint num_events_in_wait_list, const cl_event *event_wait_list,
|
||||
cl_event *event);
|
||||
typedef cl_int (*pfnclEnqueueSignalSemaphoresKHR)(
|
||||
cl_command_queue command_queue, cl_uint num_semaphores,
|
||||
const cl_semaphore_khr *sema_list,
|
||||
const cl_semaphore_payload_khr *sema_payload_list,
|
||||
cl_uint num_events_in_wait_list, const cl_event *event_wait_list,
|
||||
cl_event *event);
|
||||
typedef cl_int (*pfnclEnqueueAcquireExternalMemObjectsKHR)(
|
||||
cl_command_queue command_queue, cl_uint num_mem_objects,
|
||||
const cl_mem *mem_objects, cl_uint num_events_in_wait_list,
|
||||
const cl_event *event_wait_list, cl_event *event);
|
||||
typedef cl_int (*pfnclEnqueueReleaseExternalMemObjectsKHR)(
|
||||
cl_command_queue command_queue, cl_uint num_mem_objects,
|
||||
const cl_mem *mem_objects, cl_uint num_events_in_wait_list,
|
||||
const cl_event *event_wait_list, cl_event *event);
|
||||
typedef cl_int (*pfnclReleaseSemaphoreKHR)(cl_semaphore_khr sema_object);
|
||||
|
||||
extern pfnclCreateSemaphoreWithPropertiesKHR
|
||||
clCreateSemaphoreWithPropertiesKHRptr;
|
||||
extern pfnclEnqueueWaitSemaphoresKHR clEnqueueWaitSemaphoresKHRptr;
|
||||
extern pfnclEnqueueSignalSemaphoresKHR clEnqueueSignalSemaphoresKHRptr;
|
||||
extern pfnclEnqueueAcquireExternalMemObjectsKHR
|
||||
clEnqueueAcquireExternalMemObjectsKHRptr;
|
||||
extern pfnclEnqueueReleaseExternalMemObjectsKHR
|
||||
clEnqueueReleaseExternalMemObjectsKHRptr;
|
||||
extern pfnclReleaseSemaphoreKHR clReleaseSemaphoreKHRptr;
|
||||
|
||||
cl_int getCLImageInfoFromVkImageInfo(const VkImageCreateInfo *, size_t,
|
||||
cl_image_format *, cl_image_desc *);
|
||||
cl_int check_external_memory_handle_type(
|
||||
cl_device_id deviceID,
|
||||
cl_external_memory_handle_type_khr requiredHandleType);
|
||||
cl_int check_external_semaphore_handle_type(
|
||||
cl_device_id deviceID,
|
||||
cl_external_semaphore_handle_type_khr requiredHandleType);
|
||||
cl_int setMaxImageDimensions(cl_device_id deviceID, size_t &width,
|
||||
size_t &height);
|
||||
|
||||
class clExternalMemory {
|
||||
protected:
|
||||
cl_mem m_externalMemory;
|
||||
int fd;
|
||||
void *handle;
|
||||
clExternalMemory(const clExternalMemory &externalMemory);
|
||||
|
||||
public:
|
||||
clExternalMemory();
|
||||
clExternalMemory(const VulkanDeviceMemory *deviceMemory,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType,
|
||||
uint64_t offset, uint64_t size, cl_context context,
|
||||
cl_device_id deviceId);
|
||||
|
||||
virtual ~clExternalMemory();
|
||||
cl_mem getExternalMemoryBuffer();
|
||||
};
|
||||
class clExternalMemoryImage {
|
||||
protected:
|
||||
cl_mem m_externalMemory;
|
||||
int fd;
|
||||
void *handle;
|
||||
cl_command_queue cmd_queue;
|
||||
clExternalMemoryImage();
|
||||
|
||||
public:
|
||||
clExternalMemoryImage(
|
||||
const VulkanDeviceMemory &deviceMemory,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType,
|
||||
cl_context context, size_t totalImageMemSize, size_t imageWidth,
|
||||
size_t imageHeight, size_t totalSize, const VulkanImage2D &image2D,
|
||||
cl_device_id deviceId);
|
||||
virtual ~clExternalMemoryImage();
|
||||
cl_mem getExternalMemoryImage();
|
||||
};
|
||||
|
||||
class clExternalSemaphore {
|
||||
protected:
|
||||
cl_semaphore_khr m_externalSemaphore;
|
||||
int fd;
|
||||
void *handle;
|
||||
clExternalSemaphore(const clExternalSemaphore &externalSemaphore);
|
||||
|
||||
public:
|
||||
clExternalSemaphore(
|
||||
const VulkanSemaphore &deviceSemaphore, cl_context context,
|
||||
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType,
|
||||
cl_device_id deviceId);
|
||||
virtual ~clExternalSemaphore();
|
||||
void signal(cl_command_queue command_queue);
|
||||
void wait(cl_command_queue command_queue);
|
||||
// operator openclExternalSemaphore_t() const;
|
||||
};
|
||||
|
||||
extern void init_cl_vk_ext(cl_platform_id);
|
||||
|
||||
#endif // _opencl_vulkan_wrapper_hpp_
|
||||
@@ -1,195 +0,0 @@
|
||||
//
|
||||
// Copyright (c) 2022 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
|
||||
#ifndef _vulkan_api_list_hpp_
|
||||
#define _vulkan_api_list_hpp_
|
||||
|
||||
#define VK_FUNC_LIST \
|
||||
VK_FUNC_DECL(vkEnumerateInstanceVersion) \
|
||||
VK_FUNC_DECL(vkEnumerateInstanceExtensionProperties) \
|
||||
VK_FUNC_DECL(vkEnumerateInstanceLayerProperties) \
|
||||
VK_FUNC_DECL(vkCreateInstance) \
|
||||
VK_FUNC_DECL(vkGetInstanceProcAddr) \
|
||||
VK_FUNC_DECL(vkGetDeviceProcAddr) \
|
||||
VK_FUNC_DECL(vkEnumeratePhysicalDevices) \
|
||||
VK_FUNC_DECL(vkGetPhysicalDeviceProperties) \
|
||||
VK_FUNC_DECL(vkCreateDevice) \
|
||||
VK_FUNC_DECL(vkDestroyDevice) \
|
||||
VK_FUNC_DECL(vkGetDeviceQueue) \
|
||||
VK_FUNC_DECL(vkQueueWaitIdle) \
|
||||
VK_FUNC_DECL(vkCreateDescriptorSetLayout) \
|
||||
VK_FUNC_DECL(vkCreatePipelineLayout) \
|
||||
VK_FUNC_DECL(vkCreateShaderModule) \
|
||||
VK_FUNC_DECL(vkCreateComputePipelines) \
|
||||
VK_FUNC_DECL(vkCreateDescriptorPool) \
|
||||
VK_FUNC_DECL(vkAllocateDescriptorSets) \
|
||||
VK_FUNC_DECL(vkFreeDescriptorSets) \
|
||||
VK_FUNC_DECL(vkAllocateCommandBuffers) \
|
||||
VK_FUNC_DECL(vkBeginCommandBuffer) \
|
||||
VK_FUNC_DECL(vkCmdBindPipeline) \
|
||||
VK_FUNC_DECL(vkCmdBindDescriptorSets) \
|
||||
VK_FUNC_DECL(vkCmdPipelineBarrier) \
|
||||
VK_FUNC_DECL(vkCmdDispatch) \
|
||||
VK_FUNC_DECL(vkCmdFillBuffer) \
|
||||
VK_FUNC_DECL(vkCmdCopyBuffer) \
|
||||
VK_FUNC_DECL(vkCmdUpdateBuffer) \
|
||||
VK_FUNC_DECL(vkCmdCopyBufferToImage) \
|
||||
VK_FUNC_DECL(vkCmdCopyImageToBuffer) \
|
||||
VK_FUNC_DECL(vkEndCommandBuffer) \
|
||||
VK_FUNC_DECL(vkCreateBuffer) \
|
||||
VK_FUNC_DECL(vkCreateImageView) \
|
||||
VK_FUNC_DECL(vkAllocateMemory) \
|
||||
VK_FUNC_DECL(vkMapMemory) \
|
||||
VK_FUNC_DECL(vkBindBufferMemory) \
|
||||
VK_FUNC_DECL(vkBindImageMemory) \
|
||||
VK_FUNC_DECL(vkUnmapMemory) \
|
||||
VK_FUNC_DECL(vkFreeMemory) \
|
||||
VK_FUNC_DECL(vkCreateCommandPool) \
|
||||
VK_FUNC_DECL(vkResetCommandPool) \
|
||||
VK_FUNC_DECL(vkDestroyCommandPool) \
|
||||
VK_FUNC_DECL(vkResetCommandBuffer) \
|
||||
VK_FUNC_DECL(vkFreeCommandBuffers) \
|
||||
VK_FUNC_DECL(vkQueueSubmit) \
|
||||
VK_FUNC_DECL(vkCmdExecuteCommands) \
|
||||
VK_FUNC_DECL(vkCreateFence) \
|
||||
VK_FUNC_DECL(vkDestroyFence) \
|
||||
VK_FUNC_DECL(vkGetFenceStatus) \
|
||||
VK_FUNC_DECL(vkResetFences) \
|
||||
VK_FUNC_DECL(vkWaitForFences) \
|
||||
VK_FUNC_DECL(vkCreateSemaphore) \
|
||||
VK_FUNC_DECL(vkDestroySemaphore) \
|
||||
VK_FUNC_DECL(vkCreateEvent) \
|
||||
VK_FUNC_DECL(vkDestroyImageView) \
|
||||
VK_FUNC_DECL(vkCreateImage) \
|
||||
VK_FUNC_DECL(vkGetImageMemoryRequirements) \
|
||||
VK_FUNC_DECL(vkDestroyImage) \
|
||||
VK_FUNC_DECL(vkDestroyBuffer) \
|
||||
VK_FUNC_DECL(vkDestroyPipeline) \
|
||||
VK_FUNC_DECL(vkDestroyShaderModule) \
|
||||
VK_FUNC_DECL(vkGetPhysicalDeviceMemoryProperties) \
|
||||
VK_FUNC_DECL(vkDestroyInstance) \
|
||||
VK_FUNC_DECL(vkUpdateDescriptorSets) \
|
||||
VK_FUNC_DECL(vkDestroyDescriptorPool) \
|
||||
VK_FUNC_DECL(vkDestroyPipelineLayout) \
|
||||
VK_FUNC_DECL(vkDestroyDescriptorSetLayout) \
|
||||
VK_FUNC_DECL(vkGetPhysicalDeviceQueueFamilyProperties) \
|
||||
VK_FUNC_DECL(vkGetPhysicalDeviceFeatures) \
|
||||
VK_FUNC_DECL(vkGetPhysicalDeviceProperties2KHR) \
|
||||
VK_FUNC_DECL(vkGetBufferMemoryRequirements) \
|
||||
VK_FUNC_DECL(vkGetMemoryFdKHR) \
|
||||
VK_FUNC_DECL(vkGetSemaphoreFdKHR) \
|
||||
VK_FUNC_DECL(vkEnumeratePhysicalDeviceGroups) \
|
||||
VK_FUNC_DECL(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \
|
||||
VK_FUNC_DECL(vkGetPhysicalDeviceSurfaceFormatsKHR) \
|
||||
VK_FUNC_DECL(vkGetPhysicalDeviceSurfacePresentModesKHR) \
|
||||
VK_FUNC_DECL(vkEnumerateDeviceExtensionProperties) \
|
||||
VK_FUNC_DECL(vkGetPhysicalDeviceSurfaceSupportKHR)
|
||||
|
||||
#define VK_WINDOWS_FUNC_LIST \
|
||||
VK_FUNC_DECL(vkGetMemoryWin32HandleKHR) \
|
||||
VK_FUNC_DECL(vkGetSemaphoreWin32HandleKHR)
|
||||
|
||||
#define vkEnumerateInstanceVersion _vkEnumerateInstanceVersion
|
||||
#define vkEnumerateInstanceExtensionProperties \
|
||||
_vkEnumerateInstanceExtensionProperties
|
||||
#define vkEnumerateInstanceLayerProperties _vkEnumerateInstanceLayerProperties
|
||||
#define vkCreateInstance _vkCreateInstance
|
||||
#define vkGetInstanceProcAddr _vkGetInstanceProcAddr
|
||||
#define vkGetDeviceProcAddr _vkGetDeviceProcAddr
|
||||
#define vkEnumeratePhysicalDevices _vkEnumeratePhysicalDevices
|
||||
#define vkGetPhysicalDeviceProperties _vkGetPhysicalDeviceProperties
|
||||
#define vkCreateDevice _vkCreateDevice
|
||||
#define vkDestroyDevice _vkDestroyDevice
|
||||
#define vkGetDeviceQueue _vkGetDeviceQueue
|
||||
#define vkQueueWaitIdle _vkQueueWaitIdle
|
||||
#define vkCreateDescriptorSetLayout _vkCreateDescriptorSetLayout
|
||||
#define vkCreatePipelineLayout _vkCreatePipelineLayout
|
||||
#define vkCreateShaderModule _vkCreateShaderModule
|
||||
#define vkCreateComputePipelines _vkCreateComputePipelines
|
||||
#define vkCreateDescriptorPool _vkCreateDescriptorPool
|
||||
#define vkAllocateDescriptorSets _vkAllocateDescriptorSets
|
||||
#define vkFreeDescriptorSets _vkFreeDescriptorSets
|
||||
#define vkAllocateCommandBuffers _vkAllocateCommandBuffers
|
||||
#define vkBeginCommandBuffer _vkBeginCommandBuffer
|
||||
#define vkCmdBindPipeline _vkCmdBindPipeline
|
||||
#define vkCmdBindDescriptorSets _vkCmdBindDescriptorSets
|
||||
#define vkCmdPipelineBarrier _vkCmdPipelineBarrier
|
||||
#define vkCmdDispatch _vkCmdDispatch
|
||||
#define vkCmdFillBuffer _vkCmdFillBuffer
|
||||
#define vkCmdCopyBuffer _vkCmdCopyBuffer
|
||||
#define vkCmdUpdateBuffer _vkCmdUpdateBuffer
|
||||
#define vkCmdCopyBufferToImage _vkCmdCopyBufferToImage
|
||||
#define vkCmdCopyImageToBuffer _vkCmdCopyImageToBuffer
|
||||
#define vkEndCommandBuffer _vkEndCommandBuffer
|
||||
#define vkCreateBuffer _vkCreateBuffer
|
||||
#define vkCreateImageView _vkCreateImageView
|
||||
#define vkAllocateMemory _vkAllocateMemory
|
||||
#define vkMapMemory _vkMapMemory
|
||||
#define vkBindBufferMemory _vkBindBufferMemory
|
||||
#define vkBindImageMemory _vkBindImageMemory
|
||||
#define vkUnmapMemory _vkUnmapMemory
|
||||
#define vkFreeMemory _vkFreeMemory
|
||||
#define vkCreateCommandPool _vkCreateCommandPool
|
||||
#define vkResetCommandPool _vkResetCommandPool
|
||||
#define vkDestroyCommandPool _vkDestroyCommandPool
|
||||
#define vkResetCommandBuffer _vkResetCommandBuffer
|
||||
#define vkFreeCommandBuffers _vkFreeCommandBuffers
|
||||
#define vkQueueSubmit _vkQueueSubmit
|
||||
#define vkCmdExecuteCommands _vkCmdExecuteCommands
|
||||
#define vkCreateFence _vkCreateFence
|
||||
#define vkDestroyFence _vkDestroyFence
|
||||
#define vkGetFenceStatus _vkGetFenceStatus
|
||||
#define vkResetFences _vkResetFences
|
||||
#define vkWaitForFences _vkWaitForFences
|
||||
#define vkCreateSemaphore _vkCreateSemaphore
|
||||
#define vkDestroySemaphore _vkDestroySemaphore
|
||||
#define vkCreateEvent _vkCreateEvent
|
||||
#define vkDestroyImageView _vkDestroyImageView
|
||||
#define vkCreateImage _vkCreateImage
|
||||
#define vkGetImageMemoryRequirements _vkGetImageMemoryRequirements
|
||||
#define vkDestroyImage _vkDestroyImage
|
||||
#define vkDestroyBuffe _vkDestroyBuffer
|
||||
#define vkDestroyPipeline _vkDestroyPipeline
|
||||
#define vkDestroyShaderModule _vkDestroyShaderModule
|
||||
#define vkGetPhysicalDeviceMemoryProperties _vkGetPhysicalDeviceMemoryProperties
|
||||
#define vkDestroyInstance _vkDestroyInstance
|
||||
#define vkUpdateDescriptorSets _vkUpdateDescriptorSets
|
||||
#define vkDestroyDescriptorPool _vkDestroyDescriptorPool
|
||||
#define vkDestroyPipelineLayout _vkDestroyPipelineLayout
|
||||
#define vkDestroyDescriptorSetLayout _vkDestroyDescriptorSetLayout
|
||||
#define vkGetPhysicalDeviceQueueFamilyProperties \
|
||||
_vkGetPhysicalDeviceQueueFamilyProperties
|
||||
#define vkGetPhysicalDeviceFeatures _vkGetPhysicalDeviceFeatures
|
||||
#define vkGetPhysicalDeviceProperties2KHR _vkGetPhysicalDeviceProperties2KHR
|
||||
#define vkGetBufferMemoryRequirements _vkGetBufferMemoryRequirements
|
||||
#define vkGetMemoryFdKHR _vkGetMemoryFdKHR
|
||||
#define vkGetSemaphoreFdKHR _vkGetSemaphoreFdKHR
|
||||
#define vkEnumeratePhysicalDeviceGroups _vkEnumeratePhysicalDeviceGroups
|
||||
#define vkGetPhysicalDeviceSurfaceCapabilitiesKHR \
|
||||
_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
|
||||
#define vkGetPhysicalDeviceSurfaceFormatsKHR \
|
||||
_vkGetPhysicalDeviceSurfaceFormatsKHR
|
||||
#define vkGetPhysicalDeviceSurfacePresentModesKHR \
|
||||
_vkGetPhysicalDeviceSurfacePresentModesKHR
|
||||
#define vkEnumerateDeviceExtensionProperties \
|
||||
_vkEnumerateDeviceExtensionProperties
|
||||
#define vkGetPhysicalDeviceSurfaceSupportKHR \
|
||||
_vkGetPhysicalDeviceSurfaceSupportKHR
|
||||
|
||||
#define vkGetMemoryWin32HandleKHR _vkGetMemoryWin32HandleKHR
|
||||
#define vkGetSemaphoreWin32HandleKHR _vkGetSemaphoreWin32HandleKHR
|
||||
|
||||
#endif //_vulkan_api_list_hpp_
|
||||
@@ -1,423 +0,0 @@
|
||||
//
|
||||
// Copyright (c) 2022 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
|
||||
|
||||
#include <algorithm>
|
||||
#include "vulkan_list_map.hpp"
|
||||
#include "vulkan_utility.hpp"
|
||||
#include "vulkan_wrapper.hpp"
|
||||
|
||||
/////////////////////////////////////////////
|
||||
// VulkanPhysicalDeviceList implementation //
|
||||
/////////////////////////////////////////////
|
||||
|
||||
VulkanPhysicalDeviceList::VulkanPhysicalDeviceList(
|
||||
const VulkanPhysicalDeviceList &physicalDeviceList)
|
||||
{}
|
||||
|
||||
VulkanPhysicalDeviceList::VulkanPhysicalDeviceList() {}
|
||||
|
||||
VulkanPhysicalDeviceList::~VulkanPhysicalDeviceList() {}
|
||||
|
||||
/////////////////////////////////////////
|
||||
// VulkanMemoryHeapList implementation //
|
||||
/////////////////////////////////////////
|
||||
|
||||
VulkanMemoryHeapList::VulkanMemoryHeapList(
|
||||
const VulkanMemoryHeapList &memoryHeapList)
|
||||
{}
|
||||
|
||||
VulkanMemoryHeapList::VulkanMemoryHeapList() {}
|
||||
|
||||
VulkanMemoryHeapList::~VulkanMemoryHeapList() {}
|
||||
|
||||
/////////////////////////////////////////
|
||||
// VulkanMemoryTypeList implementation //
|
||||
/////////////////////////////////////////
|
||||
|
||||
VulkanMemoryTypeList::VulkanMemoryTypeList(
|
||||
const VulkanMemoryTypeList &memoryTypeList)
|
||||
{}
|
||||
|
||||
VulkanMemoryTypeList::VulkanMemoryTypeList() {}
|
||||
|
||||
VulkanMemoryTypeList::~VulkanMemoryTypeList() {}
|
||||
|
||||
//////////////////////////////////////////
|
||||
// VulkanQueueFamilyList implementation //
|
||||
//////////////////////////////////////////
|
||||
|
||||
VulkanQueueFamilyList::VulkanQueueFamilyList(
|
||||
const VulkanQueueFamilyList &queueFamilyList)
|
||||
{}
|
||||
|
||||
VulkanQueueFamilyList::VulkanQueueFamilyList() {}
|
||||
|
||||
VulkanQueueFamilyList::~VulkanQueueFamilyList() {}
|
||||
|
||||
/////////////////////////////////////////////////////
|
||||
// VulkanQueueFamilyToQueueCountMap implementation //
|
||||
/////////////////////////////////////////////////////
|
||||
|
||||
VulkanQueueFamilyToQueueCountMap::VulkanQueueFamilyToQueueCountMap(
|
||||
const VulkanQueueFamilyToQueueCountMap &queueFamilyToQueueCountMap)
|
||||
{}
|
||||
|
||||
VulkanQueueFamilyToQueueCountMap::VulkanQueueFamilyToQueueCountMap(
|
||||
uint32_t numQueuesPerFamily)
|
||||
{
|
||||
uint32_t maxQueueFamilyCount = 0;
|
||||
const VulkanPhysicalDeviceList &physicalDeviceList =
|
||||
getVulkanInstance().getPhysicalDeviceList();
|
||||
for (size_t pdIdx = 0; pdIdx < physicalDeviceList.size(); pdIdx++)
|
||||
{
|
||||
maxQueueFamilyCount = std::max(
|
||||
maxQueueFamilyCount,
|
||||
(uint32_t)physicalDeviceList[pdIdx].getQueueFamilyList().size());
|
||||
}
|
||||
|
||||
for (uint32_t qfIdx = 0; qfIdx < maxQueueFamilyCount; qfIdx++)
|
||||
{
|
||||
insert(qfIdx, numQueuesPerFamily);
|
||||
}
|
||||
}
|
||||
|
||||
VulkanQueueFamilyToQueueCountMap::~VulkanQueueFamilyToQueueCountMap() {}
|
||||
|
||||
////////////////////////////////////////////////////
|
||||
// VulkanQueueFamilyToQueueListMap implementation //
|
||||
////////////////////////////////////////////////////
|
||||
|
||||
VulkanQueueFamilyToQueueListMap::VulkanQueueFamilyToQueueListMap(
|
||||
const VulkanQueueFamilyToQueueListMap &queueFamilyToQueueMap)
|
||||
{}
|
||||
|
||||
VulkanQueueFamilyToQueueListMap::VulkanQueueFamilyToQueueListMap() {}
|
||||
|
||||
VulkanQueueFamilyToQueueListMap::~VulkanQueueFamilyToQueueListMap() {}
|
||||
|
||||
void VulkanQueueFamilyToQueueListMap::insert(uint32_t key,
|
||||
VulkanQueueList &queueList)
|
||||
{
|
||||
m_map.insert(std::pair<uint32_t, std::reference_wrapper<VulkanQueueList>>(
|
||||
key, std::reference_wrapper<VulkanQueueList>(queueList)));
|
||||
}
|
||||
|
||||
VulkanQueueList &VulkanQueueFamilyToQueueListMap::operator[](uint32_t key)
|
||||
{
|
||||
return m_map.at(key).get();
|
||||
}
|
||||
|
||||
////////////////////////////////////
|
||||
// VulkanQueueList implementation //
|
||||
////////////////////////////////////
|
||||
|
||||
VulkanQueueList::VulkanQueueList(const VulkanQueueList &queueList) {}
|
||||
|
||||
VulkanQueueList::VulkanQueueList() {}
|
||||
|
||||
VulkanQueueList::~VulkanQueueList() {}
|
||||
|
||||
/////////////////////////////////////////////////////////
|
||||
// VulkanDescriptorSetLayoutBindingList implementation //
|
||||
/////////////////////////////////////////////////////////
|
||||
|
||||
VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList(
|
||||
const VulkanDescriptorSetLayoutBindingList &descriptorSetLayoutBindingList)
|
||||
{}
|
||||
|
||||
VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList() {}
|
||||
|
||||
VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList(
|
||||
size_t numDescriptorSetLayoutBindings, VulkanDescriptorType descriptorType,
|
||||
uint32_t descriptorCount, VulkanShaderStage shaderStage)
|
||||
{
|
||||
for (size_t idx = 0; idx < numDescriptorSetLayoutBindings; idx++)
|
||||
{
|
||||
VulkanDescriptorSetLayoutBinding *descriptorSetLayoutBinding =
|
||||
new VulkanDescriptorSetLayoutBinding((uint32_t)idx, descriptorType,
|
||||
descriptorCount, shaderStage);
|
||||
add(*descriptorSetLayoutBinding);
|
||||
}
|
||||
}
|
||||
|
||||
VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList(
|
||||
VulkanDescriptorType descriptorType0, uint32_t descriptorCount0,
|
||||
VulkanDescriptorType descriptorType1, uint32_t descriptorCount1,
|
||||
VulkanShaderStage shaderStage)
|
||||
{
|
||||
for (uint32_t idx = 0; idx < descriptorCount0; idx++)
|
||||
{
|
||||
VulkanDescriptorSetLayoutBinding *descriptorSetLayoutBinding0 =
|
||||
new VulkanDescriptorSetLayoutBinding(idx, descriptorType0, 1,
|
||||
shaderStage);
|
||||
add(*descriptorSetLayoutBinding0);
|
||||
}
|
||||
for (uint32_t idx = 0; idx < descriptorCount1; idx++)
|
||||
{
|
||||
VulkanDescriptorSetLayoutBinding *descriptorSetLayoutBinding1 =
|
||||
new VulkanDescriptorSetLayoutBinding(
|
||||
descriptorCount0 + idx, descriptorType1, 1, shaderStage);
|
||||
add(*descriptorSetLayoutBinding1);
|
||||
}
|
||||
}
|
||||
|
||||
VulkanDescriptorSetLayoutBindingList::~VulkanDescriptorSetLayoutBindingList()
|
||||
{
|
||||
for (size_t idx = 0; idx < m_wrapperList.size(); idx++)
|
||||
{
|
||||
VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding =
|
||||
m_wrapperList[idx];
|
||||
delete &descriptorSetLayoutBinding;
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////
|
||||
// VulkanDescriptorSetLayoutList implementation //
|
||||
//////////////////////////////////////////////////
|
||||
|
||||
VulkanDescriptorSetLayoutList::VulkanDescriptorSetLayoutList(
|
||||
const VulkanDescriptorSetLayoutList &descriptorSetLayoutList)
|
||||
{}
|
||||
|
||||
VulkanDescriptorSetLayoutList::VulkanDescriptorSetLayoutList() {}
|
||||
|
||||
VulkanDescriptorSetLayoutList::~VulkanDescriptorSetLayoutList() {}
|
||||
|
||||
////////////////////////////////////////////
|
||||
// VulkanCommandBufferList implementation //
|
||||
////////////////////////////////////////////
|
||||
|
||||
VulkanCommandBufferList::VulkanCommandBufferList(
|
||||
const VulkanCommandBufferList &commandBufferList)
|
||||
{}
|
||||
|
||||
VulkanCommandBufferList::VulkanCommandBufferList() {}
|
||||
|
||||
VulkanCommandBufferList::VulkanCommandBufferList(
|
||||
size_t numCommandBuffers, const VulkanDevice &device,
|
||||
const VulkanCommandPool &commandPool)
|
||||
{
|
||||
for (size_t idx = 0; idx < numCommandBuffers; idx++)
|
||||
{
|
||||
VulkanCommandBuffer *commandBuffer =
|
||||
new VulkanCommandBuffer(device, commandPool);
|
||||
add(*commandBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
VulkanCommandBufferList::~VulkanCommandBufferList()
|
||||
{
|
||||
for (size_t idx = 0; idx < m_wrapperList.size(); idx++)
|
||||
{
|
||||
VulkanCommandBuffer &commandBuffer = m_wrapperList[idx];
|
||||
delete &commandBuffer;
|
||||
}
|
||||
}
|
||||
|
||||
/////////////////////////////////////
|
||||
// VulkanBufferList implementation //
|
||||
/////////////////////////////////////
|
||||
|
||||
VulkanBufferList::VulkanBufferList(const VulkanBufferList &bufferList) {}
|
||||
|
||||
VulkanBufferList::VulkanBufferList(
|
||||
size_t numBuffers, const VulkanDevice &device, uint64_t size,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType,
|
||||
VulkanBufferUsage bufferUsage, VulkanSharingMode sharingMode,
|
||||
const VulkanQueueFamilyList &queueFamilyList)
|
||||
{
|
||||
for (size_t bIdx = 0; bIdx < numBuffers; bIdx++)
|
||||
{
|
||||
VulkanBuffer *buffer =
|
||||
new VulkanBuffer(device, size, externalMemoryHandleType,
|
||||
bufferUsage, sharingMode, queueFamilyList);
|
||||
add(*buffer);
|
||||
}
|
||||
}
|
||||
|
||||
VulkanBufferList::~VulkanBufferList()
|
||||
{
|
||||
for (size_t bIdx = 0; bIdx < m_wrapperList.size(); bIdx++)
|
||||
{
|
||||
VulkanBuffer &buffer = m_wrapperList[bIdx];
|
||||
delete &buffer;
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////
|
||||
// VulkanImage2DList implementation //
|
||||
//////////////////////////////////////
|
||||
|
||||
VulkanImage2DList::VulkanImage2DList(const VulkanImage2DList &image2DList) {}
|
||||
|
||||
VulkanImage2DList::VulkanImage2DList(
|
||||
size_t numImages, std::vector<VulkanDeviceMemory *> &deviceMemory,
|
||||
uint64_t baseOffset, uint64_t interImageOffset, const VulkanDevice &device,
|
||||
VulkanFormat format, uint32_t width, uint32_t height, uint32_t mipLevels,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType,
|
||||
VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage,
|
||||
VulkanSharingMode sharingMode)
|
||||
{
|
||||
for (size_t i2DIdx = 0; i2DIdx < numImages; i2DIdx++)
|
||||
{
|
||||
VulkanImage2D *image2D = new VulkanImage2D(
|
||||
device, format, width, height, mipLevels, externalMemoryHandleType,
|
||||
imageCreateFlag, imageUsage, sharingMode);
|
||||
add(*image2D);
|
||||
deviceMemory[i2DIdx]->bindImage(
|
||||
*image2D, baseOffset + (i2DIdx * interImageOffset));
|
||||
}
|
||||
}
|
||||
|
||||
VulkanImage2DList::VulkanImage2DList(
|
||||
size_t numImages, const VulkanDevice &device, VulkanFormat format,
|
||||
uint32_t width, uint32_t height, uint32_t mipLevels,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType,
|
||||
VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage,
|
||||
VulkanSharingMode sharingMode)
|
||||
{
|
||||
for (size_t bIdx = 0; bIdx < numImages; bIdx++)
|
||||
{
|
||||
VulkanImage2D *image2D = new VulkanImage2D(
|
||||
device, format, width, height, mipLevels, externalMemoryHandleType,
|
||||
imageCreateFlag, imageUsage, sharingMode);
|
||||
add(*image2D);
|
||||
}
|
||||
}
|
||||
|
||||
VulkanImage2DList::~VulkanImage2DList()
|
||||
{
|
||||
for (size_t i2DIdx = 0; i2DIdx < m_wrapperList.size(); i2DIdx++)
|
||||
{
|
||||
VulkanImage2D &image2D = m_wrapperList[i2DIdx];
|
||||
delete &image2D;
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// VulkanImageViewList implementation //
|
||||
////////////////////////////////////////
|
||||
|
||||
VulkanImageViewList::VulkanImageViewList(const VulkanImageViewList &image2DList)
|
||||
{}
|
||||
|
||||
VulkanImageViewList::VulkanImageViewList(const VulkanDevice &device,
|
||||
const VulkanImage2DList &image2DList,
|
||||
bool createImageViewPerMipLevel)
|
||||
{
|
||||
for (size_t i2DIdx = 0; i2DIdx < image2DList.size(); i2DIdx++)
|
||||
{
|
||||
if (createImageViewPerMipLevel)
|
||||
{
|
||||
for (uint32_t mipLevel = 0;
|
||||
mipLevel < image2DList[i2DIdx].getNumMipLevels(); mipLevel++)
|
||||
{
|
||||
VulkanImageView *image2DView =
|
||||
new VulkanImageView(device, image2DList[i2DIdx],
|
||||
VULKAN_IMAGE_VIEW_TYPE_2D, mipLevel, 1);
|
||||
add(*image2DView);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
VulkanImageView *image2DView = new VulkanImageView(
|
||||
device, image2DList[i2DIdx], VULKAN_IMAGE_VIEW_TYPE_2D);
|
||||
add(*image2DView);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VulkanImageViewList::~VulkanImageViewList()
|
||||
{
|
||||
for (size_t ivIdx = 0; ivIdx < m_wrapperList.size(); ivIdx++)
|
||||
{
|
||||
VulkanImageView &imageView = m_wrapperList[ivIdx];
|
||||
delete &imageView;
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////
|
||||
// VulkanDeviceMemoryList implementation //
|
||||
///////////////////////////////////////////
|
||||
|
||||
VulkanDeviceMemoryList::VulkanDeviceMemoryList(
|
||||
const VulkanDeviceMemoryList &deviceMemoryList)
|
||||
{}
|
||||
|
||||
VulkanDeviceMemoryList::VulkanDeviceMemoryList(
|
||||
size_t numImages, const VulkanImage2DList &image2DList,
|
||||
const VulkanDevice &device, const VulkanMemoryType &memoryType,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType)
|
||||
{
|
||||
for (size_t i2DIdx = 0; i2DIdx < image2DList.size(); i2DIdx++)
|
||||
{
|
||||
VulkanDeviceMemory *deviceMemory = new VulkanDeviceMemory(
|
||||
device, image2DList[i2DIdx], memoryType, externalMemoryHandleType);
|
||||
add(*deviceMemory);
|
||||
deviceMemory->bindImage(image2DList[i2DIdx]);
|
||||
}
|
||||
}
|
||||
|
||||
VulkanDeviceMemoryList::~VulkanDeviceMemoryList()
|
||||
{
|
||||
for (size_t dmIdx = 0; dmIdx < m_wrapperList.size(); dmIdx++)
|
||||
{
|
||||
VulkanDeviceMemory &deviceMemory = m_wrapperList[dmIdx];
|
||||
delete &deviceMemory;
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// VulkanSemaphoreList implementation //
|
||||
////////////////////////////////////////
|
||||
|
||||
VulkanSemaphoreList::VulkanSemaphoreList(
|
||||
const VulkanSemaphoreList &semaphoreList)
|
||||
{}
|
||||
|
||||
VulkanSemaphoreList::VulkanSemaphoreList() {}
|
||||
|
||||
VulkanSemaphoreList::VulkanSemaphoreList(
|
||||
size_t numSemaphores, const VulkanDevice &device,
|
||||
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType,
|
||||
const std::wstring namePrefix)
|
||||
{
|
||||
std::wstring name = L"";
|
||||
for (size_t idx = 0; idx < numSemaphores; idx++)
|
||||
{
|
||||
if (namePrefix.size())
|
||||
{
|
||||
const size_t maxNameSize = 256;
|
||||
wchar_t tempName[maxNameSize];
|
||||
swprintf(tempName, maxNameSize, L"%s%d", namePrefix.c_str(),
|
||||
(int)idx);
|
||||
name = tempName;
|
||||
}
|
||||
VulkanSemaphore *semaphore =
|
||||
new VulkanSemaphore(device, externalSemaphoreHandleType, name);
|
||||
add(*semaphore);
|
||||
}
|
||||
}
|
||||
|
||||
VulkanSemaphoreList::~VulkanSemaphoreList()
|
||||
{
|
||||
for (size_t idx = 0; idx < m_wrapperList.size(); idx++)
|
||||
{
|
||||
VulkanSemaphore &Semaphore = m_wrapperList[idx];
|
||||
delete &Semaphore;
|
||||
}
|
||||
}
|
||||
@@ -1,386 +0,0 @@
|
||||
//
|
||||
// Copyright (c) 2022 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
|
||||
#ifndef _vulkan_list_map_hpp_
|
||||
#define _vulkan_list_map_hpp_
|
||||
|
||||
#include <functional>
|
||||
#include "vulkan_wrapper_types.hpp"
|
||||
#include "vulkan_utility.hpp"
|
||||
#include <iostream>
|
||||
template <class VulkanWrapper, class VulkanNative> class VulkanList {
|
||||
protected:
|
||||
std::vector<std::reference_wrapper<VulkanWrapper>> m_wrapperList;
|
||||
std::vector<std::reference_wrapper<const VulkanWrapper>> m_constWrapperList;
|
||||
std::vector<VulkanNative> m_nativeList;
|
||||
|
||||
VulkanList(const VulkanList &list);
|
||||
VulkanList();
|
||||
virtual ~VulkanList();
|
||||
virtual void add(VulkanWrapper &wrapper);
|
||||
|
||||
public:
|
||||
virtual void add(const VulkanWrapper &wrapper);
|
||||
virtual size_t size() const;
|
||||
virtual const VulkanWrapper &operator[](size_t idx) const;
|
||||
virtual VulkanWrapper &operator[](size_t idx);
|
||||
virtual const VulkanNative *operator()() const;
|
||||
};
|
||||
|
||||
template <class VulkanKey, class VulkanValue> class VulkanMap {
|
||||
protected:
|
||||
std::map<VulkanKey, VulkanValue> m_map;
|
||||
|
||||
VulkanMap(const VulkanMap &map);
|
||||
VulkanMap();
|
||||
virtual ~VulkanMap();
|
||||
|
||||
public:
|
||||
void insert(const VulkanKey &key, VulkanValue &value);
|
||||
const VulkanValue &operator[](const VulkanKey &key) const;
|
||||
VulkanValue &operator[](const VulkanKey &key);
|
||||
};
|
||||
|
||||
class VulkanPhysicalDeviceList
|
||||
: public VulkanList<VulkanPhysicalDevice, VkPhysicalDevice> {
|
||||
friend class VulkanInstance;
|
||||
|
||||
protected:
|
||||
VulkanPhysicalDeviceList(
|
||||
const VulkanPhysicalDeviceList &physicalDeviceList);
|
||||
|
||||
public:
|
||||
VulkanPhysicalDeviceList();
|
||||
virtual ~VulkanPhysicalDeviceList();
|
||||
};
|
||||
|
||||
class VulkanQueueFamilyList : public VulkanList<VulkanQueueFamily, uint32_t> {
|
||||
friend class VulkanPhysicalDevice;
|
||||
|
||||
protected:
|
||||
VulkanQueueFamilyList(const VulkanQueueFamilyList &queueFamilyList);
|
||||
|
||||
public:
|
||||
VulkanQueueFamilyList();
|
||||
virtual ~VulkanQueueFamilyList();
|
||||
};
|
||||
|
||||
class VulkanMemoryHeapList : public VulkanList<VulkanMemoryHeap, uint32_t> {
|
||||
friend class VulkanPhysicalDevice;
|
||||
|
||||
protected:
|
||||
VulkanMemoryHeapList(const VulkanMemoryHeapList &memoryHeapList);
|
||||
|
||||
public:
|
||||
VulkanMemoryHeapList();
|
||||
virtual ~VulkanMemoryHeapList();
|
||||
};
|
||||
|
||||
class VulkanMemoryTypeList : public VulkanList<VulkanMemoryType, uint32_t> {
|
||||
friend class VulkanPhysicalDevice;
|
||||
friend class VulkanBuffer;
|
||||
friend class VulkanImage;
|
||||
|
||||
protected:
|
||||
VulkanMemoryTypeList(const VulkanMemoryTypeList &memoryTypeList);
|
||||
|
||||
public:
|
||||
VulkanMemoryTypeList();
|
||||
virtual ~VulkanMemoryTypeList();
|
||||
};
|
||||
|
||||
class VulkanQueueFamilyToQueueCountMap : public VulkanMap<uint32_t, uint32_t> {
|
||||
protected:
|
||||
VulkanQueueFamilyToQueueCountMap(
|
||||
const VulkanQueueFamilyToQueueCountMap &queueFamilyToQueueCountMap);
|
||||
|
||||
public:
|
||||
VulkanQueueFamilyToQueueCountMap(uint32_t numQueuesPerFamily = 0);
|
||||
virtual ~VulkanQueueFamilyToQueueCountMap();
|
||||
};
|
||||
|
||||
class VulkanQueueList : public VulkanList<VulkanQueue, VkQueue> {
|
||||
friend class VulkanDevice;
|
||||
|
||||
protected:
|
||||
VulkanQueueList(const VulkanQueueList &queueList);
|
||||
|
||||
public:
|
||||
VulkanQueueList();
|
||||
virtual ~VulkanQueueList();
|
||||
};
|
||||
|
||||
class VulkanQueueFamilyToQueueListMap
|
||||
: public VulkanMap<uint32_t, std::reference_wrapper<VulkanQueueList>> {
|
||||
protected:
|
||||
VulkanQueueFamilyToQueueListMap(
|
||||
const VulkanQueueFamilyToQueueListMap &queueFamilyToQueueMap);
|
||||
|
||||
public:
|
||||
VulkanQueueFamilyToQueueListMap();
|
||||
virtual ~VulkanQueueFamilyToQueueListMap();
|
||||
void insert(uint32_t key, VulkanQueueList &queueList);
|
||||
VulkanQueueList &operator[](uint32_t key);
|
||||
};
|
||||
|
||||
class VulkanDescriptorSetLayoutBindingList
|
||||
: public VulkanList<VulkanDescriptorSetLayoutBinding,
|
||||
VkDescriptorSetLayoutBinding> {
|
||||
protected:
|
||||
VulkanDescriptorSetLayoutBindingList(
|
||||
const VulkanDescriptorSetLayoutBindingList
|
||||
&descriptorSetLayoutBindingList);
|
||||
|
||||
public:
|
||||
VulkanDescriptorSetLayoutBindingList();
|
||||
VulkanDescriptorSetLayoutBindingList(
|
||||
size_t numDescriptorSetLayoutBindings,
|
||||
VulkanDescriptorType descriptorType, uint32_t descriptorCount = 1,
|
||||
VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
|
||||
VulkanDescriptorSetLayoutBindingList(
|
||||
VulkanDescriptorType descriptorType0, uint32_t descriptorCount0,
|
||||
VulkanDescriptorType descriptorType1, uint32_t descriptorCount1,
|
||||
VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
|
||||
virtual ~VulkanDescriptorSetLayoutBindingList();
|
||||
};
|
||||
|
||||
class VulkanDescriptorSetLayoutList
|
||||
: public VulkanList<VulkanDescriptorSetLayout, VkDescriptorSetLayout> {
|
||||
protected:
|
||||
VulkanDescriptorSetLayoutList(
|
||||
const VulkanDescriptorSetLayoutList &descriptorSetLayoutList);
|
||||
|
||||
public:
|
||||
VulkanDescriptorSetLayoutList();
|
||||
virtual ~VulkanDescriptorSetLayoutList();
|
||||
};
|
||||
|
||||
class VulkanCommandBufferList
|
||||
: public VulkanList<VulkanCommandBuffer, VkCommandBuffer> {
|
||||
protected:
|
||||
VulkanCommandBufferList(const VulkanCommandBufferList &commandBufferList);
|
||||
|
||||
public:
|
||||
VulkanCommandBufferList();
|
||||
VulkanCommandBufferList(size_t numCommandBuffers,
|
||||
const VulkanDevice &device,
|
||||
const VulkanCommandPool &commandPool);
|
||||
virtual ~VulkanCommandBufferList();
|
||||
};
|
||||
|
||||
class VulkanBufferList : public VulkanList<VulkanBuffer, VkBuffer> {
|
||||
protected:
|
||||
VulkanBufferList(const VulkanBufferList &bufferList);
|
||||
|
||||
public:
|
||||
VulkanBufferList(
|
||||
size_t numBuffers, const VulkanDevice &device, uint64_t size,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType =
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
|
||||
VulkanBufferUsage bufferUsage =
|
||||
VULKAN_BUFFER_USAGE_STORAGE_BUFFER_TRANSFER_SRC_DST,
|
||||
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE,
|
||||
const VulkanQueueFamilyList &queueFamilyList =
|
||||
getEmptyVulkanQueueFamilyList());
|
||||
virtual ~VulkanBufferList();
|
||||
};
|
||||
|
||||
class VulkanImage2DList : public VulkanList<VulkanImage2D, VkImage> {
|
||||
protected:
|
||||
VulkanImage2DList(const VulkanImage2DList &image2DList);
|
||||
|
||||
public:
|
||||
VulkanImage2DList(
|
||||
size_t numImages, std::vector<VulkanDeviceMemory *> &deviceMemory,
|
||||
uint64_t baseOffset, uint64_t interImageOffset,
|
||||
const VulkanDevice &device, VulkanFormat format, uint32_t width,
|
||||
uint32_t height, uint32_t mipLevels,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType =
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
|
||||
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
|
||||
VulkanImageUsage imageUsage =
|
||||
VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
|
||||
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
|
||||
VulkanImage2DList(
|
||||
size_t numImages, const VulkanDevice &device, VulkanFormat format,
|
||||
uint32_t width, uint32_t height, uint32_t mipLevels = 1,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType =
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
|
||||
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
|
||||
VulkanImageUsage imageUsage =
|
||||
VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
|
||||
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
|
||||
virtual ~VulkanImage2DList();
|
||||
};
|
||||
|
||||
class VulkanImageViewList : public VulkanList<VulkanImageView, VkImageView> {
|
||||
protected:
|
||||
VulkanImageViewList(const VulkanImageViewList &imageViewList);
|
||||
|
||||
public:
|
||||
VulkanImageViewList(const VulkanDevice &device,
|
||||
const VulkanImage2DList &image2DList,
|
||||
bool createImageViewPerMipLevel = true);
|
||||
virtual ~VulkanImageViewList();
|
||||
};
|
||||
|
||||
class VulkanDeviceMemoryList
|
||||
: public VulkanList<VulkanDeviceMemory, VkDeviceMemory> {
|
||||
protected:
|
||||
VulkanDeviceMemoryList(const VulkanDeviceMemoryList &deviceMemoryList);
|
||||
|
||||
public:
|
||||
VulkanDeviceMemoryList(
|
||||
size_t numImages, const VulkanImage2DList &image2DList,
|
||||
const VulkanDevice &device, const VulkanMemoryType &memoryType,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType =
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE);
|
||||
virtual ~VulkanDeviceMemoryList();
|
||||
};
|
||||
|
||||
class VulkanSemaphoreList : public VulkanList<VulkanSemaphore, VkSemaphore> {
|
||||
protected:
|
||||
VulkanSemaphoreList(const VulkanSemaphoreList &semaphoreList);
|
||||
|
||||
public:
|
||||
VulkanSemaphoreList();
|
||||
VulkanSemaphoreList(
|
||||
size_t numSemaphores, const VulkanDevice &device,
|
||||
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType =
|
||||
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE,
|
||||
const std::wstring namePrefix = L"");
|
||||
virtual ~VulkanSemaphoreList();
|
||||
};
|
||||
|
||||
///////////////////////////////
|
||||
// VulkanList implementation //
|
||||
///////////////////////////////
|
||||
|
||||
template <class VulkanWrapper, class VulkanNative>
|
||||
VulkanList<VulkanWrapper, VulkanNative>::VulkanList(const VulkanList &list)
|
||||
: m_wrapperList(list.m_wrapperList),
|
||||
m_constWrapperList(list.m_constWrapperList),
|
||||
m_nativeList(list.m_nativeList)
|
||||
{}
|
||||
|
||||
template <class VulkanWrapper, class VulkanNative>
|
||||
VulkanList<VulkanWrapper, VulkanNative>::VulkanList()
|
||||
{}
|
||||
|
||||
template <class VulkanWrapper, class VulkanNative>
|
||||
VulkanList<VulkanWrapper, VulkanNative>::~VulkanList()
|
||||
{}
|
||||
|
||||
template <class VulkanWrapper, class VulkanNative>
|
||||
void VulkanList<VulkanWrapper, VulkanNative>::add(VulkanWrapper &wrapper)
|
||||
{
|
||||
|
||||
if (m_constWrapperList.size() != size_t(0))
|
||||
{
|
||||
std::cout << "This list can only contain externally allocated objects"
|
||||
<< std::endl;
|
||||
return;
|
||||
}
|
||||
m_wrapperList.push_back(std::reference_wrapper<VulkanWrapper>(wrapper));
|
||||
m_nativeList.push_back((VulkanNative)wrapper);
|
||||
}
|
||||
|
||||
template <class VulkanWrapper, class VulkanNative>
|
||||
void VulkanList<VulkanWrapper, VulkanNative>::add(const VulkanWrapper &wrapper)
|
||||
{
|
||||
if (m_wrapperList.size() != size_t(0))
|
||||
{
|
||||
std::cout << "This list cannot contain externally allocated objects"
|
||||
<< std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
m_constWrapperList.push_back(
|
||||
std::reference_wrapper<const VulkanWrapper>(wrapper));
|
||||
m_nativeList.push_back((VulkanNative)wrapper);
|
||||
}
|
||||
|
||||
template <class VulkanWrapper, class VulkanNative>
|
||||
size_t VulkanList<VulkanWrapper, VulkanNative>::size() const
|
||||
{
|
||||
return (m_wrapperList.size() > 0) ? m_wrapperList.size()
|
||||
: m_constWrapperList.size();
|
||||
}
|
||||
|
||||
template <class VulkanWrapper, class VulkanNative>
|
||||
const VulkanWrapper &
|
||||
VulkanList<VulkanWrapper, VulkanNative>::operator[](size_t idx) const
|
||||
{
|
||||
if (idx < size())
|
||||
{
|
||||
// CHECK_LT(idx, size());
|
||||
return (m_wrapperList.size() > 0) ? m_wrapperList[idx].get()
|
||||
: m_constWrapperList[idx].get();
|
||||
}
|
||||
}
|
||||
|
||||
template <class VulkanWrapper, class VulkanNative>
|
||||
VulkanWrapper &VulkanList<VulkanWrapper, VulkanNative>::operator[](size_t idx)
|
||||
{
|
||||
// CHECK_LT(idx, m_wrapperList.size());
|
||||
return m_wrapperList[idx].get();
|
||||
}
|
||||
|
||||
template <class VulkanWrapper, class VulkanNative>
|
||||
const VulkanNative *VulkanList<VulkanWrapper, VulkanNative>::operator()() const
|
||||
{
|
||||
return m_nativeList.data();
|
||||
}
|
||||
|
||||
//////////////////////////////
|
||||
// VulkanMap implementation //
|
||||
//////////////////////////////
|
||||
|
||||
template <class VulkanKey, class VulkanValue>
|
||||
VulkanMap<VulkanKey, VulkanValue>::VulkanMap(const VulkanMap &map)
|
||||
: m_map(map.m_map)
|
||||
{}
|
||||
|
||||
template <class VulkanKey, class VulkanValue>
|
||||
VulkanMap<VulkanKey, VulkanValue>::VulkanMap()
|
||||
{}
|
||||
|
||||
template <class VulkanKey, class VulkanValue>
|
||||
VulkanMap<VulkanKey, VulkanValue>::~VulkanMap()
|
||||
{}
|
||||
|
||||
template <class VulkanKey, class VulkanValue>
|
||||
void VulkanMap<VulkanKey, VulkanValue>::insert(const VulkanKey &key,
|
||||
VulkanValue &value)
|
||||
{
|
||||
m_map.insert(std::pair<VulkanKey, std::reference_wrapper<VulkanValue>>(
|
||||
key, std::reference_wrapper<VulkanValue>(value)));
|
||||
}
|
||||
|
||||
template <class VulkanKey, class VulkanValue>
|
||||
const VulkanValue &
|
||||
VulkanMap<VulkanKey, VulkanValue>::operator[](const VulkanKey &key) const
|
||||
{
|
||||
return m_map.at(key);
|
||||
}
|
||||
|
||||
template <class VulkanKey, class VulkanValue>
|
||||
VulkanValue &VulkanMap<VulkanKey, VulkanValue>::operator[](const VulkanKey &key)
|
||||
{
|
||||
return m_map.at(key);
|
||||
}
|
||||
|
||||
#endif // _vulkan_list_map_hpp_
|
||||
@@ -1,692 +0,0 @@
|
||||
//
|
||||
// Copyright (c) 2022 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
|
||||
#include "vulkan_utility.hpp"
|
||||
#include "vulkan_wrapper.hpp"
|
||||
#include <assert.h>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <CL/cl.h>
|
||||
#include <CL/cl_ext.h>
|
||||
#if defined(_WIN32) || defined(_WIN64)
|
||||
#include <versionhelpers.h>
|
||||
#endif
|
||||
#define ASSERT(x) assert((x))
|
||||
#define BUFFERSIZE 3000
|
||||
|
||||
|
||||
const VulkanInstance &getVulkanInstance()
|
||||
{
|
||||
static VulkanInstance instance;
|
||||
return instance;
|
||||
}
|
||||
|
||||
const VulkanPhysicalDevice &getVulkanPhysicalDevice()
|
||||
{
|
||||
size_t pdIdx;
|
||||
cl_int errNum = 0;
|
||||
cl_platform_id platform = NULL;
|
||||
cl_uchar uuid[CL_UUID_SIZE_KHR];
|
||||
cl_device_id *devices;
|
||||
char *extensions = NULL;
|
||||
size_t extensionSize = 0;
|
||||
cl_uint num_devices = 0;
|
||||
cl_uint device_no = 0;
|
||||
const size_t bufsize = BUFFERSIZE;
|
||||
char buf[BUFFERSIZE];
|
||||
const VulkanInstance &instance = getVulkanInstance();
|
||||
const VulkanPhysicalDeviceList &physicalDeviceList =
|
||||
instance.getPhysicalDeviceList();
|
||||
|
||||
// get the platform ID
|
||||
errNum = clGetPlatformIDs(1, &platform, NULL);
|
||||
if (errNum != CL_SUCCESS)
|
||||
{
|
||||
printf("Error: Failed to get platform\n");
|
||||
throw std::runtime_error("Error: Failed to get number of platform\n");
|
||||
}
|
||||
|
||||
errNum =
|
||||
clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 0, NULL, &num_devices);
|
||||
if (CL_SUCCESS != errNum)
|
||||
{
|
||||
throw std::runtime_error(
|
||||
"Error: clGetDeviceIDs failed in returning of devices\n");
|
||||
}
|
||||
devices = (cl_device_id *)malloc(num_devices * sizeof(cl_device_id));
|
||||
if (NULL == devices)
|
||||
{
|
||||
throw std::runtime_error(
|
||||
"Error: Unable to allocate memory for devices\n");
|
||||
}
|
||||
errNum = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, num_devices, devices,
|
||||
NULL);
|
||||
if (CL_SUCCESS != errNum)
|
||||
{
|
||||
throw std::runtime_error("Error: Failed to get deviceID.\n");
|
||||
}
|
||||
bool is_selected = false;
|
||||
for (device_no = 0; device_no < num_devices; device_no++)
|
||||
{
|
||||
errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_EXTENSIONS, 0,
|
||||
NULL, &extensionSize);
|
||||
if (CL_SUCCESS != errNum)
|
||||
{
|
||||
throw std::runtime_error("Error in clGetDeviceInfo for getting "
|
||||
"device_extension size....\n");
|
||||
}
|
||||
extensions = (char *)malloc(extensionSize);
|
||||
if (NULL == extensions)
|
||||
{
|
||||
throw std::runtime_error(
|
||||
"Unable to allocate memory for extensions\n");
|
||||
}
|
||||
errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_EXTENSIONS,
|
||||
extensionSize, extensions, NULL);
|
||||
if (CL_SUCCESS != errNum)
|
||||
{
|
||||
throw std::runtime_error("Error: Error in clGetDeviceInfo for "
|
||||
"getting device_extension\n");
|
||||
}
|
||||
errNum = clGetDeviceInfo(devices[device_no], CL_DEVICE_UUID_KHR,
|
||||
CL_UUID_SIZE_KHR, uuid, &extensionSize);
|
||||
if (CL_SUCCESS != errNum)
|
||||
{
|
||||
throw std::runtime_error(
|
||||
"Error: clGetDeviceInfo failed with error\n");
|
||||
}
|
||||
free(extensions);
|
||||
for (pdIdx = 0; pdIdx < physicalDeviceList.size(); pdIdx++)
|
||||
{
|
||||
if (!memcmp(&uuid, physicalDeviceList[pdIdx].getUUID(),
|
||||
VK_UUID_SIZE))
|
||||
{
|
||||
std::cout << "Selected physical device = "
|
||||
<< physicalDeviceList[pdIdx] << std::endl;
|
||||
is_selected = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (is_selected)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ((pdIdx >= physicalDeviceList.size())
|
||||
|| (physicalDeviceList[pdIdx] == (VkPhysicalDevice)VK_NULL_HANDLE))
|
||||
{
|
||||
throw std::runtime_error("failed to find a suitable GPU!");
|
||||
}
|
||||
std::cout << "Selected physical device is: " << physicalDeviceList[pdIdx]
|
||||
<< std::endl;
|
||||
return physicalDeviceList[pdIdx];
|
||||
}
|
||||
|
||||
const VulkanQueueFamily &getVulkanQueueFamily(uint32_t queueFlags)
|
||||
{
|
||||
size_t qfIdx;
|
||||
const VulkanPhysicalDevice &physicalDevice = getVulkanPhysicalDevice();
|
||||
const VulkanQueueFamilyList &queueFamilyList =
|
||||
physicalDevice.getQueueFamilyList();
|
||||
|
||||
for (qfIdx = 0; qfIdx < queueFamilyList.size(); qfIdx++)
|
||||
{
|
||||
if ((queueFamilyList[qfIdx].getQueueFlags() & queueFlags) == queueFlags)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return queueFamilyList[qfIdx];
|
||||
}
|
||||
|
||||
const VulkanMemoryType &
|
||||
getVulkanMemoryType(const VulkanDevice &device,
|
||||
VulkanMemoryTypeProperty memoryTypeProperty)
|
||||
{
|
||||
size_t mtIdx;
|
||||
const VulkanMemoryTypeList &memoryTypeList =
|
||||
device.getPhysicalDevice().getMemoryTypeList();
|
||||
|
||||
for (mtIdx = 0; mtIdx < memoryTypeList.size(); mtIdx++)
|
||||
{
|
||||
if ((memoryTypeList[mtIdx].getMemoryTypeProperty() & memoryTypeProperty)
|
||||
== memoryTypeProperty)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// CHECK_LT(mtIdx, memoryTypeList.size());
|
||||
return memoryTypeList[mtIdx];
|
||||
}
|
||||
|
||||
bool checkVkSupport()
|
||||
{
|
||||
bool result = true;
|
||||
const VulkanInstance &instance = getVulkanInstance();
|
||||
const VulkanPhysicalDeviceList &physicalDeviceList =
|
||||
instance.getPhysicalDeviceList();
|
||||
if (physicalDeviceList() == NULL)
|
||||
{
|
||||
std::cout << "physicalDeviceList is null, No GPUs found with "
|
||||
"Vulkan support !!!\n";
|
||||
result = false;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
const VulkanQueueFamilyList &getEmptyVulkanQueueFamilyList()
|
||||
{
|
||||
static VulkanQueueFamilyList queueFamilyList;
|
||||
return queueFamilyList;
|
||||
}
|
||||
|
||||
const VulkanDescriptorSetLayoutList &getEmptyVulkanDescriptorSetLayoutList()
|
||||
{
|
||||
static VulkanDescriptorSetLayoutList descriptorSetLayoutList;
|
||||
|
||||
return descriptorSetLayoutList;
|
||||
}
|
||||
|
||||
const VulkanQueueFamilyToQueueCountMap &
|
||||
getDefaultVulkanQueueFamilyToQueueCountMap()
|
||||
{
|
||||
static VulkanQueueFamilyToQueueCountMap queueFamilyToQueueCountMap(1);
|
||||
|
||||
return queueFamilyToQueueCountMap;
|
||||
}
|
||||
|
||||
const std::vector<VulkanExternalMemoryHandleType>
|
||||
getSupportedVulkanExternalMemoryHandleTypeList()
|
||||
{
|
||||
std::vector<VulkanExternalMemoryHandleType> externalMemoryHandleTypeList;
|
||||
|
||||
#if _WIN32
|
||||
if (IsWindows8OrGreater())
|
||||
{
|
||||
externalMemoryHandleTypeList.push_back(
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT);
|
||||
}
|
||||
externalMemoryHandleTypeList.push_back(
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT);
|
||||
#else
|
||||
externalMemoryHandleTypeList.push_back(
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD);
|
||||
#endif
|
||||
|
||||
return externalMemoryHandleTypeList;
|
||||
}
|
||||
|
||||
const std::vector<VulkanExternalSemaphoreHandleType>
|
||||
getSupportedVulkanExternalSemaphoreHandleTypeList()
|
||||
{
|
||||
std::vector<VulkanExternalSemaphoreHandleType>
|
||||
externalSemaphoreHandleTypeList;
|
||||
|
||||
#if _WIN32
|
||||
if (IsWindows8OrGreater())
|
||||
{
|
||||
externalSemaphoreHandleTypeList.push_back(
|
||||
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT);
|
||||
}
|
||||
externalSemaphoreHandleTypeList.push_back(
|
||||
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT);
|
||||
#else
|
||||
externalSemaphoreHandleTypeList.push_back(
|
||||
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD);
|
||||
#endif
|
||||
|
||||
return externalSemaphoreHandleTypeList;
|
||||
}
|
||||
|
||||
const std::vector<VulkanFormat> getSupportedVulkanFormatList()
|
||||
{
|
||||
std::vector<VulkanFormat> formatList;
|
||||
|
||||
formatList.push_back(VULKAN_FORMAT_R8_UINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R8_SINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R8G8_UINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R8G8_SINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R8G8B8A8_UINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R8G8B8A8_SINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R16_UINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R16_SINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R16G16_UINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R16G16_SINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R16G16B16A16_UINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R16G16B16A16_SINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R32_UINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R32_SINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R32_SFLOAT);
|
||||
formatList.push_back(VULKAN_FORMAT_R32G32_UINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R32G32_SINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R32G32_SFLOAT);
|
||||
formatList.push_back(VULKAN_FORMAT_R32G32B32A32_UINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R32G32B32A32_SINT);
|
||||
formatList.push_back(VULKAN_FORMAT_R32G32B32A32_SFLOAT);
|
||||
|
||||
for (size_t fIdx = 0; fIdx < formatList.size(); fIdx++)
|
||||
{
|
||||
switch (formatList[fIdx])
|
||||
{
|
||||
case VULKAN_FORMAT_R8_UINT:
|
||||
case VULKAN_FORMAT_R8_SINT:
|
||||
case VULKAN_FORMAT_R8G8_UINT:
|
||||
case VULKAN_FORMAT_R8G8_SINT:
|
||||
case VULKAN_FORMAT_R8G8B8A8_UINT:
|
||||
case VULKAN_FORMAT_R8G8B8A8_SINT:
|
||||
case VULKAN_FORMAT_R16_UINT:
|
||||
case VULKAN_FORMAT_R16_SINT:
|
||||
case VULKAN_FORMAT_R16G16_UINT:
|
||||
case VULKAN_FORMAT_R16G16_SINT:
|
||||
case VULKAN_FORMAT_R16G16B16A16_UINT:
|
||||
case VULKAN_FORMAT_R16G16B16A16_SINT:
|
||||
case VULKAN_FORMAT_R32_UINT:
|
||||
case VULKAN_FORMAT_R32_SINT:
|
||||
case VULKAN_FORMAT_R32_SFLOAT:
|
||||
case VULKAN_FORMAT_R32G32_UINT:
|
||||
case VULKAN_FORMAT_R32G32_SINT:
|
||||
case VULKAN_FORMAT_R32G32_SFLOAT:
|
||||
case VULKAN_FORMAT_R32G32B32A32_UINT:
|
||||
case VULKAN_FORMAT_R32G32B32A32_SINT:
|
||||
case VULKAN_FORMAT_R32G32B32A32_SFLOAT: break;
|
||||
|
||||
case VULKAN_FORMAT_UNDEFINED:
|
||||
case VULKAN_FORMAT_R4G4_UNORM_PACK8:
|
||||
case VULKAN_FORMAT_R4G4B4A4_UNORM_PACK16:
|
||||
case VULKAN_FORMAT_B4G4R4A4_UNORM_PACK16:
|
||||
case VULKAN_FORMAT_R5G6B5_UNORM_PACK16:
|
||||
case VULKAN_FORMAT_B5G6R5_UNORM_PACK16:
|
||||
case VULKAN_FORMAT_R5G5B5A1_UNORM_PACK16:
|
||||
case VULKAN_FORMAT_B5G5R5A1_UNORM_PACK16:
|
||||
case VULKAN_FORMAT_A1R5G5B5_UNORM_PACK16:
|
||||
case VULKAN_FORMAT_R8_UNORM:
|
||||
case VULKAN_FORMAT_R8_SNORM:
|
||||
case VULKAN_FORMAT_R8_USCALED:
|
||||
case VULKAN_FORMAT_R8_SSCALED:
|
||||
case VULKAN_FORMAT_R8_SRGB:
|
||||
case VULKAN_FORMAT_R8G8_SNORM:
|
||||
case VULKAN_FORMAT_R8G8_UNORM:
|
||||
case VULKAN_FORMAT_R8G8_USCALED:
|
||||
case VULKAN_FORMAT_R8G8_SSCALED:
|
||||
case VULKAN_FORMAT_R8G8_SRGB:
|
||||
case VULKAN_FORMAT_R8G8B8_UNORM:
|
||||
case VULKAN_FORMAT_R8G8B8_SNORM:
|
||||
case VULKAN_FORMAT_R8G8B8_USCALED:
|
||||
case VULKAN_FORMAT_R8G8B8_SSCALED:
|
||||
case VULKAN_FORMAT_R8G8B8_UINT:
|
||||
case VULKAN_FORMAT_R8G8B8_SINT:
|
||||
case VULKAN_FORMAT_R8G8B8_SRGB:
|
||||
case VULKAN_FORMAT_B8G8R8_UNORM:
|
||||
case VULKAN_FORMAT_B8G8R8_SNORM:
|
||||
case VULKAN_FORMAT_B8G8R8_USCALED:
|
||||
case VULKAN_FORMAT_B8G8R8_SSCALED:
|
||||
case VULKAN_FORMAT_B8G8R8_UINT:
|
||||
case VULKAN_FORMAT_B8G8R8_SINT:
|
||||
case VULKAN_FORMAT_B8G8R8_SRGB:
|
||||
case VULKAN_FORMAT_R8G8B8A8_UNORM:
|
||||
case VULKAN_FORMAT_R8G8B8A8_SNORM:
|
||||
case VULKAN_FORMAT_R8G8B8A8_USCALED:
|
||||
case VULKAN_FORMAT_R8G8B8A8_SSCALED:
|
||||
case VULKAN_FORMAT_R8G8B8A8_SRGB:
|
||||
case VULKAN_FORMAT_B8G8R8A8_UNORM:
|
||||
case VULKAN_FORMAT_B8G8R8A8_SNORM:
|
||||
case VULKAN_FORMAT_B8G8R8A8_USCALED:
|
||||
case VULKAN_FORMAT_B8G8R8A8_SSCALED:
|
||||
case VULKAN_FORMAT_B8G8R8A8_UINT:
|
||||
case VULKAN_FORMAT_B8G8R8A8_SINT:
|
||||
case VULKAN_FORMAT_B8G8R8A8_SRGB:
|
||||
case VULKAN_FORMAT_A8B8G8R8_UNORM_PACK32:
|
||||
case VULKAN_FORMAT_A8B8G8R8_SNORM_PACK32:
|
||||
case VULKAN_FORMAT_A8B8G8R8_USCALED_PACK32:
|
||||
case VULKAN_FORMAT_A8B8G8R8_SSCALED_PACK32:
|
||||
case VULKAN_FORMAT_A8B8G8R8_UINT_PACK32:
|
||||
case VULKAN_FORMAT_A8B8G8R8_SINT_PACK32:
|
||||
case VULKAN_FORMAT_A8B8G8R8_SRGB_PACK32:
|
||||
case VULKAN_FORMAT_A2R10G10B10_UNORM_PACK32:
|
||||
case VULKAN_FORMAT_A2R10G10B10_SNORM_PACK32:
|
||||
case VULKAN_FORMAT_A2R10G10B10_USCALED_PACK32:
|
||||
case VULKAN_FORMAT_A2R10G10B10_SSCALED_PACK32:
|
||||
case VULKAN_FORMAT_A2R10G10B10_UINT_PACK32:
|
||||
case VULKAN_FORMAT_A2R10G10B10_SINT_PACK32:
|
||||
case VULKAN_FORMAT_A2B10G10R10_UNORM_PACK32:
|
||||
case VULKAN_FORMAT_A2B10G10R10_SNORM_PACK32:
|
||||
case VULKAN_FORMAT_A2B10G10R10_USCALED_PACK32:
|
||||
case VULKAN_FORMAT_A2B10G10R10_SSCALED_PACK32:
|
||||
case VULKAN_FORMAT_A2B10G10R10_UINT_PACK32:
|
||||
case VULKAN_FORMAT_A2B10G10R10_SINT_PACK32:
|
||||
case VULKAN_FORMAT_R16_UNORM:
|
||||
case VULKAN_FORMAT_R16_SNORM:
|
||||
case VULKAN_FORMAT_R16_USCALED:
|
||||
case VULKAN_FORMAT_R16_SSCALED:
|
||||
case VULKAN_FORMAT_R16_SFLOAT:
|
||||
case VULKAN_FORMAT_R16G16_UNORM:
|
||||
case VULKAN_FORMAT_R16G16_SNORM:
|
||||
case VULKAN_FORMAT_R16G16_USCALED:
|
||||
case VULKAN_FORMAT_R16G16_SSCALED:
|
||||
case VULKAN_FORMAT_R16G16_SFLOAT:
|
||||
case VULKAN_FORMAT_R16G16B16_UNORM:
|
||||
case VULKAN_FORMAT_R16G16B16_SNORM:
|
||||
case VULKAN_FORMAT_R16G16B16_USCALED:
|
||||
case VULKAN_FORMAT_R16G16B16_SSCALED:
|
||||
case VULKAN_FORMAT_R16G16B16_UINT:
|
||||
case VULKAN_FORMAT_R16G16B16_SINT:
|
||||
case VULKAN_FORMAT_R16G16B16_SFLOAT:
|
||||
case VULKAN_FORMAT_R16G16B16A16_UNORM:
|
||||
case VULKAN_FORMAT_R16G16B16A16_SNORM:
|
||||
case VULKAN_FORMAT_R16G16B16A16_USCALED:
|
||||
case VULKAN_FORMAT_R16G16B16A16_SSCALED:
|
||||
case VULKAN_FORMAT_R16G16B16A16_SFLOAT:
|
||||
case VULKAN_FORMAT_R32G32B32_UINT:
|
||||
case VULKAN_FORMAT_R32G32B32_SINT:
|
||||
case VULKAN_FORMAT_R32G32B32_SFLOAT:
|
||||
case VULKAN_FORMAT_R64_UINT:
|
||||
case VULKAN_FORMAT_R64_SINT:
|
||||
case VULKAN_FORMAT_R64_SFLOAT:
|
||||
case VULKAN_FORMAT_R64G64_UINT:
|
||||
case VULKAN_FORMAT_R64G64_SINT:
|
||||
case VULKAN_FORMAT_R64G64_SFLOAT:
|
||||
case VULKAN_FORMAT_R64G64B64_UINT:
|
||||
case VULKAN_FORMAT_R64G64B64_SINT:
|
||||
case VULKAN_FORMAT_R64G64B64_SFLOAT:
|
||||
case VULKAN_FORMAT_R64G64B64A64_UINT:
|
||||
case VULKAN_FORMAT_R64G64B64A64_SINT:
|
||||
case VULKAN_FORMAT_R64G64B64A64_SFLOAT:
|
||||
case VULKAN_FORMAT_B10G11R11_UFLOAT_PACK32:
|
||||
case VULKAN_FORMAT_E5B9G9R9_UFLOAT_PACK32:
|
||||
case VULKAN_FORMAT_D16_UNORM:
|
||||
case VULKAN_FORMAT_X8_D24_UNORM_PACK32:
|
||||
case VULKAN_FORMAT_D32_SFLOAT:
|
||||
case VULKAN_FORMAT_S8_UINT:
|
||||
case VULKAN_FORMAT_D16_UNORM_S8_UINT:
|
||||
case VULKAN_FORMAT_D24_UNORM_S8_UINT:
|
||||
case VULKAN_FORMAT_D32_SFLOAT_S8_UINT:
|
||||
case VULKAN_FORMAT_BC1_RGB_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_BC1_RGB_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_BC1_RGBA_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_BC1_RGBA_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_BC2_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_BC2_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_BC3_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_BC3_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_BC4_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_BC4_SNORM_BLOCK:
|
||||
case VULKAN_FORMAT_BC5_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_BC5_SNORM_BLOCK:
|
||||
case VULKAN_FORMAT_BC6H_UFLOAT_BLOCK:
|
||||
case VULKAN_FORMAT_BC6H_SFLOAT_BLOCK:
|
||||
case VULKAN_FORMAT_BC7_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_BC7_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_EAC_R11_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_EAC_R11_SNORM_BLOCK:
|
||||
case VULKAN_FORMAT_EAC_R11G11_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_EAC_R11G11_SNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_4x4_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_4x4_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_5x4_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_5x4_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_5x5_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_5x5_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_6x5_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_6x5_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_6x6_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_6x6_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_8x5_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_8x5_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_8x6_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_8x6_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_8x8_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_8x8_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_10x5_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_10x5_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_10x6_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_10x6_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_10x8_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_10x8_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_10x10_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_10x10_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_12x10_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_12x10_SRGB_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_12x12_UNORM_BLOCK:
|
||||
case VULKAN_FORMAT_ASTC_12x12_SRGB_BLOCK:
|
||||
ASSERT(0);
|
||||
std::cout << "Unsupport texture format";
|
||||
}
|
||||
}
|
||||
|
||||
return formatList;
|
||||
}
|
||||
|
||||
uint32_t getVulkanFormatElementSize(VulkanFormat format)
|
||||
{
|
||||
switch (format)
|
||||
{
|
||||
case VULKAN_FORMAT_R8_UINT: return uint32_t(1);
|
||||
case VULKAN_FORMAT_R8_SINT: return uint32_t(1);
|
||||
case VULKAN_FORMAT_R8G8_UINT: return uint32_t(2);
|
||||
case VULKAN_FORMAT_R8G8_SINT: return uint32_t(2);
|
||||
case VULKAN_FORMAT_R8G8B8A8_UINT: return uint32_t(4);
|
||||
case VULKAN_FORMAT_R8G8B8A8_SINT: return uint32_t(4);
|
||||
case VULKAN_FORMAT_R16_UINT: return uint32_t(2);
|
||||
case VULKAN_FORMAT_R16_SINT: return uint32_t(2);
|
||||
case VULKAN_FORMAT_R16G16_UINT: return uint32_t(4);
|
||||
case VULKAN_FORMAT_R16G16_SINT: return uint32_t(4);
|
||||
case VULKAN_FORMAT_R16G16B16A16_UINT: return uint32_t(8);
|
||||
case VULKAN_FORMAT_R16G16B16A16_SINT: return uint32_t(8);
|
||||
case VULKAN_FORMAT_R32_UINT: return uint32_t(4);
|
||||
case VULKAN_FORMAT_R32_SINT: return uint32_t(4);
|
||||
case VULKAN_FORMAT_R32_SFLOAT: return uint32_t(4);
|
||||
case VULKAN_FORMAT_R32G32_UINT: return uint32_t(8);
|
||||
case VULKAN_FORMAT_R32G32_SINT: return uint32_t(8);
|
||||
case VULKAN_FORMAT_R32G32_SFLOAT: return uint32_t(8);
|
||||
case VULKAN_FORMAT_R32G32B32A32_UINT: return uint32_t(16);
|
||||
case VULKAN_FORMAT_R32G32B32A32_SINT: return uint32_t(16);
|
||||
case VULKAN_FORMAT_R32G32B32A32_SFLOAT: return uint32_t(16);
|
||||
default: ASSERT(0); std::cout << "Unknown format";
|
||||
}
|
||||
|
||||
return uint32_t(0);
|
||||
}
|
||||
|
||||
const char *getVulkanFormatGLSLFormat(VulkanFormat format)
|
||||
{
|
||||
switch (format)
|
||||
{
|
||||
case VULKAN_FORMAT_R8_UINT: return "r8ui";
|
||||
case VULKAN_FORMAT_R8_SINT: return "r8i";
|
||||
case VULKAN_FORMAT_R8G8_UINT: return "rg8ui";
|
||||
case VULKAN_FORMAT_R8G8_SINT: return "rg8i";
|
||||
case VULKAN_FORMAT_R8G8B8A8_UINT: return "rgba8ui";
|
||||
case VULKAN_FORMAT_R8G8B8A8_SINT: return "rgba8i";
|
||||
case VULKAN_FORMAT_R16_UINT: return "r16ui";
|
||||
case VULKAN_FORMAT_R16_SINT: return "r16i";
|
||||
case VULKAN_FORMAT_R16G16_UINT: return "rg16ui";
|
||||
case VULKAN_FORMAT_R16G16_SINT: return "rg16i";
|
||||
case VULKAN_FORMAT_R16G16B16A16_UINT: return "rgba16ui";
|
||||
case VULKAN_FORMAT_R16G16B16A16_SINT: return "rgba16i";
|
||||
case VULKAN_FORMAT_R32_UINT: return "r32ui";
|
||||
case VULKAN_FORMAT_R32_SINT: return "r32i";
|
||||
case VULKAN_FORMAT_R32_SFLOAT: return "r32f";
|
||||
case VULKAN_FORMAT_R32G32_UINT: return "rg32ui";
|
||||
case VULKAN_FORMAT_R32G32_SINT: return "rg32i";
|
||||
case VULKAN_FORMAT_R32G32_SFLOAT: return "rg32f";
|
||||
case VULKAN_FORMAT_R32G32B32A32_UINT: return "rgba32ui";
|
||||
case VULKAN_FORMAT_R32G32B32A32_SINT: return "rgba32i";
|
||||
case VULKAN_FORMAT_R32G32B32A32_SFLOAT: return "rgba32f";
|
||||
default: ASSERT(0); std::cout << "Unknown format";
|
||||
}
|
||||
|
||||
return (const char *)size_t(0);
|
||||
}
|
||||
|
||||
std::ostream &operator<<(std::ostream &os,
|
||||
VulkanMemoryTypeProperty memoryTypeProperty)
|
||||
{
|
||||
switch (memoryTypeProperty)
|
||||
{
|
||||
case VULKAN_MEMORY_TYPE_PROPERTY_NONE: return os << "None";
|
||||
case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL:
|
||||
return os << "Device local";
|
||||
case VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_COHERENT:
|
||||
return os << "Host visible and coherent";
|
||||
case VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED:
|
||||
return os << "Host visible and cached";
|
||||
case VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED_COHERENT:
|
||||
return os << "Host visible, cached and coherent";
|
||||
case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_COHERENT:
|
||||
return os << "Device local, Host visible and coherent";
|
||||
case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED:
|
||||
return os << "Device local, Host visible and cached";
|
||||
case VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED_COHERENT:
|
||||
return os << "Device local, Host visible, cached and coherent";
|
||||
}
|
||||
|
||||
return os;
|
||||
}
|
||||
|
||||
std::ostream &
|
||||
operator<<(std::ostream &os,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType)
|
||||
{
|
||||
switch (externalMemoryHandleType)
|
||||
{
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE: return os << "None";
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD:
|
||||
return os << "Opaque file descriptor";
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT:
|
||||
return os << "Opaque NT handle";
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT:
|
||||
return os << "Opaque D3DKMT handle";
|
||||
case VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
|
||||
return os << "Opaque NT and D3DKMT handle";
|
||||
}
|
||||
|
||||
return os;
|
||||
}
|
||||
|
||||
std::ostream &
|
||||
operator<<(std::ostream &os,
|
||||
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType)
|
||||
{
|
||||
switch (externalSemaphoreHandleType)
|
||||
{
|
||||
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE: return os << "None";
|
||||
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD:
|
||||
return os << "Opaque file descriptor";
|
||||
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT:
|
||||
return os << "Opaque NT handle";
|
||||
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT:
|
||||
return os << "Opaque D3DKMT handle";
|
||||
case VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT:
|
||||
return os << "Opaque NT and D3DKMT handle";
|
||||
}
|
||||
|
||||
return os;
|
||||
}
|
||||
|
||||
std::ostream &operator<<(std::ostream &os, VulkanFormat format)
|
||||
{
|
||||
switch (format)
|
||||
{
|
||||
case VULKAN_FORMAT_R8_UINT: return os << "R8_UINT";
|
||||
case VULKAN_FORMAT_R8_SINT: return os << "R8_SINT";
|
||||
case VULKAN_FORMAT_R8G8_UINT: return os << "R8G8_UINT";
|
||||
case VULKAN_FORMAT_R8G8_SINT: return os << "R8G8_SINT";
|
||||
case VULKAN_FORMAT_R8G8B8A8_UINT: return os << "R8G8B8A8_UINT";
|
||||
case VULKAN_FORMAT_R8G8B8A8_SINT: return os << "R8G8B8A8_SINT";
|
||||
case VULKAN_FORMAT_R16_UINT: return os << "R16_UINT";
|
||||
case VULKAN_FORMAT_R16_SINT: return os << "R16_SINT";
|
||||
case VULKAN_FORMAT_R16G16_UINT: return os << "R16G16_UINT";
|
||||
case VULKAN_FORMAT_R16G16_SINT: return os << "R16G16_SINT";
|
||||
case VULKAN_FORMAT_R16G16B16A16_UINT: return os << "R16G16B16A16_UINT";
|
||||
case VULKAN_FORMAT_R16G16B16A16_SINT: return os << "R16G16B16A16_SINT";
|
||||
case VULKAN_FORMAT_R32_UINT: return os << "R32_UINT";
|
||||
case VULKAN_FORMAT_R32_SINT: return os << "R32_SINT";
|
||||
case VULKAN_FORMAT_R32_SFLOAT: return os << "R32_SFLOAT";
|
||||
case VULKAN_FORMAT_R32G32_UINT: return os << "R32G32_UINT";
|
||||
case VULKAN_FORMAT_R32G32_SINT: return os << "R32G32_SINT";
|
||||
case VULKAN_FORMAT_R32G32_SFLOAT: return os << "R32G32_SFLOAT";
|
||||
case VULKAN_FORMAT_R32G32B32A32_UINT: return os << "R32G32B32A32_UINT";
|
||||
case VULKAN_FORMAT_R32G32B32A32_SINT: return os << "R32G32B32A32_SINT";
|
||||
case VULKAN_FORMAT_R32G32B32A32_SFLOAT:
|
||||
return os << "R32G32B32A32_SFLOAT";
|
||||
break;
|
||||
default: ASSERT(0); std::cout << "Unknown format";
|
||||
}
|
||||
|
||||
return os;
|
||||
}
|
||||
|
||||
static char *findFilePath(const std::string filename)
|
||||
{
|
||||
const char *searchPath[] = {
|
||||
"./", // Same dir
|
||||
"./shaders/", // In shaders folder in same dir
|
||||
"../test_conformance/vulkan/shaders/" // In src folder
|
||||
};
|
||||
for (unsigned int i = 0; i < sizeof(searchPath) / sizeof(char *); ++i)
|
||||
{
|
||||
std::string path(searchPath[i]);
|
||||
|
||||
path.append(filename);
|
||||
FILE *fp;
|
||||
fp = fopen(path.c_str(), "rb");
|
||||
|
||||
if (fp != NULL)
|
||||
{
|
||||
fclose(fp);
|
||||
// File found
|
||||
char *file_path = (char *)(malloc(path.length() + 1));
|
||||
strncpy(file_path, path.c_str(), path.length() + 1);
|
||||
return file_path;
|
||||
}
|
||||
if (fp)
|
||||
{
|
||||
fclose(fp);
|
||||
}
|
||||
}
|
||||
// File not found
|
||||
return 0;
|
||||
}
|
||||
|
||||
std::vector<char> readFile(const std::string &filename)
|
||||
{
|
||||
char *file_path = findFilePath(filename);
|
||||
|
||||
std::ifstream file(file_path, std::ios::ate | std::ios::binary);
|
||||
|
||||
if (!file.is_open())
|
||||
{
|
||||
throw std::runtime_error("failed to open shader spv file!\n");
|
||||
}
|
||||
size_t fileSize = (size_t)file.tellg();
|
||||
std::vector<char> buffer(fileSize);
|
||||
file.seekg(0);
|
||||
file.read(buffer.data(), fileSize);
|
||||
file.close();
|
||||
printf("filesize is %d", fileSize);
|
||||
return buffer;
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
//
|
||||
// Copyright (c) 2022 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
|
||||
#ifndef _vulkan_utility_hpp_
|
||||
#define _vulkan_utility_hpp_
|
||||
|
||||
#include "vulkan_wrapper_types.hpp"
|
||||
#include <vector>
|
||||
#include <ostream>
|
||||
#include <string.h>
|
||||
#include <map>
|
||||
#include "../../../test_common/harness/testHarness.h"
|
||||
|
||||
#define STRING_(str) #str
|
||||
#define STRING(str) STRING_(str)
|
||||
|
||||
#define ROUND_UP(n, multiple) \
|
||||
(((n) + (multiple)-1) - ((((n) + (multiple)-1)) % (multiple)))
|
||||
|
||||
const VulkanInstance& getVulkanInstance();
|
||||
const VulkanPhysicalDevice& getVulkanPhysicalDevice();
|
||||
const VulkanQueueFamily&
|
||||
getVulkanQueueFamily(uint32_t queueFlags = VULKAN_QUEUE_FLAG_MASK_ALL);
|
||||
const VulkanMemoryType&
|
||||
getVulkanMemoryType(const VulkanDevice& device,
|
||||
VulkanMemoryTypeProperty memoryTypeProperty);
|
||||
bool checkVkSupport();
|
||||
const VulkanQueueFamilyList& getEmptyVulkanQueueFamilyList();
|
||||
const VulkanDescriptorSetLayoutList& getEmptyVulkanDescriptorSetLayoutList();
|
||||
const VulkanQueueFamilyToQueueCountMap&
|
||||
getDefaultVulkanQueueFamilyToQueueCountMap();
|
||||
const std::vector<VulkanExternalMemoryHandleType>
|
||||
getSupportedVulkanExternalMemoryHandleTypeList();
|
||||
const std::vector<VulkanExternalSemaphoreHandleType>
|
||||
getSupportedVulkanExternalSemaphoreHandleTypeList();
|
||||
const std::vector<VulkanFormat> getSupportedVulkanFormatList();
|
||||
|
||||
uint32_t getVulkanFormatElementSize(VulkanFormat format);
|
||||
const char* getVulkanFormatGLSLFormat(VulkanFormat format);
|
||||
const char* getVulkanFormatGLSLTypePrefix(VulkanFormat format);
|
||||
|
||||
std::string prepareVulkanShader(
|
||||
std::string shaderCode,
|
||||
const std::map<std::string, std::string>& patternToSubstituteMap);
|
||||
|
||||
std::ostream& operator<<(std::ostream& os,
|
||||
VulkanMemoryTypeProperty memoryTypeProperty);
|
||||
std::ostream&
|
||||
operator<<(std::ostream& os,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType);
|
||||
std::ostream&
|
||||
operator<<(std::ostream& os,
|
||||
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType);
|
||||
std::ostream& operator<<(std::ostream& os, VulkanFormat format);
|
||||
|
||||
std::vector<char> readFile(const std::string& filename);
|
||||
#endif // _vulkan_utility_hpp_
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,580 +0,0 @@
|
||||
//
|
||||
// Copyright (c) 2022 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
|
||||
#ifndef _vulkan_wrapper_hpp_
|
||||
#define _vulkan_wrapper_hpp_
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
#include "vulkan_wrapper_types.hpp"
|
||||
#include "vulkan_list_map.hpp"
|
||||
#include "vulkan_api_list.hpp"
|
||||
|
||||
class VulkanInstance {
|
||||
friend const VulkanInstance &getVulkanInstance();
|
||||
|
||||
protected:
|
||||
VkInstance m_vkInstance;
|
||||
VulkanPhysicalDeviceList m_physicalDeviceList;
|
||||
|
||||
VulkanInstance();
|
||||
VulkanInstance(const VulkanInstance &);
|
||||
virtual ~VulkanInstance();
|
||||
|
||||
public:
|
||||
const VulkanPhysicalDeviceList &getPhysicalDeviceList() const;
|
||||
operator VkInstance() const;
|
||||
};
|
||||
|
||||
class VulkanPhysicalDevice {
|
||||
friend class VulkanInstance;
|
||||
|
||||
protected:
|
||||
VkPhysicalDevice m_vkPhysicalDevice;
|
||||
VkPhysicalDeviceProperties m_vkPhysicalDeviceProperties;
|
||||
uint8_t m_vkDeviceUUID[VK_UUID_SIZE];
|
||||
uint8_t m_vkDeviceLUID[VK_LUID_SIZE];
|
||||
uint32_t m_vkDeviceNodeMask;
|
||||
VkPhysicalDeviceFeatures m_vkPhysicalDeviceFeatures;
|
||||
VkPhysicalDeviceMemoryProperties m_vkPhysicalDeviceMemoryProperties;
|
||||
VulkanQueueFamilyList m_queueFamilyList;
|
||||
VulkanMemoryHeapList m_memoryHeapList;
|
||||
VulkanMemoryTypeList m_memoryTypeList;
|
||||
|
||||
VulkanPhysicalDevice(const VulkanPhysicalDevice &physicalDevice);
|
||||
VulkanPhysicalDevice(VkPhysicalDevice vkPhysicalDevice);
|
||||
virtual ~VulkanPhysicalDevice();
|
||||
|
||||
public:
|
||||
const VulkanQueueFamilyList &getQueueFamilyList() const;
|
||||
const VulkanMemoryHeapList &getMemoryHeapList() const;
|
||||
const VulkanMemoryTypeList &getMemoryTypeList() const;
|
||||
const uint8_t *getUUID() const;
|
||||
const uint8_t *getLUID() const;
|
||||
uint32_t getNodeMask() const;
|
||||
operator VkPhysicalDevice() const;
|
||||
};
|
||||
|
||||
class VulkanMemoryHeap {
|
||||
friend class VulkanPhysicalDevice;
|
||||
|
||||
protected:
|
||||
uint32_t m_memoryHeapIndex;
|
||||
uint64_t m_size;
|
||||
VulkanMemoryHeapFlag m_memoryHeapFlag;
|
||||
|
||||
VulkanMemoryHeap(const VulkanMemoryHeap &memoryHeap);
|
||||
VulkanMemoryHeap(uint32_t m_memoryHeapIndex, uint64_t m_size,
|
||||
VulkanMemoryHeapFlag m_memoryHeapFlag);
|
||||
virtual ~VulkanMemoryHeap();
|
||||
|
||||
public:
|
||||
uint64_t getSize() const;
|
||||
VulkanMemoryHeapFlag getMemoryHeapFlag() const;
|
||||
operator uint32_t() const;
|
||||
};
|
||||
|
||||
class VulkanMemoryType {
|
||||
friend class VulkanPhysicalDevice;
|
||||
|
||||
protected:
|
||||
uint32_t m_memoryTypeIndex;
|
||||
const VulkanMemoryTypeProperty m_memoryTypeProperty;
|
||||
const VulkanMemoryHeap &m_memoryHeap;
|
||||
|
||||
VulkanMemoryType(const VulkanMemoryType &memoryType);
|
||||
VulkanMemoryType(uint32_t memoryTypeIndex,
|
||||
VulkanMemoryTypeProperty memoryTypeProperty,
|
||||
const VulkanMemoryHeap &memoryHeap);
|
||||
virtual ~VulkanMemoryType();
|
||||
|
||||
public:
|
||||
VulkanMemoryTypeProperty getMemoryTypeProperty() const;
|
||||
const VulkanMemoryHeap &getMemoryHeap() const;
|
||||
operator uint32_t() const;
|
||||
};
|
||||
|
||||
class VulkanQueueFamily {
|
||||
friend class VulkanPhysicalDevice;
|
||||
|
||||
protected:
|
||||
uint32_t m_queueFamilyIndex;
|
||||
VkQueueFamilyProperties m_vkQueueFamilyProperties;
|
||||
|
||||
VulkanQueueFamily(const VulkanQueueFamily &queueFamily);
|
||||
VulkanQueueFamily(uint32_t queueFamilyIndex,
|
||||
VkQueueFamilyProperties vkQueueFamilyProperties);
|
||||
virtual ~VulkanQueueFamily();
|
||||
|
||||
public:
|
||||
uint32_t getQueueFlags() const;
|
||||
uint32_t getQueueCount() const;
|
||||
operator uint32_t() const;
|
||||
};
|
||||
|
||||
class VulkanDevice {
|
||||
protected:
|
||||
const VulkanPhysicalDevice &m_physicalDevice;
|
||||
VkDevice m_vkDevice;
|
||||
VulkanQueueFamilyToQueueListMap m_queueFamilyIndexToQueueListMap;
|
||||
|
||||
VulkanDevice(const VulkanDevice &device);
|
||||
|
||||
public:
|
||||
VulkanDevice(
|
||||
const VulkanPhysicalDevice &physicalDevice = getVulkanPhysicalDevice(),
|
||||
const VulkanQueueFamilyToQueueCountMap &queueFamilyToQueueCountMap =
|
||||
getDefaultVulkanQueueFamilyToQueueCountMap());
|
||||
virtual ~VulkanDevice();
|
||||
const VulkanPhysicalDevice &getPhysicalDevice() const;
|
||||
VulkanQueue &
|
||||
getQueue(const VulkanQueueFamily &queueFamily = getVulkanQueueFamily(),
|
||||
uint32_t queueIndex = 0);
|
||||
operator VkDevice() const;
|
||||
};
|
||||
|
||||
class VulkanQueue {
|
||||
friend class VulkanDevice;
|
||||
|
||||
protected:
|
||||
VkQueue m_vkQueue;
|
||||
|
||||
VulkanQueue(VkQueue vkQueue);
|
||||
VulkanQueue(const VulkanQueue &queue);
|
||||
virtual ~VulkanQueue();
|
||||
|
||||
public:
|
||||
const VulkanQueueFamily &getQueueFamily();
|
||||
void submit(const VulkanSemaphoreList &waitSemaphoreList,
|
||||
const VulkanCommandBufferList &commandBufferList,
|
||||
const VulkanSemaphoreList &signalSemaphoreList);
|
||||
void submit(const VulkanSemaphore &waitSemaphore,
|
||||
const VulkanCommandBuffer &commandBuffer,
|
||||
const VulkanSemaphore &signalSemaphore);
|
||||
void submit(const VulkanCommandBuffer &commandBuffer,
|
||||
const VulkanSemaphore &signalSemaphore);
|
||||
void submit(const VulkanCommandBuffer &commandBuffer);
|
||||
void waitIdle();
|
||||
operator VkQueue() const;
|
||||
};
|
||||
|
||||
class VulkanDescriptorSetLayoutBinding {
|
||||
protected:
|
||||
VkDescriptorSetLayoutBinding m_vkDescriptorSetLayoutBinding;
|
||||
|
||||
VulkanDescriptorSetLayoutBinding(
|
||||
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding);
|
||||
|
||||
public:
|
||||
VulkanDescriptorSetLayoutBinding(
|
||||
uint32_t binding, VulkanDescriptorType descriptorType,
|
||||
uint32_t descriptorCount = 1,
|
||||
VulkanShaderStage shaderStage = VULKAN_SHADER_STAGE_COMPUTE);
|
||||
virtual ~VulkanDescriptorSetLayoutBinding();
|
||||
operator VkDescriptorSetLayoutBinding() const;
|
||||
};
|
||||
|
||||
class VulkanDescriptorSetLayout {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
VkDescriptorSetLayout m_vkDescriptorSetLayout;
|
||||
|
||||
VulkanDescriptorSetLayout(
|
||||
const VulkanDescriptorSetLayout &descriptorSetLayout);
|
||||
void
|
||||
VulkanDescriptorSetLayoutCommon(const VulkanDescriptorSetLayoutBindingList
|
||||
&descriptorSetLayoutBindingList);
|
||||
|
||||
public:
|
||||
VulkanDescriptorSetLayout(
|
||||
const VulkanDevice &device,
|
||||
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding);
|
||||
VulkanDescriptorSetLayout(
|
||||
const VulkanDevice &device,
|
||||
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding0,
|
||||
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding1);
|
||||
VulkanDescriptorSetLayout(const VulkanDevice &device,
|
||||
const VulkanDescriptorSetLayoutBindingList
|
||||
&descriptorSetLayoutBindingList);
|
||||
virtual ~VulkanDescriptorSetLayout();
|
||||
operator VkDescriptorSetLayout() const;
|
||||
};
|
||||
|
||||
class VulkanPipelineLayout {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
VkPipelineLayout m_vkPipelineLayout;
|
||||
|
||||
VulkanPipelineLayout(const VulkanPipelineLayout &pipelineLayout);
|
||||
void VulkanPipelineLayoutCommon(
|
||||
const VulkanDescriptorSetLayoutList &descriptorSetLayoutList);
|
||||
|
||||
public:
|
||||
VulkanPipelineLayout(const VulkanDevice &device,
|
||||
const VulkanDescriptorSetLayout &descriptorSetLayout);
|
||||
VulkanPipelineLayout(
|
||||
const VulkanDevice &device,
|
||||
const VulkanDescriptorSetLayoutList &descriptorSetLayoutList =
|
||||
getEmptyVulkanDescriptorSetLayoutList());
|
||||
virtual ~VulkanPipelineLayout();
|
||||
operator VkPipelineLayout() const;
|
||||
};
|
||||
|
||||
class VulkanShaderModule {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
VkShaderModule m_vkShaderModule;
|
||||
|
||||
VulkanShaderModule(const VulkanShaderModule &shaderModule);
|
||||
|
||||
public:
|
||||
VulkanShaderModule(const VulkanDevice &device,
|
||||
const std::vector<char> &code);
|
||||
virtual ~VulkanShaderModule();
|
||||
operator VkShaderModule() const;
|
||||
};
|
||||
|
||||
class VulkanPipeline {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
VkPipeline m_vkPipeline;
|
||||
|
||||
VulkanPipeline(const VulkanPipeline &pipeline);
|
||||
|
||||
public:
|
||||
VulkanPipeline(const VulkanDevice &device);
|
||||
virtual ~VulkanPipeline();
|
||||
virtual VulkanPipelineBindPoint getPipelineBindPoint() const = 0;
|
||||
operator VkPipeline() const;
|
||||
};
|
||||
|
||||
class VulkanComputePipeline : public VulkanPipeline {
|
||||
protected:
|
||||
VulkanComputePipeline(const VulkanComputePipeline &computePipeline);
|
||||
|
||||
public:
|
||||
VulkanComputePipeline(const VulkanDevice &device,
|
||||
const VulkanPipelineLayout &pipelineLayout,
|
||||
const VulkanShaderModule &shaderModule,
|
||||
const std::string &entryFuncName = "main");
|
||||
virtual ~VulkanComputePipeline();
|
||||
VulkanPipelineBindPoint getPipelineBindPoint() const;
|
||||
};
|
||||
|
||||
class VulkanDescriptorPool {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
VkDescriptorPool m_vkDescriptorPool;
|
||||
|
||||
VulkanDescriptorPool(const VulkanDescriptorPool &descriptorPool);
|
||||
void VulkanDescriptorPoolCommon(const VulkanDescriptorSetLayoutBindingList
|
||||
&descriptorSetLayoutBindingList);
|
||||
|
||||
public:
|
||||
VulkanDescriptorPool(
|
||||
const VulkanDevice &device,
|
||||
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding);
|
||||
VulkanDescriptorPool(
|
||||
const VulkanDevice &device,
|
||||
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding0,
|
||||
const VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding1);
|
||||
VulkanDescriptorPool(const VulkanDevice &device,
|
||||
const VulkanDescriptorSetLayoutBindingList
|
||||
&descriptorSetLayoutBindingList);
|
||||
virtual ~VulkanDescriptorPool();
|
||||
operator VkDescriptorPool() const;
|
||||
};
|
||||
|
||||
class VulkanDescriptorSet {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
const VulkanDescriptorPool &m_descriptorPool;
|
||||
VkDescriptorSet m_vkDescriptorSet;
|
||||
|
||||
VulkanDescriptorSet(const VulkanDescriptorSet &descriptorSet);
|
||||
|
||||
public:
|
||||
VulkanDescriptorSet(const VulkanDevice &device,
|
||||
const VulkanDescriptorPool &descriptorPool,
|
||||
const VulkanDescriptorSetLayout &descriptorSetLayout);
|
||||
virtual ~VulkanDescriptorSet();
|
||||
void update(uint32_t binding, const VulkanBuffer &buffer);
|
||||
void update(uint32_t binding, const VulkanImageView &imageView);
|
||||
operator VkDescriptorSet() const;
|
||||
};
|
||||
|
||||
class VulkanOffset3D {
|
||||
protected:
|
||||
VkOffset3D m_vkOffset3D;
|
||||
|
||||
public:
|
||||
VulkanOffset3D(const VulkanOffset3D &extent3D);
|
||||
VulkanOffset3D(uint32_t x = 0, uint32_t y = 0, uint32_t z = 0);
|
||||
virtual ~VulkanOffset3D();
|
||||
uint32_t getX() const;
|
||||
uint32_t getY() const;
|
||||
uint32_t getZ() const;
|
||||
operator VkOffset3D() const;
|
||||
};
|
||||
|
||||
class VulkanExtent3D {
|
||||
protected:
|
||||
VkExtent3D m_vkExtent3D;
|
||||
|
||||
public:
|
||||
VulkanExtent3D(const VulkanExtent3D &extent3D);
|
||||
VulkanExtent3D(uint32_t width, uint32_t height = 1, uint32_t depth = 1);
|
||||
virtual ~VulkanExtent3D();
|
||||
uint32_t getWidth() const;
|
||||
uint32_t getHeight() const;
|
||||
uint32_t getDepth() const;
|
||||
operator VkExtent3D() const;
|
||||
};
|
||||
|
||||
class VulkanCommandPool {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
VkCommandPool m_vkCommandPool;
|
||||
|
||||
VulkanCommandPool(const VulkanCommandPool &commandPool);
|
||||
|
||||
public:
|
||||
VulkanCommandPool(
|
||||
const VulkanDevice &device,
|
||||
const VulkanQueueFamily &queueFamily = getVulkanQueueFamily());
|
||||
virtual ~VulkanCommandPool();
|
||||
operator VkCommandPool() const;
|
||||
};
|
||||
|
||||
class VulkanCommandBuffer {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
const VulkanCommandPool &m_commandPool;
|
||||
VkCommandBuffer m_vkCommandBuffer;
|
||||
|
||||
VulkanCommandBuffer(const VulkanCommandBuffer &commandBuffer);
|
||||
|
||||
public:
|
||||
VulkanCommandBuffer(const VulkanDevice &device,
|
||||
const VulkanCommandPool &commandPool);
|
||||
virtual ~VulkanCommandBuffer();
|
||||
void begin();
|
||||
void bindPipeline(const VulkanPipeline &pipeline);
|
||||
void bindDescriptorSets(const VulkanPipeline &pipeline,
|
||||
const VulkanPipelineLayout &pipelineLayout,
|
||||
const VulkanDescriptorSet &descriptorSet);
|
||||
void pipelineBarrier(const VulkanImage2DList &image2DList,
|
||||
VulkanImageLayout oldImageLayout,
|
||||
VulkanImageLayout newImageLayout);
|
||||
void dispatch(uint32_t groupCountX, uint32_t groupCountY,
|
||||
uint32_t groupCountZ);
|
||||
void fillBuffer(const VulkanBuffer &buffer, uint32_t data,
|
||||
uint64_t offset = 0, uint64_t size = VK_WHOLE_SIZE);
|
||||
void updateBuffer(const VulkanBuffer &buffer, void *pdata,
|
||||
uint64_t offset = 0, uint64_t size = VK_WHOLE_SIZE);
|
||||
void copyBufferToImage(const VulkanBuffer &buffer, const VulkanImage &image,
|
||||
VulkanImageLayout imageLayout =
|
||||
VULKAN_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
|
||||
void copyBufferToImage(const VulkanBuffer &buffer, const VulkanImage &image,
|
||||
uint64_t bufferOffset = 0, uint32_t mipLevel = 0,
|
||||
uint32_t baseArrayLayer = 0, uint32_t layerCount = 1,
|
||||
VulkanOffset3D offset3D = VulkanOffset3D(0, 0, 0),
|
||||
VulkanExtent3D extent3D = VulkanExtent3D(0, 0, 0));
|
||||
void copyImageToBuffer(const VulkanImage &image, const VulkanBuffer &buffer,
|
||||
uint64_t bufferOffset = 0, uint32_t mipLevel = 0,
|
||||
uint32_t baseArrayLayer = 0, uint32_t layerCount = 1,
|
||||
VulkanOffset3D offset3D = VulkanOffset3D(0, 0, 0),
|
||||
VulkanExtent3D extent3D = VulkanExtent3D(0, 0, 0));
|
||||
void end();
|
||||
operator VkCommandBuffer() const;
|
||||
};
|
||||
|
||||
class VulkanBuffer {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
VkBuffer m_vkBuffer;
|
||||
uint64_t m_size;
|
||||
uint64_t m_alignment;
|
||||
VulkanMemoryTypeList m_memoryTypeList;
|
||||
|
||||
VulkanBuffer(const VulkanBuffer &buffer);
|
||||
|
||||
public:
|
||||
VulkanBuffer(const VulkanDevice &device, uint64_t size,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType =
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
|
||||
VulkanBufferUsage bufferUsage =
|
||||
VULKAN_BUFFER_USAGE_STORAGE_BUFFER_TRANSFER_SRC_DST,
|
||||
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE,
|
||||
const VulkanQueueFamilyList &queueFamilyList =
|
||||
getEmptyVulkanQueueFamilyList());
|
||||
virtual ~VulkanBuffer();
|
||||
uint64_t getSize() const;
|
||||
uint64_t getAlignment() const;
|
||||
const VulkanMemoryTypeList &getMemoryTypeList() const;
|
||||
operator VkBuffer() const;
|
||||
};
|
||||
|
||||
class VulkanImage {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
const VulkanImageType m_imageType;
|
||||
const VulkanExtent3D m_extent3D;
|
||||
const VulkanFormat m_format;
|
||||
const uint32_t m_numMipLevels;
|
||||
const uint32_t m_numLayers;
|
||||
VkImage m_vkImage;
|
||||
uint64_t m_size;
|
||||
uint64_t m_alignment;
|
||||
VulkanMemoryTypeList m_memoryTypeList;
|
||||
VkImageCreateInfo VulkanImageCreateInfo;
|
||||
VulkanImage(const VulkanImage &image);
|
||||
|
||||
public:
|
||||
VulkanImage(
|
||||
const VulkanDevice &device, VulkanImageType imageType,
|
||||
VulkanFormat format, const VulkanExtent3D &extent3D,
|
||||
uint32_t numMipLevels = 1, uint32_t arrayLayers = 1,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType =
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
|
||||
VulkanImageCreateFlag imageCreateFlags = VULKAN_IMAGE_CREATE_FLAG_NONE,
|
||||
VulkanImageTiling imageTiling = VULKAN_IMAGE_TILING_OPTIMAL,
|
||||
VulkanImageUsage imageUsage =
|
||||
VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
|
||||
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
|
||||
virtual ~VulkanImage();
|
||||
virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const;
|
||||
VulkanFormat getFormat() const;
|
||||
uint32_t getNumMipLevels() const;
|
||||
uint32_t getNumLayers() const;
|
||||
uint64_t getSize() const;
|
||||
uint64_t getAlignment() const;
|
||||
const VulkanMemoryTypeList &getMemoryTypeList() const;
|
||||
VkImageCreateInfo getVkImageCreateInfo() const;
|
||||
operator VkImage() const;
|
||||
};
|
||||
|
||||
class VulkanImage2D : public VulkanImage {
|
||||
protected:
|
||||
VkImageView m_vkImageView;
|
||||
|
||||
VulkanImage2D(const VulkanImage2D &image2D);
|
||||
|
||||
public:
|
||||
VulkanImage2D(
|
||||
const VulkanDevice &device, VulkanFormat format, uint32_t width,
|
||||
uint32_t height, uint32_t numMipLevels = 1,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType =
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
|
||||
VulkanImageCreateFlag imageCreateFlag = VULKAN_IMAGE_CREATE_FLAG_NONE,
|
||||
VulkanImageUsage imageUsage =
|
||||
VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST,
|
||||
VulkanSharingMode sharingMode = VULKAN_SHARING_MODE_EXCLUSIVE);
|
||||
virtual ~VulkanImage2D();
|
||||
virtual VulkanExtent3D getExtent3D(uint32_t mipLevel = 0) const;
|
||||
};
|
||||
|
||||
class VulkanImageView {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
VkImageView m_vkImageView;
|
||||
|
||||
VulkanImageView(const VulkanImageView &imageView);
|
||||
|
||||
public:
|
||||
VulkanImageView(const VulkanDevice &device, const VulkanImage &image,
|
||||
VulkanImageViewType imageViewType,
|
||||
uint32_t baseMipLevel = 0,
|
||||
uint32_t mipLevelCount = VULKAN_REMAINING_MIP_LEVELS,
|
||||
uint32_t baseArrayLayer = 0,
|
||||
uint32_t layerCount = VULKAN_REMAINING_ARRAY_LAYERS);
|
||||
virtual ~VulkanImageView();
|
||||
operator VkImageView() const;
|
||||
};
|
||||
|
||||
class VulkanDeviceMemory {
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
VkDeviceMemory m_vkDeviceMemory;
|
||||
uint64_t m_size;
|
||||
bool m_isDedicated;
|
||||
|
||||
VulkanDeviceMemory(const VulkanDeviceMemory &deviceMemory);
|
||||
|
||||
public:
|
||||
VulkanDeviceMemory(const VulkanDevice &device, uint64_t size,
|
||||
const VulkanMemoryType &memoryType,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType =
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
|
||||
const void *name = NULL);
|
||||
VulkanDeviceMemory(const VulkanDevice &device, const VulkanImage &image,
|
||||
const VulkanMemoryType &memoryType,
|
||||
VulkanExternalMemoryHandleType externalMemoryHandleType =
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE,
|
||||
const void *name = NULL);
|
||||
virtual ~VulkanDeviceMemory();
|
||||
uint64_t getSize() const;
|
||||
#ifdef _WIN32
|
||||
HANDLE
|
||||
getHandle(VulkanExternalMemoryHandleType externalMemoryHandleType) const;
|
||||
#else
|
||||
int
|
||||
getHandle(VulkanExternalMemoryHandleType externalMemoryHandleType) const;
|
||||
#endif
|
||||
bool isDedicated() const;
|
||||
void *map(size_t offset = 0, size_t size = VK_WHOLE_SIZE);
|
||||
void unmap();
|
||||
void bindBuffer(const VulkanBuffer &buffer, uint64_t offset = 0);
|
||||
void bindImage(const VulkanImage &image, uint64_t offset = 0);
|
||||
operator VkDeviceMemory() const;
|
||||
};
|
||||
|
||||
class VulkanSemaphore {
|
||||
friend class VulkanQueue;
|
||||
|
||||
protected:
|
||||
const VulkanDevice &m_device;
|
||||
VkSemaphore m_vkSemaphore;
|
||||
const std::wstring m_name;
|
||||
|
||||
VulkanSemaphore(const VulkanSemaphore &semaphore);
|
||||
|
||||
public:
|
||||
VulkanSemaphore(
|
||||
const VulkanDevice &device,
|
||||
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType =
|
||||
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE,
|
||||
const std::wstring name = L"");
|
||||
virtual ~VulkanSemaphore();
|
||||
#ifdef _WIN32
|
||||
HANDLE getHandle(
|
||||
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType) const;
|
||||
#else
|
||||
int getHandle(
|
||||
VulkanExternalSemaphoreHandleType externalSemaphoreHandleType) const;
|
||||
#endif
|
||||
const std::wstring &getName() const;
|
||||
operator VkSemaphore() const;
|
||||
};
|
||||
|
||||
|
||||
#define VK_FUNC_DECL(name) extern "C" PFN_##name _##name;
|
||||
VK_FUNC_LIST
|
||||
#if defined(_WIN32) || defined(_WIN64)
|
||||
VK_WINDOWS_FUNC_LIST
|
||||
#endif
|
||||
#undef VK_FUNC_DECL
|
||||
|
||||
#endif // _vulkan_wrapper_hpp_
|
||||
@@ -1,463 +0,0 @@
|
||||
//
|
||||
// Copyright (c) 2022 The Khronos Group Inc.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
|
||||
#ifndef _vulkan_wrapper_types_hpp_
|
||||
#define _vulkan_wrapper_types_hpp_
|
||||
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
#define VULKAN_MIN_BUFFER_OFFSET_COPY_ALIGNMENT 4
|
||||
#define VULKAN_REMAINING_MIP_LEVELS VK_REMAINING_MIP_LEVELS
|
||||
#define VULKAN_REMAINING_ARRAY_LAYERS VK_REMAINING_ARRAY_LAYERS
|
||||
|
||||
class VulkanInstance;
|
||||
class VulkanPhysicalDevice;
|
||||
class VulkanMemoryHeap;
|
||||
class VulkanMemoryType;
|
||||
class VulkanQueueFamily;
|
||||
class VulkanDevice;
|
||||
class VulkanQueue;
|
||||
class VulkanDescriptorSetLayoutBinding;
|
||||
class VulkanDescriptorSetLayout;
|
||||
class VulkanPipelineLayout;
|
||||
class VulkanShaderModule;
|
||||
class VulkanPipeline;
|
||||
class VulkanComputePipeline;
|
||||
class VulkanDescriptorPool;
|
||||
class VulkanDescriptorSet;
|
||||
class VulkanCommandPool;
|
||||
class VulkanCommandBuffer;
|
||||
class VulkanBuffer;
|
||||
class VulkanOffset3D;
|
||||
class VulkanExtent3D;
|
||||
class VulkanImage;
|
||||
class VulkanImage2D;
|
||||
class VulkanImageView;
|
||||
class VulkanDeviceMemory;
|
||||
class VulkanSemaphore;
|
||||
|
||||
class VulkanPhysicalDeviceList;
|
||||
class VulkanMemoryHeapList;
|
||||
class VulkanMemoryTypeList;
|
||||
class VulkanQueueFamilyList;
|
||||
class VulkanQueueFamilyToQueueCountMap;
|
||||
class VulkanQueueFamilyToQueueListMap;
|
||||
class VulkanQueueList;
|
||||
class VulkanCommandBufferList;
|
||||
class VulkanDescriptorSetLayoutList;
|
||||
class VulkanBufferList;
|
||||
class VulkanImage2DList;
|
||||
class VulkanImageViewList;
|
||||
class VulkanDeviceMemoryList;
|
||||
class VulkanSemaphoreList;
|
||||
|
||||
enum VulkanQueueFlag
|
||||
{
|
||||
VULKAN_QUEUE_FLAG_GRAPHICS = VK_QUEUE_GRAPHICS_BIT,
|
||||
VULKAN_QUEUE_FLAG_COMPUTE = VK_QUEUE_COMPUTE_BIT,
|
||||
VULKAN_QUEUE_FLAG_TRANSFER = VK_QUEUE_TRANSFER_BIT,
|
||||
VULKAN_QUEUE_FLAG_MASK_ALL = VULKAN_QUEUE_FLAG_GRAPHICS
|
||||
| VULKAN_QUEUE_FLAG_COMPUTE | VULKAN_QUEUE_FLAG_TRANSFER
|
||||
};
|
||||
|
||||
enum VulkanDescriptorType
|
||||
{
|
||||
VULKAN_DESCRIPTOR_TYPE_SAMPLER = VK_DESCRIPTOR_TYPE_SAMPLER,
|
||||
VULKAN_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER =
|
||||
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
||||
VULKAN_DESCRIPTOR_TYPE_SAMPLED_IMAGE = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
|
||||
VULKAN_DESCRIPTOR_TYPE_STORAGE_IMAGE = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
|
||||
VULKAN_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER =
|
||||
VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
|
||||
VULKAN_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER =
|
||||
VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
|
||||
VULKAN_DESCRIPTOR_TYPE_UNIFORM_BUFFER = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
||||
VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
|
||||
VULKAN_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC =
|
||||
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
|
||||
VULKAN_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC =
|
||||
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
|
||||
VULKAN_DESCRIPTOR_TYPE_INPUT_ATTACHMENT =
|
||||
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
|
||||
};
|
||||
|
||||
enum VulkanShaderStage
|
||||
{
|
||||
VULKAN_SHADER_STAGE_VERTEX = VK_SHADER_STAGE_VERTEX_BIT,
|
||||
VULKAN_SHADER_STAGE_FRAGMENT = VK_SHADER_STAGE_FRAGMENT_BIT,
|
||||
VULKAN_SHADER_STAGE_COMPUTE = VK_SHADER_STAGE_COMPUTE_BIT,
|
||||
VULKAN_SHADER_STAGE_ALL_GRAPHICS = VK_SHADER_STAGE_ALL_GRAPHICS,
|
||||
VULKAN_SHADER_STAGE_ALL = VK_SHADER_STAGE_ALL
|
||||
};
|
||||
|
||||
enum VulkanPipelineBindPoint
|
||||
{
|
||||
VULKAN_PIPELINE_BIND_POINT_GRAPHICS = VK_PIPELINE_BIND_POINT_GRAPHICS,
|
||||
VULKAN_PIPELINE_BIND_POINT_COMPUTE = VK_PIPELINE_BIND_POINT_COMPUTE
|
||||
};
|
||||
|
||||
enum VulkanMemoryTypeProperty
|
||||
{
|
||||
VULKAN_MEMORY_TYPE_PROPERTY_NONE = 0,
|
||||
VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL =
|
||||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
|
||||
VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_COHERENT =
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
|
||||
| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||||
VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED =
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
|
||||
| VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
|
||||
VULKAN_MEMORY_TYPE_PROPERTY_HOST_VISIBLE_CACHED_COHERENT =
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT
|
||||
| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||||
VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_COHERENT =
|
||||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
|
||||
| VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
|
||||
| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
||||
VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED =
|
||||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
|
||||
| VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
|
||||
| VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
|
||||
VULKAN_MEMORY_TYPE_PROPERTY_DEVICE_LOCAL_HOST_VISIBLE_CACHED_COHERENT =
|
||||
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
|
||||
| VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT
|
||||
| VK_MEMORY_PROPERTY_HOST_CACHED_BIT
|
||||
| VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
|
||||
};
|
||||
|
||||
enum VulkanMemoryHeapFlag
|
||||
{
|
||||
VULKAN_MEMORY_HEAP_FLAG_NONE = 0,
|
||||
VULKAN_MEMORY_HEAP_FLAG_DEVICE_LOCAL = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT
|
||||
};
|
||||
|
||||
enum VulkanExternalMemoryHandleType
|
||||
{
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_NONE = 0,
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD =
|
||||
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT =
|
||||
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT =
|
||||
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
|
||||
VULKAN_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT =
|
||||
VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
|
||||
| VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR
|
||||
};
|
||||
|
||||
enum VulkanExternalSemaphoreHandleType
|
||||
{
|
||||
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NONE = 0,
|
||||
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD =
|
||||
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
|
||||
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT =
|
||||
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
|
||||
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT =
|
||||
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
|
||||
VULKAN_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_NT_KMT =
|
||||
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
|
||||
| VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR
|
||||
};
|
||||
|
||||
enum VulkanBufferUsage
|
||||
{
|
||||
VULKAN_BUFFER_USAGE_TRANSFER_SRC = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
||||
VULKAN_BUFFER_USAGE_TRANSFER_DST = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
|
||||
VULKAN_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER =
|
||||
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
|
||||
VULKAN_BUFFER_USAGE_STORAGE_TEXEL_BUFFER =
|
||||
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
|
||||
VULKAN_BUFFER_USAGE_UNIFORM_BUFFER = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
||||
VULKAN_BUFFER_USAGE_STORAGE_BUFFER = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
|
||||
VULKAN_BUFFER_USAGE_INDEX_BUFFER = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
|
||||
VULKAN_BUFFER_USAGE_VERTEX_BUFFER = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
||||
VULKAN_BUFFER_USAGE_INDIRECT_BUFFER = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
|
||||
VULKAN_BUFFER_USAGE_STORAGE_BUFFER_TRANSFER_SRC_DST =
|
||||
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT
|
||||
| VK_BUFFER_USAGE_TRANSFER_DST_BIT,
|
||||
VULKAN_BUFFER_USAGE_UNIFORM_BUFFER_TRANSFER_SRC_DST =
|
||||
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT
|
||||
| VK_BUFFER_USAGE_TRANSFER_DST_BIT,
|
||||
};
|
||||
|
||||
enum VulkanSharingMode
|
||||
{
|
||||
VULKAN_SHARING_MODE_EXCLUSIVE = VK_SHARING_MODE_EXCLUSIVE,
|
||||
VULKAN_SHARING_MODE_CONCURRENT = VK_SHARING_MODE_CONCURRENT
|
||||
};
|
||||
|
||||
enum VulkanImageType
|
||||
{
|
||||
VULKAN_IMAGE_TYPE_1D = VK_IMAGE_TYPE_1D,
|
||||
VULKAN_IMAGE_TYPE_2D = VK_IMAGE_TYPE_2D,
|
||||
VULKAN_IMAGE_TYPE_3D = VK_IMAGE_TYPE_3D
|
||||
};
|
||||
|
||||
enum VulkanFormat
|
||||
{
|
||||
VULKAN_FORMAT_UNDEFINED = VK_FORMAT_UNDEFINED,
|
||||
VULKAN_FORMAT_R4G4_UNORM_PACK8 = VK_FORMAT_R4G4_UNORM_PACK8,
|
||||
VULKAN_FORMAT_R4G4B4A4_UNORM_PACK16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16,
|
||||
VULKAN_FORMAT_B4G4R4A4_UNORM_PACK16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16,
|
||||
VULKAN_FORMAT_R5G6B5_UNORM_PACK16 = VK_FORMAT_R5G6B5_UNORM_PACK16,
|
||||
VULKAN_FORMAT_B5G6R5_UNORM_PACK16 = VK_FORMAT_B5G6R5_UNORM_PACK16,
|
||||
VULKAN_FORMAT_R5G5B5A1_UNORM_PACK16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16,
|
||||
VULKAN_FORMAT_B5G5R5A1_UNORM_PACK16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16,
|
||||
VULKAN_FORMAT_A1R5G5B5_UNORM_PACK16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16,
|
||||
VULKAN_FORMAT_R8_UNORM = VK_FORMAT_R8_UNORM,
|
||||
VULKAN_FORMAT_R8_SNORM = VK_FORMAT_R8_SNORM,
|
||||
VULKAN_FORMAT_R8_USCALED = VK_FORMAT_R8_USCALED,
|
||||
VULKAN_FORMAT_R8_SSCALED = VK_FORMAT_R8_SSCALED,
|
||||
VULKAN_FORMAT_R8_UINT = VK_FORMAT_R8_UINT,
|
||||
VULKAN_FORMAT_R8_SINT = VK_FORMAT_R8_SINT,
|
||||
VULKAN_FORMAT_R8_SRGB = VK_FORMAT_R8_SRGB,
|
||||
VULKAN_FORMAT_R8G8_SNORM = VK_FORMAT_R8G8_SNORM,
|
||||
VULKAN_FORMAT_R8G8_UNORM = VK_FORMAT_R8G8_UNORM,
|
||||
VULKAN_FORMAT_R8G8_USCALED = VK_FORMAT_R8G8_USCALED,
|
||||
VULKAN_FORMAT_R8G8_SSCALED = VK_FORMAT_R8G8_SSCALED,
|
||||
VULKAN_FORMAT_R8G8_UINT = VK_FORMAT_R8G8_UINT,
|
||||
VULKAN_FORMAT_R8G8_SINT = VK_FORMAT_R8G8_SINT,
|
||||
VULKAN_FORMAT_R8G8_SRGB = VK_FORMAT_R8G8_SRGB,
|
||||
VULKAN_FORMAT_R8G8B8_UNORM = VK_FORMAT_R8G8B8_UNORM,
|
||||
VULKAN_FORMAT_R8G8B8_SNORM = VK_FORMAT_R8G8B8_SNORM,
|
||||
VULKAN_FORMAT_R8G8B8_USCALED = VK_FORMAT_R8G8B8_USCALED,
|
||||
VULKAN_FORMAT_R8G8B8_SSCALED = VK_FORMAT_R8G8B8_SSCALED,
|
||||
VULKAN_FORMAT_R8G8B8_UINT = VK_FORMAT_R8G8B8_UINT,
|
||||
VULKAN_FORMAT_R8G8B8_SINT = VK_FORMAT_R8G8B8_SINT,
|
||||
VULKAN_FORMAT_R8G8B8_SRGB = VK_FORMAT_R8G8B8_SRGB,
|
||||
VULKAN_FORMAT_B8G8R8_UNORM = VK_FORMAT_B8G8R8_UNORM,
|
||||
VULKAN_FORMAT_B8G8R8_SNORM = VK_FORMAT_B8G8R8_SNORM,
|
||||
VULKAN_FORMAT_B8G8R8_USCALED = VK_FORMAT_B8G8R8_USCALED,
|
||||
VULKAN_FORMAT_B8G8R8_SSCALED = VK_FORMAT_B8G8R8_SSCALED,
|
||||
VULKAN_FORMAT_B8G8R8_UINT = VK_FORMAT_B8G8R8_UINT,
|
||||
VULKAN_FORMAT_B8G8R8_SINT = VK_FORMAT_B8G8R8_SINT,
|
||||
VULKAN_FORMAT_B8G8R8_SRGB = VK_FORMAT_B8G8R8_SRGB,
|
||||
VULKAN_FORMAT_R8G8B8A8_UNORM = VK_FORMAT_R8G8B8A8_UNORM,
|
||||
VULKAN_FORMAT_R8G8B8A8_SNORM = VK_FORMAT_R8G8B8A8_SNORM,
|
||||
VULKAN_FORMAT_R8G8B8A8_USCALED = VK_FORMAT_R8G8B8A8_USCALED,
|
||||
VULKAN_FORMAT_R8G8B8A8_SSCALED = VK_FORMAT_R8G8B8A8_SSCALED,
|
||||
VULKAN_FORMAT_R8G8B8A8_UINT = VK_FORMAT_R8G8B8A8_UINT,
|
||||
VULKAN_FORMAT_R8G8B8A8_SINT = VK_FORMAT_R8G8B8A8_SINT,
|
||||
VULKAN_FORMAT_R8G8B8A8_SRGB = VK_FORMAT_R8G8B8A8_SRGB,
|
||||
VULKAN_FORMAT_B8G8R8A8_UNORM = VK_FORMAT_B8G8R8A8_UNORM,
|
||||
VULKAN_FORMAT_B8G8R8A8_SNORM = VK_FORMAT_B8G8R8A8_SNORM,
|
||||
VULKAN_FORMAT_B8G8R8A8_USCALED = VK_FORMAT_B8G8R8A8_USCALED,
|
||||
VULKAN_FORMAT_B8G8R8A8_SSCALED = VK_FORMAT_B8G8R8A8_SSCALED,
|
||||
VULKAN_FORMAT_B8G8R8A8_UINT = VK_FORMAT_B8G8R8A8_UINT,
|
||||
VULKAN_FORMAT_B8G8R8A8_SINT = VK_FORMAT_B8G8R8A8_SINT,
|
||||
VULKAN_FORMAT_B8G8R8A8_SRGB = VK_FORMAT_B8G8R8A8_SRGB,
|
||||
VULKAN_FORMAT_A8B8G8R8_UNORM_PACK32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32,
|
||||
VULKAN_FORMAT_A8B8G8R8_SNORM_PACK32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32,
|
||||
VULKAN_FORMAT_A8B8G8R8_USCALED_PACK32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32,
|
||||
VULKAN_FORMAT_A8B8G8R8_SSCALED_PACK32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
|
||||
VULKAN_FORMAT_A8B8G8R8_UINT_PACK32 = VK_FORMAT_A8B8G8R8_UINT_PACK32,
|
||||
VULKAN_FORMAT_A8B8G8R8_SINT_PACK32 = VK_FORMAT_A8B8G8R8_SINT_PACK32,
|
||||
VULKAN_FORMAT_A8B8G8R8_SRGB_PACK32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32,
|
||||
VULKAN_FORMAT_A2R10G10B10_UNORM_PACK32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32,
|
||||
VULKAN_FORMAT_A2R10G10B10_SNORM_PACK32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32,
|
||||
VULKAN_FORMAT_A2R10G10B10_USCALED_PACK32 =
|
||||
VK_FORMAT_A2R10G10B10_USCALED_PACK32,
|
||||
VULKAN_FORMAT_A2R10G10B10_SSCALED_PACK32 =
|
||||
VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
|
||||
VULKAN_FORMAT_A2R10G10B10_UINT_PACK32 = VK_FORMAT_A2R10G10B10_UINT_PACK32,
|
||||
VULKAN_FORMAT_A2R10G10B10_SINT_PACK32 = VK_FORMAT_A2R10G10B10_SINT_PACK32,
|
||||
VULKAN_FORMAT_A2B10G10R10_UNORM_PACK32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32,
|
||||
VULKAN_FORMAT_A2B10G10R10_SNORM_PACK32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32,
|
||||
VULKAN_FORMAT_A2B10G10R10_USCALED_PACK32 =
|
||||
VK_FORMAT_A2B10G10R10_USCALED_PACK32,
|
||||
VULKAN_FORMAT_A2B10G10R10_SSCALED_PACK32 =
|
||||
VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
|
||||
VULKAN_FORMAT_A2B10G10R10_UINT_PACK32 = VK_FORMAT_A2B10G10R10_UINT_PACK32,
|
||||
VULKAN_FORMAT_A2B10G10R10_SINT_PACK32 = VK_FORMAT_A2B10G10R10_SINT_PACK32,
|
||||
VULKAN_FORMAT_R16_UNORM = VK_FORMAT_R16_UNORM,
|
||||
VULKAN_FORMAT_R16_SNORM = VK_FORMAT_R16_SNORM,
|
||||
VULKAN_FORMAT_R16_USCALED = VK_FORMAT_R16_USCALED,
|
||||
VULKAN_FORMAT_R16_SSCALED = VK_FORMAT_R16_SSCALED,
|
||||
VULKAN_FORMAT_R16_UINT = VK_FORMAT_R16_UINT,
|
||||
VULKAN_FORMAT_R16_SINT = VK_FORMAT_R16_SINT,
|
||||
VULKAN_FORMAT_R16_SFLOAT = VK_FORMAT_R16_SFLOAT,
|
||||
VULKAN_FORMAT_R16G16_UNORM = VK_FORMAT_R16G16_UNORM,
|
||||
VULKAN_FORMAT_R16G16_SNORM = VK_FORMAT_R16G16_SNORM,
|
||||
VULKAN_FORMAT_R16G16_USCALED = VK_FORMAT_R16G16_USCALED,
|
||||
VULKAN_FORMAT_R16G16_SSCALED = VK_FORMAT_R16G16_SSCALED,
|
||||
VULKAN_FORMAT_R16G16_UINT = VK_FORMAT_R16G16_UINT,
|
||||
VULKAN_FORMAT_R16G16_SINT = VK_FORMAT_R16G16_SINT,
|
||||
VULKAN_FORMAT_R16G16_SFLOAT = VK_FORMAT_R16G16_SFLOAT,
|
||||
VULKAN_FORMAT_R16G16B16_UNORM = VK_FORMAT_R16G16B16_UNORM,
|
||||
VULKAN_FORMAT_R16G16B16_SNORM = VK_FORMAT_R16G16B16_SNORM,
|
||||
VULKAN_FORMAT_R16G16B16_USCALED = VK_FORMAT_R16G16B16_USCALED,
|
||||
VULKAN_FORMAT_R16G16B16_SSCALED = VK_FORMAT_R16G16B16_SSCALED,
|
||||
VULKAN_FORMAT_R16G16B16_UINT = VK_FORMAT_R16G16B16_UINT,
|
||||
VULKAN_FORMAT_R16G16B16_SINT = VK_FORMAT_R16G16B16_SINT,
|
||||
VULKAN_FORMAT_R16G16B16_SFLOAT = VK_FORMAT_R16G16B16_SFLOAT,
|
||||
VULKAN_FORMAT_R16G16B16A16_UNORM = VK_FORMAT_R16G16B16A16_UNORM,
|
||||
VULKAN_FORMAT_R16G16B16A16_SNORM = VK_FORMAT_R16G16B16A16_SNORM,
|
||||
VULKAN_FORMAT_R16G16B16A16_USCALED = VK_FORMAT_R16G16B16A16_USCALED,
|
||||
VULKAN_FORMAT_R16G16B16A16_SSCALED = VK_FORMAT_R16G16B16A16_SSCALED,
|
||||
VULKAN_FORMAT_R16G16B16A16_UINT = VK_FORMAT_R16G16B16A16_UINT,
|
||||
VULKAN_FORMAT_R16G16B16A16_SINT = VK_FORMAT_R16G16B16A16_SINT,
|
||||
VULKAN_FORMAT_R16G16B16A16_SFLOAT = VK_FORMAT_R16G16B16A16_SFLOAT,
|
||||
VULKAN_FORMAT_R32_UINT = VK_FORMAT_R32_UINT,
|
||||
VULKAN_FORMAT_R32_SINT = VK_FORMAT_R32_SINT,
|
||||
VULKAN_FORMAT_R32_SFLOAT = VK_FORMAT_R32_SFLOAT,
|
||||
VULKAN_FORMAT_R32G32_UINT = VK_FORMAT_R32G32_UINT,
|
||||
VULKAN_FORMAT_R32G32_SINT = VK_FORMAT_R32G32_SINT,
|
||||
VULKAN_FORMAT_R32G32_SFLOAT = VK_FORMAT_R32G32_SFLOAT,
|
||||
VULKAN_FORMAT_R32G32B32_UINT = VK_FORMAT_R32G32B32_UINT,
|
||||
VULKAN_FORMAT_R32G32B32_SINT = VK_FORMAT_R32G32B32_SINT,
|
||||
VULKAN_FORMAT_R32G32B32_SFLOAT = VK_FORMAT_R32G32B32_SFLOAT,
|
||||
VULKAN_FORMAT_R32G32B32A32_UINT = VK_FORMAT_R32G32B32A32_UINT,
|
||||
VULKAN_FORMAT_R32G32B32A32_SINT = VK_FORMAT_R32G32B32A32_SINT,
|
||||
VULKAN_FORMAT_R32G32B32A32_SFLOAT = VK_FORMAT_R32G32B32A32_SFLOAT,
|
||||
VULKAN_FORMAT_R64_UINT = VK_FORMAT_R64_UINT,
|
||||
VULKAN_FORMAT_R64_SINT = VK_FORMAT_R64_SINT,
|
||||
VULKAN_FORMAT_R64_SFLOAT = VK_FORMAT_R64_SFLOAT,
|
||||
VULKAN_FORMAT_R64G64_UINT = VK_FORMAT_R64G64_UINT,
|
||||
VULKAN_FORMAT_R64G64_SINT = VK_FORMAT_R64G64_SINT,
|
||||
VULKAN_FORMAT_R64G64_SFLOAT = VK_FORMAT_R64G64_SFLOAT,
|
||||
VULKAN_FORMAT_R64G64B64_UINT = VK_FORMAT_R64G64B64_UINT,
|
||||
VULKAN_FORMAT_R64G64B64_SINT = VK_FORMAT_R64G64B64_SINT,
|
||||
VULKAN_FORMAT_R64G64B64_SFLOAT = VK_FORMAT_R64G64B64_SFLOAT,
|
||||
VULKAN_FORMAT_R64G64B64A64_UINT = VK_FORMAT_R64G64B64A64_UINT,
|
||||
VULKAN_FORMAT_R64G64B64A64_SINT = VK_FORMAT_R64G64B64A64_SINT,
|
||||
VULKAN_FORMAT_R64G64B64A64_SFLOAT = VK_FORMAT_R64G64B64A64_SFLOAT,
|
||||
VULKAN_FORMAT_B10G11R11_UFLOAT_PACK32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32,
|
||||
VULKAN_FORMAT_E5B9G9R9_UFLOAT_PACK32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
|
||||
VULKAN_FORMAT_D16_UNORM = VK_FORMAT_D16_UNORM,
|
||||
VULKAN_FORMAT_X8_D24_UNORM_PACK32 = VK_FORMAT_X8_D24_UNORM_PACK32,
|
||||
VULKAN_FORMAT_D32_SFLOAT = VK_FORMAT_D32_SFLOAT,
|
||||
VULKAN_FORMAT_S8_UINT = VK_FORMAT_S8_UINT,
|
||||
VULKAN_FORMAT_D16_UNORM_S8_UINT = VK_FORMAT_D16_UNORM_S8_UINT,
|
||||
VULKAN_FORMAT_D24_UNORM_S8_UINT = VK_FORMAT_D24_UNORM_S8_UINT,
|
||||
VULKAN_FORMAT_D32_SFLOAT_S8_UINT = VK_FORMAT_D32_SFLOAT_S8_UINT,
|
||||
VULKAN_FORMAT_BC1_RGB_UNORM_BLOCK = VK_FORMAT_BC1_RGB_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_BC1_RGB_SRGB_BLOCK = VK_FORMAT_BC1_RGB_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_BC1_RGBA_UNORM_BLOCK = VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_BC1_RGBA_SRGB_BLOCK = VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_BC2_UNORM_BLOCK = VK_FORMAT_BC2_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_BC2_SRGB_BLOCK = VK_FORMAT_BC2_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_BC3_UNORM_BLOCK = VK_FORMAT_BC3_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_BC3_SRGB_BLOCK = VK_FORMAT_BC3_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_BC4_UNORM_BLOCK = VK_FORMAT_BC4_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_BC4_SNORM_BLOCK = VK_FORMAT_BC4_SNORM_BLOCK,
|
||||
VULKAN_FORMAT_BC5_UNORM_BLOCK = VK_FORMAT_BC5_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_BC5_SNORM_BLOCK = VK_FORMAT_BC5_SNORM_BLOCK,
|
||||
VULKAN_FORMAT_BC6H_UFLOAT_BLOCK = VK_FORMAT_BC6H_UFLOAT_BLOCK,
|
||||
VULKAN_FORMAT_BC6H_SFLOAT_BLOCK = VK_FORMAT_BC6H_SFLOAT_BLOCK,
|
||||
VULKAN_FORMAT_BC7_UNORM_BLOCK = VK_FORMAT_BC7_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_BC7_SRGB_BLOCK = VK_FORMAT_BC7_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK =
|
||||
VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK =
|
||||
VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_EAC_R11_UNORM_BLOCK = VK_FORMAT_EAC_R11_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_EAC_R11_SNORM_BLOCK = VK_FORMAT_EAC_R11_SNORM_BLOCK,
|
||||
VULKAN_FORMAT_EAC_R11G11_UNORM_BLOCK = VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_EAC_R11G11_SNORM_BLOCK = VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_4x4_UNORM_BLOCK = VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_4x4_SRGB_BLOCK = VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_5x4_UNORM_BLOCK = VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_5x4_SRGB_BLOCK = VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_5x5_UNORM_BLOCK = VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_5x5_SRGB_BLOCK = VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_6x5_UNORM_BLOCK = VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_6x5_SRGB_BLOCK = VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_6x6_UNORM_BLOCK = VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_6x6_SRGB_BLOCK = VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_8x5_UNORM_BLOCK = VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_8x5_SRGB_BLOCK = VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_8x6_UNORM_BLOCK = VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_8x6_SRGB_BLOCK = VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_8x8_UNORM_BLOCK = VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_8x8_SRGB_BLOCK = VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_10x5_UNORM_BLOCK = VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_10x5_SRGB_BLOCK = VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_10x6_UNORM_BLOCK = VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_10x6_SRGB_BLOCK = VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_10x8_UNORM_BLOCK = VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_10x8_SRGB_BLOCK = VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_10x10_UNORM_BLOCK = VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_10x10_SRGB_BLOCK = VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_12x10_UNORM_BLOCK = VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_12x10_SRGB_BLOCK = VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_12x12_UNORM_BLOCK = VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
|
||||
VULKAN_FORMAT_ASTC_12x12_SRGB_BLOCK = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
|
||||
};
|
||||
|
||||
enum VulkanImageLayout
|
||||
{
|
||||
VULKAN_IMAGE_LAYOUT_UNDEFINED = VK_IMAGE_LAYOUT_UNDEFINED,
|
||||
VULKAN_IMAGE_LAYOUT_GENERAL = VK_IMAGE_LAYOUT_GENERAL,
|
||||
VULKAN_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL =
|
||||
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
||||
VULKAN_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL =
|
||||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||||
};
|
||||
|
||||
enum VulkanImageUsage
|
||||
{
|
||||
VULKAN_IMAGE_USAGE_TRANSFER_SRC = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
|
||||
VULKAN_IMAGE_USAGE_TRANSFER_DST = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
|
||||
VULKAN_IMAGE_USAGE_SAMPLED = VK_IMAGE_USAGE_SAMPLED_BIT,
|
||||
VULKAN_IMAGE_USAGE_STORAGE = VK_IMAGE_USAGE_STORAGE_BIT,
|
||||
VULKAN_IMAGE_USAGE_COLOR_ATTACHMENT = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
|
||||
VULKAN_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT =
|
||||
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
|
||||
VULKAN_IMAGE_USAGE_TRANSIENT_ATTACHMENT =
|
||||
VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
|
||||
VULKAN_IMAGE_USAGE_INPUT_ATTACHMENT = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
|
||||
VULKAN_IMAGE_USAGE_TRANSFER_SRC_DST =
|
||||
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
|
||||
VULKAN_IMAGE_USAGE_STORAGE_TRANSFER_SRC_DST = VULKAN_IMAGE_USAGE_STORAGE
|
||||
| VULKAN_IMAGE_USAGE_TRANSFER_SRC | VULKAN_IMAGE_USAGE_TRANSFER_DST,
|
||||
VULKAN_IMAGE_USAGE_SAMPLED_STORAGE_TRANSFER_SRC_DST =
|
||||
VK_IMAGE_USAGE_SAMPLED_BIT | VULKAN_IMAGE_USAGE_STORAGE
|
||||
| VULKAN_IMAGE_USAGE_TRANSFER_SRC | VULKAN_IMAGE_USAGE_TRANSFER_DST
|
||||
};
|
||||
|
||||
enum VulkanImageTiling
|
||||
{
|
||||
VULKAN_IMAGE_TILING_OPTIMAL = VK_IMAGE_TILING_OPTIMAL,
|
||||
VULKAN_IMAGE_TILING_LINEAR = VK_IMAGE_TILING_LINEAR
|
||||
};
|
||||
|
||||
enum VulkanImageCreateFlag
|
||||
{
|
||||
VULKAN_IMAGE_CREATE_FLAG_NONE = 0,
|
||||
VULKAN_IMAGE_CREATE_FLAG_MUTABLE_FORMAT =
|
||||
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
|
||||
VULKAN_IMAGE_CREATE_FLAG_CUBE_COMPATIBLE =
|
||||
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
|
||||
VULKAN_IMAGE_CREATE_FLAG_CUBE_COMPATIBLE_MUTABLE_FORMAT =
|
||||
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
|
||||
};
|
||||
|
||||
enum VulkanImageViewType
|
||||
{
|
||||
VULKAN_IMAGE_VIEW_TYPE_1D = VK_IMAGE_VIEW_TYPE_1D,
|
||||
VULKAN_IMAGE_VIEW_TYPE_2D = VK_IMAGE_VIEW_TYPE_2D,
|
||||
VULKAN_IMAGE_VIEW_TYPE_3D = VK_IMAGE_VIEW_TYPE_3D,
|
||||
VULKAN_IMAGE_VIEW_TYPE_CUBE = VK_IMAGE_VIEW_TYPE_CUBE,
|
||||
VULKAN_IMAGE_VIEW_TYPE_1D_ARRAY = VK_IMAGE_VIEW_TYPE_1D_ARRAY,
|
||||
VULKAN_IMAGE_VIEW_TYPE_2D_ARRAY = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
|
||||
VULKAN_IMAGE_VIEW_TYPE_CUBE_ARRAY = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
|
||||
};
|
||||
|
||||
#endif // _vulkan_wrapper_types_hpp_
|
||||
Reference in New Issue
Block a user