Bug 13632 Header 84 Assorted questions and comments on vulkan.h
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index 756e1b3..c92c080 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -41,7 +41,7 @@
void set_solid_pattern(const std::vector<uint8_t> &solid);
- VkGpuSize buffer_size() const;
+ VkDeviceSize buffer_size() const;
bool fill(Buffer &buf) const { return walk(FILL, buf); }
bool fill(Image &img) const { return walk(FILL, img); }
bool check(Buffer &buf) const { return walk(CHECK, buf); }
@@ -87,7 +87,7 @@
: info_(info), regions_(), pattern_(HASH)
{
// create a region for every mip level in array slice 0
- VkGpuSize offset = 0;
+ VkDeviceSize offset = 0;
for (uint32_t lv = 0; lv < info_.mipLevels; lv++) {
VkBufferImageCopy region = {};
@@ -97,14 +97,14 @@
region.imageExtent = Image::extent(info_.extent, lv);
if (info_.usage & VK_IMAGE_USAGE_DEPTH_STENCIL_BIT) {
- if (info_.format != VK_FMT_S8_UINT) {
+ if (info_.format != VK_FORMAT_S8_UINT) {
region.imageSubresource.aspect = VK_IMAGE_ASPECT_DEPTH;
regions_.push_back(region);
}
- if (info_.format == VK_FMT_D16_UNORM_S8_UINT ||
- info_.format == VK_FMT_D32_SFLOAT_S8_UINT ||
- info_.format == VK_FMT_S8_UINT) {
+ if (info_.format == VK_FORMAT_D16_UNORM_S8_UINT ||
+ info_.format == VK_FORMAT_D32_SFLOAT_S8_UINT ||
+ info_.format == VK_FORMAT_S8_UINT) {
region.imageSubresource.aspect = VK_IMAGE_ASPECT_STENCIL;
regions_.push_back(region);
}
@@ -119,7 +119,7 @@
// arraySize should be limited in our tests. If this proves to be an
// issue, we can store only the regions for array slice 0 and be smart.
if (info_.arraySize > 1) {
- const VkGpuSize slice_pitch = offset;
+ const VkDeviceSize slice_pitch = offset;
const uint32_t slice_region_count = regions_.size();
regions_.reserve(slice_region_count * info_.arraySize);
@@ -139,7 +139,7 @@
ImageChecker::ImageChecker(const VkImageCreateInfo &info, const std::vector<VkImageSubresourceRange> &ranges)
: info_(info), regions_(), pattern_(HASH)
{
- VkGpuSize offset = 0;
+ VkDeviceSize offset = 0;
for (std::vector<VkImageSubresourceRange>::const_iterator it = ranges.begin();
it != ranges.end(); it++) {
for (uint32_t lv = 0; lv < it->mipLevels; lv++) {
@@ -182,9 +182,9 @@
return layout;
}
-VkGpuSize ImageChecker::buffer_size() const
+VkDeviceSize ImageChecker::buffer_size() const
{
- VkGpuSize size = 0;
+ VkDeviceSize size = 0;
for (std::vector<VkBufferImageCopy>::const_iterator it = regions_.begin();
it != regions_.end(); it++) {
@@ -301,182 +301,182 @@
static const struct format_info {
size_t size;
uint32_t channel_count;
- } format_table[VK_NUM_FMT] = {
- [VK_FMT_UNDEFINED] = { 0, 0 },
- [VK_FMT_R4G4_UNORM] = { 1, 2 },
- [VK_FMT_R4G4_USCALED] = { 1, 2 },
- [VK_FMT_R4G4B4A4_UNORM] = { 2, 4 },
- [VK_FMT_R4G4B4A4_USCALED] = { 2, 4 },
- [VK_FMT_R5G6B5_UNORM] = { 2, 3 },
- [VK_FMT_R5G6B5_USCALED] = { 2, 3 },
- [VK_FMT_R5G5B5A1_UNORM] = { 2, 4 },
- [VK_FMT_R5G5B5A1_USCALED] = { 2, 4 },
- [VK_FMT_R8_UNORM] = { 1, 1 },
- [VK_FMT_R8_SNORM] = { 1, 1 },
- [VK_FMT_R8_USCALED] = { 1, 1 },
- [VK_FMT_R8_SSCALED] = { 1, 1 },
- [VK_FMT_R8_UINT] = { 1, 1 },
- [VK_FMT_R8_SINT] = { 1, 1 },
- [VK_FMT_R8_SRGB] = { 1, 1 },
- [VK_FMT_R8G8_UNORM] = { 2, 2 },
- [VK_FMT_R8G8_SNORM] = { 2, 2 },
- [VK_FMT_R8G8_USCALED] = { 2, 2 },
- [VK_FMT_R8G8_SSCALED] = { 2, 2 },
- [VK_FMT_R8G8_UINT] = { 2, 2 },
- [VK_FMT_R8G8_SINT] = { 2, 2 },
- [VK_FMT_R8G8_SRGB] = { 2, 2 },
- [VK_FMT_R8G8B8_UNORM] = { 3, 3 },
- [VK_FMT_R8G8B8_SNORM] = { 3, 3 },
- [VK_FMT_R8G8B8_USCALED] = { 3, 3 },
- [VK_FMT_R8G8B8_SSCALED] = { 3, 3 },
- [VK_FMT_R8G8B8_UINT] = { 3, 3 },
- [VK_FMT_R8G8B8_SINT] = { 3, 3 },
- [VK_FMT_R8G8B8_SRGB] = { 3, 3 },
- [VK_FMT_R8G8B8A8_UNORM] = { 4, 4 },
- [VK_FMT_R8G8B8A8_SNORM] = { 4, 4 },
- [VK_FMT_R8G8B8A8_USCALED] = { 4, 4 },
- [VK_FMT_R8G8B8A8_SSCALED] = { 4, 4 },
- [VK_FMT_R8G8B8A8_UINT] = { 4, 4 },
- [VK_FMT_R8G8B8A8_SINT] = { 4, 4 },
- [VK_FMT_R8G8B8A8_SRGB] = { 4, 4 },
- [VK_FMT_R10G10B10A2_UNORM] = { 4, 4 },
- [VK_FMT_R10G10B10A2_SNORM] = { 4, 4 },
- [VK_FMT_R10G10B10A2_USCALED] = { 4, 4 },
- [VK_FMT_R10G10B10A2_SSCALED] = { 4, 4 },
- [VK_FMT_R10G10B10A2_UINT] = { 4, 4 },
- [VK_FMT_R10G10B10A2_SINT] = { 4, 4 },
- [VK_FMT_R16_UNORM] = { 2, 1 },
- [VK_FMT_R16_SNORM] = { 2, 1 },
- [VK_FMT_R16_USCALED] = { 2, 1 },
- [VK_FMT_R16_SSCALED] = { 2, 1 },
- [VK_FMT_R16_UINT] = { 2, 1 },
- [VK_FMT_R16_SINT] = { 2, 1 },
- [VK_FMT_R16_SFLOAT] = { 2, 1 },
- [VK_FMT_R16G16_UNORM] = { 4, 2 },
- [VK_FMT_R16G16_SNORM] = { 4, 2 },
- [VK_FMT_R16G16_USCALED] = { 4, 2 },
- [VK_FMT_R16G16_SSCALED] = { 4, 2 },
- [VK_FMT_R16G16_UINT] = { 4, 2 },
- [VK_FMT_R16G16_SINT] = { 4, 2 },
- [VK_FMT_R16G16_SFLOAT] = { 4, 2 },
- [VK_FMT_R16G16B16_UNORM] = { 6, 3 },
- [VK_FMT_R16G16B16_SNORM] = { 6, 3 },
- [VK_FMT_R16G16B16_USCALED] = { 6, 3 },
- [VK_FMT_R16G16B16_SSCALED] = { 6, 3 },
- [VK_FMT_R16G16B16_UINT] = { 6, 3 },
- [VK_FMT_R16G16B16_SINT] = { 6, 3 },
- [VK_FMT_R16G16B16_SFLOAT] = { 6, 3 },
- [VK_FMT_R16G16B16A16_UNORM] = { 8, 4 },
- [VK_FMT_R16G16B16A16_SNORM] = { 8, 4 },
- [VK_FMT_R16G16B16A16_USCALED] = { 8, 4 },
- [VK_FMT_R16G16B16A16_SSCALED] = { 8, 4 },
- [VK_FMT_R16G16B16A16_UINT] = { 8, 4 },
- [VK_FMT_R16G16B16A16_SINT] = { 8, 4 },
- [VK_FMT_R16G16B16A16_SFLOAT] = { 8, 4 },
- [VK_FMT_R32_UINT] = { 4, 1 },
- [VK_FMT_R32_SINT] = { 4, 1 },
- [VK_FMT_R32_SFLOAT] = { 4, 1 },
- [VK_FMT_R32G32_UINT] = { 8, 2 },
- [VK_FMT_R32G32_SINT] = { 8, 2 },
- [VK_FMT_R32G32_SFLOAT] = { 8, 2 },
- [VK_FMT_R32G32B32_UINT] = { 12, 3 },
- [VK_FMT_R32G32B32_SINT] = { 12, 3 },
- [VK_FMT_R32G32B32_SFLOAT] = { 12, 3 },
- [VK_FMT_R32G32B32A32_UINT] = { 16, 4 },
- [VK_FMT_R32G32B32A32_SINT] = { 16, 4 },
- [VK_FMT_R32G32B32A32_SFLOAT] = { 16, 4 },
- [VK_FMT_R64_SFLOAT] = { 8, 1 },
- [VK_FMT_R64G64_SFLOAT] = { 16, 2 },
- [VK_FMT_R64G64B64_SFLOAT] = { 24, 3 },
- [VK_FMT_R64G64B64A64_SFLOAT] = { 32, 4 },
- [VK_FMT_R11G11B10_UFLOAT] = { 4, 3 },
- [VK_FMT_R9G9B9E5_UFLOAT] = { 4, 3 },
- [VK_FMT_D16_UNORM] = { 2, 1 },
- [VK_FMT_D24_UNORM] = { 3, 1 },
- [VK_FMT_D32_SFLOAT] = { 4, 1 },
- [VK_FMT_S8_UINT] = { 1, 1 },
- [VK_FMT_D16_UNORM_S8_UINT] = { 3, 2 },
- [VK_FMT_D24_UNORM_S8_UINT] = { 4, 2 },
- [VK_FMT_D32_SFLOAT_S8_UINT] = { 4, 2 },
- [VK_FMT_BC1_RGB_UNORM] = { 8, 4 },
- [VK_FMT_BC1_RGB_SRGB] = { 8, 4 },
- [VK_FMT_BC1_RGBA_UNORM] = { 8, 4 },
- [VK_FMT_BC1_RGBA_SRGB] = { 8, 4 },
- [VK_FMT_BC2_UNORM] = { 16, 4 },
- [VK_FMT_BC2_SRGB] = { 16, 4 },
- [VK_FMT_BC3_UNORM] = { 16, 4 },
- [VK_FMT_BC3_SRGB] = { 16, 4 },
- [VK_FMT_BC4_UNORM] = { 8, 4 },
- [VK_FMT_BC4_SNORM] = { 8, 4 },
- [VK_FMT_BC5_UNORM] = { 16, 4 },
- [VK_FMT_BC5_SNORM] = { 16, 4 },
- [VK_FMT_BC6H_UFLOAT] = { 16, 4 },
- [VK_FMT_BC6H_SFLOAT] = { 16, 4 },
- [VK_FMT_BC7_UNORM] = { 16, 4 },
- [VK_FMT_BC7_SRGB] = { 16, 4 },
+ } format_table[VK_NUM_FORMAT] = {
+ [VK_FORMAT_UNDEFINED] = { 0, 0 },
+ [VK_FORMAT_R4G4_UNORM] = { 1, 2 },
+ [VK_FORMAT_R4G4_USCALED] = { 1, 2 },
+ [VK_FORMAT_R4G4B4A4_UNORM] = { 2, 4 },
+ [VK_FORMAT_R4G4B4A4_USCALED] = { 2, 4 },
+ [VK_FORMAT_R5G6B5_UNORM] = { 2, 3 },
+ [VK_FORMAT_R5G6B5_USCALED] = { 2, 3 },
+ [VK_FORMAT_R5G5B5A1_UNORM] = { 2, 4 },
+ [VK_FORMAT_R5G5B5A1_USCALED] = { 2, 4 },
+ [VK_FORMAT_R8_UNORM] = { 1, 1 },
+ [VK_FORMAT_R8_SNORM] = { 1, 1 },
+ [VK_FORMAT_R8_USCALED] = { 1, 1 },
+ [VK_FORMAT_R8_SSCALED] = { 1, 1 },
+ [VK_FORMAT_R8_UINT] = { 1, 1 },
+ [VK_FORMAT_R8_SINT] = { 1, 1 },
+ [VK_FORMAT_R8_SRGB] = { 1, 1 },
+ [VK_FORMAT_R8G8_UNORM] = { 2, 2 },
+ [VK_FORMAT_R8G8_SNORM] = { 2, 2 },
+ [VK_FORMAT_R8G8_USCALED] = { 2, 2 },
+ [VK_FORMAT_R8G8_SSCALED] = { 2, 2 },
+ [VK_FORMAT_R8G8_UINT] = { 2, 2 },
+ [VK_FORMAT_R8G8_SINT] = { 2, 2 },
+ [VK_FORMAT_R8G8_SRGB] = { 2, 2 },
+ [VK_FORMAT_R8G8B8_UNORM] = { 3, 3 },
+ [VK_FORMAT_R8G8B8_SNORM] = { 3, 3 },
+ [VK_FORMAT_R8G8B8_USCALED] = { 3, 3 },
+ [VK_FORMAT_R8G8B8_SSCALED] = { 3, 3 },
+ [VK_FORMAT_R8G8B8_UINT] = { 3, 3 },
+ [VK_FORMAT_R8G8B8_SINT] = { 3, 3 },
+ [VK_FORMAT_R8G8B8_SRGB] = { 3, 3 },
+ [VK_FORMAT_R8G8B8A8_UNORM] = { 4, 4 },
+ [VK_FORMAT_R8G8B8A8_SNORM] = { 4, 4 },
+ [VK_FORMAT_R8G8B8A8_USCALED] = { 4, 4 },
+ [VK_FORMAT_R8G8B8A8_SSCALED] = { 4, 4 },
+ [VK_FORMAT_R8G8B8A8_UINT] = { 4, 4 },
+ [VK_FORMAT_R8G8B8A8_SINT] = { 4, 4 },
+ [VK_FORMAT_R8G8B8A8_SRGB] = { 4, 4 },
+ [VK_FORMAT_R10G10B10A2_UNORM] = { 4, 4 },
+ [VK_FORMAT_R10G10B10A2_SNORM] = { 4, 4 },
+ [VK_FORMAT_R10G10B10A2_USCALED] = { 4, 4 },
+ [VK_FORMAT_R10G10B10A2_SSCALED] = { 4, 4 },
+ [VK_FORMAT_R10G10B10A2_UINT] = { 4, 4 },
+ [VK_FORMAT_R10G10B10A2_SINT] = { 4, 4 },
+ [VK_FORMAT_R16_UNORM] = { 2, 1 },
+ [VK_FORMAT_R16_SNORM] = { 2, 1 },
+ [VK_FORMAT_R16_USCALED] = { 2, 1 },
+ [VK_FORMAT_R16_SSCALED] = { 2, 1 },
+ [VK_FORMAT_R16_UINT] = { 2, 1 },
+ [VK_FORMAT_R16_SINT] = { 2, 1 },
+ [VK_FORMAT_R16_SFLOAT] = { 2, 1 },
+ [VK_FORMAT_R16G16_UNORM] = { 4, 2 },
+ [VK_FORMAT_R16G16_SNORM] = { 4, 2 },
+ [VK_FORMAT_R16G16_USCALED] = { 4, 2 },
+ [VK_FORMAT_R16G16_SSCALED] = { 4, 2 },
+ [VK_FORMAT_R16G16_UINT] = { 4, 2 },
+ [VK_FORMAT_R16G16_SINT] = { 4, 2 },
+ [VK_FORMAT_R16G16_SFLOAT] = { 4, 2 },
+ [VK_FORMAT_R16G16B16_UNORM] = { 6, 3 },
+ [VK_FORMAT_R16G16B16_SNORM] = { 6, 3 },
+ [VK_FORMAT_R16G16B16_USCALED] = { 6, 3 },
+ [VK_FORMAT_R16G16B16_SSCALED] = { 6, 3 },
+ [VK_FORMAT_R16G16B16_UINT] = { 6, 3 },
+ [VK_FORMAT_R16G16B16_SINT] = { 6, 3 },
+ [VK_FORMAT_R16G16B16_SFLOAT] = { 6, 3 },
+ [VK_FORMAT_R16G16B16A16_UNORM] = { 8, 4 },
+ [VK_FORMAT_R16G16B16A16_SNORM] = { 8, 4 },
+ [VK_FORMAT_R16G16B16A16_USCALED] = { 8, 4 },
+ [VK_FORMAT_R16G16B16A16_SSCALED] = { 8, 4 },
+ [VK_FORMAT_R16G16B16A16_UINT] = { 8, 4 },
+ [VK_FORMAT_R16G16B16A16_SINT] = { 8, 4 },
+ [VK_FORMAT_R16G16B16A16_SFLOAT] = { 8, 4 },
+ [VK_FORMAT_R32_UINT] = { 4, 1 },
+ [VK_FORMAT_R32_SINT] = { 4, 1 },
+ [VK_FORMAT_R32_SFLOAT] = { 4, 1 },
+ [VK_FORMAT_R32G32_UINT] = { 8, 2 },
+ [VK_FORMAT_R32G32_SINT] = { 8, 2 },
+ [VK_FORMAT_R32G32_SFLOAT] = { 8, 2 },
+ [VK_FORMAT_R32G32B32_UINT] = { 12, 3 },
+ [VK_FORMAT_R32G32B32_SINT] = { 12, 3 },
+ [VK_FORMAT_R32G32B32_SFLOAT] = { 12, 3 },
+ [VK_FORMAT_R32G32B32A32_UINT] = { 16, 4 },
+ [VK_FORMAT_R32G32B32A32_SINT] = { 16, 4 },
+ [VK_FORMAT_R32G32B32A32_SFLOAT] = { 16, 4 },
+ [VK_FORMAT_R64_SFLOAT] = { 8, 1 },
+ [VK_FORMAT_R64G64_SFLOAT] = { 16, 2 },
+ [VK_FORMAT_R64G64B64_SFLOAT] = { 24, 3 },
+ [VK_FORMAT_R64G64B64A64_SFLOAT] = { 32, 4 },
+ [VK_FORMAT_R11G11B10_UFLOAT] = { 4, 3 },
+ [VK_FORMAT_R9G9B9E5_UFLOAT] = { 4, 3 },
+ [VK_FORMAT_D16_UNORM] = { 2, 1 },
+ [VK_FORMAT_D24_UNORM] = { 3, 1 },
+ [VK_FORMAT_D32_SFLOAT] = { 4, 1 },
+ [VK_FORMAT_S8_UINT] = { 1, 1 },
+ [VK_FORMAT_D16_UNORM_S8_UINT] = { 3, 2 },
+ [VK_FORMAT_D24_UNORM_S8_UINT] = { 4, 2 },
+ [VK_FORMAT_D32_SFLOAT_S8_UINT] = { 4, 2 },
+ [VK_FORMAT_BC1_RGB_UNORM] = { 8, 4 },
+ [VK_FORMAT_BC1_RGB_SRGB] = { 8, 4 },
+ [VK_FORMAT_BC1_RGBA_UNORM] = { 8, 4 },
+ [VK_FORMAT_BC1_RGBA_SRGB] = { 8, 4 },
+ [VK_FORMAT_BC2_UNORM] = { 16, 4 },
+ [VK_FORMAT_BC2_SRGB] = { 16, 4 },
+ [VK_FORMAT_BC3_UNORM] = { 16, 4 },
+ [VK_FORMAT_BC3_SRGB] = { 16, 4 },
+ [VK_FORMAT_BC4_UNORM] = { 8, 4 },
+ [VK_FORMAT_BC4_SNORM] = { 8, 4 },
+ [VK_FORMAT_BC5_UNORM] = { 16, 4 },
+ [VK_FORMAT_BC5_SNORM] = { 16, 4 },
+ [VK_FORMAT_BC6H_UFLOAT] = { 16, 4 },
+ [VK_FORMAT_BC6H_SFLOAT] = { 16, 4 },
+ [VK_FORMAT_BC7_UNORM] = { 16, 4 },
+ [VK_FORMAT_BC7_SRGB] = { 16, 4 },
// TODO: Initialize remaining compressed formats.
- [VK_FMT_ETC2_R8G8B8_UNORM] = { 0, 0 },
- [VK_FMT_ETC2_R8G8B8_SRGB] = { 0, 0 },
- [VK_FMT_ETC2_R8G8B8A1_UNORM] = { 0, 0 },
- [VK_FMT_ETC2_R8G8B8A1_SRGB] = { 0, 0 },
- [VK_FMT_ETC2_R8G8B8A8_UNORM] = { 0, 0 },
- [VK_FMT_ETC2_R8G8B8A8_SRGB] = { 0, 0 },
- [VK_FMT_EAC_R11_UNORM] = { 0, 0 },
- [VK_FMT_EAC_R11_SNORM] = { 0, 0 },
- [VK_FMT_EAC_R11G11_UNORM] = { 0, 0 },
- [VK_FMT_EAC_R11G11_SNORM] = { 0, 0 },
- [VK_FMT_ASTC_4x4_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_4x4_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_5x4_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_5x4_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_5x5_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_5x5_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_6x5_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_6x5_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_6x6_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_6x6_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_8x5_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_8x5_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_8x6_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_8x6_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_8x8_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_8x8_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_10x5_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_10x5_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_10x6_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_10x6_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_10x8_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_10x8_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_10x10_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_10x10_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_12x10_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_12x10_SRGB] = { 0, 0 },
- [VK_FMT_ASTC_12x12_UNORM] = { 0, 0 },
- [VK_FMT_ASTC_12x12_SRGB] = { 0, 0 },
- [VK_FMT_B4G4R4A4_UNORM] = { 2, 4 },
- [VK_FMT_B5G5R5A1_UNORM] = { 2, 4 },
- [VK_FMT_B5G6R5_UNORM] = { 2, 3 },
- [VK_FMT_B5G6R5_USCALED] = { 2, 3 },
- [VK_FMT_B8G8R8_UNORM] = { 3, 3 },
- [VK_FMT_B8G8R8_SNORM] = { 3, 3 },
- [VK_FMT_B8G8R8_USCALED] = { 3, 3 },
- [VK_FMT_B8G8R8_SSCALED] = { 3, 3 },
- [VK_FMT_B8G8R8_UINT] = { 3, 3 },
- [VK_FMT_B8G8R8_SINT] = { 3, 3 },
- [VK_FMT_B8G8R8_SRGB] = { 3, 3 },
- [VK_FMT_B8G8R8A8_UNORM] = { 4, 4 },
- [VK_FMT_B8G8R8A8_SNORM] = { 4, 4 },
- [VK_FMT_B8G8R8A8_USCALED] = { 4, 4 },
- [VK_FMT_B8G8R8A8_SSCALED] = { 4, 4 },
- [VK_FMT_B8G8R8A8_UINT] = { 4, 4 },
- [VK_FMT_B8G8R8A8_SINT] = { 4, 4 },
- [VK_FMT_B8G8R8A8_SRGB] = { 4, 4 },
- [VK_FMT_B10G10R10A2_UNORM] = { 4, 4 },
- [VK_FMT_B10G10R10A2_SNORM] = { 4, 4 },
- [VK_FMT_B10G10R10A2_USCALED] = { 4, 4 },
- [VK_FMT_B10G10R10A2_SSCALED] = { 4, 4 },
- [VK_FMT_B10G10R10A2_UINT] = { 4, 4 },
- [VK_FMT_B10G10R10A2_SINT] = { 4, 4 },
+ [VK_FORMAT_ETC2_R8G8B8_UNORM] = { 0, 0 },
+ [VK_FORMAT_ETC2_R8G8B8_SRGB] = { 0, 0 },
+ [VK_FORMAT_ETC2_R8G8B8A1_UNORM] = { 0, 0 },
+ [VK_FORMAT_ETC2_R8G8B8A1_SRGB] = { 0, 0 },
+ [VK_FORMAT_ETC2_R8G8B8A8_UNORM] = { 0, 0 },
+ [VK_FORMAT_ETC2_R8G8B8A8_SRGB] = { 0, 0 },
+ [VK_FORMAT_EAC_R11_UNORM] = { 0, 0 },
+ [VK_FORMAT_EAC_R11_SNORM] = { 0, 0 },
+ [VK_FORMAT_EAC_R11G11_UNORM] = { 0, 0 },
+ [VK_FORMAT_EAC_R11G11_SNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_4x4_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_4x4_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_5x4_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_5x4_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_5x5_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_5x5_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_6x5_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_6x5_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_6x6_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_6x6_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_8x5_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_8x5_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_8x6_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_8x6_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_8x8_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_8x8_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_10x5_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_10x5_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_10x6_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_10x6_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_10x8_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_10x8_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_10x10_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_10x10_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_12x10_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_12x10_SRGB] = { 0, 0 },
+ [VK_FORMAT_ASTC_12x12_UNORM] = { 0, 0 },
+ [VK_FORMAT_ASTC_12x12_SRGB] = { 0, 0 },
+ [VK_FORMAT_B4G4R4A4_UNORM] = { 2, 4 },
+ [VK_FORMAT_B5G5R5A1_UNORM] = { 2, 4 },
+ [VK_FORMAT_B5G6R5_UNORM] = { 2, 3 },
+ [VK_FORMAT_B5G6R5_USCALED] = { 2, 3 },
+ [VK_FORMAT_B8G8R8_UNORM] = { 3, 3 },
+ [VK_FORMAT_B8G8R8_SNORM] = { 3, 3 },
+ [VK_FORMAT_B8G8R8_USCALED] = { 3, 3 },
+ [VK_FORMAT_B8G8R8_SSCALED] = { 3, 3 },
+ [VK_FORMAT_B8G8R8_UINT] = { 3, 3 },
+ [VK_FORMAT_B8G8R8_SINT] = { 3, 3 },
+ [VK_FORMAT_B8G8R8_SRGB] = { 3, 3 },
+ [VK_FORMAT_B8G8R8A8_UNORM] = { 4, 4 },
+ [VK_FORMAT_B8G8R8A8_SNORM] = { 4, 4 },
+ [VK_FORMAT_B8G8R8A8_USCALED] = { 4, 4 },
+ [VK_FORMAT_B8G8R8A8_SSCALED] = { 4, 4 },
+ [VK_FORMAT_B8G8R8A8_UINT] = { 4, 4 },
+ [VK_FORMAT_B8G8R8A8_SINT] = { 4, 4 },
+ [VK_FORMAT_B8G8R8A8_SRGB] = { 4, 4 },
+ [VK_FORMAT_B10G10R10A2_UNORM] = { 4, 4 },
+ [VK_FORMAT_B10G10R10A2_SNORM] = { 4, 4 },
+ [VK_FORMAT_B10G10R10A2_USCALED] = { 4, 4 },
+ [VK_FORMAT_B10G10R10A2_SSCALED] = { 4, 4 },
+ [VK_FORMAT_B10G10R10A2_UINT] = { 4, 4 },
+ [VK_FORMAT_B10G10R10A2_SINT] = { 4, 4 },
};
return format_table[format].size;
@@ -522,9 +522,9 @@
void add_memory_ref(const vk_testing::Object &obj)
{
- const std::vector<VkGpuMemory> mems = obj.memories();
- for (std::vector<VkGpuMemory>::const_iterator it = mems.begin(); it != mems.end(); it++) {
- std::vector<VkGpuMemory>::iterator ref;
+ const std::vector<VkDeviceMemory> mems = obj.memories();
+ for (std::vector<VkDeviceMemory>::const_iterator it = mems.begin(); it != mems.end(); it++) {
+ std::vector<VkDeviceMemory>::iterator ref;
for (ref = mem_refs_.begin(); ref != mem_refs_.end(); ref++) {
if (*ref == *it)
break;
@@ -540,7 +540,7 @@
vk_testing::Queue &queue_;
vk_testing::CmdBuffer cmd_;
- std::vector<VkGpuMemory> mem_refs_;
+ std::vector<VkDeviceMemory> mem_refs_;
};
typedef VkCmdBlitTest VkCmdFillBufferTest;
@@ -570,7 +570,7 @@
TEST_F(VkCmdFillBufferTest, Large)
{
- const VkGpuSize size = 32 * 1024 * 1024;
+ const VkDeviceSize size = 32 * 1024 * 1024;
vk_testing::Buffer buf;
buf.init(dev_, size);
@@ -584,7 +584,7 @@
submit_and_done();
const uint32_t *data = static_cast<const uint32_t *>(buf.map());
- VkGpuSize offset;
+ VkDeviceSize offset;
for (offset = 0; offset < size / 2; offset += 4)
EXPECT_EQ(0x11111111, data[offset / 4]) << "Offset is: " << offset;
for (; offset < size; offset += 4)
@@ -607,7 +607,7 @@
submit_and_done();
const uint32_t *data = static_cast<const uint32_t *>(buf.map());
- VkGpuSize offset;
+ VkDeviceSize offset;
for (offset = 0; offset < 32; offset += 4)
EXPECT_EQ(0x11111111, data[offset / 4]) << "Offset is: " << offset;
for (; offset < 64; offset += 4)
@@ -618,7 +618,7 @@
TEST_F(VkCmdFillBufferTest, MultiAlignments)
{
vk_testing::Buffer bufs[9];
- VkGpuSize size = 4;
+ VkDeviceSize size = 4;
cmd_.begin();
for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
@@ -634,7 +634,7 @@
size = 4;
for (int i = 0; i < ARRAY_SIZE(bufs); i++) {
const uint32_t *data = static_cast<const uint32_t *>(bufs[i].map());
- VkGpuSize offset;
+ VkDeviceSize offset;
for (offset = 0; offset < size; offset += 4)
EXPECT_EQ(0x11111111, data[offset / 4]) << "Buffser is: " << i << "\n" <<
"Offset is: " << offset;
@@ -674,12 +674,12 @@
TEST_F(VkCmdCopyBufferTest, Large)
{
- const VkGpuSize size = 32 * 1024 * 1024;
+ const VkDeviceSize size = 32 * 1024 * 1024;
vk_testing::Buffer src, dst;
src.init(dev_, size);
uint32_t *data = static_cast<uint32_t *>(src.map());
- VkGpuSize offset;
+ VkDeviceSize offset;
for (offset = 0; offset < size; offset += 4)
data[offset / 4] = offset;
src.unmap();
@@ -772,16 +772,16 @@
err = vkCreateEvent(dev_.obj(), &event_info, &event);
ASSERT_VK_SUCCESS(err);
- err = vkGetObjectInfo(event, VK_INFO_TYPE_MEMORY_REQUIREMENTS,
+ err = vkGetObjectInfo(event, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
&data_size, &mem_req);
ASSERT_VK_SUCCESS(err);
// VkResult VKAPI vkAllocMemory(
// VkDevice device,
// const VkMemoryAllocInfo* pAllocInfo,
- // VkGpuMemory* pMem);
+ // VkDeviceMemory* pMem);
VkMemoryAllocInfo mem_info;
- VkGpuMemory event_mem;
+ VkDeviceMemory event_mem;
ASSERT_NE(0, mem_req.size) << "vkGetObjectInfo (Event): Failed - expect events to require memory";
@@ -817,14 +817,7 @@
VkBufferMemoryBarrier *pmemory_barrier = &memory_barrier;
VkPipeEvent set_events[] = { VK_PIPE_EVENT_TRANSFER_COMPLETE };
- VkPipelineBarrier pipeline_barrier = {};
- pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
- pipeline_barrier.eventCount = 1;
- pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- pipeline_barrier.memBarrierCount = 1;
- pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
- vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier(cmd_.obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&pmemory_barrier);
VkBufferCopy region = {};
region.copySize = 4;
@@ -833,13 +826,7 @@
memory_barrier = bufs[1].buffer_memory_barrier(
VK_MEMORY_OUTPUT_TRANSFER_BIT, VK_MEMORY_INPUT_TRANSFER_BIT, 0, 4);
pmemory_barrier = &memory_barrier;
- pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
- pipeline_barrier.eventCount = 1;
- pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- pipeline_barrier.memBarrierCount = 1;
- pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
- vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier(cmd_.obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&pmemory_barrier);
vkCmdCopyBuffer(cmd_.obj(), bufs[1].obj(), bufs[2].obj(), 1, ®ion);
@@ -853,14 +840,7 @@
memory_barrier = bufs[1].buffer_memory_barrier(
VK_MEMORY_OUTPUT_TRANSFER_BIT, VK_MEMORY_INPUT_CPU_READ_BIT, 0, 4);
pmemory_barrier = &memory_barrier;
- VkEventWaitInfo wait_info = {};
- wait_info.sType = VK_STRUCTURE_TYPE_EVENT_WAIT_INFO;
- wait_info.eventCount = 1;
- wait_info.pEvents = &event;
- wait_info.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- wait_info.memBarrierCount = 1;
- wait_info.ppMemBarriers = (const void **)&pmemory_barrier;
- vkCmdWaitEvents(cmd_.obj(), &wait_info);
+ vkCmdWaitEvents(cmd_.obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, &event, 1, (const void **)&pmemory_barrier);
cmd_.end();
@@ -885,19 +865,19 @@
protected:
void init_test_formats(VkFlags features)
{
- first_linear_format_ = VK_FMT_UNDEFINED;
- first_optimal_format_ = VK_FMT_UNDEFINED;
+ first_linear_format_ = VK_FORMAT_UNDEFINED;
+ first_optimal_format_ = VK_FORMAT_UNDEFINED;
for (std::vector<vk_testing::Device::Format>::const_iterator it = dev_.formats().begin();
it != dev_.formats().end(); it++) {
if (it->features & features) {
test_formats_.push_back(*it);
- if (it->tiling == VK_LINEAR_TILING &&
- first_linear_format_ == VK_FMT_UNDEFINED)
+ if (it->tiling == VK_IMAGE_TILING_LINEAR &&
+ first_linear_format_ == VK_FORMAT_UNDEFINED)
first_linear_format_ = it->format;
- if (it->tiling == VK_OPTIMAL_TILING &&
- first_optimal_format_ == VK_FMT_UNDEFINED)
+ if (it->tiling == VK_IMAGE_TILING_OPTIMAL &&
+ first_optimal_format_ == VK_FORMAT_UNDEFINED)
first_optimal_format_ = it->format;
}
}
@@ -972,7 +952,7 @@
virtual void SetUp()
{
VkCmdBlitTest::SetUp();
- init_test_formats(VK_FORMAT_COLOR_ATTACHMENT_BIT);
+ init_test_formats(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
ASSERT_NE(true, test_formats_.empty());
}
@@ -1019,13 +999,13 @@
it != test_formats_.end(); it++) {
// not sure what to do here
- if (it->format == VK_FMT_UNDEFINED ||
- (it->format >= VK_FMT_B8G8R8_UNORM &&
- it->format <= VK_FMT_B8G8R8_SRGB))
+ if (it->format == VK_FORMAT_UNDEFINED ||
+ (it->format >= VK_FORMAT_B8G8R8_UNORM &&
+ it->format <= VK_FORMAT_B8G8R8_SRGB))
continue;
VkImageCreateInfo img_info = vk_testing::Image::create_info();
- img_info.imageType = VK_IMAGE_2D;
+ img_info.imageType = VK_IMAGE_TYPE_2D;
img_info.format = it->format;
img_info.extent.width = 64;
img_info.extent.height = 64;
@@ -1040,7 +1020,7 @@
virtual void SetUp()
{
VkCmdBlitTest::SetUp();
- init_test_formats(VK_FORMAT_COLOR_ATTACHMENT_BIT);
+ init_test_formats(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
ASSERT_NE(true, test_formats_.empty());
}
@@ -1087,13 +1067,13 @@
it != test_formats_.end(); it++) {
// not sure what to do here
- if (it->format == VK_FMT_UNDEFINED ||
- (it->format >= VK_FMT_B8G8R8_UNORM &&
- it->format <= VK_FMT_B8G8R8_SRGB))
+ if (it->format == VK_FORMAT_UNDEFINED ||
+ (it->format >= VK_FORMAT_B8G8R8_UNORM &&
+ it->format <= VK_FORMAT_B8G8R8_SRGB))
continue;
VkImageCreateInfo img_info = vk_testing::Image::create_info();
- img_info.imageType = VK_IMAGE_2D;
+ img_info.imageType = VK_IMAGE_TYPE_2D;
img_info.format = it->format;
img_info.extent.width = 64;
img_info.extent.height = 64;
@@ -1108,7 +1088,7 @@
virtual void SetUp()
{
VkCmdBlitTest::SetUp();
- init_test_formats(VK_FORMAT_COLOR_ATTACHMENT_BIT);
+ init_test_formats(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
ASSERT_NE(true, test_formats_.empty());
}
@@ -1117,7 +1097,7 @@
{
// convert VkImageCopy to two sets of VkBufferImageCopy
std::vector<VkBufferImageCopy> src_regions, dst_regions;
- VkGpuSize src_offset = 0, dst_offset = 0;
+ VkDeviceSize src_offset = 0, dst_offset = 0;
for (std::vector<VkImageCopy>::const_iterator it = copies.begin(); it != copies.end(); it++) {
VkBufferImageCopy src_region = {}, dst_region = {};
@@ -1133,7 +1113,7 @@
dst_region.imageExtent = it->extent;
dst_regions.push_back(dst_region);
- const VkGpuSize size = it->extent.width * it->extent.height * it->extent.depth;
+ const VkDeviceSize size = it->extent.width * it->extent.height * it->extent.depth;
src_offset += vk_testing::get_format_size(src_info.format) * size;
dst_offset += vk_testing::get_format_size(dst_info.format) * size;
}
@@ -1169,13 +1149,13 @@
it != test_formats_.end(); it++) {
// not sure what to do here
- if (it->format == VK_FMT_UNDEFINED ||
- (it->format >= VK_FMT_B8G8R8_UNORM &&
- it->format <= VK_FMT_B8G8R8_SRGB))
+ if (it->format == VK_FORMAT_UNDEFINED ||
+ (it->format >= VK_FORMAT_B8G8R8_UNORM &&
+ it->format <= VK_FORMAT_B8G8R8_SRGB))
continue;
VkImageCreateInfo img_info = vk_testing::Image::create_info();
- img_info.imageType = VK_IMAGE_2D;
+ img_info.imageType = VK_IMAGE_TYPE_2D;
img_info.format = it->format;
img_info.extent.width = 64;
img_info.extent.height = 64;
@@ -1233,21 +1213,21 @@
for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
// not sure what to do here
- if (it->format == VK_FMT_UNDEFINED ||
- (it->format >= VK_FMT_R32G32B32_UINT &&
- it->format <= VK_FMT_R32G32B32_SFLOAT) ||
- (it->format >= VK_FMT_B8G8R8_UNORM &&
- it->format <= VK_FMT_B8G8R8_SRGB) ||
- (it->format >= VK_FMT_BC1_RGB_UNORM &&
- it->format <= VK_FMT_ASTC_12x12_SRGB) ||
- (it->format >= VK_FMT_D16_UNORM &&
- it->format <= VK_FMT_D32_SFLOAT_S8_UINT) ||
- it->format == VK_FMT_R64G64B64_SFLOAT ||
- it->format == VK_FMT_R64G64B64A64_SFLOAT)
+ if (it->format == VK_FORMAT_UNDEFINED ||
+ (it->format >= VK_FORMAT_R32G32B32_UINT &&
+ it->format <= VK_FORMAT_R32G32B32_SFLOAT) ||
+ (it->format >= VK_FORMAT_B8G8R8_UNORM &&
+ it->format <= VK_FORMAT_B8G8R8_SRGB) ||
+ (it->format >= VK_FORMAT_BC1_RGB_UNORM &&
+ it->format <= VK_FORMAT_ASTC_12x12_SRGB) ||
+ (it->format >= VK_FORMAT_D16_UNORM &&
+ it->format <= VK_FORMAT_D32_SFLOAT_S8_UINT) ||
+ it->format == VK_FORMAT_R64G64B64_SFLOAT ||
+ it->format == VK_FORMAT_R64G64B64A64_SFLOAT)
continue;
VkImageCreateInfo img_info = vk_testing::Image::create_info();
- img_info.imageType = VK_IMAGE_2D;
+ img_info.imageType = VK_IMAGE_TYPE_2D;
img_info.format = it->format;
img_info.extent.width = 64;
img_info.extent.height = 64;
@@ -1274,7 +1254,7 @@
if (test_raw_)
init_test_formats();
else
- init_test_formats(VK_FORMAT_CONVERSION_BIT);
+ init_test_formats(VK_FORMAT_FEATURE_CONVERSION_BIT);
ASSERT_NE(true, test_formats_.empty());
}
@@ -1292,13 +1272,13 @@
// TODO support all formats
switch (format) {
- case VK_FMT_R8G8B8A8_UNORM:
+ case VK_FORMAT_R8G8B8A8_UNORM:
raw.push_back(color[0] * 255.0f);
raw.push_back(color[1] * 255.0f);
raw.push_back(color[2] * 255.0f);
raw.push_back(color[3] * 255.0f);
break;
- case VK_FMT_B8G8R8A8_UNORM:
+ case VK_FORMAT_B8G8R8A8_UNORM:
raw.push_back(color[2] * 255.0f);
raw.push_back(color[1] * 255.0f);
raw.push_back(color[0] * 255.0f);
@@ -1317,13 +1297,13 @@
// TODO support all formats
switch (format) {
- case VK_FMT_R8G8B8A8_UNORM:
+ case VK_FORMAT_R8G8B8A8_UNORM:
raw.push_back(static_cast<uint8_t>(color[0]));
raw.push_back(static_cast<uint8_t>(color[1]));
raw.push_back(static_cast<uint8_t>(color[2]));
raw.push_back(static_cast<uint8_t>(color[3]));
break;
- case VK_FMT_B8G8R8A8_UNORM:
+ case VK_FORMAT_B8G8R8A8_UNORM:
raw.push_back(static_cast<uint8_t>(color[2]));
raw.push_back(static_cast<uint8_t>(color[1]));
raw.push_back(static_cast<uint8_t>(color[0]));
@@ -1388,27 +1368,14 @@
cmd_.begin();
- VkPipeEvent set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
- VkPipelineBarrier pipeline_barrier = {};
- pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
- pipeline_barrier.eventCount = 1;
- pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- pipeline_barrier.memBarrierCount = to_clear.size();
- pipeline_barrier.ppMemBarriers = (const void **)&p_to_clear[0];
- vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+ VkPipeEvent set_events[] = { VK_PIPE_EVENT_COMMANDS_COMPLETE };
+ vkCmdPipelineBarrier(cmd_.obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&p_to_clear[0]);
vkCmdClearColorImage(cmd_.obj(),
img.obj(), VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
clear_color, ranges.size(), &ranges[0]);
- pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
- pipeline_barrier.eventCount = 1;
- pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- pipeline_barrier.memBarrierCount = to_xfer.size();
- pipeline_barrier.ppMemBarriers = (const void **)&p_to_xfer[0];
- vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier(cmd_.obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&p_to_xfer[0]);
cmd_.end();
@@ -1445,7 +1412,7 @@
const float color[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
VkImageCreateInfo img_info = vk_testing::Image::create_info();
- img_info.imageType = VK_IMAGE_2D;
+ img_info.imageType = VK_IMAGE_TYPE_2D;
img_info.format = it->format;
img_info.extent.width = 64;
img_info.extent.height = 64;
@@ -1481,23 +1448,23 @@
const uint32_t color[4] = { 0x11111111, 0x22222222, 0x33333333, 0x44444444 };
// not sure what to do here
- if (it->format == VK_FMT_UNDEFINED ||
- (it->format >= VK_FMT_R8G8B8_UNORM &&
- it->format <= VK_FMT_R8G8B8_SRGB) ||
- (it->format >= VK_FMT_B8G8R8_UNORM &&
- it->format <= VK_FMT_B8G8R8_SRGB) ||
- (it->format >= VK_FMT_R16G16B16_UNORM &&
- it->format <= VK_FMT_R16G16B16_SFLOAT) ||
- (it->format >= VK_FMT_R32G32B32_UINT &&
- it->format <= VK_FMT_R32G32B32_SFLOAT) ||
- it->format == VK_FMT_R64G64B64_SFLOAT ||
- it->format == VK_FMT_R64G64B64A64_SFLOAT ||
- (it->format >= VK_FMT_D16_UNORM &&
- it->format <= VK_FMT_D32_SFLOAT_S8_UINT))
+ if (it->format == VK_FORMAT_UNDEFINED ||
+ (it->format >= VK_FORMAT_R8G8B8_UNORM &&
+ it->format <= VK_FORMAT_R8G8B8_SRGB) ||
+ (it->format >= VK_FORMAT_B8G8R8_UNORM &&
+ it->format <= VK_FORMAT_B8G8R8_SRGB) ||
+ (it->format >= VK_FORMAT_R16G16B16_UNORM &&
+ it->format <= VK_FORMAT_R16G16B16_SFLOAT) ||
+ (it->format >= VK_FORMAT_R32G32B32_UINT &&
+ it->format <= VK_FORMAT_R32G32B32_SFLOAT) ||
+ it->format == VK_FORMAT_R64G64B64_SFLOAT ||
+ it->format == VK_FORMAT_R64G64B64A64_SFLOAT ||
+ (it->format >= VK_FORMAT_D16_UNORM &&
+ it->format <= VK_FORMAT_D32_SFLOAT_S8_UINT))
continue;
VkImageCreateInfo img_info = vk_testing::Image::create_info();
- img_info.imageType = VK_IMAGE_2D;
+ img_info.imageType = VK_IMAGE_TYPE_2D;
img_info.format = it->format;
img_info.extent.width = 64;
img_info.extent.height = 64;
@@ -1516,7 +1483,7 @@
virtual void SetUp()
{
VkCmdBlitTest::SetUp();
- init_test_formats(VK_FORMAT_DEPTH_STENCIL_ATTACHMENT_BIT);
+ init_test_formats(VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
ASSERT_NE(true, test_formats_.empty());
}
@@ -1526,16 +1493,16 @@
// depth
switch (format) {
- case VK_FMT_D16_UNORM:
- case VK_FMT_D16_UNORM_S8_UINT:
+ case VK_FORMAT_D16_UNORM:
+ case VK_FORMAT_D16_UNORM_S8_UINT:
{
const uint16_t unorm = depth * 65535.0f;
raw.push_back(unorm & 0xff);
raw.push_back(unorm >> 8);
}
break;
- case VK_FMT_D32_SFLOAT:
- case VK_FMT_D32_SFLOAT_S8_UINT:
+ case VK_FORMAT_D32_SFLOAT:
+ case VK_FORMAT_D32_SFLOAT_S8_UINT:
{
const union {
float depth;
@@ -1554,14 +1521,14 @@
// stencil
switch (format) {
- case VK_FMT_S8_UINT:
+ case VK_FORMAT_S8_UINT:
raw.push_back(stencil);
break;
- case VK_FMT_D16_UNORM_S8_UINT:
+ case VK_FORMAT_D16_UNORM_S8_UINT:
raw.push_back(stencil);
raw.push_back(0);
break;
- case VK_FMT_D32_SFLOAT_S8_UINT:
+ case VK_FORMAT_D32_SFLOAT_S8_UINT:
raw.push_back(stencil);
raw.push_back(0);
raw.push_back(0);
@@ -1618,28 +1585,15 @@
cmd_.begin();
- VkPipeEvent set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
- VkPipelineBarrier pipeline_barrier = {};
- pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
- pipeline_barrier.eventCount = 1;
- pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- pipeline_barrier.memBarrierCount = to_clear.size();
- pipeline_barrier.ppMemBarriers = (const void **)&p_to_clear[0];
- vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+ VkPipeEvent set_events[] = { VK_PIPE_EVENT_COMMANDS_COMPLETE };
+ vkCmdPipelineBarrier(cmd_.obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, to_clear.size(), (const void **)&p_to_clear[0]);
vkCmdClearDepthStencil(cmd_.obj(),
img.obj(), VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
depth, stencil,
ranges.size(), &ranges[0]);
- pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
- pipeline_barrier.eventCount = 1;
- pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- pipeline_barrier.memBarrierCount = to_xfer.size();
- pipeline_barrier.ppMemBarriers = (const void **)&p_to_xfer[0];
- vkCmdPipelineBarrier(cmd_.obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier(cmd_.obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, to_xfer.size(), (const void **)&p_to_xfer[0]);
cmd_.end();
@@ -1661,14 +1615,14 @@
for (std::vector<vk_testing::Device::Format>::const_iterator it = test_formats_.begin();
it != test_formats_.end(); it++) {
// known driver issues
- if (it->format == VK_FMT_S8_UINT ||
- it->format == VK_FMT_D24_UNORM ||
- it->format == VK_FMT_D16_UNORM_S8_UINT ||
- it->format == VK_FMT_D24_UNORM_S8_UINT)
+ if (it->format == VK_FORMAT_S8_UINT ||
+ it->format == VK_FORMAT_D24_UNORM ||
+ it->format == VK_FORMAT_D16_UNORM_S8_UINT ||
+ it->format == VK_FORMAT_D24_UNORM_S8_UINT)
continue;
VkImageCreateInfo img_info = vk_testing::Image::create_info();
- img_info.imageType = VK_IMAGE_2D;
+ img_info.imageType = VK_IMAGE_TYPE_2D;
img_info.format = it->format;
img_info.extent.width = 64;
img_info.extent.height = 64;
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index 326a8c8..736daea 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -78,11 +78,11 @@
protected:
vk_testing::Device *m_device;
VkApplicationInfo app_info;
- VkPhysicalGpu objs[16];
+ VkPhysicalDevice objs[16];
uint32_t gpu_count;
VkInstance inst;
VkImage m_image;
- VkGpuMemory *m_image_mem;
+ VkDeviceMemory *m_image_mem;
uint32_t m_num_mem;
virtual void SetUp() {
@@ -140,11 +140,11 @@
mipCount++;
}
- fmt = VK_FMT_R8G8B8A8_UINT;
+ fmt = VK_FORMAT_R8G8B8A8_UINT;
// TODO: Pick known good format rather than just expect common format
/*
* XXX: What should happen if given NULL HANDLE for the pData argument?
- * We're not requesting VK_INFO_TYPE_MEMORY_REQUIREMENTS so there is
+ * We're not requesting VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS so there is
* an expectation that pData is a valid pointer.
* However, why include a returned size value? That implies that the
* amount of data may vary and that doesn't work well for using a
@@ -152,7 +152,7 @@
*/
size = sizeof(image_fmt);
err = vkGetFormatInfo(this->device(), fmt,
- VK_INFO_TYPE_FORMAT_PROPERTIES,
+ VK_FORMAT_INFO_TYPE_PROPERTIES,
&size, &image_fmt);
ASSERT_VK_SUCCESS(err);
@@ -174,7 +174,7 @@
VkImageCreateInfo imageCreateInfo = {};
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
- imageCreateInfo.imageType = VK_IMAGE_2D;
+ imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.format = fmt;
imageCreateInfo.arraySize = 1;
imageCreateInfo.extent.width = w;
@@ -182,11 +182,11 @@
imageCreateInfo.extent.depth = 1;
imageCreateInfo.mipLevels = mipCount;
imageCreateInfo.samples = 1;
- if (image_fmt.linearTilingFeatures & VK_FORMAT_SAMPLED_IMAGE_BIT) {
- imageCreateInfo.tiling = VK_LINEAR_TILING;
+ if (image_fmt.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
+ imageCreateInfo.tiling = VK_IMAGE_TILING_LINEAR;
}
- else if (image_fmt.optimalTilingFeatures & VK_FORMAT_SAMPLED_IMAGE_BIT) {
- imageCreateInfo.tiling = VK_OPTIMAL_TILING;
+ else if (image_fmt.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
+ imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
}
else {
ASSERT_TRUE(false) << "Cannot find supported tiling format - Exiting";
@@ -223,15 +223,15 @@
mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.pNext = NULL;
- err = vkGetObjectInfo(m_image, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+ err = vkGetObjectInfo(m_image, VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
&num_alloc_size, &num_allocations);
ASSERT_VK_SUCCESS(err);
ASSERT_EQ(num_alloc_size,sizeof(num_allocations));
mem_req = (VkMemoryRequirements *) malloc(num_allocations * sizeof(VkMemoryRequirements));
- m_image_mem = (VkGpuMemory *) malloc(num_allocations * sizeof(VkGpuMemory));
+ m_image_mem = (VkDeviceMemory *) malloc(num_allocations * sizeof(VkDeviceMemory));
m_num_mem = num_allocations;
err = vkGetObjectInfo(m_image,
- VK_INFO_TYPE_MEMORY_REQUIREMENTS,
+ VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
&mem_reqs_size, mem_req);
ASSERT_VK_SUCCESS(err);
ASSERT_EQ(mem_reqs_size, num_allocations * sizeof(VkMemoryRequirements));
@@ -285,7 +285,7 @@
VkFormat fmt;
VkImageView imageView;
- fmt = VK_FMT_R8G8B8A8_UINT;
+ fmt = VK_FORMAT_R8G8B8A8_UINT;
CreateImage(512, 256);
@@ -302,7 +302,7 @@
// } VkImageViewCreateInfo;
VkImageViewCreateInfo viewInfo = {};
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
- viewInfo.viewType = VK_IMAGE_VIEW_2D;
+ viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
viewInfo.format = fmt;
viewInfo.channels.r = VK_CHANNEL_SWIZZLE_R;
diff --git a/tests/init.cpp b/tests/init.cpp
index de02b34..a0c44d1 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -80,13 +80,13 @@
protected:
VkApplicationInfo app_info;
VkInstance inst;
- VkPhysicalGpu objs[16];
+ VkPhysicalDevice objs[16];
uint32_t gpu_count;
uint32_t m_device_id;
vk_testing::Device *m_device;
- VkPhysicalGpuProperties props;
- std::vector<VkPhysicalGpuQueueProperties> queue_props;
+ VkPhysicalDeviceProperties props;
+ std::vector<VkPhysicalDeviceQueueProperties> queue_props;
uint32_t graphics_queue_node_index;
virtual void SetUp() {
@@ -137,10 +137,10 @@
}
};
-TEST(Initialization, vkEnumerateGpus) {
+TEST(Initialization, vkEnumeratePhysicalDevices) {
VkApplicationInfo app_info = {};
VkInstance inst;
- VkPhysicalGpu objs[16];
+ VkPhysicalDevice objs[16];
uint32_t gpu_count;
VkResult err;
vk_testing::PhysicalGpu *gpu;
@@ -192,13 +192,13 @@
TEST_F(XglTest, AllocMemory) {
VkResult err;
VkMemoryAllocInfo alloc_info = {};
- VkGpuMemory gpu_mem;
+ VkDeviceMemory gpu_mem;
uint8_t *pData;
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
alloc_info.allocationSize = 1024 * 1024; // 1MB
alloc_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT |
- VK_MEMORY_PROPERTY_CPU_VISIBLE_BIT;
+ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
// TODO: Try variety of memory priorities
@@ -239,16 +239,16 @@
err = vkCreateEvent(device(), &event_info, &event);
ASSERT_VK_SUCCESS(err);
- err = vkGetObjectInfo(event, VK_INFO_TYPE_MEMORY_REQUIREMENTS,
+ err = vkGetObjectInfo(event, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
&data_size, &mem_req);
ASSERT_VK_SUCCESS(err);
// VkResult VKAPI vkAllocMemory(
// VkDevice device,
// const VkMemoryAllocInfo* pAllocInfo,
- // VkGpuMemory* pMem);
+ // VkDeviceMemory* pMem);
VkMemoryAllocInfo mem_info;
- VkGpuMemory event_mem;
+ VkDeviceMemory event_mem;
ASSERT_NE(0, mem_req.size) << "vkGetObjectInfo (Event): Failed - expect events to require memory";
@@ -339,11 +339,11 @@
// typedef enum VkQueryType_
// {
- // VK_QUERY_OCCLUSION = 0x00000000,
- // VK_QUERY_PIPELINE_STATISTICS = 0x00000001,
+ // VK_QUERY_TYPE_OCCLUSION = 0x00000000,
+ // VK_QUERY_TYPE_PIPELINE_STATISTICS = 0x00000001,
- // VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_OCCLUSION,
- // VK_QUERY_TYPE_END_RANGE = VK_QUERY_PIPELINE_STATISTICS,
+ // VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
+ // VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_PIPELINE_STATISTICS,
// VK_NUM_QUERY_TYPE = (VK_QUERY_TYPE_END_RANGE - VK_QUERY_TYPE_BEGIN_RANGE + 1),
// VK_MAX_ENUM(VkQueryType_)
// } VkQueryType;
@@ -358,7 +358,7 @@
memset(&query_info, 0, sizeof(query_info));
query_info.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
- query_info.queryType = VK_QUERY_OCCLUSION;
+ query_info.queryType = VK_QUERY_TYPE_OCCLUSION;
query_info.slots = MAX_QUERY_SLOTS;
// VkResult VKAPI vkCreateQueryPool(
@@ -370,7 +370,7 @@
ASSERT_VK_SUCCESS(err);
data_size = sizeof(mem_req);
- err = vkGetObjectInfo(query_pool, VK_INFO_TYPE_MEMORY_REQUIREMENTS,
+ err = vkGetObjectInfo(query_pool, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
&data_size, &mem_req);
ASSERT_VK_SUCCESS(err);
ASSERT_NE(0, data_size) << "Invalid data_size";
@@ -378,9 +378,9 @@
// VkResult VKAPI vkAllocMemory(
// VkDevice device,
// const VkMemoryAllocInfo* pAllocInfo,
- // VkGpuMemory* pMem);
+ // VkDeviceMemory* pMem);
VkMemoryAllocInfo mem_info;
- VkGpuMemory query_mem;
+ VkDeviceMemory query_mem;
memset(&mem_info, 0, sizeof(mem_info));
mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
@@ -404,13 +404,13 @@
// TOOD: vkCmdEndQuery
err = vkGetQueryPoolResults(query_pool, 0, MAX_QUERY_SLOTS,
- &query_result_size, VK_NULL_HANDLE);
+ &query_result_size, VK_NULL_HANDLE, 0);
ASSERT_VK_SUCCESS(err);
if (query_result_size > 0) {
query_result_data = new uint32_t [query_result_size];
err = vkGetQueryPoolResults(query_pool, 0, MAX_QUERY_SLOTS,
- &query_result_size, query_result_data);
+ &query_result_size, query_result_data, 0);
ASSERT_VK_SUCCESS(err);
// TODO: Test Query result data.
@@ -431,7 +431,7 @@
VkResult err;
VkQueue queue;
- const VkPhysicalGpuQueueProperties props = device->gpu().queue_properties()[queue_node_index];
+ const VkPhysicalDeviceQueueProperties props = device->gpu().queue_properties()[queue_node_index];
for (que_idx = 0; que_idx < props.queueCount; que_idx++) {
// TODO: Need to add support for separate MEMMGR and work queues, including synchronization
err = vkGetDeviceQueue(device->obj(), queue_node_index, que_idx, &queue);
@@ -443,12 +443,12 @@
void print_queue_info(vk_testing::Device *device, uint32_t queue_node_index)
{
uint32_t que_idx;
- VkPhysicalGpuQueueProperties queue_props;
- VkPhysicalGpuProperties props;
+ VkPhysicalDeviceQueueProperties queue_props;
+ VkPhysicalDeviceProperties props;
props = device->gpu().properties();
queue_props = device->gpu().queue_properties()[queue_node_index];
- ASSERT_NE(0, queue_props.queueCount) << "No Queues available at Node Index #" << queue_node_index << " GPU: " << props.gpuName;
+ ASSERT_NE(0, queue_props.queueCount) << "No Queues available at Node Index #" << queue_node_index << " GPU: " << props.deviceName;
// VkResult VKAPI vkGetDeviceQueue(
// VkDevice device,
@@ -459,7 +459,7 @@
* queue handles are retrieved from the device by calling
* vkGetDeviceQueue() with a queue node index and a requested logical
* queue ID. The queue node index is the index into the array of
- * VkPhysicalGpuQueueProperties returned by GetGpuInfo. Each
+ * VkPhysicalDeviceQueueProperties returned by GetPhysicalDeviceInfo. Each
* queue node index has different attributes specified by the VkQueueFlags property.
* The logical queue ID is a sequential number starting from zero
* and referencing up to the number of queues supported of that node index
@@ -533,11 +533,11 @@
mipCount++;
}
- fmt = VK_FMT_R8G8B8A8_UINT;
+ fmt = VK_FORMAT_R8G8B8A8_UINT;
// TODO: Pick known good format rather than just expect common format
/*
* XXX: What should happen if given NULL HANDLE for the pData argument?
- * We're not requesting VK_INFO_TYPE_MEMORY_REQUIREMENTS so there is
+ * We're not requesting VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS so there is
* an expectation that pData is a valid pointer.
* However, why include a returned size value? That implies that the
* amount of data may vary and that doesn't work well for using a
@@ -546,7 +546,7 @@
size = sizeof(image_fmt);
err = vkGetFormatInfo(device(), fmt,
- VK_INFO_TYPE_FORMAT_PROPERTIES,
+ VK_FORMAT_INFO_TYPE_PROPERTIES,
&size, &image_fmt);
ASSERT_VK_SUCCESS(err);
@@ -568,7 +568,7 @@
VkImageCreateInfo imageCreateInfo = {};
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
- imageCreateInfo.imageType = VK_IMAGE_2D;
+ imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.format = fmt;
imageCreateInfo.arraySize = 1;
imageCreateInfo.extent.width = w;
@@ -576,7 +576,7 @@
imageCreateInfo.extent.depth = 1;
imageCreateInfo.mipLevels = mipCount;
imageCreateInfo.samples = 1;
- imageCreateInfo.tiling = VK_LINEAR_TILING;
+ imageCreateInfo.tiling = VK_IMAGE_TILING_LINEAR;
imageCreateInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
@@ -596,10 +596,10 @@
// void* pData);
// typedef struct VkSubresourceLayout_
// {
-// VkGpuSize offset; // Specified in bytes
-// VkGpuSize size; // Specified in bytes
-// VkGpuSize rowPitch; // Specified in bytes
-// VkGpuSize depthPitch; // Specified in bytes
+// VkDeviceSize offset; // Specified in bytes
+// VkDeviceSize size; // Specified in bytes
+// VkDeviceSize rowPitch; // Specified in bytes
+// VkDeviceSize depthPitch; // Specified in bytes
// } VkSubresourceLayout;
// typedef struct VkImageSubresource_
@@ -611,7 +611,7 @@
// typedef enum VkSubresourceInfoType_
// {
// // Info type for vkGetImageSubresourceInfo()
-// VK_INFO_TYPE_SUBRESOURCE_LAYOUT = 0x00000000,
+// VK_SUBRESOURCE_INFO_TYPE_LAYOUT = 0x00000000,
// VK_MAX_ENUM(VkSubresourceInfoType_)
// } VkSubresourceInfoType;
@@ -625,7 +625,7 @@
{
VkSubresourceLayout layout = {};
data_size = sizeof(layout);
- err = vkGetImageSubresourceInfo(image, &subresource, VK_INFO_TYPE_SUBRESOURCE_LAYOUT,
+ err = vkGetImageSubresourceInfo(image, &subresource, VK_SUBRESOURCE_INFO_TYPE_LAYOUT,
&data_size, &layout);
ASSERT_VK_SUCCESS(err);
ASSERT_EQ(sizeof(VkSubresourceLayout), data_size) << "Invalid structure (VkSubresourceLayout) size";
@@ -640,7 +640,7 @@
VkMemoryRequirements mem_req;
data_size = sizeof(mem_req);
- err = vkGetObjectInfo(image, VK_INFO_TYPE_MEMORY_REQUIREMENTS,
+ err = vkGetObjectInfo(image, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
&data_size, &mem_req);
ASSERT_VK_SUCCESS(err);
ASSERT_EQ(data_size, sizeof(mem_req));
@@ -648,9 +648,9 @@
// VkResult VKAPI vkAllocMemory(
// VkDevice device,
// const VkMemoryAllocInfo* pAllocInfo,
- // VkGpuMemory* pMem);
+ // VkDeviceMemory* pMem);
VkMemoryAllocInfo mem_info = {};
- VkGpuMemory image_mem;
+ VkDeviceMemory image_mem;
mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.pNext = NULL;
@@ -679,7 +679,7 @@
VkImageView view;
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
viewInfo.image = image;
- viewInfo.viewType = VK_IMAGE_VIEW_2D;
+ viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
viewInfo.format = fmt;
viewInfo.channels.r = VK_CHANNEL_SWIZZLE_R;
diff --git a/tests/render_tests.cpp b/tests/render_tests.cpp
index 89cc5a6..1f657fa 100644
--- a/tests/render_tests.cpp
+++ b/tests/render_tests.cpp
@@ -226,7 +226,7 @@
VkImage m_texture;
VkImageView m_textureView;
VkImageViewAttachInfo m_textureViewInfo;
- VkGpuMemory m_textureMem;
+ VkDeviceMemory m_textureMem;
VkSampler m_sampler;
@@ -291,10 +291,10 @@
}
cmdBuffer->PrepareAttachments();
- cmdBuffer->BindStateObject(VK_STATE_BIND_RASTER, m_stateRaster);
- cmdBuffer->BindStateObject(VK_STATE_BIND_VIEWPORT, m_stateViewport);
- cmdBuffer->BindStateObject(VK_STATE_BIND_COLOR_BLEND, m_colorBlend);
- cmdBuffer->BindStateObject(VK_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil);
+ cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_RASTER, m_stateRaster);
+ cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_VIEWPORT, m_stateViewport);
+ cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_COLOR_BLEND, m_colorBlend);
+ cmdBuffer->BindStateObject(VK_STATE_BIND_POINT_DEPTH_STENCIL, m_stateDepthStencil);
descriptorSet.CreateVKDescriptorSet(cmdBuffer);
pipelineobj.CreateVKPipeline(descriptorSet);
cmdBuffer->BindPipeline(pipelineobj);
@@ -701,11 +701,11 @@
VkVertexInputAttributeDescription vi_attribs[2];
vi_attribs[0].binding = MESH_BIND_ID; // Binding ID
vi_attribs[0].location = 0; // location, position
- vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
vi_attribs[1].binding = MESH_BIND_ID; // Binding ID
vi_attribs[1].location = 1; // location, color
- vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[1].offsetInBytes = 1*sizeof(float)*4; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs,2);
@@ -779,7 +779,7 @@
VkVertexInputAttributeDescription vi_attrib;
vi_attrib.binding = MESH_BUF_ID; // index into vertexBindingDescriptions
vi_attrib.location = 0;
- vi_attrib.format = VK_FMT_R32G32_SFLOAT; // format of source data
+ vi_attrib.format = VK_FORMAT_R32G32_SFLOAT; // format of source data
vi_attrib.offsetInBytes = 0; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(&vi_attrib, 1);
@@ -871,7 +871,7 @@
meshBuffer.BufferMemoryBarrier();
VkIndexBufferObj indexBuffer(m_device);
- indexBuffer.CreateAndInitBuffer(sizeof(g_idxData)/sizeof(g_idxData[0]), VK_INDEX_16, g_idxData);
+ indexBuffer.CreateAndInitBuffer(sizeof(g_idxData)/sizeof(g_idxData[0]), VK_INDEX_TYPE_UINT16, g_idxData);
indexBuffer.BufferMemoryBarrier();
VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX, this);
@@ -896,11 +896,11 @@
VkVertexInputAttributeDescription vi_attribs[2];
vi_attribs[0].binding = MESH_BIND_ID; // binding ID from BINDING_DESCRIPTION array to use for this attribute
vi_attribs[0].location = 0; // layout location of vertex attribute
- vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
vi_attribs[1].binding = MESH_BIND_ID; // binding ID from BINDING_DESCRIPTION array to use for this attribute
vi_attribs[1].location = 1; // layout location of vertex attribute
- vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs,2);
@@ -990,7 +990,7 @@
VkVertexInputAttributeDescription vi_attribs[1];
vi_attribs[0].binding = MESH_BIND_ID; // binding ID
vi_attribs[0].location = 0;
- vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs,1);
@@ -1080,7 +1080,7 @@
VkVertexInputAttributeDescription vi_attribs[1];
vi_attribs[0].binding = MESH_BIND_ID; // binding ID
vi_attribs[0].location = 0;
- vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs,1);
@@ -1180,7 +1180,7 @@
VkVertexInputAttributeDescription vi_attribs[1];
vi_attribs[0].binding = MESH_BIND_ID; // binding ID
vi_attribs[0].location = 0;
- vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs,1);
@@ -1271,7 +1271,7 @@
VkVertexInputAttributeDescription vi_attribs[1];
vi_attribs[0].binding = MESH_BIND_ID; // binding ID
vi_attribs[0].location = 0;
- vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs,1);
@@ -1505,11 +1505,11 @@
VkVertexInputAttributeDescription vi_attribs[2];
vi_attribs[0].binding = MESH_BUF_ID; // binding ID
vi_attribs[0].location = 0;
- vi_attribs[0].format = VK_FMT_R32G32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
vi_attribs[1].binding = MESH_BUF_ID; // binding ID
vi_attribs[1].location = 1;
- vi_attribs[1].format = VK_FMT_R32G32_SFLOAT; // format of source data
+ vi_attribs[1].format = VK_FORMAT_R32G32_SFLOAT; // format of source data
vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
@@ -1610,11 +1610,11 @@
VkVertexInputAttributeDescription vi_attribs[2];
vi_attribs[0].binding = MESH_BUF_ID; // binding ID
vi_attribs[0].location = 4;
- vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = sizeof(float) * 4 * 2; // Offset of first element in bytes from base of vertex
vi_attribs[1].binding = MESH_BUF_ID; // binding ID
vi_attribs[1].location = 1;
- vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[1].offsetInBytes = sizeof(float) * 4 * 1; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
@@ -1705,11 +1705,11 @@
VkVertexInputAttributeDescription vi_attribs[2];
vi_attribs[0].binding = MESH_BUF_ID; // binding ID
vi_attribs[0].location = 0;
- vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
vi_attribs[1].binding = MESH_BUF_ID; // binding ID
vi_attribs[1].location = 1;
- vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
@@ -1795,14 +1795,14 @@
VkPipelineDsStateCreateInfo ds_state;
ds_state.depthTestEnable = VK_TRUE;
ds_state.depthWriteEnable = VK_TRUE;
- ds_state.depthFunc = VK_COMPARE_LESS_EQUAL;
+ ds_state.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
ds_state.depthBoundsEnable = VK_FALSE;
ds_state.stencilTestEnable = VK_FALSE;
ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
- ds_state.back.stencilFunc = VK_COMPARE_ALWAYS;
- ds_state.format = VK_FMT_D32_SFLOAT;
+ ds_state.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
+ ds_state.format = VK_FORMAT_D32_SFLOAT;
ds_state.front = ds_state.back;
pipelineobj.SetDepthStencil(&ds_state);
@@ -1819,11 +1819,11 @@
VkVertexInputAttributeDescription vi_attribs[2];
vi_attribs[0].binding = MESH_BUF_ID; // binding ID
vi_attribs[0].location = 0;
- vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
vi_attribs[1].binding = MESH_BUF_ID; // binding ID
vi_attribs[1].location = 1;
- vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
@@ -2582,11 +2582,11 @@
VkVertexInputAttributeDescription vi_attribs[2];
vi_attribs[0].binding = MESH_BIND_ID; // Binding ID
vi_attribs[0].location = 0; // location
- vi_attribs[0].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
vi_attribs[1].binding = MESH_BIND_ID; // Binding ID
vi_attribs[1].location = 1; // location
- vi_attribs[1].format = VK_FMT_R32G32B32A32_SFLOAT; // format of source data
+ vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex
pipelineobj.AddVertexInputAttribs(vi_attribs,2);
@@ -2596,14 +2596,14 @@
VkPipelineDsStateCreateInfo ds_state;
ds_state.depthTestEnable = VK_TRUE;
ds_state.depthWriteEnable = VK_TRUE;
- ds_state.depthFunc = VK_COMPARE_LESS_EQUAL;
+ ds_state.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
ds_state.depthBoundsEnable = VK_FALSE;
ds_state.stencilTestEnable = VK_FALSE;
ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
- ds_state.back.stencilFunc = VK_COMPARE_ALWAYS;
- ds_state.format = VK_FMT_D32_SFLOAT;
+ ds_state.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
+ ds_state.format = VK_FORMAT_D32_SFLOAT;
ds_state.front = ds_state.back;
pipelineobj.SetDepthStencil(&ds_state);
diff --git a/tests/test_common.h b/tests/test_common.h
index 2683597..fc00882 100644
--- a/tests/test_common.h
+++ b/tests/test_common.h
@@ -28,8 +28,8 @@
STR(VK_ERROR_UNKNOWN);
STR(VK_ERROR_UNAVAILABLE);
STR(VK_ERROR_INITIALIZATION_FAILED);
- STR(VK_ERROR_OUT_OF_MEMORY);
- STR(VK_ERROR_OUT_OF_GPU_MEMORY);
+ STR(VK_ERROR_OUT_OF_HOST_MEMORY);
+ STR(VK_ERROR_OUT_OF_DEVICE_MEMORY);
STR(VK_ERROR_DEVICE_ALREADY_CREATED);
STR(VK_ERROR_DEVICE_LOST);
STR(VK_ERROR_INVALID_POINTER);
diff --git a/tests/test_environment.h b/tests/test_environment.h
index 2081992..43530a7 100644
--- a/tests/test_environment.h
+++ b/tests/test_environment.h
@@ -18,7 +18,7 @@
const std::vector<Device *> &devices() { return devs_; }
Device &default_device() { return *(devs_[default_dev_]); }
- VkPhysicalGpu gpus[16];
+ VkPhysicalDevice gpus[16];
private:
VkApplicationInfo app_;
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 6c1de3b..a81ae89 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -39,8 +39,8 @@
m_stateDepthStencil( VK_NULL_HANDLE ),
m_width( 256.0 ), // default window width
m_height( 256.0 ), // default window height
- m_render_target_fmt( VK_FMT_R8G8B8A8_UNORM ),
- m_depth_stencil_fmt( VK_FMT_UNDEFINED ),
+ m_render_target_fmt( VK_FORMAT_R8G8B8A8_UNORM ),
+ m_depth_stencil_fmt( VK_FORMAT_UNDEFINED ),
m_depth_clear_color( 1.0 ),
m_stencil_clear_color( 0 )
{
@@ -114,7 +114,7 @@
{
VkResult err;
- m_render_target_fmt = VK_FMT_B8G8R8A8_UNORM;
+ m_render_target_fmt = VK_FORMAT_B8G8R8A8_UNORM;
// create a raster state (solid, back-face culling)
VkDynamicRsStateCreateInfo raster = {};
@@ -256,7 +256,7 @@
-VkDeviceObj::VkDeviceObj(uint32_t id, VkPhysicalGpu obj) :
+VkDeviceObj::VkDeviceObj(uint32_t id, VkPhysicalDevice obj) :
vk_testing::Device(obj), id(id)
{
init();
@@ -356,7 +356,7 @@
for (int i = 0; i < m_type_counts.size(); i++) {
bindings[i].descriptorType = m_type_counts[i].type;
bindings[i].count = m_type_counts[i].count;
- bindings[i].stageFlags = VK_SHADER_STAGE_FLAGS_ALL;
+ bindings[i].stageFlags = VK_SHADER_STAGE_ALL;
bindings[i].pImmutableSamplers = NULL;
}
@@ -428,18 +428,10 @@
VkImageMemoryBarrier *pmemory_barrier = &barrier;
- VkPipeEvent pipe_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
- VkPipelineBarrier pipeline_barrier = {};
- pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
- pipeline_barrier.pNext = NULL;
- pipeline_barrier.eventCount = 1;
- pipeline_barrier.pEvents = pipe_events;
- pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- pipeline_barrier.memBarrierCount = 1;
- pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
+ VkPipeEvent pipe_events[] = { VK_PIPE_EVENT_COMMANDS_COMPLETE };
// write barrier to the command buffer
- vkCmdPipelineBarrier(cmd_buf->obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier(cmd_buf->obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, pipe_events, 1, (const void **)&pmemory_barrier);
}
void VkImageObj::SetLayout(VkCommandBufferObj *cmd_buf,
@@ -518,7 +510,7 @@
bool VkImageObj::IsCompatible(VkFlags usage, VkFlags features)
{
if ((usage & VK_IMAGE_USAGE_SAMPLED_BIT) &&
- !(features & VK_FORMAT_SAMPLED_IMAGE_BIT))
+ !(features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
return false;
return true;
@@ -547,28 +539,28 @@
size = sizeof(image_fmt);
err = vkGetFormatInfo(m_device->obj(), fmt,
- VK_INFO_TYPE_FORMAT_PROPERTIES,
+ VK_FORMAT_INFO_TYPE_PROPERTIES,
&size, &image_fmt);
ASSERT_VK_SUCCESS(err);
- if (requested_tiling == VK_LINEAR_TILING) {
+ if (requested_tiling == VK_IMAGE_TILING_LINEAR) {
if (IsCompatible(usage, image_fmt.linearTilingFeatures)) {
- tiling = VK_LINEAR_TILING;
+ tiling = VK_IMAGE_TILING_LINEAR;
} else if (IsCompatible(usage, image_fmt.optimalTilingFeatures)) {
- tiling = VK_OPTIMAL_TILING;
+ tiling = VK_IMAGE_TILING_OPTIMAL;
} else {
ASSERT_TRUE(false) << "Error: Cannot find requested tiling configuration";
}
} else if (IsCompatible(usage, image_fmt.optimalTilingFeatures)) {
- tiling = VK_OPTIMAL_TILING;
+ tiling = VK_IMAGE_TILING_OPTIMAL;
} else if (IsCompatible(usage, image_fmt.linearTilingFeatures)) {
- tiling = VK_LINEAR_TILING;
+ tiling = VK_IMAGE_TILING_LINEAR;
} else {
ASSERT_TRUE(false) << "Error: Cannot find requested tiling configuration";
}
VkImageCreateInfo imageCreateInfo = vk_testing::Image::create_info();
- imageCreateInfo.imageType = VK_IMAGE_2D;
+ imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.format = fmt;
imageCreateInfo.extent.width = w;
imageCreateInfo.extent.height = h;
@@ -653,13 +645,13 @@
:VkImageObj(device)
{
m_device = device;
- const VkFormat tex_format = VK_FMT_B8G8R8A8_UNORM;
+ const VkFormat tex_format = VK_FORMAT_B8G8R8A8_UNORM;
uint32_t tex_colors[2] = { 0xffff0000, 0xff00ff00 };
void *data;
int32_t x, y;
VkImageObj stagingImage(device);
- stagingImage.init(16, 16, tex_format, 0, VK_LINEAR_TILING);
+ stagingImage.init(16, 16, tex_format, 0, VK_IMAGE_TILING_LINEAR);
VkSubresourceLayout layout = stagingImage.subresource_layout(subresource(VK_IMAGE_ASPECT_COLOR, 0, 0));
if (colors == NULL)
@@ -673,7 +665,7 @@
view.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
view.pNext = NULL;
view.image = VK_NULL_HANDLE;
- view.viewType = VK_IMAGE_VIEW_2D;
+ view.viewType = VK_IMAGE_VIEW_TYPE_2D;
view.format = tex_format;
view.channels.r = VK_CHANNEL_SWIZZLE_R;
view.channels.g = VK_CHANNEL_SWIZZLE_G;
@@ -687,7 +679,7 @@
view.minLod = 0.0f;
/* create image */
- init(16, 16, tex_format, VK_IMAGE_USAGE_SAMPLED_BIT, VK_OPTIMAL_TILING);
+ init(16, 16, tex_format, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_TILING_OPTIMAL);
/* create image view */
view.image = obj();
@@ -714,16 +706,16 @@
samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
samplerCreateInfo.magFilter = VK_TEX_FILTER_NEAREST;
samplerCreateInfo.minFilter = VK_TEX_FILTER_NEAREST;
- samplerCreateInfo.mipMode = VK_TEX_MIPMAP_BASE;
+ samplerCreateInfo.mipMode = VK_TEX_MIPMAP_MODE_BASE;
samplerCreateInfo.addressU = VK_TEX_ADDRESS_WRAP;
samplerCreateInfo.addressV = VK_TEX_ADDRESS_WRAP;
samplerCreateInfo.addressW = VK_TEX_ADDRESS_WRAP;
samplerCreateInfo.mipLodBias = 0.0;
samplerCreateInfo.maxAnisotropy = 0.0;
- samplerCreateInfo.compareFunc = VK_COMPARE_NEVER;
+ samplerCreateInfo.compareOp = VK_COMPARE_OP_NEVER;
samplerCreateInfo.minLod = 0.0;
samplerCreateInfo.maxLod = 0.0;
- samplerCreateInfo.borderColorType = VK_BORDER_COLOR_OPAQUE_WHITE;
+ samplerCreateInfo.borderColor = VK_BORDER_COLOR_OPAQUE_WHITE;
init(*m_device, samplerCreateInfo);
}
@@ -767,7 +759,7 @@
VkBufferViewCreateInfo view_info = {};
view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
view_info.buffer = obj();
- view_info.viewType = VK_BUFFER_VIEW_RAW;
+ view_info.viewType = VK_BUFFER_VIEW_TYPE_RAW;
view_info.offset = 0;
view_info.range = allocationSize;
m_bufferView.init(*m_device, view_info);
@@ -776,7 +768,7 @@
this->m_bufferViewInfo.view = m_bufferView.obj();
}
-void VkConstantBufferObj::Bind(VkCmdBuffer cmdBuffer, VkGpuSize offset, uint32_t binding)
+void VkConstantBufferObj::Bind(VkCmdBuffer cmdBuffer, VkDeviceSize offset, uint32_t binding)
{
vkCmdBindVertexBuffers(cmdBuffer, binding, 1, &obj(), &offset);
}
@@ -827,17 +819,10 @@
buffer_memory_barrier(outputMask, inputMask, 0, m_numVertices * m_stride);
VkBufferMemoryBarrier *pmemory_barrier = &memory_barrier;
- VkPipeEvent set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
- VkPipelineBarrier pipeline_barrier = {};
- pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
- pipeline_barrier.eventCount = 1;
- pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- pipeline_barrier.memBarrierCount = 1;
- pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
+ VkPipeEvent set_events[] = { VK_PIPE_EVENT_COMMANDS_COMPLETE };
// write barrier to the command buffer
- m_commandBuffer->PipelineBarrier(&pipeline_barrier);
+ m_commandBuffer->PipelineBarrier(VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&pmemory_barrier);
// finish recording the command buffer
err = m_commandBuffer->EndCommandBuffer();
@@ -870,17 +855,17 @@
m_numVertices = numIndexes;
m_indexType = indexType;
switch (indexType) {
- case VK_INDEX_8:
+ case VK_INDEX_TYPE_UINT8:
m_stride = 1;
- viewFormat = VK_FMT_R8_UINT;
+ viewFormat = VK_FORMAT_R8_UINT;
break;
- case VK_INDEX_16:
+ case VK_INDEX_TYPE_UINT16:
m_stride = 2;
- viewFormat = VK_FMT_R16_UINT;
+ viewFormat = VK_FORMAT_R16_UINT;
break;
- case VK_INDEX_32:
+ case VK_INDEX_TYPE_UINT32:
m_stride = 4;
- viewFormat = VK_FMT_R32_UINT;
+ viewFormat = VK_FORMAT_R32_UINT;
break;
default:
assert(!"unknown index type");
@@ -898,7 +883,7 @@
VkBufferViewCreateInfo view_info = {};
view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
view_info.buffer = obj();
- view_info.viewType = VK_BUFFER_VIEW_FORMATTED;
+ view_info.viewType = VK_BUFFER_VIEW_TYPE_FORMATTED;
view_info.format = viewFormat;
view_info.offset = 0;
view_info.range = allocationSize;
@@ -908,7 +893,7 @@
this->m_bufferViewInfo.view = m_bufferView.obj();
}
-void VkIndexBufferObj::Bind(VkCmdBuffer cmdBuffer, VkGpuSize offset)
+void VkIndexBufferObj::Bind(VkCmdBuffer cmdBuffer, VkDeviceSize offset)
{
vkCmdBindIndexBuffer(cmdBuffer, obj(), offset, m_indexType);
}
@@ -930,7 +915,7 @@
return stageInfo;
}
-VkShaderObj::VkShaderObj(VkDeviceObj *device, const char * shader_code, VkPipelineShaderStage stage, VkRenderFramework *framework)
+VkShaderObj::VkShaderObj(VkDeviceObj *device, const char * shader_code, VkShaderStage stage, VkRenderFramework *framework)
{
VkResult err = VK_SUCCESS;
std::vector<unsigned int> spv;
@@ -950,7 +935,7 @@
createInfo.pCode = malloc(createInfo.codeSize);
createInfo.flags = 0;
- /* try version 0 first: VkPipelineShaderStage followed by GLSL */
+ /* try version 0 first: VkShaderStage followed by GLSL */
((uint32_t *) createInfo.pCode)[0] = ICD_SPV_MAGIC;
((uint32_t *) createInfo.pCode)[1] = 0;
((uint32_t *) createInfo.pCode)[2] = stage;
@@ -981,7 +966,7 @@
m_ia_state.sType = VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO;
m_ia_state.pNext = VK_NULL_HANDLE;
- m_ia_state.topology = VK_TOPOLOGY_TRIANGLE_LIST;
+ m_ia_state.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
m_ia_state.disableVertexReuse = VK_FALSE;
m_ia_state.primitiveRestartEnable = VK_FALSE;
m_ia_state.primitiveRestartIndex = 0;
@@ -993,8 +978,8 @@
m_rs_state.programPointSize = VK_FALSE;
m_rs_state.pointOrigin = VK_COORDINATE_ORIGIN_UPPER_LEFT;
m_rs_state.provokingVertex = VK_PROVOKING_VERTEX_LAST;
- m_rs_state.fillMode = VK_FILL_SOLID;
- m_rs_state.cullMode = VK_CULL_NONE;
+ m_rs_state.fillMode = VK_FILL_MODE_SOLID;
+ m_rs_state.cullMode = VK_CULL_MODE_NONE;
m_rs_state.frontFace = VK_FRONT_FACE_CCW;
memset(&m_cb_state,0,sizeof(m_cb_state));
@@ -1013,21 +998,21 @@
m_ds_state.sType = VK_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
m_ds_state.pNext = &m_ms_state,
- m_ds_state.format = VK_FMT_D32_SFLOAT;
+ m_ds_state.format = VK_FORMAT_D32_SFLOAT;
m_ds_state.depthTestEnable = VK_FALSE;
m_ds_state.depthWriteEnable = VK_FALSE;
m_ds_state.depthBoundsEnable = VK_FALSE;
- m_ds_state.depthFunc = VK_COMPARE_LESS_EQUAL;
+ m_ds_state.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
m_ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
m_ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
m_ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
- m_ds_state.back.stencilFunc = VK_COMPARE_ALWAYS;
+ m_ds_state.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
m_ds_state.stencilTestEnable = VK_FALSE;
m_ds_state.front = m_ds_state.back;
VkPipelineCbAttachmentState att = {};
att.blendEnable = VK_FALSE;
- att.format = VK_FMT_B8G8R8A8_UNORM;
+ att.format = VK_FORMAT_B8G8R8A8_UNORM;
att.channelWriteMask = 0xf;
AddColorAttachment(0, &att);
@@ -1072,7 +1057,7 @@
m_ds_state.depthTestEnable = ds_state->depthTestEnable;
m_ds_state.depthWriteEnable = ds_state->depthWriteEnable;
m_ds_state.depthBoundsEnable = ds_state->depthBoundsEnable;
- m_ds_state.depthFunc = ds_state->depthFunc;
+ m_ds_state.depthCompareOp = ds_state->depthCompareOp;
m_ds_state.stencilTestEnable = ds_state->stencilTestEnable;
m_ds_state.back = ds_state->back;
m_ds_state.front = ds_state->front;
@@ -1110,9 +1095,9 @@
init(*m_device, info);
}
-vector<VkGpuMemory> VkMemoryRefManager::mem_refs() const
+vector<VkDeviceMemory> VkMemoryRefManager::mem_refs() const
{
- std::vector<VkGpuMemory> mems;
+ std::vector<VkDeviceMemory> mems;
if (this->mem_refs_.size()) {
mems.reserve(this->mem_refs_.size());
for (uint32_t i = 0; i < this->mem_refs_.size(); i++)
@@ -1124,11 +1109,11 @@
void VkMemoryRefManager::AddMemoryRefs(vk_testing::Object &vkObject)
{
- const std::vector<VkGpuMemory> mems = vkObject.memories();
+ const std::vector<VkDeviceMemory> mems = vkObject.memories();
AddMemoryRefs(mems);
}
-void VkMemoryRefManager::AddMemoryRefs(vector<VkGpuMemory> mem)
+void VkMemoryRefManager::AddMemoryRefs(vector<VkDeviceMemory> mem)
{
for (size_t i = 0; i < mem.size(); i++) {
if (mem[i] != NULL) {
@@ -1182,9 +1167,9 @@
return VK_SUCCESS;
}
-void VkCommandBufferObj::PipelineBarrier(VkPipelineBarrier *barrierPtr)
+void VkCommandBufferObj::PipelineBarrier(VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
{
- vkCmdPipelineBarrier(obj(), barrierPtr);
+ vkCmdPipelineBarrier(obj(), waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers);
}
void VkCommandBufferObj::ClearAllBuffers(VkClearColor clear_color, float depth_clear_color, uint32_t stencil_clear_color,
@@ -1215,19 +1200,12 @@
memory_barrier.subresourceRange = srRange;
VkImageMemoryBarrier *pmemory_barrier = &memory_barrier;
- VkPipeEvent set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
- VkPipelineBarrier pipeline_barrier = {};
- pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
- pipeline_barrier.eventCount = 1;
- pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- pipeline_barrier.memBarrierCount = 1;
- pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
+ VkPipeEvent set_events[] = { VK_PIPE_EVENT_COMMANDS_COMPLETE };
for (i = 0; i < m_renderTargets.size(); i++) {
memory_barrier.image = m_renderTargets[i]->image();
memory_barrier.oldLayout = m_renderTargets[i]->layout();
- vkCmdPipelineBarrier( obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier( obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&pmemory_barrier);
m_renderTargets[i]->layout(memory_barrier.newLayout);
vkCmdClearColorImage(obj(),
@@ -1253,7 +1231,7 @@
memory_barrier.image = depthStencilObj->obj();
memory_barrier.subresourceRange = dsRange;
- vkCmdPipelineBarrier( obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier( obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&pmemory_barrier);
vkCmdClearDepthStencil(obj(),
depthStencilObj->obj(), VK_IMAGE_LAYOUT_CLEAR_OPTIMAL,
@@ -1266,7 +1244,7 @@
memory_barrier.oldLayout = VK_IMAGE_LAYOUT_CLEAR_OPTIMAL;
memory_barrier.newLayout = depthStencilObj->BindInfo()->layout;
memory_barrier.subresourceRange = dsRange;
- vkCmdPipelineBarrier( obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier( obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&pmemory_barrier);
}
}
@@ -1305,20 +1283,13 @@
memory_barrier.subresourceRange = srRange;
VkImageMemoryBarrier *pmemory_barrier = &memory_barrier;
- VkPipeEvent set_events[] = { VK_PIPE_EVENT_GPU_COMMANDS_COMPLETE };
- VkPipelineBarrier pipeline_barrier = {};
- pipeline_barrier.sType = VK_STRUCTURE_TYPE_PIPELINE_BARRIER;
- pipeline_barrier.eventCount = 1;
- pipeline_barrier.pEvents = set_events;
- pipeline_barrier.waitEvent = VK_WAIT_EVENT_TOP_OF_PIPE;
- pipeline_barrier.memBarrierCount = 1;
- pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
+ VkPipeEvent set_events[] = { VK_PIPE_EVENT_COMMANDS_COMPLETE };
for(i=0; i<m_renderTargets.size(); i++)
{
memory_barrier.image = m_renderTargets[i]->image();
memory_barrier.oldLayout = m_renderTargets[i]->layout();
- vkCmdPipelineBarrier( obj(), &pipeline_barrier);
+ vkCmdPipelineBarrier( obj(), VK_WAIT_EVENT_TOP_OF_PIPE, 1, set_events, 1, (const void **)&pmemory_barrier);
m_renderTargets[i]->layout(memory_barrier.newLayout);
}
}
@@ -1411,7 +1382,7 @@
mem_ref_mgr.AddMemoryRefs(*indexBuffer);
}
-void VkCommandBufferObj::BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkGpuSize offset, uint32_t binding)
+void VkCommandBufferObj::BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize offset, uint32_t binding)
{
vkCmdBindVertexBuffers(obj(), binding, 1, &vertexBuffer->obj(), &offset);
mem_ref_mgr.AddMemoryRefs(*vertexBuffer);
@@ -1438,11 +1409,11 @@
m_device = device;
m_initialized = true;
- m_depth_stencil_fmt = VK_FMT_D16_UNORM;
+ m_depth_stencil_fmt = VK_FORMAT_D16_UNORM;
image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
image_info.pNext = NULL;
- image_info.imageType = VK_IMAGE_2D;
+ image_info.imageType = VK_IMAGE_TYPE_2D;
image_info.format = m_depth_stencil_fmt;
image_info.extent.width = width;
image_info.extent.height = height;
@@ -1450,7 +1421,7 @@
image_info.mipLevels = 1;
image_info.arraySize = 1;
image_info.samples = 1;
- image_info.tiling = VK_OPTIMAL_TILING;
+ image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
image_info.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_BIT;
image_info.flags = 0;
init(*m_device, image_info);
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index 55a4769..09c07dc 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -34,14 +34,14 @@
class VkDeviceObj : public vk_testing::Device
{
public:
- VkDeviceObj(uint32_t id, VkPhysicalGpu obj);
+ VkDeviceObj(uint32_t id, VkPhysicalDevice obj);
VkDevice device() { return obj(); }
void get_device_queue();
uint32_t id;
- VkPhysicalGpuProperties props;
- const VkPhysicalGpuQueueProperties *queue_props;
+ VkPhysicalDeviceProperties props;
+ const VkPhysicalDeviceQueueProperties *queue_props;
VkQueue m_queue;
};
@@ -50,13 +50,13 @@
{
public:
void AddMemoryRefs(vk_testing::Object &vkObject);
- void AddMemoryRefs(vector<VkGpuMemory> mem);
+ void AddMemoryRefs(vector<VkDeviceMemory> mem);
void EmitAddMemoryRefs(VkQueue queue);
void EmitRemoveMemoryRefs(VkQueue queue);
- vector<VkGpuMemory> mem_refs() const;
+ vector<VkDeviceMemory> mem_refs() const;
protected:
- vector<VkGpuMemory> mem_refs_;
+ vector<VkDeviceMemory> mem_refs_;
};
@@ -83,7 +83,7 @@
~VkRenderFramework();
VkDevice device() {return m_device->device();}
- VkPhysicalGpu gpu() {return objs[0];}
+ VkPhysicalDevice gpu() {return objs[0];}
VkRenderPass renderPass() {return m_renderPass;}
VkFramebuffer framebuffer() {return m_framebuffer;}
void InitViewport(float width, float height);
@@ -100,7 +100,7 @@
protected:
VkApplicationInfo app_info;
VkInstance inst;
- VkPhysicalGpu objs[16];
+ VkPhysicalDevice objs[16];
uint32_t gpu_count;
VkDeviceObj *m_device;
VkCmdBuffer m_cmdBuffer;
@@ -157,17 +157,17 @@
VkResult BeginCommandBuffer(VkCmdBufferBeginInfo *pInfo);
VkResult BeginCommandBuffer(VkRenderPass renderpass_obj, VkFramebuffer framebuffer_obj);
VkResult EndCommandBuffer();
- void PipelineBarrier(VkPipelineBarrier *barrierPtr);
+ void PipelineBarrier(VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers);
void AddRenderTarget(VkImageObj *renderTarget);
void AddDepthStencil();
void ClearAllBuffers(VkClearColor clear_color, float depth_clear_color, uint32_t stencil_clear_color, VkDepthStencilObj *depthStencilObj);
void PrepareAttachments();
void AddMemoryRefs(vk_testing::Object &vkObject);
- void AddMemoryRefs(uint32_t ref_count, const VkGpuMemory *mem);
+ void AddMemoryRefs(uint32_t ref_count, const VkDeviceMemory *mem);
void AddMemoryRefs(vector<vk_testing::Object *> images);
void BindPipeline(VkPipelineObj &pipeline);
void BindDescriptorSet(VkDescriptorSetObj &descriptorSet);
- void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkGpuSize offset, uint32_t binding);
+ void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize offset, uint32_t binding);
void BindIndexBuffer(VkIndexBufferObj *indexBuffer, uint32_t offset);
void BindStateObject(VkStateBindPoint stateBindPoint, VkDynamicStateObject stateObject);
void BeginRenderPass(VkRenderPass renderpass, VkFramebuffer framebuffer);
@@ -208,7 +208,7 @@
VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
VK_MEMORY_INPUT_TRANSFER_BIT);
- void Bind(VkCmdBuffer cmdBuffer, VkGpuSize offset, uint32_t binding);
+ void Bind(VkCmdBuffer cmdBuffer, VkDeviceSize offset, uint32_t binding);
VkBufferViewAttachInfo m_bufferViewInfo;
@@ -226,7 +226,7 @@
public:
VkIndexBufferObj(VkDeviceObj *device);
void CreateAndInitBuffer(int numIndexes, VkIndexType dataFormat, const void* data);
- void Bind(VkCmdBuffer cmdBuffer, VkGpuSize offset);
+ void Bind(VkCmdBuffer cmdBuffer, VkDeviceSize offset);
VkIndexType GetIndexType();
protected:
@@ -242,7 +242,7 @@
public:
void init(uint32_t w, uint32_t h,
VkFormat fmt, VkFlags usage,
- VkImageTiling tiling=VK_LINEAR_TILING);
+ VkImageTiling tiling=VK_IMAGE_TILING_LINEAR);
// void clear( CommandBuffer*, uint32_t[4] );
@@ -251,9 +251,9 @@
m_imageInfo.layout = layout;
}
- VkGpuMemory memory() const
+ VkDeviceMemory memory() const
{
- const std::vector<VkGpuMemory> mems = memories();
+ const std::vector<VkDeviceMemory> mems = memories();
return mems.empty() ? VK_NULL_HANDLE : mems[0];
}
@@ -278,7 +278,7 @@
VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
VK_NULL_HANDLE,
obj(),
- VK_FMT_B8G8R8A8_UNORM,
+ VK_FORMAT_B8G8R8A8_UNORM,
0,
0,
1
@@ -328,7 +328,7 @@
protected:
VkDeviceObj *m_device;
vk_testing::ImageView m_textureView;
- VkGpuSize m_rowPitch;
+ VkDeviceSize m_rowPitch;
};
class VkSamplerObj : public vk_testing::Sampler
@@ -376,12 +376,12 @@
class VkShaderObj : public vk_testing::Shader
{
public:
- VkShaderObj(VkDeviceObj *device, const char * shaderText, VkPipelineShaderStage stage, VkRenderFramework *framework);
+ VkShaderObj(VkDeviceObj *device, const char * shaderText, VkShaderStage stage, VkRenderFramework *framework);
VkPipelineShaderStageCreateInfo* GetStageCreateInfo();
protected:
VkPipelineShaderStageCreateInfo stage_info;
- VkPipelineShaderStage m_stage;
+ VkShaderStage m_stage;
VkDeviceObj *m_device;
};
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index d9cdc9b..a3e134d 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -63,13 +63,13 @@
}
template<typename T>
-std::vector<T> get_info(VkPhysicalGpu gpu, VkPhysicalGpuInfoType type, size_t min_elems)
+std::vector<T> get_info(VkPhysicalDevice gpu, VkPhysicalDeviceInfoType type, size_t min_elems)
{
std::vector<T> info;
size_t size;
- if (EXPECT(vkGetGpuInfo(gpu, type, &size, NULL) == VK_SUCCESS && size % sizeof(T) == 0)) {
+ if (EXPECT(vkGetPhysicalDeviceInfo(gpu, type, &size, NULL) == VK_SUCCESS && size % sizeof(T) == 0)) {
info.resize(size / sizeof(T));
- if (!EXPECT(vkGetGpuInfo(gpu, type, &size, &info[0]) == VK_SUCCESS && size == info.size() * sizeof(T)))
+ if (!EXPECT(vkGetPhysicalDeviceInfo(gpu, type, &size, &info[0]) == VK_SUCCESS && size == info.size() * sizeof(T)))
info.clear();
}
@@ -105,24 +105,24 @@
error_callback = callback;
}
-VkPhysicalGpuProperties PhysicalGpu::properties() const
+VkPhysicalDeviceProperties PhysicalGpu::properties() const
{
- return get_info<VkPhysicalGpuProperties>(gpu_, VK_INFO_TYPE_PHYSICAL_GPU_PROPERTIES, 1)[0];
+ return get_info<VkPhysicalDeviceProperties>(gpu_, VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES, 1)[0];
}
-VkPhysicalGpuPerformance PhysicalGpu::performance() const
+VkPhysicalDevicePerformance PhysicalGpu::performance() const
{
- return get_info<VkPhysicalGpuPerformance>(gpu_, VK_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE, 1)[0];
+ return get_info<VkPhysicalDevicePerformance>(gpu_, VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE, 1)[0];
}
-std::vector<VkPhysicalGpuQueueProperties> PhysicalGpu::queue_properties() const
+std::vector<VkPhysicalDeviceQueueProperties> PhysicalGpu::queue_properties() const
{
- return get_info<VkPhysicalGpuQueueProperties>(gpu_, VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES, 0);
+ return get_info<VkPhysicalDeviceQueueProperties>(gpu_, VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES, 0);
}
-VkPhysicalGpuMemoryProperties PhysicalGpu::memory_properties() const
+VkPhysicalDeviceMemoryProperties PhysicalGpu::memory_properties() const
{
- return get_info<VkPhysicalGpuMemoryProperties>(gpu_, VK_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES, 1)[0];
+ return get_info<VkPhysicalDeviceMemoryProperties>(gpu_, VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES, 1)[0];
}
std::vector<const char *> PhysicalGpu::layers(std::vector<char> &buf) const
@@ -164,10 +164,10 @@
return exts;
}
-VkGpuCompatibilityInfo PhysicalGpu::compatibility(const PhysicalGpu &other) const
+VkPhysicalDeviceCompatibilityInfo PhysicalGpu::compatibility(const PhysicalGpu &other) const
{
- VkGpuCompatibilityInfo data;
- if (!EXPECT(vkGetMultiGpuCompatibility(gpu_, other.gpu_, &data) == VK_SUCCESS))
+ VkPhysicalDeviceCompatibilityInfo data;
+ if (!EXPECT(vkGetMultiDeviceCompatibility(gpu_, other.gpu_, &data) == VK_SUCCESS))
memset(&data, 0, sizeof(data));
return data;
@@ -187,7 +187,7 @@
uint32_t BaseObject::memory_allocation_count() const
{
- return get_info<uint32_t>(obj_, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT, 1)[0];
+ return get_info<uint32_t>(obj_, VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, 1)[0];
}
std::vector<VkMemoryRequirements> BaseObject::memory_requirements() const
@@ -195,11 +195,11 @@
VkResult err;
uint32_t num_allocations = 0;
size_t num_alloc_size = sizeof(num_allocations);
- err = vkGetObjectInfo(obj_, VK_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+ err = vkGetObjectInfo(obj_, VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
&num_alloc_size, &num_allocations);
EXPECT(err == VK_SUCCESS && num_alloc_size == sizeof(num_allocations));
std::vector<VkMemoryRequirements> info =
- get_info<VkMemoryRequirements>(obj_, VK_INFO_TYPE_MEMORY_REQUIREMENTS, 0);
+ get_info<VkMemoryRequirements>(obj_, VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, 0);
EXPECT(info.size() == num_allocations);
if (info.size() == 1 && !info[0].size)
info.clear();
@@ -241,15 +241,15 @@
EXPECT(vkDestroyObject(obj()) == VK_SUCCESS);
}
-void Object::bind_memory(const Device &dev, uint32_t alloc_idx, const GpuMemory &mem, VkGpuSize mem_offset)
+void Object::bind_memory(const Device &dev, uint32_t alloc_idx, const GpuMemory &mem, VkDeviceSize mem_offset)
{
bound = true;
VkQueue queue = dev.graphics_queues()[0]->obj();
EXPECT(vkQueueBindObjectMemory(queue, obj(), alloc_idx, mem.obj(), mem_offset) == VK_SUCCESS);
}
-void Object::bind_memory(const Device &dev, uint32_t alloc_idx, VkGpuSize offset, VkGpuSize size,
- const GpuMemory &mem, VkGpuSize mem_offset)
+void Object::bind_memory(const Device &dev, uint32_t alloc_idx, VkDeviceSize offset, VkDeviceSize size,
+ const GpuMemory &mem, VkDeviceSize mem_offset)
{
bound = true;
VkQueue queue = dev.graphics_queues()[0]->obj();
@@ -286,7 +286,7 @@
}
}
-void Object::alloc_memory(const Device &dev, const std::vector<VkGpuMemory> &mems)
+void Object::alloc_memory(const Device &dev, const std::vector<VkDeviceMemory> &mems)
{
if (!EXPECT(!internal_mems_) || !mem_alloc_count_)
return;
@@ -305,9 +305,9 @@
}
}
-std::vector<VkGpuMemory> Object::memories() const
+std::vector<VkDeviceMemory> Object::memories() const
{
- std::vector<VkGpuMemory> mems;
+ std::vector<VkDeviceMemory> mems;
if (internal_mems_) {
mems.reserve(mem_alloc_count_);
for (uint32_t i = 0; i < mem_alloc_count_; i++)
@@ -334,7 +334,7 @@
void Device::init(bool enable_layers)
{
// request all queues
- const std::vector<VkPhysicalGpuQueueProperties> queue_props = gpu_.queue_properties();
+ const std::vector<VkPhysicalDeviceQueueProperties> queue_props = gpu_.queue_properties();
std::vector<VkDeviceQueueCreateInfo> queue_info;
queue_info.reserve(queue_props.size());
for (int i = 0; i < queue_props.size(); i++) {
@@ -387,16 +387,16 @@
size_t data_size;
uint32_t queue_node_count;
- err = vkGetGpuInfo(gpu_.obj(), VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES,
+ err = vkGetPhysicalDeviceInfo(gpu_.obj(), VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES,
&data_size, NULL);
EXPECT(err == VK_SUCCESS);
- queue_node_count = data_size / sizeof(VkPhysicalGpuQueueProperties);
+ queue_node_count = data_size / sizeof(VkPhysicalDeviceQueueProperties);
EXPECT(queue_node_count >= 1);
- VkPhysicalGpuQueueProperties queue_props[queue_node_count];
+ VkPhysicalDeviceQueueProperties queue_props[queue_node_count];
- err = vkGetGpuInfo(gpu_.obj(), VK_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES,
+ err = vkGetPhysicalDeviceInfo(gpu_.obj(), VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES,
&data_size, queue_props);
EXPECT(err == VK_SUCCESS);
@@ -427,17 +427,17 @@
void Device::init_formats()
{
- for (int f = VK_FMT_BEGIN_RANGE; f <= VK_FMT_END_RANGE; f++) {
+ for (int f = VK_FORMAT_BEGIN_RANGE; f <= VK_FORMAT_END_RANGE; f++) {
const VkFormat fmt = static_cast<VkFormat>(f);
const VkFormatProperties props = format_properties(fmt);
if (props.linearTilingFeatures) {
- const Format tmp = { fmt, VK_LINEAR_TILING, props.linearTilingFeatures };
+ const Format tmp = { fmt, VK_IMAGE_TILING_LINEAR, props.linearTilingFeatures };
formats_.push_back(tmp);
}
if (props.optimalTilingFeatures) {
- const Format tmp = { fmt, VK_OPTIMAL_TILING, props.optimalTilingFeatures };
+ const Format tmp = { fmt, VK_IMAGE_TILING_OPTIMAL, props.optimalTilingFeatures };
formats_.push_back(tmp);
}
}
@@ -447,7 +447,7 @@
VkFormatProperties Device::format_properties(VkFormat format)
{
- const VkFormatInfoType type = VK_INFO_TYPE_FORMAT_PROPERTIES;
+ const VkFormatInfoType type = VK_FORMAT_INFO_TYPE_PROPERTIES;
VkFormatProperties data;
size_t size = sizeof(data);
if (!EXPECT(vkGetFormatInfo(obj(), format, type, &size, &data) == VK_SUCCESS && size == sizeof(data)))
@@ -497,12 +497,12 @@
submit(cmd, fence);
}
-void Queue::add_mem_references(const std::vector<VkGpuMemory> &mem_refs)
+void Queue::add_mem_references(const std::vector<VkDeviceMemory> &mem_refs)
{
EXPECT(vkQueueAddMemReferences(obj(), mem_refs.size(), &mem_refs[0]) == VK_SUCCESS);
}
-void Queue::remove_mem_references(const std::vector<VkGpuMemory> &mem_refs)
+void Queue::remove_mem_references(const std::vector<VkDeviceMemory> &mem_refs)
{
EXPECT(vkQueueRemoveMemReferences(obj(), mem_refs.size(), &mem_refs[0]) == VK_SUCCESS);
}
@@ -622,7 +622,7 @@
VkResult QueryPool::results(uint32_t start, uint32_t count, size_t size, void *data)
{
size_t tmp = size;
- VkResult err = vkGetQueryPoolResults(obj(), start, count, &tmp, data);
+ VkResult err = vkGetQueryPoolResults(obj(), start, count, &tmp, data, 0);
if (err == VK_SUCCESS) {
if (!EXPECT(tmp == size))
memset(data, 0, size);
@@ -668,12 +668,12 @@
void Image::init(const Device &dev, const VkPeerImageOpenInfo &info, const VkImageCreateInfo &original_info)
{
VkImage img;
- VkGpuMemory mem;
+ VkDeviceMemory mem;
EXPECT(vkOpenPeerImage(dev.obj(), &info, &img, &mem) == VK_SUCCESS);
Object::init(img);
init_info(dev, original_info);
- alloc_memory(dev, std::vector<VkGpuMemory>(1, mem));
+ alloc_memory(dev, std::vector<VkDeviceMemory>(1, mem));
}
void Image::init_info(const Device &dev, const VkImageCreateInfo &info)
@@ -689,7 +689,7 @@
}
void Image::bind_memory(const Device &dev, uint32_t alloc_idx, const VkImageMemoryBindInfo &info,
- const GpuMemory &mem, VkGpuSize mem_offset)
+ const GpuMemory &mem, VkDeviceSize mem_offset)
{
VkQueue queue = dev.graphics_queues()[0]->obj();
EXPECT(!alloc_idx && vkQueueBindImageMemoryRange(queue, obj(), 0, &info, mem.obj(), mem_offset) == VK_SUCCESS);
@@ -697,7 +697,7 @@
VkSubresourceLayout Image::subresource_layout(const VkImageSubresource &subres) const
{
- const VkSubresourceInfoType type = VK_INFO_TYPE_SUBRESOURCE_LAYOUT;
+ const VkSubresourceInfoType type = VK_SUBRESOURCE_INFO_TYPE_LAYOUT;
VkSubresourceLayout data;
size_t size = sizeof(data);
if (!EXPECT(vkGetImageSubresourceInfo(obj(), &subres, type, &size, &data) == VK_SUCCESS && size == sizeof(data)))
@@ -708,7 +708,7 @@
bool Image::transparent() const
{
- return (create_info_.tiling == VK_LINEAR_TILING &&
+ return (create_info_.tiling == VK_IMAGE_TILING_LINEAR &&
create_info_.samples == 1 &&
!(create_info_.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
VK_IMAGE_USAGE_DEPTH_STENCIL_BIT)));
@@ -924,7 +924,7 @@
graphics_cmd_buf_info.renderPassContinue.renderPass = renderpass_obj;
graphics_cmd_buf_info.renderPassContinue.framebuffer = framebuffer_obj;
- info.flags = VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT |
+ info.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
info.pNext = &graphics_cmd_buf_info;
@@ -935,7 +935,7 @@
void CmdBuffer::begin()
{
VkCmdBufferBeginInfo info = {};
- info.flags = VK_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT |
+ info.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT |
VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT;
info.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 18de306..a8eb41b 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -66,15 +66,15 @@
class PhysicalGpu {
public:
- explicit PhysicalGpu(VkPhysicalGpu gpu) : gpu_(gpu) {}
+ explicit PhysicalGpu(VkPhysicalDevice gpu) : gpu_(gpu) {}
- const VkPhysicalGpu &obj() const { return gpu_; }
+ const VkPhysicalDevice &obj() const { return gpu_; }
- // vkGetGpuInfo()
- VkPhysicalGpuProperties properties() const;
- VkPhysicalGpuPerformance performance() const;
- VkPhysicalGpuMemoryProperties memory_properties() const;
- std::vector<VkPhysicalGpuQueueProperties> queue_properties() const;
+ // vkGetPhysicalDeviceInfo()
+ VkPhysicalDeviceProperties properties() const;
+ VkPhysicalDevicePerformance performance() const;
+ VkPhysicalDeviceMemoryProperties memory_properties() const;
+ std::vector<VkPhysicalDeviceQueueProperties> queue_properties() const;
// vkGetProcAddr()
void *get_proc(const char *name) const { return vkGetProcAddr(gpu_, name); }
@@ -85,11 +85,11 @@
// vkEnumerateLayers()
std::vector<const char *> layers(std::vector<char> &buf) const;
- // vkGetMultiGpuCompatibility()
- VkGpuCompatibilityInfo compatibility(const PhysicalGpu &other) const;
+ // vkGetMultiDeviceCompatibility()
+ VkPhysicalDeviceCompatibilityInfo compatibility(const PhysicalGpu &other) const;
private:
- VkPhysicalGpu gpu_;
+ VkPhysicalDevice gpu_;
};
class BaseObject {
@@ -127,18 +127,18 @@
const VkObject &obj() const { return reinterpret_cast<const VkObject &>(BaseObject::obj()); }
// vkQueueBindObjectMemory()
- void bind_memory(const Device &dev, uint32_t alloc_idx, const GpuMemory &mem, VkGpuSize mem_offset);
+ void bind_memory(const Device &dev, uint32_t alloc_idx, const GpuMemory &mem, VkDeviceSize mem_offset);
void unbind_memory(const Device &dev, uint32_t alloc_idx);
void unbind_memory(const Device &dev);
// vkQueueBindObjectMemoryRange()
- void bind_memory(const Device &dev, uint32_t alloc_idx, VkGpuSize offset, VkGpuSize size,
- const GpuMemory &mem, VkGpuSize mem_offset);
+ void bind_memory(const Device &dev, uint32_t alloc_idx, VkDeviceSize offset, VkDeviceSize size,
+ const GpuMemory &mem, VkDeviceSize mem_offset);
// Unless an object is initialized with init_no_mem(), memories are
// automatically allocated and bound. These methods can be used to get
// the memories (for vkQueueAddMemReferences), or to map/unmap the primary memory.
- std::vector<VkGpuMemory> memories() const;
+ std::vector<VkDeviceMemory> memories() const;
const void *map(VkFlags flags) const;
void *map(VkFlags flags);
@@ -161,7 +161,7 @@
// allocate and bind internal memories
void alloc_memory(const Device &dev);
- void alloc_memory(const Device &dev, const std::vector<VkGpuMemory> &mems);
+ void alloc_memory(const Device &dev, const std::vector<VkDeviceMemory> &mems);
private:
void cleanup();
@@ -196,7 +196,7 @@
class Device : public DerivedObject<VkDevice, BaseObject> {
public:
- explicit Device(VkPhysicalGpu gpu) : gpu_(gpu) {}
+ explicit Device(VkPhysicalDevice gpu) : gpu_(gpu) {}
~Device();
// vkCreateDevice()
@@ -261,8 +261,8 @@
// vkQueueAddMemReferences()
// vkQueueRemoveMemReferences()
- void add_mem_references(const std::vector<VkGpuMemory> &mem_refs);
- void remove_mem_references(const std::vector<VkGpuMemory> &mem_refs);
+ void add_mem_references(const std::vector<VkDeviceMemory> &mem_refs);
+ void remove_mem_references(const std::vector<VkDeviceMemory> &mem_refs);
// vkQueueWaitIdle()
void wait();
@@ -273,7 +273,7 @@
void wait_semaphore(Semaphore &sem);
};
-class GpuMemory : public DerivedObject<VkGpuMemory, BaseObject> {
+class GpuMemory : public DerivedObject<VkDeviceMemory, BaseObject> {
public:
~GpuMemory();
@@ -286,7 +286,7 @@
// vkOpenPeerMemory()
void init(const Device &dev, const VkPeerMemoryOpenInfo &info);
- void init(VkGpuMemory mem) { BaseObject::init(mem, false); }
+ void init(VkDeviceMemory mem) { BaseObject::init(mem, false); }
// vkSetMemoryPriority()
void set_priority(VkMemoryPriority priority);
@@ -356,17 +356,17 @@
public:
explicit Buffer() {}
explicit Buffer(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info); }
- explicit Buffer(const Device &dev, VkGpuSize size) { init(dev, size); }
+ explicit Buffer(const Device &dev, VkDeviceSize size) { init(dev, size); }
// vkCreateBuffer()
void init(const Device &dev, const VkBufferCreateInfo &info);
- void init(const Device &dev, VkGpuSize size) { init(dev, create_info(size, 0)); }
+ void init(const Device &dev, VkDeviceSize size) { init(dev, create_info(size, 0)); }
void init_no_mem(const Device &dev, const VkBufferCreateInfo &info);
- static VkBufferCreateInfo create_info(VkGpuSize size, VkFlags usage);
+ static VkBufferCreateInfo create_info(VkDeviceSize size, VkFlags usage);
VkBufferMemoryBarrier buffer_memory_barrier(VkFlags output_mask, VkFlags input_mask,
- VkGpuSize offset, VkGpuSize size) const
+ VkDeviceSize offset, VkDeviceSize size) const
{
VkBufferMemoryBarrier barrier = {};
barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
@@ -400,13 +400,13 @@
// vkQueueBindImageMemoryRange()
void bind_memory(const Device &dev, uint32_t alloc_idx, const VkImageMemoryBindInfo &info,
- const GpuMemory &mem, VkGpuSize mem_offset);
+ const GpuMemory &mem, VkDeviceSize mem_offset);
// vkGetImageSubresourceInfo()
VkSubresourceLayout subresource_layout(const VkImageSubresource &subres) const;
bool transparent() const;
- bool copyable() const { return (format_features_ & VK_FORMAT_SAMPLED_IMAGE_BIT); }
+ bool copyable() const { return (format_features_ & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT); }
VkImageSubresourceRange subresource_range(VkImageAspect aspect) const { return subresource_range(create_info_, aspect); }
VkExtent3D extent() const { return create_info_.extent; }
@@ -632,7 +632,7 @@
return info;
}
-inline VkBufferCreateInfo Buffer::create_info(VkGpuSize size, VkFlags usage)
+inline VkBufferCreateInfo Buffer::create_info(VkDeviceSize size, VkFlags usage)
{
VkBufferCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index de59fd4..8f9f360 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -184,7 +184,7 @@
int x, y;
VkImageObj displayImage(image->device());
- displayImage.init(image->extent().width, image->extent().height, image->format(), 0, VK_LINEAR_TILING);
+ displayImage.init(image->extent().width, image->extent().height, image->format(), 0, VK_IMAGE_TILING_LINEAR);
displayImage.CopyImage(*image);
filename.append(basename);
@@ -197,7 +197,7 @@
size_t data_size = sizeof(sr_layout);
err = vkGetImageSubresourceInfo( image->image(), &sr,
- VK_INFO_TYPE_SUBRESOURCE_LAYOUT,
+ VK_SUBRESOURCE_INFO_TYPE_LAYOUT,
&data_size, &sr_layout);
ASSERT_VK_SUCCESS( err );
ASSERT_EQ(data_size, sizeof(sr_layout));
@@ -218,7 +218,7 @@
const int *row = (const int *) ptr;
int swapped;
- if (displayImage.format() == VK_FMT_B8G8R8A8_UNORM)
+ if (displayImage.format() == VK_FORMAT_B8G8R8A8_UNORM)
{
for (x = 0; x < displayImage.width(); x++) {
swapped = (*row & 0xff00ff00) | (*row & 0x000000ff) << 16 | (*row & 0x00ff0000) >> 16;
@@ -226,7 +226,7 @@
row++;
}
}
- else if (displayImage.format() == VK_FMT_R8G8B8A8_UNORM)
+ else if (displayImage.format() == VK_FORMAT_R8G8B8A8_UNORM)
{
for (x = 0; x < displayImage.width(); x++) {
file.write((char *) row, 3);
@@ -311,7 +311,7 @@
if (!m_show_images) return;
- err = vkGetImageSubresourceInfo( image->image(), &sr, VK_INFO_TYPE_SUBRESOURCE_LAYOUT,
+ err = vkGetImageSubresourceInfo( image->image(), &sr, VK_SUBRESOURCE_INFO_TYPE_LAYOUT,
&data_size, &sr_layout);
ASSERT_VK_SUCCESS( err );
ASSERT_EQ(data_size, sizeof(sr_layout));
@@ -492,7 +492,7 @@
for (int x=0; x < m_images.size(); x++)
{
VK_WSI_X11_PRESENTABLE_IMAGE_CREATE_INFO presentable_image_info = {};
- presentable_image_info.format = VK_FMT_B8G8R8A8_UNORM;
+ presentable_image_info.format = VK_FORMAT_B8G8R8A8_UNORM;
presentable_image_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
presentable_image_info.extent.width = m_display_image->m_width;
presentable_image_info.extent.height = m_display_image->m_height;
@@ -505,7 +505,7 @@
assert(!err);
vk_testing::Buffer buf;
- buf.init(m_device, (VkGpuSize) m_display_image->m_data_size);
+ buf.init(m_device, (VkDeviceSize) m_display_image->m_data_size);
dest_ptr = buf.map();
memcpy(dest_ptr,m_display_image->m_data, m_display_image->m_data_size);
buf.unmap();
@@ -1081,7 +1081,7 @@
//
// Convert VK shader type to compiler's
//
-EShLanguage VkTestFramework::FindLanguage(const VkPipelineShaderStage shader_type)
+EShLanguage VkTestFramework::FindLanguage(const VkShaderStage shader_type)
{
switch (shader_type) {
case VK_SHADER_STAGE_VERTEX:
@@ -1112,7 +1112,7 @@
// Compile a given string containing GLSL into SPV for use by VK
// Return value of false means an error was encountered.
//
-bool VkTestFramework::GLSLtoSPV(const VkPipelineShaderStage shader_type,
+bool VkTestFramework::GLSLtoSPV(const VkShaderStage shader_type,
const char *pshader,
std::vector<unsigned int> &spv)
{
diff --git a/tests/vktestframework.h b/tests/vktestframework.h
index 76f02a1..ba53923 100644
--- a/tests/vktestframework.h
+++ b/tests/vktestframework.h
@@ -63,7 +63,7 @@
int m_height;
void *m_data;
VkImage m_presentableImage;
- VkGpuMemory m_presentableMemory;
+ VkDeviceMemory m_presentableMemory;
unsigned m_data_size;
};
@@ -81,7 +81,7 @@
void Compare(const char *comment, VkImageObj *image);
void RecordImage(VkImageObj * image);
void RecordImages(vector<VkImageObj *> image);
- bool GLSLtoSPV(const VkPipelineShaderStage shader_type,
+ bool GLSLtoSPV(const VkShaderStage shader_type,
const char *pshader,
std::vector<unsigned int> &spv);
static bool m_use_spv;
@@ -96,7 +96,7 @@
void SetMessageOptions(EShMessages& messages);
void ProcessConfigFile();
EShLanguage FindLanguage(const std::string& name);
- EShLanguage FindLanguage(const VkPipelineShaderStage shader_type);
+ EShLanguage FindLanguage(const VkShaderStage shader_type);
std::string ConfigFile;
bool SetConfigFile(const std::string& name);