commit 3229e63406d8805cbf70d74a0394412e5699d6d7 Author: Danny Robson Date: Wed Feb 24 11:11:41 2016 +1100 initial import diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7eff626 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +/aclocal.m4 +/autom4te.cache/ +/build-aux/ +/configure +*.in +/m4/libtool.m4 +/m4/lt*.m4 diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..67dde66 --- /dev/null +++ b/AUTHORS @@ -0,0 +1 @@ +Danny Robson diff --git a/Makefile.am b/Makefile.am new file mode 100644 index 0000000..62eb42e --- /dev/null +++ b/Makefile.am @@ -0,0 +1,58 @@ +AUTOMAKE_OPTIONS = dist-bzip2 dist-xz subdir-objects +ACLOCAL_AMFLAGS = -I m4 + +AM_CXXFLAGS = $(UTIL_CRUFT_CFLAGS) + +DEFAULT_INCLUDES = -I${top_srcdir} -I${top_builddir} -I${top_builddir}/vk +noinst_LIBRARIES = libcruft-vk.a + +SUFFIXES = .hpp.xml .hpp + +vk.hpp: vk.xml vk.xsl + $(XSLTPROC) $(XSLTFLAGS) -o $(builddir)/$@ $(srcdir)/vk.xsl $(srcdir)/vk.xml + +EXTRA_DIST = vk.xml vk.xsl +#BUILT_SOURCES = vk.hpp + +libcruft_vk_a_SOURCES = \ + vk.hpp \ + fwd.hpp \ + object.cpp \ + object.hpp \ + buffer.cpp \ + buffer.hpp \ + command_buffer.cpp \ + command_buffer.hpp \ + command_pool.cpp \ + command_pool.hpp \ + device.cpp \ + device.hpp \ + device_memory.cpp \ + device_memory.hpp \ + event.cpp \ + event.hpp \ + except.cpp \ + except.hpp \ + fence.cpp \ + fence.hpp \ + framebuffer.cpp \ + framebuffer.hpp \ + instance.cpp \ + instance.hpp \ + image.cpp \ + image.hpp \ + physical_device.cpp \ + physical_device.hpp \ + pipeline.cpp \ + pipeline.hpp \ + pipeline_cache.cpp \ + pipeline_cache.hpp \ + queue.cpp \ + queue.hpp \ + render_pass.cpp \ + render_pass.hpp \ + semaphore.cpp \ + semaphore.hpp \ + shader_module.cpp \ + shader_module.hpp \ + traits.hpp diff --git a/buffer.cpp b/buffer.cpp new file mode 100644 index 0000000..d67bc13 --- /dev/null +++ b/buffer.cpp @@ -0,0 +1,7 @@ +#include "./buffer.hpp" + +using vk::buffer; + + +/////////////////////////////////////////////////////////////////////////////// + diff --git a/buffer.hpp b/buffer.hpp new file mode 100644 index 0000000..cafead1 --- /dev/null +++ b/buffer.hpp @@ -0,0 +1,13 @@ +#ifndef __VK_BUFFER_HPP +#define __VK_BUFFER_HPP + +#include "./object.hpp" +#include "./fwd.hpp" + +namespace vk { + struct buffer : public owned { + + }; +} + +#endif diff --git a/command_buffer.cpp b/command_buffer.cpp new file mode 100644 index 0000000..4eafafe --- /dev/null +++ b/command_buffer.cpp @@ -0,0 +1,108 @@ +#include "./command_buffer.hpp" + +#include "./event.hpp" +#include "./pipeline.hpp" + +using vk::command_buffer; + + +/////////////////////////////////////////////////////////////////////////////// +void +command_buffer::reset (VkCommandBufferResetFlags flags) +{ + auto err = vkResetCommandBuffer (id (), flags); + error::try_code (err); +} + + +/////////////////////////////////////////////////////////////////////////////// +void +command_buffer::begin (const VkCommandBufferBeginInfo &info) +{ + auto err = vkBeginCommandBuffer (id (), &info); + error::try_code (err); +} + + +//----------------------------------------------------------------------------- +void +command_buffer::begin (const VkRenderPassBeginInfo &info, VkSubpassContents contents) +{ + vkCmdBeginRenderPass (id (), &info, contents); +} + + +//----------------------------------------------------------------------------- +void +command_buffer::end (void) +{ + auto err = vkEndCommandBuffer (id ()); + error::try_code (err); +} + + +//----------------------------------------------------------------------------- +void +command_buffer::end_pass (void) +{ + vkCmdEndRenderPass (id ()); +} + + +/////////////////////////////////////////////////////////////////////////////// +template +void +command_buffer::execute (const command_buffer (&buffers)[N]) +{ + vkCmdExecuteCOmmands (id (), N, buffers); +} + + +//----------------------------------------------------------------------------- +void +command_buffer::next_subpass (const VkSubpassContents contents) +{ + vkCmdNextSubpass (id (), contents); +} + + +/////////////////////////////////////////////////////////////////////////////// +void +command_buffer::bind (VkPipelineBindPoint point, const pipeline &p) +{ + vkCmdBindPipeline (id (), point, p.id ()); +} + + +/////////////////////////////////////////////////////////////////////////////// +void +command_buffer::set (const event &ev, VkPipelineStageFlags flags) +{ + vkCmdSetEvent (id (), ev.id (), flags); +} + + +//----------------------------------------------------------------------------- +void +command_buffer::reset (const event &ev, VkPipelineStageFlags flags) +{ + vkCmdResetEvent (id (), ev.id (), flags); +} + + +//----------------------------------------------------------------------------- +void +command_buffer::wait (util::view events, + VkPipelineStageFlags src_mask, + VkPipelineStageFlags dst_mask, + util::view VkMemoryBarriers, + util::view VkBufferMemoryBarriers, + util::view VkImageMemoryBarriers) +{ + vkCmdWaitEvents (id (), + events.size (), &events.cbegin ()->id (), + src_mask, dst_mask, + VkMemoryBarriers.size (), VkMemoryBarriers.cbegin (), + VkBufferMemoryBarriers.size (), VkBufferMemoryBarriers.cbegin (), + VkImageMemoryBarriers.size (), VkImageMemoryBarriers.cbegin ()); +} diff --git a/command_buffer.hpp b/command_buffer.hpp new file mode 100644 index 0000000..0329ac8 --- /dev/null +++ b/command_buffer.hpp @@ -0,0 +1,44 @@ +#ifndef __VK_COMMAND_BUFFER_HPP +#define __VK_COMMAND_BUFFER_HPP + +#include "./object.hpp" + +#include + +namespace vk { + struct command_buffer : public owned { + void reset (VkCommandBufferResetFlags); + + void begin (const VkCommandBufferBeginInfo&); + void begin (const VkRenderPassBeginInfo&, VkSubpassContents); + void end (void); + void end_pass (void); + + template + void execute (const command_buffer (&buffers)[N]); + + void next_subpass (VkSubpassContents); + + void bind (VkPipelineBindPoint, const pipeline&); + + void set (const event&, VkPipelineStageFlags); + void reset (const event&, VkPipelineStageFlags); + + void wait (util::view, + VkPipelineStageFlags src_mask, + VkPipelineStageFlags dst_mask, + util::view, + util::view, + util::view); + + void pipeline_barrier ( + VkPipelineStageFlags src_mask, + VkPipelineStageFlags dst_mask, + VkDependencyFlags, + util::view, + util::view, + util::view); + }; +} + +#endif diff --git a/command_pool.cpp b/command_pool.cpp new file mode 100644 index 0000000..9720831 --- /dev/null +++ b/command_pool.cpp @@ -0,0 +1,14 @@ +#include "./command_pool.hpp" + +#include "./device.hpp" + +using vk::command_pool; + + +/////////////////////////////////////////////////////////////////////////////// +void +command_pool::reset (const device &dev, VkCommandPoolResetFlags flags) +{ + auto err = vkResetCommandPool (dev.id (), id (), flags); + error::try_code (err); +} diff --git a/command_pool.hpp b/command_pool.hpp new file mode 100644 index 0000000..bd899a6 --- /dev/null +++ b/command_pool.hpp @@ -0,0 +1,12 @@ +#ifndef __VK_COMMAND_POOL_HPP +#define __VK_COMMAND_POOL_HPP + +#include "./object.hpp" + +namespace vk { + struct command_pool : public owned { + void reset (const device&, VkCommandPoolResetFlags); + }; +} + +#endif diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000..751df20 --- /dev/null +++ b/configure.ac @@ -0,0 +1,57 @@ +AC_INIT([vk-cruft], [0.0.1], [danny@nerdcruft.net], [], [http://nerdcruft.net/]) +## Explicitly set an empty CXXFLAGS if not present to prevent AC_PROG_CXX from +## generating a default -O2. This allows us to manually select -O0 when +## debugging is enabled. +: ${CXXFLAGS=""} + +############################################################################### +## Build environment discovery + +AC_CONFIG_AUX_DIR([build-aux]) +AC_CONFIG_MACRO_DIR([m4]) + +AC_USE_SYSTEM_EXTENSIONS +AC_CANONICAL_HOST + +AC_LANG([C++]) + +NC_CXX +NC_PLATFORM +NC_OPTIMISATION +NC_WARNINGS +NC_DEBUGGING + +LT_INIT + +AM_INIT_AUTOMAKE([1.14 foreign dist-xz dist-bzip2 subdir-objects]) +AM_SILENT_RULES([yes]) + +AC_CONFIG_HEADERS([config.h]) + +AX_CHECK_GNU_MAKE + + +############################################################################### +## Required build packages + +AC_CHECK_PROGS([XSLTPROC], [xsltproc], [false]) +AS_IF([test "x$XSLTPROC" == "xfalse"], [ + AC_MSG_ERROR([Cannot find xsltproc]) +]) + + +############################################################################### +## Required packages + +PKG_CHECK_MODULES([UTIL_CRUFT], [libcruft-util >= 0]) +AC_SUBST([UTIL_CRUFT_CFLAGS]) +AC_SUBST([UTIL_CRUFT_LIBS]) + + +############################################################################### +## Output + +AX_APPEND_FLAG([-include config.h]) + +AC_CONFIG_FILES([libcruft-vk.pc Makefile]) +AC_OUTPUT diff --git a/device.cpp b/device.cpp new file mode 100644 index 0000000..1f8a8b3 --- /dev/null +++ b/device.cpp @@ -0,0 +1,43 @@ +#include "./device.hpp" + +#include "./physical_device.hpp" + +using vk::device; + + +/////////////////////////////////////////////////////////////////////////////// +device::device (const physical_device &phys, + const VkDeviceCreateInfo &info): + instantiated (phys.id (), &info, nullptr) +{ ; } + + +/////////////////////////////////////////////////////////////////////////////// +VkPhysicalDeviceMemoryProperties +device::physical_properties (void) const +{ + VkPhysicalDeviceMemoryProperties props; + vkGetPhysicalDeviceMemoryProperties (id (), &props); + return props; +} + + +/////////////////////////////////////////////////////////////////////////////// +void +device::flush (const VkMappedMemoryRange *first, + const VkMappedMemoryRange *last) +{ + auto err = vkFlushMappedMemoryRanges (id (), last - first, first); + error::try_code (err); +} + + +//----------------------------------------------------------------------------- +void +device::invalidate (const VkMappedMemoryRange *first, + const VkMappedMemoryRange *last) +{ + auto err = vkInvalidateMappedMemoryRanges (id (), last - first, first); + error::try_code (err); +} + diff --git a/device.hpp b/device.hpp new file mode 100644 index 0000000..f0aa35d --- /dev/null +++ b/device.hpp @@ -0,0 +1,24 @@ +#ifndef __VK_DEVICE_HPP +#define __VK_DEVICE_HPP + +#include "./object.hpp" + +#include "./fwd.hpp" + +namespace vk { + struct device : public instantiated { + device (const physical_device&, + const VkDeviceCreateInfo&); + + VkPhysicalDeviceMemoryProperties + physical_properties (void) const; + + void flush (const VkMappedMemoryRange *first, + const VkMappedMemoryRange *last); + + void invalidate (const VkMappedMemoryRange *first, + const VkMappedMemoryRange *last); + }; +} + +#endif diff --git a/device_memory.cpp b/device_memory.cpp new file mode 100644 index 0000000..2a1962a --- /dev/null +++ b/device_memory.cpp @@ -0,0 +1,39 @@ +#include "./device_memory.hpp" + +#include "./device.hpp" + +using vk::device_memory; + + +/////////////////////////////////////////////////////////////////////////////// +void* +device_memory::map (const device &dev, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags) +{ + void *res; + + auto err = vkMapMemory (dev.id (), id (), offset, size, flags, &res); + error::try_code (err); + + return res; +} + + +//----------------------------------------------------------------------------- +void +device_memory::unmap (const device &dev) +{ + vkUnmapMemory (dev.id (), id ()); +} + + +/////////////////////////////////////////////////////////////////////////////// +VkDeviceSize +device_memory::commitment (const device &dev) const +{ + VkDeviceSize size; + vkGetDeviceMemoryCommitment (dev.id (), id (), &size); + return size; +} diff --git a/device_memory.hpp b/device_memory.hpp new file mode 100644 index 0000000..6106d76 --- /dev/null +++ b/device_memory.hpp @@ -0,0 +1,20 @@ +#ifndef __VK_DEVICE_MEMORY_HPP +#define __VK_DEVICE_MEMORY_HPP + +#include "./object.hpp" +#include "./fwd.hpp" + +namespace vk { + struct device_memory : public owned { + void* map (const device&, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags); + + void unmap (const device&); + + VkDeviceSize commitment (const device&) const; + }; +} + +#endif diff --git a/event.cpp b/event.cpp new file mode 100644 index 0000000..4f37b43 --- /dev/null +++ b/event.cpp @@ -0,0 +1,33 @@ +#include "./event.hpp" + +#include "./device.hpp" + +using vk::event; + + +/////////////////////////////////////////////////////////////////////////////// +bool +event::is_set (const device &dev) const +{ + auto res = vkGetEventStatus (dev.id (), id ()); + error::try_code (res); + return res == VK_EVENT_SET; +} + + +//----------------------------------------------------------------------------- +void +event::set (const device &dev) +{ + auto err = vkSetEvent (dev.id (), id ()); + error::try_code (err); +} + + +//----------------------------------------------------------------------------- +void +event::reset (const device &dev) +{ + auto err = vkResetEvent (dev.id (), id ()); + error::try_code (err); +} diff --git a/event.hpp b/event.hpp new file mode 100644 index 0000000..38b7713 --- /dev/null +++ b/event.hpp @@ -0,0 +1,16 @@ +#ifndef __VK_EVENT_HPP +#define __VK_EVENT_HPP + +#include "./object.hpp" +#include "./fwd.hpp" + +namespace vk { + struct event : public owned { + bool is_set (const device&) const; + + void set (const device&); + void reset (const device&); + }; +} + +#endif diff --git a/except.cpp b/except.cpp new file mode 100644 index 0000000..5efe218 --- /dev/null +++ b/except.cpp @@ -0,0 +1,48 @@ +#include "./except.hpp" + +#include + +using vk::error; + + +/////////////////////////////////////////////////////////////////////////////// +void +error::try_code (VkResult res) +{ + if (__builtin_expect (res >= 0, true)) + return; + + throw_code (res); +} + + +//----------------------------------------------------------------------------- +void +error::throw_code (VkResult res) +{ + switch (res) { + case VK_SUCCESS: throw error_code (); + + // partial successes + case VK_NOT_READY: throw error_code (); + case VK_TIMEOUT: throw error_code (); + case VK_EVENT_SET: throw error_code (); + case VK_EVENT_RESET: throw error_code (); + case VK_INCOMPLETE: throw error_code (); + + // errors + case VK_ERROR_OUT_OF_HOST_MEMORY: throw error_code (); + case VK_ERROR_OUT_OF_DEVICE_MEMORY: throw error_code (); + case VK_ERROR_INITIALIZATION_FAILED: throw error_code (); + case VK_ERROR_DEVICE_LOST: throw error_code (); + case VK_ERROR_MEMORY_MAP_FAILED: throw error_code (); + case VK_ERROR_LAYER_NOT_PRESENT: throw error_code (); + case VK_ERROR_EXTENSION_NOT_PRESENT: throw error_code (); + case VK_ERROR_FEATURE_NOT_PRESENT: throw error_code (); + case VK_ERROR_INCOMPATIBLE_DRIVER: throw error_code (); + case VK_ERROR_TOO_MANY_OBJECTS: throw error_code (); + case VK_ERROR_FORMAT_NOT_SUPPORTED: throw error_code (); + } + + unreachable (); +} diff --git a/except.hpp b/except.hpp new file mode 100644 index 0000000..b725b0a --- /dev/null +++ b/except.hpp @@ -0,0 +1,23 @@ +#ifndef __VK_EXCEPT_HPP +#define __VK_EXCEPT_HPP + +#include "./vk.hpp" + +#include + +namespace vk { + class error : public std::exception { + public: + static void try_code (VkResult); + static void throw_code [[noreturn]] (VkResult); + }; + + + template + class error_code : public error { + public: + const char* what (void) const noexcept override; + }; +} + +#endif diff --git a/fence.cpp b/fence.cpp new file mode 100644 index 0000000..566d26b --- /dev/null +++ b/fence.cpp @@ -0,0 +1,39 @@ +#include "./fence.hpp" + +#include "./device.hpp" + +using vk::fence; + + +/////////////////////////////////////////////////////////////////////////////// +bool +fence::is_ready (const device &dev) +{ + auto res = vkGetFenceStatus (dev.id (), id ()); + error::try_code (res); + return res == VK_SUCCESS; +} + + +/////////////////////////////////////////////////////////////////////////////// +void +fence::reset (const device &dev, fence *first, fence *last) +{ + vkResetFences (dev.id (), last - first, &first->id ()); +} + + +//----------------------------------------------------------------------------- +void +fence::wait (const device &d, fence *first, fence *last, uint64_t timeout) +{ + vkWaitForFences (d.id (), last - first, &first->id (), VK_FALSE, timeout); +} + + +//----------------------------------------------------------------------------- +void +fence::wait_all (const device &d, fence *first, fence *last, uint64_t timeout) +{ + vkWaitForFences (d.id (), last - first, &first->id (), VK_TRUE, timeout); +} diff --git a/fence.hpp b/fence.hpp new file mode 100644 index 0000000..a74990c --- /dev/null +++ b/fence.hpp @@ -0,0 +1,16 @@ +#ifndef __VK_FENCE_HPP +#define __VK_FENCE_HPP + +#include "./object.hpp" + +namespace vk { + struct fence : owned { + bool is_ready (const device &dev); + + static void reset (const device&, fence *first, fence *last); + static void wait (const device&, fence *first, fence *last, uint64_t timeout); + static void wait_all (const device&, fence *first, fence *last, uint64_t timeout); + }; +} + +#endif diff --git a/framebuffer.cpp b/framebuffer.cpp new file mode 100644 index 0000000..06043d6 --- /dev/null +++ b/framebuffer.cpp @@ -0,0 +1,15 @@ +#include "./framebuffer.hpp" + +#include "./device.hpp" + +using vk::framebuffer; + + +/////////////////////////////////////////////////////////////////////////////// +VkExtent2D +framebuffer::area_granularity (const device &dev) const +{ + VkExtent2D extent; + vkGetRenderAreaGranularity (dev.id (), id (), &extent); + return extent; +} diff --git a/framebuffer.hpp b/framebuffer.hpp new file mode 100644 index 0000000..8e8af7f --- /dev/null +++ b/framebuffer.hpp @@ -0,0 +1,12 @@ +#ifndef __VK_FRAMEBUFFER_HPP +#define __VK_FRAMEBUFFER_HPP + +#include "./object.hpp" + +namespace vk { + struct framebuffer : public owned { + VkExtent2D area_granularity (const device&) const; + }; +} + +#endif diff --git a/fwd.hpp b/fwd.hpp new file mode 100644 index 0000000..a8dcaf2 --- /dev/null +++ b/fwd.hpp @@ -0,0 +1,33 @@ +#ifndef __VK_FWD_HPP +#define __VK_FWD_HPP + +#include "./vk.hpp" + +namespace vk { + template struct instantiated; + template struct enumerated; + template struct owned; + + struct instance; + struct physical_device; + struct device; + struct queue; + struct command_pool; + struct command_buffer; + struct fence; + struct semaphore; + struct event; + struct render_pass; + struct framebuffer; + struct shader_module; + struct pipeline; + struct pipeline_cache; + struct device_memory; + struct buffer; + struct buffer_view; + + class error; + template class error_code; +} + +#endif diff --git a/image.cpp b/image.cpp new file mode 100644 index 0000000..eb2b360 --- /dev/null +++ b/image.cpp @@ -0,0 +1 @@ +#include "./image.hpp" diff --git a/image.hpp b/image.hpp new file mode 100644 index 0000000..7e075f1 --- /dev/null +++ b/image.hpp @@ -0,0 +1,8 @@ +#ifndef __VK_IMAGE_HPP +#define __VK_IMAGE_HPP + +namespace vk { + +} + +#endif diff --git a/instance.cpp b/instance.cpp new file mode 100644 index 0000000..b19c5d6 --- /dev/null +++ b/instance.cpp @@ -0,0 +1,9 @@ +#include "./instance.hpp" + +using vk::instance; + + +/////////////////////////////////////////////////////////////////////////////// +instance::instance (const VkInstanceCreateInfo &info): + instantiated (&info, nullptr) +{ ; } diff --git a/instance.hpp b/instance.hpp new file mode 100644 index 0000000..bdbd9bc --- /dev/null +++ b/instance.hpp @@ -0,0 +1,15 @@ +#ifndef __VK_INSTANCE_HPP +#define __VK_INSTANCE_HPP + +#include "./object.hpp" + +#include "./vk.hpp" +#include "./traits.hpp" + +namespace vk { + struct instance : public instantiated { + instance (const VkInstanceCreateInfo &info); + }; +} + +#endif diff --git a/m4/nc_append_one_compile_flag.m4 b/m4/nc_append_one_compile_flag.m4 new file mode 100644 index 0000000..967dd0e --- /dev/null +++ b/m4/nc_append_one_compile_flag.m4 @@ -0,0 +1,25 @@ +# SYNOPSIS +# +# NC_APPEND_ONE_COMPILE_FLAG([FLAG1 FLAG2 ...], [FLAGS-VARIABLE], [EXTRA-FLAGS]) +# +# DESCRIPTION +# +# Append the first valid compilation flag in the provided list to FLAGS-VARIABLE + + +AC_DEFUN([NC_APPEND_ONE_COMPILE_FLAG], [ + AX_REQUIRE_DEFINED([AX_CHECK_COMPILE_FLAG]) + AX_REQUIRE_DEFINED([AX_APPEND_FLAG]) + + for __dummy in "1"; do + for flag in $1; do + AX_CHECK_COMPILE_FLAG([$flag], + [AX_APPEND_FLAG([$flag], [$2]) + break 2], + [], + [$3]) + done + + AC_MSG_ERROR([unable to find a valid compilation flag in '$1']) + done +]) diff --git a/m4/nc_cxx.m4 b/m4/nc_cxx.m4 new file mode 100644 index 0000000..b7faa3b --- /dev/null +++ b/m4/nc_cxx.m4 @@ -0,0 +1,27 @@ +AC_DEFUN([NC_CXX],[ + AX_CHECK_COMPILE_FLAG( + [-std=c++1z], + [AX_APPEND_FLAG([-std=c++1z], [CXXFLAGS])], + [AC_ERROR([Unable to enable c++1z])] + ) + + AX_APPEND_COMPILE_FLAGS([-pipe], [], [-Werror]) + + AX_APPEND_COMPILE_FLAGS([-fno-deduce-init-list], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-fno-deduce-init-list], [], [-Werror]) + + AC_C_CONST + AC_C_RESTRICT + AC_C_INLINE + + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([struct A { virtual void C (void) = 0; }; + struct B : A { void C (void) override; }; ], + [])], + [], [AC_DEFINE([override], [], [Pretend about override keyword support])]) + + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([struct A final { }; ], + [])], + [], [AC_DEFINE([final], [], [Pretend about final keyword support])]) + + AX_APPEND_COMPILE_FLAGS([-fvisibility=hidden], [], [-Werror]) +]) diff --git a/m4/nc_debugging.m4 b/m4/nc_debugging.m4 new file mode 100644 index 0000000..207505d --- /dev/null +++ b/m4/nc_debugging.m4 @@ -0,0 +1,72 @@ +AC_DEFUN([NC_DEBUGGING],[ + ##------------------------------------------------------------------------- + AX_REQUIRE_DEFINED([AS_HELP_STRING]) + AX_REQUIRE_DEFINED([AX_APPEND_COMPILE_FLAGS]) + AX_REQUIRE_DEFINED([AX_APPEND_LINK_FLAGS]) + AX_REQUIRE_DEFINED([NC_APPEND_ONE_COMPILE_FLAG]) + + ##------------------------------------------------------------------------- + AC_ARG_ENABLE([sanitizer], [ + AS_HELP_STRING([--enable-sanitizer], [enable memory sanitizer]) + ]) + + AS_IF([test "x$enable_sanitizer" = "xyes"], [ + m4_foreach([NAME], [ + dnl common top-level names. deliberately does not include + dnl 'undefined' due to false positives in some core libraries + dnl (eg, boost::format). + [address], + dnl gcc currently causes segfaults at configure time with [thread], + dnl + dnl gcc specific names. do not use vptr or boost::format will die + [alignment], + [bounds], + [enum], + [float-cast-overflow], + [float-divide-by-zero], + [integer-divide-by-zero], + [leak], + [nonnull-attribute], + [object-size], + [return], + [returns-nonnull-attribute], + [shift], + [signed-integer-overflow], + [unreachable], + [vla-bound], + dnl clang specific names + [integer], + [undefined-trap], + [cfi]dnl + ], [ + AX_APPEND_COMPILE_FLAGS([-fsanitize=[]NAME], [], [-Werror]) + AX_APPEND_LINK_FLAGS([-fsanitize=[]NAME], [], [-Werror]) + ]) + + ## We, and the std library, tend to use unsigned overflow legitimately + AX_APPEND_COMPILE_FLAGS([-fno-sanitize=unsigned-integer-overflow], [], [-Werror]) + AX_APPEND_LINK_FLAGS([-fno-sanitize=unsigned-integer-overflow], [], [-Werror]) + + AX_APPEND_COMPILE_FLAGS([-ftrapv], [], [-Werror]) + ]) + + ##------------------------------------------------------------------------- + AC_ARG_ENABLE([debugging], [ + AS_HELP_STRING([--enable-debugging], [enables developer debugging support]) + ]) + + AS_IF([test "x${enable_debugging}" = "xyes"], [ + AC_DEFINE([ENABLE_DEBUGGING], [], [Debugging support enabled]) + AC_DEFINE([_GLIBCXX_DEBUG], [], [Use glibcxx debugging mode]) + + NC_APPEND_ONE_COMPILE_FLAG([-O0]) + ], [ + AX_APPEND_COMPILE_FLAGS([-O2]) + AX_APPEND_COMPILE_FLAGS([-fno-rtti]) + AC_DEFINE([NO_RTTI], [], [RTTI disabled]) + ]) + + ##------------------------------------------------------------------------- + AX_APPEND_COMPILE_FLAGS([-g], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-ggdb], [], [-Werror]) +]) diff --git a/m4/nc_optimisation.m4 b/m4/nc_optimisation.m4 new file mode 100644 index 0000000..4d26663 --- /dev/null +++ b/m4/nc_optimisation.m4 @@ -0,0 +1,112 @@ +AC_DEFUN([NC_OPTIMISATION],[ + ##------------------------------------------------------------------------- + AX_REQUIRE_DEFINED([AX_APPEND_COMPILE_FLAGS]) + AX_REQUIRE_DEFINED([AC_CANONICAL_HOST]) + AX_REQUIRE_DEFINED([AX_COMPILER_VENDOR]) + + AX_COMPILER_VENDOR + + ##------------------------------------------------------------------------- + ## Enable LTO + + AC_ARG_ENABLE([lto], [ + AS_HELP_STRING([--enable-lto], [enable link-time optimisation]) + ]) + + AS_IF([test "x$enable_lto" == "xyes"], [ + AS_IF([test x"${host_os}" == x"mingw32"], [ + AC_ERROR([mingw32 link-time optimisation is currently broken]) + ]) + + AS_IF([test "x$ax_cv_cxx_compiler_vendor" == "xgnu"], [ + AC_CHECK_TOOLS([RANLIB], [gcc-ranlib ranlib]) + AC_CHECK_TOOLS([AR], [gcc-ar ar]) + AC_CHECK_TOOLS([NM], [gcc-nm nm]) + ]) + + AX_APPEND_COMPILE_FLAGS([-flto], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-fno-fat-lto-objects], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-flto-odr-type-merging], [], [-Werror]) + AX_APPEND_LINK_FLAGS([-fuse-linker-plugin], [], [-Werror]) + + AX_APPEND_COMPILE_FLAGS([-fdevirtualize-at-ltrans], [], [-Werror]) + ]) + + ##------------------------------------------------------------------------- + ## Enable frame pointer + + AC_ARG_ENABLE([frame-pointer], [ + AS_HELP_STRING([--enable-frame-pointer], [retain the frame pointer even if optimising]) + ]) + + AS_IF([test "x$enable_frame_pointer" = "xyes"], [ + AX_APPEND_COMPILE_FLAGS([-fno-omit-frame-pointer], [], [-Werror]) + ]) + + + ##------------------------------------------------------------------------- + ## Choose the most performant processor architecture and features + + AC_CANONICAL_HOST + + AS_CASE([$host_cpu], + [x86_64], [ + AX_APPEND_COMPILE_FLAGS([-mtune=generic], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-msse], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-msse2], [], [-Werror]) + ], + + [i686], [ + AX_APPEND_COMPILE_FLAGS([-march=prescott], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-mtune=generic], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-mcmov], [], [-Werror]) + ], + + [AC_MSG_WARN([unknown host_cpu])] + ) + + AX_APPEND_COMPILE_FLAGS([-pipe]) + + # base instruction set requirements for x86 + AX_APPEND_COMPILE_FLAGS([-mfpmath=sse], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-msahf], [], [-Werror]) + + ##------------------------------------------------------------------------- + ## Enable aggressive code generation optimisations + + AS_IF([test "x$enable_debugging" != "xyes"], [ + # gcc vectorisation + AX_APPEND_COMPILE_FLAGS([-ftree-vectorize], [], [-Werror]) + + # clang vectorisation + AX_APPEND_COMPILE_FLAGS([-fvectorize], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-fslp-vectorize], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-fslp-vectorize-aggressive], [], [-Werror]) + + # loop hosting/distribution + AX_APPEND_COMPILE_FLAGS([-ftree-loop-distribute-patterns], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-ftree-loop-distribution], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-ftree-loop-if-convert-stores], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-ftree-loop-linear], [], [-Werror]) + + AX_APPEND_COMPILE_FLAGS([-funsafe-loop-optimizations], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-floop-interchange], [], [-Werror]) + + # safety removal for performance + AX_APPEND_COMPILE_FLAGS([-fno-stack-protector], [], [-Werror]) + ]) + + ##------------------------------------------------------------------------- + ## Enable code size optimisations (that don't impact performance) + ## Note: we assume CXX, and that CXXLINK is g++ not ld, hence the -Wl opt + AS_IF([test "x$enable_debugging" != "xyes"], [ + AX_APPEND_COMPILE_FLAGS([-fdevirtualize], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-fdevirtualize-speculatively], [], [-Werror]) + + AX_CHECK_LINK_FLAG([-Wl,--gc-sections], [ + AX_APPEND_COMPILE_FLAGS([-fdata-sections], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-ffunction-sections], [], [-Werror]) + AX_APPEND_LINK_FLAGS([-Wl,--gc-sections], [], [-Werror]) + ]) + ]) +]) diff --git a/m4/nc_platform.m4 b/m4/nc_platform.m4 new file mode 100644 index 0000000..4fcb7cf --- /dev/null +++ b/m4/nc_platform.m4 @@ -0,0 +1,28 @@ +AC_DEFUN([NC_PLATFORM],[ + AC_CANONICAL_HOST + + AM_CONDITIONAL([PLATFORM_WIN32], [test "x$host_os" = "xmingw32"]) + AM_CONDITIONAL([PLATFORM_LINUX], [test "x$host_os" = "xlinux-gnu"]) + + AS_CASE([$host_os], + [mingw32], [ + AC_CHECK_HEADERS([winsock2.h ws2tcpip.h]) + AC_CHECK_HEADERS([windows.h],[],[],[AC_INCLUDES_DEFAULT]) + AC_SUBST([NET_LIBS], [-lws2_32]) + + AX_APPEND_COMPILE_FLAGS([-DBOOST_THREAD_USE_LIB], [], [-Werror]) + + ## Force as many static libraries as possible to avoid bullshit libc + ## cross-library memory management issues. + AX_APPEND_LINK_FLAGS([-static-libstdc++], [], [-Werror]) + AX_APPEND_LINK_FLAGS([-static-libgcc], [], [-Werror]) + ], + + [linux-gnu], [ ], + + [AC_MSG_ERROR([Unknown platform])] + ) + + AX_APPEND_COMPILE_FLAGS([-fno-common], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-fno-nonansi-builtins], [], [-Werror]) +]) diff --git a/m4/nc_warnings.m4 b/m4/nc_warnings.m4 new file mode 100644 index 0000000..4a141e8 --- /dev/null +++ b/m4/nc_warnings.m4 @@ -0,0 +1,81 @@ +AC_DEFUN([NC_WARNINGS],[ + AX_REQUIRE_DEFINED([AX_APPEND_COMPILE_FLAGS]) + AX_REQUIRE_DEFINED([AX_COMPILER_VENDOR]) + + AX_COMPILER_VENDOR + + # ------------------------------------------------------------------------- + # Compound warnings + AX_APPEND_COMPILE_FLAGS([-Wall], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wextra], [], [-Werror]) + + # ------------------------------------------------------------------------- + # General warnings + AX_APPEND_COMPILE_FLAGS([-Wbool-compare], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wcast-align], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wcast-qual], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wdisabled-optimization], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wfloat-conversion], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wfloat-equal], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-aggressive-loop-optimizations], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wnoexcept], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wnon-virtual-dtor], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-parentheses], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wpointer-arith], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wredundant-decls], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wshadow], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wsign-compare], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wsign-promo], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wstrict-aliasing], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wstrict-overflow], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wtype-limits], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wunsafe-loop-optimizations], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wunused-but-set-variable], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wunused-parameter], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wuseless-cast], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wpessimizing-move], [], [-Werror]) + + # ------------------------------------------------------------------------- + # Required extensions + #AX_APPEND_COMPILE_FLAGS([-Wgnu-flexible-array-union-member], [], [-Werror]) + #AX_APPEND_COMPILE_FLAGS([-Wno-c99-extensions], [], [-Werror]) + #AX_APPEND_COMPILE_FLAGS([-Wno-vla-extension], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-vla], [], [-Werror]) + + AS_IF([test "x$ax_cv_cxx_compiler_vendor" != "xgnu"], [ + AX_APPEND_COMPILE_FLAGS([-Wno-c99-extensions], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-flexible-array-extensions], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-gnu-conditional-omitted-operand], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-gnu-empty-struct], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-gnu-flexible-array-union-member], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-gnu-zero-variadic-macro-arguments], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-vla-extension], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-zero-length-array], [], [-Werror]) + ]) + + # ------------------------------------------------------------------------- + # Excessive warnings + AX_APPEND_COMPILE_FLAGS([-Wno-missing-braces], [], [-Werror]) + + AS_IF([test "x$ax_cv_cxx_compiler_vendor" != "xgnu"], [ + AX_APPEND_COMPILE_FLAGS([-Wno-nested-anon-types], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wno-unused-const-variable], [], [-Werror]) + ]) + + # ------------------------------------------------------------------------- + # Strict warnings + AX_APPEND_COMPILE_FLAGS([-pedantic], [], [-Werror]) + + # ------------------------------------------------------------------------- + # Advisory warnings + AC_ARG_ENABLE([advisory], [ + AS_HELP_STRING([--enable-advisory], [enable advisory warnings]) + ]) + + AS_IF([test "x$enable_advisory" = "xyes"], [ + AX_APPEND_COMPILE_FLAGS([-Winline], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wsuggest-final-types], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wsuggest-final-methods], [], [-Werror]) + AX_APPEND_COMPILE_FLAGS([-Wsuggest-override], [], [-Werror]) + ], []) +]) diff --git a/object.cpp b/object.cpp new file mode 100644 index 0000000..65518a1 --- /dev/null +++ b/object.cpp @@ -0,0 +1 @@ +#include "./object.hpp" diff --git a/object.hpp b/object.hpp new file mode 100644 index 0000000..2948eb2 --- /dev/null +++ b/object.hpp @@ -0,0 +1,56 @@ +#ifndef __VK_OBJECT_HPP +#define __VK_OBJECT_HPP + +#include "./traits.hpp" +#include "./except.hpp" + +#include + +namespace vk { + template + struct object { + using id_t = typename id_traits::id_t; + + object (id_t); + + id_t& id (void) const&; + + private: + id_t m_id; + }; + + + template + struct instantiated : public object { + using id_t = typename object::id_t; + + template + instantiated (Args &&...args): + object (make (std::forward (args)...)) + { ; } + + ~instantiated () + { + life_traits::destroy (this->id (), nullptr); + } + + private: + template + static + id_t make (Args &&...args) + { + id_t id; + auto res = life_traits::create (std::forward (args)..., &id); + error::try_code (res); + return id; + } + }; + + template + struct enumerated : public object { }; + + template + struct owned : public object { }; +} + +#endif diff --git a/physical_device.cpp b/physical_device.cpp new file mode 100644 index 0000000..b6f5c63 --- /dev/null +++ b/physical_device.cpp @@ -0,0 +1,3 @@ +#include "physical_device.hpp" + +/////////////////////////////////////////////////////////////////////////////// diff --git a/physical_device.hpp b/physical_device.hpp new file mode 100644 index 0000000..23f78be --- /dev/null +++ b/physical_device.hpp @@ -0,0 +1,13 @@ +#ifndef __VK_PHYSICAL_DEVICE_HPP +#define __VK_PHYSICAL_DEVICE_HPP + +#include "./object.hpp" + +#include "./vk.hpp" + +namespace vk { + struct physical_device : public enumerated { + }; +} + +#endif diff --git a/pipeline.cpp b/pipeline.cpp new file mode 100644 index 0000000..b296994 --- /dev/null +++ b/pipeline.cpp @@ -0,0 +1,7 @@ +#include "./pipeline.hpp" + +using vk::pipeline; + + +/////////////////////////////////////////////////////////////////////////////// + diff --git a/pipeline.hpp b/pipeline.hpp new file mode 100644 index 0000000..e697a81 --- /dev/null +++ b/pipeline.hpp @@ -0,0 +1,13 @@ +#ifndef __VK_PIPELINE_HPP +#define __VK_PIPELINE_HPP + +#include "./object.hpp" +#include "./fwd.hpp" + +namespace vk { + struct pipeline : public owned { + + }; +} + +#endif diff --git a/pipeline_cache.cpp b/pipeline_cache.cpp new file mode 100644 index 0000000..3a4ee5c --- /dev/null +++ b/pipeline_cache.cpp @@ -0,0 +1,17 @@ +#ifndef __VK_PIPELINE_CACHE_HPP +#define __VK_PIPELINE_CACHE_HPP + +#include "./object.hpp" +#include "./fwd.hpp" + +namespace vk { + struct pipeline_cache : public owned { + void merge (const device&, + const pipeline_cache *first, + const pipeline_cache *last); + + size_t get (const device&, void *dst, size_t len) const; + }; +} + +#endif diff --git a/pipeline_cache.hpp b/pipeline_cache.hpp new file mode 100644 index 0000000..9598197 --- /dev/null +++ b/pipeline_cache.hpp @@ -0,0 +1,26 @@ +#include "./pipeline_cache.hpp" + +#include "./device.hpp" + +using vk::pipeline_cache; + + +/////////////////////////////////////////////////////////////////////////////// +void +pipeline_cache::merge (const device &dev, + const pipeline_cache *first, + const pipeline_cache *last) +{ + auto err = vkMergePipelineCache (dev.id (), id (), last - first, &first->id ()); + error::try_code (err); +} + + +/////////////////////////////////////////////////////////////////////////////// +size_t +pipeline_cache::get (const device &dev, void *dst, size_t len) +{ + auto err = vkGetPipelineCacheData (dev.id (), id (), dst, &len); + error::try_code (err); + return len; +} diff --git a/queue.cpp b/queue.cpp new file mode 100644 index 0000000..da9581f --- /dev/null +++ b/queue.cpp @@ -0,0 +1,18 @@ +#include "./queue.hpp" + +#include "./except.hpp" + +using vk::queue; + + +/////////////////////////////////////////////////////////////////////////////// +void +queue::wait_idle (void) +{ + auto err = vkQueueWaitIdle (id ()); + error::try_code (err); +} + + +/////////////////////////////////////////////////////////////////////////////// + diff --git a/queue.hpp b/queue.hpp new file mode 100644 index 0000000..abeff8b --- /dev/null +++ b/queue.hpp @@ -0,0 +1,16 @@ +#ifndef __VK_QUEUE_HPP +#define __VK_QUEUE_HPP + +#include "./object.hpp" +#include "./fwd.hpp" + +namespace vk { + struct queue : public owned { + void wait_idle (void); + + template + void submit (T data, const fence&); // VkQueueSubmit + }; +} + +#endif diff --git a/render_pass.cpp b/render_pass.cpp new file mode 100644 index 0000000..ca39112 --- /dev/null +++ b/render_pass.cpp @@ -0,0 +1 @@ +#include "./render_pass.hpp" diff --git a/render_pass.hpp b/render_pass.hpp new file mode 100644 index 0000000..6240028 --- /dev/null +++ b/render_pass.hpp @@ -0,0 +1,12 @@ +#ifndef __VK_RENDER_PASS_HPP +#define __VK_RENDER_PASS_HPP + +#include "./object.hpp" + +namespace vk { + struct render_pass : public owned { + + }; +} + +#endif diff --git a/semaphore.cpp b/semaphore.cpp new file mode 100644 index 0000000..fc1e766 --- /dev/null +++ b/semaphore.cpp @@ -0,0 +1 @@ +#include "./semaphore.hpp" diff --git a/semaphore.hpp b/semaphore.hpp new file mode 100644 index 0000000..2012d49 --- /dev/null +++ b/semaphore.hpp @@ -0,0 +1,13 @@ +#ifndef __VK_SEMAPHORE_HPP +#define __VK_SEMAPHORE_HPP + +#include "./object.hpp" +#include "./fwd.hpp" + +namespace vk { + struct semaphore : public owned { + + }; +} + +#endif diff --git a/shader_module.cpp b/shader_module.cpp new file mode 100644 index 0000000..e57328b --- /dev/null +++ b/shader_module.cpp @@ -0,0 +1 @@ +#include "./shader_module.hpp" diff --git a/shader_module.hpp b/shader_module.hpp new file mode 100644 index 0000000..a53ecb1 --- /dev/null +++ b/shader_module.hpp @@ -0,0 +1,13 @@ +#ifndef __VK_SHADER_MODULE_HPP +#define __VK_SHADER_MODULE_HPP + +#include "./object.hpp" +#include "./fwd.hpp" + +namespace vk { + struct shader_module : public owned { + + }; +} + +#endif diff --git a/traits.hpp b/traits.hpp new file mode 100644 index 0000000..5504518 --- /dev/null +++ b/traits.hpp @@ -0,0 +1,113 @@ +#ifndef __VK_TRAITS_HPP +#define __VK_TRAITS_HPP + +#include "./fwd.hpp" +#include "./vk.hpp" + +namespace vk { + /////////////////////////////////////////////////////////////////////////// + template struct id_traits { }; + + template <> struct id_traits { using id_t = VkInstance; }; + template <> struct id_traits { using id_t = VkPhysicalDevice; }; + template <> struct id_traits { using id_t = VkDevice; }; + template <> struct id_traits { using id_t = VkQueue; }; + template <> struct id_traits { using id_t = VkCommandPool; }; + template <> struct id_traits { using id_t = VkCommandBuffer; }; + template <> struct id_traits { using id_t = VkFence; }; + template <> struct id_traits { using id_t = VkSemaphore; }; + template <> struct id_traits { using id_t = VkEvent; }; + template <> struct id_traits { using id_t = VkRenderPass; }; + template <> struct id_traits { using id_t = VkFramebuffer; }; + template <> struct id_traits { using id_t = VkShaderModule; }; + template <> struct id_traits { using id_t = VkPipeline; }; + template <> struct id_traits { using id_t = VkPipelineCache; }; + template <> struct id_traits { using id_t = VkDeviceMemory; }; + template <> struct id_traits { using id_t = VkBuffer; }; + template <> struct id_traits { using id_t = VkBufferView; }; + + + /////////////////////////////////////////////////////////////////////////// + template struct life_traits { }; + + template <> struct life_traits { + static constexpr auto create = vkCreateInstance; + static constexpr auto destroy = vkDestroyInstance; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreateDevice; + static constexpr auto destroy = vkDestroyDevice; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreateCommandPool; + static constexpr auto destroy = vkDestroyCommandPool; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreateFence; + static constexpr auto destroy = vkDestroyFence; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreateSemaphore; + static constexpr auto destroy = vkDestroySemaphore; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreateEvent; + static constexpr auto destroy = vkDestroyEvent; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreateRenderPass; + static constexpr auto destroy = vkDestroyRenderPass; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreateFramebuffer; + static constexpr auto destroy = vkDestroyFramebuffer; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreateShaderModule; + static constexpr auto destroy = vkDestroyShaderModule; + }; + + template struct create_traits { }; + template <> struct create_traits { + static constexpr auto func = vkCreateComputePipelines; + }; + template <> struct create_traits { + static constexpr auto func = vkCreateGraphicsPipelines; + }; + + template <> struct life_traits { + template + static constexpr auto create = create_traits

