external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmGraphicsShaderTestUtil.cpp \
external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmInstructionTests.cpp \
external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmTests.cpp \
+ external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmUtils.cpp \
external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutCase.cpp \
external/vulkancts/modules/vulkan/ssbo/vktSSBOLayoutTests.cpp \
external/vulkancts/modules/vulkan/synchronization/vktSynchronizationBasicEventTests.cpp \
VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078001,
VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = 1000078002,
VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = 1000079000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000,
VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMemoryProperties2KHR& value);
std::ostream& operator<< (std::ostream& s, const VkSparseImageFormatProperties2KHR& value);
std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSparseImageFormatInfo2KHR& value);
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevice16BitStorageFeaturesKHR& value);
std::ostream& operator<< (std::ostream& s, const VkRectLayerKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPresentRegionKHR& value);
std::ostream& operator<< (std::ostream& s, const VkPresentRegionsKHR& value);
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX: return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX";
case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX: return "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX";
case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX: return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX";
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR";
case VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX: return "VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX";
case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX: return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX";
case VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX: return "VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX";
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevice16BitStorageFeaturesKHR& value)
+{
+ s << "VkPhysicalDevice16BitStorageFeaturesKHR = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tstorageUniformBufferBlock16 = " << value.storageUniformBufferBlock16 << '\n';
+ s << "\tstorageUniform16 = " << value.storageUniform16 << '\n';
+ s << "\tstoragePushConstant16 = " << value.storagePushConstant16 << '\n';
+ s << "\tstorageInputOutput16 = " << value.storageInputOutput16 << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkRectLayerKHR& value)
{
s << "VkRectLayerKHR = {\n";
VkImageTiling tiling;
};
+struct VkPhysicalDevice16BitStorageFeaturesKHR
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 storageUniformBufferBlock16;
+ VkBool32 storageUniform16;
+ VkBool32 storagePushConstant16;
+ VkBool32 storageInputOutput16;
+};
+
struct VkRectLayerKHR
{
VkOffset2D offset;
vktSpvAsmInstructionTests.hpp
vktSpvAsmTests.cpp
vktSpvAsmTests.hpp
+ vktSpvAsmUtils.cpp
+ vktSpvAsmUtils.hpp
)
set(DEQP_VK_SPIRV_ASSEMBLY_LIBS
throw tcu::NotSupportedError("shaderInt64 feature is not supported");
}
+ {
+ const InstanceInterface& vki = m_context.getInstanceInterface();
+ const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
+
+ // 16bit storage features
+ {
+ if (!is16BitStorageFeaturesSupported(vki, physicalDevice, m_shaderSpec.requestedExtensionFeatures.ext16BitStorage))
+ TCU_THROW(NotSupportedError, "Requested 16bit storage features not supported");
+ }
+ }
+
vector<AllocationSp> inputAllocs;
vector<AllocationSp> outputAllocs;
vector<BufferHandleSp> inputBuffers;
#include "tcuTestLog.hpp"
#include "tcuVector.hpp"
#include "vkMemUtil.hpp"
+#include "vktSpvAsmUtils.hpp"
#include <string>
#include <vector>
std::vector<deUint32> specConstants;
BufferSp pushConstants;
std::vector<std::string> extensions;
+ ExtensionFeatures requestedExtensionFeatures;
qpTestResult failResult;
std::string failMessage;
// If null, a default verification will be performed by comparing the memory pointed to by outputAllocations
ComputeVerifyIOFunc verifyIO;
ComputeShaderSpec (void)
- : entryPoint ("main")
- , pushConstants (DE_NULL)
- , failResult (QP_TEST_RESULT_FAIL)
- , failMessage ("Output doesn't match with expected")
- , verifyIO (DE_NULL)
+ : entryPoint ("main")
+ , pushConstants (DE_NULL)
+ , requestedExtensionFeatures ()
+ , failResult (QP_TEST_RESULT_FAIL)
+ , failMessage ("Output doesn't match with expected")
+ , verifyIO (DE_NULL)
{}
};
const GraphicsResources& resources_,
const GraphicsInterfaces& interfaces_,
const vector<string>& extensions_,
- const vector<string>& features_)
- : testCodeFragments (testCodeFragments_)
- , specConstants (specConstants_)
- , hasTessellation (false)
- , requiredStages (static_cast<VkShaderStageFlagBits>(0))
- , requiredDeviceExtensions (extensions_)
- , requiredDeviceFeatures (features_)
- , pushConstants (pushConsants_)
- , resources (resources_)
- , interfaces (interfaces_)
- , failResult (QP_TEST_RESULT_FAIL)
- , failMessageTemplate ("${reason}")
+ const vector<string>& features_,
+ ExtensionFeatures extensionFeatures_)
+ : testCodeFragments (testCodeFragments_)
+ , specConstants (specConstants_)
+ , hasTessellation (false)
+ , requiredStages (static_cast<VkShaderStageFlagBits>(0))
+ , requiredDeviceExtensions (extensions_)
+ , requiredDeviceFeatures (features_)
+ , requestedExtensionFeatures (extensionFeatures_)
+ , pushConstants (pushConsants_)
+ , resources (resources_)
+ , interfaces (interfaces_)
+ , failResult (QP_TEST_RESULT_FAIL)
+ , failMessageTemplate ("${reason}")
{
inputColors[0] = inputs[0];
inputColors[1] = inputs[1];
}
InstanceContext::InstanceContext (const InstanceContext& other)
- : moduleMap (other.moduleMap)
- , testCodeFragments (other.testCodeFragments)
- , specConstants (other.specConstants)
- , hasTessellation (other.hasTessellation)
- , requiredStages (other.requiredStages)
- , requiredDeviceExtensions (other.requiredDeviceExtensions)
- , requiredDeviceFeatures (other.requiredDeviceFeatures)
- , pushConstants (other.pushConstants)
- , resources (other.resources)
- , interfaces (other.interfaces)
- , failResult (other.failResult)
- , failMessageTemplate (other.failMessageTemplate)
+ : moduleMap (other.moduleMap)
+ , testCodeFragments (other.testCodeFragments)
+ , specConstants (other.specConstants)
+ , hasTessellation (other.hasTessellation)
+ , requiredStages (other.requiredStages)
+ , requiredDeviceExtensions (other.requiredDeviceExtensions)
+ , requiredDeviceFeatures (other.requiredDeviceFeatures)
+ , requestedExtensionFeatures (other.requestedExtensionFeatures)
+ , pushConstants (other.pushConstants)
+ , resources (other.resources)
+ , interfaces (other.interfaces)
+ , failResult (other.failResult)
+ , failMessageTemplate (other.failMessageTemplate)
{
inputColors[0] = other.inputColors[0];
inputColors[1] = other.inputColors[1];
return createBuffer(vk, vkDevice, &resourceBufferParams);
}
-
TestStatus runAndVerifyDefaultPipeline (Context& context, InstanceContext instance)
{
const VkDevice vkDevice = context.getDevice();
+ const VkPhysicalDevice vkPhysicalDevice = context.getPhysicalDevice();
const DeviceInterface& vk = context.getDeviceInterface();
+ const InstanceInterface& vkInstance = context.getInstanceInterface();
const VkQueue queue = context.getUniversalQueue();
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
const tcu::UVec2 renderSize (256, 256);
}
}
+ // 16bit storage features
+ {
+ if (!is16BitStorageFeaturesSupported(vkInstance, vkPhysicalDevice, instance.requestedExtensionFeatures.ext16BitStorage))
+ TCU_THROW(NotSupportedError, "Requested 16bit storage features not supported");
+ }
+
de::Random(seed).shuffle(instance.inputColors, instance.inputColors+4);
de::Random(seed).shuffle(instance.outputColors, instance.outputColors+4);
const Vec4 vertexData[] =
const GraphicsInterfaces& interfaces,
const vector<string>& extensions,
const vector<string>& features,
+ ExtensionFeatures extensionFeatures,
tcu::TestCaseGroup* tests,
const qpTestResult failResult,
const string& failMessageTemplate)
addFunctionCaseWithPrograms<InstanceContext>(
tests, name + "_vert", "", addShaderCodeCustomVertex, runAndVerifyDefaultPipeline,
createInstanceContext(vertFragPipelineStages, inputColors, outputColors, testCodeFragments,
- specConstantMap, pushConstants, resources, interfaces, extensions, features, failResult, failMessageTemplate));
+ specConstantMap, pushConstants, resources, interfaces, extensions, features, extensionFeatures, failResult, failMessageTemplate));
specConstantMap.clear();
specConstantMap[VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT] = specConstants;
addFunctionCaseWithPrograms<InstanceContext>(
tests, name + "_tessc", "", addShaderCodeCustomTessControl, runAndVerifyDefaultPipeline,
createInstanceContext(tessPipelineStages, inputColors, outputColors, testCodeFragments,
- specConstantMap, pushConstants, resources, interfaces, extensions, features, failResult, failMessageTemplate));
+ specConstantMap, pushConstants, resources, interfaces, extensions, features, extensionFeatures, failResult, failMessageTemplate));
specConstantMap.clear();
specConstantMap[VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT] = specConstants;
addFunctionCaseWithPrograms<InstanceContext>(
tests, name + "_tesse", "", addShaderCodeCustomTessEval, runAndVerifyDefaultPipeline,
createInstanceContext(tessPipelineStages, inputColors, outputColors, testCodeFragments,
- specConstantMap, pushConstants, resources, interfaces, extensions, features, failResult, failMessageTemplate));
+ specConstantMap, pushConstants, resources, interfaces, extensions, features, extensionFeatures, failResult, failMessageTemplate));
specConstantMap.clear();
specConstantMap[VK_SHADER_STAGE_GEOMETRY_BIT] = specConstants;
addFunctionCaseWithPrograms<InstanceContext>(
tests, name + "_geom", "", addShaderCodeCustomGeometry, runAndVerifyDefaultPipeline,
createInstanceContext(geomPipelineStages, inputColors, outputColors, testCodeFragments,
- specConstantMap, pushConstants, resources, interfaces, extensions, features, failResult, failMessageTemplate));
+ specConstantMap, pushConstants, resources, interfaces, extensions, features, extensionFeatures, failResult, failMessageTemplate));
specConstantMap.clear();
specConstantMap[VK_SHADER_STAGE_FRAGMENT_BIT] = specConstants;
addFunctionCaseWithPrograms<InstanceContext>(
tests, name + "_frag", "", addShaderCodeCustomFragment, runAndVerifyDefaultPipeline,
createInstanceContext(vertFragPipelineStages, inputColors, outputColors, testCodeFragments,
- specConstantMap, pushConstants, resources, interfaces, extensions, features, failResult, failMessageTemplate));
+ specConstantMap, pushConstants, resources, interfaces, extensions, features, extensionFeatures, failResult, failMessageTemplate));
}
void addTessCtrlTest(tcu::TestCaseGroup* group, const char* name, const map<string, string>& fragments)
runAndVerifyDefaultPipeline, createInstanceContext(
pipelineStages, defaultColors, defaultColors, fragments,
StageToSpecConstantMap(), PushConstants(), GraphicsResources(),
- GraphicsInterfaces(), vector<string>(), vector<string>()));
+ GraphicsInterfaces(), vector<string>(), vector<string>(),
+ ExtensionFeatures()));
}
} // SpirVAssembly
#include "vkPrograms.hpp"
#include "vktSpvAsmComputeShaderTestUtil.hpp"
+#include "vktSpvAsmUtils.hpp"
#include "vktTestCaseUtil.hpp"
#include "deRandom.hpp"
vk::VkShaderStageFlagBits requiredStages;
std::vector<std::string> requiredDeviceExtensions;
std::vector<std::string> requiredDeviceFeatures;
+ ExtensionFeatures requestedExtensionFeatures;
PushConstants pushConstants;
// Possible resources used by the graphics pipeline.
// If it is not empty, a single descriptor set (number 0) will be allocated
const GraphicsResources& resources_,
const GraphicsInterfaces& interfaces_,
const std::vector<std::string>& extensions_,
- const std::vector<std::string>& features_);
+ const std::vector<std::string>& features_,
+ ExtensionFeatures extFeatures_);
InstanceContext (const InstanceContext& other);
const GraphicsInterfaces& interfaces,
const std::vector<std::string>& extensions,
const std::vector<std::string>& features,
+ ExtensionFeatures extensionFeatures,
const qpTestResult failResult = QP_TEST_RESULT_FAIL,
const std::string& failMessageTemplate = std::string())
{
- InstanceContext ctx (inputColors, outputColors, testCodeFragments, specConstants, pushConstants, resources, interfaces, extensions, features);
+ InstanceContext ctx (inputColors, outputColors, testCodeFragments, specConstants, pushConstants, resources, interfaces, extensions, features, extensionFeatures);
for (size_t i = 0; i < N; ++i)
{
ctx.moduleMap[elements[i].moduleName].push_back(std::make_pair(elements[i].entryName, elements[i].stage));
{
return createInstanceContext(elements, inputColors, outputColors, testCodeFragments,
StageToSpecConstantMap(), PushConstants(), GraphicsResources(),
- GraphicsInterfaces(), std::vector<std::string>(), std::vector<std::string>());
+ GraphicsInterfaces(), std::vector<std::string>(), std::vector<std::string>(),
+ ExtensionFeatures());
}
// The same as createInstanceContext above, but with default colors.
const GraphicsInterfaces& interfaces,
const std::vector<std::string>& extensions,
const std::vector<std::string>& features,
+ ExtensionFeatures extensionFeatures,
tcu::TestCaseGroup* tests,
const qpTestResult failResult = QP_TEST_RESULT_FAIL,
const std::string& failMessageTemplate = std::string());
createTestsForAllStages(
name, inputColors, outputColors, testCodeFragments, noSpecConstants, noPushConstants,
- noResources, noInterfaces, noExtensions, noFeatures, tests, failResult, failMessageTemplate);
+ noResources, noInterfaces, noExtensions, noFeatures, ExtensionFeatures(),
+ tests, failResult, failMessageTemplate);
}
inline void createTestsForAllStages (const std::string& name,
createTestsForAllStages(
name, inputColors, outputColors, testCodeFragments, specConstants, noPushConstants,
- noResources, noInterfaces, noExtensions, noFeatures, tests, failResult, failMessageTemplate);
+ noResources, noInterfaces, noExtensions, noFeatures, ExtensionFeatures(),
+ tests, failResult, failMessageTemplate);
}
inline void createTestsForAllStages (const std::string& name,
const GraphicsResources& resources,
const std::vector<std::string>& extensions,
tcu::TestCaseGroup* tests,
+ ExtensionFeatures extensionFeatures = ExtensionFeatures(),
const qpTestResult failResult = QP_TEST_RESULT_FAIL,
const std::string& failMessageTemplate = std::string())
{
createTestsForAllStages(
name, inputColors, outputColors, testCodeFragments, noSpecConstants, noPushConstants,
- resources, noInterfaces, extensions, noFeatures, tests, failResult, failMessageTemplate);
+ resources, noInterfaces, extensions, noFeatures, extensionFeatures,
+ tests, failResult, failMessageTemplate);
}
inline void createTestsForAllStages (const std::string& name,
const GraphicsInterfaces interfaces,
const std::vector<std::string>& extensions,
tcu::TestCaseGroup* tests,
+ ExtensionFeatures extensionFeatures = ExtensionFeatures(),
const qpTestResult failResult = QP_TEST_RESULT_FAIL,
const std::string& failMessageTemplate = std::string())
{
createTestsForAllStages(
name, inputColors, outputColors, testCodeFragments, noSpecConstants, noPushConstants,
- noResources, interfaces, extensions, noFeatures, tests, failResult, failMessageTemplate);
+ noResources, interfaces, extensions, noFeatures, extensionFeatures,
+ tests, failResult, failMessageTemplate);
}
inline void createTestsForAllStages (const std::string& name,
const GraphicsResources& resources,
const std::vector<std::string>& extensions,
tcu::TestCaseGroup* tests,
+ ExtensionFeatures extensionFeatures = ExtensionFeatures(),
const qpTestResult failResult = QP_TEST_RESULT_FAIL,
const std::string& failMessageTemplate = std::string())
{
createTestsForAllStages(
name, inputColors, outputColors, testCodeFragments, noSpecConstants, pushConstants,
- resources, noInterfaces, extensions, noFeatures, tests, failResult, failMessageTemplate);
+ resources, noInterfaces, extensions, noFeatures, extensionFeatures,
+ tests, failResult, failMessageTemplate);
}
// Sets up and runs a Vulkan pipeline, then spot-checks the resulting image.
--- /dev/null
+/*-------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Utilities for Vulkan SPIR-V assembly tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktSpvAsmUtils.hpp"
+
+#include "deMemory.h"
+
+namespace vkt
+{
+namespace SpirVAssembly
+{
+
+using namespace vk;
+
+bool is16BitStorageFeaturesSupported (const InstanceInterface& vki, VkPhysicalDevice device, Extension16BitStorageFeatures toCheck)
+{
+ VkPhysicalDevice16BitStorageFeaturesKHR extensionFeatures =
+ {
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, // sType
+ DE_NULL, // pNext
+ false, // storageUniformBufferBlock16
+ false, // storageUniform16
+ false, // storagePushConstant16
+ false, // storageInputOutput16
+ };
+ VkPhysicalDeviceFeatures2KHR features;
+
+ deMemset(&features, 0, sizeof(features));
+ features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+ features.pNext = &extensionFeatures;
+
+ vki.getPhysicalDeviceFeatures2KHR(device, &features);
+
+ if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK) != 0 && extensionFeatures.storageUniformBufferBlock16 == VK_FALSE)
+ return false;
+
+ if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM) != 0 && extensionFeatures.storageUniform16 == VK_FALSE)
+ return false;
+
+ if ((toCheck & EXT16BITSTORAGEFEATURES_PUSH_CONSTANT) != 0 && extensionFeatures.storagePushConstant16 == VK_FALSE)
+ return false;
+
+ if ((toCheck & EXT16BITSTORAGEFEATURES_INPUT_OUTPUT) != 0 && extensionFeatures.storageInputOutput16 == VK_FALSE)
+ return false;
+
+ return true;
+}
+
+} // SpirVAssembly
+} // vkt
--- /dev/null
+#ifndef _VKTSPVASMUTILS_HPP
+#define _VKTSPVASMUTILS_HPP
+/*-------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *//*!
+ * \file
+ * \brief Utilities for Vulkan SPIR-V assembly tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vkDefs.hpp"
+#include "vkTypeUtil.hpp"
+
+namespace vkt
+{
+namespace SpirVAssembly
+{
+
+enum Extension16BitStorageFeatureBits
+{
+ EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK = (1u << 1),
+ EXT16BITSTORAGEFEATURES_UNIFORM = (1u << 2),
+ EXT16BITSTORAGEFEATURES_PUSH_CONSTANT = (1u << 3),
+ EXT16BITSTORAGEFEATURES_INPUT_OUTPUT = (1u << 4),
+};
+typedef deUint32 Extension16BitStorageFeatures;
+
+struct ExtensionFeatures
+{
+ Extension16BitStorageFeatures ext16BitStorage;
+
+ ExtensionFeatures (void)
+ : ext16BitStorage (0)
+ {}
+ explicit ExtensionFeatures (Extension16BitStorageFeatures ext16BitStorage_)
+ : ext16BitStorage (ext16BitStorage_)
+ {}
+};
+
+// Returns true if the given 16bit storage extension features in `toCheck` are all supported.
+bool is16BitStorageFeaturesSupported (const vk::InstanceInterface& vkInstance,
+ vk::VkPhysicalDevice device,
+ Extension16BitStorageFeatures toCheck);
+
+} // SpirVAssembly
+} // vkt
+
+#endif // _VKTSPVASMUTILS_HPP
VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078001,
VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = 1000078002,
VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = 1000079000,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000,
VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
VkCommandPoolTrimFlagsKHR flags);
#endif
+#define VK_KHR_16bit_storage 1
+#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
+#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
+
+typedef struct VkPhysicalDevice16BitStorageFeaturesKHR {
+ VkStructureType sType;
+ const void* pNext;
+ VkBool32 storageUniformBufferBlock16;
+ VkBool32 storageUniform16;
+ VkBool32 storagePushConstant16;
+ VkBool32 storageInputOutput16;
+} VkPhysicalDevice16BitStorageFeaturesKHR;
+
#define VK_KHR_incremental_present 1
#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
projects / platform / upstream / VK-GL-CTS.git / commitdiff