::func; + static constexpr auto destroy = vkDestroyPipeline; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreatePipelineCache; + static constexpr auto destroy = vkDestroyPipelineCache; + }; + + template <> struct life_traits { + static constexpr auto create = vkAllocateMemory; + static constexpr auto destroy = vkFreeMemory; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreateBuffer; + static constexpr auto destroy = vkDestroyBuffer; + }; + + template <> struct life_traits { + static constexpr auto create = vkCreateBufferView; + + }; +} + +#endif diff --git a/vk.xml b/vk.xml new file mode 100644 index 0000000..4bfc733 --- /dev/null +++ b/vk.xml @@ -0,0 +1,5099 @@ + + + +Copyright (c) 2015-2016 The Khronos Group Inc. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and/or associated documentation files (the +"Materials"), to deal in the Materials without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Materials, and to +permit persons to whom the Materials are furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Materials. + +THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + +------------------------------------------------------------------------ + +This file, vk.xml, is the Vulkan API Registry. It is a critically important +and normative part of the Vulkan Specification, including a canonical +machine-readable definition of the API, parameter and member validation +language incorporated into the Specification and reference pages, and other +material which is registered by Khronos, such as tags used by extension and +layer authors. The only authoritative version of vk.xml is the one +maintained in the master branch of the Khronos Vulkan Github project. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + #include "vk_platform.h" + + #include "vulkan.h" + #include <X11/Xlib.h> + #include <android/native_window.h> + #include <mir_toolkit/client_types.h> + #include <wayland-client.h> + #include <windows.h> + #include <xcb/xcb.h> + + + + + + + + + + + + + + + + #define VK_MAKE_VERSION(major, minor, patch) \ + (((major) << 22) | ((minor) << 12) | (patch)) + #define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22) + #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) + #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) + + // Vulkan API version supported by this file +#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 3) + + + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + + +#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; +#else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; +#endif + + + +#define VK_NULL_HANDLE 0 + + + typedef uint32_t VkSampleMask; + typedef uint32_t VkBool32; + typedef uint32_t VkFlags; + typedef uint64_t VkDeviceSize; + + + + + + + + + + + typedef VkFlags VkFramebufferCreateFlags; + typedef VkFlags VkQueryPoolCreateFlags; + typedef VkFlags VkRenderPassCreateFlags; + typedef VkFlags VkSamplerCreateFlags; + typedef VkFlags VkPipelineLayoutCreateFlags; + typedef VkFlags VkPipelineCacheCreateFlags; + typedef VkFlags VkPipelineDepthStencilStateCreateFlags; + typedef VkFlags VkPipelineDynamicStateCreateFlags; + typedef VkFlags VkPipelineColorBlendStateCreateFlags; + typedef VkFlags VkPipelineMultisampleStateCreateFlags; + typedef VkFlags VkPipelineRasterizationStateCreateFlags; + typedef VkFlags VkPipelineViewportStateCreateFlags; + typedef VkFlags VkPipelineTessellationStateCreateFlags; + typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; + typedef VkFlags VkPipelineVertexInputStateCreateFlags; + typedef VkFlags VkPipelineShaderStageCreateFlags; + typedef VkFlags VkDescriptorSetLayoutCreateFlags; + typedef VkFlags VkBufferViewCreateFlags; + typedef VkFlags VkInstanceCreateFlags; + typedef VkFlags VkDeviceCreateFlags; + typedef VkFlags VkDeviceQueueCreateFlags; + typedef VkFlags VkQueueFlags; + typedef VkFlags VkMemoryPropertyFlags; + typedef VkFlags VkMemoryHeapFlags; + typedef VkFlags VkAccessFlags; + typedef VkFlags VkBufferUsageFlags; + typedef VkFlags VkBufferCreateFlags; + typedef VkFlags VkShaderStageFlags; + typedef VkFlags VkImageUsageFlags; + typedef VkFlags VkImageCreateFlags; + typedef VkFlags VkImageViewCreateFlags; + typedef VkFlags VkPipelineCreateFlags; + typedef VkFlags VkColorComponentFlags; + typedef VkFlags VkFenceCreateFlags; + typedef VkFlags VkSemaphoreCreateFlags; + typedef VkFlags VkFormatFeatureFlags; + typedef VkFlags VkQueryControlFlags; + typedef VkFlags VkQueryResultFlags; + typedef VkFlags VkShaderModuleCreateFlags; + typedef VkFlags VkEventCreateFlags; + typedef VkFlags VkCommandPoolCreateFlags; + typedef VkFlags VkCommandPoolResetFlags; + typedef VkFlags VkCommandBufferResetFlags; + typedef VkFlags VkCommandBufferUsageFlags; + typedef VkFlags VkQueryPipelineStatisticFlags; + typedef VkFlags VkMemoryMapFlags; + typedef VkFlags VkImageAspectFlags; + typedef VkFlags VkSparseMemoryBindFlags; + typedef VkFlags VkSparseImageFormatFlags; + typedef VkFlags VkSubpassDescriptionFlags; + typedef VkFlags VkPipelineStageFlags; + typedef VkFlags VkSampleCountFlags; + typedef VkFlags VkAttachmentDescriptionFlags; + typedef VkFlags VkStencilFaceFlags; + typedef VkFlags VkCullModeFlags; + typedef VkFlags VkDescriptorPoolCreateFlags; + typedef VkFlags VkDescriptorPoolResetFlags; + typedef VkFlags VkDependencyFlags; + + typedef VkFlags VkCompositeAlphaFlagsKHR; + typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; + typedef VkFlags VkSurfaceTransformFlagsKHR; + typedef VkFlags VkSwapchainCreateFlagsKHR; + typedef VkFlags VkDisplayModeCreateFlagsKHR; + typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; + typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; + typedef VkFlags VkMirSurfaceCreateFlagsKHR; + typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; + typedef VkFlags VkWin32SurfaceCreateFlagsKHR; + typedef VkFlags VkXlibSurfaceCreateFlagsKHR; + typedef VkFlags VkXcbSurfaceCreateFlagsKHR; + + typedef VkFlags VkDebugReportFlagsEXT; + + + VK_DEFINE_HANDLE(VkInstance) + VK_DEFINE_HANDLE(VkPhysicalDevice) + VK_DEFINE_HANDLE(VkDevice) + VK_DEFINE_HANDLE(VkQueue) + VK_DEFINE_HANDLE(VkCommandBuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) + + + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + + + typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); + + + typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + + + + int32_t x + int32_t y + + + int32_t x + int32_t y + int32_t z + + + uint32_t width + uint32_t height + + + uint32_t width + uint32_t height + uint32_t depth + + + float x + float y + float width + float height + float minDepth + float maxDepth + + pname:width must: be greater than `0.0` and less than or equal to sname:VkPhysicalDeviceLimits::pname:maxViewportDimensions[0] + pname:height must: be greater than `0.0` and less than or equal to sname:VkPhysicalDeviceLimits::pname:maxViewportDimensions[1] + pname:x and pname:y must: each be between pname:viewportBoundsRange[0] and pname:viewportBoundsRange[1], inclusive + pname:x + pname:width must: be less than or equal to pname:viewportBoundsRange[1] + pname:y + pname:height must: be less than or equal to pname:viewportBoundsRange[1] + pname:minDepth must: be between `0.0` and `1.0`, inclusive + pname:maxDepth must: be between `0.0` and `1.0`, inclusive + + + + VkOffset2D offset + VkExtent2D extent + + + VkOffset3D offset + VkExtent3D extent + + + VkRect2D rect + uint32_t baseArrayLayer + uint32_t layerCount + + + VkComponentSwizzle r + VkComponentSwizzle g + VkComponentSwizzle b + VkComponentSwizzle a + + + + uint32_t maxImageDimension1D + uint32_t maxImageDimension2D + uint32_t maxImageDimension3D + uint32_t maxImageDimensionCube + uint32_t maxImageArrayLayers + uint32_t maxTexelBufferElements + uint32_t maxUniformBufferRange + uint32_t maxStorageBufferRange + uint32_t maxPushConstantsSize + + uint32_t maxMemoryAllocationCount + uint32_t maxSamplerAllocationCount + VkDeviceSize bufferImageGranularity + VkDeviceSize sparseAddressSpaceSize + + uint32_t maxBoundDescriptorSets + uint32_t maxPerStageDescriptorSamplers + uint32_t maxPerStageDescriptorUniformBuffers + uint32_t maxPerStageDescriptorStorageBuffers + uint32_t maxPerStageDescriptorSampledImages + uint32_t maxPerStageDescriptorStorageImages + uint32_t maxPerStageDescriptorInputAttachments + uint32_t maxPerStageResources + uint32_t maxDescriptorSetSamplers + uint32_t maxDescriptorSetUniformBuffers + uint32_t maxDescriptorSetUniformBuffersDynamic + uint32_t maxDescriptorSetStorageBuffers + uint32_t maxDescriptorSetStorageBuffersDynamic + uint32_t maxDescriptorSetSampledImages + uint32_t maxDescriptorSetStorageImages + uint32_t maxDescriptorSetInputAttachments + + uint32_t maxVertexInputAttributes + uint32_t maxVertexInputBindings + uint32_t maxVertexInputAttributeOffset + uint32_t maxVertexInputBindingStride + uint32_t maxVertexOutputComponents + + uint32_t maxTessellationGenerationLevel + uint32_t maxTessellationPatchSize + uint32_t maxTessellationControlPerVertexInputComponents + uint32_t maxTessellationControlPerVertexOutputComponents + uint32_t maxTessellationControlPerPatchOutputComponents + uint32_t maxTessellationControlTotalOutputComponents + + uint32_t maxTessellationEvaluationInputComponents + uint32_t maxTessellationEvaluationOutputComponents + + uint32_t maxGeometryShaderInvocations + uint32_t maxGeometryInputComponents + uint32_t maxGeometryOutputComponents + uint32_t maxGeometryOutputVertices + uint32_t maxGeometryTotalOutputComponents + + uint32_t maxFragmentInputComponents + uint32_t maxFragmentOutputAttachments + uint32_t maxFragmentDualSrcAttachments + uint32_t maxFragmentCombinedOutputResources + + uint32_t maxComputeSharedMemorySize + uint32_t maxComputeWorkGroupCount[3] + uint32_t maxComputeWorkGroupInvocations + uint32_t maxComputeWorkGroupSize[3] + + uint32_t subPixelPrecisionBits + uint32_t subTexelPrecisionBits + uint32_t mipmapPrecisionBits + + uint32_t maxDrawIndexedIndexValue + uint32_t maxDrawIndirectCount + + float maxSamplerLodBias + float maxSamplerAnisotropy + + uint32_t maxViewports + uint32_t maxViewportDimensions[2] + float viewportBoundsRange[2] + uint32_t viewportSubPixelBits + + size_t minMemoryMapAlignment + VkDeviceSize minTexelBufferOffsetAlignment + VkDeviceSize minUniformBufferOffsetAlignment + VkDeviceSize minStorageBufferOffsetAlignment + + int32_t minTexelOffset + uint32_t maxTexelOffset + int32_t minTexelGatherOffset + uint32_t maxTexelGatherOffset + float minInterpolationOffset + float maxInterpolationOffset + uint32_t subPixelInterpolationOffsetBits + + uint32_t maxFramebufferWidth + uint32_t maxFramebufferHeight + uint32_t maxFramebufferLayers + VkSampleCountFlags framebufferColorSampleCounts + VkSampleCountFlags framebufferDepthSampleCounts + VkSampleCountFlags framebufferStencilSampleCounts + VkSampleCountFlags framebufferNoAttachmentsSampleCounts + uint32_t maxColorAttachments + + VkSampleCountFlags sampledImageColorSampleCounts + VkSampleCountFlags sampledImageIntegerSampleCounts + VkSampleCountFlags sampledImageDepthSampleCounts + VkSampleCountFlags sampledImageStencilSampleCounts + VkSampleCountFlags storageImageSampleCounts + uint32_t maxSampleMaskWords + + VkBool32 timestampComputeAndGraphics + float timestampPeriod + + uint32_t maxClipDistances + uint32_t maxCullDistances + uint32_t maxCombinedClipAndCullDistances + + uint32_t discreteQueuePriorities + + float pointSizeRange[2] + float lineWidthRange[2] + float pointSizeGranularity + float lineWidthGranularity + VkBool32 strictLines + VkBool32 standardSampleLocations + VkDeviceSize optimalBufferCopyOffsetAlignment + VkDeviceSize optimalBufferCopyRowPitchAlignment + VkDeviceSize nonCoherentAtomSize + + + VkBool32 robustBufferAccess + VkBool32 fullDrawIndexUint32 + VkBool32 imageCubeArray + VkBool32 independentBlend + VkBool32 geometryShader + VkBool32 tessellationShader + VkBool32 sampleRateShading + VkBool32 dualSrcBlend + VkBool32 logicOp + VkBool32 multiDrawIndirect + VkBool32 drawIndirectFirstInstance + VkBool32 depthClamp + VkBool32 depthBiasClamp + VkBool32 fillModeNonSolid + VkBool32 depthBounds + VkBool32 wideLines + VkBool32 largePoints + VkBool32 alphaToOne + VkBool32 multiViewport + VkBool32 samplerAnisotropy + VkBool32 textureCompressionETC2 + VkBool32 textureCompressionASTC_LDR + VkBool32 textureCompressionBC + VkBool32 occlusionQueryPrecise + VkBool32 pipelineStatisticsQuery + VkBool32 vertexPipelineStoresAndAtomics + VkBool32 fragmentStoresAndAtomics + VkBool32 shaderTessellationAndGeometryPointSize + VkBool32 shaderImageGatherExtended + VkBool32 shaderStorageImageExtendedFormats + VkBool32 shaderStorageImageMultisample + VkBool32 shaderStorageImageReadWithoutFormat + VkBool32 shaderStorageImageWriteWithoutFormat + VkBool32 shaderUniformBufferArrayDynamicIndexing + VkBool32 shaderSampledImageArrayDynamicIndexing + VkBool32 shaderStorageBufferArrayDynamicIndexing + VkBool32 shaderStorageImageArrayDynamicIndexing + VkBool32 shaderClipDistance + VkBool32 shaderCullDistance + VkBool32 shaderFloat64 + VkBool32 shaderInt64 + VkBool32 shaderInt16 + VkBool32 shaderResourceResidency + VkBool32 shaderResourceMinLod + VkBool32 sparseBinding + VkBool32 sparseResidencyBuffer + VkBool32 sparseResidencyImage2D + VkBool32 sparseResidencyImage3D + VkBool32 sparseResidency2Samples + VkBool32 sparseResidency4Samples + VkBool32 sparseResidency8Samples + VkBool32 sparseResidency16Samples + VkBool32 sparseResidencyAliased + VkBool32 variableMultisampleRate + VkBool32 inheritedQueries + + If the value of any member of this structure is ename:VK_FALSE, as returned by flink:vkGetPhysicalDeviceFeatures, then it must: be ename:VK_FALSE when passed as part of the sname:VkDeviceCreateInfo struct when creating a device + + + + VkBool32 residencyStandard2DBlockShape + VkBool32 residencyStandard2DMultisampleBlockShape + VkBool32 residencyStandard3DBlockShape + VkBool32 residencyAlignedMipSize + VkBool32 residencyNonResidentStrict + + + uint32_t apiVersion + uint32_t driverVersion + uint32_t vendorID + uint32_t deviceID + VkPhysicalDeviceType deviceType + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] + uint8_t pipelineCacheUUID[VK_UUID_SIZE] + VkPhysicalDeviceLimits limits + VkPhysicalDeviceSparseProperties sparseProperties + + + char extensionName[VK_MAX_EXTENSION_NAME_SIZE] + uint32_t specVersion + + + char layerName[VK_MAX_EXTENSION_NAME_SIZE] + uint32_t specVersion + uint32_t implementationVersion + char description[VK_MAX_DESCRIPTION_SIZE] + + + VkStructureType sType + const void* pNext + const char* pApplicationName + uint32_t applicationVersion + const char* pEngineName + uint32_t engineVersion + uint32_t apiVersion + + pname:apiVersion must: be zero, or otherwise it must: be a version that the implementation supports, or supports an effective substitute for + + + + void* pUserData + PFN_vkAllocationFunction pfnAllocation + PFN_vkReallocationFunction pfnReallocation + PFN_vkFreeFunction pfnFree + PFN_vkInternalAllocationNotification pfnInternalAllocation + PFN_vkInternalFreeNotification pfnInternalFree + + pname:pfnAllocation must: be a pointer to a valid user-defined PFN_vkAllocationFunction + pname:pfnReallocation must: be a pointer to a valid user-defined PFN_vkReallocationFunction + pname:pfnFree must: be a pointer to a valid user-defined PFN_vkFreeFunction + If either of pname:pfnInternalAllocatione or pname:pfnInternalFree is not `NULL`, both must: be valid callbacks + + + + VkStructureType sType + const void* pNext + VkDeviceQueueCreateFlags flags + uint32_t queueFamilyIndex + uint32_t queueCount + const float* pQueuePriorities + + pname:queueFamilyIndex must: be less than the value of pname:pQueueFamilyPropertyCount returned by fname:vkGetPhysicalDeviceQueueFamilyProperties + pname:queueCount must: be less than or equal to the value of the pname:queueCount member of the sname:VkQueueFamilyProperties structure, as returned by fname:vkGetPhysicalDeviceQueueFamilyProperties in the pname:pQueueFamilyProperties[pname:queueFamilyIndex] + The value of any given element of pname:pQueuePriorities must: be between `0.0` and `1.0` inclusive + + + + VkStructureType sType + const void* pNext + VkDeviceCreateFlags flags + uint32_t queueCreateInfoCount + const VkDeviceQueueCreateInfo* pQueueCreateInfos + uint32_t enabledLayerCount + const char* const* ppEnabledLayerNames + uint32_t enabledExtensionCount + const char* const* ppEnabledExtensionNames + const VkPhysicalDeviceFeatures* pEnabledFeatures + + Any given element of pname:ppEnabledLayerNames must: be the name of a layer present on the system, exactly matching a string returned in the sname:VkLayerProperties structure by fname:vkEnumerateDeviceLayerProperties + Any given element of pname:ppEnabledExtensionNames must: be the name of an extension present on the system, exactly matching a string returned in the sname:VkExtensionProperties structure by fname:vkEnumerateDeviceExtensionProperties + If an extension listed in pname:ppEnabledExtensionNames is provided as part of a layer, then both the layer and extension must: be enabled to enable that extension + The pname:queueFamilyIndex member of any given element of pname:pQueueCreateInfos must: be unique within pname:pQueueCreateInfos + + + + VkStructureType sType + const void* pNext + VkInstanceCreateFlags flags + const VkApplicationInfo* pApplicationInfo + uint32_t enabledLayerCount + const char* const* ppEnabledLayerNames + uint32_t enabledExtensionCount + const char* const* ppEnabledExtensionNames + + Any given element of pname:ppEnabledLayerNames must: be the name of a layer present on the system, exactly matching a string returned in the sname:VkLayerProperties structure by fname:vkEnumerateInstanceLayerProperties + Any given element of pname:ppEnabledExtensionNames must: be the name of an extension present on the system, exactly matching a string returned in the sname:VkExtensionProperties structure by fname:vkEnumerateInstanceExtensionProperties + If an extension listed in pname:ppEnabledExtensionNames is provided as part of a layer, then both the layer and extension must: be enabled to enable that extension + + + + VkQueueFlags queueFlags + uint32_t queueCount + uint32_t timestampValidBits + VkExtent3D minImageTransferGranularity + + + VkStructureType sType + const void* pNext + VkDeviceSize allocationSize + uint32_t memoryTypeIndex + + The value of pname:allocationSize must: be less than or equal to the amount of memory available to the sname:VkMemoryHeap specified by pname:memoryTypeIndex and the calling command's sname:VkDevice + The value of pname:allocationSize must: be greater than `0` + + + + VkDeviceSize size + VkDeviceSize alignment + uint32_t memoryTypeBits + + + VkMemoryPropertyFlags propertyFlags + uint32_t heapIndex + + + VkDeviceSize size + VkMemoryHeapFlags flags + + + VkImageAspectFlags aspectMask + VkExtent3D imageGranularity + VkSparseImageFormatFlags flags + + + VkSparseImageFormatProperties formatProperties + uint32_t imageMipTailFirstLod + VkDeviceSize imageMipTailSize + VkDeviceSize imageMipTailOffset + VkDeviceSize imageMipTailStride + + + uint32_t memoryTypeCount + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES] + uint32_t memoryHeapCount + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS] + + + VkStructureType sType + const void* pNext + VkDeviceMemory memory + VkDeviceSize offset + VkDeviceSize size + + pname:memory must: currently be mapped + pname:offset must: be less than the size of the currently mapped range of pname:memory + If pname:size is not equal to ename:VK_WHOLE_SIZE, the sum of pname:offset and pname:size must: be less than or equal to the size of the currently mapped range of pname:memory + pname:offset and pname:size must: each be a multiple of sname:VkPhysicalDeviceLimits::pname:nonCoherentAtomSize + + + + VkFormatFeatureFlags linearTilingFeatures + VkFormatFeatureFlags optimalTilingFeatures + VkFormatFeatureFlags bufferFeatures + + + VkExtent3D maxExtent + uint32_t maxMipLevels + uint32_t maxArrayLayers + VkSampleCountFlags sampleCounts + VkDeviceSize maxResourceSize + + + VkBuffer buffer + VkDeviceSize offset + VkDeviceSize range + + If pname:range is not equal to ename:VK_WHOLE_SIZE, the sum of pname:offset and pname:range must: be less than or equal to the size of pname:buffer + + + + VkSampler sampler + VkImageView imageView + VkImageLayout imageLayout + + + VkStructureType sType + const void* pNext + VkDescriptorSet dstSet + uint32_t dstBinding + uint32_t dstArrayElement + uint32_t descriptorCount + VkDescriptorType descriptorType + const VkDescriptorImageInfo* pImageInfo + const VkDescriptorBufferInfo* pBufferInfo + const VkBufferView* pTexelBufferView + + pname:dstBinding must: be a valid binding point within pname:dstSet + pname:descriptorType must: match the type of pname:dstBinding within pname:dstSet + The sum of pname:dstArrayElement and pname:descriptorCount must: be less than or equal to the number of array elements in the descriptor set binding specified by pname:dstBinding, and all applicable consecutive bindings, as described by <<descriptorsets-updates-consecutive>> + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, pname:pImageInfo must: be a pointer to an array of pname:descriptorCount valid sname:VkDescriptorImageInfo structures + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, pname:pTexelBufferView must: be a pointer to an array of pname:descriptorCount valid sname:VkBufferView handles + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pname:pBufferInfo must: be a pointer to an array of pname:descriptorCount valid sname:VkDescriptorBufferInfo structures + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_SAMPLER or ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and pname:dstSet was not created with a layout that included immutable samplers for pname:dstBinding with pname:descriptorType, the pname:sampler member of any given element of pname:pImageInfo must: be a valid sname:VkSampler object + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the pname:imageView and pname:imageLayout members of any given element of pname:pImageInfo must: be a valid sname:VkImageView and elink:VkImageLayout, respectively + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:offset member of any given element of pname:pBufferInfo must: be a multiple of the value of sname:VkPhysicalDeviceLimits::pname:minUniformBufferOffsetAlignment + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:offset member of any given element of pname:pBufferInfo must: be a multiple of the value of sname:VkPhysicalDeviceLimits::pname:minStorageBufferOffsetAlignment + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:buffer member of any given element of pname:pBufferInfo must: have been created with ename:VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT set + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:buffer member of any given element of pname:pBufferInfo must: have been created with ename:VK_BUFFER_USAGE_STORAGE_BUFFER_BIT set + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the pname:range member of any given element of pname:pBufferInfo must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxUniformBufferRange + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the pname:range member of any given element of pname:pBufferInfo must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxStorageBufferRange + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the sname:VkBuffer that pname:pTexelBufferView was created from must: have been created with ename:VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT set + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the sname:VkBuffer that pname:pTexelBufferView was created from must: have been created with ename:VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT set + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or ename:VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the pname:imageView must: have been created with identity swizzle + + + + VkStructureType sType + const void* pNext + VkDescriptorSet srcSet + uint32_t srcBinding + uint32_t srcArrayElement + VkDescriptorSet dstSet + uint32_t dstBinding + uint32_t dstArrayElement + uint32_t descriptorCount + + pname:srcBinding must: be a valid binding within pname:srcSet + The sum of pname:srcArrayElement and pname:descriptorCount must: be less than or equal to the number of array elements in the descriptor set binding specified by pname:srcBinding, and all applicable consecutive bindings, as described by <<descriptorsets-updates-consecutive>> + pname:dstBinding must: be a valid binding within pname:dstSet + The sum of pname:dstArrayElement and pname:descriptorCount must: be less than or equal to the number of array elements in the descriptor set binding specified by pname:dstBinding, and all applicable consecutive bindings, as described by <<descriptorsets-updates-consecutive>> + + + + VkStructureType sType + const void* pNext + VkBufferCreateFlags flags + VkDeviceSize size + VkBufferUsageFlags usage + VkSharingMode sharingMode + uint32_t queueFamilyIndexCount + const uint32_t* pQueueFamilyIndices + + The value of pname:size must: be greater than `0` + If pname:sharingMode is ename:VK_SHARING_MODE_CONCURRENT, pname:pQueueFamilyIndices must: be a pointer to an array of pname:queueFamilyIndexCount basetype:uint32_t values + If pname:sharingMode is ename:VK_SHARING_MODE_CONCURRENT, pname:queueFamilyIndexCount must: be greater than `1` + If the <<features-features-sparseBinding,sparse bindings>> feature is not enabled, pname:flags mustnot: contain ename:VK_BUFFER_CREATE_SPARSE_BINDING_BIT + If the <<features-features-sparseResidencyBuffer,sparse buffer residency>> feature is not enabled, pname:flags mustnot: contain ename:VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT + If the <<features-features-sparseResidencyAliased,sparse aliased residency>> feature is not enabled, pname:flags mustnot: contain ename:VK_BUFFER_CREATE_SPARSE_ALIASED_BIT + If pname:flags contains ename:VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, it must: also contain at least one of ename:VK_BUFFER_CREATE_SPARSE_BINDING_BIT or ename:VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT + + + + VkStructureType sType + const void* pNext + VkBufferViewCreateFlagsflags + VkBuffer buffer + VkFormat format + VkDeviceSize offset + VkDeviceSize range + + The value of pname:offset must: be a multiple of sname:VkPhysicalDeviceLimits::pname:minTexelBufferOffsetAlignment + The value of pname:range must: be greater than `0` + If pname:range is not equal to ename:VK_WHOLE_SIZE, the sum of pname:offset and pname:range must: be less than or equal to the size of pname:buffer + If pname:range is not equal to ename:VK_WHOLE_SIZE, the value of pname:range must: be a multiple of the element size of pname:format + The value of pname:range, divided by the size of an element of pname:format, must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxTexelBufferElements + pname:buffer must: have been created with a pname:usage value containing at least one of ename:VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or ename:VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT + If pname:buffer was created with pname:usage containing ename:VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, pname:format must: be supported for uniform texel buffers, as specified by the ename:VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT flag in sname:VkFormatProperties::pname:bufferFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + If pname:buffer was created with pname:usage containing ename:VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, pname:format must: be supported for storage texel buffers, as specified by the ename:VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT flag in sname:VkFormatProperties::pname:bufferFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + + + + VkImageAspectFlags aspectMask + uint32_t mipLevel + uint32_t arrayLayer + + pname:mipLevel must: be less than the pname:mipLevels specified in slink:VkImageCreateInfo when the image was created + pname:arrayLayer must: be less than the pname:arrayLayers specified in slink:VkImageCreateInfo when the image was created + + + + VkImageAspectFlags aspectMask + uint32_t mipLevel + uint32_t baseArrayLayer + uint32_t layerCount + + If pname:aspectMask contains ename:VK_IMAGE_ASPECT_COLOR_BIT, it mustnot: contain either of ename:VK_IMAGE_ASPECT_DEPTH_BIT or ename:VK_IMAGE_ASPECT_STENCIL_BIT + pname:aspectMask mustnot: contain ename:VK_IMAGE_ASPECT_METADATA_BIT + pname:mipLevel must: be less than the pname:mipLevels specified in slink:VkImageCreateInfo when the image was created + latexmath:[$(baseArrayLayer + layerCount)$] must: be less than or equal to the pname:arrayLayers specified in slink:VkImageCreateInfo when the image was created + + + + VkImageAspectFlags aspectMask + uint32_t baseMipLevel + uint32_t levelCount + uint32_t baseArrayLayer + uint32_t layerCount + + latexmath:[$(baseMipLevel + levelCount)$] must: be less than or equal to the pname:mipLevels specified in slink:VkImageCreateInfo when the image was created + latexmath:[$(baseArrayLayer + layerCount)$] must: be less than or equal to the pname:arrayLayers specified in slink:VkImageCreateInfo when the image was created + + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMask + VkAccessFlags dstAccessMask + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMask + VkAccessFlags dstAccessMask + uint32_t srcQueueFamilyIndex + uint32_t dstQueueFamilyIndex + VkBuffer buffer + VkDeviceSize offset + VkDeviceSize size + + The value of pname:offset must: be less than the size of pname:buffer + The sum of pname:offset and pname:size must: be less than or equal to than the size of pname:buffer + If pname:buffer was created with a sharing mode of ename:VK_SHARING_MODE_CONCURRENT, pname:srcQueueFamilyIndex and pname:dstQueueFamilyIndex must: both be VK_QUEUE_FAMILY_IGNORED + If pname:buffer was created with a sharing mode of ename:VK_SHARING_MODE_EXCLUSIVE, pname:srcQueueFamilyIndex and pname:dstQueueFamilyIndex must: either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see <<devsandqueues-queueprops>>) + If pname:buffer was created with a sharing mode of ename:VK_SHARING_MODE_EXCLUSIVE, and pname:srcQueueFamilyIndex and pname:dstQueueFamilyIndex are valid queue families, at least one of them must: be the same as the family of the queue that will execute this barrier + + + + VkStructureType sType + const void* pNext + VkAccessFlags srcAccessMask + VkAccessFlags dstAccessMask + VkImageLayout oldLayout + VkImageLayout newLayout + uint32_t srcQueueFamilyIndex + uint32_t dstQueueFamilyIndex + VkImage image + VkImageSubresourceRange subresourceRange + + pname:oldLayout must: be ename:VK_IMAGE_LAYOUT_UNDEFINED, ename:VK_IMAGE_LAYOUT_PREINITIALIZED or the current layout of the image region affected by the barrier + pname:newLayout mustnot: be ename:VK_IMAGE_LAYOUT_UNDEFINED or ename:VK_IMAGE_LAYOUT_PREINITIALIZED + If pname:image was created with a sharing mode of ename:VK_SHARING_MODE_CONCURRENT, pname:srcQueueFamilyIndex and pname:dstQueueFamilyIndex must: both be VK_QUEUE_FAMILY_IGNORED + If pname:image was created with a sharing mode of ename:VK_SHARING_MODE_EXCLUSIVE, pname:srcQueueFamilyIndex and pname:dstQueueFamilyIndex must: either both be VK_QUEUE_FAMILY_IGNORED, or both be a valid queue family (see <<devsandqueues-queueprops>>) + If pname:image was created with a sharing mode of ename:VK_SHARING_MODE_EXCLUSIVE, and pname:srcQueueFamilyIndex and pname:dstQueueFamilyIndex are valid queue families, at least one of them must: be the same as the family of the queue that will execute this barrier + pname:subresourceRange must: be a valid subresource range for the image (see <<resources-image-views>>) + If pname:image has a depth/stencil format with both depth and stencil components, then pname:aspectMask member of pname:subresourceRange must: include both ename:VK_IMAGE_ASPECT_DEPTH_BIT and ename:VK_IMAGE_ASPECT_STENCIL_BIT + If either pname:oldLayout or pname:newLayout is ename:VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then pname:image must: have been created with ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set + If either pname:oldLayout or pname:newLayout is ename:VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then pname:image must: have been created with ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set + If either pname:oldLayout or pname:newLayout is ename:VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then pname:image must: have been created with ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set + If either pname:oldLayout or pname:newLayout is ename:VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then pname:image must: have been created with ename:VK_IMAGE_USAGE_SAMPLED_BIT or ename:VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set + If either pname:oldLayout or pname:newLayout is ename:VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then pname:image must: have been created with ename:VK_IMAGE_USAGE_TRANSFER_SRC_BIT set + If either pname:oldLayout or pname:newLayout is ename:VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then pname:image must: have been created with ename:VK_IMAGE_USAGE_TRANSFER_DST_BIT set + + + + VkStructureType sType + const void* pNext + VkImageCreateFlags flags + VkImageType imageType + VkFormat format + VkExtent3D extent + uint32_t mipLevels + uint32_t arrayLayers + VkSampleCountFlagBits samples + VkImageTiling tiling + VkImageUsageFlags usage + VkSharingMode sharingMode + uint32_t queueFamilyIndexCount + const uint32_t* pQueueFamilyIndices + VkImageLayout initialLayout + + If pname:sharingMode is ename:VK_SHARING_MODE_CONCURRENT, pname:pQueueFamilyIndices must: be a pointer to an array of pname:queueFamilyIndexCount basetype:uint32_t values + If pname:sharingMode is ename:VK_SHARING_MODE_CONCURRENT, pname:queueFamilyIndexCount must: be greater than `1` + pname:format mustnot: be ename:VK_FORMAT_UNDEFINED + The values of the pname:width, pname:height and pname:depth members of pname:extent must: all be greater than `0` + The value of pname:mipLevels must: be greater than `0` + The value of pname:arrayLayers must: be greater than `0` + If pname:imageType is ename:VK_IMAGE_TYPE_1D, the value of pname:extent.width must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxImageDimension1D, or the value of sname:VkImageFormatProperties::pname:maxExtent.width (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with values of pname:format, pname:type, pname:tiling, pname:usage and pname:flags equal to those in this structure) - whichever is higher + If pname:imageType is ename:VK_IMAGE_TYPE_2D and pname:flags does not contain ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, the value of pname:extent.width and pname:extent.height must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxImageDimension2D, or the value of sname:VkImageFormatProperties::pname:maxExtent.width/height (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with values of pname:format, pname:type, pname:tiling, pname:usage and pname:flags equal to those in this structure) - whichever is higher + If pname:imageType is ename:VK_IMAGE_TYPE_2D and pname:flags contains ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, the value of pname:extent.width and pname:extent.height must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxImageDimensionCube, or the value of sname:VkImageFormatProperties::pname:maxExtent.width/height (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with values of pname:format, pname:type, pname:tiling, pname:usage and pname:flags equal to those in this structure) - whichever is higher + If pname:imageType is ename:VK_IMAGE_TYPE_2D and pname:flags contains ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, the value of pname:extent.width and pname:extent.height must: be equal + If pname:imageType is ename:VK_IMAGE_TYPE_3D, the value of pname:extent.width, pname:extent.height and pname:extent.depth must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxImageDimension3D, or the value of sname:VkImageFormatProperties::pname:maxExtent.width/height/depth (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with values of pname:format, pname:type, pname:tiling, pname:usage and pname:flags equal to those in this structure) - whichever is higher + The value of pname:mipLevels must: be less than or equal to or equal to the value of latexmath:[$\lfloor\log_2(\max(\mathit{extent.width}, \mathit{extent.height}, \mathit{extent.depth}))\rfloor + 1$] + If the values of any of pname:extent.width, pname:extent.height or pname:extent.depth are greater than the values of the equivalently named members of sname:VkPhysicalDeviceLimits::pname:maxImageDimension3D, pname:mipLevels must: be less than or equal to the value of sname:VkImageFormatProperties::pname:maxMipLevels (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with values of pname:format, pname:type, pname:tiling, pname:usage and pname:flags equal to those in this structure) + The value of pname:arrayLayers must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxImageArrayLayers, or the value of sname:VkImageFormatProperties::pname:maxArrayLayers (as returned by fname:vkGetPhysicalDeviceImageFormatProperties with values of pname:format, pname:type, pname:tiling, pname:usage and pname:flags equal to those in this structure) - whichever is higher + The value of pname:samples must: be a bit value that is set in the value of sname:VkPhysicalDeviceLimits::pname:sampleCounts returned by flink:vkGetPhysicalDeviceProperties, or the value of sname:VkImageFormatProperties::pname:maxExtent.sampleCounts returned by fname:vkGetPhysicalDeviceImageFormatProperties with values of pname:format, pname:type, pname:tiling, pname:usage and pname:flags equal to those in this structure + If pname:usage includes ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, ename:VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT or ename:VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, the value of pname:extent.width must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxFramebufferWidth + If pname:usage includes ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, ename:VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT or ename:VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, the value of pname:extent.height must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxFramebufferHeight + If pname:usage includes ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, the value of pname:samples must: be a bit value that is set in the value of sname:VkPhysicalDeviceLimits::pname:maxFramebufferColorSamples + If pname:usage includes ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and pname:format includes a depth aspect, the value of pname:samples must: be a bit value that is set in the value of sname:VkPhysicalDeviceLimits::pname:maxFramebufferDepthSamples + If pname:usage includes ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, and pname:format includes a stencil aspect, the value of pname:samples must: be a bit value that is set in the value of sname:VkPhysicalDeviceLimits::pname:maxFramebufferStencilSamples + If pname:usage includes ename:VK_IMAGE_USAGE_SAMPLED_BIT, and pname:format includes a color aspect, the value of pname:samples must: be a bit value that is set in the value of sname:VkPhysicalDeviceLimits::pname:maxSampledImageColorSamples + If pname:usage includes ename:VK_IMAGE_USAGE_SAMPLED_BIT, and pname:format includes a depth aspect, the value of pname:samples must: be a bit value that is set in the value of sname:VkPhysicalDeviceLimits::pname:maxSampledImageDepthSamples + If pname:usage includes ename:VK_IMAGE_USAGE_SAMPLED_BIT, and pname:format is an integer format, the value of pname:samples must: be a bit value that is set in the value of sname:VkPhysicalDeviceLimits::pname:maxSampledImageIntegerSamples + If pname:usage includes ename:VK_IMAGE_USAGE_STORAGE_BIT, the value of pname:samples must: be a bit value that is set in the value of sname:VkPhysicalDeviceLimits::pname:maxStorageImageSamples + If the <<features-features-textureCompressionETC2,ETC2 texture compression>> feature is not enabled, pname:format mustnot: be ename:VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, ename:VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, ename:VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, ename:VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, ename:VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, ename:VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, ename:VK_FORMAT_EAC_R11_UNORM_BLOCK, ename:VK_FORMAT_EAC_R11_SNORM_BLOCK, ename:VK_FORMAT_EAC_R11G11_UNORM_BLOCK, or ename:VK_FORMAT_EAC_R11G11_SNORM_BLOCK + If the <<features-features-textureCompressionASTC_LDR,ASTC LDR texture compression>> feature is not enabled, pname:format mustnot: be ename:VK_FORMAT_ASTC_4x4_UNORM_BLOCK, ename:VK_FORMAT_ASTC_4x4_SRGB_BLOCK, ename:VK_FORMAT_ASTC_5x4_UNORM_BLOCK, ename:VK_FORMAT_ASTC_5x4_SRGB_BLOCK, ename:VK_FORMAT_ASTC_5x5_UNORM_BLOCK, ename:VK_FORMAT_ASTC_5x5_SRGB_BLOCK, ename:VK_FORMAT_ASTC_6x5_UNORM_BLOCK, ename:VK_FORMAT_ASTC_6x5_SRGB_BLOCK, ename:VK_FORMAT_ASTC_6x6_UNORM_BLOCK, ename:VK_FORMAT_ASTC_6x6_SRGB_BLOCK, ename:VK_FORMAT_ASTC_8x5_UNORM_BLOCK, ename:VK_FORMAT_ASTC_8x5_SRGB_BLOCK, ename:VK_FORMAT_ASTC_8x6_UNORM_BLOCK, ename:VK_FORMAT_ASTC_8x6_SRGB_BLOCK, ename:VK_FORMAT_ASTC_8x8_UNORM_BLOCK, ename:VK_FORMAT_ASTC_8x8_SRGB_BLOCK, ename:VK_FORMAT_ASTC_10x5_UNORM_BLOCK, ename:VK_FORMAT_ASTC_10x5_SRGB_BLOCK, ename:VK_FORMAT_ASTC_10x6_UNORM_BLOCK, ename:VK_FORMAT_ASTC_10x6_SRGB_BLOCK, ename:VK_FORMAT_ASTC_10x8_UNORM_BLOCK, ename:VK_FORMAT_ASTC_10x8_SRGB_BLOCK, ename:VK_FORMAT_ASTC_10x10_UNORM_BLOCK, ename:VK_FORMAT_ASTC_10x10_SRGB_BLOCK, ename:VK_FORMAT_ASTC_12x10_UNORM_BLOCK, ename:VK_FORMAT_ASTC_12x10_SRGB_BLOCK, ename:VK_FORMAT_ASTC_12x12_UNORM_BLOCK, or ename:VK_FORMAT_ASTC_12x12_SRGB_BLOCK + If the <<features-features-textureCompressionBC,BC texture compression>> feature is not enabled, pname:format mustnot: be ename:VK_FORMAT_BC1_RGB_UNORM_BLOCK, ename:VK_FORMAT_BC1_RGB_SRGB_BLOCK, ename:VK_FORMAT_BC1_RGBA_UNORM_BLOCK, ename:VK_FORMAT_BC1_RGBA_SRGB_BLOCK, ename:VK_FORMAT_BC2_UNORM_BLOCK, ename:VK_FORMAT_BC2_SRGB_BLOCK, ename:VK_FORMAT_BC3_UNORM_BLOCK, ename:VK_FORMAT_BC3_SRGB_BLOCK, ename:VK_FORMAT_BC4_UNORM_BLOCK, ename:VK_FORMAT_BC4_SNORM_BLOCK, ename:VK_FORMAT_BC5_UNORM_BLOCK, ename:VK_FORMAT_BC5_SNORM_BLOCK, ename:VK_FORMAT_BC6H_UFLOAT_BLOCK, ename:VK_FORMAT_BC6H_SFLOAT_BLOCK, ename:VK_FORMAT_BC7_UNORM_BLOCK, or ename:VK_FORMAT_BC7_SRGB_BLOCK + If the <<features-features-shaderStorageImageMultisample,multisampled storage images>> feature is not enabled, and pname:usage contains ename:VK_IMAGE_USAGE_STORAGE_BIT, pname:samples must: be ename:VK_SAMPLE_COUNT_1_BIT + If the <<features-features-sparseBinding,sparse bindings>> feature is not enabled, pname:flags mustnot: contain ename:VK_IMAGE_CREATE_SPARSE_BINDING_BIT + If the <<features-features-sparseResidencyImage2D,sparse residency for 2D images>> feature is not enabled, and pname:imageType is VK_IMAGE_TYPE_2D, pname:flags mustnot: contain ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + If the <<features-features-sparseResidencyImage3D,sparse residency for 3D images>> feature is not enabled, and pname:imageType is VK_IMAGE_TYPE_3D, pname:flags mustnot: contain ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + If the <<features-features-sparseResidency2Samples,sparse residency for images with 2 samples>> feature is not enabled, pname:imageType is VK_IMAGE_TYPE_2D, and pname:samples is ename:VK_SAMPLE_COUNT_2_BIT, pname:flags mustnot: contain ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + If the <<features-features-sparseResidency4Samples,sparse residency for images with 4 samples>> feature is not enabled, pname:imageType is VK_IMAGE_TYPE_2D, and pname:samples is ename:VK_SAMPLE_COUNT_4_BIT, pname:flags mustnot: contain ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + If the <<features-features-sparseResidency8Samples,sparse residency for images with 8 samples>> feature is not enabled, pname:imageType is VK_IMAGE_TYPE_2D, and pname:samples is ename:VK_SAMPLE_COUNT_8_BIT, pname:flags mustnot: contain ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + If the <<features-features-sparseResidency16Samples,sparse residency for images with 16 samples>> feature is not enabled, pname:imageType is VK_IMAGE_TYPE_2D, and pname:samples is ename:VK_SAMPLE_COUNT_16_BIT, pname:flags mustnot: contain ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + If the value of pname:tiling is ename:VK_IMAGE_TILING_LINEAR, and the value of sname:VkFormatProperties::pname:linearTilingFeatures (as returned by fname:vkGetPhysicalDeviceFormatProperties with the same value of pname:format) does not include VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, pname:usage mustnot: contain ename:VK_IMAGE_USAGE_SAMPLED_BIT + If the value of pname:tiling is ename:VK_IMAGE_TILING_LINEAR, and the value of sname:VkFormatProperties::pname:linearTilingFeatures (as returned by fname:vkGetPhysicalDeviceFormatProperties with the same value of pname:format) does not include VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, pname:usage mustnot: contain ename:VK_IMAGE_USAGE_STORAGE_BIT + If the value of pname:tiling is ename:VK_IMAGE_TILING_LINEAR, and the value of sname:VkFormatProperties::pname:linearTilingFeatures (as returned by fname:vkGetPhysicalDeviceFormatProperties with the same value of pname:format) does not include VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, pname:usage mustnot: contain ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT + If the value of pname:tiling is ename:VK_IMAGE_TILING_LINEAR, and the value of sname:VkFormatProperties::pname:linearTilingFeatures (as returned by fname:vkGetPhysicalDeviceFormatProperties with the same value of pname:format) does not include VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, pname:usage mustnot: contain ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT + If the value of pname:tiling is ename:VK_IMAGE_TILING_OPTIMAL, and the value of sname:VkFormatProperties::pname:optimalTilingFeatures (as returned by fname:vkGetPhysicalDeviceFormatProperties with the same value of pname:format) does not include VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, pname:usage mustnot: contain ename:VK_IMAGE_USAGE_SAMPLED_BIT + If the value of pname:tiling is ename:VK_IMAGE_TILING_OPTIMAL, and the value of sname:VkFormatProperties::pname:optimalTilingFeatures (as returned by fname:vkGetPhysicalDeviceFormatProperties with the same value of pname:format) does not include VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, pname:usage mustnot: contain ename:VK_IMAGE_USAGE_STORAGE_BIT + If the value of pname:tiling is ename:VK_IMAGE_TILING_OPTIMAL, and the value of sname:VkFormatProperties::pname:optimalTilingFeatures (as returned by fname:vkGetPhysicalDeviceFormatProperties with the same value of pname:format) does not include VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, pname:usage mustnot: contain ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT + If the value of pname:tiling is ename:VK_IMAGE_TILING_OPTIMAL, and the value of sname:VkFormatProperties::pname:optimalTilingFeatures (as returned by fname:vkGetPhysicalDeviceFormatProperties with the same value of pname:format) does not include VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, pname:usage mustnot: contain ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT + If pname:flags contains ename:VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, it must: also contain at least one of ename:VK_IMAGE_CREATE_SPARSE_BINDING_BIT or ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT + + + + VkDeviceSize offset + VkDeviceSize size + VkDeviceSize rowPitch + VkDeviceSize arrayPitch + VkDeviceSize depthPitch + + + VkStructureType sType + const void* pNext + VkImageViewCreateFlags flags + VkImage image + VkImageViewType viewType + VkFormat format + VkComponentMapping components + VkImageSubresourceRange subresourceRange + + If pname:image was not created with ename:VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT then pname:viewType mustnot: be ename:VK_IMAGE_VIEW_TYPE_CUBE or ename:VK_IMAGE_VIEW_TYPE_CUBE_ARRAY + If the <<features-features-imageCubeArray,image cubemap arrays>> feature is not enabled, pname:viewType mustnot: be ename:VK_IMAGE_VIEW_TYPE_CUBE_ARRAY + If the <<features-features-textureCompressionETC2,ETC2 texture compression>> feature is not enabled, pname:format mustnot: be ename:VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, ename:VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, ename:VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, ename:VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, ename:VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, ename:VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, ename:VK_FORMAT_EAC_R11_UNORM_BLOCK, ename:VK_FORMAT_EAC_R11_SNORM_BLOCK, ename:VK_FORMAT_EAC_R11G11_UNORM_BLOCK, or ename:VK_FORMAT_EAC_R11G11_SNORM_BLOCK + If the <<features-features-textureCompressionASTC_LDR,ASTC LDR texture compression>> feature is not enabled, pname:format mustnot: be ename:VK_FORMAT_ASTC_4x4_UNORM_BLOCK, ename:VK_FORMAT_ASTC_4x4_SRGB_BLOCK, ename:VK_FORMAT_ASTC_5x4_UNORM_BLOCK, ename:VK_FORMAT_ASTC_5x4_SRGB_BLOCK, ename:VK_FORMAT_ASTC_5x5_UNORM_BLOCK, ename:VK_FORMAT_ASTC_5x5_SRGB_BLOCK, ename:VK_FORMAT_ASTC_6x5_UNORM_BLOCK, ename:VK_FORMAT_ASTC_6x5_SRGB_BLOCK, ename:VK_FORMAT_ASTC_6x6_UNORM_BLOCK, ename:VK_FORMAT_ASTC_6x6_SRGB_BLOCK, ename:VK_FORMAT_ASTC_8x5_UNORM_BLOCK, ename:VK_FORMAT_ASTC_8x5_SRGB_BLOCK, ename:VK_FORMAT_ASTC_8x6_UNORM_BLOCK, ename:VK_FORMAT_ASTC_8x6_SRGB_BLOCK, ename:VK_FORMAT_ASTC_8x8_UNORM_BLOCK, ename:VK_FORMAT_ASTC_8x8_SRGB_BLOCK, ename:VK_FORMAT_ASTC_10x5_UNORM_BLOCK, ename:VK_FORMAT_ASTC_10x5_SRGB_BLOCK, ename:VK_FORMAT_ASTC_10x6_UNORM_BLOCK, ename:VK_FORMAT_ASTC_10x6_SRGB_BLOCK, ename:VK_FORMAT_ASTC_10x8_UNORM_BLOCK, ename:VK_FORMAT_ASTC_10x8_SRGB_BLOCK, ename:VK_FORMAT_ASTC_10x10_UNORM_BLOCK, ename:VK_FORMAT_ASTC_10x10_SRGB_BLOCK, ename:VK_FORMAT_ASTC_12x10_UNORM_BLOCK, ename:VK_FORMAT_ASTC_12x10_SRGB_BLOCK, ename:VK_FORMAT_ASTC_12x12_UNORM_BLOCK, or ename:VK_FORMAT_ASTC_12x12_SRGB_BLOCK + If the <<features-features-textureCompressionBC,BC texture compression>> feature is not enabled, pname:format mustnot: be ename:VK_FORMAT_BC1_RGB_UNORM_BLOCK, ename:VK_FORMAT_BC1_RGB_SRGB_BLOCK, ename:VK_FORMAT_BC1_RGBA_UNORM_BLOCK, ename:VK_FORMAT_BC1_RGBA_SRGB_BLOCK, ename:VK_FORMAT_BC2_UNORM_BLOCK, ename:VK_FORMAT_BC2_SRGB_BLOCK, ename:VK_FORMAT_BC3_UNORM_BLOCK, ename:VK_FORMAT_BC3_SRGB_BLOCK, ename:VK_FORMAT_BC4_UNORM_BLOCK, ename:VK_FORMAT_BC4_SNORM_BLOCK, ename:VK_FORMAT_BC5_UNORM_BLOCK, ename:VK_FORMAT_BC5_SNORM_BLOCK, ename:VK_FORMAT_BC6H_UFLOAT_BLOCK, ename:VK_FORMAT_BC6H_SFLOAT_BLOCK, ename:VK_FORMAT_BC7_UNORM_BLOCK, or ename:VK_FORMAT_BC7_SRGB_BLOCK + If pname:image was created with ename:VK_IMAGE_TILING_LINEAR and pname:usage containing ename:VK_IMAGE_USAGE_SAMPLED_BIT, pname:format must: be supported for sampled images, as specified by the ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + If pname:image was created with ename:VK_IMAGE_TILING_LINEAR and pname:usage containing ename:VK_IMAGE_USAGE_STORAGE_BIT, pname:format must: be supported for storage images, as specified by the ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + If pname:image was created with ename:VK_IMAGE_TILING_LINEAR and pname:usage containing ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, pname:format must: be supported for color attachments, as specified by the ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + If pname:image was created with ename:VK_IMAGE_TILING_LINEAR and pname:usage containing ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, pname:format must: be supported for depth/stencil attachments, as specified by the ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + If pname:image was created with ename:VK_IMAGE_TILING_OPTIMAL and pname:usage containing ename:VK_IMAGE_USAGE_SAMPLED_BIT, pname:format must: be supported for sampled images, as specified by the ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT flag in sname:VkFormatProperties::pname:optimalTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + If pname:image was created with ename:VK_IMAGE_TILING_OPTIMAL and pname:usage containing ename:VK_IMAGE_USAGE_STORAGE_BIT, pname:format must: be supported for storage images, as specified by the ename:VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT flag in sname:VkFormatProperties::pname:optimalTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + If pname:image was created with ename:VK_IMAGE_TILING_OPTIMAL and pname:usage containing ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, pname:format must: be supported for color attachments, as specified by the ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in sname:VkFormatProperties::pname:optimalTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + If pname:image was created with ename:VK_IMAGE_TILING_OPTIMAL and pname:usage containing ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, pname:format must: be supported for depth/stencil attachments, as specified by the ename:VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT flag in sname:VkFormatProperties::pname:optimalTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + pname:subresourceRange must: be a valid subresource range for pname:image (see <<resources-image-views>>) + If pname:image was created with the ename:VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, pname:format must: be compatible with the pname:format used to create pname:image, as defined in <<features-formats-compatibility-classes,Format Compatibility Classes>> + If pname:image was not created with the ename:VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, pname:format must: be identical to the pname:format used to create pname:image + pname:subResourceRange and pname:viewType must: be compatible with the image, as described in the <<resources-image-views-compatibility,table below>> + + + + VkDeviceSize srcOffset + VkDeviceSize dstOffset + VkDeviceSize size + + + VkDeviceSize resourceOffset + VkDeviceSize size + VkDeviceMemory memory + VkDeviceSize memoryOffset + VkSparseMemoryBindFlagsflags + + If pname:memory is not sname:VK_NULL_HANDLE, pname:memory and pname:memoryOffset must: match the memory requirements of the resource, as described in section <<resources-association>> + If pname:memory is not sname:VK_NULL_HANDLE, pname:memory mustnot: have been created with a memory type that reports ename:VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT bit set + pname:resourceOffset must: be less than the size of the resource + The sum of pname:resourceOffset and pname:size must: be less than or equal to the size of the resource + pname:memoryOffset must: be less than the size of pname:memory + The sum of pname:memoryOffset and pname:size must: be less than or equal to the size of pname:memory + + + + VkImageSubresource subresource + VkOffset3D offset + VkExtent3D extent + VkDeviceMemory memory + VkDeviceSize memoryOffset + VkSparseMemoryBindFlagsflags + + If the <<features-features-sparseResidencyAliased,sparse aliased residency>> feature is not enabled, and if any other resources are bound to ranges of pname:memory, the range of pname:memory being bound mustnot: overlap with those bound ranges + pname:memory and pname:memoryOffset must: match the memory requirements of the calling command's pname:image, as described in section <<resources-association>> + pname:subresource must: be a valid subresource for pname:image (see <<resources-image-views>>) + pname:offset.x must: be a multiple of the block width (sname:VkSparseImageFormatProperties::pname:imageGranularity.width) of the image + pname:extent.width must: either be a multiple of the block width of the image, or else pname:extent.width + pname:offset.x must: equal the width of the image subresource + pname:offset.y must: be a multiple of the block height (sname:VkSparseImageFormatProperties::pname:imageGranularity.height) of the image + pname:extent.height must: either be a multiple of the block height of the image, or else pname:extent.height + pname:offset.y must: equal the height of the image subresource + pname:offset.z must: be a multiple of the block depth (sname:VkSparseImageFormatProperties::pname:imageGranularity.depth) of the image + pname:extent.depth must: either be a multiple of the block depth of the image, or else pname:extent.depth + pname:offset.z must: equal the depth of the image subresource + + + + VkBuffer buffer + uint32_t bindCount + const VkSparseMemoryBind* pBinds + + + VkImage image + uint32_t bindCount + const VkSparseMemoryBind* pBinds + + For any given element of pname:pBinds, if the pname:flags member of that element contains ename:VK_SPARSE_MEMORY_BIND_METADATA_BIT, the binding range defined must: be within the mip tail region of the metadata aspect of pname:image + + + + VkImage image + uint32_t bindCount + const VkSparseImageMemoryBind* pBinds + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + uint32_t bufferBindCount + const VkSparseBufferMemoryBindInfo* pBufferBinds + uint32_t imageOpaqueBindCount + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds + uint32_t imageBindCount + const VkSparseImageMemoryBindInfo* pImageBinds + uint32_t signalSemaphoreCount + const VkSemaphore* pSignalSemaphores + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffset + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffset + VkExtent3D extent + + The pname:aspectMask member of pname:srcSubresource and pname:dstSubresource must: match + The pname:layerCount member of pname:srcSubresource and pname:dstSubresource must: match + If either of the calling command's pname:srcImage or pname:dstImage parameters are of elink:VkImageType ename:VK_IMAGE_TYPE_3D, the pname:baseArrayLayer and pname:layerCount members of both pname:srcSubresource and pname:dstSubresource must: be `0` and `1`, respectively + The pname:aspectMask member of pname:srcSubresource must: specify aspects present in the calling command's pname:srcImage + The pname:aspectMask member of pname:dstSubresource must: specify aspects present in the calling command's pname:dstImage + pname:srcOffset.x and (pname:extent.width + pname:srcOffset.x) must: both be greater than or equal to `0` and less than or equal to the source image subresource width + pname:srcOffset.y and (pname:extent.height + pname:srcOffset.y) must: both be greater than or equal to `0` and less than or equal to the source image subresource height + pname:srcOffset.z and (pname:extent.depth + pname:srcOffset.z) must: both be greater than or equal to `0` and less than or equal to the source image subresource depth + pname:dstOffset.x and (pname:extent.width + pname:dstOffset.x) must: both be greater than or equal to `0` and less than or equal to the destination image subresource width + pname:dstOffset.y and (pname:extent.height + pname:dstOffset.y) must: both be greater than or equal to `0` and less than or equal to the destination image subresource height + pname:dstOffset.z and (pname:extent.depth + pname:dstOffset.z) must: both be greater than or equal to `0` and less than or equal to the destination image subresource depth + If the calling command's pname:srcImage is a compressed format image: + all members of pname:srcOffset must: be a multiple of the block size in the relevant dimensions + pname:extent.width must: be a multiple of the block width or (pname:extent.width + pname:srcOffset.x) must: equal the source image subresource width + pname:extent.height must: be a multiple of the block height or (pname:extent.height + pname:srcOffset.y) must: equal the source image subresource height + pname:extent.depth must: be a multiple of the block depth or (pname:extent.depth + pname:srcOffset.z) must: equal the source image subresource depth + If the calling command's pname:dstImage is a compressed format image: + all members of pname:dstOffset must: be a multiple of the block size in the relevant dimensions + pname:extent.width must: be a multiple of the block width or (pname:extent.width + pname:dstOffset.x) must: equal the destination image subresource width + pname:extent.height must: be a multiple of the block height or (pname:extent.height + pname:dstOffset.y) must: equal the destination image subresource height + pname:extent.depth must: be a multiple of the block depth or (pname:extent.depth + pname:dstOffset.z) must: equal the destination image subresource depth + pname:srcOffset, pname:dstOffset, and pname:extent must: respect the image transfer granularity requirements of the queue family that it will be submitted against, as described in <<execution-physical-device-enumeration,Physical Device Enumeration>> + + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffsets[2] + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffsets[2] + + The pname:aspectMask member of pname:srcSubresource and pname:dstSubresource must: match + The pname:layerCount member of pname:srcSubresource and pname:dstSubresource must: match + If either of the calling command's pname:srcImage or pname:dstImage parameters are of elink:VkImageType ename:VK_IMAGE_TYPE_3D, the pname:baseArrayLayer and pname:layerCount members of both pname:srcSubresource and pname:dstSubresource must: be `0` and `1`, respectively + The pname:aspectMask member of pname:srcSubresource must: specify aspects present in the calling command's pname:srcImage + The pname:aspectMask member of pname:dstSubresource must: specify aspects present in the calling command's pname:dstImage + pname:srcOffset[0].x and pname:srcOffset[1].x must: both be greater than or equal to `0` and less than or equal to the source image subresource width + pname:srcOffset[0].y and pname:srcOffset[1].y must: both be greater than or equal to `0` and less than or equal to the source image subresource height + pname:srcOffset[0].z and pname:srcOffset[1].z must: both be greater than or equal to `0` and less than or equal to the source image subresource depth + pname:dstOffset[0].x and pname:dstOffset[1].x must: both be greater than or equal to `0` and less than or equal to the destination image subresource width + pname:dstOffset[0].y and pname:dstOffset[1].y must: both be greater than or equal to `0` and less than or equal to the destination image subresource height + pname:dstOffset[0].z and pname:dstOffset[1].z must: both be greater than or equal to `0` and less than or equal to the destination image subresource depth + + + + VkDeviceSize bufferOffset + uint32_t bufferRowLength + uint32_t bufferImageHeight + VkImageSubresourceLayers imageSubresource + VkOffset3D imageOffset + VkExtent3D imageExtent + + pname:bufferOffset must: be a multiple of the calling command's sname:VkImage parameter's texel size + pname:bufferOffset must: be a multiple of `4` + pname:bufferRowLength must: be `0`, or greater than or equal to the pname:width member of pname:imageExtent + pname:bufferImageHeight must: be `0`, or greater than or equal to the pname:height member of pname:imageExtent + pname:imageOffset.x and (pname:imageExtent.width + pname:imageOffset.x) must: both be greater than or equal to `0` and less than or equal to the image subresource width + pname:imageOffset.y and (imageExtent.height + pname:imageOffset.y) must: both be greater than or equal to `0` and less than or equal to the image subresource height + pname:imageOffset.z and (imageExtent.depth + pname:imageOffset.z) must: both be greater than or equal to `0` and less than or equal to the image subresource depth + If the calling command's sname:VkImage parameter is a compressed format image: + pname:bufferRowLength, pname:bufferImageHeight and all members of pname:imageOffset must: be a multiple of the block size in the relevant dimensions + pname:bufferOffset must: be a multiple of the block size in bytes + pname:imageExtent.width must: be a multiple of the block width or (pname:imageExtent.width + pname:imageOffset.x) must: equal the image subresource width + pname:imageExtent.height must: be a multiple of the block height or (pname:imageExtent.height + pname:imageOffset.y) must: equal the image subresource height + pname:imageExtent.depth must: be a multiple of the block depth or (pname:imageExtent.depth + pname:imageOffset.z) must: equal the image subresource depth + pname:bufferOffset, pname:bufferRowLength, pname:bufferImageHeight and all members of pname:imageOffset and pname:imageExtent must: respect the image transfer granularity requirements of the queue family that it will be submitted against, as described in <<execution-physical-device-enumeration,Physical Device Enumeration>> + The pname:aspectMask member of pname:srcSubresource must: specify aspects present in the calling command's sname:VkImage parameter + The pname:aspectMask member of pname:pSubresource must: only have a single bit set + If the calling command's sname:VkImage parameter is of elink:VkImageType ename:VK_IMAGE_TYPE_3D, the pname:baseArrayLayer and pname:layerCount members of both pname:srcSubresource and pname:dstSubresource must: be `0` and `1`, respectively + + + + VkImageSubresourceLayers srcSubresource + VkOffset3D srcOffset + VkImageSubresourceLayers dstSubresource + VkOffset3D dstOffset + VkExtent3D extent + + The pname:aspectMask member of pname:srcSubresource and pname:dstSubresource must: only contain ename:VK_IMAGE_ASPECT_COLOR_BIT + The pname:layerCount member of pname:srcSubresource and pname:dstSubresource must: match + If either of the calling command's pname:srcImage or pname:dstImage parameters are of elink:VkImageType ename:VK_IMAGE_TYPE_3D, the pname:baseArrayLayer and pname:layerCount members of both pname:srcSubresource and pname:dstSubresource must: be `0` and `1`, respectively + + + + VkStructureType sType + const void* pNext + VkShaderModuleCreateFlags flags + size_t codeSize + const uint32_t* pCode + + pname:codeSize must: be greater than 0 + pname:codeSize must: be a multiple of 4 + pname:pCode must: point to valid SPIR-V code, formatted and packed as described by https://www.khronos.org/registry/spir-v/specs/1.0/SPIRV.html[the SPIR-V Specification v1.0] + pname:pCode must: adhere to the validation rules described by the <<spirvenv-module-validation, Validation Rules within a Module>> section of the <<spirvenv-capabilities,SPIR-V Environment>> appendix + pname:pCode must: declare the code:Shader capability + pname:pCode mustnot: declare any capability that is not supported by the API, as described by the <<spirvenv-module-validation, Capabilities>> section of the <<spirvenv-capabilities,SPIR-V Environment>> appendix + If pname:pCode declares any of the capabilities that are listed as not required by the implementation, the relevant feature must: be enabled, as listed in the <<spirvenv-capabilities-table,SPIR-V Environment>> appendix + + + + uint32_t binding + VkDescriptorType descriptorType + uint32_t descriptorCount + VkShaderStageFlags stageFlags + const VkSampler* pImmutableSamplers + + If pname:descriptorType is ename:VK_DESCRIPTOR_TYPE_SAMPLER or ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and pname:descriptorCount is not `0` and pname:pImmutableSamplers is not `NULL`, pname:pImmutableSamplers must: be a pointer to an array of pname:descriptorCount valid sname:VkSampler handles + If pname:descriptorCount is not `0`, pname:stageFlags must: be a valid combination of elink:VkShaderStageFlagBits values + + + + VkStructureType sType + const void* pNext + VkDescriptorSetLayoutCreateFlags flags + uint32_t bindingCount + const VkDescriptorSetLayoutBinding* pBindings + + + VkDescriptorType type + uint32_t descriptorCount + + The value of pname:descriptorCount must: be greater than `0` + + + + VkStructureType sType + const void* pNext + VkDescriptorPoolCreateFlags flags + uint32_t maxSets + uint32_t poolSizeCount + const VkDescriptorPoolSize* pPoolSizes + + The value of pname:maxSets must: be greater than `0` + + + + VkStructureType sType + const void* pNext + VkDescriptorPool descriptorPool + uint32_t descriptorSetCount + const VkDescriptorSetLayout* pSetLayouts + + The value of pname:descriptorSetCount mustnot: be greater than the number of sets that are currently available for allocation in pname:descriptorPool + + + + uint32_t constantID + uint32_t offset + size_t size + + + uint32_t mapEntryCount + const VkSpecializationMapEntry* pMapEntries + size_t dataSize + const void* pData + + The pname:offset member of any given element of pname:pMapEntries must: be less than pname:dataSize + The sum of the pname:offset and pname:size members of any given element of pname:pMapEntries must: be less than or equal to pname:dataSize + + + + VkStructureType sType + const void* pNext + VkPipelineShaderStageCreateFlags flags + VkShaderStageFlagBits stage + VkShaderModule module + const char* pName + const VkSpecializationInfo* pSpecializationInfo + + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, pname:stage mustnot: be pname:VK_SHADER_STAGE_GEOMETRY_BIT + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, pname:stage mustnot: be pname:VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or pname:VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT + pname:stage mustnot: be ename:VK_SHADER_STAGE_ALL_GRAPHICS, or ename:VK_SHADER_STAGE_ALL + pname:pName must: be the name of an code:OpEntryPoint in pname:module with an execution model that matches pname:stage + If the identified entry point includes any variable in its interface that is declared with the code:ClipDistance code:BuiltIn decoration, that variable mustnot: have an array size greater than sname:VkPhysicalDeviceLimits::pname:maxClipDistances + If the identified entry point includes any variable in its interface that is declared with the code:CullDistance code:BuiltIn decoration, that variable mustnot: have an array size greater than sname:VkPhysicalDeviceLimits::pname:maxCullDistances + If the identified entry point includes any variables in its interface that are declared with the code:ClipDistance or code:CullDistance code:BuiltIn decoration, those variables mustnot: have array sizes which sum to more than sname:VkPhysicalDeviceLimits::pname:maxCombinedClipAndCullDistances + If the identified entry point includes any variable in its interface that is declared with the code:SampleMask code:BuiltIn decoration, that variable mustnot: have an array size greater than sname:VkPhysicalDeviceLimits::pname:maxSampleMaskWords + If pname:stage is ename:VK_SHADER_STAGE_VERTEX_BIT, the identified entry point mustnot: include any input variable in its interface that is decorated with code:CullDistance + If pname:stage is ename:VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or ename:VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and the identified entry point has an code:OpExecutionMode instruction that specifies a patch size with code:OutputVertices, the patch size must: be greater than `0` and less than or equal to sname:VkPhysicalDeviceLimits::pname:maxTessellationPatchSize + If pname:stage is ename:VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must: have an code:OpExecutionMode instruction that specifies a maximum output vertex count that is greater than `0` and less than or equal to sname:VkPhysicalDeviceLimits::pname:maxGeometryOutputVertices + If pname:stage is ename:VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must: have an code:OpExecutionMode instruction that specifies an invocation count that is greater than `0` and less than or equal to sname:VkPhysicalDeviceLimits::pname:maxGeometryShaderInvocations + If pname:stage is ename:VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to code:Layer for any primitive, it must: write the same value to code:Layer for all vertices of a given primitive + If pname:stage is ename:VK_SHADER_STAGE_GEOMETRY_BIT, and the identified entry point writes to code:ViewportIndex for any primitive, it must: write the same value to code:ViewportIndex for all vertices of a given primitive + If pname:stage is ename:VK_SHADER_STAGE_FRAGMENT_BIT, the identified entry point mustnot: include any output variables in its interface decorated with code:CullDistance + If pname:stage is ename:VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to code:FragDepth in any execution path, it must: write to code:FragDepth in all execution paths + + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flags + VkPipelineShaderStageCreateInfo stage + VkPipelineLayout layout + VkPipeline basePipelineHandle + int32_t basePipelineIndex + + If pname:flags contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and pname:basePipelineIndex is not `-1`, pname:basePipelineHandle must: be sname:VK_NULL_HANDLE + If pname:flags contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and pname:basePipelineIndex is not `-1`, it must: be a valid index into the calling command's pname:pCreateInfos parameter + If pname:flags contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and pname:basePipelineHandle is not sname:VK_NULL_HANDLE, pname:basePipelineIndex must: be `-1` + If pname:flags contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and pname:basePipelineHandle is not sname:VK_NULL_HANDLE, pname:basePipelineHandle must: be a valid sname:VkPipeline handle + If pname:flags contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and pname:basePipelineHandle is not sname:VK_NULL_HANDLE, it must: be a valid handle to a compute sname:VkPipeline + The pname:stage member of pname:stage must: be ename:VK_SHADER_STAGE_COMPUTE_BIT + The shader code for the entry point identified by pname:stage and the rest of the state identified by this structure must: adhere to the pipeline linking rules described in the <<interfaces,Shader Interfaces>> chapter + pname:layout must: be <<descriptorsets-pipelinelayout-consistency,consistent>> with all shaders specified in pname:pStages + + + + uint32_t binding + uint32_t stride + VkVertexInputRate inputRate + + pname:binding must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxVertexInputBindings + pname:stride must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxVertexInputBindingStride + + + + uint32_t location + uint32_t binding + VkFormat format + uint32_t offset + + pname:binding must: be less than sname:VkPhysicalDeviceLimits::pname:maxVertexInputBindings + pname:offset must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxVertexInputAttributeOffset + pname:format must: be allowed as a vertex buffer format, as specified by the ename:VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT flag in sname:VkFormatProperties::pname:bufferFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + + + + VkStructureType sType + const void* pNext + VkPipelineVertexInputStateCreateFlags flags + uint32_t vertexBindingDescriptionCount + const VkVertexInputBindingDescription* pVertexBindingDescriptions + uint32_t vertexAttributeDescriptionCount + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions + + pname:vertexBindingDescriptionCount must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxVertexInputBindings + pname:vertexAttributeDescriptionCount must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxVertexInputAttributes + For every value of pname:binding specified by any given element of pname:pVertexAttributeDescriptions, a sname:VkVertexInputBindingDescription must: exist in pname:pVertexBindingDescriptions with the same value of pname:binding + All elements of pname:pVertexBindingDescriptions must: describe distinct binding numbers + All elements of pname:pVertexAttributeDescriptions must: describe distinct attribute locations + + + + + VkStructureType sType + const void* pNext + VkPipelineInputAssemblyStateCreateFlags flags + VkPrimitiveTopology topology + VkBool32 primitiveRestartEnable + + If pname:topology is ename:VK_PRIMITIVE_TOPOLOGY_POINT_LIST, ename:VK_PRIMITIVE_TOPOLOGY_LINE_LIST, ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, ename:VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or ename:VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the value of pname:primitiveRestartEnable must: be ename:VK_FALSE + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, pname:topology mustnot: be any of ename:VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, ename:VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY or ename:VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, pname:topology mustnot: be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST + + + + VkStructureType sType + const void* pNext + VkPipelineTessellationStateCreateFlags flags + uint32_t patchControlPoints + + pname:patchControlPoints must: be greater than zero and less than or equal to sname:VkPhysicalDeviceLimits::pname:maxTessellationPatchSize + + + + VkStructureType sType + const void* pNext + VkPipelineViewportStateCreateFlags flags + uint32_t viewportCount + const VkViewport* pViewports + uint32_t scissorCount + const VkRect2D* pScissors + + If the <<features-features-multiViewport,multiple viewports>> feature is not enabled, pname:viewportCount must: be `1` + If the <<features-features-multiViewport,multiple viewports>> feature is not enabled, pname:scissorCount must: be `1` + pname:viewportCount must: be between `1` and sname:VkPhysicalDeviceLimits::pname:maxViewports, inclusive + pname:scissorCount must: be between `1` and sname:VkPhysicalDeviceLimits::pname:maxViewports, inclusive + The values of pname:scissorCount and pname:viewportCount must: be identical + + + + VkStructureType sType + const void* pNext + VkPipelineRasterizationStateCreateFlags flags + VkBool32 depthClampEnable + VkBool32 rasterizerDiscardEnable + VkPolygonMode polygonMode + VkCullModeFlags cullMode + VkFrontFace frontFace + VkBool32 depthBiasEnable + float depthBiasConstantFactor + float depthBiasClamp + float depthBiasSlopeFactor + float lineWidth + + If the <<features-features-depthClamp,depth clamping>> feature is not enabled, the value of pname:depthClampEnable must: be ename:VK_FALSE + If the <<features-features-fillModeNonSolid,non-solid fill modes>> feature is not enabled, the value of pname:fillMode must: be ename:VK_POLYGON_MODE_FILL + + + + VkStructureType sType + const void* pNext + VkPipelineMultisampleStateCreateFlags flags + VkSampleCountFlagBits rasterizationSamples + VkBool32 sampleShadingEnable + float minSampleShading + const VkSampleMask* pSampleMask + VkBool32 alphaToCoverageEnable + VkBool32 alphaToOneEnable + + If the <<features-features-sampleRateShading,sample rate shading>> feature is not enabled, pname:sampleShadingEnable must: be ename:VK_FALSE + If the <<features-features-alphaToOne,alpha to one>> feature is not enabled, pname:alphaToOneEnable must: be ename:VK_FALSE + + + + VkBool32 blendEnable + VkBlendFactor srcColorBlendFactor + VkBlendFactor dstColorBlendFactor + VkBlendOp colorBlendOp + VkBlendFactor srcAlphaBlendFactor + VkBlendFactor dstAlphaBlendFactor + VkBlendOp alphaBlendOp + VkColorComponentFlags colorWriteMask + + If the <<features-features-dualSrcBlend,dual source blending>> feature is not enabled, pname:srcColorBlendFactor mustnot: be pname:VK_BLEND_SRC1_COLOR, pname:VK_BLEND_ONE_MINUS_SRC1_COLOR, pname:VK_BLEND_SRC1_ALPHA, or pname:VK_BLEND_ONE_MINUS_SRC1_ALPHA + If the <<features-features-dualSrcBlend,dual source blending>> feature is not enabled, pname:dstColorBlendFactor mustnot: be pname:VK_BLEND_SRC1_COLOR, pname:VK_BLEND_ONE_MINUS_SRC1_COLOR, pname:VK_BLEND_SRC1_ALPHA, or pname:VK_BLEND_ONE_MINUS_SRC1_ALPHA + If the <<features-features-dualSrcBlend,dual source blending>> feature is not enabled, pname:srcAlphaBlendFactor mustnot: be pname:VK_BLEND_SRC1_COLOR, pname:VK_BLEND_ONE_MINUS_SRC1_COLOR, pname:VK_BLEND_SRC1_ALPHA, or pname:VK_BLEND_ONE_MINUS_SRC1_ALPHA + If the <<features-features-dualSrcBlend,dual source blending>> feature is not enabled, pname:dstAlphaBlendFactor mustnot: be pname:VK_BLEND_SRC1_COLOR, pname:VK_BLEND_ONE_MINUS_SRC1_COLOR, pname:VK_BLEND_SRC1_ALPHA, or pname:VK_BLEND_ONE_MINUS_SRC1_ALPHA + + + + VkStructureType sType + const void* pNext + VkPipelineColorBlendStateCreateFlags flags + VkBool32 logicOpEnable + VkLogicOp logicOp + uint32_t attachmentCount + const VkPipelineColorBlendAttachmentState* pAttachments + float blendConstants[4] + + If the <<features-features-independentBlend,independent blending>> feature is not enabled, all elements of pname:pAttachments must: be identical + If the <<features-features-logicOp,logic operations>> feature is not enabled, pname:logicOpEnable must: be ename:VK_FALSE + If pname:logicOpEnable is ename:VK_TRUE, pname:logicOp must: be a valid elink:VkLogicOp value + + + + VkStructureType sType + const void* pNext + VkPipelineDynamicStateCreateFlags flags + uint32_t dynamicStateCount + const VkDynamicState* pDynamicStates + + + VkStencilOp failOp + VkStencilOp passOp + VkStencilOp depthFailOp + VkCompareOp compareOp + uint32_t compareMask + uint32_t writeMask + uint32_t reference + + + VkStructureType sType + const void* pNext + VkPipelineDepthStencilStateCreateFlags flags + VkBool32 depthTestEnable + VkBool32 depthWriteEnable + VkCompareOp depthCompareOp + VkBool32 depthBoundsTestEnable + VkBool32 stencilTestEnable + VkStencilOpState front + VkStencilOpState back + float minDepthBounds + float maxDepthBounds + + If the <<features-features-depthBounds,depth bounds testing>> feature is not enabled, the value of pname:depthBoundsTestEnable must: be ename:VK_FALSE + + + + VkStructureType sType + const void* pNext + VkPipelineCreateFlags flags + uint32_t stageCount + const VkPipelineShaderStageCreateInfo* pStages + const VkPipelineVertexInputStateCreateInfo* pVertexInputState + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState + const VkPipelineTessellationStateCreateInfo* pTessellationState + const VkPipelineViewportStateCreateInfo* pViewportState + const VkPipelineRasterizationStateCreateInfo* pRasterizationState + const VkPipelineMultisampleStateCreateInfo* pMultisampleState + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState + const VkPipelineColorBlendStateCreateInfo* pColorBlendState + const VkPipelineDynamicStateCreateInfo* pDynamicState + VkPipelineLayout layout + VkRenderPass renderPass + uint32_t subpass + VkPipeline basePipelineHandle + int32_t basePipelineIndex + + If pname:flags contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and pname:basePipelineIndex is not `-1`, pname:basePipelineHandle must: be sname:VK_NULL_HANDLE + If pname:flags contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and pname:basePipelineIndex is not `-1`, it must: be a valid index into the calling command's pname:pCreateInfos parameter + If pname:flags contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and pname:basePipelineHandle is not sname:VK_NULL_HANDLE, pname:basePipelineIndex must: be `-1` + If pname:flags contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and pname:basePipelineHandle is not sname:VK_NULL_HANDLE, pname:basePipelineHandle must: be a valid sname:VkPipeline handle + If pname:flags contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and pname:basePipelineHandle is not sname:VK_NULL_HANDLE, it must: be a valid handle to a graphics sname:VkPipeline + pname:stageCount must: be greater than or equal to `1` + The pname:stage member of each element of pname:pStages must: be unique + The pname:stage member of one element of pname:pStages must: be ename:VK_SHADER_STAGE_VERTEX_BIT + The pname:stage member of any given element of pname:pStages mustnot: be ename:VK_SHADER_STAGE_COMPUTE_BIT + If pname:pStages includes a tessellation control shader stage, it must: include a tessellation evaluation shader stage + If pname:pStages includes a tessellation evaluation shader stage, it must: include a tessellation control shader stage + If pname:pStages includes a tessellation control shader stage and a tessellation evaluation shader stage, pname:pTessellationState mustnot: be `NULL` + If pname:pStages includes both a tessellation control shader stage and a tessellation evaluation shader stage, the shader code of at least one must: contain an code:OpExecutionMode instruction that specifies the type of subdivision in the pipeline + If pname:pStages includes both a tessellation control shader stage and a tessellation evaluation shader stage, and the shader code of both contain an code:OpExecutionMode instruction that specifies the type of subdivision in the pipeline, they must: both specify the same subdivision mode + If pname:pStages includes both a tessellation control shader stage and a tessellation evaluation shader stage, the shader code of at least one must: contain an code:OpExecutionMode instruction that specifies the output patch size in the pipeline + If pname:pStages includes both a tessellation control shader stage and a tessellation evaluation shader stage, and the shader code of both contain an code:OpExecutionMode instruction that specifies the out patch size in the pipeline, they must: both specify the same patch size + If pname:pStages includes tessellation shader stages, the pname:topology member of pname:pInputAssembly must: be ename:VK_PRIMITIVE_TOPOLOGY_PATCH_LIST + If pname:pStages includes a geometry shader stage, and doesn't include any tessellation shader stages, its shader code must: contain an code:OpExecutionMode instruction that specifies an input primitive type that is <<shaders-geometry-execution, compatible>> with the primitive topology specified in pname:pInputAssembly + If pname:pStages includes a geometry shader stage, and also includes tessellation shader stages, its shader code must: contain an code:OpExecutionMode instruction that specifies an input primitive type that is <<shaders-geometry-execution, compatible>> with the primitive topology that is output by the tessellation stages + If pname:pStages includes a fragment shader stage and a geometry shader stage, and the fragment shader code reads from an input variable that is decorated with code:PrimitiveID, then the geometry shader code must: write to a matching output variable, decorated with code:PrimitiveID, in all execution paths + If pname:pStages includes a fragment shader stage, its shader code mustnot: read from any input attachment that is defined as ename:VK_ATTACHMENT_UNUSED in pname:subpass + The shader code for the entry points identified by pname:pStages, and the rest of the state identified by this structure must: adhere to the pipeline linking rules described in the <<interfaces,Shader Interfaces>> chapter + If pname:subpass uses a depth/stencil attachment in pname:renderpass that has a layout of ename:VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the sname:VkAttachmentReference defined by pname:subpass, and pname:pDepthStencilState is not `NULL`, the pname:depthWriteEnable member of pname:pDepthStencilState must: be ename:VK_FALSE + If pname:subpass uses a depth/stencil attachment in pname:renderpass that has a layout of ename:VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the sname:VkAttachmentReference defined by pname:subpass, and pname:pDepthStencilState is not `NULL`, the value of the pname:failOp, pname:passOp and pname:depthFailOp members of each of the pname:front and pname:back members of pname:pDepthStencilState must: be ename:VK_STENCIL_OP_KEEP + If pname:pColorBlendState is not `NULL`, the value of the pname:blendEnable member of each element of the pname:pAttachment member of pname:pColorBlendState must: be ename:VK_FALSE if the pname:format of the attachment referred to in pname:subpass of pname:renderPass does not support color blend operations, as specified by the ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures or sname:VkFormatProperties::pname:optimalTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + If pname:pColorBlendState is not `NULL`, The pname:attachmentCount member of pname:pColorBlendState must: be equal to the value of pname:colorAttachmentCount used to create pname:subpass + If no element of the pname:pDynamicStates member of pname:pDynamicState is ename:VK_DYNAMIC_STATE_VIEWPORT, the pname:pViewports member of pname:pViewportState must: be a pointer to an array of pname:pViewportState->viewportCount sname:VkViewport structures + If no element of the pname:pDynamicStates member of pname:pDynamicState is ename:VK_DYNAMIC_STATE_SCISSOR, the pname:pScissors member of pname:pViewportState must: be a pointer to an array of pname:pViewportState->scissorCount sname:VkRect2D structures + If the wide lines feature is not enabled, and no element of the pname:pDynamicStates member of pname:pDynamicState is ename:VK_DYNAMIC_STATE_LINE_WIDTH, the pname:lineWidth member of pname:pRasterizationState must: be `1.0` + If the pname:rasterizerDiscardEnable member of pname:pRasterizationState is ename:VK_FALSE, pname:pViewportState must: be a pointer to a valid sname:VkPipelineViewportStateCreateInfo structure + If the pname:rasterizerDiscardEnable member of pname:pRasterizationState is ename:VK_FALSE, pname:pMultisampleState must: be a pointer to a valid sname:VkPipelineMultisampleStateCreateInfo structure + If the pname:rasterizerDiscardEnable member of pname:pRasterizationState is ename:VK_FALSE, and pname:subpass uses a depth/stencil attachment, pname:pDepthStencilState must: be a pointer to a valid sname:VkPipelineDepthStencilStateCreateInfo structure + If the pname:rasterizerDiscardEnable member of pname:pRasterizationState is ename:VK_FALSE, and pname:subpass uses color attachments, pname:pColorBlendState must: be a pointer to a valid sname:VkPipelineColorBlendStateCreateInfo structure + If the depth bias clamping feature is not enabled, no element of the pname:pDynamicStates member of pname:pDynamicState is ename:VK_DYNAMIC_STATE_DEPTH_BIAS, and the pname:depthBiasEnable member of pname:pDepthStencil is ename:VK_TRUE, the pname:depthBiasClamp member of pname:pDepthStencil must: be `0.0` + If no element of the pname:pDynamicStates member of pname:pDynamicState is ename:VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the pname:depthBoundsTestEnable member of pname:pDepthStencil is ename:VK_TRUE, the value of the pname:minDepthBounds and pname:maxDepthBounds members of pname:pDepthStencil must: be between `0.0` and `1.0`, inclusive + pname:layout must: be <<descriptorsets-pipelinelayout-consistency,consistent>> with all shaders specified in pname:pStages + If pname:subpass uses color and/or depth/stencil attachments, then the pname:rasterizationSamples member of pname:pMultisampleState must: be the same as the sample count for those subpass attachments + If pname:subpass does not use any color and/or depth/stencil attachments, then the pname:rasterizationSamples member of pname:pMultisampleState must: follow the rules for a <<renderpass-noattachments, zero-attachment subpass>> + pname:subpass must: be a valid subpass within pname:renderpass + + + + VkStructureType sType + const void* pNext + VkPipelineCacheCreateFlags flags + size_t initialDataSize + const void* pInitialData + + If pname:initialDataSize is not `0`, it must: be equal to the size of pname:pInitialData, as returned by fname:vkGetPipelineCacheData when pname:pInitialData was originally retrieved + If pname:initialDataSize is not `0`, pname:pInitialData must: have been retrieved from a previous call to fname:vkGetPipelineCacheData + + + + VkShaderStageFlags stageFlags + uint32_t offset + uint32_t size + + The sum of pname:offset and pname:size must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxPushConstantsSize + The value of pname:size must: be greater than `0` + The value of pname:size must: be a multiple of `4` + + + + VkStructureType sType + const void* pNext + VkPipelineLayoutCreateFlags flags + uint32_t setLayoutCount + const VkDescriptorSetLayout* pSetLayouts + uint32_t pushConstantRangeCount + const VkPushConstantRange* pPushConstantRanges + + pname:setLayoutCount must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxBoundDescriptorSets + The total number of descriptors of the type ename:VK_DESCRIPTOR_TYPE_SAMPLER and ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER accessible to any given shader stage across all elements of pname:pSetLayouts must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxPerStageDescriptorSamplers + The total number of descriptors of the type ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER and ename:VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pname:pSetLayouts must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxPerStageDescriptorUniformBuffers + The total number of descriptors of the type ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER and ename:VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC accessible to any given shader stage across all elements of pname:pSetLayouts must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxPerStageDescriptorStorageBuffers + The total number of descriptors of the type ename:VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, ename:VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, and ename:VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER accessible to any given shader stage across all elements of pname:pSetLayouts must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxPerStageDescriptorSampledImages + The total number of descriptors of the type ename:VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, and ename:VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER accessible to any given shader stage across all elements of pname:pSetLayouts must: be less than or equal to the value of sname:VkPhysicalDeviceLimits::pname:maxPerStageDescriptorStorageImages + + + + VkStructureType sType + const void* pNext + VkSamplerCreateFlags flags + VkFilter magFilter + VkFilter minFilter + VkSamplerMipmapMode mipmapMode + VkSamplerAddressMode addressModeU + VkSamplerAddressMode addressModeV + VkSamplerAddressMode addressModeW + float mipLodBias + VkBool32 anisotropyEnable + float maxAnisotropy + VkBool32 compareEnable + VkCompareOp compareOp + float minLod + float maxLod + VkBorderColor borderColor + VkBool32 unnormalizedCoordinates + + The absolute value of pname:mipLodBias must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxSamplerLodBias + If the <<features-features-samplerAnisotropy,anisotropic sampling>> feature is not enabled, pname:anisotropyEnable must: be ename:VK_FALSE + If pname:anisotropyEnable is ename:VK_TRUE, the value of pname:maxAnisotropy must: be between `1.0` and sname:VkPhysicalDeviceLimits::pname:maxSamplerAnisotropy, inclusive + If pname:unnormalizedCoordinates is ename:VK_TRUE, pname:minFilter and pname:magFilter must: be equal + If pname:unnormalizedCoordinates is ename:VK_TRUE, pname:mipmapMode must: be ename:VK_SAMPLER_MIPMAP_MODE_NEAREST + If pname:unnormalizedCoordinates is ename:VK_TRUE, pname:minLod and pname:maxLod must: be zero + If pname:unnormalizedCoordinates is ename:VK_TRUE, pname:addressModeU and pname:addressModeV must: each be either ename:VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE or ename:VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER + If pname:unnormalizedCoordinates is ename:VK_TRUE, pname:anisotropyEnable must: be ename:VK_FALSE + If pname:unnormalizedCoordinates is ename:VK_TRUE, pname:compareEnable must: be ename:VK_FALSE + If any of pname:addressModeU, pname:addressModeV or pname:addressModeW are ename:VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, pname:borderColor must: be a valid elink:VkBorderColor value + If pname:compareEnable is ename:VK_TRUE, pname:compareOp must: be a valid elink:VkCompareOp value + + + + VkStructureType sType + const void* pNext + VkCommandPoolCreateFlags flags + uint32_t queueFamilyIndex + + pname:queueFamilyIndex must: be the index of a queue family available in the calling command's pname:device parameter + + + + VkStructureType sType + const void* pNext + VkCommandPool commandPool + VkCommandBufferLevel level + uint32_t commandBufferCount + + + VkStructureType sType + const void* pNext + VkRenderPass renderPass + uint32_t subpass + VkFramebuffer framebuffer + VkBool32 occlusionQueryEnable + VkQueryControlFlags queryFlags + VkQueryPipelineStatisticFlags pipelineStatistics + + If the <<features-features-inheritedQueries,inherited queries>> feature is not enabled, pname:occlusionQueryEnable must: be ename:VK_FALSE + If the <<features-features-inheritedQueries,inherited queries>> feature is enabled, pname:queryFlags must: be a valid combination of elink:VkQueryControlFlagBits values + If the <<features-features-pipelineStatisticsQuery,pipeline statistics queries>> feature is not enabled, pname:pipelineStatistics must: be code:0 + + + + VkStructureType sType + const void* pNext + VkCommandBufferUsageFlags flags + const VkCommandBufferInheritanceInfo* pInheritanceInfo + + If pname:flags contains ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the pname:renderPass member of pname:pInheritanceInfo must: be a valid sname:VkRenderPass + If pname:flags contains ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the pname:subpass member of pname:pInheritanceInfo must: be a valid subpass index within the pname:renderPass member of pname:pInheritanceInfo + If pname:flags contains ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, the pname:framebuffer member of pname:pInheritanceInfo must: be either sname:VK_NULL_HANDLE, or a valid sname:VkFramebuffer that is compatible with the pname:renderPass member of pname:pInheritanceInfo + + + + float float32[4] + int32_t int32[4] + uint32_t uint32[4] + + + float depth + uint32_t stencil + + + VkClearColorValue color + VkClearDepthStencilValue depthStencil + + + VkStructureType sType + const void* pNext + VkRenderPass renderPass + VkFramebuffer framebuffer + VkRect2D renderArea + uint32_t clearValueCount + const VkClearValue* pClearValues + + The value of pname:clearValueCount must: be greater than or equal to the number of attachments in pname:renderPass that specify a pname:loadOp of ename:VK_ATTACHMENT_LOAD_OP_CLEAR + + + + VkImageAspectFlags aspectMask + uint32_t colorAttachment + VkClearValue clearValue + + If pname:aspectMask includes ename:VK_IMAGE_ASPECT_COLOR_BIT, it mustnot: include ename:VK_IMAGE_ASPECT_DEPTH_BIT or ename:VK_IMAGE_ASPECT_STENCIL_BIT + pname:aspectMask mustnot: include ename:VK_IMAGE_ASPECT_METADATA_BIT + + + + VkAttachmentDescriptionFlags flags + VkFormat format + VkSampleCountFlagBits samples + VkAttachmentLoadOp loadOp + VkAttachmentStoreOp storeOp + VkAttachmentLoadOp stencilLoadOp + VkAttachmentStoreOp stencilStoreOp + VkImageLayout initialLayout + VkImageLayout finalLayout + + + uint32_t attachment + VkImageLayout layout + + + VkSubpassDescriptionFlags flags + VkPipelineBindPoint pipelineBindPoint + uint32_t inputAttachmentCount + const VkAttachmentReference* pInputAttachments + uint32_t colorAttachmentCount + const VkAttachmentReference* pColorAttachments + const VkAttachmentReference* pResolveAttachments + const VkAttachmentReference* pDepthStencilAttachment + uint32_t preserveAttachmentCount + const uint32_t* pPreserveAttachments + + pname:pipelineBindPoint must: be ename:VK_PIPELINE_BIND_POINT_GRAPHICS + The value of pname:colorCount must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxColorAttachments + If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then pname:loadOp mustnot: be ename:VK_ATTACHMENT_LOAD_OP_CLEAR + If pname:pResolveAttachments is not `NULL`, for each resolve attachment that does not have the value ename:VK_ATTACHMENT_UNUSED, the corresponding color attachment mustnot: have the value ename:VK_ATTACHMENT_UNUSED + If pname:pResolveAttachments is not `NULL`, the sample count of each element of pname:pColorAttachments must: be anything other than ename:VK_SAMPLE_COUNT_1_BIT + Any given element of pname:pResolveAttachments must: have a sample count of ename:VK_SAMPLE_COUNT_1_BIT + Any given element of pname:pResolveAttachments must: have the same elink:VkFormat as its corresponding color attachment + All attachments in pname:pColorAttachments and pname:pDepthStencilAttachment that are not ename:VK_ATTACHMENT_UNUSED must: have the same sample count + If any input attachments are ename:VK_ATTACHMENT_UNUSED, then any pipelines bound during the subpass mustnot: accesss those input attachments from the fragment shader + The pname:attachment member of any element of pname:pPreserveAttachments mustnot: be ename:VK_ATTACHMENT_UNUSED + Any given element of pname:pPreserveAttachments mustnot: also be an element of any other member of the subpass description + If any attachment is used as both an input attachment and a color or depth/stencil attachment, then each use must use the same pname:layout + + + + uint32_t srcSubpass + uint32_t dstSubpass + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkAccessFlags srcAccessMask + VkAccessFlags dstAccessMask + VkDependencyFlags dependencyFlags + + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, pname:srcStageMask mustnot: contain pname:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, pname:dstStageMask mustnot: contain pname:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, pname:srcStageMask mustnot: contain pname:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or pname:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, pname:dstStageMask mustnot: contain pname:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or pname:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT + The value of pname:srcSubpass must: be less than or equal to pname:dstSubpass, unless one of them is ename:VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order + The values of pname:srcSubpass and pname:dstSubpass mustnot: both be equal to ename:VK_SUBPASS_EXTERNAL + + + + VkStructureType sType + const void* pNext + VkRenderPassCreateFlags flags + uint32_t attachmentCount + const VkAttachmentDescription* pAttachments + uint32_t subpassCount + const VkSubpassDescription* pSubpasses + uint32_t dependencyCount + const VkSubpassDependency* pDependencies + + If any two subpasses operate on attachments with overlapping ranges of the same sname:VkDeviceMemory object, and at least one subpass writes to that area of sname:VkDeviceMemory, a subpass dependency must: be included (either directly or via some intermediate subpasses) between them + If the pname:attachment member of any element of pname:pInputAttachments, pname:pColorAttachments, pname:pResolveAttachments or pname:pDepthStencilAttachment, or the attachment indexed by any element of pname:pPreserveAttachments in any given element of pname:pSubpasses is bound to a range of a sname:VkDeviceMemory object that overlaps with any other attachment in any subpass (including the same subpass), the sname:VkAttachmentDescription structures describing them must: include ename:VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT in pname:flags + If the pname:attachment member of any element of pname:pInputAttachments, pname:pColorAttachments, pname:pResolveAttachments or pname:pDepthStencilAttachment, or the value of any element of pname:pPreserveAttachments in any given element of pname:pSubpasses is not ename:VK_ATTACHMENT_UNUSED, it must: be less than the value of pname:attachmentCount + The value of any element of the pname:pPreserveAttachments member in any given element of pname:pSubpasses mustnot: be ename:VK_ATTACHMENT_UNUSED + + + + VkStructureType sType + const void* pNext + VkEventCreateFlags flags + + + VkStructureType sType + const void* pNext + VkFenceCreateFlags flags + + + VkStructureType sType + const void* pNext + VkSemaphoreCreateFlags flags + + + VkStructureType sType + const void* pNext + VkQueryPoolCreateFlags flags + VkQueryType queryType + uint32_t queryCount + VkQueryPipelineStatisticFlags pipelineStatistics + + If the <<features-features-pipelineStatisticsQuery,pipeline statistics queries>> feature is not enabled, pname:queryType mustnot: be ename:VK_QUERY_TYPE_PIPELINE_STATISTICS + If pname:queryType is ename:VK_QUERY_TYPE_PIPELINE_STATISTICS, pname:pipelineStatistics must: be a valid combination of elink:VkQueryPipelineStatisticFlagBits values + + + + VkStructureType sType + const void* pNext + VkFramebufferCreateFlags flags + VkRenderPass renderPass + uint32_t attachmentCount + const VkImageView* pAttachments + uint32_t width + uint32_t height + uint32_t layers + + The value of pname:attachmentCount must: be equal to the attachment count specified in pname:renderPass + Any given element of pname:pAttachments that is used as a color attachment or resolve attachment by pname:renderPass must: have been created with a pname:usage value including ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT + Any given element of pname:pAttachments that is used as a depth/stencil attachment by pname:renderPass must: have been created with a pname:usage value including ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT + Any given element of pname:pAttachments that is used as an input attachment by pname:renderPass must: have been created with a pname:usage value including ename:VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT + Any given element of pname:pAttachments must: have been created with an elink:VkFormat value that matches the elink:VkFormat specified by the corresponding sname:VkAttachmentDescription in pname:renderPass + Any given element of pname:pAttachments must: have been created with a pname:samples value that matches the pname:samples value specified by the corresponding sname:VkAttachmentDescription in pname:renderPass + Any given element of pname:pAttachments must: have dimensions at least as large as the corresponding framebuffer dimension + Any given element of pname:pAttachments must: only specify a single mip-level + Any given element of pname:pAttachments must: have been created with identity swizzle + The value of pname:width must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxFramebufferWidth + The value of pname:height must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxFramebufferHeight + The value of pname:layers must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxFramebufferLayers + + + + uint32_t vertexCount + uint32_t instanceCount + uint32_t firstVertex + uint32_t firstInstance + + For a given vertex buffer binding, any attribute data fetched must: be entirely contained within the corresponding vertex buffer binding, as described in <<fxvertex-input>> + If the <<features-features-drawIndirectFirstInstance,drawIndirectFirstInstance>> feature is not enabled, pname:firstInstance must: be code:0 + + + + uint32_t indexCount + uint32_t instanceCount + uint32_t firstIndex + int32_t vertexOffset + uint32_t firstInstance + + For a given vertex buffer binding, any attribute data fetched must: be entirely contained within the corresponding vertex buffer binding, as described in <<fxvertex-input>> + The total value of (pname:indexSize * (pname:firstIndex + pname:indexCount) + pname:offset) must: be less than or equal to the size of the currently bound index buffer, with indexSize being based on the type specified by pname:indexType, where the index buffer, pname:indexType, and pname:offset are specified via fname:vkCmdBindIndexBuffer + If the <<features-features-drawIndirectFirstInstance,drawIndirectFirstInstance>> feature is not enabled, pname:firstInstance must: be code:0 + + + + uint32_t x + uint32_t y + uint32_t z + + pname:x must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxComputeWorkGroupCount[0] + pname:y must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxComputeWorkGroupCount[1] + pname:z must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxComputeWorkGroupCount[2] + + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + const VkPipelineStageFlags* pWaitDstStageMask + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + uint32_t signalSemaphoreCount + const VkSemaphore* pSignalSemaphores + + Any given element of pname:pSignalSemaphores must: currently be unsignalled + Any given element of pname:pCommandBuffers must: either have been recorded with the VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, or not currently be executing on the device + Any given element of pname:pCommandBuffers must: be in the executable state + If any given element of pname:pCommandBuffers contains commands that execute secondary command buffers, those secondary command buffers must: have been recorded with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, or not currently be executing on the device + If any given element of pname:pCommandBuffers was created with ename:VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, it mustnot: have been previously submitted without re-recording that command buffer + Any given element of pname:pCommandBuffers mustnot: contain commands that execute a secondary command buffer, if that secondary command buffer has been recorded in another primary command buffer after it was recorded into this sname:VkCommandBuffer + Any given element of pname:pCommandBuffers must: have been created on a sname:VkCommandPool that was created for the same queue family that the calling command's pname:queue belongs to + Any given element of pname:pCommandBuffers mustnot: have been created with ename:VK_COMMAND_BUFFER_LEVEL_SECONDARY + Any given element of sname:VkSemaphore in pname:pWaitSemaphores must: refer to a prior signal of that sname:VkSemaphore that won't be consumed by any other wait on that semaphore + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, any given element of pname:pWaitDstStageMask mustnot: contain pname:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, any given element of pname:pWaitDstStageMask mustnot: contain pname:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or pname:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT + + + + + VkDisplayKHR display + const char* displayName + VkExtent2D physicalDimensions + VkExtent2D physicalResolution + VkSurfaceTransformFlagsKHR supportedTransforms + VkBool32 planeReorderPossible + VkBool32 persistentContent + + + VkDisplayKHR currentDisplay + uint32_t currentStackIndex + + + VkExtent2D visibleRegion + uint32_t refreshRate + + + VkDisplayModeKHR displayMode + VkDisplayModeParametersKHR parameters + + + VkStructureType sType + const void* pNext + VkDisplayModeCreateFlagsKHR flags + VkDisplayModeParametersKHR parameters + + The pname:width and pname:height members of the pname:visibleRegion member of pname:parameters must be greater than `0` + The pname:refreshRate member of pname:parameters must be greater than `0` + + + + VkDisplayPlaneAlphaFlagsKHR supportedAlpha + VkOffset2D minSrcPosition + VkOffset2D maxSrcPosition + VkExtent2D minSrcExtent + VkExtent2D maxSrcExtent + VkOffset2D minDstPosition + VkOffset2D maxDstPosition + VkExtent2D minDstExtent + VkExtent2D maxDstExtent + + + VkStructureType sType + const void* pNext + VkDisplaySurfaceCreateFlagsKHR flags + VkDisplayModeKHR displayMode + uint32_t planeIndex + uint32_t planeStackIndex + VkSurfaceTransformFlagBitsKHR transform + float globalAlpha + VkDisplayPlaneAlphaFlagBitsKHR alphaMode + VkExtent2D imageExtent + + pname:planeIndex must: be less than the number of display planes supported by the device as determined by calling fname:vkGetPhysicalDeviceDisplayPlanePropertiesKHR + If the pname:planeReorderPossible member of the sname:VkDisplayPropertiesKHR structure returned by fname:vkGetPhysicalDeviceDisplayPropertiesKHR for the display corresponding to pname:displayMode is ename:VK_TRUE then pname:planeStackIndex must: be less than the number of display planes supported by the device as determined by calling fname:vkGetPhysicalDeviceDisplayPlanePropertiesKHR; otherwise pname:planeStackIndex must: equal the pname:currentStackIndex member of sname:VkDisplayPlanePropertiesKHR returned by fname:vkGetPhysicalDeviceDisplayPlanePropertiesKHR for the display plane corresponding to pname:displayMode + If pname:alphaMode is ename:VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR then pname:globalAlpha must: be between `0` and `1`, inclusive + pname:alphaMode must: be `0` or one of the bits present in the pname:supportedAlpha member of sname:VkDisplayPlaneCapabilitiesKHR returned by fname:vkGetDisplayPlaneCapabilitiesKHR for the display plane corresponding to pname:displayMode + The pname:width and pname:height members of pname:imageExtent must be less than the pname:maxImageDimensions2D member of sname:VkPhysicalDeviceLimits + + + + VkStructureType sType + const void* pNext + VkRect2D srcRect + VkRect2D dstRect + VkBool32 persistent + + pname:srcRect must: specify a rectangular region that is a subset of the image being presented + pname:dstRect must: specify a rectangular region that is a subset of the pname:visibleRegion parameter of the display mode the swapchain being presented uses + If the pname:persistentContent member of the sname:VkDisplayPropertiesKHR structure returned by fname:vkGetPhysicalDeviceDisplayPropertiesKHR for the display the present operation targets then pname:persistent must: be ename:VK_FALSE + + + + uint32_t minImageCount + uint32_t maxImageCount + VkExtent2D currentExtent + VkExtent2D minImageExtent + VkExtent2D maxImageExtent + uint32_t maxImageArrayLayers + VkSurfaceTransformFlagsKHR supportedTransforms + VkSurfaceTransformFlagBitsKHR currentTransform + VkCompositeAlphaFlagsKHR supportedCompositeAlpha + VkImageUsageFlags supportedUsageFlags + + + VkStructureType sType + const void* pNext + VkAndroidSurfaceCreateFlagsKHR flags + ANativeWindow* window + + pname:window mustnot: be in a connected state + + + + VkStructureType sType + const void* pNext + VkMirSurfaceCreateFlagsKHR flags + MirConnection* connection + MirSurface* mirSurface + + + VkStructureType sType + const void* pNext + VkWaylandSurfaceCreateFlagsKHR flags + struct wl_display* display + struct wl_surface* surface + + + VkStructureType sType + const void* pNext + VkWin32SurfaceCreateFlagsKHR flags + HINSTANCE hinstance + HWND hwnd + + + VkStructureType sType + const void* pNext + VkXlibSurfaceCreateFlagsKHR flags + Display* dpy + Window window + + + VkStructureType sType + const void* pNext + VkXcbSurfaceCreateFlagsKHR flags + xcb_connection_t* connection + xcb_window_t window + + + VkFormat format + VkColorSpaceKHR colorSpace + + + VkStructureType sType + const void* pNext + VkSwapchainCreateFlagsKHR flags + VkSurfaceKHR surface + uint32_t minImageCount + VkFormat imageFormat + VkColorSpaceKHR imageColorSpace + VkExtent2D imageExtent + uint32_t imageArrayLayers + VkImageUsageFlags imageUsage + VkSharingMode imageSharingMode + uint32_t queueFamilyIndexCount + const uint32_t* pQueueFamilyIndices + VkSurfaceTransformFlagBitsKHR preTransform + VkCompositeAlphaFlagBitsKHR compositeAlpha + VkPresentModeKHR presentMode + VkBool32 clipped + VkSwapchainKHR oldSwapchain + + pname:surface must: be a surface that is supported by the device as determined using fname:vkGetPhysicalDeviceSurfaceSupportKHR + The native window referred to by pname:surface mustnot: already be associated with a swapchain other than pname:oldSwapchain, or with a non-{apiname} graphics API surface + pname:minImageCount must: be greater than or equal to the value returned in the pname:minImageCount member of the sname:VkSurfaceCapabilitiesKHR structure returned by fname:vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface + pname:minImageCount must: be less than or equal to the value returned in the pname:maxImageCount member of the sname:VkSurfaceCapabilitiesKHR structure returned by fname:vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface if the returned value of pname:maxImageCount is not zero + pname:imageFormat and pname:imageColorspace must: match the pname:format and pname:colorSpace members, respectively, of one of the sname:VkSurfaceFormatKHR structures returned by fname:vkGetPhysicalDeviceSurfaceFormatsKHR for the surface + pname:imageExtent must: be between pname:minImageExtent and pname:maxImageExtent, inclusive, where pname:minImageExtent and pname:maxImageExtent are members of the sname:VkSurfaceCapabilitiesKHR structure returned by fname:vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface + pname:imageArrayLayers must: be greater than `0` and less than or equal to the pname:maxImageArrayLayers member of the sname:VkSurfaceCapabilitiesKHR structure returned by fname:vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface + pname:imageUsage must: be a subset of the supported usage flags present in the pname:supportedUsageFlags member of the sname:VkSurfaceCapabilitiesKHR structure returned by fname:vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface + If pname:imageSharingMode is ename:VK_SHARING_MODE_CONCURRENT, pname:pQueueFamilyIndices must: be a pointer to an array of pname:queueFamilyIndexCount basetype:uint32_t values + If pname:imageSharingMode is ename:VK_SHARING_MODE_CONCURRENT, pname:queueFamilyIndexCount must: be greater than `1` + pname:preTransform must: be one of the bits present in the pname:supportedTransforms member of the sname:VkSurfaceCapabilitiesKHR structure returned by fname:vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface + pname:compositeAlpha must: be one of the bits present in the pname:supportedCompositeAlpha member of the sname:VkSurfaceCapabilitiesKHR structure returned by fname:vkGetPhysicalDeviceSurfaceCapabilitiesKHR for the surface + pname:presentMode must: be one of the ename:VkPresentModeKHR values returned by fname:vkGetPhysicalDeviceSurfacePresentModesKHR for the surface + + + + VkStructureType sType + const void* pNext + uint32_t waitSemaphoreCount + const VkSemaphore* pWaitSemaphores + uint32_t swapchainCount + const VkSwapchainKHR* pSwapchains + const uint32_t* pImageIndices + VkResult* pResults + + Any given element of pname:pImageIndices must: be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pname:pSwapchains array that is owned by the application + Any given element of sname:VkSemaphore in pname:pWaitSemaphores must: refer to a prior signal of that sname:VkSemaphore that won't be consumed by any other wait on that semaphore + + + + VkStructureType sType + const void* pNext + VkDebugReportFlagsEXT flags + PFN_vkDebugReportCallbackEXT pfnCallback + void* pUserData + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + VkResult vkCreateInstance + const VkInstanceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkInstance* pInstance + + + void vkDestroyInstance + VkInstance instance + const VkAllocationCallbacks* pAllocator + + All child objects created using pname:instance must: have been destroyed prior to destroying pname:instance + If sname:VkAllocationCallbacks were provided when pname:instance was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:instance was created, pname:pAllocator must: be `NULL` + + + + VkResult vkEnumeratePhysicalDevices + VkInstance instance + uint32_t* pPhysicalDeviceCount + VkPhysicalDevice* pPhysicalDevices + + + PFN_vkVoidFunction vkGetDeviceProcAddr + VkDevice device + const char* pName + + pname:pName must: be the name of a supported command that has a first parameter of type sname:VkDevice, sname:VkQueue or sname:VkCommandBuffer, either in the core API or an enabled extension + + + + PFN_vkVoidFunction vkGetInstanceProcAddr + VkInstance instance + const char* pName + + If pname:instance is `NULL`, pname:pName must: be one of: fname:vkEnumerateInstanceExtensionProperties, fname:vkEnumerateInstanceLayerProperties or fname:vkCreateInstance + If pname:instance is not `NULL`, pname:pName must: be the name of a core command or a command from an enabled extension, other than: fname:vkEnumerateInstanceExtensionProperties, fname:vkEnumerateInstanceLayerProperties or fname:vkCreateInstance + + + + void vkGetPhysicalDeviceProperties + VkPhysicalDevice physicalDevice + VkPhysicalDeviceProperties* pProperties + + + void vkGetPhysicalDeviceQueueFamilyProperties + VkPhysicalDevice physicalDevice + uint32_t* pQueueFamilyPropertyCount + VkQueueFamilyProperties* pQueueFamilyProperties + + + void vkGetPhysicalDeviceMemoryProperties + VkPhysicalDevice physicalDevice + VkPhysicalDeviceMemoryProperties* pMemoryProperties + + + void vkGetPhysicalDeviceFeatures + VkPhysicalDevice physicalDevice + VkPhysicalDeviceFeatures* pFeatures + + + void vkGetPhysicalDeviceFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkFormatProperties* pFormatProperties + + + VkResult vkGetPhysicalDeviceImageFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkImageTiling tiling + VkImageUsageFlags usage + VkImageCreateFlags flags + VkImageFormatProperties* pImageFormatProperties + + + VkResult vkCreateDevice + VkPhysicalDevice physicalDevice + const VkDeviceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDevice* pDevice + + + void vkDestroyDevice + VkDevice device + const VkAllocationCallbacks* pAllocator + + All child objects created on pname:device must: have been destroyed prior to destroying pname:device + If sname:VkAllocationCallbacks were provided when pname:device was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:device was created, pname:pAllocator must: be `NULL` + + + + VkResult vkEnumerateInstanceLayerProperties + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateInstanceExtensionProperties + const char* pLayerName + uint32_t* pPropertyCount + VkExtensionProperties* pProperties + + If pname:pLayerName is not `NULL`, it must: be the name of a layer available on the system + + + + VkResult vkEnumerateDeviceLayerProperties + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkLayerProperties* pProperties + + + VkResult vkEnumerateDeviceExtensionProperties + VkPhysicalDevice physicalDevice + const char* pLayerName + uint32_t* pPropertyCount + VkExtensionProperties* pProperties + + If pname:pLayerName is not `NULL`, it must: be the name of a layer available on the system + + + + void vkGetDeviceQueue + VkDevice device + uint32_t queueFamilyIndex + uint32_t queueIndex + VkQueue* pQueue + + pname:queueFamilyIndex must: be one of the queue family indexes specified when pname:device was created, via the sname:VkDeviceQueueCreateInfo structure + pname:queueIndex must: be less than the number of queues created for the specified queue family index when pname:device was created, via the pname:queueCount member of the sname:VkDeviceQueueCreateInfo structure + + + + VkResult vkQueueSubmit + VkQueue queue + uint32_t submitCount + const VkSubmitInfo* pSubmits + VkFence fence + + pname:fence must: be unsignalled + pname:fence mustnot: be associated with any other queue command that has not yet completed execution on that queue + + + + VkResult vkQueueWaitIdle + VkQueue queue + + + VkResult vkDeviceWaitIdle + VkDevice device + + all sname:VkQueue objects created from pname:device + + + + VkResult vkAllocateMemory + VkDevice device + const VkMemoryAllocateInfo* pAllocateInfo + const VkAllocationCallbacks* pAllocator + VkDeviceMemory* pMemory + + The number of currently valid memory objects, allocated from pname:device, must: be less than sname:VkPhysicalDeviceLimits::pname:maxMemoryAllocationCount + + + + void vkFreeMemory + VkDevice device + VkDeviceMemory memory + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:memory (via images or buffers) must: have completed execution + + + + VkResult vkMapMemory + VkDevice device + VkDeviceMemory memory + VkDeviceSize offset + VkDeviceSize size + VkMemoryMapFlags flags + void** ppData + + pname:memory mustnot: currently be mapped + pname:offset must: be less than the size of pname:memory + If pname:size is not equal to ename:VK_WHOLE_SIZE, the sum of pname:offset and pname:size must: be less than or equal to the pname:size of the pname:memory + pname:memory must: have been created with a memory type that reports ename:VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT + + + + void vkUnmapMemory + VkDevice device + VkDeviceMemory memory + + pname:memory must: currently be mapped + + + + VkResult vkFlushMappedMemoryRanges + VkDevice device + uint32_t memoryRangeCount + const VkMappedMemoryRange* pMemoryRanges + + The memory ranges specified by pname:pMemoryRanges must: all currently be mapped + + + + VkResult vkInvalidateMappedMemoryRanges + VkDevice device + uint32_t memoryRangeCount + const VkMappedMemoryRange* pMemoryRanges + + The memory ranges specified by pname:pMemoryRanges must: all currently be mapped + + + + void vkGetDeviceMemoryCommitment + VkDevice device + VkDeviceMemory memory + VkDeviceSize* pCommittedMemoryInBytes + + pname:memory must: have been created with a memory type that reports ename:VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT + + + + void vkGetBufferMemoryRequirements + VkDevice device + VkBuffer buffer + VkMemoryRequirements* pMemoryRequirements + + + VkResult vkBindBufferMemory + VkDevice device + VkBuffer buffer + VkDeviceMemory memory + VkDeviceSize memoryOffset + + pname:buffer mustnot: already be backed by a memory object + pname:buffer mustnot: have been created with any sparse memory binding flags + pname:memoryOffset must: be less than the size of pname:memory + If pname:buffer was created with the ename:VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or ename:VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, pname:memoryOffset must: be a multiple of the value of sname:VkPhysicalDeviceLimits::pname:minTexelBufferOffsetAlignment + If pname:buffer was created with the ename:VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, pname:memoryOffset must: be a multiple of the value of sname:VkPhysicalDeviceLimits::pname:minUniformBufferOffsetAlignment + If pname:buffer was created with the ename:VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, pname:memoryOffset must: be a multiple of the value of sname:VkPhysicalDeviceLimits::pname:minStorageBufferOffsetAlignment + pname:memory must: have been allocated using one of the memory types allowed in the pname:memoryTypeBits member of the sname:VkMemoryRequirements structure returned from a call to fname:vkGetBufferMemoryRequirements with pname:buffer + The sum of pname:memoryOffset and the size of pname:buffer must: be less than or equal to the size of pname:memory + pname:memoryOffset must: be an integer multiple of the pname:alignment member of the sname:VkMemoryRequirements structure returned from a call to fname:vkGetBufferMemoryRequirements with pname:buffer + + + + void vkGetImageMemoryRequirements + VkDevice device + VkImage image + VkMemoryRequirements* pMemoryRequirements + + + VkResult vkBindImageMemory + VkDevice device + VkImage image + VkDeviceMemory memory + VkDeviceSize memoryOffset + + pname:image mustnot: already be backed by a memory object + pname:image mustnot: have been created with any sparse memory binding flags + pname:memoryOffset must: be less than the size of pname:memory + pname:memory must: have been allocated using one of the memory types allowed in the pname:memoryTypeBits member of the sname:VkMemoryRequirements structure returned from a call to fname:vkGetImageMemoryRequirements with pname:image + pname:memoryOffset must: be an integer multiple of the pname:alignment member of the sname:VkMemoryRequirements structure returned from a call to fname:vkGetImageMemoryRequirements with pname:image + pname:memory must: have storage from pname:memoryOffset onwards equal to or greater than the pname:size member of the sname:VkMemoryRequirements structure returned from a call to fname:vkGetImageMemoryRequirements with pname:image + + + + void vkGetImageSparseMemoryRequirements + VkDevice device + VkImage image + uint32_t* pSparseMemoryRequirementCount + VkSparseImageMemoryRequirements* pSparseMemoryRequirements + + pname:image must: have been created with the ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag + + + + void vkGetPhysicalDeviceSparseImageFormatProperties + VkPhysicalDevice physicalDevice + VkFormat format + VkImageType type + VkSampleCountFlagBits samples + VkImageUsageFlags usage + VkImageTiling tiling + uint32_t* pPropertyCount + VkSparseImageFormatProperties* pProperties + + If pname:format is an integer format, samples must: be one of the bit flag values specified in the value of sname:VkPhysicalDeviceLimits::pname:sampledImageIntegerSampleCounts + If pname:format is a non-integer color format, samples must: be one of the bit flag values specified in the value of sname:VkPhysicalDeviceLimits::pname:sampledImageColorSampleCounts + If pname:format is a depth format, samples must: be one of the bit flag values specified in the value of sname:VkPhysicalDeviceLimits::pname:sampledImageDepthSampleCounts + If pname:format is a stencil format, samples must: be one of the bit flag values specified in the value of sname:VkPhysicalDeviceLimits::pname:sampledImageStencilSampleCounts + If pname:usage includes ename:VK_IMAGE_USAGE_STORAGE_BIT, samples must: be one of the bit flag values specified in the value of sname:VkPhysicalDeviceLimits::pname:storageImageSampleCounts + + + + VkResult vkQueueBindSparse + VkQueue queue + uint32_t bindInfoCount + const VkBindSparseInfo* pBindInfo + VkFence fence + + pname:fence must: be unsignalled + pname:fence mustnot: be associated with any other queue command that has not yet completed execution on that queue + + + + VkResult vkCreateFence + VkDevice device + const VkFenceCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkFence* pFence + + + void vkDestroyFence + VkDevice device + VkFence fence + const VkAllocationCallbacks* pAllocator + + pname:fence mustnot: be associated with any queue command that has not yet completed execution on that queue + If sname:VkAllocationCallbacks were provided when pname:fence was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:fence was created, pname:pAllocator must: be `NULL` + + + + VkResult vkResetFences + VkDevice device + uint32_t fenceCount + const VkFence* pFences + + Any given element of pname:pFences mustnot: currently be associated with any queue command that has not yet completed execution on that queue + + + + VkResult vkGetFenceStatus + VkDevice device + VkFence fence + + + VkResult vkWaitForFences + VkDevice device + uint32_t fenceCount + const VkFence* pFences + VkBool32 waitAll + uint64_t timeout + + + VkResult vkCreateSemaphore + VkDevice device + const VkSemaphoreCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSemaphore* pSemaphore + + + void vkDestroySemaphore + VkDevice device + VkSemaphore semaphore + const VkAllocationCallbacks* pAllocator + + pname:semaphore mustnot: be associated with any queue command that has not yet completed execution on that queue + If sname:VkAllocationCallbacks were provided when pname:semaphore was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:semaphore was created, pname:pAllocator must: be `NULL` + + + + VkResult vkCreateEvent + VkDevice device + const VkEventCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkEvent* pEvent + + + void vkDestroyEvent + VkDevice device + VkEvent event + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:event must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:event was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:event was created, pname:pAllocator must: be `NULL` + + + + VkResult vkGetEventStatus + VkDevice device + VkEvent event + + + VkResult vkSetEvent + VkDevice device + VkEvent event + + + VkResult vkResetEvent + VkDevice device + VkEvent event + + + VkResult vkCreateQueryPool + VkDevice device + const VkQueryPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkQueryPool* pQueryPool + + + void vkDestroyQueryPool + VkDevice device + VkQueryPool queryPool + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:queryPool must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:queryPool was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:queryPool was created, pname:pAllocator must: be `NULL` + + + + VkResult vkGetQueryPoolResults + VkDevice device + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + size_t dataSize + void* pData + VkDeviceSize stride + VkQueryResultFlags flags + + pname:firstQuery must: be less than the number of queries in pname:queryPool + If ename:VK_QUERY_RESULT_64_BIT is not set in pname:flags then pname:pData and pname:stride must be multiples of `4` + If ename:VK_QUERY_RESULT_64_BIT is set in pname:flags then pname:pData and pname:stride must be multiples of `8` + The sum of pname:firstQuery and pname:queryCount must: be less than or equal to the number of queries in pname:queryPool + pname:dataSize must: be large enough to contain the result of each query, as described <<queries-operation-memorylayout,here>> + If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_TIMESTAMP, pname:flags mustnot: contain ename:VK_QUERY_RESULT_PARTIAL_BIT + + + + VkResult vkCreateBuffer + VkDevice device + const VkBufferCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBuffer* pBuffer + + If the pname:flags member of pname:pCreateInfo includes ename:VK_BUFFER_CREATE_SPARSE_BINDING_BIT or ename:VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, creating this sname:VkBuffer mustnot: cause the total required sparse memory for all currently valid sparse resources on the device to exceed sname:VkPhysicalDeviceLimits::pname:sparseAddressSpaceSize + + + + void vkDestroyBuffer + VkDevice device + VkBuffer buffer + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:buffer, either directly or via a sname:VkBufferView, must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:buffer was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:buffer was created, pname:pAllocator must: be `NULL` + + + + VkResult vkCreateBufferView + VkDevice device + const VkBufferViewCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkBufferView* pView + + + void vkDestroyBufferView + VkDevice device + VkBufferView bufferView + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:bufferView must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:bufferView was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:bufferView was created, pname:pAllocator must: be `NULL` + + + + VkResult vkCreateImage + VkDevice device + const VkImageCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkImage* pImage + + If the pname:flags member of pname:pCreateInfo includes ename:VK_IMAGE_CREATE_SPARSE_BINDING_BIT or ename:VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, creating this sname:VkImage mustnot: cause the total required sparse memory for all currently valid sparse resources on the device to exceed sname:VkPhysicalDeviceLimits::pname:sparseAddressSpaceSize + + + + void vkDestroyImage + VkDevice device + VkImage image + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:image, either directly or via a sname:VkImageView, must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:image was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:image was created, pname:pAllocator must: be `NULL` + + + + void vkGetImageSubresourceLayout + VkDevice device + VkImage image + const VkImageSubresource* pSubresource + VkSubresourceLayout* pLayout + + pname:image must: have been created with pname:tiling equal to ename:VK_IMAGE_TILING_LINEAR + The pname:aspectMask member of pname:pSubresource must: only have a single bit set + + + + VkResult vkCreateImageView + VkDevice device + const VkImageViewCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkImageView* pView + + + void vkDestroyImageView + VkDevice device + VkImageView imageView + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:imageView must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:imageView was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:imageView was created, pname:pAllocator must: be `NULL` + + + + VkResult vkCreateShaderModule + VkDevice device + const VkShaderModuleCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkShaderModule* pShaderModule + + + void vkDestroyShaderModule + VkDevice device + VkShaderModule shaderModule + const VkAllocationCallbacks* pAllocator + + If sname:VkAllocationCallbacks were provided when pname:shaderModule was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:shaderModule was created, pname:pAllocator must: be `NULL` + + + + VkResult vkCreatePipelineCache + VkDevice device + const VkPipelineCacheCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineCache* pPipelineCache + + + void vkDestroyPipelineCache + VkDevice device + VkPipelineCache pipelineCache + const VkAllocationCallbacks* pAllocator + + If sname:VkAllocationCallbacks were provided when pname:pipelineCache was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:pipelineCache was created, pname:pAllocator must: be `NULL` + + + + VkResult vkGetPipelineCacheData + VkDevice device + VkPipelineCache pipelineCache + size_t* pDataSize + void* pData + + + VkResult vkMergePipelineCaches + VkDevice device + VkPipelineCache dstCache + uint32_t srcCacheCount + const VkPipelineCache* pSrcCaches + + pname:dstCache mustnot: appear in the list of source caches + + + + VkResult vkCreateGraphicsPipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkGraphicsPipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + If the value of the pname:flags member of any given element of pname:pCreateInfos contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the pname:basePipelineIndex member of that same element is not `-1`, the value of pname:basePipelineIndex must: be less than the index into pname:pCreateInfos that corresponds to that element + + + + VkResult vkCreateComputePipelines + VkDevice device + VkPipelineCache pipelineCache + uint32_t createInfoCount + const VkComputePipelineCreateInfo* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkPipeline* pPipelines + + If the value of the pname:flags member of any given element of pname:pCreateInfos contains the ename:VK_PIPELINE_CREATE_DERIVATIVE_BIT flag, and the pname:basePipelineIndex member of that same element is not `-1`, the value of pname:basePipelineIndex must: be less than the index into pname:pCreateInfos that corresponds to that element + + + + void vkDestroyPipeline + VkDevice device + VkPipeline pipeline + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:pipeline must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:pipeline was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:pipeline was created, pname:pAllocator must: be `NULL` + + + + VkResult vkCreatePipelineLayout + VkDevice device + const VkPipelineLayoutCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkPipelineLayout* pPipelineLayout + + + void vkDestroyPipelineLayout + VkDevice device + VkPipelineLayout pipelineLayout + const VkAllocationCallbacks* pAllocator + + If sname:VkAllocationCallbacks were provided when pname:pipelineLayout was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:pipelineLayout was created, pname:pAllocator must: be `NULL` + + + + VkResult vkCreateSampler + VkDevice device + const VkSamplerCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSampler* pSampler + + + void vkDestroySampler + VkDevice device + VkSampler sampler + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:sampler must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:sampler was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:sampler was created, pname:pAllocator must: be `NULL` + + + + VkResult vkCreateDescriptorSetLayout + VkDevice device + const VkDescriptorSetLayoutCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorSetLayout* pSetLayout + + + void vkDestroyDescriptorSetLayout + VkDevice device + VkDescriptorSetLayout descriptorSetLayout + const VkAllocationCallbacks* pAllocator + + If sname:VkAllocationCallbacks were provided when pname:descriptorSetLayout was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:descriptorSetLayout was created, pname:pAllocator must: be `NULL` + + + + VkResult vkCreateDescriptorPool + VkDevice device + const VkDescriptorPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDescriptorPool* pDescriptorPool + + + void vkDestroyDescriptorPool + VkDevice device + VkDescriptorPool descriptorPool + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:descriptorPool (via any allocated descriptor sets) must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:descriptorPool was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:descriptorPool was created, pname:pAllocator must: be `NULL` + + + + VkResult vkResetDescriptorPool + VkDevice device + VkDescriptorPool descriptorPool + VkDescriptorPoolResetFlags flags + + any sname:VkDescriptorSet objects allocated from pname:descriptorPool + + + All uses of pname:descriptorPool (via any allocated descriptor sets) must: have completed execution + + + + VkResult vkAllocateDescriptorSets + VkDevice device + const VkDescriptorSetAllocateInfo* pAllocateInfo + VkDescriptorSet* pDescriptorSets + + + VkResult vkFreeDescriptorSets + VkDevice device + VkDescriptorPool descriptorPool + uint32_t descriptorSetCount + const VkDescriptorSet* pDescriptorSets + + All submitted commands that refer to any element of pname:pDesciptorSets must: have completed execution + pname:pDescriptorSets must: be a pointer to an array of pname:descriptorSetCount sname:VkDescriptorSet handles, each element of which must: either be a valid handle or sname:VK_NULL_HANDLE + pname:descriptorPool must: have been created with the ename:VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT flag + + + + void vkUpdateDescriptorSets + VkDevice device + uint32_t descriptorWriteCount + const VkWriteDescriptorSet* pDescriptorWrites + uint32_t descriptorCopyCount + const VkCopyDescriptorSet* pDescriptorCopies + + + VkResult vkCreateFramebuffer + VkDevice device + const VkFramebufferCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkFramebuffer* pFramebuffer + + + void vkDestroyFramebuffer + VkDevice device + VkFramebuffer framebuffer + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:framebuffer must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:framebuffer was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:framebuffer was created, pname:pAllocator must: be `NULL` + + + + VkResult vkCreateRenderPass + VkDevice device + const VkRenderPassCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkRenderPass* pRenderPass + + + void vkDestroyRenderPass + VkDevice device + VkRenderPass renderPass + const VkAllocationCallbacks* pAllocator + + All submitted commands that refer to pname:renderPass must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:renderPass was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:renderPass was created, pname:pAllocator must: be `NULL` + + + + void vkGetRenderAreaGranularity + VkDevice device + VkRenderPass renderPass + VkExtent2D* pGranularity + + + VkResult vkCreateCommandPool + VkDevice device + const VkCommandPoolCreateInfo* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkCommandPool* pCommandPool + + + void vkDestroyCommandPool + VkDevice device + VkCommandPool commandPool + const VkAllocationCallbacks* pAllocator + + All sname:VkCommandBuffer objects allocated from pname:commandPool mustnot: be pending execution + If sname:VkAllocationCallbacks were provided when pname:commandPool was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:commandPool was created, pname:pAllocator must: be `NULL` + + + + VkResult vkResetCommandPool + VkDevice device + VkCommandPool commandPool + VkCommandPoolResetFlags flags + + All sname:VkCommandBuffer objects allocated from pname:commandPool mustnot: currently be pending execution + + + + VkResult vkAllocateCommandBuffers + VkDevice device + const VkCommandBufferAllocateInfo* pAllocateInfo + VkCommandBuffer* pCommandBuffers + + + void vkFreeCommandBuffers + VkDevice device + VkCommandPool commandPool + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + + All elements of pname:pCommandBuffers mustnot: be pending execution + pname:pCommandBuffers must: be a pointer to an array of pname:commandBufferCount sname:VkCommandBuffer handles, each element of which must: either be a valid handle or sname:VK_NULL_HANDLE + + + + VkResult vkBeginCommandBuffer + VkCommandBuffer commandBuffer + const VkCommandBufferBeginInfo* pBeginInfo + + pname:commandBuffer mustnot: be in the recording state + If pname:commandBuffer was allocated from a sname:VkCommandPool which did not have the ename:VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag set, pname:commandBuffer must: be in the initial state. + If pname:commandBuffer is a secondary command buffer, the pname:pInheritanceInfo member of pname:pBeginInfo must: be a valid sname:VkCommandBufferInheritanceInfo structure + If pname:commandBuffer is a secondary command buffer and either the pname:occlusionQueryEnable member of the pname:pInheritanceInfo member of pname:pBeginInfo is ename:VK_FALSE, or the precise occlusion queries feature is not enabled, the pname:queryFlags member of the pname:pInheritanceInfo member pname:pBeginInfo mustnot: contain ename:VK_QUERY_CONTROL_PRECISE_BIT + + + + + VkResult vkEndCommandBuffer + VkCommandBuffer commandBuffer + + pname:commandBuffer must: be in the recording state + fname:vkEndCommandBuffer mustnot: be called inside a render pass instance + All queries made <<queries-operation-active,active>> during the recording of pname:commandBuffer must: have been made inactive + + + + VkResult vkResetCommandBuffer + VkCommandBuffer commandBuffer + VkCommandBufferResetFlags flags + + pname:commandBuffer mustnot: currently be pending execution + pname:commandBuffer must: have been allocated from a pool that was created with the ename:VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT + + + + void vkCmdBindPipeline + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipeline pipeline + + If the value of pname:pipelineBindPoint is ename:VK_PIPELINE_BIND_POINT_COMPUTE, the sname:VkCommandPool that pname:commandBuffer was allocated from must: support compute operations + If the value of pname:pipelineBindPoint is ename:VK_PIPELINE_BIND_POINT_GRAPHICS, the sname:VkCommandPool that pname:commandBuffer was allocated from must: support graphics operations + If the value of pname:pipelineBindPoint is ename:VK_PIPELINE_BIND_POINT_COMPUTE, pname:pipeline must: be a compute pipeline + If the value of pname:pipelineBindPoint is ename:VK_PIPELINE_BIND_POINT_GRAPHICS, pname:pipeline must: be a graphics pipeline + If the <<features-features-variableMultisampleRate,variable multisample rate>> feature is not supported, pname:pipeline is a graphics pipeline, the current subpass has no attachments, and this is not the first call to this function with a graphics pipeline after transitioning to the current subpass, then the sample count specified by this pipeline must: match that set in the previous pipeline + + + + void vkCmdSetViewport + VkCommandBuffer commandBuffer + uint32_t firstViewport + uint32_t viewportCount + const VkViewport* pViewports + + pname:firstViewport must: be less than sname:VkPhysicalDeviceLimits::pname:maxViewports + The sum of pname:firstViewport and pname:viewportCount must: be between `1` and sname:VkPhysicalDeviceLimits::pname:maxViewports, inclusive + + + + void vkCmdSetScissor + VkCommandBuffer commandBuffer + uint32_t firstScissor + uint32_t scissorCount + const VkRect2D* pScissors + + pname:firstScissor must: be less than sname:VkPhysicalDeviceLimits::pname:maxViewports + The sum of pname:firstScissor and pname:scissorCount must: be between `1` and sname:VkPhysicalDeviceLimits::pname:maxViewports, inclusive + The pname:x and pname:y members of pname:offset must: be greater than or equal to `0` + Evaluation of (pname:offset.x + pname:extent.width) mustnot: cause a signed integer addition overflow + Evaluation of (pname:offset.y + pname:extent.height) mustnot: cause a signed integer addition overflow + + + + void vkCmdSetLineWidth + VkCommandBuffer commandBuffer + float lineWidth + + If the <<features-features-wideLines,wide lines>> feature is not enabled, the value of pname:lineWidth must: be `1.0` + + + + void vkCmdSetDepthBias + VkCommandBuffer commandBuffer + float depthBiasConstantFactor + float depthBiasClamp + float depthBiasSlopeFactor + + If the <<features-features-depthBiasClamp,depth bias clamping>> feature is not enabled, the value of pname:depthBiasClamp must: be code:0.0 + + + + void vkCmdSetBlendConstants + VkCommandBuffer commandBuffer + const float blendConstants[4] + + + void vkCmdSetDepthBounds + VkCommandBuffer commandBuffer + float minDepthBounds + float maxDepthBounds + + The value of pname:minDepthBounds must: be between `0.0` and `1.0`, inclusive + The value of pname:maxDepthBounds must: be between `0.0` and `1.0`, inclusive + + + + void vkCmdSetStencilCompareMask + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t compareMask + + + void vkCmdSetStencilWriteMask + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t writeMask + + + void vkCmdSetStencilReference + VkCommandBuffer commandBuffer + VkStencilFaceFlags faceMask + uint32_t reference + + + void vkCmdBindDescriptorSets + VkCommandBuffer commandBuffer + VkPipelineBindPoint pipelineBindPoint + VkPipelineLayout layout + uint32_t firstSet + uint32_t descriptorSetCount + const VkDescriptorSet* pDescriptorSets + uint32_t dynamicOffsetCount + const uint32_t* pDynamicOffsets + + Any given element of pname:pDescriptorSets must: have been created with a sname:VkDescriptorSetLayout that matches the sname:VkDescriptorSetLayout at set _n_ in pname:layout, where _n_ is the sum of the index into pname:pDescriptorSets and pname:firstSet + pname:dynamicOffsetCount must: be equal to the total number of dynamic descriptors in pname:pDescriptorSets + pname:pipelineBindPoint must: be supported by the pname:commandBuffer's parent sname:VkCommandPool's queue family + Any given element of pname:pDynamicOffsets must: satisfy the required alignment for the corresponding descriptor binding's descriptor type + + + + void vkCmdBindIndexBuffer + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + VkIndexType indexType + + The value of pname:offset must: be less than the size of pname:buffer + The sum of pname:offset, and the address of the range of sname:VkDeviceMemory object that's backing pname:buffer, must: be a multiple of the type indicated by pname:indexType + pname:buffer must: have been created with the ename:VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag + + + + void vkCmdBindVertexBuffers + VkCommandBuffer commandBuffer + uint32_t firstBinding + uint32_t bindingCount + const VkBuffer* pBuffers + const VkDeviceSize* pOffsets + + pname:firstBinding must: be less than sname:VkPhysicalDeviceLimits::pname:maxVertexInputBindings + The sum of pname:firstBinding and pname:bindingCount must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxVertexInputBindings + All elements of pname:pOffsets must: be less than the size of the corresponding element in pname:pBuffers + All elements of pname:pBuffers must: have been created with the ename:VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag + + + + void vkCmdDraw + VkCommandBuffer commandBuffer + uint32_t vertexCount + uint32_t instanceCount + uint32_t firstVertex + uint32_t firstInstance + + For each set _n_ that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must: have been bound to _n_ at ename:VK_PIPELINE_BIND_POINT_GRAPHICS, with a sname:VkPipelineLayout that is compatible for set _n_, with the sname:VkPipelineLayout used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + For each push constant that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must: have been set for ename:VK_PIPELINE_BIND_POINT_GRAPHICS, with a sname:VkPipelineLayout that is compatible for push constants, with the sname:VkPipelineLayout used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + Descriptors in each bound descriptor set, specified via fname:vkCmdBindDescriptorSets, must: be valid if they are statically used by the currently bound sname:VkPipeline object, specified via fname:vkCmdBindPipeline + All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must: have valid buffers bound + For a given vertex buffer binding, any attribute data fetched must: be entirely contained within the corresponding vertex buffer binding, as described in <<fxvertex-input>> + A valid graphics pipeline must: be bound to the current command buffer with ename:VK_PIPELINE_BIND_POINT_GRAPHICS + If the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must: have been set on the current command buffer + Every input attachment used by the current subpass must: be bound to the pipeline via a descriptor set + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used to sample from any sname:VkImage with a sname:VkImageView of the type ename:VK_IMAGE_VIEW_TYPE_3D, ename:VK_IMAGE_VIEW_TYPE_CUBE, ename:VK_IMAGE_VIEW_TYPE_1D_ARRAY, ename:VK_IMAGE_VIEW_TYPE_2D_ARRAY or ename:VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions with code:ImplicitLod, code:Dref or code:Proj in their name, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions that includes a lod bias or any offset values, in any shader stage + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + Any slink:VkImage being sampled with ename:VK_FILTER_LINEAR as a result of this command must: be of a format which supports linear filtering, as specified by the ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + + + + void vkCmdDrawIndexed + VkCommandBuffer commandBuffer + uint32_t indexCount + uint32_t instanceCount + uint32_t firstIndex + int32_t vertexOffset + uint32_t firstInstance + + For each set _n_ that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must: have been bound to _n_ at ename:VK_PIPELINE_BIND_POINT_GRAPHICS, with a sname:VkPipelineLayout that is compatible for set _n_, with the sname:VkPipelineLayout used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + For each push constant that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must: have been set for ename:VK_PIPELINE_BIND_POINT_GRAPHICS, with a sname:VkPipelineLayout that is compatible for push constants, with the sname:VkPipelineLayout used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + Descriptors in each bound descriptor set, specified via fname:vkCmdBindDescriptorSets, must: be valid if they are statically used by the currently bound sname:VkPipeline object, specified via fname:vkCmdBindPipeline + All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must: have valid buffers bound + For a given vertex buffer binding, any attribute data fetched must: be entirely contained within the corresponding vertex buffer binding, as described in <<fxvertex-input>> + A valid graphics pipeline must: be bound to the current command buffer with ename:VK_PIPELINE_BIND_POINT_GRAPHICS + If the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must: have been set on the current command buffer + The total value of (pname:indexSize * (pname:firstIndex + pname:indexCount) + pname:offset) must: be less than or equal to the size of the currently bound index buffer, with indexSize being based on the type specified by pname:indexType, where the index buffer, pname:indexType, and pname:offset are specified via fname:vkCmdBindIndexBuffer + Every input attachment used by the current subpass must: be bound to the pipeline via a descriptor set + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used to sample from any sname:VkImage with a sname:VkImageView of the type ename:VK_IMAGE_VIEW_TYPE_3D, ename:VK_IMAGE_VIEW_TYPE_CUBE, ename:VK_IMAGE_VIEW_TYPE_1D_ARRAY, ename:VK_IMAGE_VIEW_TYPE_2D_ARRAY or ename:VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions with code:ImplicitLod, code:Dref or code:Proj in their name, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions that includes a lod bias or any offset values, in any shader stage + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + Any slink:VkImage being sampled with ename:VK_FILTER_LINEAR as a result of this command must: be of a format which supports linear filtering, as specified by the ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + + + + void vkCmdDrawIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + The value of pname:offset must: be a multiple of `4` + If pname:drawCount is greater than `1`, the value of pname:stride must: be a multiple of `4` and must: be greater than or equal to sizeof(sname:VkDrawIndirectCommand) + If the <<features-features-multiDrawIndirect,multi-draw indirect>> feature is not enabled, the value of pname:drawCount must: be `0` or `1` + If the <<features-features-drawIndirectFirstInstance,drawIndirectFirstInstance>> feature is not enabled, all the pname:firstInstance members of the sname:VkDrawIndirectCommand structures accessed by this command must: be code:0 + For each set _n_ that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must: have been bound to _n_ at ename:VK_PIPELINE_BIND_POINT_GRAPHICS, with a sname:VkPipelineLayout that is compatible for set _n_, with the sname:VkPipelineLayout used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + For each push constant that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must: have been set for ename:VK_PIPELINE_BIND_POINT_GRAPHICS, with a sname:VkPipelineLayout that is compatible for push constants, with the sname:VkPipelineLayout used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + Descriptors in each bound descriptor set, specified via fname:vkCmdBindDescriptorSets, must: be valid if they are statically used by the currently bound sname:VkPipeline object, specified via fname:vkCmdBindPipeline + All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must: have valid buffers bound + A valid graphics pipeline must: be bound to the current command buffer with ename:VK_PIPELINE_BIND_POINT_GRAPHICS + If the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must: have been set on the current command buffer + If pname:drawCount is equal to `1`, the total value of (pname:offset + sizeof(sname:VkDrawIndirectCommand)) must: be less than or equal to the size of pname:buffer + If pname:drawCount is greater than `1`, the total value of (pname:stride x (pname:drawCount - 1) + pname:offset + sizeof(sname:VkDrawIndirectCommand)) must: be less than or equal to the size of pname:buffer + pname:drawCount must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxDrawIndirectCount + Every input attachment used by the current subpass must: be bound to the pipeline via a descriptor set + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used to sample from any sname:VkImage with a sname:VkImageView of the type ename:VK_IMAGE_VIEW_TYPE_3D, ename:VK_IMAGE_VIEW_TYPE_CUBE, ename:VK_IMAGE_VIEW_TYPE_1D_ARRAY, ename:VK_IMAGE_VIEW_TYPE_2D_ARRAY or ename:VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions with code:ImplicitLod, code:Dref or code:Proj in their name, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions that includes a lod bias or any offset values, in any shader stage + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + Any slink:VkImage being sampled with ename:VK_FILTER_LINEAR as a result of this command must: be of a format which supports linear filtering, as specified by the ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + + + + void vkCmdDrawIndexedIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + uint32_t drawCount + uint32_t stride + + The value of pname:offset must: be a multiple of `4` + If pname:drawCount is greater than `1`, the value of pname:stride must: be a multiple of `4` and must: be greater than or equal to sizeof(sname:VkDrawIndexedIndirectCommand) + If the <<features-features-multiDrawIndirect,multi-draw indirect>> feature is not enabled, the value of pname:drawCount must: be `0` or `1` + If the <<features-features-drawIndirectFirstInstance,drawIndirectFirstInstance>> feature is not enabled, all the pname:firstInstance members of the sname:VkDrawIndexedIndirectCommand structures accessed by this command must: be code:0 + For each set _n_ that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS, a descriptor set must: have been bound to _n_ at ename:VK_PIPELINE_BIND_POINT_GRAPHICS, with a sname:VkPipelineLayout that is compatible for set _n_, with the sname:VkPipelineLayout used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + For each push constant that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS, a push constant value must: have been set for ename:VK_PIPELINE_BIND_POINT_GRAPHICS, with a sname:VkPipelineLayout that is compatible for push constants, with the sname:VkPipelineLayout used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + Descriptors in each bound descriptor set, specified via fname:vkCmdBindDescriptorSets, must: be valid if they are statically used by the currently bound sname:VkPipeline object, specified via fname:vkCmdBindPipeline + All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must: have valid buffers bound + A valid graphics pipeline must: be bound to the current command buffer with ename:VK_PIPELINE_BIND_POINT_GRAPHICS + If the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS requires any dynamic state, that state must: have been set on the current command buffer + If pname:drawCount is equal to `1`, the total value of (pname:offset + sizeof(sname:VkDrawIndexedIndirectCommand)) must: be less than or equal to the size of pname:buffer + If pname:drawCount is greater than `1`, the total value of (pname:stride x (pname:drawCount - 1) + pname:offset + sizeof(sname:VkDrawIndexedIndirectCommand)) must: be less than or equal to the size of pname:buffer + pname:drawCount must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxDrawIndirectCount + Every input attachment used by the current subpass must: be bound to the pipeline via a descriptor set + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used to sample from any sname:VkImage with a sname:VkImageView of the type ename:VK_IMAGE_VIEW_TYPE_3D, ename:VK_IMAGE_VIEW_TYPE_CUBE, ename:VK_IMAGE_VIEW_TYPE_1D_ARRAY, ename:VK_IMAGE_VIEW_TYPE_2D_ARRAY or ename:VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions with code:ImplicitLod, code:Dref or code:Proj in their name, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions that includes a lod bias or any offset values, in any shader stage + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS accesses a uniform buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_GRAPHICS accesses a storage buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + Any slink:VkImage being sampled with ename:VK_FILTER_LINEAR as a result of this command must: be of a format which supports linear filtering, as specified by the ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + + + + void vkCmdDispatch + VkCommandBuffer commandBuffer + uint32_t x + uint32_t y + uint32_t z + + pname:x must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxComputeWorkGroupCount[0] + pname:y must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxComputeWorkGroupCount[1] + pname:z must: be less than or equal to sname:VkPhysicalDeviceLimits::pname:maxComputeWorkGroupCount[2] + For each set _n_ that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must: have been bound to _n_ at ename:VK_PIPELINE_BIND_POINT_COMPUTE, with a sname:VkPipelineLayout that is compatible for set _n_, with the sname:VkPipelineLayout used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + Descriptors in each bound descriptor set, specified via fname:vkCmdBindDescriptorSets, must: be valid if they are statically used by the currently bound sname:VkPipeline object, specified via fname:vkCmdBindPipeline + A valid compute pipeline must: be bound to the current command buffer with ename:VK_PIPELINE_BIND_POINT_COMPUTE + For each push constant that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must: have been set for ename:VK_PIPELINE_BIND_POINT_COMPUTE, with a sname:VkPipelineLayout that is compatible for push constants with the one used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it mustnot: be used to sample from any sname:VkImage with a sname:VkImageView of the type ename:VK_IMAGE_VIEW_TYPE_3D, ename:VK_IMAGE_VIEW_TYPE_CUBE, ename:VK_IMAGE_VIEW_TYPE_1D_ARRAY, ename:VK_IMAGE_VIEW_TYPE_2D_ARRAY or ename:VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions with code:ImplicitLod, code:Dref or code:Proj in their name, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions that includes a lod bias or any offset values, in any shader stage + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + Any slink:VkImage being sampled with ename:VK_FILTER_LINEAR as a result of this command must: be of a format which supports linear filtering, as specified by the ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + + + + void vkCmdDispatchIndirect + VkCommandBuffer commandBuffer + VkBuffer buffer + VkDeviceSize offset + + For each set _n_ that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE, a descriptor set must: have been bound to _n_ at ename:VK_PIPELINE_BIND_POINT_COMPUTE, with a sname:VkPipelineLayout that is compatible for set _n_, with the sname:VkPipelineLayout used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + Descriptors in each bound descriptor set, specified via fname:vkCmdBindDescriptorSets, must: be valid if they are statically used by the currently bound sname:VkPipeline object, specified via fname:vkCmdBindPipeline + A valid compute pipeline must: be bound to the current command buffer with ename:VK_PIPELINE_BIND_POINT_COMPUTE + pname:buffer must: have been created with the ename:VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set + The value of pname:offset must: be a multiple of `4` + The sum of pname:offset and the size of sname:VkDispatchIndirectCommand must: be less than or equal to the size of pname:buffer + For each push constant that is statically used by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE, a push constant value must: have been set for ename:VK_PIPELINE_BIND_POINT_COMPUTE, with a sname:VkPipelineLayout that is compatible for push constants with the one used to create the current sname:VkPipeline, as described in <<descriptorsets-compatibility>> + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it mustnot: be used to sample from any sname:VkImage with a sname:VkImageView of the type ename:VK_IMAGE_VIEW_TYPE_3D, ename:VK_IMAGE_VIEW_TYPE_CUBE, ename:VK_IMAGE_VIEW_TYPE_1D_ARRAY, ename:VK_IMAGE_VIEW_TYPE_2D_ARRAY or ename:VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions with code:ImplicitLod, code:Dref or code:Proj in their name, in any shader stage + If any sname:VkSampler object that is accessed from a shader by the sname:VkPipeline currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE uses unnormalized coordinates, it mustnot: be used with any of the SPIR-V `OpImageSample*` or `OpImageSparseSample*` instructions that includes a lod bias or any offset values, in any shader stage + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE accesses a uniform buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + If the <<features-features-robustBufferAccess,robust buffer access>> feature is not enabled, and any shader stage in the sname:VkPipeline object currently bound to ename:VK_PIPELINE_BIND_POINT_COMPUTE accesses a storage buffer, it mustnot: access values outside of the range of that buffer specified in the currently bound descriptor set + Any slink:VkImage being sampled with ename:VK_FILTER_LINEAR as a result of this command must: be of a format which supports linear filtering, as specified by the ename:VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + + + + void vkCmdCopyBuffer + VkCommandBuffer commandBuffer + VkBuffer srcBuffer + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferCopy* pRegions + + The sum of the pname:srcOffset and pname:copySize members of a given element of pname:pRegions must: be less than or equal to the size of pname:srcBuffer + The sum of the pname:dstOffset and pname:copySize members of a given element of pname:pRegions must: be less than or equal to the size of pname:dstBuffer + The union of the source regions, and the union of the destination regions, specified by the elements of pname:pRegions, mustnot: overlap in memory + pname:srcBuffer must: have been created with pname:VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag + pname:dstBuffer must: have been created with pname:VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag + + + + void vkCmdCopyImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageCopy* pRegions + + The source region specified by a given element of pname:pRegions must: be a region that is contained within pname:srcImage + The destination region specified by a given element of pname:pRegions must: be a region that is contained within pname:dstImage + The union of all source regions, and the union of all destination regions, specified by the elements of pname:pRegions, mustnot: overlap in memory + pname:srcImage must: have been created with pname:VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag + pname:srcImageLayout must: specify the layout of the subresources of pname:srcImage specified in pname:pRegions at the time this command is executed on a sname:VkDevice + pname:srcImageLayout must: be either of VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL + pname:dstImage must: have been created with pname:VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag + pname:dstImageLayout must: specify the layout of the subresources of pname:dstImage specified in pname:pRegions at the time this command is executed on a sname:VkDevice + pname:dstImageLayout must: be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL + The elink:VkFormat of each of pname:srcImage and pname:dstImage must: be compatible, as defined <<copies-images-format-compatibility, below>> + The sample count of pname:srcImage and pname:dstImage must: match + + + + void vkCmdBlitImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageBlit* pRegions + VkFilter filter + + The source region specified by a given element of pname:pRegions must: be a region that is contained within pname:srcImage + The destination region specified by a given element of pname:pRegions must: be a region that is contained within pname:dstImage + The union of all source regions, and the union of all destination regions, specified by the elements of pname:pRegions, mustnot: overlap in memory + pname:srcImage must: use a format that supports ename:VK_FORMAT_FEATURE_BLIT_SRC_BIT, which is indicated by sname:VkFormatProperties::pname:linearTilingFeatures (for linear tiled images) or sname:VkFormatProperties::pname:optimalTilingFeatures (for optimally tiled images) - as returned by fname:vkGetPhysicalDeviceFormatProperties + pname:srcImage must: have been created with pname:VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag + pname:srcImageLayout must: specify the layout of the subresources of pname:srcImage specified in pname:pRegions at the time this command is executed on a sname:VkDevice + pname:srcImageLayout must: be either of VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL + pname:dstImage must: use a format that supports ename:VK_FORMAT_FEATURE_BLIT_DST_BIT, which is indicated by sname:VkFormatProperties::pname:linearTilingFeatures (for linear tiled images) or sname:VkFormatProperties::pname:optimalTilingFeatures (for optimally tiled images) - as returned by fname:vkGetPhysicalDeviceFormatProperties + pname:dstImage must: have been created with pname:VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag + pname:dstImageLayout must: specify the layout of the subresources of pname:dstImage specified in pname:pRegions at the time this command is executed on a sname:VkDevice + pname:dstImageLayout must: be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL + The sample count of pname:srcImage and pname:dstImage must: both be equal to ename:VK_SAMPLE_COUNT_1_BIT + If either of pname:srcImage or pname:dstImage was created with a signed integer elink:VkFormat, the other must: also have been created with a signed integer elink:VkFormat + If either of pname:srcImage or pname:dstImage was created with an unsigned integer elink:VkFormat, the other must: also have been created with an unsigned integer elink:VkFormat + If either of pname:srcImage or pname:dstImage was created with a depth/stencil format, the other must: have exactly the same format + If pname:srcImage was created with a depth/stencil format, pname:filter must: be ename:VK_FILTER_NEAREST + + + + void vkCmdCopyBufferToImage + VkCommandBuffer commandBuffer + VkBuffer srcBuffer + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkBufferImageCopy* pRegions + + The buffer region specified by a given element of pname:pRegions must: be a region that is contained within pname:srcBuffer + The image region specified by a given element of pname:pRegions must: be a region that is contained within pname:dstImage + The union of all source regions, and the union of all destination regions, specified by the elements of pname:pRegions, mustnot: overlap in memory + pname:srcBuffer must: have been created with pname:VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag + pname:dstImage must: have been created with pname:VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag + pname:dstImage must: have a sample count equal to ename:VK_SAMPLE_COUNT_1_BIT + pname:dstImageLayout must: specify the layout of the subresources of pname:dstImage specified in pname:pRegions at the time this command is executed on a sname:VkDevice + pname:dstImageLayout must: be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL + + + + void vkCmdCopyImageToBuffer + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkBuffer dstBuffer + uint32_t regionCount + const VkBufferImageCopy* pRegions + + The image region specified by a given element of pname:pRegions must: be a region that is contained within pname:srcImage + The buffer region specified by a given element of pname:pRegions must: be a region that is contained within pname:dstBuffer + The union of all source regions, and the union of all destination regions, specified by the elements of pname:pRegions, mustnot: overlap in memory + pname:srcImage must: have been created with pname:VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag + pname:srcImage must: have a sample count equal to ename:VK_SAMPLE_COUNT_1_BIT + pname:srcImageLayout must: specify the layout of the subresources of pname:srcImage specified in pname:pRegions at the time this command is executed on a sname:VkDevice + pname:srcImageLayout must: be either of VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL + pname:dstBuffer must: have been created with pname:VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag + + + + void vkCmdUpdateBuffer + VkCommandBuffer commandBuffer + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize dataSize + const uint32_t* pData + + The sum of pname:dstOffset and pname:dataSize must: be less than or equal to the size of pname:dstBuffer + pname:dstBuffer must: have been created with pname:VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag + The value of pname:dstOffset must: be a multiple of `4` + The value of pname:dataSize must: be greater than `0` + The value of pname:dataSize must: be less than `65536` + The value of pname:dataSize must: be a multiple of `4` + + + + void vkCmdFillBuffer + VkCommandBuffer commandBuffer + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize size + uint32_t data + + If pname:size is not equal to ename:VK_WHOLE_SIZE, the sum of pname:dstOffset and pname:size must: be less than or equal to the size of pname:dstBuffer + pname:dstBuffer must: have been created with pname:VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag + pname:dstOffset must: be a multiple of `4` + If pname:size is not equal to ename:VK_WHOLE_SIZE, pname:size must: be a multiple of `4` + + + + void vkCmdClearColorImage + VkCommandBuffer commandBuffer + VkImage image + VkImageLayout imageLayout + const VkClearColorValue* pColor + uint32_t rangeCount + const VkImageSubresourceRange* pRanges + + pname:image must: have been created with pname:VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag + pname:imageLayout must: specify the layout of the subresource ranges of pname:image specified in pname:pRanges at the time this command is executed on a sname:VkDevice + pname:imageLayout must: be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL + The image range of any given element of pname:pRanges must: be a subresource range that is contained within pname:image + + + + void vkCmdClearDepthStencilImage + VkCommandBuffer commandBuffer + VkImage image + VkImageLayout imageLayout + const VkClearDepthStencilValue* pDepthStencil + uint32_t rangeCount + const VkImageSubresourceRange* pRanges + + pname:image must: have been created with pname:VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag + pname:imageLayout must: specify the layout of the subresource ranges of pname:image specified in pname:pRanges at the time this command is executed on a sname:VkDevice + pname:imageLayout must: be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL + The image range of any given element of pname:pRanges must: be a subresource range that is contained within pname:image + + + + void vkCmdClearAttachments + VkCommandBuffer commandBuffer + uint32_t attachmentCount + const VkClearAttachment* pAttachments + uint32_t rectCount + const VkClearRect* pRects + + If the pname:aspectMask member of any given element of pname:pAttachments contains ename:VK_IMAGE_ASPECT_COLOR_BIT, the pname:colorAttachment member of those elements must: refer to a valid color attachment in the current subpass + The rectangular region specified by a given element of pname:pRects must: be contained within the render area of the current render pass instance + The layers specified by a given element of pname:pRects must: be contained within every attachment that pname:pAttachments refers to + + + + void vkCmdResolveImage + VkCommandBuffer commandBuffer + VkImage srcImage + VkImageLayout srcImageLayout + VkImage dstImage + VkImageLayout dstImageLayout + uint32_t regionCount + const VkImageResolve* pRegions + + The source region specified by a given element of pname:pRegions must: be a region that is contained within pname:srcImage + The destination region specified by a given element of pname:pRegions must: be a region that is contained within pname:dstImage + The union of all source regions, and the union of all destination regions, specified by the elements of pname:pRegions, mustnot: overlap in memory + pname:srcImage must: have a sample count equal to any valid sample count value other than ename:VK_SAMPLE_COUNT_1_BIT + pname:dstImage must: have a sample count equal to ename:VK_SAMPLE_COUNT_1_BIT + pname:srcImageLayout must: specify the layout of the subresources of pname:srcImage specified in pname:pRegions at the time this command is executed on a sname:VkDevice + pname:srcImageLayout must: be either of VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL + pname:dstImageLayout must: specify the layout of the subresources of pname:dstImage specified in pname:pRegions at the time this command is executed on a sname:VkDevice + pname:dstImageLayout must: be either of VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL or VK_IMAGE_LAYOUT_GENERAL + If pname:dstImage was created with pname:tiling equal to ename:VK_IMAGE_TILING_LINEAR, pname:dstImage must: have been created with a pname:format that supports being a color attachment, as specified by the ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in sname:VkFormatProperties::pname:linearTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + If pname:dstImage was created with pname:tiling equal to ename:VK_IMAGE_TILING_OPTIMAL, pname:dstImage must: have been created with a pname:format that supports being a color attachment, as specified by the ename:VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT flag in sname:VkFormatProperties::pname:optimalTilingFeatures returned by fname:vkGetPhysicalDeviceFormatProperties + + + + + void vkCmdSetEvent + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags stageMask + + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, pname:stageMask mustnot: contain pname:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, pname:stageMask mustnot: contain pname:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or pname:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT + + + + void vkCmdResetEvent + VkCommandBuffer commandBuffer + VkEvent event + VkPipelineStageFlags stageMask + + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, pname:stageMask mustnot: contain pname:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, pname:stageMask mustnot: contain pname:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or pname:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT + + + + void vkCmdWaitEvents + VkCommandBuffer commandBuffer + uint32_t eventCount + const VkEvent* pEvents + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + uint32_t memoryBarrierCount + const VkMemoryBarrier* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier* pImageMemoryBarriers + + pname:srcStageMask must: be the bitwise OR of the pname:stageMask parameter used in previous calls to fname:vkCmdSetEvent with any of the members of pname:pEvents and VK_PIPELINE_STAGE_HOST_BIT if any of the members of pname:pEvents was set using fname:vkSetEvent + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, pname:srcStageMask mustnot: contain pname:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, pname:dstStageMask mustnot: contain pname:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, pname:srcStageMask mustnot: contain pname:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or pname:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, pname:dstStageMask mustnot: contain pname:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or pname:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT + If pname:pEvents includes one or more events that will be signaled by fname:vkSetEvent after pname:commandBuffer has been submitted to a queue, then fname:vkCmdWaitEvents mustnot: be called inside a render pass instance + + + + void vkCmdPipelineBarrier + VkCommandBuffer commandBuffer + VkPipelineStageFlags srcStageMask + VkPipelineStageFlags dstStageMask + VkDependencyFlags dependencyFlags + uint32_t memoryBarrierCount + const VkMemoryBarrier* pMemoryBarriers + uint32_t bufferMemoryBarrierCount + const VkBufferMemoryBarrier* pBufferMemoryBarriers + uint32_t imageMemoryBarrierCount + const VkImageMemoryBarrier* pImageMemoryBarriers + + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, pname:srcStageMask mustnot: contain pname:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT + If the <<features-features-geometryShader,geometry shaders>> feature is not enabled, pname:dstStageMask mustnot: contain pname:VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, pname:srcStageMask mustnot: contain pname:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or pname:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT + If the <<features-features-tessellationShader,tessellation shaders>> feature is not enabled, pname:dstStageMask mustnot: contain pname:VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or pname:VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT + If fname:vkCmdPipelineBarrier is called within a render pass instance, the render pass must: declare at least one self-dependency from the current subpass to itself - see <<synchronization-pipeline-barriers-subpass-self-dependencies,Subpass Self-dependency>> + + + + void vkCmdBeginQuery + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + VkQueryControlFlags flags + + The query identified by pname:queryPool and pname:query must: currently not be <<queries-operation-active,active>> + The query identified by pname:queryPool and pname:query must: be unavailable + If the <<features-features-occlusionQueryPrecise,precise occlusion queries>> feature is not enabled, or the pname:queryType used to create pname:queryPool was not ename:VK_QUERY_TYPE_OCCLUSION, pname:flags mustnot: contain ename:VK_QUERY_CONTROL_PRECISE_BIT + pname:queryPool must: have been created with a pname:queryType that differs from that of any other queries that have been made <<queries-operation-active,active>>, and are currently still active within pname:commandBuffer + pname:query must: be less than the number of queries in pname:queryPool + If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_OCCLUSION, the sname:VkCommandPool that pname:commandBuffer was created from must: support graphics operations + If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pname:pipelineStatistics indicate graphics operations, the sname:VkCommandPool that pname:commandBuffer was created from must: support graphics operations + If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_PIPELINE_STATISTICS and any of the pname:pipelineStatistics indicate compute operations, the sname:VkCommandPool that pname:commandBuffer was created from must: support compute operations + + + + void vkCmdEndQuery + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t query + + The query identified by pname:queryPool and pname:query must: currently be <<queries-operation-active,active>> + pname:query must: be less than the number of queries in pname:queryPool + + + + void vkCmdResetQueryPool + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + + pname:firstQuery must: be less than the number of queries in pname:queryPool + The sum of pname:firstQuery and pname:queryCount must: be less than or equal to the number of queries in pname:queryPool + + + + void vkCmdWriteTimestamp + VkCommandBuffer commandBuffer + VkPipelineStageFlagBits pipelineStage + VkQueryPool queryPool + uint32_t query + + The query identified by pname:queryPool and pname:query must: be _unavailable_ + The command pool's queue family must: support a non-zero value of pname:timestampValidBits + + + + void vkCmdCopyQueryPoolResults + VkCommandBuffer commandBuffer + VkQueryPool queryPool + uint32_t firstQuery + uint32_t queryCount + VkBuffer dstBuffer + VkDeviceSize dstOffset + VkDeviceSize stride + VkQueryResultFlags flags + + pname:firstQuery must: be less than the number of queries in pname:queryPool + The sum of pname:firstQuery and pname:queryCount must: be less than or equal to the number of queries in pname:queryPool + If ename:VK_QUERY_RESULT_64_BIT is not set in pname:flags then pname:dstOffset and pname:stride must be multiples of `4` + If ename:VK_QUERY_RESULT_64_BIT is set in pname:flags then pname:dstOffset and pname:stride must be multiples of `8` + pname:dstBuffer must: have enough storage, from pname:dstOffset, to contain the result of each query, as described <<queries-operation-memorylayout,here>> + If the pname:queryType used to create pname:queryPool was ename:VK_QUERY_TYPE_TIMESTAMP, pname:flags mustnot: contain ename:VK_QUERY_RESULT_PARTIAL_BIT + + + + void vkCmdPushConstants + VkCommandBuffer commandBuffer + VkPipelineLayout layout + VkShaderStageFlags stageFlags + uint32_t offset + uint32_t size + const void* pValues + + pname:stageFlags must: match exactly the shader stages used in pname:layout for the range specified by pname:offset and pname:size + pname:offset must: be a multiple of `4` + pname:size must: be a multiple of `4` + + + + void vkCmdBeginRenderPass + VkCommandBuffer commandBuffer + const VkRenderPassBeginInfo* pRenderPassBegin + VkSubpassContents contents + + If any of the pname:initialLayout or pname:finalLayout member of the sname:VkAttachmentDescription structures or the pname:layout member of the sname:VkAttachmentReference structures specified when creating the render pass specified in the pname:renderPass member of pname:pRenderPassBegin is ename:VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image of the framebuffer specified in the pname:framebuffer member of pname:pRenderPassBegin must: have been created with ename:VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT set + If any of the pname:initialLayout or pname:finalLayout member of the sname:VkAttachmentDescription structures or the pname:layout member of the sname:VkAttachmentReference structures specified when creating the render pass specified in the pname:renderPass member of pname:pRenderPassBegin is ename:VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL or ename:VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image of the framebuffer specified in the pname:framebuffer member of pname:pRenderPassBegin must: have been created with ename:VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set + If any of the pname:initialLayout or pname:finalLayout member of the sname:VkAttachmentDescription structures or the pname:layout member of the sname:VkAttachmentReference structures specified when creating the render pass specified in the pname:renderPass member of pname:pRenderPassBegin is ename:VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image of the framebuffer specified in the pname:framebuffer member of pname:pRenderPassBegin must: have been created with ename:VK_IMAGE_USAGE_SAMPLED_BIT or ename:VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set + If any of the pname:initialLayout or pname:finalLayout member of the sname:VkAttachmentDescription structures or the pname:layout member of the sname:VkAttachmentReference structures specified when creating the render pass specified in the pname:renderPass member of pname:pRenderPassBegin is ename:VK_IMAGE_LAYOUT_TRANSFER_SRC_BIT then the corresponding attachment image of the framebuffer specified in the pname:framebuffer member of pname:pRenderPassBegin must: have been created with ename:VK_IMAGE_USAGE_TRANSFER_SRC_BIT set + If any of the pname:initialLayout or pname:finalLayout member of the sname:VkAttachmentDescription structures or the pname:layout member of the sname:VkAttachmentReference structures specified when creating the render pass specified in the pname:renderPass member of pname:pRenderPassBegin is ename:VK_IMAGE_LAYOUT_TRANSFER_DST_BIT then the corresponding attachment image of the framebuffer specified in the pname:framebuffer member of pname:pRenderPassBegin must: have been created with ename:VK_IMAGE_USAGE_TRANSFER_DST_BIT set + + + + void vkCmdNextSubpass + VkCommandBuffer commandBuffer + VkSubpassContents contents + + The current subpass index must: be less than the number of subpasses in the render pass minus one + + + + void vkCmdEndRenderPass + VkCommandBuffer commandBuffer + + The current subpass index must: be equal to the number of subpasses in the render pass minus one + + + + void vkCmdExecuteCommands + VkCommandBuffer commandBuffer + uint32_t commandBufferCount + const VkCommandBuffer* pCommandBuffers + + pname:commandBuffer must: have been created with a pname:level value of VK_COMMAND_BUFFER_LEVEL_PRIMARY + Any given element of pname:pCommandBuffers must: have been created with a pname:level value of VK_COMMAND_BUFFER_LEVEL_SECONDARY + Any given element of pname:pCommandBuffers mustnot: be already pending execution in pname:commandBuffer, or appear twice in pname:pCommandBuffers, unless it was created with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag + Any given element of pname:pCommandBuffers mustnot: be already pending execution in any other sname:VkCommandBuffer, unless it was created with the ename:VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT flag + Any given element of pname:pCommandBuffers must: be in the executable state + If fname:vkCmdExecuteCommands is being called within a render pass instance, that render pass instance must: have been begun with the pname:contents parameter of fname:vkCmdBeginRenderPass set to ename:VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS + If fname:vkCmdExecuteCommands is being called within a render pass instance, any given element of pname:pCommandBuffers must: have been recorded with the ename:VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT + If fname:vkCmdExecuteCommands is being called within a render pass instance, any given element of pname:pCommandBuffers must: have been recorded with the pname:subpass member of the pname:inheritanceInfo structure set to the index of the subpass which the given command buffer will be executed in + If fname:vkCmdExecuteCommands is being called within a render pass instance, any given element of pname:pCommandBuffers must: have been recorded with a render pass that is compatible with the current render pass - see <<renderpass-compatibility>> + If fname:vkCmdExecuteCommands is being called within a render pass instance, and any given element of pname:pCommandBuffers was recorded with the pname:framebuffer member of the sname:VkCommandBufferInheritanceInfo structure not equal to sname:VK_NULL_HANDLE, that sname:VkFramebuffer must: be compatible with the sname:VkFramebuffer used in the current render pass instance + If the <<features-features-inheritedQueries,inherited queries>> feature is not enabled, pname:commandBuffer mustnot: have any queries <<queries-operation-active,active>> + If pname:commandBuffer has a ename:VK_QUERY_TYPE_OCCLUSION query <<queries-operation-active,active>>, then each element of pname:pCommandBuffers must: have been recorded with sname:VkCommandBufferBeginInfo::pname:occlusionQueryEnable set to ename:VK_TRUE + If pname:commandBuffer has a ename:VK_QUERY_TYPE_OCCLUSION query <<queries-operation-active,active>>, then each element of pname:pCommandBuffers must: have been recorded with sname:VkCommandBufferBeginInfo::pname:queryFlags having all bits set that are set for the query + If pname:commandBuffer has a ename:VK_QUERY_TYPE_PIPELINE_STATISTICS query <<queries-operation-active,active>>, then each element of pname:pCommandBuffers must: have been recorded with sname:VkCommandBufferBeginInfo::pname:pipelineStatistics having all bits set that are set in the sname:VkQueryPool the query uses + Any given element of pname:pCommandBuffers mustnot: begin any query types that are <<queries-operation-active,active>> in pname:commandBuffer + + + + VkResult vkCreateAndroidSurfaceKHR + VkInstance instance + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkGetPhysicalDeviceDisplayPropertiesKHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPropertiesKHR* pProperties + + + VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR + VkPhysicalDevice physicalDevice + uint32_t* pPropertyCount + VkDisplayPlanePropertiesKHR* pProperties + + + VkResult vkGetDisplayPlaneSupportedDisplaysKHR + VkPhysicalDevice physicalDevice + uint32_t planeIndex + uint32_t* pDisplayCount + VkDisplayKHR* pDisplays + + pname:planeIndex must: be less than the number of display planes supported by the device as determined by calling fname:vkGetPhysicalDeviceDisplayPlanePropertiesKHR + + + + VkResult vkGetDisplayModePropertiesKHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + uint32_t* pPropertyCount + VkDisplayModePropertiesKHR* pProperties + + + VkResult vkCreateDisplayModeKHR + VkPhysicalDevice physicalDevice + VkDisplayKHR display + const VkDisplayModeCreateInfoKHR*pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDisplayModeKHR* pMode + + + VkResult vkGetDisplayPlaneCapabilitiesKHR + VkPhysicalDevice physicalDevice + VkDisplayModeKHR mode + uint32_t planeIndex + VkDisplayPlaneCapabilitiesKHR* pCapabilities + + + VkResult vkCreateDisplayPlaneSurfaceKHR + VkInstance instance + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkResult vkCreateSharedSwapchainsKHR + VkDevice device + uint32_t swapchainCount + const VkSwapchainCreateInfoKHR* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkSwapchainKHR* pSwapchains + + + VkResult vkCreateMirSurfaceKHR + VkInstance instance + const VkMirSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceMirPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + MirConnection* connection + + pname:queueFamilyIndex must: be less than the value of pname:pQueueFamilyPropertyCount returned by fname:vkGetPhysicalDeviceQueueFamilyProperties for the given pname:physicalDevice + + + + void vkDestroySurfaceKHR + VkInstance instance + VkSurfaceKHR surface + const VkAllocationCallbacks* pAllocator + + All sname:VkSwapchainKHR objects created for pname:surface must: have been destroyed prior to destroying pname:surface + If sname:VkAllocationCallbacks were provided when pname:surface was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:surface was created, pname:pAllocator must: be `NULL` + + + + VkResult vkGetPhysicalDeviceSurfaceSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + VkSurfaceKHR surface + VkBool32* pSupported + + pname:queueFamilyIndex must: be less than the value of pname:pQueueFamilyPropertyCount returned by fname:vkGetPhysicalDeviceQueueFamilyProperties for the given pname:physicalDevice + + + + VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities + + + VkResult vkGetPhysicalDeviceSurfaceFormatsKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pSurfaceFormatCount + VkSurfaceFormatKHR* pSurfaceFormats + + + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR + VkPhysicalDevice physicalDevice + VkSurfaceKHR surface + uint32_t* pPresentModeCount + VkPresentModeKHR* pPresentModes + + + VkResult vkCreateSwapchainKHR + VkDevice device + const VkSwapchainCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSwapchainKHR* pSwapchain + + + void vkDestroySwapchainKHR + VkDevice device + VkSwapchainKHR swapchain + const VkAllocationCallbacks* pAllocator + + All uses of presentable images acquired from pname:swapchain and owned by the application must: have completed execution + If sname:VkAllocationCallbacks were provided when pname:swapchain was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:swapchain was created, pname:pAllocator must: be `NULL` + + + + VkResult vkGetSwapchainImagesKHR + VkDevice device + VkSwapchainKHR swapchain + uint32_t* pSwapchainImageCount + VkImage* pSwapchainImages + + + VkResult vkAcquireNextImageKHR + VkDevice device + VkSwapchainKHR swapchain + uint64_t timeout + VkSemaphore semaphore + VkFence fence + uint32_t* pImageIndex + + If pname:semaphore is not sname:VK_NULL_HANDLE it must: be unsignalled + If pname:fence is not sname:VK_NULL_HANDLE it must: be unsignalled and mustnot: be associated with any other queue command that has not yet completed execution on that queue + + + + VkResult vkQueuePresentKHR + VkQueue queue + const VkPresentInfoKHR* pPresentInfo + + Any given element of pname:pSwapchains member of pname:pPresentInfo must: be a swapchain that is created for a surface for which presentation is supported from pname:queue as determined using a call to fname:vkGetPhysicalDeviceSurfaceSupportKHR + + + + VkResult vkCreateWaylandSurfaceKHR + VkInstance instance + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + struct wl_display* display + + pname:queueFamilyIndex must: be less than the value of pname:pQueueFamilyPropertyCount returned by fname:vkGetPhysicalDeviceQueueFamilyProperties for the given pname:physicalDevice + + + + VkResult vkCreateWin32SurfaceKHR + VkInstance instance + const VkWin32SurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + + pname:queueFamilyIndex must: be less than the value of pname:pQueueFamilyPropertyCount returned by fname:vkGetPhysicalDeviceQueueFamilyProperties for the given pname:physicalDevice + + + + VkResult vkCreateXlibSurfaceKHR + VkInstance instance + const VkXlibSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + Display* dpy + VisualID visualID + + pname:queueFamilyIndex must: be less than the value of pname:pQueueFamilyPropertyCount returned by fname:vkGetPhysicalDeviceQueueFamilyProperties for the given pname:physicalDevice + + + + VkResult vkCreateXcbSurfaceKHR + VkInstance instance + const VkXcbSurfaceCreateInfoKHR* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkSurfaceKHR* pSurface + + + VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR + VkPhysicalDevice physicalDevice + uint32_t queueFamilyIndex + xcb_connection_t* connection + xcb_visualid_t visual_id + + pname:queueFamilyIndex must: be less than the value of pname:pQueueFamilyPropertyCount returned by fname:vkGetPhysicalDeviceQueueFamilyProperties for the given pname:physicalDevice + + + + VkResult vkCreateDebugReportCallbackEXT + VkInstance instance + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkDebugReportCallbackEXT* pCallback + + + void vkDestroyDebugReportCallbackEXT + VkInstance instance + VkDebugReportCallbackEXT callback + const VkAllocationCallbacks* pAllocator + + If sname:VkAllocationCallbacks were provided when pname:instance was created, a compatible set of callbacks must: be provided here + If no sname:VkAllocationCallbacks were provided when pname:instance was created, pname:pAllocator must: be `NULL` + + + + void vkDebugReportMessageEXT + VkInstance instance + VkDebugReportFlagsEXT flags + VkDebugReportObjectTypeEXT objectType + uint64_t object + size_t location + int32_t messageCode + const char* pLayerPrefix + const char* pMessage + + pname:instance must: be a valid sname:VkInstance handle + pname:flags must be a combination of one or more of sname:VkDebugReportFlagBitsEXT + pname:objType must be one of sname:VkDebugReportObjectTypeEXT, ename:VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT if pname:object is `NULL` + pname:object may be a {apiname} object + pname:pLayerPrefix must: be a `NULL` terminated string. + pname:pMsg must: be a `NULL` terminated string. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/vk.xsl b/vk.xsl new file mode 100644 index 0000000..11b8c1e --- /dev/null +++ b/vk.xsl @@ -0,0 +1,178 @@ + + + + + + + + using = ; + + + + using = ; + + + + // actually a 64 bit pointer + // should make use of parent info + using = uint64_t; + + + + // should make use of function parameters + typedef void (*) (void); + + + + struct { + + + + + + ; + + }; + + + + // should make use of member types + union { + + + + + ; + + }; + + + + + + + + + + + + + + + + + + constexpr auto = ; + + + + + // make use of @expand + enum { + + = , + + }; + + + + enum { + + + + = 1UL << + + + = + + + + #error Unhandle enum type for + + + , + + }; + + + + + + + + ( + + + + + + , + + ); + + + + + + + + + + + + + + + + + + + #ifndef __VK_HPP + #define __VK_HPP + #include <cstdint> + #include <cstddef> + + struct Display; + struct VisualID; + using Window = unsigned long; + + struct ANativeWindow; + + struct MirConnection; + struct MirSurface; + + struct wl_display; + struct wl_surface; + + using HANDLE = void*; + using HINSTANCE = HANDLE; + using HWND = HANDLE; + + struct xcb_connection_t; + struct xcb_visualid_t; + using xcb_window_t = uint32_t; + + + + + + + + + + + + + + #endif + + + + + + + + #error Unmatched element < => + + +