diff --git a/third_party/vulkan/loader/dev_ext_trampoline.c b/third_party/vulkan/loader/dev_ext_trampoline.c index c5c549aee..55eee0c25 100644 --- a/third_party/vulkan/loader/dev_ext_trampoline.c +++ b/third_party/vulkan/loader/dev_ext_trampoline.c @@ -16,6 +16,7 @@ * limitations under the License. * * Author: Jon Ashburn + * Author: Lenny Komow */ #include "vk_loader_platform.h" @@ -27,264 +28,256 @@ // Clang-format does not understand macros. // clang-format off - // Trampoline function macro for unknown physical device extension command. -#define DevExtTramp(num) \ -VKAPI_ATTR void VKAPI_CALL vkdev_ext##num(VkDevice device) { \ - const struct loader_dev_dispatch_table *disp; \ - disp = loader_get_dev_dispatch(device); \ - disp->ext_dispatch.dev_ext[num](device); \ - } - -DevExtTramp(0) -DevExtTramp(1) -DevExtTramp(2) -DevExtTramp(3) -DevExtTramp(4) -DevExtTramp(5) -DevExtTramp(6) -DevExtTramp(7) -DevExtTramp(8) -DevExtTramp(9) -DevExtTramp(10) -DevExtTramp(11) -DevExtTramp(12) -DevExtTramp(13) -DevExtTramp(14) -DevExtTramp(15) -DevExtTramp(16) -DevExtTramp(17) -DevExtTramp(18) -DevExtTramp(19) -DevExtTramp(20) -DevExtTramp(21) -DevExtTramp(22) -DevExtTramp(23) -DevExtTramp(24) -DevExtTramp(25) -DevExtTramp(26) -DevExtTramp(27) -DevExtTramp(28) -DevExtTramp(29) -DevExtTramp(30) -DevExtTramp(31) -DevExtTramp(32) -DevExtTramp(33) -DevExtTramp(34) -DevExtTramp(35) -DevExtTramp(36) -DevExtTramp(37) -DevExtTramp(38) -DevExtTramp(39) -DevExtTramp(40) -DevExtTramp(41) -DevExtTramp(42) -DevExtTramp(43) -DevExtTramp(44) -DevExtTramp(45) -DevExtTramp(46) -DevExtTramp(47) -DevExtTramp(48) -DevExtTramp(49) -DevExtTramp(50) -DevExtTramp(51) -DevExtTramp(52) -DevExtTramp(53) -DevExtTramp(54) -DevExtTramp(55) -DevExtTramp(56) -DevExtTramp(57) -DevExtTramp(58) -DevExtTramp(59) -DevExtTramp(60) -DevExtTramp(61) -DevExtTramp(62) -DevExtTramp(63) -DevExtTramp(64) -DevExtTramp(65) -DevExtTramp(66) -DevExtTramp(67) -DevExtTramp(68) -DevExtTramp(69) -DevExtTramp(70) -DevExtTramp(71) -DevExtTramp(72) -DevExtTramp(73) -DevExtTramp(74) -DevExtTramp(75) -DevExtTramp(76) -DevExtTramp(77) -DevExtTramp(78) -DevExtTramp(79) -DevExtTramp(80) -DevExtTramp(81) -DevExtTramp(82) -DevExtTramp(83) -DevExtTramp(84) -DevExtTramp(85) -DevExtTramp(86) -DevExtTramp(87) -DevExtTramp(88) -DevExtTramp(89) -DevExtTramp(90) -DevExtTramp(91) -DevExtTramp(92) -DevExtTramp(93) -DevExtTramp(94) -DevExtTramp(95) -DevExtTramp(96) -DevExtTramp(97) -DevExtTramp(98) -DevExtTramp(99) -DevExtTramp(100) -DevExtTramp(101) -DevExtTramp(102) -DevExtTramp(103) -DevExtTramp(104) -DevExtTramp(105) -DevExtTramp(106) -DevExtTramp(107) -DevExtTramp(108) -DevExtTramp(109) -DevExtTramp(110) -DevExtTramp(111) -DevExtTramp(112) -DevExtTramp(113) -DevExtTramp(114) -DevExtTramp(115) -DevExtTramp(116) -DevExtTramp(117) -DevExtTramp(118) -DevExtTramp(119) -DevExtTramp(120) -DevExtTramp(121) -DevExtTramp(122) -DevExtTramp(123) -DevExtTramp(124) -DevExtTramp(125) -DevExtTramp(126) -DevExtTramp(127) -DevExtTramp(128) -DevExtTramp(129) -DevExtTramp(130) -DevExtTramp(131) -DevExtTramp(132) -DevExtTramp(133) -DevExtTramp(134) -DevExtTramp(135) -DevExtTramp(136) -DevExtTramp(137) -DevExtTramp(138) -DevExtTramp(139) -DevExtTramp(140) -DevExtTramp(141) -DevExtTramp(142) -DevExtTramp(143) -DevExtTramp(144) -DevExtTramp(145) -DevExtTramp(146) -DevExtTramp(147) -DevExtTramp(148) -DevExtTramp(149) -DevExtTramp(150) -DevExtTramp(151) -DevExtTramp(152) -DevExtTramp(153) -DevExtTramp(154) -DevExtTramp(155) -DevExtTramp(156) -DevExtTramp(157) -DevExtTramp(158) -DevExtTramp(159) -DevExtTramp(160) -DevExtTramp(161) -DevExtTramp(162) -DevExtTramp(163) -DevExtTramp(164) -DevExtTramp(165) -DevExtTramp(166) -DevExtTramp(167) -DevExtTramp(168) -DevExtTramp(169) -DevExtTramp(170) -DevExtTramp(171) -DevExtTramp(172) -DevExtTramp(173) -DevExtTramp(174) -DevExtTramp(175) -DevExtTramp(176) -DevExtTramp(177) -DevExtTramp(178) -DevExtTramp(179) -DevExtTramp(180) -DevExtTramp(181) -DevExtTramp(182) -DevExtTramp(183) -DevExtTramp(184) -DevExtTramp(185) -DevExtTramp(186) -DevExtTramp(187) -DevExtTramp(188) -DevExtTramp(189) -DevExtTramp(190) -DevExtTramp(191) -DevExtTramp(192) -DevExtTramp(193) -DevExtTramp(194) -DevExtTramp(195) -DevExtTramp(196) -DevExtTramp(197) -DevExtTramp(198) -DevExtTramp(199) -DevExtTramp(200) -DevExtTramp(201) -DevExtTramp(202) -DevExtTramp(203) -DevExtTramp(204) -DevExtTramp(205) -DevExtTramp(206) -DevExtTramp(207) -DevExtTramp(208) -DevExtTramp(209) -DevExtTramp(210) -DevExtTramp(211) -DevExtTramp(212) -DevExtTramp(213) -DevExtTramp(214) -DevExtTramp(215) -DevExtTramp(216) -DevExtTramp(217) -DevExtTramp(218) -DevExtTramp(219) -DevExtTramp(220) -DevExtTramp(221) -DevExtTramp(222) -DevExtTramp(223) -DevExtTramp(224) -DevExtTramp(225) -DevExtTramp(226) -DevExtTramp(227) -DevExtTramp(228) -DevExtTramp(229) -DevExtTramp(230) -DevExtTramp(231) -DevExtTramp(232) -DevExtTramp(233) -DevExtTramp(234) -DevExtTramp(235) -DevExtTramp(236) -DevExtTramp(237) -DevExtTramp(238) -DevExtTramp(239) -DevExtTramp(240) -DevExtTramp(241) -DevExtTramp(242) -DevExtTramp(243) -DevExtTramp(244) -DevExtTramp(245) -DevExtTramp(246) -DevExtTramp(247) -DevExtTramp(248) -DevExtTramp(249) +VKAPI_ATTR void VKAPI_CALL vkdev_ext0(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext1(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext2(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext3(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext4(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext5(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext6(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext7(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext8(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext9(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext10(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext11(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext12(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext13(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext14(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext15(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext16(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext17(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext18(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext19(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext20(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext21(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext22(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext23(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext24(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext25(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext26(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext27(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext28(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext29(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext30(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext31(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext32(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext33(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext34(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext35(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext36(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext37(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext38(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext39(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext40(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext41(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext42(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext43(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext44(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext45(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext46(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext47(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext48(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext49(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext50(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext51(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext52(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext53(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext54(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext55(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext56(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext57(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext58(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext59(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext60(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext61(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext62(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext63(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext64(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext65(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext66(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext67(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext68(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext69(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext70(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext71(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext72(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext73(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext74(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext75(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext76(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext77(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext78(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext79(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext80(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext81(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext82(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext83(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext84(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext85(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext86(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext87(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext88(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext89(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext90(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext91(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext92(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext93(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext94(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext95(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext96(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext97(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext98(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext99(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext100(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext101(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext102(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext103(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext104(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext105(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext106(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext107(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext108(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext109(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext110(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext111(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext112(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext113(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext114(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext115(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext116(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext117(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext118(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext119(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext120(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext121(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext122(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext123(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext124(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext125(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext126(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext127(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext128(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext129(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext130(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext131(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext132(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext133(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext134(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext135(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext136(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext137(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext138(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext139(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext140(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext141(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext142(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext143(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext144(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext145(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext146(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext147(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext148(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext149(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext150(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext151(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext152(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext153(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext154(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext155(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext156(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext157(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext158(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext159(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext160(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext161(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext162(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext163(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext164(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext165(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext166(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext167(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext168(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext169(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext170(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext171(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext172(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext173(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext174(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext175(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext176(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext177(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext178(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext179(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext180(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext181(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext182(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext183(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext184(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext185(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext186(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext187(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext188(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext189(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext190(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext191(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext192(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext193(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext194(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext195(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext196(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext197(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext198(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext199(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext200(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext201(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext202(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext203(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext204(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext205(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext206(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext207(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext208(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext209(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext210(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext211(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext212(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext213(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext214(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext215(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext216(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext217(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext218(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext219(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext220(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext221(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext222(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext223(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext224(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext225(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext226(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext227(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext228(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext229(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext230(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext231(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext232(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext233(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext234(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext235(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext236(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext237(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext238(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext239(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext240(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext241(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext242(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext243(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext244(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext245(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext246(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext247(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext248(VkDevice device); +VKAPI_ATTR void VKAPI_CALL vkdev_ext249(VkDevice device); void *loader_get_dev_ext_trampoline(uint32_t index) { switch (index) { diff --git a/third_party/vulkan/loader/extension_manual.c b/third_party/vulkan/loader/extension_manual.c index 6ddb9b098..ef62b52b1 100644 --- a/third_party/vulkan/loader/extension_manual.c +++ b/third_party/vulkan/loader/extension_manual.c @@ -16,6 +16,7 @@ * limitations under the License. * * Author: Mark Young + * Author: Lenny Komow */ #define _GNU_SOURCE @@ -36,6 +37,8 @@ VkResult setupLoaderTrampPhysDevGroups(VkInstance instance); VkResult setupLoaderTermPhysDevGroups(struct loader_instance *inst); +// ---- VK_KHX_device_group extension trampoline/terminators + VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX( VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) { @@ -125,6 +128,8 @@ out: return res; } +// ---- VK_NV_external_memory_capabilities extension trampoline/terminators + VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, @@ -173,6 +178,760 @@ terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV( externalHandleType, pExternalImageFormatProperties); } +// ---- VK_KHR_get_physical_device_properties2 extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceFeatures2KHR(unwrapped_phys_dev, pFeatures); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2KHR *pFeatures) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceFeatures2KHR != NULL) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceFeatures2KHR(phys_dev_term->phys_dev, pFeatures); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceFeatures2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceFeatures", + icd_term->scanned_icd->lib_name); + + // Write to the VkPhysicalDeviceFeatures2KHR struct + icd_term->dispatch.GetPhysicalDeviceFeatures(phys_dev_term->phys_dev, &pFeatures->features); + + void *pNext = pFeatures->pNext; + while (pNext != NULL) { + switch (*(VkStructureType *)pNext) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX: { + // Skip the check if VK_KHX_multiview is enabled because it's a device extension + // Write to the VkPhysicalDeviceMultiviewFeaturesKHX struct + VkPhysicalDeviceMultiviewFeaturesKHX *multiview_features = pNext; + multiview_features->multiview = VK_FALSE; + multiview_features->multiviewGeometryShader = VK_FALSE; + multiview_features->multiviewTessellationShader = VK_FALSE; + + pNext = multiview_features->pNext; + break; + } + default: { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceFeatures2KHR: Emulation found unrecognized structure type in pFeatures->pNext - " + "this struct will be ignored"); + + struct VkStructureHeader *header = pNext; + pNext = (void *)header->pNext; + break; + } + } + } + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHR *pProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceProperties2KHR(unwrapped_phys_dev, pProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHR *pProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceProperties2KHR != NULL) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceProperties2KHR(phys_dev_term->phys_dev, pProperties); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceProperties2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceProperties", + icd_term->scanned_icd->lib_name); + + // Write to the VkPhysicalDeviceProperties2KHR struct + icd_term->dispatch.GetPhysicalDeviceProperties(phys_dev_term->phys_dev, &pProperties->properties); + + void *pNext = pProperties->pNext; + while (pNext != NULL) { + switch (*(VkStructureType *)pNext) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: { + VkPhysicalDeviceIDPropertiesKHR *id_properties = pNext; + + // Verify that "VK_KHR_external_memory_capabilities" is enabled + if (icd_term->this_instance->enabled_known_extensions.khr_external_memory_capabilities) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceProperties2KHR: Emulation cannot generate unique IDs for struct " + "VkPhysicalDeviceIDPropertiesKHR - setting IDs to zero instead"); + + // Write to the VkPhysicalDeviceIDPropertiesKHR struct + memset(id_properties->deviceUUID, 0, VK_UUID_SIZE); + memset(id_properties->driverUUID, 0, VK_UUID_SIZE); + id_properties->deviceLUIDValid = VK_FALSE; + } + + pNext = id_properties->pNext; + break; + } + default: { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceProperties2KHR: Emulation found unrecognized structure type in " + "pProperties->pNext - this struct will be ignored"); + + struct VkStructureHeader *header = pNext; + pNext = (void *)header->pNext; + break; + } + } + } + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2KHR *pFormatProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceFormatProperties2KHR(unwrapped_phys_dev, format, pFormatProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2KHR *pFormatProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceFormatProperties2KHR != NULL) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceFormatProperties2KHR(phys_dev_term->phys_dev, format, pFormatProperties); + } else { + // Emulate the call + loader_log( + icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceFormatProperties2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceFormatProperties", + icd_term->scanned_icd->lib_name); + + // Write to the VkFormatProperties2KHR struct + icd_term->dispatch.GetPhysicalDeviceFormatProperties(phys_dev_term->phys_dev, format, &pFormatProperties->formatProperties); + + if (pFormatProperties->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceFormatProperties2KHR: Emulation found unrecognized structure type in " + "pFormatProperties->pNext - this struct will be ignored"); + } + } +} + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo, + VkImageFormatProperties2KHR *pImageFormatProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + return disp->GetPhysicalDeviceImageFormatProperties2KHR(unwrapped_phys_dev, pImageFormatInfo, pImageFormatProperties); +} + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo, + VkImageFormatProperties2KHR *pImageFormatProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceImageFormatProperties2KHR != NULL) { + // Pass the call to the driver + return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties2KHR(phys_dev_term->phys_dev, pImageFormatInfo, + pImageFormatProperties); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceImageFormatProperties2KHR: Emulating call in ICD \"%s\" using " + "vkGetPhysicalDeviceImageFormatProperties", + icd_term->scanned_icd->lib_name); + + // If there is more info in either pNext, then this is unsupported + if (pImageFormatInfo->pNext != NULL || pImageFormatProperties->pNext != NULL) { + return VK_ERROR_FORMAT_NOT_SUPPORTED; + } + + // Write to the VkImageFormatProperties2KHR struct + return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties( + phys_dev_term->phys_dev, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, + pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties); + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t *pQueueFamilyPropertyCount, + VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceQueueFamilyProperties2KHR(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties2KHR != NULL) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties2KHR(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, + pQueueFamilyProperties); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceQueueFamilyProperties2KHR: Emulating call in ICD \"%s\" using " + "vkGetPhysicalDeviceQueueFamilyProperties", + icd_term->scanned_icd->lib_name); + + if (pQueueFamilyProperties == NULL || *pQueueFamilyPropertyCount == 0) { + // Write to pQueueFamilyPropertyCount + icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, NULL); + } else { + // Allocate a temporary array for the output of the old function + VkQueueFamilyProperties *properties = loader_stack_alloc(*pQueueFamilyPropertyCount * sizeof(VkQueueFamilyProperties)); + if (properties == NULL) { + *pQueueFamilyPropertyCount = 0; + loader_log( + icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "vkGetPhysicalDeviceQueueFamilyProperties2KHR: Out of memory - Failed to allocate array for loader emulation."); + return; + } + + icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, + properties); + for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; ++i) { + // Write to the VkQueueFamilyProperties2KHR struct + memcpy(&pQueueFamilyProperties[i].queueFamilyProperties, &properties[i], sizeof(VkQueueFamilyProperties)); + + if (pQueueFamilyProperties[i].pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceQueueFamilyProperties2KHR: Emulation found unrecognized structure type in " + "pQueueFamilyProperties[%d].pNext - this struct will be ignored", + i); + } + } + } + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceMemoryProperties2KHR(unwrapped_phys_dev, pMemoryProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceMemoryProperties2KHR != NULL) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceMemoryProperties2KHR(phys_dev_term->phys_dev, pMemoryProperties); + } else { + // Emulate the call + loader_log( + icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceMemoryProperties2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceMemoryProperties", + icd_term->scanned_icd->lib_name); + + // Write to the VkPhysicalDeviceMemoryProperties2KHR struct + icd_term->dispatch.GetPhysicalDeviceMemoryProperties(phys_dev_term->phys_dev, &pMemoryProperties->memoryProperties); + + if (pMemoryProperties->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceMemoryProperties2KHR: Emulation found unrecognized structure type in " + "pMemoryProperties->pNext - this struct will be ignored"); + } + } +} + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount, + VkSparseImageFormatProperties2KHR *pProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceSparseImageFormatProperties2KHR(unwrapped_phys_dev, pFormatInfo, pPropertyCount, pProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount, + VkSparseImageFormatProperties2KHR *pProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties2KHR != NULL) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties2KHR(phys_dev_term->phys_dev, pFormatInfo, pPropertyCount, + pProperties); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceSparseImageFormatProperties2KHR: Emulating call in ICD \"%s\" using " + "vkGetPhysicalDeviceSparseImageFormatProperties", + icd_term->scanned_icd->lib_name); + + if (pFormatInfo->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceSparseImageFormatProperties2KHR: Emulation found unrecognized structure type in " + "pFormatInfo->pNext - this struct will be ignored"); + } + + if (pProperties == NULL || *pPropertyCount == 0) { + // Write to pPropertyCount + icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties( + phys_dev_term->phys_dev, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, + pFormatInfo->tiling, pPropertyCount, NULL); + } else { + // Allocate a temporary array for the output of the old function + VkSparseImageFormatProperties *properties = + loader_stack_alloc(*pPropertyCount * sizeof(VkSparseImageMemoryRequirements)); + if (properties == NULL) { + *pPropertyCount = 0; + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "vkGetPhysicalDeviceSparseImageFormatProperties2KHR: Out of memory - Failed to allocate array for " + "loader emulation."); + return; + } + + icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties( + phys_dev_term->phys_dev, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, + pFormatInfo->tiling, pPropertyCount, properties); + for (uint32_t i = 0; i < *pPropertyCount; ++i) { + // Write to the VkSparseImageFormatProperties2KHR struct + memcpy(&pProperties[i].properties, &properties[i], sizeof(VkSparseImageFormatProperties)); + + if (pProperties[i].pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceSparseImageFormatProperties2KHR: Emulation found unrecognized structure type in " + "pProperties[%d].pNext - this struct will be ignored", + i); + } + } + } + } +} + +// ---- VK_KHR_get_surface_capabilities2 extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, + VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + return disp->GetPhysicalDeviceSurfaceCapabilities2KHR(unwrapped_phys_dev, pSurfaceInfo, pSurfaceCapabilities); +} + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, + VkSurfaceCapabilities2KHR *pSurfaceCapabilities) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + VkIcdSurface *icd_surface = (VkIcdSurface *)(pSurfaceInfo->surface); + uint8_t icd_index = phys_dev_term->icd_index; + + if (icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2KHR != NULL) { + // Pass the call to the driver, possibly unwrapping the ICD surface + if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) { + VkPhysicalDeviceSurfaceInfo2KHR info_copy = *pSurfaceInfo; + info_copy.surface = icd_surface->real_icd_surfaces[icd_index]; + return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2KHR(phys_dev_term->phys_dev, &info_copy, + pSurfaceCapabilities); + } else { + return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2KHR(phys_dev_term->phys_dev, pSurfaceInfo, + pSurfaceCapabilities); + } + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Emulating call in ICD \"%s\" using " + "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", + icd_term->scanned_icd->lib_name); + + if (pSurfaceInfo->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Emulation found unrecognized structure type in " + "pSurfaceInfo->pNext - this struct will be ignored"); + } + + // Write to the VkSurfaceCapabilities2KHR struct + VkSurfaceKHR surface = pSurfaceInfo->surface; + if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) { + surface = icd_surface->real_icd_surfaces[icd_index]; + } + VkResult res = icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev_term->phys_dev, surface, + &pSurfaceCapabilities->surfaceCapabilities); + + if (pSurfaceCapabilities->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Emulation found unrecognized structure type in " + "pSurfaceCapabilities->pNext - this struct will be ignored"); + } + return res; + } +} + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, + uint32_t *pSurfaceFormatCount, + VkSurfaceFormat2KHR *pSurfaceFormats) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + return disp->GetPhysicalDeviceSurfaceFormats2KHR(unwrapped_phys_dev, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); +} + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, + uint32_t *pSurfaceFormatCount, + VkSurfaceFormat2KHR *pSurfaceFormats) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + VkIcdSurface *icd_surface = (VkIcdSurface *)(pSurfaceInfo->surface); + uint8_t icd_index = phys_dev_term->icd_index; + + if (icd_term->dispatch.GetPhysicalDeviceSurfaceFormats2KHR != NULL) { + // Pass the call to the driver, possibly unwrapping the ICD surface + if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) { + VkPhysicalDeviceSurfaceInfo2KHR info_copy = *pSurfaceInfo; + info_copy.surface = icd_surface->real_icd_surfaces[icd_index]; + return icd_term->dispatch.GetPhysicalDeviceSurfaceFormats2KHR(phys_dev_term->phys_dev, &info_copy, pSurfaceFormatCount, + pSurfaceFormats); + } else { + return icd_term->dispatch.GetPhysicalDeviceSurfaceFormats2KHR(phys_dev_term->phys_dev, pSurfaceInfo, + pSurfaceFormatCount, pSurfaceFormats); + } + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceSurfaceFormats2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceSurfaceFormatsKHR", + icd_term->scanned_icd->lib_name); + + if (pSurfaceInfo->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceSurfaceFormats2KHR: Emulation found unrecognized structure type in pSurfaceInfo->pNext " + "- this struct will be ignored"); + } + + VkSurfaceKHR surface = pSurfaceInfo->surface; + if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) { + surface = icd_surface->real_icd_surfaces[icd_index]; + } + + if (*pSurfaceFormatCount == 0 || pSurfaceFormats == NULL) { + // Write to pSurfaceFormatCount + return icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev, surface, pSurfaceFormatCount, + NULL); + } else { + // Allocate a temporary array for the output of the old function + VkSurfaceFormatKHR *formats = loader_stack_alloc(*pSurfaceFormatCount * sizeof(VkSurfaceFormatKHR)); + if (formats == NULL) { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + + VkResult res = icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev, surface, + pSurfaceFormatCount, formats); + for (uint32_t i = 0; i < *pSurfaceFormatCount; ++i) { + pSurfaceFormats[i].surfaceFormat = formats[i]; + if (pSurfaceFormats[i].pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceSurfaceFormats2KHR: Emulation found unrecognized structure type in " + "pSurfaceFormats[%d].pNext - this struct will be ignored", + i); + } + } + return res; + } + } +} + +// ---- VK_EXT_display_surface_counter extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT *pSurfaceCapabilities) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + return disp->GetPhysicalDeviceSurfaceCapabilities2EXT(unwrapped_phys_dev, surface, pSurfaceCapabilities); +} + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + VkIcdSurface *icd_surface = (VkIcdSurface *)(surface); + uint8_t icd_index = phys_dev_term->icd_index; + + // Unwrap the surface if needed + VkSurfaceKHR unwrapped_surface = surface; + if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) { + unwrapped_surface = icd_surface->real_icd_surfaces[icd_index]; + } + + if (icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2EXT != NULL) { + // Pass the call to the driver + return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2EXT(phys_dev_term->phys_dev, unwrapped_surface, + pSurfaceCapabilities); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceSurfaceCapabilities2EXT: Emulating call in ICD \"%s\" using " + "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", + icd_term->scanned_icd->lib_name); + + VkSurfaceCapabilitiesKHR surface_caps; + VkResult res = + icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev_term->phys_dev, unwrapped_surface, &surface_caps); + pSurfaceCapabilities->minImageCount = surface_caps.minImageCount; + pSurfaceCapabilities->maxImageCount = surface_caps.maxImageCount; + pSurfaceCapabilities->currentExtent = surface_caps.currentExtent; + pSurfaceCapabilities->minImageExtent = surface_caps.minImageExtent; + pSurfaceCapabilities->maxImageExtent = surface_caps.maxImageExtent; + pSurfaceCapabilities->maxImageArrayLayers = surface_caps.maxImageArrayLayers; + pSurfaceCapabilities->supportedTransforms = surface_caps.supportedTransforms; + pSurfaceCapabilities->currentTransform = surface_caps.currentTransform; + pSurfaceCapabilities->supportedCompositeAlpha = surface_caps.supportedCompositeAlpha; + pSurfaceCapabilities->supportedUsageFlags = surface_caps.supportedUsageFlags; + pSurfaceCapabilities->supportedSurfaceCounters = 0; + + if (pSurfaceCapabilities->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceSurfaceCapabilities2EXT: Emulation found unrecognized structure type in " + "pSurfaceCapabilities->pNext - this struct will be ignored"); + } + + return res; + } +} + +// ---- VK_EXT_direct_mode_display extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + return disp->ReleaseDisplayEXT(unwrapped_phys_dev, display); +} + +VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.ReleaseDisplayEXT == NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "ICD \"%s\" associated with VkPhysicalDevice does not support vkReleaseDisplayEXT - Consequently, the call is " + "invalid because it should not be possible to acquire a display on this device", + icd_term->scanned_icd->lib_name); + } + return icd_term->dispatch.ReleaseDisplayEXT(phys_dev_term->phys_dev, display); +} + +// ---- VK_EXT_acquire_xlib_display extension trampoline/terminators + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + return disp->AcquireXlibDisplayEXT(unwrapped_phys_dev, dpy, display); +} + +VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, + VkDisplayKHR display) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.AcquireXlibDisplayEXT != NULL) { + // Pass the call to the driver + return icd_term->dispatch.AcquireXlibDisplayEXT(phys_dev_term->phys_dev, dpy, display); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkAcquireXLibDisplayEXT: Emulating call in ICD \"%s\" by returning error", icd_term->scanned_icd->lib_name); + + // Fail for the unsupported command + return VK_ERROR_INITIALIZATION_FAILED; + } +} + +VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, + VkDisplayKHR *pDisplay) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + return disp->GetRandROutputDisplayEXT(unwrapped_phys_dev, dpy, rrOutput, pDisplay); +} + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, + VkDisplayKHR *pDisplay) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetRandROutputDisplayEXT != NULL) { + // Pass the call to the driver + return icd_term->dispatch.GetRandROutputDisplayEXT(phys_dev_term->phys_dev, dpy, rrOutput, pDisplay); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetRandROutputDisplayEXT: Emulating call in ICD \"%s\" by returning null display", + icd_term->scanned_icd->lib_name); + + // Return a null handle to indicate this can't be done + *pDisplay = VK_NULL_HANDLE; + return VK_SUCCESS; + } +} + +#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT + +// ---- VK_KHR_external_memory_capabilities extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo, + VkExternalBufferPropertiesKHR *pExternalBufferProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceExternalBufferPropertiesKHR(unwrapped_phys_dev, pExternalBufferInfo, pExternalBufferProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo, + VkExternalBufferPropertiesKHR *pExternalBufferProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceExternalBufferPropertiesKHR) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceExternalBufferPropertiesKHR(phys_dev_term->phys_dev, pExternalBufferInfo, + pExternalBufferProperties); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalBufferPropertiesKHR: Emulating call in ICD \"%s\"", icd_term->scanned_icd->lib_name); + + if (pExternalBufferInfo->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalBufferPropertiesKHR: Emulation found unrecognized structure type in " + "pExternalBufferInfo->pNext - this struct will be ignored"); + } + + // Fill in everything being unsupported + memset(&pExternalBufferProperties->externalMemoryProperties, 0, sizeof(VkExternalMemoryPropertiesKHR)); + + if (pExternalBufferProperties->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalBufferPropertiesKHR: Emulation found unrecognized structure type in " + "pExternalBufferProperties->pNext - this struct will be ignored"); + } + } +} + +// ---- VK_KHR_external_semaphore_capabilities extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR *pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR *pExternalSemaphoreProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceExternalSemaphorePropertiesKHR(unwrapped_phys_dev, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR *pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR *pExternalSemaphoreProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceExternalSemaphorePropertiesKHR != NULL) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceExternalSemaphorePropertiesKHR(phys_dev_term->phys_dev, pExternalSemaphoreInfo, + pExternalSemaphoreProperties); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: Emulating call in ICD \"%s\"", + icd_term->scanned_icd->lib_name); + + if (pExternalSemaphoreInfo->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: Emulation found unrecognized structure type in " + "pExternalSemaphoreInfo->pNext - this struct will be ignored"); + } + + // Fill in everything being unsupported + pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0; + pExternalSemaphoreProperties->compatibleHandleTypes = 0; + pExternalSemaphoreProperties->externalSemaphoreFeatures = 0; + + if (pExternalSemaphoreProperties->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: Emulation found unrecognized structure type in " + "pExternalSemaphoreProperties->pNext - this struct will be ignored"); + } + } +} + +// ---- VK_KHR_external_fence_capabilities extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR *pExternalFenceInfo, + VkExternalFencePropertiesKHR *pExternalFenceProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + disp = loader_get_instance_layer_dispatch(physicalDevice); + disp->GetPhysicalDeviceExternalFencePropertiesKHR(unwrapped_phys_dev, pExternalFenceInfo, pExternalFenceProperties); +} + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR *pExternalFenceInfo, + VkExternalFencePropertiesKHR *pExternalFenceProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + + if (icd_term->dispatch.GetPhysicalDeviceExternalFencePropertiesKHR != NULL) { + // Pass the call to the driver + icd_term->dispatch.GetPhysicalDeviceExternalFencePropertiesKHR(phys_dev_term->phys_dev, pExternalFenceInfo, + pExternalFenceProperties); + } else { + // Emulate the call + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalFencePropertiesKHR: Emulating call in ICD \"%s\"", icd_term->scanned_icd->lib_name); + + if (pExternalFenceInfo->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalFencePropertiesKHR: Emulation found unrecognized structure type in " + "pExternalFenceInfo->pNext - this struct will be ignored"); + } + + // Fill in everything being unsupported + pExternalFenceProperties->exportFromImportedHandleTypes = 0; + pExternalFenceProperties->compatibleHandleTypes = 0; + pExternalFenceProperties->externalFenceFeatures = 0; + + if (pExternalFenceProperties->pNext != NULL) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "vkGetPhysicalDeviceExternalFencePropertiesKHR: Emulation found unrecognized structure type in " + "pExternalFenceProperties->pNext - this struct will be ignored"); + } + } +} + +// ---- Helper functions VkResult setupLoaderTrampPhysDevGroups(VkInstance instance) { VkResult res = VK_SUCCESS; @@ -583,4 +1342,4 @@ out: } return res; -} \ No newline at end of file +} diff --git a/third_party/vulkan/loader/extension_manual.h b/third_party/vulkan/loader/extension_manual.h index 35d7c6fa0..3b299d553 100644 --- a/third_party/vulkan/loader/extension_manual.h +++ b/third_party/vulkan/loader/extension_manual.h @@ -47,3 +47,114 @@ terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV( VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties); +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2KHR* pFeatures); + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHR* pProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHR* pProperties); + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2KHR* pFormatProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, + VkFormatProperties2KHR* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, + VkImageFormatProperties2KHR* pImageFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, + VkImageFormatProperties2KHR* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2KHR* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, + VkSparseImageFormatProperties2KHR* pProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, + VkSparseImageFormatProperties2KHR* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display); + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, + VkDisplayKHR display); + +VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, + VkDisplayKHR* pDisplay); + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, + VkDisplayKHR* pDisplay); +#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, + VkExternalBufferPropertiesKHR* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, + VkExternalBufferPropertiesKHR* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, + VkExternalFencePropertiesKHR* pExternalFenceProperties); + +VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, + VkExternalFencePropertiesKHR* pExternalFenceProperties); diff --git a/third_party/vulkan/loader/loader.c b/third_party/vulkan/loader/loader.c index a32ae372b..a3f4a5980 100644 --- a/third_party/vulkan/loader/loader.c +++ b/third_party/vulkan/loader/loader.c @@ -78,7 +78,7 @@ enum loader_debug { }; uint32_t g_loader_debug = 0; -uint32_t g_loader_log_msgs = 0x0E; +uint32_t g_loader_log_msgs = 0; // thread safety lock for accessing global data structures such as "loader" // all entrypoints on the instance chain need to be locked except GPA @@ -86,8 +86,6 @@ uint32_t g_loader_log_msgs = 0x0E; loader_platform_thread_mutex loader_lock; loader_platform_thread_mutex loader_json_lock; -const char *std_validation_str = "VK_LAYER_LUNARG_standard_validation"; - LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_init); void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope alloc_scope) { @@ -103,6 +101,7 @@ void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t #endif pMemory = malloc(size); } + return pMemory; } @@ -208,7 +207,6 @@ static inline char *loader_getenv(const char *name, const struct loader_instance return getenv(name); } - static inline char *loader_secure_getenv(const char *name, const struct loader_instance *inst) { // No allocation of memory necessary for Linux, but we should at least touch // the inst pointer to get rid of compiler warnings. @@ -219,8 +217,9 @@ static inline char *loader_secure_getenv(const char *name, const struct loader_i #elif defined(HAVE___SECURE_GETENV) return __secure_getenv(name); #else -#pragma message("Warning: Falling back to non-secure getenv for environmental lookups! Consider" \ - " updating to a different libc.") +#pragma message( \ + "Warning: Falling back to non-secure getenv for environmental lookups! Consider" \ + " updating to a different libc.") return loader_getenv(name, inst); #endif } @@ -260,7 +259,7 @@ static inline char *loader_getenv(const char *name, const struct loader_instance } static inline char *loader_secure_getenv(const char *name, const struct loader_instance *inst) { - // No secure version for Winddows as far as I know + // No secure version for Windows as far as I know return loader_getenv(name, inst); } @@ -291,7 +290,7 @@ static inline void loader_free_getenv(char *val, const struct loader_instance *i void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t msg_code, const char *format, ...) { char msg[512]; char cmd_line_msg[512]; - uint16_t cmd_line_size = sizeof(cmd_line_msg); + size_t cmd_line_size = sizeof(cmd_line_msg); va_list ap; int ret; @@ -312,6 +311,8 @@ void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t ms } cmd_line_msg[0] = '\0'; + cmd_line_size -= 1; + size_t original_size = cmd_line_size; va_start(ap, format); if ((msg_type & LOADER_INFO_BIT) != 0) { @@ -319,7 +320,7 @@ void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t ms cmd_line_size -= 4; } if ((msg_type & LOADER_WARN_BIT) != 0) { - if (cmd_line_size != sizeof(cmd_line_msg)) { + if (cmd_line_size != original_size) { strncat(cmd_line_msg, " | ", cmd_line_size); cmd_line_size -= 3; } @@ -327,7 +328,7 @@ void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t ms cmd_line_size -= 7; } if ((msg_type & LOADER_PERF_BIT) != 0) { - if (cmd_line_size != sizeof(cmd_line_msg)) { + if (cmd_line_size != original_size) { strncat(cmd_line_msg, " | ", cmd_line_size); cmd_line_size -= 3; } @@ -335,7 +336,7 @@ void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t ms cmd_line_size -= 4; } if ((msg_type & LOADER_ERROR_BIT) != 0) { - if (cmd_line_size != sizeof(cmd_line_msg)) { + if (cmd_line_size != original_size) { strncat(cmd_line_msg, " | ", cmd_line_size); cmd_line_size -= 3; } @@ -343,23 +344,35 @@ void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t ms cmd_line_size -= 5; } if ((msg_type & LOADER_DEBUG_BIT) != 0) { - if (cmd_line_size != sizeof(cmd_line_msg)) { + if (cmd_line_size != original_size) { strncat(cmd_line_msg, " | ", cmd_line_size); cmd_line_size -= 3; } strncat(cmd_line_msg, "DEBUG", cmd_line_size); cmd_line_size -= 5; } - if (cmd_line_size != sizeof(cmd_line_msg)) { + if (cmd_line_size != original_size) { strncat(cmd_line_msg, ": ", cmd_line_size); cmd_line_size -= 2; } - strncat(cmd_line_msg, msg, cmd_line_size); + + if (0 < cmd_line_size) { + // If the message is too long, trim it down + if (strlen(msg) > cmd_line_size) { + msg[cmd_line_size - 1] = '\0'; + } + strncat(cmd_line_msg, msg, cmd_line_size); + } else { + // Shouldn't get here, but check to make sure if we've already overrun + // the string boundary + assert(false); + } #if defined(WIN32) OutputDebugString(cmd_line_msg); OutputDebugString("\n"); #endif + fputs(cmd_line_msg, stderr); fputc('\n', stderr); } @@ -436,30 +449,28 @@ VkResult loaderGetRegistryFiles(const struct loader_instance *inst, char *locati *reg_data = loader_instance_heap_alloc(inst, total_size, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (NULL == *reg_data) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderGetRegistryFiles: Failed to allocate " - "space for registry data for key %s", - name); + "loaderGetRegistryFiles: Failed to allocate space for registry data for key %s", name); result = VK_ERROR_OUT_OF_HOST_MEMORY; goto out; } *reg_data[0] = '\0'; } else if (strlen(*reg_data) + name_size + 1 > total_size) { - *reg_data = loader_instance_heap_realloc(inst, *reg_data, total_size, total_size * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == *reg_data) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loaderGetRegistryFiles: Failed to reallocate " - "space for registry value of size %d for key %s", - total_size * 2, name); + void *new_ptr = loader_instance_heap_realloc(inst, *reg_data, total_size, total_size * 2, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (NULL == new_ptr) { + loader_log( + inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "loaderGetRegistryFiles: Failed to reallocate space for registry value of size %d for key %s", + total_size * 2, name); result = VK_ERROR_OUT_OF_HOST_MEMORY; goto out; } + *reg_data = new_ptr; total_size *= 2; } - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, - "Located json file \"%s\" from registry \"%s\\%s\"", name, - hive == DEFAULT_VK_REGISTRY_HIVE ? DEFAULT_VK_REGISTRY_HIVE_STR : SECONDARY_VK_REGISTRY_HIVE_STR, - location); + loader_log( + inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Located json file \"%s\" from registry \"%s\\%s\"", name, + hive == DEFAULT_VK_REGISTRY_HIVE ? DEFAULT_VK_REGISTRY_HIVE_STR : SECONDARY_VK_REGISTRY_HIVE_STR, location); if (strlen(*reg_data) == 0) { (void)snprintf(*reg_data, name_size + 1, "%s", name); } else { @@ -616,14 +627,13 @@ static struct loader_layer_properties *loader_get_next_layer_property(const stru // Ensure enough room to add an entry if ((layer_list->count + 1) * sizeof(struct loader_layer_properties) > layer_list->capacity) { - layer_list->list = loader_instance_heap_realloc(inst, layer_list->list, layer_list->capacity, layer_list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (layer_list->list == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_next_layer_property: realloc failed for " - "layer list"); + void *new_ptr = loader_instance_heap_realloc(inst, layer_list->list, layer_list->capacity, layer_list->capacity * 2, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (NULL == new_ptr) { + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_next_layer_property: realloc failed for layer list"); return NULL; } + layer_list->list = new_ptr; layer_list->capacity *= 2; } @@ -638,6 +648,10 @@ void loader_delete_layer_properties(const struct loader_instance *inst, struct l if (!layer_list) return; for (i = 0; i < layer_list->count; i++) { + if (NULL != layer_list->list[i].component_layer_names) { + loader_instance_heap_free(inst, layer_list->list[i].component_layer_names); + layer_list->list[i].component_layer_names = NULL; + } loader_destroy_generic_list(inst, (struct loader_generic_list *)&layer_list->list[i].instance_extension_list); dev_ext_list = &layer_list->list[i].device_extension_list; if (dev_ext_list->capacity > 0 && NULL != dev_ext_list->list && dev_ext_list->list->entrypoint_count > 0) { @@ -702,8 +716,8 @@ static VkResult loader_add_instance_extensions(const struct loader_instance *ins bool ext_unsupported = wsi_unsupported_instance_extension(&ext_props[i]); if (!ext_unsupported) { - (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_MAJOR(ext_props[i].specVersion), - VK_MINOR(ext_props[i].specVersion), VK_PATCH(ext_props[i].specVersion)); + (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_VERSION_MAJOR(ext_props[i].specVersion), + VK_VERSION_MINOR(ext_props[i].specVersion), VK_VERSION_PATCH(ext_props[i].specVersion)); loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Instance Extension: %s (%s) version %s", ext_props[i].extensionName, lib_name, spec_version); @@ -737,9 +751,8 @@ static VkResult loader_init_device_extensions(const struct loader_instance *inst for (i = 0; i < count; i++) { char spec_version[64]; - - (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_MAJOR(ext_props[i].specVersion), - VK_MINOR(ext_props[i].specVersion), VK_PATCH(ext_props[i].specVersion)); + (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_VERSION_MAJOR(ext_props[i].specVersion), + VK_VERSION_MINOR(ext_props[i].specVersion), VK_VERSION_PATCH(ext_props[i].specVersion)); loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Device Extension: %s (%s) version %s", ext_props[i].extensionName, phys_dev_term->this_icd_term->scanned_icd->lib_name, spec_version); res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]); @@ -772,9 +785,8 @@ VkResult loader_add_device_extensions(const struct loader_instance *inst, } for (i = 0; i < count; i++) { char spec_version[64]; - - (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_MAJOR(ext_props[i].specVersion), - VK_MINOR(ext_props[i].specVersion), VK_PATCH(ext_props[i].specVersion)); + (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_VERSION_MAJOR(ext_props[i].specVersion), + VK_VERSION_MINOR(ext_props[i].specVersion), VK_VERSION_PATCH(ext_props[i].specVersion)); loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Device Extension: %s (%s) version %s", ext_props[i].extensionName, lib_name, spec_version); res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]); @@ -840,15 +852,15 @@ VkResult loader_add_to_ext_list(const struct loader_instance *inst, struct loade // add to list at end // check for enough capacity if (ext_list->count * sizeof(VkExtensionProperties) >= ext_list->capacity) { - ext_list->list = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - - if (ext_list->list == NULL) { + void *new_ptr = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (new_ptr == NULL) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_to_ext_list: Failed to reallocate " "space for extension list"); return VK_ERROR_OUT_OF_HOST_MEMORY; } + ext_list->list = new_ptr; // double capacity ext_list->capacity *= 2; @@ -882,76 +894,115 @@ VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst, struct l // add to list at end // check for enough capacity if (idx * sizeof(struct loader_dev_ext_props) >= ext_list->capacity) { - ext_list->list = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + void *new_ptr = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (ext_list->list == NULL) { + if (NULL == new_ptr) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_to_dev_ext_list: Failed to reallocate " - "space for device extension list"); + "loader_add_to_dev_ext_list: Failed to reallocate space for device extension list"); return VK_ERROR_OUT_OF_HOST_MEMORY; } + ext_list->list = new_ptr; // double capacity ext_list->capacity *= 2; } - memcpy(&ext_list->list[idx].props, props, sizeof(struct loader_dev_ext_props)); + memcpy(&ext_list->list[idx].props, props, sizeof(*props)); ext_list->list[idx].entrypoint_count = entry_count; - ext_list->list[idx].entrypoints = - loader_instance_heap_alloc(inst, sizeof(char *) * entry_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (ext_list->list[idx].entrypoints == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_to_dev_ext_list: Failed to allocate space " - "for device extension entrypoint list in list %d", - idx); - ext_list->list[idx].entrypoint_count = 0; - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - for (uint32_t i = 0; i < entry_count; i++) { - ext_list->list[idx].entrypoints[i] = - loader_instance_heap_alloc(inst, strlen(entrys[i]) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (ext_list->list[idx].entrypoints[i] == NULL) { - for (uint32_t j = 0; j < i; j++) { - loader_instance_heap_free(inst, ext_list->list[idx].entrypoints[j]); - } - loader_instance_heap_free(inst, ext_list->list[idx].entrypoints); - ext_list->list[idx].entrypoint_count = 0; - ext_list->list[idx].entrypoints = NULL; + if (entry_count == 0) { + ext_list->list[idx].entrypoints = NULL; + } else { + ext_list->list[idx].entrypoints = + loader_instance_heap_alloc(inst, sizeof(char *) * entry_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (ext_list->list[idx].entrypoints == NULL) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_to_dev_ext_list: Failed to allocate space " - "for device extension entrypoint %d name", - i); + "for device extension entrypoint list in list %d", + idx); + ext_list->list[idx].entrypoint_count = 0; return VK_ERROR_OUT_OF_HOST_MEMORY; } - strcpy(ext_list->list[idx].entrypoints[i], entrys[i]); + for (uint32_t i = 0; i < entry_count; i++) { + ext_list->list[idx].entrypoints[i] = + loader_instance_heap_alloc(inst, strlen(entrys[i]) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (ext_list->list[idx].entrypoints[i] == NULL) { + for (uint32_t j = 0; j < i; j++) { + loader_instance_heap_free(inst, ext_list->list[idx].entrypoints[j]); + } + loader_instance_heap_free(inst, ext_list->list[idx].entrypoints); + ext_list->list[idx].entrypoint_count = 0; + ext_list->list[idx].entrypoints = NULL; + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "loader_add_to_dev_ext_list: Failed to allocate space " + "for device extension entrypoint %d name", + i); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + strcpy(ext_list->list[idx].entrypoints[i], entrys[i]); + } } ext_list->count++; return VK_SUCCESS; } +// Prototype of loader_add_meta_layer function since we use it in the loader_add_implicit_layer, but can also +// call loader_add_implicit_layer from loader_add_meta_layer. +bool loader_add_meta_layer(const struct loader_instance *inst, const struct loader_layer_properties *prop, + struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list, + const struct loader_layer_list *source_list); + +// Search the given layer list for a list matching the given VkLayerProperties +bool has_vk_layer_property(const VkLayerProperties *vk_layer_prop, const struct loader_layer_list *list) { + for (uint32_t i = 0; i < list->count; i++) { + if (strcmp(vk_layer_prop->layerName, list->list[i].info.layerName) == 0) return true; + } + return false; +} + +// Search the given layer list for a layer matching the given name +bool has_layer_name(const char *name, const struct loader_layer_list *list) { + for (uint32_t i = 0; i < list->count; i++) { + if (strcmp(name, list->list[i].info.layerName) == 0) return true; + } + return false; +} + // Search the given search_list for any layers in the props list. Add these to the // output layer_list. Don't add duplicates to the output layer_list. static VkResult loader_add_layer_names_to_list(const struct loader_instance *inst, struct loader_layer_list *output_list, - uint32_t name_count, const char *const *names, - const struct loader_layer_list *search_list) { + struct loader_layer_list *expanded_output_list, uint32_t name_count, + const char *const *names, const struct loader_layer_list *source_list) { struct loader_layer_properties *layer_prop; VkResult err = VK_SUCCESS; for (uint32_t i = 0; i < name_count; i++) { - const char *search_target = names[i]; - layer_prop = loader_get_layer_property(search_target, search_list); - if (!layer_prop) { + const char *source_name = names[i]; + layer_prop = loader_get_layer_property(source_name, source_list); + if (NULL == layer_prop) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_layer_names_to_list: Unable to find layer" " %s", - search_target); + source_name); err = VK_ERROR_LAYER_NOT_PRESENT; continue; } - err = loader_add_to_layer_list(inst, output_list, 1, layer_prop); + // If not a meta-layer, simply add it. + if (0 == (layer_prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER)) { + if (!has_vk_layer_property(&layer_prop->info, output_list)) { + loader_add_to_layer_list(inst, output_list, 1, layer_prop); + } + if (!has_vk_layer_property(&layer_prop->info, expanded_output_list)) { + loader_add_to_layer_list(inst, expanded_output_list, 1, layer_prop); + } + } else { + if (!has_vk_layer_property(&layer_prop->info, output_list) || + !has_vk_layer_property(&layer_prop->info, expanded_output_list)) { + loader_add_meta_layer(inst, layer_prop, output_list, expanded_output_list, source_list); + } + } } return err; @@ -980,22 +1031,6 @@ void loader_destroy_layer_list(const struct loader_instance *inst, struct loader layer_list->capacity = 0; } -// Search the given layer list for a list matching the given VkLayerProperties -bool has_vk_layer_property(const VkLayerProperties *vk_layer_prop, const struct loader_layer_list *list) { - for (uint32_t i = 0; i < list->count; i++) { - if (strcmp(vk_layer_prop->layerName, list->list[i].info.layerName) == 0) return true; - } - return false; -} - -// Search the given layer list for a layer matching the given name -bool has_layer_name(const char *name, const struct loader_layer_list *list) { - for (uint32_t i = 0; i < list->count; i++) { - if (strcmp(name, list->list[i].info.layerName) == 0) return true; - } - return false; -} - // Append non-duplicate layer properties defined in prop_list to the given layer_info list VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loader_layer_list *list, uint32_t prop_list_count, const struct loader_layer_properties *props) { @@ -1011,24 +1046,23 @@ VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loa for (i = 0; i < prop_list_count; i++) { layer = (struct loader_layer_properties *)&props[i]; - // look for duplicates + // Look for duplicates, and skip if (has_vk_layer_property(&layer->info, list)) { continue; } - // add to list at end - // check for enough capacity - if (list->count * sizeof(struct loader_layer_properties) >= list->capacity) { - list->list = loader_instance_heap_realloc(inst, list->list, list->capacity, list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == list->list) { + // Check for enough capacity + if (((list->count + 1) * sizeof(struct loader_layer_properties)) >= list->capacity) { + size_t new_capacity = list->capacity * 2; + void *new_ptr = + loader_instance_heap_realloc(inst, list->list, list->capacity, new_capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (NULL == new_ptr) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_to_layer_list: Realloc failed for " - "when attempting to add new layer"); + "loader_add_to_layer_list: Realloc failed for when attempting to add new layer"); return VK_ERROR_OUT_OF_HOST_MEMORY; } - // double capacity - list->capacity *= 2; + list->list = new_ptr; + list->capacity = new_capacity; } memcpy(&list->list[list->count], layer, sizeof(struct loader_layer_properties)); @@ -1038,26 +1072,118 @@ VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loa return VK_SUCCESS; } -// Search the search_list for any layer with a name that matches the given name and a type -// that matches the given type. Add all matching layers to the found_list. -// Do not add if found loader_layer_properties is already on the found_list. -void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type type, - const struct loader_layer_list *search_list, struct loader_layer_list *found_list) { +// Check the individual implicit layer for the enable/disable environment variable settings. Only add it after +// every check has passed indicating it should be used. +static void loader_add_implicit_layer(const struct loader_instance *inst, const struct loader_layer_properties *prop, + struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list, + const struct loader_layer_list *source_list) { + bool enable = false; + char *env_value = NULL; + + // if no enable_environment variable is specified, this implicit layer + // should always be enabled. Otherwise check if the variable is set + if (prop->enable_env_var.name[0] == 0) { + enable = true; + } else { + env_value = loader_secure_getenv(prop->enable_env_var.name, inst); + if (env_value && !strcmp(prop->enable_env_var.value, env_value)) enable = true; + loader_free_getenv(env_value, inst); + } + + // disable_environment has priority, i.e. if both enable and disable + // environment variables are set, the layer is disabled. Implicit + // layers are required to have a disable_environment variables + env_value = loader_secure_getenv(prop->disable_env_var.name, inst); + if (env_value) { + enable = false; + } + loader_free_getenv(env_value, inst); + + if (enable) { + // If not a meta-layer, simply add it. + if (0 == (prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER)) { + if (!has_vk_layer_property(&prop->info, target_list)) { + loader_add_to_layer_list(inst, target_list, 1, prop); + } + if (NULL != expanded_target_list && !has_vk_layer_property(&prop->info, expanded_target_list)) { + loader_add_to_layer_list(inst, expanded_target_list, 1, prop); + } + } else { + if (!has_vk_layer_property(&prop->info, target_list) || + (NULL != expanded_target_list && !has_vk_layer_property(&prop->info, expanded_target_list))) { + loader_add_meta_layer(inst, prop, target_list, expanded_target_list, source_list); + } + } + } +} + +// Add the component layers of a meta-layer to the active list of layers +bool loader_add_meta_layer(const struct loader_instance *inst, const struct loader_layer_properties *prop, + struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list, + const struct loader_layer_list *source_list) { + bool found = true; + + // We need to add all the individual component layers + for (uint32_t comp_layer = 0; comp_layer < prop->num_component_layers; comp_layer++) { + bool found_comp = false; + const struct loader_layer_properties *search_prop = + loader_get_layer_property(prop->component_layer_names[comp_layer], source_list); + if (search_prop != NULL) { + found_comp = true; + + // If the component layer is itself an implicit layer, we need to do the implicit layer enable + // checks + if (0 == (search_prop->type_flags & VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER)) { + loader_add_implicit_layer(inst, search_prop, target_list, expanded_target_list, source_list); + } else { + // Otherwise, just make sure it hasn't already been added to either list before we add it + if (!has_vk_layer_property(&search_prop->info, target_list)) { + loader_add_to_layer_list(inst, target_list, 1, search_prop); + } + if (NULL != expanded_target_list && !has_vk_layer_property(&search_prop->info, expanded_target_list)) { + loader_add_to_layer_list(inst, expanded_target_list, 1, search_prop); + } + } + } + if (!found_comp) { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "loader_add_meta_layer: Failed to find layer name %s component layer " + "%s to activate", + search_prop->info.layerName, prop->component_layer_names[comp_layer]); + found = false; + } + } + return found; +} + +// Search the source_list for any layer with a name that matches the given name and a type +// that matches the given type. Add all matching layers to the target_list. +// Do not add if found loader_layer_properties is already on the target_list. +void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type_flags type_flags, + const struct loader_layer_list *source_list, struct loader_layer_list *target_list, + struct loader_layer_list *expanded_target_list) { bool found = false; - for (uint32_t i = 0; i < search_list->count; i++) { - struct loader_layer_properties *layer_prop = &search_list->list[i]; - if (0 == strcmp(layer_prop->info.layerName, name) && (layer_prop->type & type)) { - // Found a layer with the same name, add to found_list - if (VK_SUCCESS == loader_add_to_layer_list(inst, found_list, 1, layer_prop)) { - found = true; + for (uint32_t i = 0; i < source_list->count; i++) { + struct loader_layer_properties *source_prop = &source_list->list[i]; + if (0 == strcmp(source_prop->info.layerName, name) && (source_prop->type_flags & type_flags) == type_flags) { + // If not a meta-layer, simply add it. + if (0 == (source_prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER)) { + if (!has_vk_layer_property(&source_prop->info, target_list) && + VK_SUCCESS == loader_add_to_layer_list(inst, target_list, 1, source_prop)) { + found = true; + } + if (!has_vk_layer_property(&source_prop->info, expanded_target_list) && + VK_SUCCESS == loader_add_to_layer_list(inst, expanded_target_list, 1, source_prop)) { + found = true; + } + } else { + found = loader_add_meta_layer(inst, source_prop, target_list, expanded_target_list, source_list); } } } if (!found) { loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, - "loader_find_layer_name_add_list: Failed to find layer name " - "%s to activate", - name); + "loader_find_layer_name_add_list: Failed to find layer name %s to activate", name); } } @@ -1183,8 +1309,11 @@ void loader_destroy_logical_device(const struct loader_instance *inst, struct lo if (pAllocator) { dev->alloc_callbacks = *pAllocator; } - if (NULL != dev->activated_layer_list.list) { - loader_deactivate_layers(inst, dev, &dev->activated_layer_list); + if (NULL != dev->expanded_activated_layer_list.list) { + loader_deactivate_layers(inst, dev, &dev->expanded_activated_layer_list); + } + if (NULL != dev->app_activated_layer_list.list) { + loader_destroy_layer_list(inst, dev, &dev->app_activated_layer_list); } loader_device_heap_free(dev, dev); } @@ -1321,15 +1450,16 @@ bool loader_get_icd_interface_version(PFN_vkNegotiateLoaderICDInterfaceVersion f } void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) { - if (icd_tramp_list->capacity == 0) return; - for (uint32_t i = 0; i < icd_tramp_list->count; i++) { - loader_platform_close_library(icd_tramp_list->scanned_list[i].handle); - loader_instance_heap_free(inst, icd_tramp_list->scanned_list[i].lib_name); + if (0 != icd_tramp_list->capacity) { + for (uint32_t i = 0; i < icd_tramp_list->count; i++) { + loader_platform_close_library(icd_tramp_list->scanned_list[i].handle); + loader_instance_heap_free(inst, icd_tramp_list->scanned_list[i].lib_name); + } + loader_instance_heap_free(inst, icd_tramp_list->scanned_list); + icd_tramp_list->capacity = 0; + icd_tramp_list->count = 0; + icd_tramp_list->scanned_list = NULL; } - loader_instance_heap_free(inst, icd_tramp_list->scanned_list); - icd_tramp_list->capacity = 0; - icd_tramp_list->count = 0; - icd_tramp_list->scanned_list = NULL; } static VkResult loader_scanned_icd_init(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) { @@ -1444,17 +1574,16 @@ static VkResult loader_scanned_icd_add(const struct loader_instance *inst, struc // check for enough capacity if ((icd_tramp_list->count * sizeof(struct loader_scanned_icd)) >= icd_tramp_list->capacity) { - icd_tramp_list->scanned_list = - loader_instance_heap_realloc(inst, icd_tramp_list->scanned_list, icd_tramp_list->capacity, icd_tramp_list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (NULL == icd_tramp_list->scanned_list) { + void *new_ptr = loader_instance_heap_realloc(inst, icd_tramp_list->scanned_list, icd_tramp_list->capacity, + icd_tramp_list->capacity * 2, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (NULL == new_ptr) { res = VK_ERROR_OUT_OF_HOST_MEMORY; loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_scanned_icd_add: Realloc failed on icd library" - " list for ICD %s", - filename); + "loader_scanned_icd_add: Realloc failed on icd library list for ICD %s", filename); goto out; } + icd_tramp_list->scanned_list = new_ptr; + // double capacity icd_tramp_list->capacity *= 2; } @@ -1734,16 +1863,14 @@ VkResult loader_copy_layer_properties(const struct loader_instance *inst, struct } static bool loader_find_layer_name_list(const char *name, const struct loader_layer_list *layer_list) { - if (!layer_list) return false; - for (uint32_t j = 0; j < layer_list->count; j++) - if (!strcmp(name, layer_list->list[j].info.layerName)) return true; - return false; -} - -static bool loader_find_layer_name(const char *name, uint32_t layer_count, const char **layer_list) { - if (!layer_list) return false; - for (uint32_t j = 0; j < layer_count; j++) - if (!strcmp(name, layer_list[j])) return true; + if (NULL == layer_list) { + return false; + } + for (uint32_t j = 0; j < layer_list->count; j++) { + if (!strcmp(name, layer_list->list[j].info.layerName)) { + return true; + } + } return false; } @@ -1754,118 +1881,176 @@ bool loader_find_layer_name_array(const char *name, uint32_t layer_count, const return false; } -// Searches through an array of layer names (ppp_layer_names) looking for a -// layer key_name. -// If not found then simply returns updating nothing. -// Otherwise, it uses expand_count, expand_names adding them to layer names. -// Any duplicate (pre-existing) expand_names in layer names are removed. -// Order is otherwise preserved, with the layer key_name being replaced by the -// expand_names. -// @param inst -// @param layer_count -// @param ppp_layer_names -VkResult loader_expand_layer_names(struct loader_instance *inst, const char *key_name, uint32_t expand_count, - const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE], uint32_t *layer_count, - char const *const **ppp_layer_names) { - char const *const *pp_src_layers = *ppp_layer_names; +const char *std_validation_str = "VK_LAYER_LUNARG_standard_validation"; - if (!loader_find_layer_name(key_name, *layer_count, (char const **)pp_src_layers)) { - inst->activated_layers_are_std_val = false; - return VK_SUCCESS; // didn't find the key_name in the list. +// Adds the legacy VK_LAYER_LUNARG_standard_validation as a meta-layer if it +// fails to find it in the list already. This is usually an indication that a +// newer loader is being used with an older layer set. +static bool loader_add_legacy_std_val_layer(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list) { + uint32_t i; + bool success = true; + struct loader_layer_properties *props = loader_get_next_layer_property(inst, layer_instance_list); + const char std_validation_names[6][VK_MAX_EXTENSION_NAME_SIZE] = { + "VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation", + "VK_LAYER_LUNARG_object_tracker", "VK_LAYER_LUNARG_core_validation", + "VK_LAYER_GOOGLE_unique_objects"}; + uint32_t layer_count = sizeof(std_validation_names) / sizeof(std_validation_names[0]); + + loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, + "Adding VK_LAYER_LUNARG_standard_validation using the loader legacy path. This is" + " not an error."); + + if (NULL == props) { + goto out; } - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Found meta layer %s, replacing with actual layer group", key_name); - - inst->activated_layers_are_std_val = true; - char const **pp_dst_layers = loader_instance_heap_alloc(inst, (expand_count + *layer_count - 1) * sizeof(char const *), - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); - if (NULL == pp_dst_layers) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_expand_layer_names:: Failed to allocate space for " - "std_validation layer names in pp_dst_layers."); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - // copy layers from src to dst, stripping key_name and anything in - // expand_names. - uint32_t src_index, dst_index = 0; - for (src_index = 0; src_index < *layer_count; src_index++) { - if (loader_find_layer_name_array(pp_src_layers[src_index], expand_count, expand_names)) { - continue; - } - - if (!strcmp(pp_src_layers[src_index], key_name)) { - // insert all expand_names in place of key_name - uint32_t expand_index; - for (expand_index = 0; expand_index < expand_count; expand_index++) { - pp_dst_layers[dst_index++] = expand_names[expand_index]; - } - continue; - } - - pp_dst_layers[dst_index++] = pp_src_layers[src_index]; - } - - *ppp_layer_names = pp_dst_layers; - *layer_count = dst_index; - - return VK_SUCCESS; -} - -void loader_delete_shadow_inst_layer_names(const struct loader_instance *inst, const VkInstanceCreateInfo *orig, - VkInstanceCreateInfo *ours) { - // Free the layer names array iff we had to reallocate it - if (orig->ppEnabledLayerNames != ours->ppEnabledLayerNames) { - loader_instance_heap_free(inst, (void *)ours->ppEnabledLayerNames); - } -} - -void loader_init_std_validation_props(struct loader_layer_properties *props) { memset(props, 0, sizeof(struct loader_layer_properties)); - props->type = VK_LAYER_TYPE_META_EXPLICT; + props->type_flags = VK_LAYER_TYPE_FLAG_INSTANCE_LAYER | VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER | VK_LAYER_TYPE_FLAG_META_LAYER; strncpy(props->info.description, "LunarG Standard Validation Layer", sizeof(props->info.description)); props->info.implementationVersion = 1; strncpy(props->info.layerName, std_validation_str, sizeof(props->info.layerName)); - // TODO what about specVersion? for now insert loader's built version props->info.specVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION); -} -// Searches through the existing instance layer lists looking for -// the set of required layer names. If found then it adds a meta property to the -// layer list. -// Assumes the required layers are the same for both instance and device lists. -// @param inst -// @param layer_count number of layers in layer_names -// @param layer_names array of required layer names -// @param layer_instance_list -static void loader_add_layer_property_meta(const struct loader_instance *inst, uint32_t layer_count, - const char layer_names[][VK_MAX_EXTENSION_NAME_SIZE], - struct loader_layer_list *layer_instance_list) { - uint32_t i; - bool found; - struct loader_layer_list *layer_list; - - if (0 == layer_count || (!layer_instance_list)) return; - if (layer_instance_list && (layer_count > layer_instance_list->count)) return; - - layer_list = layer_instance_list; - - found = true; - if (layer_list == NULL) return; + props->component_layer_names = + loader_instance_heap_alloc(inst, sizeof(char[MAX_STRING_SIZE]) * layer_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (NULL == props->component_layer_names) { + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "Failed to allocate space for legacy VK_LAYER_LUNARG_standard_validation" + " meta-layer component_layers information."); + success = false; + goto out; + } for (i = 0; i < layer_count; i++) { - if (loader_find_layer_name_list(layer_names[i], layer_list)) continue; - found = false; - break; + strncpy(props->component_layer_names[i], std_validation_names[i], MAX_STRING_SIZE - 1); + props->component_layer_names[i][MAX_STRING_SIZE - 1] = '\0'; } - struct loader_layer_properties *props; - if (found) { - props = loader_get_next_layer_property(inst, layer_list); - if (NULL == props) { - // Error already triggered in loader_get_next_layer_property. - return; +out: + + if (!success && NULL != props && NULL != props->component_layer_names) { + loader_instance_heap_free(inst, props->component_layer_names); + props->component_layer_names = NULL; + } + + return success; +} + +// Verify that all component layers in a meta-layer are valid. +static bool verify_meta_layer_comp_layers(const struct loader_instance *inst, struct loader_layer_properties *prop, + struct loader_layer_list *instance_layers) { + bool success = true; + const uint32_t expected_major = VK_VERSION_MAJOR(prop->info.specVersion); + const uint32_t expected_minor = VK_VERSION_MINOR(prop->info.specVersion); + + for (uint32_t comp_layer = 0; comp_layer < prop->num_component_layers; comp_layer++) { + if (!loader_find_layer_name_list(prop->component_layer_names[comp_layer], instance_layers)) { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "Meta-layer %s can't find component layer %s at index %d." + " Skipping this layer.", + prop->info.layerName, prop->component_layer_names[comp_layer], comp_layer); + success = false; + break; + } else { + struct loader_layer_properties *comp_prop = + loader_get_layer_property(prop->component_layer_names[comp_layer], instance_layers); + if (comp_prop == NULL) { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "Meta-layer %s can't find property for component layer %s at index %d." + " Skipping this layer.", + prop->info.layerName, prop->component_layer_names[comp_layer], comp_layer); + success = false; + break; + } + + // Check the version of each layer, they need to at least match MAJOR and MINOR + uint32_t cur_major = VK_VERSION_MAJOR(comp_prop->info.specVersion); + uint32_t cur_minor = VK_VERSION_MINOR(comp_prop->info.specVersion); + if (cur_major != expected_major || cur_minor != expected_minor) { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "Meta-layer uses API version %d.%d, but component layer %d uses API " + "version %d.%d. Skipping this layer.", + expected_major, expected_minor, comp_layer, cur_major, cur_minor); + success = false; + break; + } + + // Make sure the layer isn't using it's own name + if (!strcmp(prop->info.layerName, prop->component_layer_names[comp_layer])) { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "Meta-layer %s lists itself in its component layer list at index %d." + " Skipping this layer.", + prop->info.layerName, comp_layer); + success = false; + break; + } + if (comp_prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER) { + loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "verify_meta_layer_comp_layers: Adding meta-layer %s which also contains meta-layer %s", + prop->info.layerName, comp_prop->info.layerName); + + // Make sure if the layer is using a meta-layer in its component list that we also verify that. + if (!verify_meta_layer_comp_layers(inst, comp_prop, instance_layers)) { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "Meta-layer %s component layer %s can not find all component layers." + " Skipping this layer.", + prop->info.layerName, prop->component_layer_names[comp_layer]); + success = false; + break; + } + } + + // Add any instance and device extensions from component layers to this layer + // list, so that anyone querying extensions will only need to look at the meta-layer + for (uint32_t ext = 0; ext < comp_prop->instance_extension_list.count; ext++) { + loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Meta-layer %s component layer %s adding instance extension %s", + prop->info.layerName, prop->component_layer_names[comp_layer], + comp_prop->instance_extension_list.list[ext].extensionName); + if (!has_vk_extension_property(&comp_prop->instance_extension_list.list[ext], &prop->instance_extension_list)) { + loader_add_to_ext_list(inst, &prop->instance_extension_list, 1, &comp_prop->instance_extension_list.list[ext]); + } + } + + for (uint32_t ext = 0; ext < comp_prop->device_extension_list.count; ext++) { + loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Meta-layer %s component layer %s adding device extension %s", + prop->info.layerName, prop->component_layer_names[comp_layer], + comp_prop->device_extension_list.list[ext].props.extensionName); + if (!has_vk_dev_ext_property(&comp_prop->device_extension_list.list[ext].props, &prop->device_extension_list)) { + loader_add_to_dev_ext_list(inst, &prop->device_extension_list, + &comp_prop->device_extension_list.list[ext].props, 0, NULL); + } + } + } + } + if (success) { + loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Meta-layer %s all %d component layers appear to be valid.", + prop->info.layerName, prop->num_component_layers); + } + return success; +} + +// Verify that all meta-layers in a layer list are valid. +static void verify_all_meta_layers(const struct loader_instance *inst, struct loader_layer_list *instance_layers) { + for (int32_t i = 0; i < (int32_t)instance_layers->count; i++) { + struct loader_layer_properties *prop = &instance_layers->list[i]; + + // If this is a meta-layer, make sure it is valid + if ((prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER) && !verify_meta_layer_comp_layers(inst, prop, instance_layers)) { + loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, + "Removing meta-layer %s from instance layer list since it appears invalid.", prop->info.layerName); + + // Delete the component layers + loader_instance_heap_free(inst, prop->component_layer_names); + + // Remove the current invalid meta-layer from the layer list. Use memmove since we are + // overlapping the source and destination addresses. + memmove(&instance_layers->list[i], &instance_layers->list[i + 1], + sizeof(struct loader_layer_properties) * (instance_layers->count - 1 - i)); + + // Decrement the count (because we now have one less) and decrement the loop index since we need to + // re-check this index. + instance_layers->count--; + i--; } - loader_init_std_validation_props(props); } } @@ -1877,23 +2062,26 @@ typedef struct { uint16_t patch; } layer_json_version; -static void loader_read_json_layer(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list, - cJSON *layer_node, layer_json_version version, cJSON *item, cJSON *disable_environment, - bool is_implicit, char *filename) { +static VkResult loader_read_json_layer(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list, + cJSON *layer_node, layer_json_version version, cJSON *item, cJSON *disable_environment, + bool is_implicit, char *filename) { char *temp; - char *name, *type, *library_path, *api_version; + char *name, *type, *library_path_str, *api_version; char *implementation_version, *description; - cJSON *ext_item; + cJSON *ext_item, *library_path, *component_layers; VkExtensionProperties ext_prop; + VkResult result = VK_ERROR_INITIALIZATION_FAILED; + struct loader_layer_properties *props = NULL; + int i, j; // The following are required in the "layer" object: // (required) "name" // (required) "type" -// (required) “library_path” -// (required) “api_version” -// (required) “implementation_version” -// (required) “description” -// (required for implicit layers) “disable_environment” +// (required) "library_path" +// (required) "api_version" +// (required) "implementation_version" +// (required) "description" +// (required for implicit layers) "disable_environment" #define GET_JSON_OBJECT(node, var) \ { \ var = cJSON_GetObjectItem(node, #var); \ @@ -1903,7 +2091,7 @@ static void loader_read_json_layer(const struct loader_instance *inst, struct lo "Didn't find required layer object %s in manifest " \ "JSON file, skipping this layer", \ #var); \ - return; \ + goto out; \ } \ } #define GET_JSON_ITEM(node, var) \ @@ -1915,7 +2103,7 @@ static void loader_read_json_layer(const struct loader_instance *inst, struct lo "Didn't find required layer value %s in manifest JSON " \ "file, skipping this layer", \ #var); \ - return; \ + goto out; \ } \ temp = cJSON_Print(item); \ if (temp == NULL) { \ @@ -1924,7 +2112,8 @@ static void loader_read_json_layer(const struct loader_instance *inst, struct lo "Problem accessing layer value %s in manifest JSON " \ "file, skipping this layer", \ #var); \ - return; \ + result = VK_ERROR_OUT_OF_HOST_MEMORY; \ + goto out; \ } \ temp[strlen(temp) - 1] = '\0'; \ var = loader_stack_alloc(strlen(temp) + 1); \ @@ -1933,58 +2122,135 @@ static void loader_read_json_layer(const struct loader_instance *inst, struct lo } GET_JSON_ITEM(layer_node, name) GET_JSON_ITEM(layer_node, type) - GET_JSON_ITEM(layer_node, library_path) GET_JSON_ITEM(layer_node, api_version) GET_JSON_ITEM(layer_node, implementation_version) GET_JSON_ITEM(layer_node, description) + + // Add list entry + if (!strcmp(type, "DEVICE")) { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Device layers are deprecated skipping this layer"); + layer_node = layer_node->next; + goto out; + } + + // Allow either GLOBAL or INSTANCE type interchangeably to handle + // layers that must work with older loaders + if (!strcmp(type, "INSTANCE") || !strcmp(type, "GLOBAL")) { + if (layer_instance_list == NULL) { + layer_node = layer_node->next; + goto out; + } + props = loader_get_next_layer_property(inst, layer_instance_list); + if (NULL == props) { + // Error already triggered in loader_get_next_layer_property. + result = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + props->type_flags = VK_LAYER_TYPE_FLAG_INSTANCE_LAYER; + if (!is_implicit) { + props->type_flags |= VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER; + } + } else { + layer_node = layer_node->next; + goto out; + } + + // Library path no longer required unless component_layers is also not defined + library_path = cJSON_GetObjectItem(layer_node, "library_path"); + component_layers = cJSON_GetObjectItem(layer_node, "component_layers"); + if (NULL != library_path) { + if (NULL != component_layers) { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "Indicating meta-layer-specific component_layers, but also " + "defining layer library path. Both are not compatible, so " + "skipping this layer"); + goto out; + } + props->num_component_layers = 0; + props->component_layer_names = NULL; + + temp = cJSON_Print(library_path); + if (NULL == temp) { + layer_node = layer_node->next; + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "Problem accessing layer value library_path in manifest JSON " + "file, skipping this layer"); + result = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + temp[strlen(temp) - 1] = '\0'; + library_path_str = loader_stack_alloc(strlen(temp) + 1); + strcpy(library_path_str, &temp[1]); + cJSON_Free(temp); + + char *fullpath = props->lib_name; + char *rel_base; + if (NULL != library_path_str) { + if (loader_platform_is_path(library_path_str)) { + // A relative or absolute path + char *name_copy = loader_stack_alloc(strlen(filename) + 1); + strcpy(name_copy, filename); + rel_base = loader_platform_dirname(name_copy); + loader_expand_path(library_path_str, rel_base, MAX_STRING_SIZE, fullpath); + } else { + // A filename which is assumed in a system directory + loader_get_fullpath(library_path_str, DEFAULT_VK_LAYERS_PATH, MAX_STRING_SIZE, fullpath); + } + } + } else if (NULL != component_layers) { + if (version.major == 1 && (version.minor < 1 || version.patch < 1)) { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "Indicating meta-layer-specific component_layers, but using older " + "JSON file version."); + } + int count = cJSON_GetArraySize(component_layers); + props->num_component_layers = count; + + // Allocate buffer for layer names + props->component_layer_names = + loader_instance_heap_alloc(inst, sizeof(char[MAX_STRING_SIZE]) * count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (NULL == props->component_layer_names) { + result = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + + // Copy the component layers into the array + for (i = 0; i < count; i++) { + cJSON *comp_layer = cJSON_GetArrayItem(component_layers, i); + if (NULL != comp_layer) { + temp = cJSON_Print(comp_layer); + if (NULL == temp) { + result = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + temp[strlen(temp) - 1] = '\0'; + strncpy(props->component_layer_names[i], temp + 1, MAX_STRING_SIZE - 1); + props->component_layer_names[i][MAX_STRING_SIZE - 1] = '\0'; + cJSON_Free(temp); + } + } + + // This is now, officially, a meta-layer + props->type_flags |= VK_LAYER_TYPE_FLAG_META_LAYER; + loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Encountered meta-layer %s", name); + + // Make sure we set up other things so we head down the correct branches below + library_path_str = NULL; + } else { + loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, + "Layer missing both library_path and component_layers fields. One or the " + "other MUST be defined. Skipping this layer"); + goto out; + } + if (is_implicit) { GET_JSON_OBJECT(layer_node, disable_environment) } #undef GET_JSON_ITEM #undef GET_JSON_OBJECT - // Add list entry - struct loader_layer_properties *props = NULL; - if (!strcmp(type, "DEVICE")) { - loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Device layers are deprecated skipping this layer"); - layer_node = layer_node->next; - return; - } - // Allow either GLOBAL or INSTANCE type interchangeably to handle - // layers that must work with older loaders - if (!strcmp(type, "INSTANCE") || !strcmp(type, "GLOBAL")) { - if (layer_instance_list == NULL) { - layer_node = layer_node->next; - return; - } - props = loader_get_next_layer_property(inst, layer_instance_list); - if (NULL == props) { - // Error already triggered in loader_get_next_layer_property. - return; - } - props->type = (is_implicit) ? VK_LAYER_TYPE_INSTANCE_IMPLICIT : VK_LAYER_TYPE_INSTANCE_EXPLICIT; - } - - if (props == NULL) { - layer_node = layer_node->next; - return; - } - strncpy(props->info.layerName, name, sizeof(props->info.layerName)); props->info.layerName[sizeof(props->info.layerName) - 1] = '\0'; - - char *fullpath = props->lib_name; - char *rel_base; - if (loader_platform_is_path(library_path)) { - // A relative or absolute path - char *name_copy = loader_stack_alloc(strlen(filename) + 1); - strcpy(name_copy, filename); - rel_base = loader_platform_dirname(name_copy); - loader_expand_path(library_path, rel_base, MAX_STRING_SIZE, fullpath); - } else { - // A filename which is assumed in a system directory - loader_get_fullpath(library_path, DEFAULT_VK_LAYERS_PATH, MAX_STRING_SIZE, fullpath); - } props->info.specVersion = loader_make_version(api_version); props->info.implementationVersion = atoi(implementation_version); strncpy((char *)props->info.description, description, sizeof(props->info.description)); @@ -1995,7 +2261,7 @@ static void loader_read_json_layer(const struct loader_instance *inst, struct lo "Didn't find required layer child value disable_environment" "in manifest JSON file, skipping this layer"); layer_node = layer_node->next; - return; + goto out; } strncpy(props->disable_env_var.name, disable_environment->child->string, sizeof(props->disable_env_var.name)); props->disable_env_var.name[sizeof(props->disable_env_var.name) - 1] = '\0'; @@ -2020,6 +2286,9 @@ static void loader_read_json_layer(const struct loader_instance *inst, struct lo var = loader_stack_alloc(strlen(temp) + 1); \ strcpy(var, &temp[1]); \ cJSON_Free(temp); \ + } else { \ + result = VK_ERROR_OUT_OF_HOST_MEMORY; \ + goto out; \ } \ } \ } @@ -2031,8 +2300,6 @@ static void loader_read_json_layer(const struct loader_instance *inst, struct lo char *vkNegotiateLoaderLayerInterfaceVersion = NULL; char *spec_version = NULL; char **entry_array = NULL; - entrypoints = NULL; - int i, j; // Layer interface functions // vkGetInstanceProcAddr @@ -2146,7 +2413,8 @@ static void loader_read_json_layer(const struct loader_instance *inst, struct lo temp = cJSON_Print(ext_item); if (NULL == temp) { entry_array[j] = NULL; - continue; + result = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; } temp[strlen(temp) - 1] = '\0'; entry_array[j] = loader_stack_alloc(strlen(temp) + 1); @@ -2168,13 +2436,28 @@ static void loader_read_json_layer(const struct loader_instance *inst, struct lo props->enable_env_var.value[sizeof(props->enable_env_var.value) - 1] = '\0'; } } + + result = VK_SUCCESS; + +out: + #undef GET_JSON_ITEM #undef GET_JSON_OBJECT + + if (VK_SUCCESS != result && NULL != props) { + props->num_component_layers = 0; + if (NULL != props->component_layer_names) { + loader_instance_heap_free(inst, props->component_layer_names); + } + props->component_layer_names = NULL; + } + + return result; } static inline bool is_valid_layer_json_version(const layer_json_version *layer_json) { // Supported versions are: 1.0.0, 1.0.1, and 1.1.0. - if ((layer_json->major == 1 && layer_json->minor == 1 && layer_json->patch == 0) || + if ((layer_json->major == 1 && layer_json->minor == 1 && layer_json->patch < 2) || (layer_json->major == 1 && layer_json->minor == 0 && layer_json->patch < 2)) { return true; } @@ -2198,24 +2481,24 @@ static inline bool layer_json_supports_layers_tag(const layer_json_version *laye // layer_list has a new entry and initialized accordingly. // If the json input object does not have all the required fields no entry // is added to the list. -static void loader_add_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list, - cJSON *json, bool is_implicit, char *filename) { +static VkResult loader_add_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list, + cJSON *json, bool is_implicit, char *filename) { // The following Fields in layer manifest file that are required: - // - “file_format_version” + // - "file_format_version" // - If more than one "layer" object are used, then the "layers" array is // required - + VkResult result = VK_ERROR_INITIALIZATION_FAILED; cJSON *item, *layers_node, *layer_node; layer_json_version json_version = {0, 0, 0}; char *vers_tok; cJSON *disable_environment = NULL; item = cJSON_GetObjectItem(json, "file_format_version"); if (item == NULL) { - return; + goto out; } char *file_vers = cJSON_PrintUnformatted(item); if (NULL == file_vers) { - return; + goto out; } loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Found manifest file %s, version %s", filename, file_vers); // Get the major/minor/and patch as integers for easier comparison @@ -2235,7 +2518,7 @@ static void loader_add_layer_properties(const struct loader_instance *inst, stru if (!is_valid_layer_json_version(&json_version)) { loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_add_layer_properties: %s invalid layer " - " manifest file version %d.%d.%d. May cause errors.", + "manifest file version %d.%d.%d. May cause errors.", filename, json_version.major, json_version.minor, json_version.patch); } cJSON_Free(file_vers); @@ -2259,10 +2542,10 @@ static void loader_add_layer_properties(const struct loader_instance *inst, stru "\'layers\' array element %d object in manifest " "JSON file %s. Skipping this file", curLayer, filename); - return; + goto out; } - loader_read_json_layer(inst, layer_instance_list, layer_node, json_version, item, disable_environment, is_implicit, - filename); + result = loader_read_json_layer(inst, layer_instance_list, layer_node, json_version, item, disable_environment, + is_implicit, filename); } } else { // Otherwise, try to read in individual layers @@ -2272,7 +2555,7 @@ static void loader_add_layer_properties(const struct loader_instance *inst, stru "loader_add_layer_properties: Can not find \'layer\' " "object in manifest JSON file %s. Skipping this file.", filename); - return; + goto out; } // Loop through all "layer" objects in the file to get a count of them // first. @@ -2294,13 +2577,16 @@ static void loader_add_layer_properties(const struct loader_instance *inst, stru filename); } else { do { - loader_read_json_layer(inst, layer_instance_list, layer_node, json_version, item, disable_environment, is_implicit, - filename); + result = loader_read_json_layer(inst, layer_instance_list, layer_node, json_version, item, disable_environment, + is_implicit, filename); layer_node = layer_node->next; } while (layer_node != NULL); } } - return; + +out: + + return result; } // Find the Vulkan library manifest files. @@ -2321,7 +2607,7 @@ static void loader_add_layer_properties(const struct loader_instance *inst, stru // List has a pointer to string for each manifest filename. // When done using the list in out_files, pointers should be freed. // Location or override string lists can be either files or directories as -//follows: +// follows: // | location | override // -------------------------------- // Win ICD | files | files @@ -2329,9 +2615,9 @@ static void loader_add_layer_properties(const struct loader_instance *inst, stru // Linux ICD | dirs | files // Linux Layer| dirs | dirs static VkResult loader_get_manifest_files(const struct loader_instance *inst, const char *env_override, const char *source_override, - bool is_layer, bool warn_if_not_present, const char *location, const char *relative_location, - struct loader_manifest_files *out_files) { - const char * override = NULL; + bool is_layer, bool warn_if_not_present, const char *location, + const char *relative_location, struct loader_manifest_files *out_files) { + const char *override = NULL; char *override_getenv = NULL; char *loc, *orig_loc = NULL; char *reg = NULL; @@ -2386,13 +2672,11 @@ static VkResult loader_get_manifest_files(const struct loader_instance *inst, co #if !defined(_WIN32) const char *xdgconfdirs = loader_secure_getenv("XDG_CONFIG_DIRS", inst); const char *xdgdatadirs = loader_secure_getenv("XDG_DATA_DIRS", inst); - if (xdgconfdirs == NULL || xdgconfdirs[0] == '\0') - xdgconfdirs = FALLBACK_CONFIG_DIRS; - if (xdgdatadirs == NULL || xdgdatadirs[0] == '\0') - xdgdatadirs = FALLBACK_DATA_DIRS; + if (xdgconfdirs == NULL || xdgconfdirs[0] == '\0') xdgconfdirs = FALLBACK_CONFIG_DIRS; + if (xdgdatadirs == NULL || xdgdatadirs[0] == '\0') xdgdatadirs = FALLBACK_DATA_DIRS; const size_t rel_size = strlen(relative_location); // Leave space for trailing separators - loc_size += strlen(xdgconfdirs) + strlen(xdgdatadirs) + 2*rel_size + 2; + loc_size += strlen(xdgconfdirs) + strlen(xdgdatadirs) + 2 * rel_size + 2; for (const char *x = xdgconfdirs; *x; ++x) if (*x == PATH_SEPARATOR) loc_size += rel_size; for (const char *x = xdgdatadirs; *x; ++x) @@ -2573,19 +2857,25 @@ static VkResult loader_get_manifest_files(const struct loader_instance *inst, co if (out_files->count == 0) { out_files->filename_list = loader_instance_heap_alloc(inst, alloced_count * sizeof(char *), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + if (NULL == out_files->filename_list) { + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "loader_get_manifest_files: Failed to allocate space for manifest file name list"); + res = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } } else if (out_files->count == alloced_count) { - out_files->filename_list = + void *new_ptr = loader_instance_heap_realloc(inst, out_files->filename_list, alloced_count * sizeof(char *), alloced_count * sizeof(char *) * 2, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + if (NULL == new_ptr) { + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "loader_get_manifest_files: Failed to reallocate space for manifest file name list"); + res = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + out_files->filename_list = new_ptr; alloced_count *= 2; } - if (out_files->filename_list == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_get_manifest_files: Failed to allocate " - "space for manifest file name list"); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; - } out_files->filename_list[out_files->count] = loader_instance_heap_alloc(inst, strlen(name) + 1, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); if (out_files->filename_list[out_files->count] == NULL) { @@ -2754,6 +3044,7 @@ VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_t if (VK_SUCCESS != res || manifest_files.count == 0) { goto out; } + loader_platform_thread_lock_mutex(&loader_json_lock); lockedMutex = true; for (uint32_t i = 0; i < manifest_files.count; i++) { @@ -2762,18 +3053,24 @@ VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_t continue; } - res = loader_get_json(inst, file_str, &json); - if (NULL == json || res != VK_SUCCESS) { + VkResult temp_res = loader_get_json(inst, file_str, &json); + if (NULL == json || temp_res != VK_SUCCESS) { if (NULL != json) { cJSON_Delete(json); json = NULL; } - if (res == VK_ERROR_OUT_OF_HOST_MEMORY) { + // If we haven't already found an ICD, copy this result to + // the returned result. + if (num_good_icds == 0) { + res = temp_res; + } + if (temp_res == VK_ERROR_OUT_OF_HOST_MEMORY) { break; } else { continue; } } + res = temp_res; cJSON *item, *itemICD; item = cJSON_GetObjectItem(json, "file_format_version"); @@ -3012,14 +3309,35 @@ void loader_layer_scan(const struct loader_instance *inst, struct loader_layer_l continue; } - loader_add_layer_properties(inst, instance_layers, json, (implicit == 1), file_str); + VkResult local_res = loader_add_layer_properties(inst, instance_layers, json, (implicit == 1), file_str); cJSON_Delete(json); + + if (VK_SUCCESS != local_res) { + goto out; + } } } - // add a meta layer for validation if the validation layers are all present - loader_add_layer_property_meta(inst, sizeof(std_validation_names) / sizeof(std_validation_names[0]), std_validation_names, - instance_layers); + // See if "VK_LAYER_LUNARG_standard_validation" already in list. + bool found_std_val = false; + for (uint32_t i = 0; i < instance_layers->count; i++) { + struct loader_layer_properties *props = &instance_layers->list[i]; + if (strcmp(props->info.layerName, std_validation_str) == 0) { + found_std_val = true; + break; + } + } + + // If we didn't find the VK_LAYER_LUNARG_standard_validation meta-layer in + // the list, then we need to add it manually. This is likely because we're + // dealing with a new loader, but an old layer folder. + if (!found_std_val && !loader_add_legacy_std_val_layer(inst, instance_layers)) { + goto out; + } + + // Verify any meta-layers in the list are valid and all the component layers are + // actually present in the available layer list + verify_all_meta_layers(inst, instance_layers); out: @@ -3046,8 +3364,8 @@ void loader_implicit_layer_scan(const struct loader_instance *inst, struct loade // Pass NULL for environment variable override - implicit layers are not // overridden by LAYERS_PATH_ENV - VkResult res = - loader_get_manifest_files(inst, NULL, NULL, true, false, DEFAULT_VK_ILAYERS_INFO, RELATIVE_VK_ILAYERS_INFO, &manifest_files); + VkResult res = loader_get_manifest_files(inst, NULL, NULL, true, false, DEFAULT_VK_ILAYERS_INFO, RELATIVE_VK_ILAYERS_INFO, + &manifest_files); if (VK_SUCCESS != res || manifest_files.count == 0) { return; } @@ -3071,17 +3389,16 @@ void loader_implicit_layer_scan(const struct loader_instance *inst, struct loade continue; } - loader_add_layer_properties(inst, instance_layers, json, true, file_str); + res = loader_add_layer_properties(inst, instance_layers, json, true, file_str); loader_instance_heap_free(inst, file_str); cJSON_Delete(json); + + if (VK_ERROR_OUT_OF_HOST_MEMORY == res) { + break; + } } loader_instance_heap_free(inst, manifest_files.filename_list); - - // add a meta layer for validation if the validation layers are all present - loader_add_layer_property_meta(inst, sizeof(std_validation_names) / sizeof(std_validation_names[0]), std_validation_names, - instance_layers); - loader_platform_thread_unlock_mutex(&loader_json_lock); } @@ -3296,23 +3613,20 @@ static bool loader_add_dev_ext_table(struct loader_instance *inst, uint32_t *ptr if (list->capacity == 0) { list->index = loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (list->index == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_dev_ext_table: Failed to allocate memory " - "for list index", + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_dev_ext_table: Failed to allocate memory for list index", funcName); return false; } list->capacity = 8 * sizeof(*(list->index)); } else if (list->capacity < (list->count + 1) * sizeof(*(list->index))) { - list->index = loader_instance_heap_realloc(inst, list->index, list->capacity, list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (list->index == NULL) { + void *new_ptr = loader_instance_heap_realloc(inst, list->index, list->capacity, list->capacity * 2, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (NULL == new_ptr) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_add_dev_ext_table: Failed to reallocate memory " - "for list index", - funcName); + "loader_add_dev_ext_table: Failed to reallocate memory for list index", funcName); return false; } + list->index = new_ptr; list->capacity *= 2; } @@ -3421,14 +3735,14 @@ static bool loader_check_icds_for_phys_dev_ext_address(struct loader_instance *i } static bool loader_check_layer_list_for_phys_dev_ext_address(struct loader_instance *inst, const char *funcName) { - struct loader_layer_properties *layer_prop_list = inst->activated_layer_list.list; - for (uint32_t layer = 0; layer < inst->activated_layer_list.count; ++layer) { + struct loader_layer_properties *layer_prop_list = inst->expanded_activated_layer_list.list; + for (uint32_t layer = 0; layer < inst->expanded_activated_layer_list.count; ++layer) { // If this layer supports the vk_layerGetPhysicalDeviceProcAddr, then call // it and see if it returns a valid pointer for this function name. if (layer_prop_list[layer].interface_version > 1) { const struct loader_layer_functions *const functions = &(layer_prop_list[layer].functions); if (NULL != functions->get_physical_device_proc_addr && - NULL != functions->get_physical_device_proc_addr((VkInstance)inst, funcName)) { + NULL != functions->get_physical_device_proc_addr((VkInstance)inst->instance, funcName)) { return true; } } @@ -3474,12 +3788,13 @@ static bool loader_add_phys_dev_ext_table(struct loader_instance *inst, uint32_t } list->capacity = 8 * sizeof(*(list->index)); } else if (list->capacity < (list->count + 1) * sizeof(*(list->index))) { - list->index = loader_instance_heap_realloc(inst, list->index, list->capacity, list->capacity * 2, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (list->index == NULL) { + void *new_ptr = loader_instance_heap_realloc(inst, list->index, list->capacity, list->capacity * 2, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + if (NULL == new_ptr) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_phys_dev_ext_table() can't reallocate list memory"); return false; } + list->index = new_ptr; list->capacity *= 2; } @@ -3603,11 +3918,11 @@ bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName, // Now, search for the first layer attached and query using it to get // the first entry point. - for (i = 0; i < inst->activated_layer_list.count; i++) { - struct loader_layer_properties *layer_prop = &inst->activated_layer_list.list[i]; + for (i = 0; i < inst->expanded_activated_layer_list.count; i++) { + struct loader_layer_properties *layer_prop = &inst->expanded_activated_layer_list.list[i]; if (layer_prop->interface_version > 1 && NULL != layer_prop->functions.get_physical_device_proc_addr) { inst->disp->phys_dev_ext[idx] = - (PFN_PhysDevExt)layer_prop->functions.get_physical_device_proc_addr((VkInstance)inst, funcName); + (PFN_PhysDevExt)layer_prop->functions.get_physical_device_proc_addr((VkInstance)inst->instance, funcName); if (NULL != inst->disp->phys_dev_ext[idx]) { break; } @@ -3648,7 +3963,7 @@ struct loader_instance *loader_get_instance(const VkInstance instance) { static loader_platform_dl_handle loader_open_layer_lib(const struct loader_instance *inst, const char *chain_type, struct loader_layer_properties *prop) { if ((prop->lib_handle = loader_platform_open_library(prop->lib_name)) == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_open_layer_lib: Failed to open library %s", prop->lib_name); + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, loader_platform_open_library_error(prop->lib_name)); } else { loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Loading layer library %s", prop->lib_name); } @@ -3677,82 +3992,45 @@ void loader_deactivate_layers(const struct loader_instance *instance, struct loa // Go through the search_list and find any layers which match type. If layer // type match is found in then add it to ext_list. -static void loader_add_layer_implicit(const struct loader_instance *inst, const enum layer_type type, - struct loader_layer_list *list, const struct loader_layer_list *search_list) { - bool enable; - char *env_value; - uint32_t i; - for (i = 0; i < search_list->count; i++) { - const struct loader_layer_properties *prop = &search_list->list[i]; - if (prop->type & type) { - // Found an implicit layer, see if it should be enabled - enable = false; - - // if no enable_environment variable is specified, this implicit - // layer - // should always be enabled. Otherwise check if the variable is set - if (prop->enable_env_var.name[0] == 0) { - enable = true; - } else { - env_value = loader_secure_getenv(prop->enable_env_var.name, inst); - if (env_value && !strcmp(prop->enable_env_var.value, env_value)) enable = true; - loader_free_getenv(env_value, inst); - } - - // disable_environment has priority, i.e. if both enable and disable - // environment variables are set, the layer is disabled. Implicit - // layers - // are required to have a disable_environment variables - env_value = loader_secure_getenv(prop->disable_env_var.name, inst); - if (env_value) { - enable = false; - } - loader_free_getenv(env_value, inst); - - if (enable) { - loader_add_to_layer_list(inst, list, 1, prop); - } +static void loader_add_implicit_layers(const struct loader_instance *inst, struct loader_layer_list *target_list, + struct loader_layer_list *expanded_target_list, + const struct loader_layer_list *source_list) { + for (uint32_t src_layer = 0; src_layer < source_list->count; src_layer++) { + const struct loader_layer_properties *prop = &source_list->list[src_layer]; + if (0 == (prop->type_flags & VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER)) { + loader_add_implicit_layer(inst, prop, target_list, expanded_target_list, source_list); } } } -// Get the layer name(s) from the env_name environment variable. If layer -// is found in search_list then add it to layer_list. But only add it to -// layer_list if type matches. -static void loader_add_layer_env(struct loader_instance *inst, const enum layer_type type, const char *env_name, - struct loader_layer_list *layer_list, const struct loader_layer_list *search_list) { - char *layerEnv; +// Get the layer name(s) from the env_name environment variable. If layer is found in +// search_list then add it to layer_list. But only add it to layer_list if type_flags matches. +static void loader_add_env_layers(struct loader_instance *inst, const enum layer_type_flags type_flags, const char *env_name, + struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list, + const struct loader_layer_list *source_list) { char *next, *name; - - layerEnv = loader_secure_getenv(env_name, inst); - if (layerEnv == NULL) { - return; + char *layer_env = loader_secure_getenv(env_name, inst); + if (layer_env == NULL) { + goto out; } - name = loader_stack_alloc(strlen(layerEnv) + 1); + name = loader_stack_alloc(strlen(layer_env) + 1); if (name == NULL) { - return; + goto out; } - strcpy(name, layerEnv); - - loader_free_getenv(layerEnv, inst); + strcpy(name, layer_env); while (name && *name) { next = loader_get_next_path(name); - if (!strcmp(std_validation_str, name)) { - // Add meta list of layers - // Don't attempt to remove duplicate layers already added by app or env var - loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Expanding meta layer %s found in environment variable", - std_validation_str); - if (type == VK_LAYER_TYPE_INSTANCE_EXPLICIT) inst->activated_layers_are_std_val = true; - for (uint32_t i = 0; i < sizeof(std_validation_names) / sizeof(std_validation_names[0]); i++) { - loader_find_layer_name_add_list(inst, std_validation_names[i], type, search_list, layer_list); - } - } else { - loader_find_layer_name_add_list(inst, name, type, search_list, layer_list); - } + loader_find_layer_name_add_list(inst, name, type_flags, source_list, target_list, expanded_target_list); name = next; } +out: + + if (layer_env != NULL) { + loader_free_getenv(layer_env, inst); + } + return; } @@ -3762,22 +4040,30 @@ VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkIns assert(inst && "Cannot have null instance"); - if (!loader_init_layer_list(inst, &inst->activated_layer_list)) { + if (!loader_init_layer_list(inst, &inst->app_activated_layer_list)) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_enable_instance_layers: Failed to initialize" - " the layer list"); + " application version of the layer list"); + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + + if (!loader_init_layer_list(inst, &inst->expanded_activated_layer_list)) { + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "loader_enable_instance_layers: Failed to initialize" + " expanded version of the layer list"); return VK_ERROR_OUT_OF_HOST_MEMORY; } // Add any implicit layers first - loader_add_layer_implicit(inst, VK_LAYER_TYPE_INSTANCE_IMPLICIT, &inst->activated_layer_list, instance_layers); + loader_add_implicit_layers(inst, &inst->app_activated_layer_list, &inst->expanded_activated_layer_list, instance_layers); // Add any layers specified via environment variable next - loader_add_layer_env(inst, VK_LAYER_TYPE_INSTANCE_EXPLICIT, "VK_INSTANCE_LAYERS", &inst->activated_layer_list, instance_layers); + loader_add_env_layers(inst, VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER, "VK_INSTANCE_LAYERS", &inst->app_activated_layer_list, + &inst->expanded_activated_layer_list, instance_layers); // Add layers specified by the application - err = loader_add_layer_names_to_list(inst, &inst->activated_layer_list, pCreateInfo->enabledLayerCount, - pCreateInfo->ppEnabledLayerNames, instance_layers); + err = loader_add_layer_names_to_list(inst, &inst->app_activated_layer_list, &inst->expanded_activated_layer_list, + pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames, instance_layers); return err; } @@ -3786,8 +4072,7 @@ VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkIns bool loader_get_layer_interface_version(PFN_vkNegotiateLoaderLayerInterfaceVersion fp_negotiate_layer_version, VkNegotiateLayerInterface *interface_struct) { memset(interface_struct, 0, sizeof(VkNegotiateLayerInterface)); - - // Base assumption is that all layers are version 1 at least. + interface_struct->sType = LAYER_NEGOTIATE_INTERFACE_STRUCT; interface_struct->loaderLayerInterfaceVersion = 1; if (fp_negotiate_layer_version != NULL) { @@ -3843,14 +4128,14 @@ VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo, c memcpy(&loader_create_info, pCreateInfo, sizeof(VkInstanceCreateInfo)); - if (inst->activated_layer_list.count > 0) { + if (inst->expanded_activated_layer_list.count > 0) { chain_info.u.pLayerInfo = NULL; chain_info.pNext = pCreateInfo->pNext; chain_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO; chain_info.function = VK_LAYER_LINK_INFO; loader_create_info.pNext = &chain_info; - layer_instance_link_info = loader_stack_alloc(sizeof(VkLayerInstanceLink) * inst->activated_layer_list.count); + layer_instance_link_info = loader_stack_alloc(sizeof(VkLayerInstanceLink) * inst->expanded_activated_layer_list.count); if (!layer_instance_link_info) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_create_instance_chain: Failed to alloc Instance" @@ -3859,8 +4144,8 @@ VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo, c } // Create instance chain of enabled layers - for (int32_t i = inst->activated_layer_list.count - 1; i >= 0; i--) { - struct loader_layer_properties *layer_prop = &inst->activated_layer_list.list[i]; + for (int32_t i = inst->expanded_activated_layer_list.count - 1; i >= 0; i--) { + struct loader_layer_properties *layer_prop = &inst->expanded_activated_layer_list.list[i]; loader_platform_dl_handle lib_handle; lib_handle = loader_open_layer_lib(inst, "instance", layer_prop); @@ -4040,7 +4325,7 @@ VkResult loader_create_device_chain(const struct loader_physical_device_tramp *p } } - layer_device_link_info = loader_stack_alloc(sizeof(VkLayerDeviceLink) * dev->activated_layer_list.count); + layer_device_link_info = loader_stack_alloc(sizeof(VkLayerDeviceLink) * dev->expanded_activated_layer_list.count); if (!layer_device_link_info) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_create_device_chain: Failed to alloc Device objects" @@ -4048,7 +4333,7 @@ VkResult loader_create_device_chain(const struct loader_physical_device_tramp *p return VK_ERROR_OUT_OF_HOST_MEMORY; } - if (dev->activated_layer_list.count > 0) { + if (dev->expanded_activated_layer_list.count > 0) { chain_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO; chain_info.function = VK_LAYER_LINK_INFO; chain_info.u.pLayerInfo = NULL; @@ -4056,8 +4341,8 @@ VkResult loader_create_device_chain(const struct loader_physical_device_tramp *p loader_create_info.pNext = &chain_info; // Create instance chain of enabled layers - for (int32_t i = dev->activated_layer_list.count - 1; i >= 0; i--) { - struct loader_layer_properties *layer_prop = &dev->activated_layer_list.list[i]; + for (int32_t i = dev->expanded_activated_layer_list.count - 1; i >= 0; i--) { + struct loader_layer_properties *layer_prop = &dev->expanded_activated_layer_list.list[i]; loader_platform_dl_handle lib_handle; bool functions_in_interface = false; @@ -4192,10 +4477,9 @@ VkResult loader_validate_layers(const struct loader_instance *inst, const uint32 } prop = loader_get_layer_property(ppEnabledLayerNames[i], list); - if (!prop) { + if (NULL == prop) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_layers: Layer %d does not exist in " - "the list of available layers", + "loader_validate_layers: Layer %d does not exist in the list of available layers", i); return VK_ERROR_LAYER_NOT_PRESENT; } @@ -4208,33 +4492,42 @@ VkResult loader_validate_instance_extensions(const struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo) { VkExtensionProperties *extension_prop; struct loader_layer_properties *layer_prop; + char *env_value; + bool check_if_known = true; for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]); if (result != VK_STRING_ERROR_NONE) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_instance_extensions: Instance " - "ppEnabledExtensionNames contains " + "loader_validate_instance_extensions: Instance ppEnabledExtensionNames contains " "string that is too long or is badly formed"); return VK_ERROR_EXTENSION_NOT_PRESENT; } - // See if the extension is in the list of supported extensions - bool found = false; - for (uint32_t j = 0; LOADER_INSTANCE_EXTENSIONS[j] != NULL; j++) { - if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], LOADER_INSTANCE_EXTENSIONS[j]) == 0) { - found = true; - break; - } + // Check if a user wants to disable the instance extension filtering behavior + env_value = loader_getenv("VK_LOADER_DISABLE_INST_EXT_FILTER", inst); + if (NULL != env_value && atoi(env_value) != 0) { + check_if_known = false; } + loader_free_getenv(env_value, inst); - // If it isn't in the list, return an error - if (!found) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_instance_extensions: Extension %d " - "not found in list of available extensions.", - i); - return VK_ERROR_EXTENSION_NOT_PRESENT; + if (check_if_known) { + // See if the extension is in the list of supported extensions + bool found = false; + for (uint32_t j = 0; LOADER_INSTANCE_EXTENSIONS[j] != NULL; j++) { + if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], LOADER_INSTANCE_EXTENSIONS[j]) == 0) { + found = true; + break; + } + } + + // If it isn't in the list, return an error + if (!found) { + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "loader_validate_instance_extensions: Extension %s not found in list of known instance extensions.", + pCreateInfo->ppEnabledExtensionNames[i]); + return VK_ERROR_EXTENSION_NOT_PRESENT; + } } extension_prop = get_extension_property(pCreateInfo->ppEnabledExtensionNames[i], icd_exts); @@ -4248,7 +4541,7 @@ VkResult loader_validate_instance_extensions(const struct loader_instance *inst, // Not in global list, search layer extension lists for (uint32_t j = 0; j < pCreateInfo->enabledLayerCount; j++) { layer_prop = loader_get_layer_property(pCreateInfo->ppEnabledLayerNames[j], instance_layers); - if (!layer_prop) { + if (NULL == layer_prop) { // Should NOT get here, loader_validate_layers should have already filtered this case out. continue; } @@ -4263,9 +4556,9 @@ VkResult loader_validate_instance_extensions(const struct loader_instance *inst, if (!extension_prop) { // Didn't find extension name in any of the global layers, error out loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_instance_extensions: Extension %d " - "not found in enabled layer list extensions.", - i); + "loader_validate_instance_extensions: Instance extension %s not supported by available ICDs or enabled " + "layers.", + pCreateInfo->ppEnabledExtensionNames[i]); return VK_ERROR_EXTENSION_NOT_PRESENT; } } @@ -4282,8 +4575,7 @@ VkResult loader_validate_device_extensions(struct loader_physical_device_tramp * VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]); if (result != VK_STRING_ERROR_NONE) { loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_device_extensions: Device " - "ppEnabledExtensionNames contains " + "loader_validate_device_extensions: Device ppEnabledExtensionNames contains " "string that is too long or is badly formed"); return VK_ERROR_EXTENSION_NOT_PRESENT; } @@ -4309,9 +4601,9 @@ VkResult loader_validate_device_extensions(struct loader_physical_device_tramp * if (!extension_prop) { // Didn't find extension name in any of the device layers, error out loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "loader_validate_device_extensions: Extension %d " - "not found in enabled layer list extensions.", - i); + "loader_validate_device_extensions: Device extension %s not supported by selected physical device " + "or enabled layers.", + pCreateInfo->ppEnabledExtensionNames[i]); return VK_ERROR_EXTENSION_NOT_PRESENT; } } @@ -4342,8 +4634,7 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateInstance(const VkInstanceCreateI filtered_extension_names = loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *)); if (!filtered_extension_names) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "terminator_CreateInstance: Failed create extension name " - "array for %d extensions", + "terminator_CreateInstance: Failed create extension name array for %d extensions", pCreateInfo->enabledExtensionCount); res = VK_ERROR_OUT_OF_HOST_MEMORY; goto out; @@ -4354,8 +4645,7 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateInstance(const VkInstanceCreateI icd_term = loader_icd_add(ptr_instance, &ptr_instance->icd_tramp_list.scanned_list[i]); if (NULL == icd_term) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "terminator_CreateInstance: Failed to add ICD %d to ICD " - "trampoline list.", + "terminator_CreateInstance: Failed to add ICD %d to ICD trampoline list.", i); res = VK_ERROR_OUT_OF_HOST_MEMORY; goto out; @@ -4626,6 +4916,65 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDevice(VkPhysicalDevice physical } } + // Handle loader emulation for structs that are not supported by the ICD: + // Presently, the emulation leaves the pNext chain alone. This means that the ICD will receive items in the chain which + // are not recognized by the ICD. If this causes the ICD to fail, then the items would have to be removed here. The current + // implementation does not remove them because copying the pNext chain would be impossible if the loader does not recognize + // the any of the struct types, as the loader would not know the size to allocate and copy. + if (icd_term->dispatch.GetPhysicalDeviceFeatures2KHR == NULL) { + const void *pNext = localCreateInfo.pNext; + while (pNext != NULL) { + switch (*(VkStructureType *)pNext) { + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkCreateDevice: Emulating handling of VkPhysicalDeviceFeatures2KHR in pNext chain for ICD \"%s\"", + icd_term->scanned_icd->lib_name); + const VkPhysicalDeviceFeatures2KHR *features = pNext; + + // Verify that VK_KHR_get_physical_device_properties2 is enabled + if (icd_term->this_instance->enabled_known_extensions.khr_get_physical_device_properties2) { + localCreateInfo.pEnabledFeatures = &features->features; + } + + // Leave this item in the pNext chain for now + + pNext = features->pNext; + break; + } + + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX: { + loader_log( + icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, + "vkCreateDevice: Emulating handling of VkDeviceGroupDeviceCreateInfoKHX in pNext chain for ICD \"%s\"", + icd_term->scanned_icd->lib_name); + const VkDeviceGroupDeviceCreateInfoKHX *group_info = pNext; + + // The group must contain only this one device, since physical device groups aren't actually supported + if (group_info->physicalDeviceCount != 1 || group_info->pPhysicalDevices[0] != physicalDevice) { + loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "vkCreateDevice: Emulation failed to create device from device group info"); + res = VK_ERROR_INITIALIZATION_FAILED; + goto out; + } + + // Nothing needs to be done here because we're leaving the item in the pNext chain and because the spec states + // that the physicalDevice argument must be included in the device group, and we've already checked that it is + + pNext = group_info->pNext; + break; + } + + // Multiview properties are also allowed, but since VK_KHX_multiview is a device extension, we'll just let the ICD + // handle that error when the user enables the extension here + default: { + const struct VkStructureHeader *header = pNext; + pNext = header->pNext; + break; + } + } + } + } + res = fpCreateDevice(phys_dev_term->phys_dev, &localCreateInfo, pAllocator, &dev->icd_device); if (res != VK_SUCCESS) { loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, @@ -4662,7 +5011,7 @@ VkResult setupLoaderTrampPhysDevs(VkInstance instance) { goto out; } - // Query how many gpus there + // Query how many GPUs there res = inst->disp->layer_inst_disp.EnumeratePhysicalDevices(instance, &total_count, NULL); if (res != VK_SUCCESS) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, @@ -5069,8 +5418,7 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(VkP goto out; } - loader_add_layer_implicit(icd_term->this_instance, VK_LAYER_TYPE_INSTANCE_IMPLICIT, &implicit_layer_list, - &icd_term->this_instance->instance_layer_list); + loader_add_implicit_layers(icd_term->this_instance, &implicit_layer_list, NULL, &icd_term->this_instance->instance_layer_list); // We need to determine which implicit layers are active, and then add their extensions. This can't be cached as // it depends on results of environment variables (which can change). if (pProperties != NULL) { @@ -5087,8 +5435,8 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(VkP goto out; } - loader_add_layer_implicit(icd_term->this_instance, VK_LAYER_TYPE_INSTANCE_IMPLICIT, &implicit_layer_list, - &icd_term->this_instance->instance_layer_list); + loader_add_implicit_layers(icd_term->this_instance, &implicit_layer_list, NULL, + &icd_term->this_instance->instance_layer_list); for (uint32_t i = 0; i < implicit_layer_list.count; i++) { for (uint32_t j = 0; j < implicit_layer_list.list[i].device_extension_list.count; j++) { diff --git a/third_party/vulkan/loader/loader.h b/third_party/vulkan/loader/loader.h index 78160d0df..3a80657d9 100644 --- a/third_party/vulkan/loader/loader.h +++ b/third_party/vulkan/loader/loader.h @@ -1,8 +1,8 @@ /* * - * Copyright (c) 2014-2016 The Khronos Group Inc. - * Copyright (c) 2014-2016 Valve Corporation - * Copyright (c) 2014-2016 LunarG, Inc. + * Copyright (c) 2014-2017 The Khronos Group Inc. + * Copyright (c) 2014-2017 Valve Corporation + * Copyright (c) 2014-2017 LunarG, Inc. * Copyright (C) 2015 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -48,9 +48,6 @@ #define DEBUG_DISABLE_APP_ALLOCATORS 0 #define MAX_STRING_SIZE 1024 -#define VK_MAJOR(version) (version >> 22) -#define VK_MINOR(version) ((version >> 12) & 0x3ff) -#define VK_PATCH(version) (version & 0xfff) // This is defined in vk_layer.h, but if there's problems we need to create the define // here. @@ -58,10 +55,10 @@ #define MAX_NUM_UNKNOWN_EXTS 250 #endif -enum layer_type { - VK_LAYER_TYPE_INSTANCE_EXPLICIT = 0x1, - VK_LAYER_TYPE_INSTANCE_IMPLICIT = 0x2, - VK_LAYER_TYPE_META_EXPLICT = 0x4, +enum layer_type_flags { + VK_LAYER_TYPE_FLAG_INSTANCE_LAYER = 0x1, // If not set, indicates Device layer + VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER = 0x2, // If not set, indicates Implicit layer + VK_LAYER_TYPE_FLAG_META_LAYER = 0x4, // If not set, indicates standard layer }; typedef enum VkStringErrorFlagBits { @@ -81,10 +78,6 @@ static const char UTF8_THREE_BYTE_MASK = 0xF8; static const char UTF8_DATA_BYTE_CODE = 0x80; static const char UTF8_DATA_BYTE_MASK = 0xC0; -static const char std_validation_names[6][VK_MAX_EXTENSION_NAME_SIZE] = { - "VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation", "VK_LAYER_LUNARG_object_tracker", - "VK_LAYER_LUNARG_core_validation", "VK_LAYER_LUNARG_swapchain", "VK_LAYER_GOOGLE_unique_objects"}; - struct VkStructureHeader { VkStructureType sType; const void *pNext; @@ -133,7 +126,7 @@ struct loader_layer_functions { struct loader_layer_properties { VkLayerProperties info; - enum layer_type type; + enum layer_type_flags type_flags; uint32_t interface_version; // PFN_vkNegotiateLoaderLayerInterfaceVersion char lib_name[MAX_STRING_SIZE]; loader_platform_dl_handle lib_handle; @@ -142,6 +135,8 @@ struct loader_layer_properties { struct loader_device_extension_list device_extension_list; struct loader_name_value disable_env_var; struct loader_name_value enable_env_var; + uint32_t num_component_layers; + char (*component_layer_names)[MAX_STRING_SIZE]; }; struct loader_layer_list { @@ -182,7 +177,13 @@ struct loader_device { VkDevice icd_device; // device object from the icd struct loader_physical_device_term *phys_dev_term; - struct loader_layer_list activated_layer_list; + // List of activated layers. + // app_ is the version based on exactly what the application asked for. + // This is what must be returned to the application on Enumerate calls. + // expanded_ is the version based on expanding meta-layers into their + // individual component layers. This is what is used internally. + struct loader_layer_list app_activated_layer_list; + struct loader_layer_list expanded_activated_layer_list; VkAllocationCallbacks alloc_callbacks; @@ -252,8 +253,15 @@ struct loader_instance { struct loader_msg_callback_map_entry *icd_msg_callback_map; struct loader_layer_list instance_layer_list; - struct loader_layer_list activated_layer_list; - bool activated_layers_are_std_val; + + // List of activated layers. + // app_ is the version based on exactly what the application asked for. + // This is what must be returned to the application on Enumerate calls. + // expanded_ is the version based on expanding meta-layers into their + // individual component layers. This is what is used internally. + struct loader_layer_list app_activated_layer_list; + struct loader_layer_list expanded_activated_layer_list; + VkInstance instance; // layers/ICD instance returned to trampoline struct loader_extension_list ext_list; // icds and loaders extensions @@ -370,7 +378,6 @@ extern THREAD_LOCAL_DECL struct loader_instance *tls_instance; extern LOADER_PLATFORM_THREAD_ONCE_DEFINITION(once_init); extern loader_platform_thread_mutex loader_lock; extern loader_platform_thread_mutex loader_json_lock; -extern const char *std_validation_str; struct loader_msg_callback_map_entry { VkDebugReportCallbackEXT icd_obj; @@ -421,16 +428,11 @@ void loader_destroy_layer_list(const struct loader_instance *inst, struct loader struct loader_layer_list *layer_list); void loader_delete_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_list); bool loader_find_layer_name_array(const char *name, uint32_t layer_count, const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]); -VkResult loader_expand_layer_names(struct loader_instance *inst, const char *key_name, uint32_t expand_count, - const char expand_names[][VK_MAX_EXTENSION_NAME_SIZE], uint32_t *layer_count, - char const *const **ppp_layer_names); -void loader_init_std_validation_props(struct loader_layer_properties *props); -void loader_delete_shadow_inst_layer_names(const struct loader_instance *inst, const VkInstanceCreateInfo *orig, - VkInstanceCreateInfo *ours); VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loader_layer_list *list, uint32_t prop_list_count, const struct loader_layer_properties *props); -void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type type, - const struct loader_layer_list *search_list, struct loader_layer_list *found_list); +void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type_flags type_flags, + const struct loader_layer_list *source_list, struct loader_layer_list *target_list, + struct loader_layer_list *expanded_target_list); void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list); VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list); void loader_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers); @@ -478,4 +480,4 @@ VkResult setupLoaderTermPhysDevs(struct loader_instance *inst); VkStringErrorFlags vk_string_validate(const int max_length, const char *char_array); -#endif // LOADER_H +#endif // LOADER_H diff --git a/third_party/vulkan/loader/phys_dev_ext.c b/third_party/vulkan/loader/phys_dev_ext.c index d668b1b90..91e0ef8f6 100644 --- a/third_party/vulkan/loader/phys_dev_ext.c +++ b/third_party/vulkan/loader/phys_dev_ext.c @@ -1,8 +1,8 @@ /* * - * Copyright (c) 2016 The Khronos Group Inc. - * Copyright (c) 2016 Valve Corporation - * Copyright (c) 2016 LunarG, Inc. + * Copyright (c) 2016-17 The Khronos Group Inc. + * Copyright (c) 2016-17 Valve Corporation + * Copyright (c) 2016-17 LunarG, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,6 +17,7 @@ * limitations under the License. * * Author: Mark Young + * Author: Lenny Komow * */ @@ -33,281 +34,511 @@ #pragma GCC optimize(3) // force gcc to use tail-calls #endif -// Trampoline function macro for unknown physical device extension command. -#define PhysDevExtTramp(num) \ - VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp##num(VkPhysicalDevice physical_device) { \ - const struct loader_instance_dispatch_table *disp; \ - disp = loader_get_instance_dispatch(physical_device); \ - disp->phys_dev_ext[num](loader_unwrap_physical_device(physical_device)); \ - } - -// Terminator function macro for unknown physical device extension command. -#define PhysDevExtTermin(num) \ - VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin##num(VkPhysicalDevice physical_device) { \ - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physical_device; \ - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; \ - struct loader_instance *inst = (struct loader_instance *)icd_term->this_instance; \ - if (NULL == icd_term->phys_dev_ext[num]) { \ - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "Extension %s not supported for this physical device", \ - inst->phys_dev_ext_disp_hash[num].func_name); \ - } \ - icd_term->phys_dev_ext[num](phys_dev_term->phys_dev); \ - } +// Declarations for the trampoline +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp0(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp1(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp2(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp3(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp4(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp5(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp6(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp7(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp8(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp9(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp10(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp11(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp12(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp13(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp14(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp15(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp16(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp17(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp18(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp19(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp20(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp21(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp22(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp23(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp24(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp25(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp26(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp27(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp28(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp29(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp30(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp31(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp32(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp33(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp34(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp35(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp36(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp37(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp38(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp39(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp40(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp41(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp42(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp43(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp44(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp45(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp46(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp47(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp48(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp49(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp50(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp51(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp52(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp53(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp54(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp55(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp56(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp57(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp58(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp59(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp60(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp61(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp62(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp63(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp64(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp65(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp66(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp67(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp68(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp69(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp70(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp71(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp72(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp73(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp74(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp75(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp76(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp77(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp78(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp79(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp80(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp81(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp82(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp83(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp84(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp85(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp86(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp87(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp88(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp89(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp90(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp91(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp92(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp93(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp94(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp95(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp96(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp97(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp98(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp99(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp100(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp101(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp102(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp103(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp104(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp105(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp106(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp107(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp108(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp109(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp110(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp111(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp112(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp113(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp114(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp115(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp116(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp117(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp118(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp119(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp120(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp121(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp122(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp123(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp124(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp125(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp126(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp127(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp128(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp129(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp130(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp131(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp132(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp133(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp134(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp135(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp136(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp137(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp138(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp139(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp140(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp141(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp142(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp143(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp144(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp145(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp146(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp147(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp148(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp149(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp150(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp151(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp152(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp153(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp154(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp155(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp156(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp157(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp158(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp159(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp160(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp161(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp162(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp163(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp164(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp165(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp166(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp167(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp168(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp169(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp170(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp171(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp172(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp173(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp174(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp175(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp176(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp177(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp178(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp179(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp180(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp181(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp182(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp183(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp184(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp185(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp186(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp187(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp188(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp189(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp190(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp191(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp192(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp193(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp194(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp195(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp196(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp197(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp198(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp199(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp200(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp201(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp202(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp203(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp204(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp205(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp206(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp207(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp208(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp209(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp210(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp211(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp212(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp213(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp214(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp215(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp216(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp217(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp218(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp219(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp220(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp221(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp222(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp223(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp224(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp225(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp226(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp227(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp228(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp229(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp230(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp231(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp232(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp233(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp234(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp235(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp236(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp237(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp238(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp239(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp240(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp241(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp242(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp243(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp244(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp245(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp246(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp247(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp248(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp249(VkPhysicalDevice); // Disable clang-format for lists of macros // clang-format off -// Instantiations of the trampoline and terminator -PhysDevExtTramp(0) PhysDevExtTermin(0) -PhysDevExtTramp(1) PhysDevExtTermin(1) -PhysDevExtTramp(2) PhysDevExtTermin(2) -PhysDevExtTramp(3) PhysDevExtTermin(3) -PhysDevExtTramp(4) PhysDevExtTermin(4) -PhysDevExtTramp(5) PhysDevExtTermin(5) -PhysDevExtTramp(6) PhysDevExtTermin(6) -PhysDevExtTramp(7) PhysDevExtTermin(7) -PhysDevExtTramp(8) PhysDevExtTermin(8) -PhysDevExtTramp(9) PhysDevExtTermin(9) -PhysDevExtTramp(10) PhysDevExtTermin(10) -PhysDevExtTramp(11) PhysDevExtTermin(11) -PhysDevExtTramp(12) PhysDevExtTermin(12) -PhysDevExtTramp(13) PhysDevExtTermin(13) -PhysDevExtTramp(14) PhysDevExtTermin(14) -PhysDevExtTramp(15) PhysDevExtTermin(15) -PhysDevExtTramp(16) PhysDevExtTermin(16) -PhysDevExtTramp(17) PhysDevExtTermin(17) -PhysDevExtTramp(18) PhysDevExtTermin(18) -PhysDevExtTramp(19) PhysDevExtTermin(19) -PhysDevExtTramp(20) PhysDevExtTermin(20) -PhysDevExtTramp(21) PhysDevExtTermin(21) -PhysDevExtTramp(22) PhysDevExtTermin(22) -PhysDevExtTramp(23) PhysDevExtTermin(23) -PhysDevExtTramp(24) PhysDevExtTermin(24) -PhysDevExtTramp(25) PhysDevExtTermin(25) -PhysDevExtTramp(26) PhysDevExtTermin(26) -PhysDevExtTramp(27) PhysDevExtTermin(27) -PhysDevExtTramp(28) PhysDevExtTermin(28) -PhysDevExtTramp(29) PhysDevExtTermin(29) -PhysDevExtTramp(30) PhysDevExtTermin(30) -PhysDevExtTramp(31) PhysDevExtTermin(31) -PhysDevExtTramp(32) PhysDevExtTermin(32) -PhysDevExtTramp(33) PhysDevExtTermin(33) -PhysDevExtTramp(34) PhysDevExtTermin(34) -PhysDevExtTramp(35) PhysDevExtTermin(35) -PhysDevExtTramp(36) PhysDevExtTermin(36) -PhysDevExtTramp(37) PhysDevExtTermin(37) -PhysDevExtTramp(38) PhysDevExtTermin(38) -PhysDevExtTramp(39) PhysDevExtTermin(39) -PhysDevExtTramp(40) PhysDevExtTermin(40) -PhysDevExtTramp(41) PhysDevExtTermin(41) -PhysDevExtTramp(42) PhysDevExtTermin(42) -PhysDevExtTramp(43) PhysDevExtTermin(43) -PhysDevExtTramp(44) PhysDevExtTermin(44) -PhysDevExtTramp(45) PhysDevExtTermin(45) -PhysDevExtTramp(46) PhysDevExtTermin(46) -PhysDevExtTramp(47) PhysDevExtTermin(47) -PhysDevExtTramp(48) PhysDevExtTermin(48) -PhysDevExtTramp(49) PhysDevExtTermin(49) -PhysDevExtTramp(50) PhysDevExtTermin(50) -PhysDevExtTramp(51) PhysDevExtTermin(51) -PhysDevExtTramp(52) PhysDevExtTermin(52) -PhysDevExtTramp(53) PhysDevExtTermin(53) -PhysDevExtTramp(54) PhysDevExtTermin(54) -PhysDevExtTramp(55) PhysDevExtTermin(55) -PhysDevExtTramp(56) PhysDevExtTermin(56) -PhysDevExtTramp(57) PhysDevExtTermin(57) -PhysDevExtTramp(58) PhysDevExtTermin(58) -PhysDevExtTramp(59) PhysDevExtTermin(59) -PhysDevExtTramp(60) PhysDevExtTermin(60) -PhysDevExtTramp(61) PhysDevExtTermin(61) -PhysDevExtTramp(62) PhysDevExtTermin(62) -PhysDevExtTramp(63) PhysDevExtTermin(63) -PhysDevExtTramp(64) PhysDevExtTermin(64) -PhysDevExtTramp(65) PhysDevExtTermin(65) -PhysDevExtTramp(66) PhysDevExtTermin(66) -PhysDevExtTramp(67) PhysDevExtTermin(67) -PhysDevExtTramp(68) PhysDevExtTermin(68) -PhysDevExtTramp(69) PhysDevExtTermin(69) -PhysDevExtTramp(70) PhysDevExtTermin(70) -PhysDevExtTramp(71) PhysDevExtTermin(71) -PhysDevExtTramp(72) PhysDevExtTermin(72) -PhysDevExtTramp(73) PhysDevExtTermin(73) -PhysDevExtTramp(74) PhysDevExtTermin(74) -PhysDevExtTramp(75) PhysDevExtTermin(75) -PhysDevExtTramp(76) PhysDevExtTermin(76) -PhysDevExtTramp(77) PhysDevExtTermin(77) -PhysDevExtTramp(78) PhysDevExtTermin(78) -PhysDevExtTramp(79) PhysDevExtTermin(79) -PhysDevExtTramp(80) PhysDevExtTermin(80) -PhysDevExtTramp(81) PhysDevExtTermin(81) -PhysDevExtTramp(82) PhysDevExtTermin(82) -PhysDevExtTramp(83) PhysDevExtTermin(83) -PhysDevExtTramp(84) PhysDevExtTermin(84) -PhysDevExtTramp(85) PhysDevExtTermin(85) -PhysDevExtTramp(86) PhysDevExtTermin(86) -PhysDevExtTramp(87) PhysDevExtTermin(87) -PhysDevExtTramp(88) PhysDevExtTermin(88) -PhysDevExtTramp(89) PhysDevExtTermin(89) -PhysDevExtTramp(90) PhysDevExtTermin(90) -PhysDevExtTramp(91) PhysDevExtTermin(91) -PhysDevExtTramp(92) PhysDevExtTermin(92) -PhysDevExtTramp(93) PhysDevExtTermin(93) -PhysDevExtTramp(94) PhysDevExtTermin(94) -PhysDevExtTramp(95) PhysDevExtTermin(95) -PhysDevExtTramp(96) PhysDevExtTermin(96) -PhysDevExtTramp(97) PhysDevExtTermin(97) -PhysDevExtTramp(98) PhysDevExtTermin(98) -PhysDevExtTramp(99) PhysDevExtTermin(99) -PhysDevExtTramp(100) PhysDevExtTermin(100) -PhysDevExtTramp(101) PhysDevExtTermin(101) -PhysDevExtTramp(102) PhysDevExtTermin(102) -PhysDevExtTramp(103) PhysDevExtTermin(103) -PhysDevExtTramp(104) PhysDevExtTermin(104) -PhysDevExtTramp(105) PhysDevExtTermin(105) -PhysDevExtTramp(106) PhysDevExtTermin(106) -PhysDevExtTramp(107) PhysDevExtTermin(107) -PhysDevExtTramp(108) PhysDevExtTermin(108) -PhysDevExtTramp(109) PhysDevExtTermin(109) -PhysDevExtTramp(110) PhysDevExtTermin(110) -PhysDevExtTramp(111) PhysDevExtTermin(111) -PhysDevExtTramp(112) PhysDevExtTermin(112) -PhysDevExtTramp(113) PhysDevExtTermin(113) -PhysDevExtTramp(114) PhysDevExtTermin(114) -PhysDevExtTramp(115) PhysDevExtTermin(115) -PhysDevExtTramp(116) PhysDevExtTermin(116) -PhysDevExtTramp(117) PhysDevExtTermin(117) -PhysDevExtTramp(118) PhysDevExtTermin(118) -PhysDevExtTramp(119) PhysDevExtTermin(119) -PhysDevExtTramp(120) PhysDevExtTermin(120) -PhysDevExtTramp(121) PhysDevExtTermin(121) -PhysDevExtTramp(122) PhysDevExtTermin(122) -PhysDevExtTramp(123) PhysDevExtTermin(123) -PhysDevExtTramp(124) PhysDevExtTermin(124) -PhysDevExtTramp(125) PhysDevExtTermin(125) -PhysDevExtTramp(126) PhysDevExtTermin(126) -PhysDevExtTramp(127) PhysDevExtTermin(127) -PhysDevExtTramp(128) PhysDevExtTermin(128) -PhysDevExtTramp(129) PhysDevExtTermin(129) -PhysDevExtTramp(130) PhysDevExtTermin(130) -PhysDevExtTramp(131) PhysDevExtTermin(131) -PhysDevExtTramp(132) PhysDevExtTermin(132) -PhysDevExtTramp(133) PhysDevExtTermin(133) -PhysDevExtTramp(134) PhysDevExtTermin(134) -PhysDevExtTramp(135) PhysDevExtTermin(135) -PhysDevExtTramp(136) PhysDevExtTermin(136) -PhysDevExtTramp(137) PhysDevExtTermin(137) -PhysDevExtTramp(138) PhysDevExtTermin(138) -PhysDevExtTramp(139) PhysDevExtTermin(139) -PhysDevExtTramp(140) PhysDevExtTermin(140) -PhysDevExtTramp(141) PhysDevExtTermin(141) -PhysDevExtTramp(142) PhysDevExtTermin(142) -PhysDevExtTramp(143) PhysDevExtTermin(143) -PhysDevExtTramp(144) PhysDevExtTermin(144) -PhysDevExtTramp(145) PhysDevExtTermin(145) -PhysDevExtTramp(146) PhysDevExtTermin(146) -PhysDevExtTramp(147) PhysDevExtTermin(147) -PhysDevExtTramp(148) PhysDevExtTermin(148) -PhysDevExtTramp(149) PhysDevExtTermin(149) -PhysDevExtTramp(150) PhysDevExtTermin(150) -PhysDevExtTramp(151) PhysDevExtTermin(151) -PhysDevExtTramp(152) PhysDevExtTermin(152) -PhysDevExtTramp(153) PhysDevExtTermin(153) -PhysDevExtTramp(154) PhysDevExtTermin(154) -PhysDevExtTramp(155) PhysDevExtTermin(155) -PhysDevExtTramp(156) PhysDevExtTermin(156) -PhysDevExtTramp(157) PhysDevExtTermin(157) -PhysDevExtTramp(158) PhysDevExtTermin(158) -PhysDevExtTramp(159) PhysDevExtTermin(159) -PhysDevExtTramp(160) PhysDevExtTermin(160) -PhysDevExtTramp(161) PhysDevExtTermin(161) -PhysDevExtTramp(162) PhysDevExtTermin(162) -PhysDevExtTramp(163) PhysDevExtTermin(163) -PhysDevExtTramp(164) PhysDevExtTermin(164) -PhysDevExtTramp(165) PhysDevExtTermin(165) -PhysDevExtTramp(166) PhysDevExtTermin(166) -PhysDevExtTramp(167) PhysDevExtTermin(167) -PhysDevExtTramp(168) PhysDevExtTermin(168) -PhysDevExtTramp(169) PhysDevExtTermin(169) -PhysDevExtTramp(170) PhysDevExtTermin(170) -PhysDevExtTramp(171) PhysDevExtTermin(171) -PhysDevExtTramp(172) PhysDevExtTermin(172) -PhysDevExtTramp(173) PhysDevExtTermin(173) -PhysDevExtTramp(174) PhysDevExtTermin(174) -PhysDevExtTramp(175) PhysDevExtTermin(175) -PhysDevExtTramp(176) PhysDevExtTermin(176) -PhysDevExtTramp(177) PhysDevExtTermin(177) -PhysDevExtTramp(178) PhysDevExtTermin(178) -PhysDevExtTramp(179) PhysDevExtTermin(179) -PhysDevExtTramp(180) PhysDevExtTermin(180) -PhysDevExtTramp(181) PhysDevExtTermin(181) -PhysDevExtTramp(182) PhysDevExtTermin(182) -PhysDevExtTramp(183) PhysDevExtTermin(183) -PhysDevExtTramp(184) PhysDevExtTermin(184) -PhysDevExtTramp(185) PhysDevExtTermin(185) -PhysDevExtTramp(186) PhysDevExtTermin(186) -PhysDevExtTramp(187) PhysDevExtTermin(187) -PhysDevExtTramp(188) PhysDevExtTermin(188) -PhysDevExtTramp(189) PhysDevExtTermin(189) -PhysDevExtTramp(190) PhysDevExtTermin(190) -PhysDevExtTramp(191) PhysDevExtTermin(191) -PhysDevExtTramp(192) PhysDevExtTermin(192) -PhysDevExtTramp(193) PhysDevExtTermin(193) -PhysDevExtTramp(194) PhysDevExtTermin(194) -PhysDevExtTramp(195) PhysDevExtTermin(195) -PhysDevExtTramp(196) PhysDevExtTermin(196) -PhysDevExtTramp(197) PhysDevExtTermin(197) -PhysDevExtTramp(198) PhysDevExtTermin(198) -PhysDevExtTramp(199) PhysDevExtTermin(199) -PhysDevExtTramp(200) PhysDevExtTermin(200) -PhysDevExtTramp(201) PhysDevExtTermin(201) -PhysDevExtTramp(202) PhysDevExtTermin(202) -PhysDevExtTramp(203) PhysDevExtTermin(203) -PhysDevExtTramp(204) PhysDevExtTermin(204) -PhysDevExtTramp(205) PhysDevExtTermin(205) -PhysDevExtTramp(206) PhysDevExtTermin(206) -PhysDevExtTramp(207) PhysDevExtTermin(207) -PhysDevExtTramp(208) PhysDevExtTermin(208) -PhysDevExtTramp(209) PhysDevExtTermin(209) -PhysDevExtTramp(210) PhysDevExtTermin(210) -PhysDevExtTramp(211) PhysDevExtTermin(211) -PhysDevExtTramp(212) PhysDevExtTermin(212) -PhysDevExtTramp(213) PhysDevExtTermin(213) -PhysDevExtTramp(214) PhysDevExtTermin(214) -PhysDevExtTramp(215) PhysDevExtTermin(215) -PhysDevExtTramp(216) PhysDevExtTermin(216) -PhysDevExtTramp(217) PhysDevExtTermin(217) -PhysDevExtTramp(218) PhysDevExtTermin(218) -PhysDevExtTramp(219) PhysDevExtTermin(219) -PhysDevExtTramp(220) PhysDevExtTermin(220) -PhysDevExtTramp(221) PhysDevExtTermin(221) -PhysDevExtTramp(222) PhysDevExtTermin(222) -PhysDevExtTramp(223) PhysDevExtTermin(223) -PhysDevExtTramp(224) PhysDevExtTermin(224) -PhysDevExtTramp(225) PhysDevExtTermin(225) -PhysDevExtTramp(226) PhysDevExtTermin(226) -PhysDevExtTramp(227) PhysDevExtTermin(227) -PhysDevExtTramp(228) PhysDevExtTermin(228) -PhysDevExtTramp(229) PhysDevExtTermin(229) -PhysDevExtTramp(230) PhysDevExtTermin(230) -PhysDevExtTramp(231) PhysDevExtTermin(231) -PhysDevExtTramp(232) PhysDevExtTermin(232) -PhysDevExtTramp(233) PhysDevExtTermin(233) -PhysDevExtTramp(234) PhysDevExtTermin(234) -PhysDevExtTramp(235) PhysDevExtTermin(235) -PhysDevExtTramp(236) PhysDevExtTermin(236) -PhysDevExtTramp(237) PhysDevExtTermin(237) -PhysDevExtTramp(238) PhysDevExtTermin(238) -PhysDevExtTramp(239) PhysDevExtTermin(239) -PhysDevExtTramp(240) PhysDevExtTermin(240) -PhysDevExtTramp(241) PhysDevExtTermin(241) -PhysDevExtTramp(242) PhysDevExtTermin(242) -PhysDevExtTramp(243) PhysDevExtTermin(243) -PhysDevExtTramp(244) PhysDevExtTermin(244) -PhysDevExtTramp(245) PhysDevExtTermin(245) -PhysDevExtTramp(246) PhysDevExtTermin(246) -PhysDevExtTramp(247) PhysDevExtTermin(247) -PhysDevExtTramp(248) PhysDevExtTermin(248) -PhysDevExtTramp(249) PhysDevExtTermin(249) +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin0(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin1(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin2(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin3(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin4(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin5(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin6(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin7(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin8(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin9(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin10(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin11(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin12(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin13(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin14(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin15(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin16(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin17(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin18(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin19(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin20(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin21(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin22(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin23(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin24(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin25(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin26(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin27(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin28(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin29(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin30(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin31(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin32(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin33(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin34(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin35(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin36(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin37(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin38(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin39(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin40(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin41(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin42(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin43(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin44(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin45(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin46(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin47(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin48(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin49(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin50(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin51(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin52(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin53(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin54(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin55(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin56(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin57(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin58(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin59(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin60(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin61(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin62(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin63(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin64(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin65(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin66(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin67(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin68(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin69(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin70(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin71(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin72(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin73(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin74(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin75(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin76(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin77(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin78(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin79(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin80(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin81(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin82(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin83(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin84(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin85(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin86(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin87(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin88(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin89(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin90(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin91(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin92(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin93(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin94(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin95(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin96(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin97(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin98(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin99(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin100(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin101(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin102(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin103(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin104(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin105(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin106(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin107(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin108(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin109(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin110(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin111(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin112(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin113(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin114(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin115(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin116(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin117(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin118(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin119(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin120(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin121(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin122(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin123(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin124(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin125(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin126(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin127(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin128(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin129(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin130(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin131(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin132(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin133(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin134(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin135(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin136(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin137(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin138(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin139(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin140(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin141(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin142(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin143(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin144(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin145(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin146(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin147(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin148(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin149(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin150(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin151(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin152(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin153(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin154(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin155(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin156(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin157(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin158(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin159(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin160(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin161(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin162(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin163(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin164(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin165(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin166(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin167(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin168(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin169(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin170(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin171(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin172(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin173(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin174(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin175(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin176(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin177(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin178(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin179(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin180(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin181(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin182(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin183(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin184(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin185(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin186(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin187(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin188(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin189(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin190(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin191(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin192(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin193(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin194(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin195(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin196(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin197(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin198(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin199(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin200(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin201(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin202(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin203(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin204(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin205(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin206(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin207(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin208(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin209(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin210(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin211(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin212(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin213(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin214(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin215(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin216(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin217(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin218(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin219(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin220(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin221(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin222(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin223(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin224(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin225(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin226(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin227(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin228(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin229(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin230(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin231(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin232(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin233(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin234(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin235(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin236(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin237(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin238(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin239(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin240(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin241(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin242(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin243(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin244(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin245(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin246(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin247(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin248(VkPhysicalDevice); +VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin249(VkPhysicalDevice); void *loader_get_phys_dev_ext_tramp(uint32_t index) { diff --git a/third_party/vulkan/loader/trampoline.c b/third_party/vulkan/loader/trampoline.c index 6e11476b8..1d6105d95 100644 --- a/third_party/vulkan/loader/trampoline.c +++ b/third_party/vulkan/loader/trampoline.c @@ -122,27 +122,11 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionPropert } loader_layer_scan(NULL, &instance_layers); - if (strcmp(pLayerName, std_validation_str) == 0) { - struct loader_layer_list local_list; - memset(&local_list, 0, sizeof(local_list)); - for (uint32_t i = 0; i < sizeof(std_validation_names) / sizeof(std_validation_names[0]); i++) { - loader_find_layer_name_add_list(NULL, std_validation_names[i], VK_LAYER_TYPE_INSTANCE_EXPLICIT, &instance_layers, - &local_list); - } - for (uint32_t i = 0; i < local_list.count; i++) { - struct loader_extension_list *ext_list = &local_list.list[i].instance_extension_list; - loader_add_to_ext_list(NULL, &local_ext_list, ext_list->count, ext_list->list); - } - loader_destroy_layer_list(NULL, NULL, &local_list); - global_ext_list = &local_ext_list; - - } else { - for (uint32_t i = 0; i < instance_layers.count; i++) { - struct loader_layer_properties *props = &instance_layers.list[i]; - if (strcmp(props->info.layerName, pLayerName) == 0) { - global_ext_list = &props->instance_extension_list; - break; - } + for (uint32_t i = 0; i < instance_layers.count; i++) { + struct loader_layer_properties *props = &instance_layers.list[i]; + if (strcmp(props->info.layerName, pLayerName) == 0) { + global_ext_list = &props->instance_extension_list; + break; } } } else { @@ -243,6 +227,22 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCr loader_platform_thread_once(&once_init, loader_initialize); + // Fail if the requested Vulkan apiVersion is > 1.0 since the loader only supports 1.0. + // Having pCreateInfo == NULL, pCreateInfo->pApplication == NULL, or + // pCreateInfo->pApplicationInfo->apiVersion == 0 all indicate that the application is + // only requesting a 1.0 instance, which this loader will always support. + uint32_t loader_major_version = 1; + uint32_t loader_minor_version = 0; + if (NULL != pCreateInfo && NULL != pCreateInfo->pApplicationInfo && + pCreateInfo->pApplicationInfo->apiVersion >= VK_MAKE_VERSION(loader_major_version, loader_minor_version + 1, 0)) { + loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "vkCreateInstance: Called with invalid API version %d.%d. Loader only supports %d.%d", + VK_VERSION_MAJOR(pCreateInfo->pApplicationInfo->apiVersion), + VK_VERSION_MINOR(pCreateInfo->pApplicationInfo->apiVersion), loader_major_version, loader_minor_version); + res = VK_ERROR_INCOMPATIBLE_DRIVER; + goto out; + } + #if (DEBUG_DISABLE_APP_ALLOCATORS == 1) { #else @@ -306,15 +306,6 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCr } } - // Convert any meta layers to the actual layers makes a copy of layer name - VkResult layerErr = - loader_expand_layer_names(ptr_instance, std_validation_str, sizeof(std_validation_names) / sizeof(std_validation_names[0]), - std_validation_names, &ici.enabledLayerCount, &ici.ppEnabledLayerNames); - if (VK_SUCCESS != layerErr) { - res = layerErr; - goto out; - } - // Scan/discover all ICD libraries memset(&ptr_instance->icd_tramp_list, 0, sizeof(ptr_instance->icd_tramp_list)); res = loader_icd_scan(ptr_instance, &ptr_instance->icd_tramp_list); @@ -332,16 +323,16 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCr goto out; } - ptr_instance->disp = - loader_instance_heap_alloc(ptr_instance, sizeof(VkLayerInstanceDispatchTable), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); + ptr_instance->disp = loader_instance_heap_alloc(ptr_instance, sizeof(struct loader_instance_dispatch_table), + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); if (ptr_instance->disp == NULL) { loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkCreateInstance: Failed to allocate Instance dispatch" - " table."); + "vkCreateInstance: Failed to allocate Loader's full Instance dispatch table."); res = VK_ERROR_OUT_OF_HOST_MEMORY; goto out; } - memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp)); + memcpy(&ptr_instance->disp->layer_inst_disp, &instance_disp, sizeof(instance_disp)); + ptr_instance->next = loader.instances; loader.instances = ptr_instance; @@ -386,9 +377,13 @@ out: util_FreeDebugReportCreateInfos(pAllocator, ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks); } - loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->activated_layer_list); + if (NULL != ptr_instance->expanded_activated_layer_list.list) { + loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->expanded_activated_layer_list); + } + if (NULL != ptr_instance->app_activated_layer_list.list) { + loader_destroy_layer_list(ptr_instance, NULL, &ptr_instance->app_activated_layer_list); + } - loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo, &ici); loader_delete_layer_properties(ptr_instance, &ptr_instance->instance_layer_list); loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_tramp_list); loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&ptr_instance->ext_list); @@ -398,7 +393,6 @@ out: // Remove temporary debug_report callback util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks, ptr_instance->tmp_callbacks); - loader_delete_shadow_inst_layer_names(ptr_instance, pCreateInfo, &ici); } if (loaderLocked) { @@ -438,7 +432,12 @@ LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, disp->DestroyInstance(instance, pAllocator); - loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->activated_layer_list); + if (NULL != ptr_instance->expanded_activated_layer_list.list) { + loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->expanded_activated_layer_list); + } + if (NULL != ptr_instance->app_activated_layer_list.list) { + loader_destroy_layer_list(ptr_instance, NULL, &ptr_instance->app_activated_layer_list); + } if (ptr_instance->phys_devs_tramp) { for (uint32_t i = 0; i < ptr_instance->phys_dev_count_tramp; i++) { @@ -601,7 +600,7 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice phy } // Make sure requested extensions to be enabled are supported - res = loader_validate_device_extensions(phys_dev, &inst->activated_layer_list, &icd_exts, pCreateInfo); + res = loader_validate_device_extensions(phys_dev, &inst->expanded_activated_layer_list, &icd_exts, pCreateInfo); if (res != VK_SUCCESS) { loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice: Failed to validate extensions in list"); goto out; @@ -613,21 +612,47 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice phy goto out; } - // Copy the instance layer list into the device - dev->activated_layer_list.capacity = inst->activated_layer_list.capacity; - dev->activated_layer_list.count = inst->activated_layer_list.count; - dev->activated_layer_list.list = - loader_device_heap_alloc(dev, inst->activated_layer_list.capacity, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); - if (dev->activated_layer_list.list == NULL) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkCreateDevice: Failed to allocate activated layer" - "list of size %d.", - inst->activated_layer_list.capacity); - res = VK_ERROR_OUT_OF_HOST_MEMORY; - goto out; + // Copy the application enabled instance layer list into the device + if (NULL != inst->app_activated_layer_list.list) { + dev->app_activated_layer_list.capacity = inst->app_activated_layer_list.capacity; + dev->app_activated_layer_list.count = inst->app_activated_layer_list.count; + dev->app_activated_layer_list.list = + loader_device_heap_alloc(dev, inst->app_activated_layer_list.capacity, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); + if (dev->app_activated_layer_list.list == NULL) { + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "vkCreateDevice: Failed to allocate application activated layer list of size %d.", + inst->app_activated_layer_list.capacity); + res = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + memcpy(dev->app_activated_layer_list.list, inst->app_activated_layer_list.list, + sizeof(*dev->app_activated_layer_list.list) * dev->app_activated_layer_list.count); + } else { + dev->app_activated_layer_list.capacity = 0; + dev->app_activated_layer_list.count = 0; + dev->app_activated_layer_list.list = NULL; + } + + // Copy the expanded enabled instance layer list into the device + if (NULL != inst->expanded_activated_layer_list.list) { + dev->expanded_activated_layer_list.capacity = inst->expanded_activated_layer_list.capacity; + dev->expanded_activated_layer_list.count = inst->expanded_activated_layer_list.count; + dev->expanded_activated_layer_list.list = + loader_device_heap_alloc(dev, inst->expanded_activated_layer_list.capacity, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); + if (dev->expanded_activated_layer_list.list == NULL) { + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, + "vkCreateDevice: Failed to allocate expanded activated layer list of size %d.", + inst->expanded_activated_layer_list.capacity); + res = VK_ERROR_OUT_OF_HOST_MEMORY; + goto out; + } + memcpy(dev->expanded_activated_layer_list.list, inst->expanded_activated_layer_list.list, + sizeof(*dev->expanded_activated_layer_list.list) * dev->expanded_activated_layer_list.count); + } else { + dev->expanded_activated_layer_list.capacity = 0; + dev->expanded_activated_layer_list.count = 0; + dev->expanded_activated_layer_list.list = NULL; } - memcpy(dev->activated_layer_list.list, inst->activated_layer_list.list, - sizeof(*dev->activated_layer_list.list) * dev->activated_layer_list.count); res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst, dev); if (res != VK_SUCCESS) { @@ -709,28 +734,10 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionPropertie struct loader_device_extension_list local_ext_list; memset(&local_ext_list, 0, sizeof(local_ext_list)); if (vk_string_validate(MaxLoaderStringLength, pLayerName) == VK_STRING_ERROR_NONE) { - if (strcmp(pLayerName, std_validation_str) == 0) { - struct loader_layer_list local_list; - memset(&local_list, 0, sizeof(local_list)); - for (uint32_t i = 0; i < sizeof(std_validation_names) / sizeof(std_validation_names[0]); i++) { - loader_find_layer_name_add_list(NULL, std_validation_names[i], VK_LAYER_TYPE_INSTANCE_EXPLICIT, - &inst->instance_layer_list, &local_list); - } - for (uint32_t i = 0; i < local_list.count; i++) { - struct loader_device_extension_list *ext_list = &local_list.list[i].device_extension_list; - for (uint32_t j = 0; j < ext_list->count; j++) { - loader_add_to_dev_ext_list(NULL, &local_ext_list, &ext_list->list[j].props, 0, NULL); - } - } - loader_destroy_layer_list(NULL, NULL, &local_list); - dev_ext_list = &local_ext_list; - - } else { - for (uint32_t i = 0; i < inst->instance_layer_list.count; i++) { - struct loader_layer_properties *props = &inst->instance_layer_list.list[i]; - if (strcmp(props->info.layerName, pLayerName) == 0) { - dev_ext_list = &props->device_extension_list; - } + for (uint32_t i = 0; i < inst->instance_layer_list.count; i++) { + struct loader_layer_properties *props = &inst->instance_layer_list.list[i]; + if (strcmp(props->info.layerName, pLayerName) == 0) { + dev_ext_list = &props->device_extension_list; } } @@ -772,7 +779,6 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(Vk uint32_t copy_size; struct loader_physical_device_tramp *phys_dev; struct loader_layer_list *enabled_layers, layers_list; - uint32_t std_val_count = sizeof(std_validation_names) / sizeof(std_validation_names[0]); memset(&layers_list, 0, sizeof(layers_list)); loader_platform_thread_lock_mutex(&loader_lock); @@ -784,49 +790,13 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(Vk phys_dev = (struct loader_physical_device_tramp *)physicalDevice; const struct loader_instance *inst = phys_dev->this_instance; - uint32_t count = inst->activated_layer_list.count; - if (inst->activated_layers_are_std_val) count = count - std_val_count + 1; - if (pProperties == NULL) { + uint32_t count = inst->app_activated_layer_list.count; + if (count == 0 || pProperties == NULL) { *pPropertyCount = count; loader_platform_thread_unlock_mutex(&loader_lock); return VK_SUCCESS; } - // Make sure to enumerate standard_validation if that is what was used - // at the instance layer enablement - if (inst->activated_layers_are_std_val) { - enabled_layers = &layers_list; - enabled_layers->count = count; - enabled_layers->capacity = enabled_layers->count * sizeof(struct loader_layer_properties); - enabled_layers->list = loader_instance_heap_alloc(inst, enabled_layers->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); - if (!enabled_layers->list) { - loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "vkEnumerateDeviceLayerProperties: Failed to allocate enabled" - "layer list of size %d", - enabled_layers->capacity); - return VK_ERROR_OUT_OF_HOST_MEMORY; - } - - uint32_t j = 0; - for (uint32_t i = 0; i < inst->activated_layer_list.count; j++) { - if (loader_find_layer_name_array(inst->activated_layer_list.list[i].info.layerName, std_val_count, - std_validation_names)) { - struct loader_layer_properties props; - loader_init_std_validation_props(&props); - VkResult err = loader_copy_layer_properties(inst, &enabled_layers->list[j], &props); - if (err != VK_SUCCESS) { - return err; - } - i += std_val_count; - } else { - VkResult err = loader_copy_layer_properties(inst, &enabled_layers->list[j], &inst->activated_layer_list.list[i++]); - if (err != VK_SUCCESS) { - return err; - } - } - } - } else { - enabled_layers = (struct loader_layer_list *)&inst->activated_layer_list; - } + enabled_layers = (struct loader_layer_list *)&inst->app_activated_layer_list; copy_size = (*pPropertyCount < count) ? *pPropertyCount : count; for (uint32_t i = 0; i < copy_size; i++) { @@ -834,9 +804,6 @@ LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(Vk } *pPropertyCount = copy_size; - if (inst->activated_layers_are_std_val) { - loader_delete_layer_properties(inst, enabled_layers); - } if (copy_size < count) { loader_platform_thread_unlock_mutex(&loader_lock); return VK_INCOMPLETE; diff --git a/third_party/vulkan/loader/unknown_ext_chain.c b/third_party/vulkan/loader/unknown_ext_chain.c new file mode 100644 index 000000000..1c8560dd6 --- /dev/null +++ b/third_party/vulkan/loader/unknown_ext_chain.c @@ -0,0 +1,819 @@ +/* + * Copyright (c) 2017 The Khronos Group Inc. + * Copyright (c) 2017 Valve Corporation + * Copyright (c) 2017 LunarG, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * Author Jon Ashburn + * Author: Lenny Komow + */ + + // This code is used to pass on physical device extensions through the call chain. It must do this without creating a stack frame, + // because the actual parameters of the call are not known. Since the first parameter is known to be a VkPhysicalDevice, it can +// unwrap the physical device, overwriting the wrapped device, and then jump to the next function in the call chain. This code +// attempts to accomplish this by relying on tail-call optimizations, but there is no guarantee that this will work. As a result, +// this code is only compiled on systems where an assembly alternative has not been written. + + #include "vk_loader_platform.h" + #include "loader.h" + + #if defined(__GNUC__) && !defined(__clang__) + #pragma GCC optimize(3) // force gcc to use tail-calls + #endif + + // Trampoline function macro for unknown physical device extension command. + #define PhysDevExtTramp(num) \ + VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp##num(VkPhysicalDevice physical_device) { \ + const struct loader_instance_dispatch_table *disp; \ + disp = loader_get_instance_dispatch(physical_device); \ + disp->phys_dev_ext[num](loader_unwrap_physical_device(physical_device)); \ + } + +// Terminator function macro for unknown physical device extension command. +#define PhysDevExtTermin(num) \ + VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin##num(VkPhysicalDevice physical_device) { \ + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physical_device; \ + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; \ + struct loader_instance *inst = (struct loader_instance *)icd_term->this_instance; \ + if (NULL == icd_term->phys_dev_ext[num]) { \ + loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "Extension %s not supported for this physical device", \ + inst->phys_dev_ext_disp_hash[num].func_name); \ + } \ + icd_term->phys_dev_ext[num](phys_dev_term->phys_dev); \ + } + +// Trampoline function macro for unknown physical device extension command. +#define DevExtTramp(num) \ + VKAPI_ATTR void VKAPI_CALL vkdev_ext##num(VkDevice device) { \ + const struct loader_dev_dispatch_table *disp; \ + disp = loader_get_dev_dispatch(device); \ + disp->ext_dispatch.dev_ext[num](device); \ + } + + +// Instantiations of the trampoline +PhysDevExtTramp(0) +PhysDevExtTramp(1) +PhysDevExtTramp(2) +PhysDevExtTramp(3) +PhysDevExtTramp(4) +PhysDevExtTramp(5) +PhysDevExtTramp(6) +PhysDevExtTramp(7) +PhysDevExtTramp(8) +PhysDevExtTramp(9) +PhysDevExtTramp(10) +PhysDevExtTramp(11) +PhysDevExtTramp(12) +PhysDevExtTramp(13) +PhysDevExtTramp(14) +PhysDevExtTramp(15) +PhysDevExtTramp(16) +PhysDevExtTramp(17) +PhysDevExtTramp(18) +PhysDevExtTramp(19) +PhysDevExtTramp(20) +PhysDevExtTramp(21) +PhysDevExtTramp(22) +PhysDevExtTramp(23) +PhysDevExtTramp(24) +PhysDevExtTramp(25) +PhysDevExtTramp(26) +PhysDevExtTramp(27) +PhysDevExtTramp(28) +PhysDevExtTramp(29) +PhysDevExtTramp(30) +PhysDevExtTramp(31) +PhysDevExtTramp(32) +PhysDevExtTramp(33) +PhysDevExtTramp(34) +PhysDevExtTramp(35) +PhysDevExtTramp(36) +PhysDevExtTramp(37) +PhysDevExtTramp(38) +PhysDevExtTramp(39) +PhysDevExtTramp(40) +PhysDevExtTramp(41) +PhysDevExtTramp(42) +PhysDevExtTramp(43) +PhysDevExtTramp(44) +PhysDevExtTramp(45) +PhysDevExtTramp(46) +PhysDevExtTramp(47) +PhysDevExtTramp(48) +PhysDevExtTramp(49) +PhysDevExtTramp(50) +PhysDevExtTramp(51) +PhysDevExtTramp(52) +PhysDevExtTramp(53) +PhysDevExtTramp(54) +PhysDevExtTramp(55) +PhysDevExtTramp(56) +PhysDevExtTramp(57) +PhysDevExtTramp(58) +PhysDevExtTramp(59) +PhysDevExtTramp(60) +PhysDevExtTramp(61) +PhysDevExtTramp(62) +PhysDevExtTramp(63) +PhysDevExtTramp(64) +PhysDevExtTramp(65) +PhysDevExtTramp(66) +PhysDevExtTramp(67) +PhysDevExtTramp(68) +PhysDevExtTramp(69) +PhysDevExtTramp(70) +PhysDevExtTramp(71) +PhysDevExtTramp(72) +PhysDevExtTramp(73) +PhysDevExtTramp(74) +PhysDevExtTramp(75) +PhysDevExtTramp(76) +PhysDevExtTramp(77) +PhysDevExtTramp(78) +PhysDevExtTramp(79) +PhysDevExtTramp(80) +PhysDevExtTramp(81) +PhysDevExtTramp(82) +PhysDevExtTramp(83) +PhysDevExtTramp(84) +PhysDevExtTramp(85) +PhysDevExtTramp(86) +PhysDevExtTramp(87) +PhysDevExtTramp(88) +PhysDevExtTramp(89) +PhysDevExtTramp(90) +PhysDevExtTramp(91) +PhysDevExtTramp(92) +PhysDevExtTramp(93) +PhysDevExtTramp(94) +PhysDevExtTramp(95) +PhysDevExtTramp(96) +PhysDevExtTramp(97) +PhysDevExtTramp(98) +PhysDevExtTramp(99) +PhysDevExtTramp(100) +PhysDevExtTramp(101) +PhysDevExtTramp(102) +PhysDevExtTramp(103) +PhysDevExtTramp(104) +PhysDevExtTramp(105) +PhysDevExtTramp(106) +PhysDevExtTramp(107) +PhysDevExtTramp(108) +PhysDevExtTramp(109) +PhysDevExtTramp(110) +PhysDevExtTramp(111) +PhysDevExtTramp(112) +PhysDevExtTramp(113) +PhysDevExtTramp(114) +PhysDevExtTramp(115) +PhysDevExtTramp(116) +PhysDevExtTramp(117) +PhysDevExtTramp(118) +PhysDevExtTramp(119) +PhysDevExtTramp(120) +PhysDevExtTramp(121) +PhysDevExtTramp(122) +PhysDevExtTramp(123) +PhysDevExtTramp(124) +PhysDevExtTramp(125) +PhysDevExtTramp(126) +PhysDevExtTramp(127) +PhysDevExtTramp(128) +PhysDevExtTramp(129) +PhysDevExtTramp(130) +PhysDevExtTramp(131) +PhysDevExtTramp(132) +PhysDevExtTramp(133) +PhysDevExtTramp(134) +PhysDevExtTramp(135) +PhysDevExtTramp(136) +PhysDevExtTramp(137) +PhysDevExtTramp(138) +PhysDevExtTramp(139) +PhysDevExtTramp(140) +PhysDevExtTramp(141) +PhysDevExtTramp(142) +PhysDevExtTramp(143) +PhysDevExtTramp(144) +PhysDevExtTramp(145) +PhysDevExtTramp(146) +PhysDevExtTramp(147) +PhysDevExtTramp(148) +PhysDevExtTramp(149) +PhysDevExtTramp(150) +PhysDevExtTramp(151) +PhysDevExtTramp(152) +PhysDevExtTramp(153) +PhysDevExtTramp(154) +PhysDevExtTramp(155) +PhysDevExtTramp(156) +PhysDevExtTramp(157) +PhysDevExtTramp(158) +PhysDevExtTramp(159) +PhysDevExtTramp(160) +PhysDevExtTramp(161) +PhysDevExtTramp(162) +PhysDevExtTramp(163) +PhysDevExtTramp(164) +PhysDevExtTramp(165) +PhysDevExtTramp(166) +PhysDevExtTramp(167) +PhysDevExtTramp(168) +PhysDevExtTramp(169) +PhysDevExtTramp(170) +PhysDevExtTramp(171) +PhysDevExtTramp(172) +PhysDevExtTramp(173) +PhysDevExtTramp(174) +PhysDevExtTramp(175) +PhysDevExtTramp(176) +PhysDevExtTramp(177) +PhysDevExtTramp(178) +PhysDevExtTramp(179) +PhysDevExtTramp(180) +PhysDevExtTramp(181) +PhysDevExtTramp(182) +PhysDevExtTramp(183) +PhysDevExtTramp(184) +PhysDevExtTramp(185) +PhysDevExtTramp(186) +PhysDevExtTramp(187) +PhysDevExtTramp(188) +PhysDevExtTramp(189) +PhysDevExtTramp(190) +PhysDevExtTramp(191) +PhysDevExtTramp(192) +PhysDevExtTramp(193) +PhysDevExtTramp(194) +PhysDevExtTramp(195) +PhysDevExtTramp(196) +PhysDevExtTramp(197) +PhysDevExtTramp(198) +PhysDevExtTramp(199) +PhysDevExtTramp(200) +PhysDevExtTramp(201) +PhysDevExtTramp(202) +PhysDevExtTramp(203) +PhysDevExtTramp(204) +PhysDevExtTramp(205) +PhysDevExtTramp(206) +PhysDevExtTramp(207) +PhysDevExtTramp(208) +PhysDevExtTramp(209) +PhysDevExtTramp(210) +PhysDevExtTramp(211) +PhysDevExtTramp(212) +PhysDevExtTramp(213) +PhysDevExtTramp(214) +PhysDevExtTramp(215) +PhysDevExtTramp(216) +PhysDevExtTramp(217) +PhysDevExtTramp(218) +PhysDevExtTramp(219) +PhysDevExtTramp(220) +PhysDevExtTramp(221) +PhysDevExtTramp(222) +PhysDevExtTramp(223) +PhysDevExtTramp(224) +PhysDevExtTramp(225) +PhysDevExtTramp(226) +PhysDevExtTramp(227) +PhysDevExtTramp(228) +PhysDevExtTramp(229) +PhysDevExtTramp(230) +PhysDevExtTramp(231) +PhysDevExtTramp(232) +PhysDevExtTramp(233) +PhysDevExtTramp(234) +PhysDevExtTramp(235) +PhysDevExtTramp(236) +PhysDevExtTramp(237) +PhysDevExtTramp(238) +PhysDevExtTramp(239) +PhysDevExtTramp(240) +PhysDevExtTramp(241) +PhysDevExtTramp(242) +PhysDevExtTramp(243) +PhysDevExtTramp(244) +PhysDevExtTramp(245) +PhysDevExtTramp(246) +PhysDevExtTramp(247) +PhysDevExtTramp(248) +PhysDevExtTramp(249) + +// Instantiations of the terminator +PhysDevExtTermin(0) +PhysDevExtTermin(1) +PhysDevExtTermin(2) +PhysDevExtTermin(3) +PhysDevExtTermin(4) +PhysDevExtTermin(5) +PhysDevExtTermin(6) +PhysDevExtTermin(7) +PhysDevExtTermin(8) +PhysDevExtTermin(9) +PhysDevExtTermin(10) +PhysDevExtTermin(11) +PhysDevExtTermin(12) +PhysDevExtTermin(13) +PhysDevExtTermin(14) +PhysDevExtTermin(15) +PhysDevExtTermin(16) +PhysDevExtTermin(17) +PhysDevExtTermin(18) +PhysDevExtTermin(19) +PhysDevExtTermin(20) +PhysDevExtTermin(21) +PhysDevExtTermin(22) +PhysDevExtTermin(23) +PhysDevExtTermin(24) +PhysDevExtTermin(25) +PhysDevExtTermin(26) +PhysDevExtTermin(27) +PhysDevExtTermin(28) +PhysDevExtTermin(29) +PhysDevExtTermin(30) +PhysDevExtTermin(31) +PhysDevExtTermin(32) +PhysDevExtTermin(33) +PhysDevExtTermin(34) +PhysDevExtTermin(35) +PhysDevExtTermin(36) +PhysDevExtTermin(37) +PhysDevExtTermin(38) +PhysDevExtTermin(39) +PhysDevExtTermin(40) +PhysDevExtTermin(41) +PhysDevExtTermin(42) +PhysDevExtTermin(43) +PhysDevExtTermin(44) +PhysDevExtTermin(45) +PhysDevExtTermin(46) +PhysDevExtTermin(47) +PhysDevExtTermin(48) +PhysDevExtTermin(49) +PhysDevExtTermin(50) +PhysDevExtTermin(51) +PhysDevExtTermin(52) +PhysDevExtTermin(53) +PhysDevExtTermin(54) +PhysDevExtTermin(55) +PhysDevExtTermin(56) +PhysDevExtTermin(57) +PhysDevExtTermin(58) +PhysDevExtTermin(59) +PhysDevExtTermin(60) +PhysDevExtTermin(61) +PhysDevExtTermin(62) +PhysDevExtTermin(63) +PhysDevExtTermin(64) +PhysDevExtTermin(65) +PhysDevExtTermin(66) +PhysDevExtTermin(67) +PhysDevExtTermin(68) +PhysDevExtTermin(69) +PhysDevExtTermin(70) +PhysDevExtTermin(71) +PhysDevExtTermin(72) +PhysDevExtTermin(73) +PhysDevExtTermin(74) +PhysDevExtTermin(75) +PhysDevExtTermin(76) +PhysDevExtTermin(77) +PhysDevExtTermin(78) +PhysDevExtTermin(79) +PhysDevExtTermin(80) +PhysDevExtTermin(81) +PhysDevExtTermin(82) +PhysDevExtTermin(83) +PhysDevExtTermin(84) +PhysDevExtTermin(85) +PhysDevExtTermin(86) +PhysDevExtTermin(87) +PhysDevExtTermin(88) +PhysDevExtTermin(89) +PhysDevExtTermin(90) +PhysDevExtTermin(91) +PhysDevExtTermin(92) +PhysDevExtTermin(93) +PhysDevExtTermin(94) +PhysDevExtTermin(95) +PhysDevExtTermin(96) +PhysDevExtTermin(97) +PhysDevExtTermin(98) +PhysDevExtTermin(99) +PhysDevExtTermin(100) +PhysDevExtTermin(101) +PhysDevExtTermin(102) +PhysDevExtTermin(103) +PhysDevExtTermin(104) +PhysDevExtTermin(105) +PhysDevExtTermin(106) +PhysDevExtTermin(107) +PhysDevExtTermin(108) +PhysDevExtTermin(109) +PhysDevExtTermin(110) +PhysDevExtTermin(111) +PhysDevExtTermin(112) +PhysDevExtTermin(113) +PhysDevExtTermin(114) +PhysDevExtTermin(115) +PhysDevExtTermin(116) +PhysDevExtTermin(117) +PhysDevExtTermin(118) +PhysDevExtTermin(119) +PhysDevExtTermin(120) +PhysDevExtTermin(121) +PhysDevExtTermin(122) +PhysDevExtTermin(123) +PhysDevExtTermin(124) +PhysDevExtTermin(125) +PhysDevExtTermin(126) +PhysDevExtTermin(127) +PhysDevExtTermin(128) +PhysDevExtTermin(129) +PhysDevExtTermin(130) +PhysDevExtTermin(131) +PhysDevExtTermin(132) +PhysDevExtTermin(133) +PhysDevExtTermin(134) +PhysDevExtTermin(135) +PhysDevExtTermin(136) +PhysDevExtTermin(137) +PhysDevExtTermin(138) +PhysDevExtTermin(139) +PhysDevExtTermin(140) +PhysDevExtTermin(141) +PhysDevExtTermin(142) +PhysDevExtTermin(143) +PhysDevExtTermin(144) +PhysDevExtTermin(145) +PhysDevExtTermin(146) +PhysDevExtTermin(147) +PhysDevExtTermin(148) +PhysDevExtTermin(149) +PhysDevExtTermin(150) +PhysDevExtTermin(151) +PhysDevExtTermin(152) +PhysDevExtTermin(153) +PhysDevExtTermin(154) +PhysDevExtTermin(155) +PhysDevExtTermin(156) +PhysDevExtTermin(157) +PhysDevExtTermin(158) +PhysDevExtTermin(159) +PhysDevExtTermin(160) +PhysDevExtTermin(161) +PhysDevExtTermin(162) +PhysDevExtTermin(163) +PhysDevExtTermin(164) +PhysDevExtTermin(165) +PhysDevExtTermin(166) +PhysDevExtTermin(167) +PhysDevExtTermin(168) +PhysDevExtTermin(169) +PhysDevExtTermin(170) +PhysDevExtTermin(171) +PhysDevExtTermin(172) +PhysDevExtTermin(173) +PhysDevExtTermin(174) +PhysDevExtTermin(175) +PhysDevExtTermin(176) +PhysDevExtTermin(177) +PhysDevExtTermin(178) +PhysDevExtTermin(179) +PhysDevExtTermin(180) +PhysDevExtTermin(181) +PhysDevExtTermin(182) +PhysDevExtTermin(183) +PhysDevExtTermin(184) +PhysDevExtTermin(185) +PhysDevExtTermin(186) +PhysDevExtTermin(187) +PhysDevExtTermin(188) +PhysDevExtTermin(189) +PhysDevExtTermin(190) +PhysDevExtTermin(191) +PhysDevExtTermin(192) +PhysDevExtTermin(193) +PhysDevExtTermin(194) +PhysDevExtTermin(195) +PhysDevExtTermin(196) +PhysDevExtTermin(197) +PhysDevExtTermin(198) +PhysDevExtTermin(199) +PhysDevExtTermin(200) +PhysDevExtTermin(201) +PhysDevExtTermin(202) +PhysDevExtTermin(203) +PhysDevExtTermin(204) +PhysDevExtTermin(205) +PhysDevExtTermin(206) +PhysDevExtTermin(207) +PhysDevExtTermin(208) +PhysDevExtTermin(209) +PhysDevExtTermin(210) +PhysDevExtTermin(211) +PhysDevExtTermin(212) +PhysDevExtTermin(213) +PhysDevExtTermin(214) +PhysDevExtTermin(215) +PhysDevExtTermin(216) +PhysDevExtTermin(217) +PhysDevExtTermin(218) +PhysDevExtTermin(219) +PhysDevExtTermin(220) +PhysDevExtTermin(221) +PhysDevExtTermin(222) +PhysDevExtTermin(223) +PhysDevExtTermin(224) +PhysDevExtTermin(225) +PhysDevExtTermin(226) +PhysDevExtTermin(227) +PhysDevExtTermin(228) +PhysDevExtTermin(229) +PhysDevExtTermin(230) +PhysDevExtTermin(231) +PhysDevExtTermin(232) +PhysDevExtTermin(233) +PhysDevExtTermin(234) +PhysDevExtTermin(235) +PhysDevExtTermin(236) +PhysDevExtTermin(237) +PhysDevExtTermin(238) +PhysDevExtTermin(239) +PhysDevExtTermin(240) +PhysDevExtTermin(241) +PhysDevExtTermin(242) +PhysDevExtTermin(243) +PhysDevExtTermin(244) +PhysDevExtTermin(245) +PhysDevExtTermin(246) +PhysDevExtTermin(247) +PhysDevExtTermin(248) +PhysDevExtTermin(249) + +// Instantiations of the device trampoline +DevExtTramp(0) +DevExtTramp(1) +DevExtTramp(2) +DevExtTramp(3) +DevExtTramp(4) +DevExtTramp(5) +DevExtTramp(6) +DevExtTramp(7) +DevExtTramp(8) +DevExtTramp(9) +DevExtTramp(10) +DevExtTramp(11) +DevExtTramp(12) +DevExtTramp(13) +DevExtTramp(14) +DevExtTramp(15) +DevExtTramp(16) +DevExtTramp(17) +DevExtTramp(18) +DevExtTramp(19) +DevExtTramp(20) +DevExtTramp(21) +DevExtTramp(22) +DevExtTramp(23) +DevExtTramp(24) +DevExtTramp(25) +DevExtTramp(26) +DevExtTramp(27) +DevExtTramp(28) +DevExtTramp(29) +DevExtTramp(30) +DevExtTramp(31) +DevExtTramp(32) +DevExtTramp(33) +DevExtTramp(34) +DevExtTramp(35) +DevExtTramp(36) +DevExtTramp(37) +DevExtTramp(38) +DevExtTramp(39) +DevExtTramp(40) +DevExtTramp(41) +DevExtTramp(42) +DevExtTramp(43) +DevExtTramp(44) +DevExtTramp(45) +DevExtTramp(46) +DevExtTramp(47) +DevExtTramp(48) +DevExtTramp(49) +DevExtTramp(50) +DevExtTramp(51) +DevExtTramp(52) +DevExtTramp(53) +DevExtTramp(54) +DevExtTramp(55) +DevExtTramp(56) +DevExtTramp(57) +DevExtTramp(58) +DevExtTramp(59) +DevExtTramp(60) +DevExtTramp(61) +DevExtTramp(62) +DevExtTramp(63) +DevExtTramp(64) +DevExtTramp(65) +DevExtTramp(66) +DevExtTramp(67) +DevExtTramp(68) +DevExtTramp(69) +DevExtTramp(70) +DevExtTramp(71) +DevExtTramp(72) +DevExtTramp(73) +DevExtTramp(74) +DevExtTramp(75) +DevExtTramp(76) +DevExtTramp(77) +DevExtTramp(78) +DevExtTramp(79) +DevExtTramp(80) +DevExtTramp(81) +DevExtTramp(82) +DevExtTramp(83) +DevExtTramp(84) +DevExtTramp(85) +DevExtTramp(86) +DevExtTramp(87) +DevExtTramp(88) +DevExtTramp(89) +DevExtTramp(90) +DevExtTramp(91) +DevExtTramp(92) +DevExtTramp(93) +DevExtTramp(94) +DevExtTramp(95) +DevExtTramp(96) +DevExtTramp(97) +DevExtTramp(98) +DevExtTramp(99) +DevExtTramp(100) +DevExtTramp(101) +DevExtTramp(102) +DevExtTramp(103) +DevExtTramp(104) +DevExtTramp(105) +DevExtTramp(106) +DevExtTramp(107) +DevExtTramp(108) +DevExtTramp(109) +DevExtTramp(110) +DevExtTramp(111) +DevExtTramp(112) +DevExtTramp(113) +DevExtTramp(114) +DevExtTramp(115) +DevExtTramp(116) +DevExtTramp(117) +DevExtTramp(118) +DevExtTramp(119) +DevExtTramp(120) +DevExtTramp(121) +DevExtTramp(122) +DevExtTramp(123) +DevExtTramp(124) +DevExtTramp(125) +DevExtTramp(126) +DevExtTramp(127) +DevExtTramp(128) +DevExtTramp(129) +DevExtTramp(130) +DevExtTramp(131) +DevExtTramp(132) +DevExtTramp(133) +DevExtTramp(134) +DevExtTramp(135) +DevExtTramp(136) +DevExtTramp(137) +DevExtTramp(138) +DevExtTramp(139) +DevExtTramp(140) +DevExtTramp(141) +DevExtTramp(142) +DevExtTramp(143) +DevExtTramp(144) +DevExtTramp(145) +DevExtTramp(146) +DevExtTramp(147) +DevExtTramp(148) +DevExtTramp(149) +DevExtTramp(150) +DevExtTramp(151) +DevExtTramp(152) +DevExtTramp(153) +DevExtTramp(154) +DevExtTramp(155) +DevExtTramp(156) +DevExtTramp(157) +DevExtTramp(158) +DevExtTramp(159) +DevExtTramp(160) +DevExtTramp(161) +DevExtTramp(162) +DevExtTramp(163) +DevExtTramp(164) +DevExtTramp(165) +DevExtTramp(166) +DevExtTramp(167) +DevExtTramp(168) +DevExtTramp(169) +DevExtTramp(170) +DevExtTramp(171) +DevExtTramp(172) +DevExtTramp(173) +DevExtTramp(174) +DevExtTramp(175) +DevExtTramp(176) +DevExtTramp(177) +DevExtTramp(178) +DevExtTramp(179) +DevExtTramp(180) +DevExtTramp(181) +DevExtTramp(182) +DevExtTramp(183) +DevExtTramp(184) +DevExtTramp(185) +DevExtTramp(186) +DevExtTramp(187) +DevExtTramp(188) +DevExtTramp(189) +DevExtTramp(190) +DevExtTramp(191) +DevExtTramp(192) +DevExtTramp(193) +DevExtTramp(194) +DevExtTramp(195) +DevExtTramp(196) +DevExtTramp(197) +DevExtTramp(198) +DevExtTramp(199) +DevExtTramp(200) +DevExtTramp(201) +DevExtTramp(202) +DevExtTramp(203) +DevExtTramp(204) +DevExtTramp(205) +DevExtTramp(206) +DevExtTramp(207) +DevExtTramp(208) +DevExtTramp(209) +DevExtTramp(210) +DevExtTramp(211) +DevExtTramp(212) +DevExtTramp(213) +DevExtTramp(214) +DevExtTramp(215) +DevExtTramp(216) +DevExtTramp(217) +DevExtTramp(218) +DevExtTramp(219) +DevExtTramp(220) +DevExtTramp(221) +DevExtTramp(222) +DevExtTramp(223) +DevExtTramp(224) +DevExtTramp(225) +DevExtTramp(226) +DevExtTramp(227) +DevExtTramp(228) +DevExtTramp(229) +DevExtTramp(230) +DevExtTramp(231) +DevExtTramp(232) +DevExtTramp(233) +DevExtTramp(234) +DevExtTramp(235) +DevExtTramp(236) +DevExtTramp(237) +DevExtTramp(238) +DevExtTramp(239) +DevExtTramp(240) +DevExtTramp(241) +DevExtTramp(242) +DevExtTramp(243) +DevExtTramp(244) +DevExtTramp(245) +DevExtTramp(246) +DevExtTramp(247) +DevExtTramp(248) +DevExtTramp(249) diff --git a/third_party/vulkan/loader/vk_loader_extensions.c b/third_party/vulkan/loader/vk_loader_extensions.c index 3db1faae8..2c257d6a1 100644 --- a/third_party/vulkan/loader/vk_loader_extensions.c +++ b/third_party/vulkan/loader/vk_loader_extensions.c @@ -151,6 +151,19 @@ VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_t LOOKUP_GIPA(GetPhysicalDeviceMemoryProperties2KHR, false); LOOKUP_GIPA(GetPhysicalDeviceSparseImageFormatProperties2KHR, false); + // ---- VK_KHR_external_memory_capabilities extension commands + LOOKUP_GIPA(GetPhysicalDeviceExternalBufferPropertiesKHR, false); + + // ---- VK_KHR_external_semaphore_capabilities extension commands + LOOKUP_GIPA(GetPhysicalDeviceExternalSemaphorePropertiesKHR, false); + + // ---- VK_KHR_external_fence_capabilities extension commands + LOOKUP_GIPA(GetPhysicalDeviceExternalFencePropertiesKHR, false); + + // ---- VK_KHR_get_surface_capabilities2 extension commands + LOOKUP_GIPA(GetPhysicalDeviceSurfaceCapabilities2KHR, false); + LOOKUP_GIPA(GetPhysicalDeviceSurfaceFormats2KHR, false); + // ---- VK_EXT_debug_report extension commands LOOKUP_GIPA(CreateDebugReportCallbackEXT, false); LOOKUP_GIPA(DestroyDebugReportCallbackEXT, false); @@ -175,12 +188,6 @@ VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_t // ---- VK_KHX_device_group_creation extension commands LOOKUP_GIPA(EnumeratePhysicalDeviceGroupsKHX, false); - // ---- VK_KHX_external_memory_capabilities extension commands - LOOKUP_GIPA(GetPhysicalDeviceExternalBufferPropertiesKHX, false); - - // ---- VK_KHX_external_semaphore_capabilities extension commands - LOOKUP_GIPA(GetPhysicalDeviceExternalSemaphorePropertiesKHX, false); - // ---- VK_NVX_device_generated_commands extension commands LOOKUP_GIPA(GetPhysicalDeviceGeneratedCommandsPropertiesNVX, false); @@ -219,9 +226,8 @@ VKAPI_ATTR void VKAPI_CALL loader_init_device_dispatch_table(struct loader_dev_d VkLayerDispatchTable *table = &dev_table->core_dispatch; for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) dev_table->ext_dispatch.dev_ext[i] = (PFN_vkDevExt)vkDevExtError; - // ---- Core 1_0 commands - table->GetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)gpa(dev, "vkGetDeviceProcAddr"); + table->GetDeviceProcAddr = gpa; table->DestroyDevice = (PFN_vkDestroyDevice)gpa(dev, "vkDestroyDevice"); table->GetDeviceQueue = (PFN_vkGetDeviceQueue)gpa(dev, "vkGetDeviceQueue"); table->QueueSubmit = (PFN_vkQueueSubmit)gpa(dev, "vkQueueSubmit"); @@ -349,7 +355,6 @@ VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct lo PFN_vkGetDeviceProcAddr gpa, VkDevice dev) { VkLayerDispatchTable *table = &dev_table->core_dispatch; - // ---- VK_KHR_swapchain extension commands table->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)gpa(dev, "vkCreateSwapchainKHR"); table->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR)gpa(dev, "vkDestroySwapchainKHR"); @@ -363,6 +368,30 @@ VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct lo // ---- VK_KHR_maintenance1 extension commands table->TrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR)gpa(dev, "vkTrimCommandPoolKHR"); + // ---- VK_KHR_external_memory_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + table->GetMemoryWin32HandleKHR = (PFN_vkGetMemoryWin32HandleKHR)gpa(dev, "vkGetMemoryWin32HandleKHR"); +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + table->GetMemoryWin32HandlePropertiesKHR = (PFN_vkGetMemoryWin32HandlePropertiesKHR)gpa(dev, "vkGetMemoryWin32HandlePropertiesKHR"); +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_memory_fd extension commands + table->GetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)gpa(dev, "vkGetMemoryFdKHR"); + table->GetMemoryFdPropertiesKHR = (PFN_vkGetMemoryFdPropertiesKHR)gpa(dev, "vkGetMemoryFdPropertiesKHR"); + + // ---- VK_KHR_external_semaphore_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + table->ImportSemaphoreWin32HandleKHR = (PFN_vkImportSemaphoreWin32HandleKHR)gpa(dev, "vkImportSemaphoreWin32HandleKHR"); +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + table->GetSemaphoreWin32HandleKHR = (PFN_vkGetSemaphoreWin32HandleKHR)gpa(dev, "vkGetSemaphoreWin32HandleKHR"); +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_semaphore_fd extension commands + table->ImportSemaphoreFdKHR = (PFN_vkImportSemaphoreFdKHR)gpa(dev, "vkImportSemaphoreFdKHR"); + table->GetSemaphoreFdKHR = (PFN_vkGetSemaphoreFdKHR)gpa(dev, "vkGetSemaphoreFdKHR"); + // ---- VK_KHR_push_descriptor extension commands table->CmdPushDescriptorSetKHR = (PFN_vkCmdPushDescriptorSetKHR)gpa(dev, "vkCmdPushDescriptorSetKHR"); @@ -372,6 +401,26 @@ VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct lo table->UpdateDescriptorSetWithTemplateKHR = (PFN_vkUpdateDescriptorSetWithTemplateKHR)gpa(dev, "vkUpdateDescriptorSetWithTemplateKHR"); table->CmdPushDescriptorSetWithTemplateKHR = (PFN_vkCmdPushDescriptorSetWithTemplateKHR)gpa(dev, "vkCmdPushDescriptorSetWithTemplateKHR"); + // ---- VK_KHR_shared_presentable_image extension commands + table->GetSwapchainStatusKHR = (PFN_vkGetSwapchainStatusKHR)gpa(dev, "vkGetSwapchainStatusKHR"); + + // ---- VK_KHR_external_fence_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + table->ImportFenceWin32HandleKHR = (PFN_vkImportFenceWin32HandleKHR)gpa(dev, "vkImportFenceWin32HandleKHR"); +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + table->GetFenceWin32HandleKHR = (PFN_vkGetFenceWin32HandleKHR)gpa(dev, "vkGetFenceWin32HandleKHR"); +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_fence_fd extension commands + table->ImportFenceFdKHR = (PFN_vkImportFenceFdKHR)gpa(dev, "vkImportFenceFdKHR"); + table->GetFenceFdKHR = (PFN_vkGetFenceFdKHR)gpa(dev, "vkGetFenceFdKHR"); + + // ---- VK_KHR_get_memory_requirements2 extension commands + table->GetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2KHR)gpa(dev, "vkGetImageMemoryRequirements2KHR"); + table->GetBufferMemoryRequirements2KHR = (PFN_vkGetBufferMemoryRequirements2KHR)gpa(dev, "vkGetBufferMemoryRequirements2KHR"); + table->GetImageSparseMemoryRequirements2KHR = (PFN_vkGetImageSparseMemoryRequirements2KHR)gpa(dev, "vkGetImageSparseMemoryRequirements2KHR"); + // ---- VK_EXT_debug_marker extension commands table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)gpa(dev, "vkDebugMarkerSetObjectTagEXT"); table->DebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)gpa(dev, "vkDebugMarkerSetObjectNameEXT"); @@ -398,30 +447,6 @@ VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct lo table->AcquireNextImage2KHX = (PFN_vkAcquireNextImage2KHX)gpa(dev, "vkAcquireNextImage2KHX"); table->CmdDispatchBaseKHX = (PFN_vkCmdDispatchBaseKHX)gpa(dev, "vkCmdDispatchBaseKHX"); - // ---- VK_KHX_external_memory_win32 extension commands -#ifdef VK_USE_PLATFORM_WIN32_KHX - table->GetMemoryWin32HandleKHX = (PFN_vkGetMemoryWin32HandleKHX)gpa(dev, "vkGetMemoryWin32HandleKHX"); -#endif // VK_USE_PLATFORM_WIN32_KHX -#ifdef VK_USE_PLATFORM_WIN32_KHX - table->GetMemoryWin32HandlePropertiesKHX = (PFN_vkGetMemoryWin32HandlePropertiesKHX)gpa(dev, "vkGetMemoryWin32HandlePropertiesKHX"); -#endif // VK_USE_PLATFORM_WIN32_KHX - - // ---- VK_KHX_external_memory_fd extension commands - table->GetMemoryFdKHX = (PFN_vkGetMemoryFdKHX)gpa(dev, "vkGetMemoryFdKHX"); - table->GetMemoryFdPropertiesKHX = (PFN_vkGetMemoryFdPropertiesKHX)gpa(dev, "vkGetMemoryFdPropertiesKHX"); - - // ---- VK_KHX_external_semaphore_win32 extension commands -#ifdef VK_USE_PLATFORM_WIN32_KHX - table->ImportSemaphoreWin32HandleKHX = (PFN_vkImportSemaphoreWin32HandleKHX)gpa(dev, "vkImportSemaphoreWin32HandleKHX"); -#endif // VK_USE_PLATFORM_WIN32_KHX -#ifdef VK_USE_PLATFORM_WIN32_KHX - table->GetSemaphoreWin32HandleKHX = (PFN_vkGetSemaphoreWin32HandleKHX)gpa(dev, "vkGetSemaphoreWin32HandleKHX"); -#endif // VK_USE_PLATFORM_WIN32_KHX - - // ---- VK_KHX_external_semaphore_fd extension commands - table->ImportSemaphoreFdKHX = (PFN_vkImportSemaphoreFdKHX)gpa(dev, "vkImportSemaphoreFdKHX"); - table->GetSemaphoreFdKHX = (PFN_vkGetSemaphoreFdKHX)gpa(dev, "vkGetSemaphoreFdKHX"); - // ---- VK_NVX_device_generated_commands extension commands table->CmdProcessCommandsNVX = (PFN_vkCmdProcessCommandsNVX)gpa(dev, "vkCmdProcessCommandsNVX"); table->CmdReserveSpaceForCommandsNVX = (PFN_vkCmdReserveSpaceForCommandsNVX)gpa(dev, "vkCmdReserveSpaceForCommandsNVX"); @@ -465,7 +490,7 @@ VKAPI_ATTR void VKAPI_CALL loader_init_instance_core_dispatch_table(VkLayerInsta table->GetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)gpa(inst, "vkGetPhysicalDeviceProperties"); table->GetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties)gpa(inst, "vkGetPhysicalDeviceQueueFamilyProperties"); table->GetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)gpa(inst, "vkGetPhysicalDeviceMemoryProperties"); - table->GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)gpa(inst, "vkGetInstanceProcAddr"); + table->GetInstanceProcAddr = gpa; table->EnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties)gpa(inst, "vkEnumerateDeviceExtensionProperties"); table->EnumerateDeviceLayerProperties = (PFN_vkEnumerateDeviceLayerProperties)gpa(inst, "vkEnumerateDeviceLayerProperties"); table->GetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties)gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties"); @@ -545,6 +570,19 @@ VKAPI_ATTR void VKAPI_CALL loader_init_instance_extension_dispatch_table(VkLayer table->GetPhysicalDeviceMemoryProperties2KHR = (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)gpa(inst, "vkGetPhysicalDeviceMemoryProperties2KHR"); table->GetPhysicalDeviceSparseImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"); + // ---- VK_KHR_external_memory_capabilities extension commands + table->GetPhysicalDeviceExternalBufferPropertiesKHR = (PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)gpa(inst, "vkGetPhysicalDeviceExternalBufferPropertiesKHR"); + + // ---- VK_KHR_external_semaphore_capabilities extension commands + table->GetPhysicalDeviceExternalSemaphorePropertiesKHR = (PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)gpa(inst, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"); + + // ---- VK_KHR_external_fence_capabilities extension commands + table->GetPhysicalDeviceExternalFencePropertiesKHR = (PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)gpa(inst, "vkGetPhysicalDeviceExternalFencePropertiesKHR"); + + // ---- VK_KHR_get_surface_capabilities2 extension commands + table->GetPhysicalDeviceSurfaceCapabilities2KHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"); + table->GetPhysicalDeviceSurfaceFormats2KHR = (PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)gpa(inst, "vkGetPhysicalDeviceSurfaceFormats2KHR"); + // ---- VK_EXT_debug_report extension commands table->CreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)gpa(inst, "vkCreateDebugReportCallbackEXT"); table->DestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)gpa(inst, "vkDestroyDebugReportCallbackEXT"); @@ -564,12 +602,6 @@ VKAPI_ATTR void VKAPI_CALL loader_init_instance_extension_dispatch_table(VkLayer // ---- VK_KHX_device_group_creation extension commands table->EnumeratePhysicalDeviceGroupsKHX = (PFN_vkEnumeratePhysicalDeviceGroupsKHX)gpa(inst, "vkEnumeratePhysicalDeviceGroupsKHX"); - // ---- VK_KHX_external_memory_capabilities extension commands - table->GetPhysicalDeviceExternalBufferPropertiesKHX = (PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHX)gpa(inst, "vkGetPhysicalDeviceExternalBufferPropertiesKHX"); - - // ---- VK_KHX_external_semaphore_capabilities extension commands - table->GetPhysicalDeviceExternalSemaphorePropertiesKHX = (PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX)gpa(inst, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHX"); - // ---- VK_NVX_device_generated_commands extension commands table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX = (PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)gpa(inst, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"); @@ -740,6 +772,30 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDis // ---- VK_KHR_maintenance1 extension commands if (!strcmp(name, "TrimCommandPoolKHR")) return (void *)table->TrimCommandPoolKHR; + // ---- VK_KHR_external_memory_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp(name, "GetMemoryWin32HandleKHR")) return (void *)table->GetMemoryWin32HandleKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp(name, "GetMemoryWin32HandlePropertiesKHR")) return (void *)table->GetMemoryWin32HandlePropertiesKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_memory_fd extension commands + if (!strcmp(name, "GetMemoryFdKHR")) return (void *)table->GetMemoryFdKHR; + if (!strcmp(name, "GetMemoryFdPropertiesKHR")) return (void *)table->GetMemoryFdPropertiesKHR; + + // ---- VK_KHR_external_semaphore_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp(name, "ImportSemaphoreWin32HandleKHR")) return (void *)table->ImportSemaphoreWin32HandleKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp(name, "GetSemaphoreWin32HandleKHR")) return (void *)table->GetSemaphoreWin32HandleKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_semaphore_fd extension commands + if (!strcmp(name, "ImportSemaphoreFdKHR")) return (void *)table->ImportSemaphoreFdKHR; + if (!strcmp(name, "GetSemaphoreFdKHR")) return (void *)table->GetSemaphoreFdKHR; + // ---- VK_KHR_push_descriptor extension commands if (!strcmp(name, "CmdPushDescriptorSetKHR")) return (void *)table->CmdPushDescriptorSetKHR; @@ -749,6 +805,26 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDis if (!strcmp(name, "UpdateDescriptorSetWithTemplateKHR")) return (void *)table->UpdateDescriptorSetWithTemplateKHR; if (!strcmp(name, "CmdPushDescriptorSetWithTemplateKHR")) return (void *)table->CmdPushDescriptorSetWithTemplateKHR; + // ---- VK_KHR_shared_presentable_image extension commands + if (!strcmp(name, "GetSwapchainStatusKHR")) return (void *)table->GetSwapchainStatusKHR; + + // ---- VK_KHR_external_fence_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp(name, "ImportFenceWin32HandleKHR")) return (void *)table->ImportFenceWin32HandleKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp(name, "GetFenceWin32HandleKHR")) return (void *)table->GetFenceWin32HandleKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_fence_fd extension commands + if (!strcmp(name, "ImportFenceFdKHR")) return (void *)table->ImportFenceFdKHR; + if (!strcmp(name, "GetFenceFdKHR")) return (void *)table->GetFenceFdKHR; + + // ---- VK_KHR_get_memory_requirements2 extension commands + if (!strcmp(name, "GetImageMemoryRequirements2KHR")) return (void *)table->GetImageMemoryRequirements2KHR; + if (!strcmp(name, "GetBufferMemoryRequirements2KHR")) return (void *)table->GetBufferMemoryRequirements2KHR; + if (!strcmp(name, "GetImageSparseMemoryRequirements2KHR")) return (void *)table->GetImageSparseMemoryRequirements2KHR; + // ---- VK_EXT_debug_marker extension commands if (!strcmp(name, "DebugMarkerSetObjectTagEXT")) return (void *)table->DebugMarkerSetObjectTagEXT; if (!strcmp(name, "DebugMarkerSetObjectNameEXT")) return (void *)table->DebugMarkerSetObjectNameEXT; @@ -775,30 +851,6 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDis if (!strcmp(name, "AcquireNextImage2KHX")) return (void *)table->AcquireNextImage2KHX; if (!strcmp(name, "CmdDispatchBaseKHX")) return (void *)table->CmdDispatchBaseKHX; - // ---- VK_KHX_external_memory_win32 extension commands -#ifdef VK_USE_PLATFORM_WIN32_KHX - if (!strcmp(name, "GetMemoryWin32HandleKHX")) return (void *)table->GetMemoryWin32HandleKHX; -#endif // VK_USE_PLATFORM_WIN32_KHX -#ifdef VK_USE_PLATFORM_WIN32_KHX - if (!strcmp(name, "GetMemoryWin32HandlePropertiesKHX")) return (void *)table->GetMemoryWin32HandlePropertiesKHX; -#endif // VK_USE_PLATFORM_WIN32_KHX - - // ---- VK_KHX_external_memory_fd extension commands - if (!strcmp(name, "GetMemoryFdKHX")) return (void *)table->GetMemoryFdKHX; - if (!strcmp(name, "GetMemoryFdPropertiesKHX")) return (void *)table->GetMemoryFdPropertiesKHX; - - // ---- VK_KHX_external_semaphore_win32 extension commands -#ifdef VK_USE_PLATFORM_WIN32_KHX - if (!strcmp(name, "ImportSemaphoreWin32HandleKHX")) return (void *)table->ImportSemaphoreWin32HandleKHX; -#endif // VK_USE_PLATFORM_WIN32_KHX -#ifdef VK_USE_PLATFORM_WIN32_KHX - if (!strcmp(name, "GetSemaphoreWin32HandleKHX")) return (void *)table->GetSemaphoreWin32HandleKHX; -#endif // VK_USE_PLATFORM_WIN32_KHX - - // ---- VK_KHX_external_semaphore_fd extension commands - if (!strcmp(name, "ImportSemaphoreFdKHX")) return (void *)table->ImportSemaphoreFdKHX; - if (!strcmp(name, "GetSemaphoreFdKHX")) return (void *)table->GetSemaphoreFdKHX; - // ---- VK_NVX_device_generated_commands extension commands if (!strcmp(name, "CmdProcessCommandsNVX")) return (void *)table->CmdProcessCommandsNVX; if (!strcmp(name, "CmdReserveSpaceForCommandsNVX")) return (void *)table->CmdReserveSpaceForCommandsNVX; @@ -926,6 +978,19 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_instance_dispatch_table(const VkLayerI if (!strcmp(name, "GetPhysicalDeviceMemoryProperties2KHR")) return (void *)table->GetPhysicalDeviceMemoryProperties2KHR; if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties2KHR")) return (void *)table->GetPhysicalDeviceSparseImageFormatProperties2KHR; + // ---- VK_KHR_external_memory_capabilities extension commands + if (!strcmp(name, "GetPhysicalDeviceExternalBufferPropertiesKHR")) return (void *)table->GetPhysicalDeviceExternalBufferPropertiesKHR; + + // ---- VK_KHR_external_semaphore_capabilities extension commands + if (!strcmp(name, "GetPhysicalDeviceExternalSemaphorePropertiesKHR")) return (void *)table->GetPhysicalDeviceExternalSemaphorePropertiesKHR; + + // ---- VK_KHR_external_fence_capabilities extension commands + if (!strcmp(name, "GetPhysicalDeviceExternalFencePropertiesKHR")) return (void *)table->GetPhysicalDeviceExternalFencePropertiesKHR; + + // ---- VK_KHR_get_surface_capabilities2 extension commands + if (!strcmp(name, "GetPhysicalDeviceSurfaceCapabilities2KHR")) return (void *)table->GetPhysicalDeviceSurfaceCapabilities2KHR; + if (!strcmp(name, "GetPhysicalDeviceSurfaceFormats2KHR")) return (void *)table->GetPhysicalDeviceSurfaceFormats2KHR; + // ---- VK_EXT_debug_report extension commands if (!strcmp(name, "CreateDebugReportCallbackEXT")) return (void *)table->CreateDebugReportCallbackEXT; if (!strcmp(name, "DestroyDebugReportCallbackEXT")) return (void *)table->DestroyDebugReportCallbackEXT; @@ -945,12 +1010,6 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_instance_dispatch_table(const VkLayerI // ---- VK_KHX_device_group_creation extension commands if (!strcmp(name, "EnumeratePhysicalDeviceGroupsKHX")) return (void *)table->EnumeratePhysicalDeviceGroupsKHX; - // ---- VK_KHX_external_memory_capabilities extension commands - if (!strcmp(name, "GetPhysicalDeviceExternalBufferPropertiesKHX")) return (void *)table->GetPhysicalDeviceExternalBufferPropertiesKHX; - - // ---- VK_KHX_external_semaphore_capabilities extension commands - if (!strcmp(name, "GetPhysicalDeviceExternalSemaphorePropertiesKHX")) return (void *)table->GetPhysicalDeviceExternalSemaphorePropertiesKHX; - // ---- VK_NVX_device_generated_commands extension commands if (!strcmp(name, "GetPhysicalDeviceGeneratedCommandsPropertiesNVX")) return (void *)table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX; @@ -983,166 +1042,6 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_instance_dispatch_table(const VkLayerI } -// ---- VK_KHR_get_physical_device_properties2 extension trampoline/terminators - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2KHR* pFeatures) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceFeatures2KHR(unwrapped_phys_dev, pFeatures); -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2KHR* pFeatures) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceFeatures2KHR) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceFeatures2KHR"); - } - icd_term->dispatch.GetPhysicalDeviceFeatures2KHR(phys_dev_term->phys_dev, pFeatures); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2KHR* pProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceProperties2KHR(unwrapped_phys_dev, pProperties); -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2KHR* pProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceProperties2KHR) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceProperties2KHR"); - } - icd_term->dispatch.GetPhysicalDeviceProperties2KHR(phys_dev_term->phys_dev, pProperties); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2KHR* pFormatProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceFormatProperties2KHR(unwrapped_phys_dev, format, pFormatProperties); -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2KHR* pFormatProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceFormatProperties2KHR) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceFormatProperties2KHR"); - } - icd_term->dispatch.GetPhysicalDeviceFormatProperties2KHR(phys_dev_term->phys_dev, format, pFormatProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, - VkImageFormatProperties2KHR* pImageFormatProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->GetPhysicalDeviceImageFormatProperties2KHR(unwrapped_phys_dev, pImageFormatInfo, pImageFormatProperties); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, - VkImageFormatProperties2KHR* pImageFormatProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceImageFormatProperties2KHR) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceImageFormatProperties2KHR"); - } - return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties2KHR(phys_dev_term->phys_dev, pImageFormatInfo, pImageFormatProperties); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2KHR* pQueueFamilyProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceQueueFamilyProperties2KHR(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties); -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2KHR* pQueueFamilyProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties2KHR) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceQueueFamilyProperties2KHR"); - } - icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties2KHR(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceMemoryProperties2KHR(unwrapped_phys_dev, pMemoryProperties); -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceMemoryProperties2KHR) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceMemoryProperties2KHR"); - } - icd_term->dispatch.GetPhysicalDeviceMemoryProperties2KHR(phys_dev_term->phys_dev, pMemoryProperties); -} - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2KHR* pProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceSparseImageFormatProperties2KHR(unwrapped_phys_dev, pFormatInfo, pPropertyCount, pProperties); -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2KHR* pProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties2KHR) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceSparseImageFormatProperties2KHR"); - } - icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties2KHR(phys_dev_term->phys_dev, pFormatInfo, pPropertyCount, pProperties); -} - - // ---- VK_KHR_maintenance1 extension trampoline/terminators VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( @@ -1154,6 +1053,90 @@ VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( } +// ---- VK_KHR_external_memory_win32 extension trampoline/terminators + +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); +} + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); +} + +#endif // VK_USE_PLATFORM_WIN32_KHR + +// ---- VK_KHR_external_memory_fd extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->GetMemoryFdKHR(device, pGetFdInfo, pFd); +} + +VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); +} + + +// ---- VK_KHR_external_semaphore_win32 extension trampoline/terminators + +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); +} + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); +} + +#endif // VK_USE_PLATFORM_WIN32_KHR + +// ---- VK_KHR_external_semaphore_fd extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); +} + +VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->GetSemaphoreFdKHR(device, pGetFdInfo, pFd); +} + + // ---- VK_KHR_push_descriptor extension trampoline/terminators VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( @@ -1207,18 +1190,98 @@ VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( } +// ---- VK_KHR_shared_presentable_image extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->GetSwapchainStatusKHR(device, swapchain); +} + + +// ---- VK_KHR_external_fence_win32 extension trampoline/terminators + +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); +} + +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR +VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); +} + +#endif // VK_USE_PLATFORM_WIN32_KHR + +// ---- VK_KHR_external_fence_fd extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->ImportFenceFdKHR(device, pImportFenceFdInfo); +} + +VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + return disp->GetFenceFdKHR(device, pGetFdInfo, pFd); +} + + +// ---- VK_KHR_get_memory_requirements2 extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + disp->GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); +} + +VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + disp->GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); +} + +VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + disp->GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + + // ---- VK_EXT_debug_marker extension trampoline/terminators VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); + VkDebugMarkerObjectTagInfoEXT local_tag_info; + memcpy(&local_tag_info, pTagInfo, sizeof(VkDebugMarkerObjectTagInfoEXT)); // If this is a physical device, we have to replace it with the proper one for the next call. if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) { struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)pTagInfo->object; - pTagInfo->object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev; + local_tag_info.object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev; } - return disp->DebugMarkerSetObjectTagEXT(device, pTagInfo); + return disp->DebugMarkerSetObjectTagEXT(device, &local_tag_info); } VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectTagEXT( @@ -1228,20 +1291,22 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectTagEXT( struct loader_device *dev; struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index); if (NULL != icd_term && NULL != icd_term->dispatch.DebugMarkerSetObjectTagEXT) { + VkDebugMarkerObjectTagInfoEXT local_tag_info; + memcpy(&local_tag_info, pTagInfo, sizeof(VkDebugMarkerObjectTagInfoEXT)); // If this is a physical device, we have to replace it with the proper one for the next call. if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) { struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)pTagInfo->object; - pTagInfo->object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev; + local_tag_info.object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev; // If this is a KHR_surface, and the ICD has created its own, we have to replace it with the proper one for the next call. } else if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) { if (NULL != icd_term && NULL != icd_term->dispatch.CreateSwapchainKHR) { VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pTagInfo->object; if (NULL != icd_surface->real_icd_surfaces) { - pTagInfo->object = (uint64_t)icd_surface->real_icd_surfaces[icd_index]; + local_tag_info.object = (uint64_t)icd_surface->real_icd_surfaces[icd_index]; } } } - return icd_term->dispatch.DebugMarkerSetObjectTagEXT(device, pTagInfo); + return icd_term->dispatch.DebugMarkerSetObjectTagEXT(device, &local_tag_info); } else { return VK_SUCCESS; } @@ -1251,12 +1316,14 @@ VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); + VkDebugMarkerObjectNameInfoEXT local_name_info; + memcpy(&local_name_info, pNameInfo, sizeof(VkDebugMarkerObjectNameInfoEXT)); // If this is a physical device, we have to replace it with the proper one for the next call. if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) { struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)pNameInfo->object; - pNameInfo->object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev; + local_name_info.object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev; } - return disp->DebugMarkerSetObjectNameEXT(device, pNameInfo); + return disp->DebugMarkerSetObjectNameEXT(device, &local_name_info); } VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectNameEXT( @@ -1266,20 +1333,22 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectNameEXT( struct loader_device *dev; struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index); if (NULL != icd_term && NULL != icd_term->dispatch.DebugMarkerSetObjectNameEXT) { + VkDebugMarkerObjectNameInfoEXT local_name_info; + memcpy(&local_name_info, pNameInfo, sizeof(VkDebugMarkerObjectNameInfoEXT)); // If this is a physical device, we have to replace it with the proper one for the next call. if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) { struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)pNameInfo->object; - pNameInfo->object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev; + local_name_info.object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev; // If this is a KHR_surface, and the ICD has created its own, we have to replace it with the proper one for the next call. } else if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) { if (NULL != icd_term && NULL != icd_term->dispatch.CreateSwapchainKHR) { VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pNameInfo->object; if (NULL != icd_surface->real_icd_surfaces) { - pNameInfo->object = (uint64_t)icd_surface->real_icd_surfaces[icd_index]; + local_name_info.object = (uint64_t)icd_surface->real_icd_surfaces[icd_index]; } } } - return icd_term->dispatch.DebugMarkerSetObjectNameEXT(device, pNameInfo); + return icd_term->dispatch.DebugMarkerSetObjectNameEXT(device, &local_name_info); } else { return VK_SUCCESS; } @@ -1487,146 +1556,6 @@ VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateViSurfaceNN( #endif // VK_USE_PLATFORM_VI_NN -// ---- VK_KHX_external_memory_capabilities extension trampoline/terminators - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHX( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, - VkExternalBufferPropertiesKHX* pExternalBufferProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceExternalBufferPropertiesKHX(unwrapped_phys_dev, pExternalBufferInfo, pExternalBufferProperties); -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalBufferPropertiesKHX( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, - VkExternalBufferPropertiesKHX* pExternalBufferProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceExternalBufferPropertiesKHX) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceExternalBufferPropertiesKHX"); - } - icd_term->dispatch.GetPhysicalDeviceExternalBufferPropertiesKHX(phys_dev_term->phys_dev, pExternalBufferInfo, pExternalBufferProperties); -} - - -// ---- VK_KHX_external_memory_win32 extension trampoline/terminators - -#ifdef VK_USE_PLATFORM_WIN32_KHX -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHX( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, - HANDLE* pHandle) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->GetMemoryWin32HandleKHX(device, memory, handleType, pHandle); -} - -#endif // VK_USE_PLATFORM_WIN32_KHX -#ifdef VK_USE_PLATFORM_WIN32_KHX -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHX( - VkDevice device, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->GetMemoryWin32HandlePropertiesKHX(device, handleType, handle, pMemoryWin32HandleProperties); -} - -#endif // VK_USE_PLATFORM_WIN32_KHX - -// ---- VK_KHX_external_memory_fd extension trampoline/terminators - -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHX( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, - int* pFd) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->GetMemoryFdKHX(device, memory, handleType, pFd); -} - -VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHX( - VkDevice device, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, - int fd, - VkMemoryFdPropertiesKHX* pMemoryFdProperties) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->GetMemoryFdPropertiesKHX(device, handleType, fd, pMemoryFdProperties); -} - - -// ---- VK_KHX_external_semaphore_capabilities extension trampoline/terminators - -VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHX( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, - VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - disp->GetPhysicalDeviceExternalSemaphorePropertiesKHX(unwrapped_phys_dev, pExternalSemaphoreInfo, pExternalSemaphoreProperties); -} - -VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHX( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, - VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceExternalSemaphorePropertiesKHX) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceExternalSemaphorePropertiesKHX"); - } - icd_term->dispatch.GetPhysicalDeviceExternalSemaphorePropertiesKHX(phys_dev_term->phys_dev, pExternalSemaphoreInfo, pExternalSemaphoreProperties); -} - - -// ---- VK_KHX_external_semaphore_win32 extension trampoline/terminators - -#ifdef VK_USE_PLATFORM_WIN32_KHX -VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHX( - VkDevice device, - const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->ImportSemaphoreWin32HandleKHX(device, pImportSemaphoreWin32HandleInfo); -} - -#endif // VK_USE_PLATFORM_WIN32_KHX -#ifdef VK_USE_PLATFORM_WIN32_KHX -VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHX( - VkDevice device, - VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, - HANDLE* pHandle) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->GetSemaphoreWin32HandleKHX(device, semaphore, handleType, pHandle); -} - -#endif // VK_USE_PLATFORM_WIN32_KHX - -// ---- VK_KHX_external_semaphore_fd extension trampoline/terminators - -VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHX( - VkDevice device, - const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->ImportSemaphoreFdKHX(device, pImportSemaphoreFdInfo); -} - -VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHX( - VkDevice device, - VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, - int* pFd) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); - return disp->GetSemaphoreFdKHX(device, semaphore, handleType, pFd); -} - - // ---- VK_NVX_device_generated_commands extension trampoline/terminators VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX( @@ -1733,116 +1662,6 @@ VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( } -// ---- VK_EXT_direct_mode_display extension trampoline/terminators - -VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->ReleaseDisplayEXT(unwrapped_phys_dev, display); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.ReleaseDisplayEXT) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support ReleaseDisplayEXT"); - } - return icd_term->dispatch.ReleaseDisplayEXT(phys_dev_term->phys_dev, display); -} - - -// ---- VK_EXT_acquire_xlib_display extension trampoline/terminators - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT -VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - VkDisplayKHR display) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->AcquireXlibDisplayEXT(unwrapped_phys_dev, dpy, display); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - VkDisplayKHR display) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.AcquireXlibDisplayEXT) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support AcquireXlibDisplayEXT"); - } - return icd_term->dispatch.AcquireXlibDisplayEXT(phys_dev_term->phys_dev, dpy, display); -} - -#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT -VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - RROutput rrOutput, - VkDisplayKHR* pDisplay) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->GetRandROutputDisplayEXT(unwrapped_phys_dev, dpy, rrOutput, pDisplay); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - RROutput rrOutput, - VkDisplayKHR* pDisplay) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetRandROutputDisplayEXT) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetRandROutputDisplayEXT"); - } - return icd_term->dispatch.GetRandROutputDisplayEXT(phys_dev_term->phys_dev, dpy, rrOutput, pDisplay); -} - -#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT - -// ---- VK_EXT_display_surface_counter extension trampoline/terminators - -VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { - const VkLayerInstanceDispatchTable *disp; - VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); - disp = loader_get_instance_layer_dispatch(physicalDevice); - return disp->GetPhysicalDeviceSurfaceCapabilities2EXT(unwrapped_phys_dev, surface, pSurfaceCapabilities); -} - -VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { - struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; - struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; - if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2EXT) { - loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, - "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceSurfaceCapabilities2EXT"); - } - VkIcdSurface *icd_surface = (VkIcdSurface *)(surface); - uint8_t icd_index = phys_dev_term->icd_index; - if (NULL != icd_surface->real_icd_surfaces && NULL != (void *)icd_surface->real_icd_surfaces[icd_index]) { - return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2EXT(phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[icd_index], pSurfaceCapabilities); - } - return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2EXT(phys_dev_term->phys_dev, surface, pSurfaceCapabilities); -} - - // ---- VK_EXT_display_control extension trampoline/terminators VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( @@ -2024,6 +1843,70 @@ bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *na return true; } + // ---- VK_KHR_external_memory_capabilities extension commands + if (!strcmp("vkGetPhysicalDeviceExternalBufferPropertiesKHR", name)) { + *addr = (ptr_instance->enabled_known_extensions.khr_external_memory_capabilities == 1) + ? (void *)GetPhysicalDeviceExternalBufferPropertiesKHR + : NULL; + return true; + } + + // ---- VK_KHR_external_memory_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp("vkGetMemoryWin32HandleKHR", name)) { + *addr = (void *)GetMemoryWin32HandleKHR; + return true; + } +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp("vkGetMemoryWin32HandlePropertiesKHR", name)) { + *addr = (void *)GetMemoryWin32HandlePropertiesKHR; + return true; + } +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_memory_fd extension commands + if (!strcmp("vkGetMemoryFdKHR", name)) { + *addr = (void *)GetMemoryFdKHR; + return true; + } + if (!strcmp("vkGetMemoryFdPropertiesKHR", name)) { + *addr = (void *)GetMemoryFdPropertiesKHR; + return true; + } + + // ---- VK_KHR_external_semaphore_capabilities extension commands + if (!strcmp("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", name)) { + *addr = (ptr_instance->enabled_known_extensions.khr_external_semaphore_capabilities == 1) + ? (void *)GetPhysicalDeviceExternalSemaphorePropertiesKHR + : NULL; + return true; + } + + // ---- VK_KHR_external_semaphore_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp("vkImportSemaphoreWin32HandleKHR", name)) { + *addr = (void *)ImportSemaphoreWin32HandleKHR; + return true; + } +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp("vkGetSemaphoreWin32HandleKHR", name)) { + *addr = (void *)GetSemaphoreWin32HandleKHR; + return true; + } +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_semaphore_fd extension commands + if (!strcmp("vkImportSemaphoreFdKHR", name)) { + *addr = (void *)ImportSemaphoreFdKHR; + return true; + } + if (!strcmp("vkGetSemaphoreFdKHR", name)) { + *addr = (void *)GetSemaphoreFdKHR; + return true; + } + // ---- VK_KHR_push_descriptor extension commands if (!strcmp("vkCmdPushDescriptorSetKHR", name)) { *addr = (void *)CmdPushDescriptorSetKHR; @@ -2048,6 +1931,72 @@ bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *na return true; } + // ---- VK_KHR_shared_presentable_image extension commands + if (!strcmp("vkGetSwapchainStatusKHR", name)) { + *addr = (void *)GetSwapchainStatusKHR; + return true; + } + + // ---- VK_KHR_external_fence_capabilities extension commands + if (!strcmp("vkGetPhysicalDeviceExternalFencePropertiesKHR", name)) { + *addr = (ptr_instance->enabled_known_extensions.khr_external_fence_capabilities == 1) + ? (void *)GetPhysicalDeviceExternalFencePropertiesKHR + : NULL; + return true; + } + + // ---- VK_KHR_external_fence_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp("vkImportFenceWin32HandleKHR", name)) { + *addr = (void *)ImportFenceWin32HandleKHR; + return true; + } +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + if (!strcmp("vkGetFenceWin32HandleKHR", name)) { + *addr = (void *)GetFenceWin32HandleKHR; + return true; + } +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_fence_fd extension commands + if (!strcmp("vkImportFenceFdKHR", name)) { + *addr = (void *)ImportFenceFdKHR; + return true; + } + if (!strcmp("vkGetFenceFdKHR", name)) { + *addr = (void *)GetFenceFdKHR; + return true; + } + + // ---- VK_KHR_get_surface_capabilities2 extension commands + if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilities2KHR", name)) { + *addr = (ptr_instance->enabled_known_extensions.khr_get_surface_capabilities2 == 1) + ? (void *)GetPhysicalDeviceSurfaceCapabilities2KHR + : NULL; + return true; + } + if (!strcmp("vkGetPhysicalDeviceSurfaceFormats2KHR", name)) { + *addr = (ptr_instance->enabled_known_extensions.khr_get_surface_capabilities2 == 1) + ? (void *)GetPhysicalDeviceSurfaceFormats2KHR + : NULL; + return true; + } + + // ---- VK_KHR_get_memory_requirements2 extension commands + if (!strcmp("vkGetImageMemoryRequirements2KHR", name)) { + *addr = (void *)GetImageMemoryRequirements2KHR; + return true; + } + if (!strcmp("vkGetBufferMemoryRequirements2KHR", name)) { + *addr = (void *)GetBufferMemoryRequirements2KHR; + return true; + } + if (!strcmp("vkGetImageSparseMemoryRequirements2KHR", name)) { + *addr = (void *)GetImageSparseMemoryRequirements2KHR; + return true; + } + // ---- VK_EXT_debug_marker extension commands if (!strcmp("vkDebugMarkerSetObjectTagEXT", name)) { *addr = (void *)DebugMarkerSetObjectTagEXT; @@ -2152,70 +2101,6 @@ bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *na return true; } - // ---- VK_KHX_external_memory_capabilities extension commands - if (!strcmp("vkGetPhysicalDeviceExternalBufferPropertiesKHX", name)) { - *addr = (ptr_instance->enabled_known_extensions.khx_external_memory_capabilities == 1) - ? (void *)GetPhysicalDeviceExternalBufferPropertiesKHX - : NULL; - return true; - } - - // ---- VK_KHX_external_memory_win32 extension commands -#ifdef VK_USE_PLATFORM_WIN32_KHX - if (!strcmp("vkGetMemoryWin32HandleKHX", name)) { - *addr = (void *)GetMemoryWin32HandleKHX; - return true; - } -#endif // VK_USE_PLATFORM_WIN32_KHX -#ifdef VK_USE_PLATFORM_WIN32_KHX - if (!strcmp("vkGetMemoryWin32HandlePropertiesKHX", name)) { - *addr = (void *)GetMemoryWin32HandlePropertiesKHX; - return true; - } -#endif // VK_USE_PLATFORM_WIN32_KHX - - // ---- VK_KHX_external_memory_fd extension commands - if (!strcmp("vkGetMemoryFdKHX", name)) { - *addr = (void *)GetMemoryFdKHX; - return true; - } - if (!strcmp("vkGetMemoryFdPropertiesKHX", name)) { - *addr = (void *)GetMemoryFdPropertiesKHX; - return true; - } - - // ---- VK_KHX_external_semaphore_capabilities extension commands - if (!strcmp("vkGetPhysicalDeviceExternalSemaphorePropertiesKHX", name)) { - *addr = (ptr_instance->enabled_known_extensions.khx_external_semaphore_capabilities == 1) - ? (void *)GetPhysicalDeviceExternalSemaphorePropertiesKHX - : NULL; - return true; - } - - // ---- VK_KHX_external_semaphore_win32 extension commands -#ifdef VK_USE_PLATFORM_WIN32_KHX - if (!strcmp("vkImportSemaphoreWin32HandleKHX", name)) { - *addr = (void *)ImportSemaphoreWin32HandleKHX; - return true; - } -#endif // VK_USE_PLATFORM_WIN32_KHX -#ifdef VK_USE_PLATFORM_WIN32_KHX - if (!strcmp("vkGetSemaphoreWin32HandleKHX", name)) { - *addr = (void *)GetSemaphoreWin32HandleKHX; - return true; - } -#endif // VK_USE_PLATFORM_WIN32_KHX - - // ---- VK_KHX_external_semaphore_fd extension commands - if (!strcmp("vkImportSemaphoreFdKHX", name)) { - *addr = (void *)ImportSemaphoreFdKHX; - return true; - } - if (!strcmp("vkGetSemaphoreFdKHX", name)) { - *addr = (void *)GetSemaphoreFdKHX; - return true; - } - // ---- VK_NVX_device_generated_commands extension commands if (!strcmp("vkCmdProcessCommandsNVX", name)) { *addr = (void *)CmdProcessCommandsNVX; @@ -2364,6 +2249,22 @@ void extensions_create_instance(struct loader_instance *ptr_instance, const VkIn if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 = 1; + // ---- VK_KHR_external_memory_capabilities extension commands + } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) { + ptr_instance->enabled_known_extensions.khr_external_memory_capabilities = 1; + + // ---- VK_KHR_external_semaphore_capabilities extension commands + } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME)) { + ptr_instance->enabled_known_extensions.khr_external_semaphore_capabilities = 1; + + // ---- VK_KHR_external_fence_capabilities extension commands + } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME)) { + ptr_instance->enabled_known_extensions.khr_external_fence_capabilities = 1; + + // ---- VK_KHR_get_surface_capabilities2 extension commands + } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) { + ptr_instance->enabled_known_extensions.khr_get_surface_capabilities2 = 1; + // ---- VK_NV_external_memory_capabilities extension commands } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) { ptr_instance->enabled_known_extensions.nv_external_memory_capabilities = 1; @@ -2378,14 +2279,6 @@ void extensions_create_instance(struct loader_instance *ptr_instance, const VkIn } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME)) { ptr_instance->enabled_known_extensions.khx_device_group_creation = 1; - // ---- VK_KHX_external_memory_capabilities extension commands - } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) { - ptr_instance->enabled_known_extensions.khx_external_memory_capabilities = 1; - - // ---- VK_KHX_external_semaphore_capabilities extension commands - } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME)) { - ptr_instance->enabled_known_extensions.khx_external_semaphore_capabilities = 1; - // ---- VK_EXT_direct_mode_display extension commands } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)) { ptr_instance->enabled_known_extensions.ext_direct_mode_display = 1; @@ -2531,6 +2424,19 @@ const VkLayerInstanceDispatchTable instance_disp = { .GetPhysicalDeviceMemoryProperties2KHR = terminator_GetPhysicalDeviceMemoryProperties2KHR, .GetPhysicalDeviceSparseImageFormatProperties2KHR = terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR, + // ---- VK_KHR_external_memory_capabilities extension commands + .GetPhysicalDeviceExternalBufferPropertiesKHR = terminator_GetPhysicalDeviceExternalBufferPropertiesKHR, + + // ---- VK_KHR_external_semaphore_capabilities extension commands + .GetPhysicalDeviceExternalSemaphorePropertiesKHR = terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHR, + + // ---- VK_KHR_external_fence_capabilities extension commands + .GetPhysicalDeviceExternalFencePropertiesKHR = terminator_GetPhysicalDeviceExternalFencePropertiesKHR, + + // ---- VK_KHR_get_surface_capabilities2 extension commands + .GetPhysicalDeviceSurfaceCapabilities2KHR = terminator_GetPhysicalDeviceSurfaceCapabilities2KHR, + .GetPhysicalDeviceSurfaceFormats2KHR = terminator_GetPhysicalDeviceSurfaceFormats2KHR, + // ---- VK_EXT_debug_report extension commands .CreateDebugReportCallbackEXT = terminator_CreateDebugReportCallbackEXT, .DestroyDebugReportCallbackEXT = terminator_DestroyDebugReportCallbackEXT, @@ -2539,6 +2445,9 @@ const VkLayerInstanceDispatchTable instance_disp = { // ---- VK_NV_external_memory_capabilities extension commands .GetPhysicalDeviceExternalImageFormatPropertiesNV = terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV, + // ---- VK_KHX_device_group extension commands + .GetPhysicalDevicePresentRectanglesKHX = terminator_GetPhysicalDevicePresentRectanglesKHX, + // ---- VK_NN_vi_surface extension commands #ifdef VK_USE_PLATFORM_VI_NN .CreateViSurfaceNN = terminator_CreateViSurfaceNN, @@ -2547,11 +2456,8 @@ const VkLayerInstanceDispatchTable instance_disp = { // ---- VK_KHX_device_group_creation extension commands .EnumeratePhysicalDeviceGroupsKHX = terminator_EnumeratePhysicalDeviceGroupsKHX, - // ---- VK_KHX_external_memory_capabilities extension commands - .GetPhysicalDeviceExternalBufferPropertiesKHX = terminator_GetPhysicalDeviceExternalBufferPropertiesKHX, - - // ---- VK_KHX_external_semaphore_capabilities extension commands - .GetPhysicalDeviceExternalSemaphorePropertiesKHX = terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHX, + // ---- VK_NVX_device_generated_commands extension commands + .GetPhysicalDeviceGeneratedCommandsPropertiesNVX = terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX, // ---- VK_EXT_direct_mode_display extension commands .ReleaseDisplayEXT = terminator_ReleaseDisplayEXT, @@ -2601,6 +2507,10 @@ const char *const LOADER_INSTANCE_EXTENSIONS[] = { VK_KHR_WIN32_SURFACE_EXTENSION_NAME, #endif // VK_USE_PLATFORM_WIN32_KHR VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, + VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, + VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, + VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME, + VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME, @@ -2608,8 +2518,6 @@ const char *const LOADER_INSTANCE_EXTENSIONS[] = { VK_NN_VI_SURFACE_EXTENSION_NAME, #endif // VK_USE_PLATFORM_VI_NN VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME, - VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, - VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME, VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME, #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME, diff --git a/third_party/vulkan/loader/vk_loader_extensions.h b/third_party/vulkan/loader/vk_loader_extensions.h index b8700250f..709e98472 100644 --- a/third_party/vulkan/loader/vk_loader_extensions.h +++ b/third_party/vulkan/loader/vk_loader_extensions.h @@ -249,6 +249,19 @@ struct loader_icd_term_dispatch { PFN_vkGetPhysicalDeviceMemoryProperties2KHR GetPhysicalDeviceMemoryProperties2KHR; PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR GetPhysicalDeviceSparseImageFormatProperties2KHR; + // ---- VK_KHR_external_memory_capabilities extension commands + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR GetPhysicalDeviceExternalBufferPropertiesKHR; + + // ---- VK_KHR_external_semaphore_capabilities extension commands + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR GetPhysicalDeviceExternalSemaphorePropertiesKHR; + + // ---- VK_KHR_external_fence_capabilities extension commands + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR GetPhysicalDeviceExternalFencePropertiesKHR; + + // ---- VK_KHR_get_surface_capabilities2 extension commands + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR GetPhysicalDeviceSurfaceCapabilities2KHR; + PFN_vkGetPhysicalDeviceSurfaceFormats2KHR GetPhysicalDeviceSurfaceFormats2KHR; + // ---- VK_EXT_debug_report extension commands PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT; PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT; @@ -273,12 +286,6 @@ struct loader_icd_term_dispatch { // ---- VK_KHX_device_group_creation extension commands PFN_vkEnumeratePhysicalDeviceGroupsKHX EnumeratePhysicalDeviceGroupsKHX; - // ---- VK_KHX_external_memory_capabilities extension commands - PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHX GetPhysicalDeviceExternalBufferPropertiesKHX; - - // ---- VK_KHX_external_semaphore_capabilities extension commands - PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX GetPhysicalDeviceExternalSemaphorePropertiesKHX; - // ---- VK_NVX_device_generated_commands extension commands PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX GetPhysicalDeviceGeneratedCommandsPropertiesNVX; @@ -310,12 +317,14 @@ struct loader_icd_term_dispatch { union loader_instance_extension_enables { struct { uint8_t khr_get_physical_device_properties2 : 1; + uint8_t khr_external_memory_capabilities : 1; + uint8_t khr_external_semaphore_capabilities : 1; + uint8_t khr_external_fence_capabilities : 1; + uint8_t khr_get_surface_capabilities2 : 1; uint8_t ext_debug_report : 1; uint8_t nv_external_memory_capabilities : 1; uint8_t nn_vi_surface : 1; uint8_t khx_device_group_creation : 1; - uint8_t khx_external_memory_capabilities : 1; - uint8_t khx_external_semaphore_capabilities : 1; uint8_t ext_direct_mode_display : 1; uint8_t ext_acquire_xlib_display : 1; uint8_t ext_display_surface_counter : 1; diff --git a/third_party/vulkan/loader/vk_loader_platform.h b/third_party/vulkan/loader/vk_loader_platform.h index 436f3b48b..c1ae0d85f 100644 --- a/third_party/vulkan/loader/vk_loader_platform.h +++ b/third_party/vulkan/loader/vk_loader_platform.h @@ -98,6 +98,10 @@ static inline char *loader_platform_dirname(char *path) { return dirname(path); // Dynamic Loading of libraries: typedef void *loader_platform_dl_handle; static inline loader_platform_dl_handle loader_platform_open_library(const char *libPath) { + // When loading the library, we use RTLD_LAZY so that not all symbols have to be + // resolved at this time (which improves performance). Note that if not all symbols + // can be resolved, this could cause crashes later. Use the LD_BIND_NOW environment + // variable to force all symbols to be resolved here. return dlopen(libPath, RTLD_LAZY | RTLD_LOCAL); } static inline const char *loader_platform_open_library_error(const char *libPath) { return dlerror(); } @@ -239,10 +243,18 @@ static char *loader_platform_basename(char *pathname) { // Dynamic Loading: typedef HMODULE loader_platform_dl_handle; -static loader_platform_dl_handle loader_platform_open_library(const char *libPath) { return LoadLibrary(libPath); } +static loader_platform_dl_handle loader_platform_open_library(const char *lib_path) { + // Try loading the library the original way first. + loader_platform_dl_handle lib_handle = LoadLibrary(lib_path); + if (lib_handle == NULL && GetLastError() == ERROR_MOD_NOT_FOUND && PathFileExists(lib_path)) { + // If that failed, then try loading it with broader search folders. + lib_handle = LoadLibraryEx(lib_path, NULL, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR); + } + return lib_handle; +} static char *loader_platform_open_library_error(const char *libPath) { static char errorMsg[164]; - (void)snprintf(errorMsg, 163, "Failed to open dynamic library \"%s\"", libPath); + (void)snprintf(errorMsg, 163, "Failed to open dynamic library \"%s\" with error %d", libPath, GetLastError()); return errorMsg; } static void loader_platform_close_library(loader_platform_dl_handle library) { FreeLibrary(library); } diff --git a/third_party/vulkan/vk_icd.h b/third_party/vulkan/vk_icd.h index 668a4d183..1983e5d4e 100644 --- a/third_party/vulkan/vk_icd.h +++ b/third_party/vulkan/vk_icd.h @@ -35,7 +35,13 @@ // Version 3 - Add ICD creation/destruction of KHR_surface objects. // Version 4 - Add unknown physical device extension qyering via // vk_icdGetPhysicalDeviceProcAddr. -#define CURRENT_LOADER_ICD_INTERFACE_VERSION 4 +// Version 5 - Tells ICDs that the loader is now paying attention to the +// application version of Vulkan passed into the ApplicationInfo +// structure during vkCreateInstance. This will tell the ICD +// that if the loader is older, it should automatically fail a +// call for any API version > 1.0. Otherwise, the loader will +// manually determine if it can support the expected version. +#define CURRENT_LOADER_ICD_INTERFACE_VERSION 5 #define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0 #define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4 typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion); diff --git a/third_party/vulkan/vk_layer.h b/third_party/vulkan/vk_layer.h index 4a502a33b..a7ac29150 100644 --- a/third_party/vulkan/vk_layer.h +++ b/third_party/vulkan/vk_layer.h @@ -68,7 +68,7 @@ typedef struct VkNegotiateLayerInterface { typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct); // Function prototype for unknown physical device extension command -typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device, ...); +typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device); // ------------------------------------------------------------------------------------------------ // CreateInstance and CreateDevice support structures @@ -132,3 +132,12 @@ typedef struct { } u; } VkLayerDeviceCreateInfo; +#ifdef __cplusplus +extern "C" { +#endif + +VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); + +#ifdef __cplusplus +} +#endif diff --git a/third_party/vulkan/vk_layer_dispatch_table.h b/third_party/vulkan/vk_layer_dispatch_table.h index d6b3f11a2..01c80a32f 100644 --- a/third_party/vulkan/vk_layer_dispatch_table.h +++ b/third_party/vulkan/vk_layer_dispatch_table.h @@ -119,6 +119,19 @@ typedef struct VkLayerInstanceDispatchTable_ { PFN_vkGetPhysicalDeviceMemoryProperties2KHR GetPhysicalDeviceMemoryProperties2KHR; PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR GetPhysicalDeviceSparseImageFormatProperties2KHR; + // ---- VK_KHR_external_memory_capabilities extension commands + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR GetPhysicalDeviceExternalBufferPropertiesKHR; + + // ---- VK_KHR_external_semaphore_capabilities extension commands + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR GetPhysicalDeviceExternalSemaphorePropertiesKHR; + + // ---- VK_KHR_external_fence_capabilities extension commands + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR GetPhysicalDeviceExternalFencePropertiesKHR; + + // ---- VK_KHR_get_surface_capabilities2 extension commands + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR GetPhysicalDeviceSurfaceCapabilities2KHR; + PFN_vkGetPhysicalDeviceSurfaceFormats2KHR GetPhysicalDeviceSurfaceFormats2KHR; + // ---- VK_EXT_debug_report extension commands PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT; PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT; @@ -138,12 +151,6 @@ typedef struct VkLayerInstanceDispatchTable_ { // ---- VK_KHX_device_group_creation extension commands PFN_vkEnumeratePhysicalDeviceGroupsKHX EnumeratePhysicalDeviceGroupsKHX; - // ---- VK_KHX_external_memory_capabilities extension commands - PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHX GetPhysicalDeviceExternalBufferPropertiesKHX; - - // ---- VK_KHX_external_semaphore_capabilities extension commands - PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX GetPhysicalDeviceExternalSemaphorePropertiesKHX; - // ---- VK_NVX_device_generated_commands extension commands PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX GetPhysicalDeviceGeneratedCommandsPropertiesNVX; @@ -311,6 +318,30 @@ typedef struct VkLayerDispatchTable_ { // ---- VK_KHR_maintenance1 extension commands PFN_vkTrimCommandPoolKHR TrimCommandPoolKHR; + // ---- VK_KHR_external_memory_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetMemoryWin32HandleKHR GetMemoryWin32HandleKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetMemoryWin32HandlePropertiesKHR GetMemoryWin32HandlePropertiesKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_memory_fd extension commands + PFN_vkGetMemoryFdKHR GetMemoryFdKHR; + PFN_vkGetMemoryFdPropertiesKHR GetMemoryFdPropertiesKHR; + + // ---- VK_KHR_external_semaphore_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkImportSemaphoreWin32HandleKHR ImportSemaphoreWin32HandleKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetSemaphoreWin32HandleKHR GetSemaphoreWin32HandleKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_semaphore_fd extension commands + PFN_vkImportSemaphoreFdKHR ImportSemaphoreFdKHR; + PFN_vkGetSemaphoreFdKHR GetSemaphoreFdKHR; + // ---- VK_KHR_push_descriptor extension commands PFN_vkCmdPushDescriptorSetKHR CmdPushDescriptorSetKHR; @@ -320,6 +351,26 @@ typedef struct VkLayerDispatchTable_ { PFN_vkUpdateDescriptorSetWithTemplateKHR UpdateDescriptorSetWithTemplateKHR; PFN_vkCmdPushDescriptorSetWithTemplateKHR CmdPushDescriptorSetWithTemplateKHR; + // ---- VK_KHR_shared_presentable_image extension commands + PFN_vkGetSwapchainStatusKHR GetSwapchainStatusKHR; + + // ---- VK_KHR_external_fence_win32 extension commands +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkImportFenceWin32HandleKHR ImportFenceWin32HandleKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR +#ifdef VK_USE_PLATFORM_WIN32_KHR + PFN_vkGetFenceWin32HandleKHR GetFenceWin32HandleKHR; +#endif // VK_USE_PLATFORM_WIN32_KHR + + // ---- VK_KHR_external_fence_fd extension commands + PFN_vkImportFenceFdKHR ImportFenceFdKHR; + PFN_vkGetFenceFdKHR GetFenceFdKHR; + + // ---- VK_KHR_get_memory_requirements2 extension commands + PFN_vkGetImageMemoryRequirements2KHR GetImageMemoryRequirements2KHR; + PFN_vkGetBufferMemoryRequirements2KHR GetBufferMemoryRequirements2KHR; + PFN_vkGetImageSparseMemoryRequirements2KHR GetImageSparseMemoryRequirements2KHR; + // ---- VK_EXT_debug_marker extension commands PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT; PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT; @@ -346,30 +397,6 @@ typedef struct VkLayerDispatchTable_ { PFN_vkAcquireNextImage2KHX AcquireNextImage2KHX; PFN_vkCmdDispatchBaseKHX CmdDispatchBaseKHX; - // ---- VK_KHX_external_memory_win32 extension commands -#ifdef VK_USE_PLATFORM_WIN32_KHX - PFN_vkGetMemoryWin32HandleKHX GetMemoryWin32HandleKHX; -#endif // VK_USE_PLATFORM_WIN32_KHX -#ifdef VK_USE_PLATFORM_WIN32_KHX - PFN_vkGetMemoryWin32HandlePropertiesKHX GetMemoryWin32HandlePropertiesKHX; -#endif // VK_USE_PLATFORM_WIN32_KHX - - // ---- VK_KHX_external_memory_fd extension commands - PFN_vkGetMemoryFdKHX GetMemoryFdKHX; - PFN_vkGetMemoryFdPropertiesKHX GetMemoryFdPropertiesKHX; - - // ---- VK_KHX_external_semaphore_win32 extension commands -#ifdef VK_USE_PLATFORM_WIN32_KHX - PFN_vkImportSemaphoreWin32HandleKHX ImportSemaphoreWin32HandleKHX; -#endif // VK_USE_PLATFORM_WIN32_KHX -#ifdef VK_USE_PLATFORM_WIN32_KHX - PFN_vkGetSemaphoreWin32HandleKHX GetSemaphoreWin32HandleKHX; -#endif // VK_USE_PLATFORM_WIN32_KHX - - // ---- VK_KHX_external_semaphore_fd extension commands - PFN_vkImportSemaphoreFdKHX ImportSemaphoreFdKHX; - PFN_vkGetSemaphoreFdKHX GetSemaphoreFdKHX; - // ---- VK_NVX_device_generated_commands extension commands PFN_vkCmdProcessCommandsNVX CmdProcessCommandsNVX; PFN_vkCmdReserveSpaceForCommandsNVX CmdReserveSpaceForCommandsNVX; diff --git a/third_party/vulkan/vulkan.h b/third_party/vulkan/vulkan.h index ef0c24678..16434fefb 100644 --- a/third_party/vulkan/vulkan.h +++ b/third_party/vulkan/vulkan.h @@ -43,7 +43,7 @@ extern "C" { #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) // Version of this file -#define VK_HEADER_VERSION 46 +#define VK_HEADER_VERSION 54 #define VK_NULL_HANDLE 0 @@ -146,7 +146,7 @@ typedef enum VkResult { VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, VK_ERROR_INVALID_SHADER_NV = -1000012000, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000, - VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX = -1000072003, + VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = -1000072003, VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, VK_RESULT_END_RANGE = VK_INCOMPLETE, VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1), @@ -222,6 +222,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002, @@ -256,31 +257,33 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = 1000070000, VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = 1000070001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX = 1000071000, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX = 1000071001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX = 1000071002, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX = 1000071003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX = 1000071004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX = 1000071005, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX = 1000071006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX = 1000071007, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX = 1000072000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX = 1000072001, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX = 1000072002, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX = 1000073001, - VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX = 1000073002, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX = 1000074000, - VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX = 1000074001, - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX = 1000075000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX = 1000076000, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX = 1000076001, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX = 1000077000, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX = 1000078001, - VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX = 1000078002, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX = 1000079000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = 1000072002, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = 1000076001, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = 1000077000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000, VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000, VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000, @@ -301,8 +304,35 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = 1000113000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000, VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = 1000127001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), @@ -590,6 +620,7 @@ typedef enum VkImageLayout { VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, VK_IMAGE_LAYOUT_PREINITIALIZED = 8, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1), @@ -655,6 +686,7 @@ typedef enum VkPolygonMode { VK_POLYGON_MODE_FILL = 0, VK_POLYGON_MODE_LINE = 1, VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1), @@ -755,6 +787,52 @@ typedef enum VkBlendOp { VK_BLEND_OP_REVERSE_SUBTRACT = 2, VK_BLEND_OP_MIN = 3, VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, + VK_BLEND_OP_DARKEN_EXT = 1000148015, + VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + VK_BLEND_OP_COLORBURN_EXT = 1000148018, + VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + VK_BLEND_OP_INVERT_EXT = 1000148023, + VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + VK_BLEND_OP_HARDMIX_EXT = 1000148030, + VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + VK_BLEND_OP_PLUS_EXT = 1000148035, + VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + VK_BLEND_OP_MINUS_EXT = 1000148039, + VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + VK_BLEND_OP_CONTRAST_EXT = 1000148041, + VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + VK_BLEND_OP_RED_EXT = 1000148043, + VK_BLEND_OP_GREEN_EXT = 1000148044, + VK_BLEND_OP_BLUE_EXT = 1000148045, VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1), @@ -896,6 +974,47 @@ typedef enum VkSubpassContents { VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF } VkSubpassContents; +typedef enum VkObjectType { + VK_OBJECT_TYPE_UNKNOWN = 0, + VK_OBJECT_TYPE_INSTANCE = 1, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + VK_OBJECT_TYPE_DEVICE = 3, + VK_OBJECT_TYPE_QUEUE = 4, + VK_OBJECT_TYPE_SEMAPHORE = 5, + VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + VK_OBJECT_TYPE_FENCE = 7, + VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + VK_OBJECT_TYPE_BUFFER = 9, + VK_OBJECT_TYPE_IMAGE = 10, + VK_OBJECT_TYPE_EVENT = 11, + VK_OBJECT_TYPE_QUERY_POOL = 12, + VK_OBJECT_TYPE_BUFFER_VIEW = 13, + VK_OBJECT_TYPE_IMAGE_VIEW = 14, + VK_OBJECT_TYPE_SHADER_MODULE = 15, + VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + VK_OBJECT_TYPE_RENDER_PASS = 18, + VK_OBJECT_TYPE_PIPELINE = 19, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + VK_OBJECT_TYPE_SAMPLER = 21, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + VK_OBJECT_TYPE_FRAMEBUFFER = 24, + VK_OBJECT_TYPE_COMMAND_POOL = 25, + VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000, + VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000, + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001, + VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN, + VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL, + VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1), + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkObjectType; + typedef VkFlags VkInstanceCreateFlags; typedef enum VkFormatFeatureFlagBits { @@ -915,6 +1034,7 @@ typedef enum VkFormatFeatureFlagBits { VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000, VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000, VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkFormatFeatureFlagBits; typedef VkFlags VkFormatFeatureFlags; @@ -1192,6 +1312,7 @@ typedef enum VkAccessFlagBits { VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000, VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000, + VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF } VkAccessFlagBits; typedef VkFlags VkAccessFlags; @@ -3323,6 +3444,8 @@ typedef enum VkPresentModeKHR { VK_PRESENT_MODE_MAILBOX_KHR = 1, VK_PRESENT_MODE_FIFO_KHR = 2, VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR, VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1), @@ -3817,7 +3940,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( #define VK_KHR_win32_surface 1 #include -#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5 +#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 #define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" typedef VkFlags VkWin32SurfaceCreateFlagsKHR; @@ -3982,6 +4105,377 @@ VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( VkCommandPoolTrimFlagsKHR flags); #endif +#define VK_KHR_external_memory_capabilities 1 +#define VK_LUID_SIZE_KHR 8 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" + + +typedef enum VkExternalMemoryHandleTypeFlagBitsKHR { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = 0x00000010, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = 0x00000020, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = 0x00000040, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBitsKHR; +typedef VkFlags VkExternalMemoryHandleTypeFlagsKHR; + +typedef enum VkExternalMemoryFeatureFlagBitsKHR { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBitsKHR; +typedef VkFlags VkExternalMemoryFeatureFlagsKHR; + +typedef struct VkExternalMemoryPropertiesKHR { + VkExternalMemoryFeatureFlagsKHR externalMemoryFeatures; + VkExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes; +} VkExternalMemoryPropertiesKHR; + +typedef struct VkPhysicalDeviceExternalImageFormatInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalImageFormatInfoKHR; + +typedef struct VkExternalImageFormatPropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalMemoryPropertiesKHR externalMemoryProperties; +} VkExternalImageFormatPropertiesKHR; + +typedef struct VkPhysicalDeviceExternalBufferInfoKHR { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalBufferInfoKHR; + +typedef struct VkExternalBufferPropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalMemoryPropertiesKHR externalMemoryProperties; +} VkExternalBufferPropertiesKHR; + +typedef struct VkPhysicalDeviceIDPropertiesKHR { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE_KHR]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDPropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, + VkExternalBufferPropertiesKHR* pExternalBufferProperties); +#endif + +#define VK_KHR_external_memory 1 +#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" +#define VK_QUEUE_FAMILY_EXTERNAL_KHR (~0U-1) + +typedef struct VkExternalMemoryImageCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHR handleTypes; +} VkExternalMemoryImageCreateInfoKHR; + +typedef struct VkExternalMemoryBufferCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHR handleTypes; +} VkExternalMemoryBufferCreateInfoKHR; + +typedef struct VkExportMemoryAllocateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsKHR handleTypes; +} VkExportMemoryAllocateInfoKHR; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_external_memory_win32 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" + +typedef struct VkImportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; +} VkImportMemoryWin32HandleInfoKHR; + +typedef struct VkExportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportMemoryWin32HandleInfoKHR; + +typedef struct VkMemoryWin32HandlePropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryWin32HandlePropertiesKHR; + +typedef struct VkMemoryGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkMemoryGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_memory_fd 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" + +typedef struct VkImportMemoryFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; + int fd; +} VkImportMemoryFdInfoKHR; + +typedef struct VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBitsKHR handleType; +} VkMemoryGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); +#endif + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_win32_keyed_mutex 1 +#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" + +typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeouts; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoKHR; + + +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_semaphore_capabilities 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" + + +typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHR { + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = 0x00000008, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000010, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalSemaphoreHandleTypeFlagBitsKHR; +typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHR; + +typedef enum VkExternalSemaphoreFeatureFlagBitsKHR { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalSemaphoreFeatureFlagBitsKHR; +typedef VkFlags VkExternalSemaphoreFeatureFlagsKHR; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalSemaphoreInfoKHR; + +typedef struct VkExternalSemaphorePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes; + VkExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures; +} VkExternalSemaphorePropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties); +#endif + +#define VK_KHR_external_semaphore 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" + + +typedef enum VkSemaphoreImportFlagBitsKHR { + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSemaphoreImportFlagBitsKHR; +typedef VkFlags VkSemaphoreImportFlagsKHR; + +typedef struct VkExportSemaphoreCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagsKHR handleTypes; +} VkExportSemaphoreCreateInfoKHR; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_external_semaphore_win32 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" + +typedef struct VkImportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlagsKHR flags; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; +} VkImportSemaphoreWin32HandleInfoKHR; + +typedef struct VkExportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportSemaphoreWin32HandleInfoKHR; + +typedef struct VkD3D12FenceSubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues; +} VkD3D12FenceSubmitInfoKHR; + +typedef struct VkSemaphoreGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +} VkSemaphoreGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_semaphore_fd 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" + +typedef struct VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlagsKHR flags; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + +typedef struct VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBitsKHR handleType; +} VkSemaphoreGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + #define VK_KHR_push_descriptor 1 #define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1 #define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" @@ -4005,6 +4499,21 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( const VkWriteDescriptorSet* pDescriptorWrites); #endif +#define VK_KHR_16bit_storage 1 +#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" + +typedef struct VkPhysicalDevice16BitStorageFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeaturesKHR; + + + #define VK_KHR_incremental_present 1 #define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1 #define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" @@ -4101,12 +4610,311 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( const void* pData); #endif +#define VK_KHR_shared_presentable_image 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" + +typedef struct VkSharedPresentSurfaceCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilitiesKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain); +#endif + +#define VK_KHR_external_fence_capabilities 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" + + +typedef enum VkExternalFenceHandleTypeFlagBitsKHR { + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000008, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalFenceHandleTypeFlagBitsKHR; +typedef VkFlags VkExternalFenceHandleTypeFlagsKHR; + +typedef enum VkExternalFenceFeatureFlagBitsKHR { + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkExternalFenceFeatureFlagBitsKHR; +typedef VkFlags VkExternalFenceFeatureFlagsKHR; + +typedef struct VkPhysicalDeviceExternalFenceInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagBitsKHR handleType; +} VkPhysicalDeviceExternalFenceInfoKHR; + +typedef struct VkExternalFencePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlagsKHR compatibleHandleTypes; + VkExternalFenceFeatureFlagsKHR externalFenceFeatures; +} VkExternalFencePropertiesKHR; + + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, + VkExternalFencePropertiesKHR* pExternalFenceProperties); +#endif + +#define VK_KHR_external_fence 1 +#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" + + +typedef enum VkFenceImportFlagBitsKHR { + VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkFenceImportFlagBitsKHR; +typedef VkFlags VkFenceImportFlagsKHR; + +typedef struct VkExportFenceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagsKHR handleTypes; +} VkExportFenceCreateInfoKHR; + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#define VK_KHR_external_fence_win32 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" + +typedef struct VkImportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlagsKHR flags; + VkExternalFenceHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; +} VkImportFenceWin32HandleInfoKHR; + +typedef struct VkExportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportFenceWin32HandleInfoKHR; + +typedef struct VkFenceGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBitsKHR handleType; +} VkFenceGetWin32HandleInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#define VK_KHR_external_fence_fd 1 +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" + +typedef struct VkImportFenceFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlagsKHR flags; + VkExternalFenceHandleTypeFlagBitsKHR handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkFenceGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBitsKHR handleType; +} VkFenceGetFdInfoKHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + +#define VK_KHR_get_surface_capabilities2 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" + +typedef struct VkPhysicalDeviceSurfaceInfo2KHR { + VkStructureType sType; + const void* pNext; + VkSurfaceKHR surface; +} VkPhysicalDeviceSurfaceInfo2KHR; + +typedef struct VkSurfaceCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceCapabilitiesKHR surfaceCapabilities; +} VkSurfaceCapabilities2KHR; + +typedef struct VkSurfaceFormat2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceFormatKHR surfaceFormat; +} VkSurfaceFormat2KHR; + + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); +#endif + +#define VK_KHR_variable_pointers 1 +#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 +#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" + +typedef struct VkPhysicalDeviceVariablePointerFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointerFeaturesKHR; + + + +#define VK_KHR_dedicated_allocation 1 +#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 1 +#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" + +typedef struct VkMemoryDedicatedRequirementsKHR { + VkStructureType sType; + void* pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirementsKHR; + +typedef struct VkMemoryDedicatedAllocateInfoKHR { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkMemoryDedicatedAllocateInfoKHR; + + + +#define VK_KHR_storage_buffer_storage_class 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" + + +#define VK_KHR_get_memory_requirements2 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" + +typedef struct VkBufferMemoryRequirementsInfo2KHR { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferMemoryRequirementsInfo2KHR; + +typedef struct VkImageMemoryRequirementsInfo2KHR { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageMemoryRequirementsInfo2KHR; + +typedef struct VkImageSparseMemoryRequirementsInfo2KHR { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageSparseMemoryRequirementsInfo2KHR; + +typedef struct VkMemoryRequirements2KHR { + VkStructureType sType; + void* pNext; + VkMemoryRequirements memoryRequirements; +} VkMemoryRequirements2KHR; + +typedef struct VkSparseImageMemoryRequirements2KHR { + VkStructureType sType; + void* pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} VkSparseImageMemoryRequirements2KHR; + + +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements); +#endif + #define VK_EXT_debug_report 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) -#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 6 +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 8 #define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" #define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT +#define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT typedef enum VkDebugReportObjectTypeEXT { @@ -4138,7 +4946,7 @@ typedef enum VkDebugReportObjectTypeEXT { VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31, @@ -4150,15 +4958,6 @@ typedef enum VkDebugReportObjectTypeEXT { VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF } VkDebugReportObjectTypeEXT; -typedef enum VkDebugReportErrorEXT { - VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, - VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, - VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_ERROR_NONE_EXT, - VK_DEBUG_REPORT_ERROR_END_RANGE_EXT = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT, - VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT - VK_DEBUG_REPORT_ERROR_NONE_EXT + 1), - VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugReportErrorEXT; - typedef enum VkDebugReportFlagBitsEXT { VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, @@ -4388,6 +5187,18 @@ VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( #define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" +#define VK_AMD_texture_gather_bias_lod 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" + +typedef struct VkTextureLODGatherFormatPropertiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 supportsTextureGatherLODBiasAMD; +} VkTextureLODGatherFormatPropertiesAMD; + + + #define VK_KHX_multiview 1 #define VK_KHX_MULTIVIEW_SPEC_VERSION 1 #define VK_KHX_MULTIVIEW_EXTENSION_NAME "VK_KHX_multiview" @@ -4743,9 +5554,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHX( typedef enum VkValidationCheckEXT { VK_VALIDATION_CHECK_ALL_EXT = 0, + VK_VALIDATION_CHECK_SHADERS_EXT = 1, VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, - VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, - VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_ALL_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1), + VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT, + VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1), VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF } VkValidationCheckEXT; @@ -4823,341 +5635,6 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHX( VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties); #endif -#define VK_KHX_external_memory_capabilities 1 -#define VK_LUID_SIZE_KHX 8 -#define VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHX_external_memory_capabilities" - - -typedef enum VkExternalMemoryHandleTypeFlagBitsKHX { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX = 0x00000010, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX = 0x00000020, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX = 0x00000040, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF -} VkExternalMemoryHandleTypeFlagBitsKHX; -typedef VkFlags VkExternalMemoryHandleTypeFlagsKHX; - -typedef enum VkExternalMemoryFeatureFlagBitsKHX { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX = 0x00000004, - VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF -} VkExternalMemoryFeatureFlagBitsKHX; -typedef VkFlags VkExternalMemoryFeatureFlagsKHX; - -typedef struct VkExternalMemoryPropertiesKHX { - VkExternalMemoryFeatureFlagsKHX externalMemoryFeatures; - VkExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes; - VkExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes; -} VkExternalMemoryPropertiesKHX; - -typedef struct VkPhysicalDeviceExternalImageFormatInfoKHX { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBitsKHX handleType; -} VkPhysicalDeviceExternalImageFormatInfoKHX; - -typedef struct VkExternalImageFormatPropertiesKHX { - VkStructureType sType; - void* pNext; - VkExternalMemoryPropertiesKHX externalMemoryProperties; -} VkExternalImageFormatPropertiesKHX; - -typedef struct VkPhysicalDeviceExternalBufferInfoKHX { - VkStructureType sType; - const void* pNext; - VkBufferCreateFlags flags; - VkBufferUsageFlags usage; - VkExternalMemoryHandleTypeFlagBitsKHX handleType; -} VkPhysicalDeviceExternalBufferInfoKHX; - -typedef struct VkExternalBufferPropertiesKHX { - VkStructureType sType; - void* pNext; - VkExternalMemoryPropertiesKHX externalMemoryProperties; -} VkExternalBufferPropertiesKHX; - -typedef struct VkPhysicalDeviceIDPropertiesKHX { - VkStructureType sType; - void* pNext; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE_KHX]; - VkBool32 deviceLUIDValid; -} VkPhysicalDeviceIDPropertiesKHX; - - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHX)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, VkExternalBufferPropertiesKHX* pExternalBufferProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHX( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, - VkExternalBufferPropertiesKHX* pExternalBufferProperties); -#endif - -#define VK_KHX_external_memory 1 -#define VK_KHX_EXTERNAL_MEMORY_SPEC_VERSION 1 -#define VK_KHX_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHX_external_memory" -#define VK_QUEUE_FAMILY_EXTERNAL_KHX (~0U-1) - -typedef struct VkExternalMemoryImageCreateInfoKHX { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsKHX handleTypes; -} VkExternalMemoryImageCreateInfoKHX; - -typedef struct VkExternalMemoryBufferCreateInfoKHX { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsKHX handleTypes; -} VkExternalMemoryBufferCreateInfoKHX; - -typedef struct VkExportMemoryAllocateInfoKHX { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsKHX handleTypes; -} VkExportMemoryAllocateInfoKHX; - - - -#ifdef VK_USE_PLATFORM_WIN32_KHX -#define VK_KHX_external_memory_win32 1 -#define VK_KHX_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 -#define VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHX_external_memory_win32" - -typedef struct VkImportMemoryWin32HandleInfoKHX { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBitsKHX handleType; - HANDLE handle; -} VkImportMemoryWin32HandleInfoKHX; - -typedef struct VkExportMemoryWin32HandleInfoKHX { - VkStructureType sType; - const void* pNext; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; -} VkExportMemoryWin32HandleInfoKHX; - -typedef struct VkMemoryWin32HandlePropertiesKHX { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryWin32HandlePropertiesKHX; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHX)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE* pHandle); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHX)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHX( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, - HANDLE* pHandle); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHX( - VkDevice device, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties); -#endif -#endif /* VK_USE_PLATFORM_WIN32_KHX */ - -#define VK_KHX_external_memory_fd 1 -#define VK_KHX_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 -#define VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHX_external_memory_fd" - -typedef struct VkImportMemoryFdInfoKHX { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBitsKHX handleType; - int fd; -} VkImportMemoryFdInfoKHX; - -typedef struct VkMemoryFdPropertiesKHX { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryFdPropertiesKHX; - - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHX)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHX)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, VkMemoryFdPropertiesKHX* pMemoryFdProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHX( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, - int* pFd); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHX( - VkDevice device, - VkExternalMemoryHandleTypeFlagBitsKHX handleType, - int fd, - VkMemoryFdPropertiesKHX* pMemoryFdProperties); -#endif - -#ifdef VK_USE_PLATFORM_WIN32_KHR -#define VK_KHX_win32_keyed_mutex 1 -#define VK_KHX_WIN32_KEYED_MUTEX_SPEC_VERSION 1 -#define VK_KHX_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHX_win32_keyed_mutex" - -typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHX { - VkStructureType sType; - const void* pNext; - uint32_t acquireCount; - const VkDeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeouts; - uint32_t releaseCount; - const VkDeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; -} VkWin32KeyedMutexAcquireReleaseInfoKHX; - - -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - -#define VK_KHX_external_semaphore_capabilities 1 -#define VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHX_external_semaphore_capabilities" - - -typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHX { - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX = 0x00000001, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX = 0x00000002, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX = 0x00000004, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX = 0x00000008, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX = 0x00000010, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF -} VkExternalSemaphoreHandleTypeFlagBitsKHX; -typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHX; - -typedef enum VkExternalSemaphoreFeatureFlagBitsKHX { - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX = 0x00000001, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX = 0x00000002, - VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF -} VkExternalSemaphoreFeatureFlagBitsKHX; -typedef VkFlags VkExternalSemaphoreFeatureFlagsKHX; - -typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHX { - VkStructureType sType; - const void* pNext; - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType; -} VkPhysicalDeviceExternalSemaphoreInfoKHX; - -typedef struct VkExternalSemaphorePropertiesKHX { - VkStructureType sType; - void* pNext; - VkExternalSemaphoreHandleTypeFlagsKHX exportFromImportedHandleTypes; - VkExternalSemaphoreHandleTypeFlagsKHX compatibleHandleTypes; - VkExternalSemaphoreFeatureFlagsKHX externalSemaphoreFeatures; -} VkExternalSemaphorePropertiesKHX; - - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHX( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, - VkExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties); -#endif - -#define VK_KHX_external_semaphore 1 -#define VK_KHX_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 -#define VK_KHX_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHX_external_semaphore" - -typedef struct VkExportSemaphoreCreateInfoKHX { - VkStructureType sType; - const void* pNext; - VkExternalSemaphoreHandleTypeFlagsKHX handleTypes; -} VkExportSemaphoreCreateInfoKHX; - - - -#ifdef VK_USE_PLATFORM_WIN32_KHX -#define VK_KHX_external_semaphore_win32 1 -#define VK_KHX_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 -#define VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHX_external_semaphore_win32" - -typedef struct VkImportSemaphoreWin32HandleInfoKHX { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagsKHX handleType; - HANDLE handle; -} VkImportSemaphoreWin32HandleInfoKHX; - -typedef struct VkExportSemaphoreWin32HandleInfoKHX { - VkStructureType sType; - const void* pNext; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; -} VkExportSemaphoreWin32HandleInfoKHX; - -typedef struct VkD3D12FenceSubmitInfoKHX { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreValuesCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValuesCount; - const uint64_t* pSignalSemaphoreValues; -} VkD3D12FenceSubmitInfoKHX; - - -typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHX)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHX)(VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE* pHandle); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHX( - VkDevice device, - const VkImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHX( - VkDevice device, - VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, - HANDLE* pHandle); -#endif -#endif /* VK_USE_PLATFORM_WIN32_KHX */ - -#define VK_KHX_external_semaphore_fd 1 -#define VK_KHX_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 -#define VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHX_external_semaphore_fd" - -typedef struct VkImportSemaphoreFdInfoKHX { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType; - int fd; -} VkImportSemaphoreFdInfoKHX; - - -typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHX)(VkDevice device, const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHX)(VkDevice device, VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHX( - VkDevice device, - const VkImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHX( - VkDevice device, - VkSemaphore semaphore, - VkExternalSemaphoreHandleTypeFlagBitsKHX handleType, - int* pFd); -#endif - #define VK_NVX_device_generated_commands 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) @@ -5167,29 +5644,29 @@ VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX) typedef enum VkIndirectCommandsTokenTypeNVX { - VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX = 0, - VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX = 1, - VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX = 2, - VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX = 3, - VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX = 4, - VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX = 5, - VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX = 6, - VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX = 7, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX + 1), + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1), VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF } VkIndirectCommandsTokenTypeNVX; typedef enum VkObjectEntryTypeNVX { - VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX = 0, - VK_OBJECT_ENTRY_PIPELINE_NVX = 1, - VK_OBJECT_ENTRY_INDEX_BUFFER_NVX = 2, - VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX = 3, - VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX = 4, - VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX, - VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX, - VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX + 1), + VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0, + VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1, + VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2, + VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3, + VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4, + VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, + VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX, + VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1), VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF } VkObjectEntryTypeNVX; @@ -5816,6 +6293,134 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( #endif #endif /* VK_USE_PLATFORM_MACOS_MVK */ +#define VK_EXT_sampler_filter_minmax 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" + + +typedef enum VkSamplerReductionModeEXT { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0, + VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1, + VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2, + VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, + VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT, + VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1), + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSamplerReductionModeEXT; + +typedef struct VkSamplerReductionModeCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSamplerReductionModeEXT reductionMode; +} VkSamplerReductionModeCreateInfoEXT; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + + + +#define VK_AMD_gpu_shader_int16 1 +#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1 +#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" + + +#define VK_EXT_blend_operation_advanced 1 +#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 +#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" + + +typedef enum VkBlendOverlapEXT { + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT, + VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT, + VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1), + VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBlendOverlapEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + + +#define VK_NV_fragment_coverage_to_color 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" + +typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; + +typedef struct VkPipelineCoverageToColorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV; + + + +#define VK_NV_framebuffer_mixed_samples 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" + + +typedef enum VkCoverageModulationModeNV { + VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, + VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, + VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, + VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, + VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV, + VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV, + VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1), + VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageModulationModeNV; + +typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; + +typedef struct VkPipelineCoverageModulationStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; +} VkPipelineCoverageModulationStateCreateInfoNV; + + + +#define VK_NV_fill_rectangle 1 +#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 +#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" + + #ifdef __cplusplus } #endif diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp index 0199195b2..ef8eed3b6 100644 --- a/third_party/vulkan/vulkan.hpp +++ b/third_party/vulkan/vulkan.hpp @@ -1,27 +1,19 @@ // Copyright (c) 2015-2017 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: +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at // -// The above copyright notice and this permission notice shall be included -// in all copies or substantial portions of the Materials. +// http://www.apache.org/licenses/LICENSE-2.0 // -// 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. +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. // This header is generated from the Khronos Vulkan XML API Registry. - #ifndef VULKAN_HPP #define VULKAN_HPP @@ -41,8 +33,7 @@ # include # include #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -static_assert( VK_HEADER_VERSION == 46 , "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 54 , "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -93,6 +84,7 @@ static_assert( VK_HEADER_VERSION == 46 , "Wrong VK_HEADER_VERSION!" ); namespace vk { + template struct FlagTraits { enum { allFlags = 0 }; @@ -197,19 +189,19 @@ namespace vk private: MaskType m_mask; }; - + template Flags operator|(BitType bit, Flags const& flags) { return flags | bit; } - + template Flags operator&(BitType bit, Flags const& flags) { return flags & bit; } - + template Flags operator^(BitType bit, Flags const& flags) { @@ -325,7 +317,6 @@ namespace vk }; #endif - #if defined(VULKAN_HPP_NO_EXCEPTIONS) && !defined(VULKAN_HPP_NO_SMART_HANDLE) # define VULKAN_HPP_NO_SMART_HANDLE #endif @@ -462,7 +453,7 @@ namespace vk eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT, eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV, eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR, - eErrorInvalidExternalHandleKHX = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHX + eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR }; VULKAN_HPP_INLINE std::string to_string(Result value) @@ -495,11 +486,12 @@ namespace vk case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT"; case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV"; case Result::eErrorOutOfPoolMemoryKHR: return "ErrorOutOfPoolMemoryKHR"; - case Result::eErrorInvalidExternalHandleKHX: return "ErrorInvalidExternalHandleKHX"; + case Result::eErrorInvalidExternalHandleKHR: return "ErrorInvalidExternalHandleKHR"; default: return "invalid"; } } + #if defined(_MSC_VER) && (_MSC_VER == 1800) # define noexcept _NOEXCEPT #endif @@ -531,6 +523,244 @@ namespace vk return std::error_condition(static_cast(e), errorCategory()); } +#if defined(_MSC_VER) && (_MSC_VER == 1800) +# define noexcept _NOEXCEPT +#endif + + class Error + { + public: + virtual ~Error() = default; + + virtual const char* what() const noexcept = 0; + }; + + class LogicError : public Error, public std::logic_error + { + public: + explicit LogicError( const std::string& what ) + : Error(), std::logic_error(what) {} + explicit LogicError( char const * what ) + : Error(), std::logic_error(what) {} + virtual ~LogicError() = default; + + virtual const char* what() const noexcept { return std::logic_error::what(); } + }; + + class SystemError : public Error, public std::system_error + { + public: + SystemError( std::error_code ec ) + : Error(), std::system_error(ec) {} + SystemError( std::error_code ec, std::string const& what ) + : Error(), std::system_error(ec, what) {} + SystemError( std::error_code ec, char const * what ) + : Error(), std::system_error(ec, what) {} + SystemError( int ev, std::error_category const& ecat ) + : Error(), std::system_error(ev, ecat) {} + SystemError( int ev, std::error_category const& ecat, std::string const& what) + : Error(), std::system_error(ev, ecat, what) {} + SystemError( int ev, std::error_category const& ecat, char const * what) + : Error(), std::system_error(ev, ecat, what) {} + virtual ~SystemError() = default; + + virtual const char* what() const noexcept { return std::system_error::what(); } + }; + +#if defined(_MSC_VER) && (_MSC_VER == 1800) +# undef noexcept +#endif + + class OutOfHostMemoryError : public SystemError + { + public: + OutOfHostMemoryError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} + OutOfHostMemoryError( char const * message ) + : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} + }; + class OutOfDeviceMemoryError : public SystemError + { + public: + OutOfDeviceMemoryError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} + OutOfDeviceMemoryError( char const * message ) + : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} + }; + class InitializationFailedError : public SystemError + { + public: + InitializationFailedError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} + InitializationFailedError( char const * message ) + : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} + }; + class DeviceLostError : public SystemError + { + public: + DeviceLostError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} + DeviceLostError( char const * message ) + : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} + }; + class MemoryMapFailedError : public SystemError + { + public: + MemoryMapFailedError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} + MemoryMapFailedError( char const * message ) + : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} + }; + class LayerNotPresentError : public SystemError + { + public: + LayerNotPresentError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} + LayerNotPresentError( char const * message ) + : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} + }; + class ExtensionNotPresentError : public SystemError + { + public: + ExtensionNotPresentError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} + ExtensionNotPresentError( char const * message ) + : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} + }; + class FeatureNotPresentError : public SystemError + { + public: + FeatureNotPresentError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} + FeatureNotPresentError( char const * message ) + : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} + }; + class IncompatibleDriverError : public SystemError + { + public: + IncompatibleDriverError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} + IncompatibleDriverError( char const * message ) + : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} + }; + class TooManyObjectsError : public SystemError + { + public: + TooManyObjectsError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} + TooManyObjectsError( char const * message ) + : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} + }; + class FormatNotSupportedError : public SystemError + { + public: + FormatNotSupportedError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} + FormatNotSupportedError( char const * message ) + : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} + }; + class FragmentedPoolError : public SystemError + { + public: + FragmentedPoolError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} + FragmentedPoolError( char const * message ) + : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} + }; + class SurfaceLostKHRError : public SystemError + { + public: + SurfaceLostKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} + SurfaceLostKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} + }; + class NativeWindowInUseKHRError : public SystemError + { + public: + NativeWindowInUseKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} + NativeWindowInUseKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} + }; + class OutOfDateKHRError : public SystemError + { + public: + OutOfDateKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} + OutOfDateKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} + }; + class IncompatibleDisplayKHRError : public SystemError + { + public: + IncompatibleDisplayKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} + IncompatibleDisplayKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} + }; + class ValidationFailedEXTError : public SystemError + { + public: + ValidationFailedEXTError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {} + ValidationFailedEXTError( char const * message ) + : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {} + }; + class InvalidShaderNVError : public SystemError + { + public: + InvalidShaderNVError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} + InvalidShaderNVError( char const * message ) + : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} + }; + class OutOfPoolMemoryKHRError : public SystemError + { + public: + OutOfPoolMemoryKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {} + OutOfPoolMemoryKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {} + }; + class InvalidExternalHandleKHRError : public SystemError + { + public: + InvalidExternalHandleKHRError( std::string const& message ) + : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHR ), message ) {} + InvalidExternalHandleKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHR ), message ) {} + }; + + VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) + { + assert ( static_cast(result) < 0 ); + switch ( result ) + { + case Result::eErrorOutOfHostMemory: throw OutOfHostMemoryError ( message ); + case Result::eErrorOutOfDeviceMemory: throw OutOfDeviceMemoryError ( message ); + case Result::eErrorInitializationFailed: throw InitializationFailedError ( message ); + case Result::eErrorDeviceLost: throw DeviceLostError ( message ); + case Result::eErrorMemoryMapFailed: throw MemoryMapFailedError ( message ); + case Result::eErrorLayerNotPresent: throw LayerNotPresentError ( message ); + case Result::eErrorExtensionNotPresent: throw ExtensionNotPresentError ( message ); + case Result::eErrorFeatureNotPresent: throw FeatureNotPresentError ( message ); + case Result::eErrorIncompatibleDriver: throw IncompatibleDriverError ( message ); + case Result::eErrorTooManyObjects: throw TooManyObjectsError ( message ); + case Result::eErrorFormatNotSupported: throw FormatNotSupportedError ( message ); + case Result::eErrorFragmentedPool: throw FragmentedPoolError ( message ); + case Result::eErrorSurfaceLostKHR: throw SurfaceLostKHRError ( message ); + case Result::eErrorNativeWindowInUseKHR: throw NativeWindowInUseKHRError ( message ); + case Result::eErrorOutOfDateKHR: throw OutOfDateKHRError ( message ); + case Result::eErrorIncompatibleDisplayKHR: throw IncompatibleDisplayKHRError ( message ); + case Result::eErrorValidationFailedEXT: throw ValidationFailedEXTError ( message ); + case Result::eErrorInvalidShaderNV: throw InvalidShaderNVError ( message ); + case Result::eErrorOutOfPoolMemoryKHR: throw OutOfPoolMemoryKHRError ( message ); + case Result::eErrorInvalidExternalHandleKHR: throw InvalidExternalHandleKHRError ( message ); + default: throw SystemError( make_error_code( result ) ); + } + } + } // namespace vk namespace std @@ -542,6 +772,7 @@ namespace std namespace vk { + template struct ResultValue { @@ -566,7 +797,8 @@ namespace vk #endif }; - template <> struct ResultValueType + template <> + struct ResultValueType { #ifdef VULKAN_HPP_NO_EXCEPTIONS typedef Result type; @@ -583,7 +815,7 @@ namespace vk #else if ( result != Result::eSuccess ) { - throw std::system_error( result, message ); + throwResultException( result, message ); } #endif } @@ -597,7 +829,7 @@ namespace vk #else if ( result != Result::eSuccess ) { - throw std::system_error( result, message ); + throwResultException( result, message ); } return data; #endif @@ -610,7 +842,7 @@ namespace vk #else if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) { - throw std::system_error( result, message ); + throwResultException( result, message ); } #endif return result; @@ -624,7 +856,7 @@ namespace vk #else if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) { - throw std::system_error( result, message ); + throwResultException( result, message ); } #endif return ResultValue( result, data ); @@ -642,319 +874,174 @@ namespace vk using FramebufferCreateFlags = Flags; - VULKAN_HPP_INLINE FramebufferCreateFlags operator|( FramebufferCreateFlagBits bit0, FramebufferCreateFlagBits bit1 ) - { - return FramebufferCreateFlags( bit0 ) | bit1; - } - enum class QueryPoolCreateFlagBits { }; using QueryPoolCreateFlags = Flags; - VULKAN_HPP_INLINE QueryPoolCreateFlags operator|( QueryPoolCreateFlagBits bit0, QueryPoolCreateFlagBits bit1 ) - { - return QueryPoolCreateFlags( bit0 ) | bit1; - } - enum class RenderPassCreateFlagBits { }; using RenderPassCreateFlags = Flags; - VULKAN_HPP_INLINE RenderPassCreateFlags operator|( RenderPassCreateFlagBits bit0, RenderPassCreateFlagBits bit1 ) - { - return RenderPassCreateFlags( bit0 ) | bit1; - } - enum class SamplerCreateFlagBits { }; using SamplerCreateFlags = Flags; - VULKAN_HPP_INLINE SamplerCreateFlags operator|( SamplerCreateFlagBits bit0, SamplerCreateFlagBits bit1 ) - { - return SamplerCreateFlags( bit0 ) | bit1; - } - enum class PipelineLayoutCreateFlagBits { }; using PipelineLayoutCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineLayoutCreateFlags operator|( PipelineLayoutCreateFlagBits bit0, PipelineLayoutCreateFlagBits bit1 ) - { - return PipelineLayoutCreateFlags( bit0 ) | bit1; - } - enum class PipelineCacheCreateFlagBits { }; using PipelineCacheCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineCacheCreateFlags operator|( PipelineCacheCreateFlagBits bit0, PipelineCacheCreateFlagBits bit1 ) - { - return PipelineCacheCreateFlags( bit0 ) | bit1; - } - enum class PipelineDepthStencilStateCreateFlagBits { }; using PipelineDepthStencilStateCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineDepthStencilStateCreateFlags operator|( PipelineDepthStencilStateCreateFlagBits bit0, PipelineDepthStencilStateCreateFlagBits bit1 ) - { - return PipelineDepthStencilStateCreateFlags( bit0 ) | bit1; - } - enum class PipelineDynamicStateCreateFlagBits { }; using PipelineDynamicStateCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineDynamicStateCreateFlags operator|( PipelineDynamicStateCreateFlagBits bit0, PipelineDynamicStateCreateFlagBits bit1 ) - { - return PipelineDynamicStateCreateFlags( bit0 ) | bit1; - } - enum class PipelineColorBlendStateCreateFlagBits { }; using PipelineColorBlendStateCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineColorBlendStateCreateFlags operator|( PipelineColorBlendStateCreateFlagBits bit0, PipelineColorBlendStateCreateFlagBits bit1 ) - { - return PipelineColorBlendStateCreateFlags( bit0 ) | bit1; - } - enum class PipelineMultisampleStateCreateFlagBits { }; using PipelineMultisampleStateCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineMultisampleStateCreateFlags operator|( PipelineMultisampleStateCreateFlagBits bit0, PipelineMultisampleStateCreateFlagBits bit1 ) - { - return PipelineMultisampleStateCreateFlags( bit0 ) | bit1; - } - enum class PipelineRasterizationStateCreateFlagBits { }; using PipelineRasterizationStateCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineRasterizationStateCreateFlags operator|( PipelineRasterizationStateCreateFlagBits bit0, PipelineRasterizationStateCreateFlagBits bit1 ) - { - return PipelineRasterizationStateCreateFlags( bit0 ) | bit1; - } - enum class PipelineViewportStateCreateFlagBits { }; using PipelineViewportStateCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineViewportStateCreateFlags operator|( PipelineViewportStateCreateFlagBits bit0, PipelineViewportStateCreateFlagBits bit1 ) - { - return PipelineViewportStateCreateFlags( bit0 ) | bit1; - } - enum class PipelineTessellationStateCreateFlagBits { }; using PipelineTessellationStateCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineTessellationStateCreateFlags operator|( PipelineTessellationStateCreateFlagBits bit0, PipelineTessellationStateCreateFlagBits bit1 ) - { - return PipelineTessellationStateCreateFlags( bit0 ) | bit1; - } - enum class PipelineInputAssemblyStateCreateFlagBits { }; using PipelineInputAssemblyStateCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineInputAssemblyStateCreateFlags operator|( PipelineInputAssemblyStateCreateFlagBits bit0, PipelineInputAssemblyStateCreateFlagBits bit1 ) - { - return PipelineInputAssemblyStateCreateFlags( bit0 ) | bit1; - } - enum class PipelineVertexInputStateCreateFlagBits { }; using PipelineVertexInputStateCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineVertexInputStateCreateFlags operator|( PipelineVertexInputStateCreateFlagBits bit0, PipelineVertexInputStateCreateFlagBits bit1 ) - { - return PipelineVertexInputStateCreateFlags( bit0 ) | bit1; - } - enum class PipelineShaderStageCreateFlagBits { }; using PipelineShaderStageCreateFlags = Flags; - VULKAN_HPP_INLINE PipelineShaderStageCreateFlags operator|( PipelineShaderStageCreateFlagBits bit0, PipelineShaderStageCreateFlagBits bit1 ) - { - return PipelineShaderStageCreateFlags( bit0 ) | bit1; - } - enum class BufferViewCreateFlagBits { }; using BufferViewCreateFlags = Flags; - VULKAN_HPP_INLINE BufferViewCreateFlags operator|( BufferViewCreateFlagBits bit0, BufferViewCreateFlagBits bit1 ) - { - return BufferViewCreateFlags( bit0 ) | bit1; - } - enum class InstanceCreateFlagBits { }; using InstanceCreateFlags = Flags; - VULKAN_HPP_INLINE InstanceCreateFlags operator|( InstanceCreateFlagBits bit0, InstanceCreateFlagBits bit1 ) - { - return InstanceCreateFlags( bit0 ) | bit1; - } - enum class DeviceCreateFlagBits { }; using DeviceCreateFlags = Flags; - VULKAN_HPP_INLINE DeviceCreateFlags operator|( DeviceCreateFlagBits bit0, DeviceCreateFlagBits bit1 ) - { - return DeviceCreateFlags( bit0 ) | bit1; - } - enum class DeviceQueueCreateFlagBits { }; using DeviceQueueCreateFlags = Flags; - VULKAN_HPP_INLINE DeviceQueueCreateFlags operator|( DeviceQueueCreateFlagBits bit0, DeviceQueueCreateFlagBits bit1 ) - { - return DeviceQueueCreateFlags( bit0 ) | bit1; - } - enum class ImageViewCreateFlagBits { }; using ImageViewCreateFlags = Flags; - VULKAN_HPP_INLINE ImageViewCreateFlags operator|( ImageViewCreateFlagBits bit0, ImageViewCreateFlagBits bit1 ) - { - return ImageViewCreateFlags( bit0 ) | bit1; - } - enum class SemaphoreCreateFlagBits { }; using SemaphoreCreateFlags = Flags; - VULKAN_HPP_INLINE SemaphoreCreateFlags operator|( SemaphoreCreateFlagBits bit0, SemaphoreCreateFlagBits bit1 ) - { - return SemaphoreCreateFlags( bit0 ) | bit1; - } - enum class ShaderModuleCreateFlagBits { }; using ShaderModuleCreateFlags = Flags; - VULKAN_HPP_INLINE ShaderModuleCreateFlags operator|( ShaderModuleCreateFlagBits bit0, ShaderModuleCreateFlagBits bit1 ) - { - return ShaderModuleCreateFlags( bit0 ) | bit1; - } - enum class EventCreateFlagBits { }; using EventCreateFlags = Flags; - VULKAN_HPP_INLINE EventCreateFlags operator|( EventCreateFlagBits bit0, EventCreateFlagBits bit1 ) - { - return EventCreateFlags( bit0 ) | bit1; - } - enum class MemoryMapFlagBits { }; using MemoryMapFlags = Flags; - VULKAN_HPP_INLINE MemoryMapFlags operator|( MemoryMapFlagBits bit0, MemoryMapFlagBits bit1 ) - { - return MemoryMapFlags( bit0 ) | bit1; - } - enum class DescriptorPoolResetFlagBits { }; using DescriptorPoolResetFlags = Flags; - VULKAN_HPP_INLINE DescriptorPoolResetFlags operator|( DescriptorPoolResetFlagBits bit0, DescriptorPoolResetFlagBits bit1 ) - { - return DescriptorPoolResetFlags( bit0 ) | bit1; - } - enum class DescriptorUpdateTemplateCreateFlagBitsKHR { }; using DescriptorUpdateTemplateCreateFlagsKHR = Flags; - VULKAN_HPP_INLINE DescriptorUpdateTemplateCreateFlagsKHR operator|( DescriptorUpdateTemplateCreateFlagBitsKHR bit0, DescriptorUpdateTemplateCreateFlagBitsKHR bit1 ) - { - return DescriptorUpdateTemplateCreateFlagsKHR( bit0 ) | bit1; - } - enum class DisplayModeCreateFlagBitsKHR { }; using DisplayModeCreateFlagsKHR = Flags; - VULKAN_HPP_INLINE DisplayModeCreateFlagsKHR operator|( DisplayModeCreateFlagBitsKHR bit0, DisplayModeCreateFlagBitsKHR bit1 ) - { - return DisplayModeCreateFlagsKHR( bit0 ) | bit1; - } - enum class DisplaySurfaceCreateFlagBitsKHR { }; using DisplaySurfaceCreateFlagsKHR = Flags; - VULKAN_HPP_INLINE DisplaySurfaceCreateFlagsKHR operator|( DisplaySurfaceCreateFlagBitsKHR bit0, DisplaySurfaceCreateFlagBitsKHR bit1 ) - { - return DisplaySurfaceCreateFlagsKHR( bit0 ) | bit1; - } - #ifdef VK_USE_PLATFORM_ANDROID_KHR enum class AndroidSurfaceCreateFlagBitsKHR { @@ -963,11 +1050,6 @@ namespace vk #ifdef VK_USE_PLATFORM_ANDROID_KHR using AndroidSurfaceCreateFlagsKHR = Flags; - - VULKAN_HPP_INLINE AndroidSurfaceCreateFlagsKHR operator|( AndroidSurfaceCreateFlagBitsKHR bit0, AndroidSurfaceCreateFlagBitsKHR bit1 ) - { - return AndroidSurfaceCreateFlagsKHR( bit0 ) | bit1; - } #endif /*VK_USE_PLATFORM_ANDROID_KHR*/ #ifdef VK_USE_PLATFORM_MIR_KHR @@ -978,11 +1060,6 @@ namespace vk #ifdef VK_USE_PLATFORM_MIR_KHR using MirSurfaceCreateFlagsKHR = Flags; - - VULKAN_HPP_INLINE MirSurfaceCreateFlagsKHR operator|( MirSurfaceCreateFlagBitsKHR bit0, MirSurfaceCreateFlagBitsKHR bit1 ) - { - return MirSurfaceCreateFlagsKHR( bit0 ) | bit1; - } #endif /*VK_USE_PLATFORM_MIR_KHR*/ #ifdef VK_USE_PLATFORM_VI_NN @@ -993,11 +1070,6 @@ namespace vk #ifdef VK_USE_PLATFORM_VI_NN using ViSurfaceCreateFlagsNN = Flags; - - VULKAN_HPP_INLINE ViSurfaceCreateFlagsNN operator|( ViSurfaceCreateFlagBitsNN bit0, ViSurfaceCreateFlagBitsNN bit1 ) - { - return ViSurfaceCreateFlagsNN( bit0 ) | bit1; - } #endif /*VK_USE_PLATFORM_VI_NN*/ #ifdef VK_USE_PLATFORM_WAYLAND_KHR @@ -1008,11 +1080,6 @@ namespace vk #ifdef VK_USE_PLATFORM_WAYLAND_KHR using WaylandSurfaceCreateFlagsKHR = Flags; - - VULKAN_HPP_INLINE WaylandSurfaceCreateFlagsKHR operator|( WaylandSurfaceCreateFlagBitsKHR bit0, WaylandSurfaceCreateFlagBitsKHR bit1 ) - { - return WaylandSurfaceCreateFlagsKHR( bit0 ) | bit1; - } #endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR @@ -1023,11 +1090,6 @@ namespace vk #ifdef VK_USE_PLATFORM_WIN32_KHR using Win32SurfaceCreateFlagsKHR = Flags; - - VULKAN_HPP_INLINE Win32SurfaceCreateFlagsKHR operator|( Win32SurfaceCreateFlagBitsKHR bit0, Win32SurfaceCreateFlagBitsKHR bit1 ) - { - return Win32SurfaceCreateFlagsKHR( bit0 ) | bit1; - } #endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_XLIB_KHR @@ -1038,11 +1100,6 @@ namespace vk #ifdef VK_USE_PLATFORM_XLIB_KHR using XlibSurfaceCreateFlagsKHR = Flags; - - VULKAN_HPP_INLINE XlibSurfaceCreateFlagsKHR operator|( XlibSurfaceCreateFlagBitsKHR bit0, XlibSurfaceCreateFlagBitsKHR bit1 ) - { - return XlibSurfaceCreateFlagsKHR( bit0 ) | bit1; - } #endif /*VK_USE_PLATFORM_XLIB_KHR*/ #ifdef VK_USE_PLATFORM_XCB_KHR @@ -1053,11 +1110,6 @@ namespace vk #ifdef VK_USE_PLATFORM_XCB_KHR using XcbSurfaceCreateFlagsKHR = Flags; - - VULKAN_HPP_INLINE XcbSurfaceCreateFlagsKHR operator|( XcbSurfaceCreateFlagBitsKHR bit0, XcbSurfaceCreateFlagBitsKHR bit1 ) - { - return XcbSurfaceCreateFlagsKHR( bit0 ) | bit1; - } #endif /*VK_USE_PLATFORM_XCB_KHR*/ #ifdef VK_USE_PLATFORM_IOS_MVK @@ -1068,11 +1120,6 @@ namespace vk #ifdef VK_USE_PLATFORM_IOS_MVK using IOSSurfaceCreateFlagsMVK = Flags; - - VULKAN_HPP_INLINE IOSSurfaceCreateFlagsMVK operator|( IOSSurfaceCreateFlagBitsMVK bit0, IOSSurfaceCreateFlagBitsMVK bit1 ) - { - return IOSSurfaceCreateFlagsMVK( bit0 ) | bit1; - } #endif /*VK_USE_PLATFORM_IOS_MVK*/ #ifdef VK_USE_PLATFORM_MACOS_MVK @@ -1083,11 +1130,6 @@ namespace vk #ifdef VK_USE_PLATFORM_MACOS_MVK using MacOSSurfaceCreateFlagsMVK = Flags; - - VULKAN_HPP_INLINE MacOSSurfaceCreateFlagsMVK operator|( MacOSSurfaceCreateFlagBitsMVK bit0, MacOSSurfaceCreateFlagBitsMVK bit1 ) - { - return MacOSSurfaceCreateFlagsMVK( bit0 ) | bit1; - } #endif /*VK_USE_PLATFORM_MACOS_MVK*/ enum class CommandPoolTrimFlagBitsKHR @@ -1096,32 +1138,29 @@ namespace vk using CommandPoolTrimFlagsKHR = Flags; - VULKAN_HPP_INLINE CommandPoolTrimFlagsKHR operator|( CommandPoolTrimFlagBitsKHR bit0, CommandPoolTrimFlagBitsKHR bit1 ) - { - return CommandPoolTrimFlagsKHR( bit0 ) | bit1; - } - enum class PipelineViewportSwizzleStateCreateFlagBitsNV { }; using PipelineViewportSwizzleStateCreateFlagsNV = Flags; - VULKAN_HPP_INLINE PipelineViewportSwizzleStateCreateFlagsNV operator|( PipelineViewportSwizzleStateCreateFlagBitsNV bit0, PipelineViewportSwizzleStateCreateFlagBitsNV bit1 ) - { - return PipelineViewportSwizzleStateCreateFlagsNV( bit0 ) | bit1; - } - enum class PipelineDiscardRectangleStateCreateFlagBitsEXT { }; using PipelineDiscardRectangleStateCreateFlagsEXT = Flags; - VULKAN_HPP_INLINE PipelineDiscardRectangleStateCreateFlagsEXT operator|( PipelineDiscardRectangleStateCreateFlagBitsEXT bit0, PipelineDiscardRectangleStateCreateFlagBitsEXT bit1 ) + enum class PipelineCoverageToColorStateCreateFlagBitsNV { - return PipelineDiscardRectangleStateCreateFlagsEXT( bit0 ) | bit1; - } + }; + + using PipelineCoverageToColorStateCreateFlagsNV = Flags; + + enum class PipelineCoverageModulationStateCreateFlagBitsNV + { + }; + + using PipelineCoverageModulationStateCreateFlagsNV = Flags; class DeviceMemory { @@ -1134,39 +1173,41 @@ namespace vk : m_deviceMemory(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory(VkDeviceMemory deviceMemory) - : m_deviceMemory(deviceMemory) + VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) + : m_deviceMemory( deviceMemory ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DeviceMemory& operator=(VkDeviceMemory deviceMemory) + DeviceMemory & operator=(VkDeviceMemory deviceMemory) { m_deviceMemory = deviceMemory; - return *this; + return *this; } #endif - DeviceMemory& operator=( std::nullptr_t ) + DeviceMemory & operator=( std::nullptr_t ) { m_deviceMemory = VK_NULL_HANDLE; return *this; } - bool operator==(DeviceMemory const &rhs) const + bool operator==( DeviceMemory const & rhs ) const { return m_deviceMemory == rhs.m_deviceMemory; } - bool operator!=(DeviceMemory const &rhs) const + bool operator!=(DeviceMemory const & rhs ) const { return m_deviceMemory != rhs.m_deviceMemory; } - bool operator<(DeviceMemory const &rhs) const + bool operator<(DeviceMemory const & rhs ) const { return m_deviceMemory < rhs.m_deviceMemory; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const { return m_deviceMemory; @@ -1185,6 +1226,7 @@ namespace vk private: VkDeviceMemory m_deviceMemory; }; + static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); class CommandPool @@ -1198,39 +1240,41 @@ namespace vk : m_commandPool(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool(VkCommandPool commandPool) - : m_commandPool(commandPool) + VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) + : m_commandPool( commandPool ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - CommandPool& operator=(VkCommandPool commandPool) + CommandPool & operator=(VkCommandPool commandPool) { m_commandPool = commandPool; - return *this; + return *this; } #endif - CommandPool& operator=( std::nullptr_t ) + CommandPool & operator=( std::nullptr_t ) { m_commandPool = VK_NULL_HANDLE; return *this; } - bool operator==(CommandPool const &rhs) const + bool operator==( CommandPool const & rhs ) const { return m_commandPool == rhs.m_commandPool; } - bool operator!=(CommandPool const &rhs) const + bool operator!=(CommandPool const & rhs ) const { return m_commandPool != rhs.m_commandPool; } - bool operator<(CommandPool const &rhs) const + bool operator<(CommandPool const & rhs ) const { return m_commandPool < rhs.m_commandPool; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const { return m_commandPool; @@ -1249,6 +1293,7 @@ namespace vk private: VkCommandPool m_commandPool; }; + static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); class Buffer @@ -1262,39 +1307,41 @@ namespace vk : m_buffer(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Buffer(VkBuffer buffer) - : m_buffer(buffer) + VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) + : m_buffer( buffer ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Buffer& operator=(VkBuffer buffer) + Buffer & operator=(VkBuffer buffer) { m_buffer = buffer; - return *this; + return *this; } #endif - Buffer& operator=( std::nullptr_t ) + Buffer & operator=( std::nullptr_t ) { m_buffer = VK_NULL_HANDLE; return *this; } - bool operator==(Buffer const &rhs) const + bool operator==( Buffer const & rhs ) const { return m_buffer == rhs.m_buffer; } - bool operator!=(Buffer const &rhs) const + bool operator!=(Buffer const & rhs ) const { return m_buffer != rhs.m_buffer; } - bool operator<(Buffer const &rhs) const + bool operator<(Buffer const & rhs ) const { return m_buffer < rhs.m_buffer; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const { return m_buffer; @@ -1313,6 +1360,7 @@ namespace vk private: VkBuffer m_buffer; }; + static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); class BufferView @@ -1326,39 +1374,41 @@ namespace vk : m_bufferView(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT BufferView(VkBufferView bufferView) - : m_bufferView(bufferView) + VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) + : m_bufferView( bufferView ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - BufferView& operator=(VkBufferView bufferView) + BufferView & operator=(VkBufferView bufferView) { m_bufferView = bufferView; - return *this; + return *this; } #endif - BufferView& operator=( std::nullptr_t ) + BufferView & operator=( std::nullptr_t ) { m_bufferView = VK_NULL_HANDLE; return *this; } - bool operator==(BufferView const &rhs) const + bool operator==( BufferView const & rhs ) const { return m_bufferView == rhs.m_bufferView; } - bool operator!=(BufferView const &rhs) const + bool operator!=(BufferView const & rhs ) const { return m_bufferView != rhs.m_bufferView; } - bool operator<(BufferView const &rhs) const + bool operator<(BufferView const & rhs ) const { return m_bufferView < rhs.m_bufferView; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const { return m_bufferView; @@ -1377,6 +1427,7 @@ namespace vk private: VkBufferView m_bufferView; }; + static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); class Image @@ -1390,39 +1441,41 @@ namespace vk : m_image(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Image(VkImage image) - : m_image(image) + VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) + : m_image( image ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Image& operator=(VkImage image) + Image & operator=(VkImage image) { m_image = image; - return *this; + return *this; } #endif - Image& operator=( std::nullptr_t ) + Image & operator=( std::nullptr_t ) { m_image = VK_NULL_HANDLE; return *this; } - bool operator==(Image const &rhs) const + bool operator==( Image const & rhs ) const { return m_image == rhs.m_image; } - bool operator!=(Image const &rhs) const + bool operator!=(Image const & rhs ) const { return m_image != rhs.m_image; } - bool operator<(Image const &rhs) const + bool operator<(Image const & rhs ) const { return m_image < rhs.m_image; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const { return m_image; @@ -1441,6 +1494,7 @@ namespace vk private: VkImage m_image; }; + static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); class ImageView @@ -1454,39 +1508,41 @@ namespace vk : m_imageView(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT ImageView(VkImageView imageView) - : m_imageView(imageView) + VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) + : m_imageView( imageView ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ImageView& operator=(VkImageView imageView) + ImageView & operator=(VkImageView imageView) { m_imageView = imageView; - return *this; + return *this; } #endif - ImageView& operator=( std::nullptr_t ) + ImageView & operator=( std::nullptr_t ) { m_imageView = VK_NULL_HANDLE; return *this; } - bool operator==(ImageView const &rhs) const + bool operator==( ImageView const & rhs ) const { return m_imageView == rhs.m_imageView; } - bool operator!=(ImageView const &rhs) const + bool operator!=(ImageView const & rhs ) const { return m_imageView != rhs.m_imageView; } - bool operator<(ImageView const &rhs) const + bool operator<(ImageView const & rhs ) const { return m_imageView < rhs.m_imageView; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const { return m_imageView; @@ -1505,6 +1561,7 @@ namespace vk private: VkImageView m_imageView; }; + static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); class ShaderModule @@ -1518,39 +1575,41 @@ namespace vk : m_shaderModule(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule(VkShaderModule shaderModule) - : m_shaderModule(shaderModule) + VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) + : m_shaderModule( shaderModule ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ShaderModule& operator=(VkShaderModule shaderModule) + ShaderModule & operator=(VkShaderModule shaderModule) { m_shaderModule = shaderModule; - return *this; + return *this; } #endif - ShaderModule& operator=( std::nullptr_t ) + ShaderModule & operator=( std::nullptr_t ) { m_shaderModule = VK_NULL_HANDLE; return *this; } - bool operator==(ShaderModule const &rhs) const + bool operator==( ShaderModule const & rhs ) const { return m_shaderModule == rhs.m_shaderModule; } - bool operator!=(ShaderModule const &rhs) const + bool operator!=(ShaderModule const & rhs ) const { return m_shaderModule != rhs.m_shaderModule; } - bool operator<(ShaderModule const &rhs) const + bool operator<(ShaderModule const & rhs ) const { return m_shaderModule < rhs.m_shaderModule; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const { return m_shaderModule; @@ -1569,6 +1628,7 @@ namespace vk private: VkShaderModule m_shaderModule; }; + static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); class Pipeline @@ -1582,39 +1642,41 @@ namespace vk : m_pipeline(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline(VkPipeline pipeline) - : m_pipeline(pipeline) + VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) + : m_pipeline( pipeline ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Pipeline& operator=(VkPipeline pipeline) + Pipeline & operator=(VkPipeline pipeline) { m_pipeline = pipeline; - return *this; + return *this; } #endif - Pipeline& operator=( std::nullptr_t ) + Pipeline & operator=( std::nullptr_t ) { m_pipeline = VK_NULL_HANDLE; return *this; } - bool operator==(Pipeline const &rhs) const + bool operator==( Pipeline const & rhs ) const { return m_pipeline == rhs.m_pipeline; } - bool operator!=(Pipeline const &rhs) const + bool operator!=(Pipeline const & rhs ) const { return m_pipeline != rhs.m_pipeline; } - bool operator<(Pipeline const &rhs) const + bool operator<(Pipeline const & rhs ) const { return m_pipeline < rhs.m_pipeline; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const { return m_pipeline; @@ -1633,6 +1695,7 @@ namespace vk private: VkPipeline m_pipeline; }; + static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); class PipelineLayout @@ -1646,39 +1709,41 @@ namespace vk : m_pipelineLayout(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout(VkPipelineLayout pipelineLayout) - : m_pipelineLayout(pipelineLayout) + VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) + : m_pipelineLayout( pipelineLayout ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PipelineLayout& operator=(VkPipelineLayout pipelineLayout) + PipelineLayout & operator=(VkPipelineLayout pipelineLayout) { m_pipelineLayout = pipelineLayout; - return *this; + return *this; } #endif - PipelineLayout& operator=( std::nullptr_t ) + PipelineLayout & operator=( std::nullptr_t ) { m_pipelineLayout = VK_NULL_HANDLE; return *this; } - bool operator==(PipelineLayout const &rhs) const + bool operator==( PipelineLayout const & rhs ) const { return m_pipelineLayout == rhs.m_pipelineLayout; } - bool operator!=(PipelineLayout const &rhs) const + bool operator!=(PipelineLayout const & rhs ) const { return m_pipelineLayout != rhs.m_pipelineLayout; } - bool operator<(PipelineLayout const &rhs) const + bool operator<(PipelineLayout const & rhs ) const { return m_pipelineLayout < rhs.m_pipelineLayout; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const { return m_pipelineLayout; @@ -1697,6 +1762,7 @@ namespace vk private: VkPipelineLayout m_pipelineLayout; }; + static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); class Sampler @@ -1710,39 +1776,41 @@ namespace vk : m_sampler(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Sampler(VkSampler sampler) - : m_sampler(sampler) + VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) + : m_sampler( sampler ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Sampler& operator=(VkSampler sampler) + Sampler & operator=(VkSampler sampler) { m_sampler = sampler; - return *this; + return *this; } #endif - Sampler& operator=( std::nullptr_t ) + Sampler & operator=( std::nullptr_t ) { m_sampler = VK_NULL_HANDLE; return *this; } - bool operator==(Sampler const &rhs) const + bool operator==( Sampler const & rhs ) const { return m_sampler == rhs.m_sampler; } - bool operator!=(Sampler const &rhs) const + bool operator!=(Sampler const & rhs ) const { return m_sampler != rhs.m_sampler; } - bool operator<(Sampler const &rhs) const + bool operator<(Sampler const & rhs ) const { return m_sampler < rhs.m_sampler; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const { return m_sampler; @@ -1761,6 +1829,7 @@ namespace vk private: VkSampler m_sampler; }; + static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); class DescriptorSet @@ -1774,39 +1843,41 @@ namespace vk : m_descriptorSet(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet(VkDescriptorSet descriptorSet) - : m_descriptorSet(descriptorSet) + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) + : m_descriptorSet( descriptorSet ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorSet& operator=(VkDescriptorSet descriptorSet) + DescriptorSet & operator=(VkDescriptorSet descriptorSet) { m_descriptorSet = descriptorSet; - return *this; + return *this; } #endif - DescriptorSet& operator=( std::nullptr_t ) + DescriptorSet & operator=( std::nullptr_t ) { m_descriptorSet = VK_NULL_HANDLE; return *this; } - bool operator==(DescriptorSet const &rhs) const + bool operator==( DescriptorSet const & rhs ) const { return m_descriptorSet == rhs.m_descriptorSet; } - bool operator!=(DescriptorSet const &rhs) const + bool operator!=(DescriptorSet const & rhs ) const { return m_descriptorSet != rhs.m_descriptorSet; } - bool operator<(DescriptorSet const &rhs) const + bool operator<(DescriptorSet const & rhs ) const { return m_descriptorSet < rhs.m_descriptorSet; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const { return m_descriptorSet; @@ -1825,6 +1896,7 @@ namespace vk private: VkDescriptorSet m_descriptorSet; }; + static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); class DescriptorSetLayout @@ -1838,39 +1910,41 @@ namespace vk : m_descriptorSetLayout(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) - : m_descriptorSetLayout(descriptorSetLayout) + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) + : m_descriptorSetLayout( descriptorSetLayout ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorSetLayout& operator=(VkDescriptorSetLayout descriptorSetLayout) + DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout) { m_descriptorSetLayout = descriptorSetLayout; - return *this; + return *this; } #endif - DescriptorSetLayout& operator=( std::nullptr_t ) + DescriptorSetLayout & operator=( std::nullptr_t ) { m_descriptorSetLayout = VK_NULL_HANDLE; return *this; } - bool operator==(DescriptorSetLayout const &rhs) const + bool operator==( DescriptorSetLayout const & rhs ) const { return m_descriptorSetLayout == rhs.m_descriptorSetLayout; } - bool operator!=(DescriptorSetLayout const &rhs) const + bool operator!=(DescriptorSetLayout const & rhs ) const { return m_descriptorSetLayout != rhs.m_descriptorSetLayout; } - bool operator<(DescriptorSetLayout const &rhs) const + bool operator<(DescriptorSetLayout const & rhs ) const { return m_descriptorSetLayout < rhs.m_descriptorSetLayout; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const { return m_descriptorSetLayout; @@ -1889,6 +1963,7 @@ namespace vk private: VkDescriptorSetLayout m_descriptorSetLayout; }; + static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); class DescriptorPool @@ -1902,39 +1977,41 @@ namespace vk : m_descriptorPool(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool(VkDescriptorPool descriptorPool) - : m_descriptorPool(descriptorPool) + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) + : m_descriptorPool( descriptorPool ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorPool& operator=(VkDescriptorPool descriptorPool) + DescriptorPool & operator=(VkDescriptorPool descriptorPool) { m_descriptorPool = descriptorPool; - return *this; + return *this; } #endif - DescriptorPool& operator=( std::nullptr_t ) + DescriptorPool & operator=( std::nullptr_t ) { m_descriptorPool = VK_NULL_HANDLE; return *this; } - bool operator==(DescriptorPool const &rhs) const + bool operator==( DescriptorPool const & rhs ) const { return m_descriptorPool == rhs.m_descriptorPool; } - bool operator!=(DescriptorPool const &rhs) const + bool operator!=(DescriptorPool const & rhs ) const { return m_descriptorPool != rhs.m_descriptorPool; } - bool operator<(DescriptorPool const &rhs) const + bool operator<(DescriptorPool const & rhs ) const { return m_descriptorPool < rhs.m_descriptorPool; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const { return m_descriptorPool; @@ -1953,6 +2030,7 @@ namespace vk private: VkDescriptorPool m_descriptorPool; }; + static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); class Fence @@ -1966,39 +2044,41 @@ namespace vk : m_fence(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Fence(VkFence fence) - : m_fence(fence) + VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) + : m_fence( fence ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Fence& operator=(VkFence fence) + Fence & operator=(VkFence fence) { m_fence = fence; - return *this; + return *this; } #endif - Fence& operator=( std::nullptr_t ) + Fence & operator=( std::nullptr_t ) { m_fence = VK_NULL_HANDLE; return *this; } - bool operator==(Fence const &rhs) const + bool operator==( Fence const & rhs ) const { return m_fence == rhs.m_fence; } - bool operator!=(Fence const &rhs) const + bool operator!=(Fence const & rhs ) const { return m_fence != rhs.m_fence; } - bool operator<(Fence const &rhs) const + bool operator<(Fence const & rhs ) const { return m_fence < rhs.m_fence; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const { return m_fence; @@ -2017,6 +2097,7 @@ namespace vk private: VkFence m_fence; }; + static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); class Semaphore @@ -2030,39 +2111,41 @@ namespace vk : m_semaphore(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore(VkSemaphore semaphore) - : m_semaphore(semaphore) + VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) + : m_semaphore( semaphore ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Semaphore& operator=(VkSemaphore semaphore) + Semaphore & operator=(VkSemaphore semaphore) { m_semaphore = semaphore; - return *this; + return *this; } #endif - Semaphore& operator=( std::nullptr_t ) + Semaphore & operator=( std::nullptr_t ) { m_semaphore = VK_NULL_HANDLE; return *this; } - bool operator==(Semaphore const &rhs) const + bool operator==( Semaphore const & rhs ) const { return m_semaphore == rhs.m_semaphore; } - bool operator!=(Semaphore const &rhs) const + bool operator!=(Semaphore const & rhs ) const { return m_semaphore != rhs.m_semaphore; } - bool operator<(Semaphore const &rhs) const + bool operator<(Semaphore const & rhs ) const { return m_semaphore < rhs.m_semaphore; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const { return m_semaphore; @@ -2081,6 +2164,7 @@ namespace vk private: VkSemaphore m_semaphore; }; + static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); class Event @@ -2094,39 +2178,41 @@ namespace vk : m_event(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Event(VkEvent event) - : m_event(event) + VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) + : m_event( event ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Event& operator=(VkEvent event) + Event & operator=(VkEvent event) { m_event = event; - return *this; + return *this; } #endif - Event& operator=( std::nullptr_t ) + Event & operator=( std::nullptr_t ) { m_event = VK_NULL_HANDLE; return *this; } - bool operator==(Event const &rhs) const + bool operator==( Event const & rhs ) const { return m_event == rhs.m_event; } - bool operator!=(Event const &rhs) const + bool operator!=(Event const & rhs ) const { return m_event != rhs.m_event; } - bool operator<(Event const &rhs) const + bool operator<(Event const & rhs ) const { return m_event < rhs.m_event; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const { return m_event; @@ -2145,6 +2231,7 @@ namespace vk private: VkEvent m_event; }; + static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); class QueryPool @@ -2158,39 +2245,41 @@ namespace vk : m_queryPool(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool(VkQueryPool queryPool) - : m_queryPool(queryPool) + VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) + : m_queryPool( queryPool ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - QueryPool& operator=(VkQueryPool queryPool) + QueryPool & operator=(VkQueryPool queryPool) { m_queryPool = queryPool; - return *this; + return *this; } #endif - QueryPool& operator=( std::nullptr_t ) + QueryPool & operator=( std::nullptr_t ) { m_queryPool = VK_NULL_HANDLE; return *this; } - bool operator==(QueryPool const &rhs) const + bool operator==( QueryPool const & rhs ) const { return m_queryPool == rhs.m_queryPool; } - bool operator!=(QueryPool const &rhs) const + bool operator!=(QueryPool const & rhs ) const { return m_queryPool != rhs.m_queryPool; } - bool operator<(QueryPool const &rhs) const + bool operator<(QueryPool const & rhs ) const { return m_queryPool < rhs.m_queryPool; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const { return m_queryPool; @@ -2209,6 +2298,7 @@ namespace vk private: VkQueryPool m_queryPool; }; + static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); class Framebuffer @@ -2222,39 +2312,41 @@ namespace vk : m_framebuffer(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer(VkFramebuffer framebuffer) - : m_framebuffer(framebuffer) + VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) + : m_framebuffer( framebuffer ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Framebuffer& operator=(VkFramebuffer framebuffer) + Framebuffer & operator=(VkFramebuffer framebuffer) { m_framebuffer = framebuffer; - return *this; + return *this; } #endif - Framebuffer& operator=( std::nullptr_t ) + Framebuffer & operator=( std::nullptr_t ) { m_framebuffer = VK_NULL_HANDLE; return *this; } - bool operator==(Framebuffer const &rhs) const + bool operator==( Framebuffer const & rhs ) const { return m_framebuffer == rhs.m_framebuffer; } - bool operator!=(Framebuffer const &rhs) const + bool operator!=(Framebuffer const & rhs ) const { return m_framebuffer != rhs.m_framebuffer; } - bool operator<(Framebuffer const &rhs) const + bool operator<(Framebuffer const & rhs ) const { return m_framebuffer < rhs.m_framebuffer; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const { return m_framebuffer; @@ -2273,6 +2365,7 @@ namespace vk private: VkFramebuffer m_framebuffer; }; + static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); class RenderPass @@ -2286,39 +2379,41 @@ namespace vk : m_renderPass(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass(VkRenderPass renderPass) - : m_renderPass(renderPass) + VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) + : m_renderPass( renderPass ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - RenderPass& operator=(VkRenderPass renderPass) + RenderPass & operator=(VkRenderPass renderPass) { m_renderPass = renderPass; - return *this; + return *this; } #endif - RenderPass& operator=( std::nullptr_t ) + RenderPass & operator=( std::nullptr_t ) { m_renderPass = VK_NULL_HANDLE; return *this; } - bool operator==(RenderPass const &rhs) const + bool operator==( RenderPass const & rhs ) const { return m_renderPass == rhs.m_renderPass; } - bool operator!=(RenderPass const &rhs) const + bool operator!=(RenderPass const & rhs ) const { return m_renderPass != rhs.m_renderPass; } - bool operator<(RenderPass const &rhs) const + bool operator<(RenderPass const & rhs ) const { return m_renderPass < rhs.m_renderPass; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const { return m_renderPass; @@ -2337,6 +2432,7 @@ namespace vk private: VkRenderPass m_renderPass; }; + static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); class PipelineCache @@ -2350,39 +2446,41 @@ namespace vk : m_pipelineCache(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache(VkPipelineCache pipelineCache) - : m_pipelineCache(pipelineCache) + VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) + : m_pipelineCache( pipelineCache ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PipelineCache& operator=(VkPipelineCache pipelineCache) + PipelineCache & operator=(VkPipelineCache pipelineCache) { m_pipelineCache = pipelineCache; - return *this; + return *this; } #endif - PipelineCache& operator=( std::nullptr_t ) + PipelineCache & operator=( std::nullptr_t ) { m_pipelineCache = VK_NULL_HANDLE; return *this; } - bool operator==(PipelineCache const &rhs) const + bool operator==( PipelineCache const & rhs ) const { return m_pipelineCache == rhs.m_pipelineCache; } - bool operator!=(PipelineCache const &rhs) const + bool operator!=(PipelineCache const & rhs ) const { return m_pipelineCache != rhs.m_pipelineCache; } - bool operator<(PipelineCache const &rhs) const + bool operator<(PipelineCache const & rhs ) const { return m_pipelineCache < rhs.m_pipelineCache; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const { return m_pipelineCache; @@ -2401,6 +2499,7 @@ namespace vk private: VkPipelineCache m_pipelineCache; }; + static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); class ObjectTableNVX @@ -2414,39 +2513,41 @@ namespace vk : m_objectTableNVX(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX(VkObjectTableNVX objectTableNVX) - : m_objectTableNVX(objectTableNVX) + VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX ) + : m_objectTableNVX( objectTableNVX ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - ObjectTableNVX& operator=(VkObjectTableNVX objectTableNVX) + ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX) { m_objectTableNVX = objectTableNVX; - return *this; + return *this; } #endif - ObjectTableNVX& operator=( std::nullptr_t ) + ObjectTableNVX & operator=( std::nullptr_t ) { m_objectTableNVX = VK_NULL_HANDLE; return *this; } - bool operator==(ObjectTableNVX const &rhs) const + bool operator==( ObjectTableNVX const & rhs ) const { return m_objectTableNVX == rhs.m_objectTableNVX; } - bool operator!=(ObjectTableNVX const &rhs) const + bool operator!=(ObjectTableNVX const & rhs ) const { return m_objectTableNVX != rhs.m_objectTableNVX; } - bool operator<(ObjectTableNVX const &rhs) const + bool operator<(ObjectTableNVX const & rhs ) const { return m_objectTableNVX < rhs.m_objectTableNVX; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const { return m_objectTableNVX; @@ -2465,6 +2566,7 @@ namespace vk private: VkObjectTableNVX m_objectTableNVX; }; + static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" ); class IndirectCommandsLayoutNVX @@ -2478,39 +2580,41 @@ namespace vk : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX) - : m_indirectCommandsLayoutNVX(indirectCommandsLayoutNVX) + VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX ) + : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - IndirectCommandsLayoutNVX& operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX) + IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX) { m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX; - return *this; + return *this; } #endif - IndirectCommandsLayoutNVX& operator=( std::nullptr_t ) + IndirectCommandsLayoutNVX & operator=( std::nullptr_t ) { m_indirectCommandsLayoutNVX = VK_NULL_HANDLE; return *this; } - bool operator==(IndirectCommandsLayoutNVX const &rhs) const + bool operator==( IndirectCommandsLayoutNVX const & rhs ) const { return m_indirectCommandsLayoutNVX == rhs.m_indirectCommandsLayoutNVX; } - bool operator!=(IndirectCommandsLayoutNVX const &rhs) const + bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const { return m_indirectCommandsLayoutNVX != rhs.m_indirectCommandsLayoutNVX; } - bool operator<(IndirectCommandsLayoutNVX const &rhs) const + bool operator<(IndirectCommandsLayoutNVX const & rhs ) const { return m_indirectCommandsLayoutNVX < rhs.m_indirectCommandsLayoutNVX; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const { return m_indirectCommandsLayoutNVX; @@ -2529,6 +2633,7 @@ namespace vk private: VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX; }; + static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" ); class DescriptorUpdateTemplateKHR @@ -2542,39 +2647,41 @@ namespace vk : m_descriptorUpdateTemplateKHR(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplateKHR(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR) - : m_descriptorUpdateTemplateKHR(descriptorUpdateTemplateKHR) + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplateKHR( VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR ) + : m_descriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DescriptorUpdateTemplateKHR& operator=(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR) + DescriptorUpdateTemplateKHR & operator=(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR) { m_descriptorUpdateTemplateKHR = descriptorUpdateTemplateKHR; - return *this; + return *this; } #endif - DescriptorUpdateTemplateKHR& operator=( std::nullptr_t ) + DescriptorUpdateTemplateKHR & operator=( std::nullptr_t ) { m_descriptorUpdateTemplateKHR = VK_NULL_HANDLE; return *this; } - bool operator==(DescriptorUpdateTemplateKHR const &rhs) const + bool operator==( DescriptorUpdateTemplateKHR const & rhs ) const { return m_descriptorUpdateTemplateKHR == rhs.m_descriptorUpdateTemplateKHR; } - bool operator!=(DescriptorUpdateTemplateKHR const &rhs) const + bool operator!=(DescriptorUpdateTemplateKHR const & rhs ) const { return m_descriptorUpdateTemplateKHR != rhs.m_descriptorUpdateTemplateKHR; } - bool operator<(DescriptorUpdateTemplateKHR const &rhs) const + bool operator<(DescriptorUpdateTemplateKHR const & rhs ) const { return m_descriptorUpdateTemplateKHR < rhs.m_descriptorUpdateTemplateKHR; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplateKHR() const { return m_descriptorUpdateTemplateKHR; @@ -2593,6 +2700,7 @@ namespace vk private: VkDescriptorUpdateTemplateKHR m_descriptorUpdateTemplateKHR; }; + static_assert( sizeof( DescriptorUpdateTemplateKHR ) == sizeof( VkDescriptorUpdateTemplateKHR ), "handle and wrapper have different size!" ); class DisplayKHR @@ -2606,39 +2714,41 @@ namespace vk : m_displayKHR(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR(VkDisplayKHR displayKHR) - : m_displayKHR(displayKHR) + VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) + : m_displayKHR( displayKHR ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DisplayKHR& operator=(VkDisplayKHR displayKHR) + DisplayKHR & operator=(VkDisplayKHR displayKHR) { m_displayKHR = displayKHR; - return *this; + return *this; } #endif - DisplayKHR& operator=( std::nullptr_t ) + DisplayKHR & operator=( std::nullptr_t ) { m_displayKHR = VK_NULL_HANDLE; return *this; } - bool operator==(DisplayKHR const &rhs) const + bool operator==( DisplayKHR const & rhs ) const { return m_displayKHR == rhs.m_displayKHR; } - bool operator!=(DisplayKHR const &rhs) const + bool operator!=(DisplayKHR const & rhs ) const { return m_displayKHR != rhs.m_displayKHR; } - bool operator<(DisplayKHR const &rhs) const + bool operator<(DisplayKHR const & rhs ) const { return m_displayKHR < rhs.m_displayKHR; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const { return m_displayKHR; @@ -2657,6 +2767,7 @@ namespace vk private: VkDisplayKHR m_displayKHR; }; + static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); class DisplayModeKHR @@ -2670,39 +2781,41 @@ namespace vk : m_displayModeKHR(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR(VkDisplayModeKHR displayModeKHR) - : m_displayModeKHR(displayModeKHR) + VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) + : m_displayModeKHR( displayModeKHR ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DisplayModeKHR& operator=(VkDisplayModeKHR displayModeKHR) + DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR) { m_displayModeKHR = displayModeKHR; - return *this; + return *this; } #endif - DisplayModeKHR& operator=( std::nullptr_t ) + DisplayModeKHR & operator=( std::nullptr_t ) { m_displayModeKHR = VK_NULL_HANDLE; return *this; } - bool operator==(DisplayModeKHR const &rhs) const + bool operator==( DisplayModeKHR const & rhs ) const { return m_displayModeKHR == rhs.m_displayModeKHR; } - bool operator!=(DisplayModeKHR const &rhs) const + bool operator!=(DisplayModeKHR const & rhs ) const { return m_displayModeKHR != rhs.m_displayModeKHR; } - bool operator<(DisplayModeKHR const &rhs) const + bool operator<(DisplayModeKHR const & rhs ) const { return m_displayModeKHR < rhs.m_displayModeKHR; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const { return m_displayModeKHR; @@ -2721,6 +2834,7 @@ namespace vk private: VkDisplayModeKHR m_displayModeKHR; }; + static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); class SurfaceKHR @@ -2734,39 +2848,41 @@ namespace vk : m_surfaceKHR(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR(VkSurfaceKHR surfaceKHR) - : m_surfaceKHR(surfaceKHR) + VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) + : m_surfaceKHR( surfaceKHR ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - SurfaceKHR& operator=(VkSurfaceKHR surfaceKHR) + SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR) { m_surfaceKHR = surfaceKHR; - return *this; + return *this; } #endif - SurfaceKHR& operator=( std::nullptr_t ) + SurfaceKHR & operator=( std::nullptr_t ) { m_surfaceKHR = VK_NULL_HANDLE; return *this; } - bool operator==(SurfaceKHR const &rhs) const + bool operator==( SurfaceKHR const & rhs ) const { return m_surfaceKHR == rhs.m_surfaceKHR; } - bool operator!=(SurfaceKHR const &rhs) const + bool operator!=(SurfaceKHR const & rhs ) const { return m_surfaceKHR != rhs.m_surfaceKHR; } - bool operator<(SurfaceKHR const &rhs) const + bool operator<(SurfaceKHR const & rhs ) const { return m_surfaceKHR < rhs.m_surfaceKHR; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const { return m_surfaceKHR; @@ -2785,6 +2901,7 @@ namespace vk private: VkSurfaceKHR m_surfaceKHR; }; + static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); class SwapchainKHR @@ -2798,39 +2915,41 @@ namespace vk : m_swapchainKHR(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR(VkSwapchainKHR swapchainKHR) - : m_swapchainKHR(swapchainKHR) + VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) + : m_swapchainKHR( swapchainKHR ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - SwapchainKHR& operator=(VkSwapchainKHR swapchainKHR) + SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR) { m_swapchainKHR = swapchainKHR; - return *this; + return *this; } #endif - SwapchainKHR& operator=( std::nullptr_t ) + SwapchainKHR & operator=( std::nullptr_t ) { m_swapchainKHR = VK_NULL_HANDLE; return *this; } - bool operator==(SwapchainKHR const &rhs) const + bool operator==( SwapchainKHR const & rhs ) const { return m_swapchainKHR == rhs.m_swapchainKHR; } - bool operator!=(SwapchainKHR const &rhs) const + bool operator!=(SwapchainKHR const & rhs ) const { return m_swapchainKHR != rhs.m_swapchainKHR; } - bool operator<(SwapchainKHR const &rhs) const + bool operator<(SwapchainKHR const & rhs ) const { return m_swapchainKHR < rhs.m_swapchainKHR; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const { return m_swapchainKHR; @@ -2849,6 +2968,7 @@ namespace vk private: VkSwapchainKHR m_swapchainKHR; }; + static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); class DebugReportCallbackEXT @@ -2862,39 +2982,41 @@ namespace vk : m_debugReportCallbackEXT(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT(VkDebugReportCallbackEXT debugReportCallbackEXT) - : m_debugReportCallbackEXT(debugReportCallbackEXT) + VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) + : m_debugReportCallbackEXT( debugReportCallbackEXT ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - DebugReportCallbackEXT& operator=(VkDebugReportCallbackEXT debugReportCallbackEXT) + DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT) { m_debugReportCallbackEXT = debugReportCallbackEXT; - return *this; + return *this; } #endif - DebugReportCallbackEXT& operator=( std::nullptr_t ) + DebugReportCallbackEXT & operator=( std::nullptr_t ) { m_debugReportCallbackEXT = VK_NULL_HANDLE; return *this; } - bool operator==(DebugReportCallbackEXT const &rhs) const + bool operator==( DebugReportCallbackEXT const & rhs ) const { return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT; } - bool operator!=(DebugReportCallbackEXT const &rhs) const + bool operator!=(DebugReportCallbackEXT const & rhs ) const { return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT; } - bool operator<(DebugReportCallbackEXT const &rhs) const + bool operator<(DebugReportCallbackEXT const & rhs ) const { return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT; } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const { return m_debugReportCallbackEXT; @@ -2913,6 +3035,7 @@ namespace vk private: VkDebugReportCallbackEXT m_debugReportCallbackEXT; }; + static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" ); struct Offset2D @@ -2925,15 +3048,14 @@ namespace vk Offset2D( VkOffset2D const & rhs ) { - memcpy( this, &rhs, sizeof(Offset2D) ); + memcpy( this, &rhs, sizeof( Offset2D ) ); } Offset2D& operator=( VkOffset2D const & rhs ) { - memcpy( this, &rhs, sizeof(Offset2D) ); + memcpy( this, &rhs, sizeof( Offset2D ) ); return *this; } - Offset2D& setX( int32_t x_ ) { x = x_; @@ -2978,15 +3100,14 @@ namespace vk Offset3D( VkOffset3D const & rhs ) { - memcpy( this, &rhs, sizeof(Offset3D) ); + memcpy( this, &rhs, sizeof( Offset3D ) ); } Offset3D& operator=( VkOffset3D const & rhs ) { - memcpy( this, &rhs, sizeof(Offset3D) ); + memcpy( this, &rhs, sizeof( Offset3D ) ); return *this; } - Offset3D& setX( int32_t x_ ) { x = x_; @@ -3038,15 +3159,14 @@ namespace vk Extent2D( VkExtent2D const & rhs ) { - memcpy( this, &rhs, sizeof(Extent2D) ); + memcpy( this, &rhs, sizeof( Extent2D ) ); } Extent2D& operator=( VkExtent2D const & rhs ) { - memcpy( this, &rhs, sizeof(Extent2D) ); + memcpy( this, &rhs, sizeof( Extent2D ) ); return *this; } - Extent2D& setWidth( uint32_t width_ ) { width = width_; @@ -3091,15 +3211,14 @@ namespace vk Extent3D( VkExtent3D const & rhs ) { - memcpy( this, &rhs, sizeof(Extent3D) ); + memcpy( this, &rhs, sizeof( Extent3D ) ); } Extent3D& operator=( VkExtent3D const & rhs ) { - memcpy( this, &rhs, sizeof(Extent3D) ); + memcpy( this, &rhs, sizeof( Extent3D ) ); return *this; } - Extent3D& setWidth( uint32_t width_ ) { width = width_; @@ -3155,15 +3274,14 @@ namespace vk Viewport( VkViewport const & rhs ) { - memcpy( this, &rhs, sizeof(Viewport) ); + memcpy( this, &rhs, sizeof( Viewport ) ); } Viewport& operator=( VkViewport const & rhs ) { - memcpy( this, &rhs, sizeof(Viewport) ); + memcpy( this, &rhs, sizeof( Viewport ) ); return *this; } - Viewport& setX( float x_ ) { x = x_; @@ -3239,15 +3357,14 @@ namespace vk Rect2D( VkRect2D const & rhs ) { - memcpy( this, &rhs, sizeof(Rect2D) ); + memcpy( this, &rhs, sizeof( Rect2D ) ); } Rect2D& operator=( VkRect2D const & rhs ) { - memcpy( this, &rhs, sizeof(Rect2D) ); + memcpy( this, &rhs, sizeof( Rect2D ) ); return *this; } - Rect2D& setOffset( Offset2D offset_ ) { offset = offset_; @@ -3292,15 +3409,14 @@ namespace vk ClearRect( VkClearRect const & rhs ) { - memcpy( this, &rhs, sizeof(ClearRect) ); + memcpy( this, &rhs, sizeof( ClearRect ) ); } ClearRect& operator=( VkClearRect const & rhs ) { - memcpy( this, &rhs, sizeof(ClearRect) ); + memcpy( this, &rhs, sizeof( ClearRect ) ); return *this; } - ClearRect& setRect( Rect2D rect_ ) { rect = rect_; @@ -3406,15 +3522,14 @@ namespace vk AllocationCallbacks( VkAllocationCallbacks const & rhs ) { - memcpy( this, &rhs, sizeof(AllocationCallbacks) ); + memcpy( this, &rhs, sizeof( AllocationCallbacks ) ); } AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs ) { - memcpy( this, &rhs, sizeof(AllocationCallbacks) ); + memcpy( this, &rhs, sizeof( AllocationCallbacks ) ); return *this; } - AllocationCallbacks& setPUserData( void* pUserData_ ) { pUserData = pUserData_; @@ -3516,15 +3631,14 @@ namespace vk DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorBufferInfo) ); + memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) ); } DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorBufferInfo) ); + memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) ); return *this; } - DescriptorBufferInfo& setBuffer( Buffer buffer_ ) { buffer = buffer_; @@ -3606,15 +3720,14 @@ namespace vk BufferCopy( VkBufferCopy const & rhs ) { - memcpy( this, &rhs, sizeof(BufferCopy) ); + memcpy( this, &rhs, sizeof( BufferCopy ) ); } BufferCopy& operator=( VkBufferCopy const & rhs ) { - memcpy( this, &rhs, sizeof(BufferCopy) ); + memcpy( this, &rhs, sizeof( BufferCopy ) ); return *this; } - BufferCopy& setSrcOffset( DeviceSize srcOffset_ ) { srcOffset = srcOffset_; @@ -3667,15 +3780,14 @@ namespace vk SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) { - memcpy( this, &rhs, sizeof(SpecializationMapEntry) ); + memcpy( this, &rhs, sizeof( SpecializationMapEntry ) ); } SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs ) { - memcpy( this, &rhs, sizeof(SpecializationMapEntry) ); + memcpy( this, &rhs, sizeof( SpecializationMapEntry ) ); return *this; } - SpecializationMapEntry& setConstantID( uint32_t constantID_ ) { constantID = constantID_; @@ -3729,15 +3841,14 @@ namespace vk SpecializationInfo( VkSpecializationInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SpecializationInfo) ); + memcpy( this, &rhs, sizeof( SpecializationInfo ) ); } SpecializationInfo& operator=( VkSpecializationInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SpecializationInfo) ); + memcpy( this, &rhs, sizeof( SpecializationInfo ) ); return *this; } - SpecializationInfo& setMapEntryCount( uint32_t mapEntryCount_ ) { mapEntryCount = mapEntryCount_; @@ -3842,15 +3953,14 @@ namespace vk ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) { - memcpy( this, &rhs, sizeof(ClearDepthStencilValue) ); + memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) ); } ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs ) { - memcpy( this, &rhs, sizeof(ClearDepthStencilValue) ); + memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) ); return *this; } - ClearDepthStencilValue& setDepth( float depth_ ) { depth = depth_; @@ -3985,15 +4095,14 @@ namespace vk PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) ); } PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) ); return *this; } - PhysicalDeviceFeatures& setRobustBufferAccess( Bool32 robustBufferAccess_ ) { robustBufferAccess = robustBufferAccess_; @@ -4492,15 +4601,14 @@ namespace vk DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DrawIndirectCommand) ); + memcpy( this, &rhs, sizeof( DrawIndirectCommand ) ); } DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DrawIndirectCommand) ); + memcpy( this, &rhs, sizeof( DrawIndirectCommand ) ); return *this; } - DrawIndirectCommand& setVertexCount( uint32_t vertexCount_ ) { vertexCount = vertexCount_; @@ -4563,15 +4671,14 @@ namespace vk DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DrawIndexedIndirectCommand) ); + memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) ); } DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DrawIndexedIndirectCommand) ); + memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) ); return *this; } - DrawIndexedIndirectCommand& setIndexCount( uint32_t indexCount_ ) { indexCount = indexCount_; @@ -4640,15 +4747,14 @@ namespace vk DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DispatchIndirectCommand) ); + memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) ); } DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs ) { - memcpy( this, &rhs, sizeof(DispatchIndirectCommand) ); + memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) ); return *this; } - DispatchIndirectCommand& setX( uint32_t x_ ) { x = x_; @@ -4723,15 +4829,14 @@ namespace vk DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayModeParametersKHR) ); + memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) ); } DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayModeParametersKHR) ); + memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) ); return *this; } - DisplayModeParametersKHR& setVisibleRegion( Extent2D visibleRegion_ ) { visibleRegion = visibleRegion_; @@ -4799,15 +4904,14 @@ namespace vk RectLayerKHR( VkRectLayerKHR const & rhs ) { - memcpy( this, &rhs, sizeof(RectLayerKHR) ); + memcpy( this, &rhs, sizeof( RectLayerKHR ) ); } RectLayerKHR& operator=( VkRectLayerKHR const & rhs ) { - memcpy( this, &rhs, sizeof(RectLayerKHR) ); + memcpy( this, &rhs, sizeof( RectLayerKHR ) ); return *this; } - RectLayerKHR& setOffset( Offset2D offset_ ) { offset = offset_; @@ -4859,15 +4963,14 @@ namespace vk PresentRegionKHR( VkPresentRegionKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentRegionKHR) ); + memcpy( this, &rhs, sizeof( PresentRegionKHR ) ); } PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentRegionKHR) ); + memcpy( this, &rhs, sizeof( PresentRegionKHR ) ); return *this; } - PresentRegionKHR& setRectangleCount( uint32_t rectangleCount_ ) { rectangleCount = rectangleCount_; @@ -4911,15 +5014,14 @@ namespace vk XYColorEXT( VkXYColorEXT const & rhs ) { - memcpy( this, &rhs, sizeof(XYColorEXT) ); + memcpy( this, &rhs, sizeof( XYColorEXT ) ); } XYColorEXT& operator=( VkXYColorEXT const & rhs ) { - memcpy( this, &rhs, sizeof(XYColorEXT) ); + memcpy( this, &rhs, sizeof( XYColorEXT ) ); return *this; } - XYColorEXT& setX( float x_ ) { x = x_; @@ -4962,15 +5064,14 @@ namespace vk RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(RefreshCycleDurationGOOGLE) ); + memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) ); } RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(RefreshCycleDurationGOOGLE) ); + memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) ); return *this; } - RefreshCycleDurationGOOGLE& setRefreshDuration( uint64_t refreshDuration_ ) { refreshDuration = refreshDuration_; @@ -5009,15 +5110,14 @@ namespace vk PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PastPresentationTimingGOOGLE) ); + memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) ); } PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PastPresentationTimingGOOGLE) ); + memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) ); return *this; } - PastPresentationTimingGOOGLE& setPresentID( uint32_t presentID_ ) { presentID = presentID_; @@ -5085,15 +5185,14 @@ namespace vk PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PresentTimeGOOGLE) ); + memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) ); } PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PresentTimeGOOGLE) ); + memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) ); return *this; } - PresentTimeGOOGLE& setPresentID( uint32_t presentID_ ) { presentID = presentID_; @@ -5137,15 +5236,14 @@ namespace vk ViewportWScalingNV( VkViewportWScalingNV const & rhs ) { - memcpy( this, &rhs, sizeof(ViewportWScalingNV) ); + memcpy( this, &rhs, sizeof( ViewportWScalingNV ) ); } ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs ) { - memcpy( this, &rhs, sizeof(ViewportWScalingNV) ); + memcpy( this, &rhs, sizeof( ViewportWScalingNV ) ); return *this; } - ViewportWScalingNV& setXcoeff( float xcoeff_ ) { xcoeff = xcoeff_; @@ -5190,7 +5288,8 @@ namespace vk eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED, - ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR + ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, + eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR }; struct DescriptorImageInfo @@ -5204,15 +5303,14 @@ namespace vk DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorImageInfo) ); + memcpy( this, &rhs, sizeof( DescriptorImageInfo ) ); } DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorImageInfo) ); + memcpy( this, &rhs, sizeof( DescriptorImageInfo ) ); return *this; } - DescriptorImageInfo& setSampler( Sampler sampler_ ) { sampler = sampler_; @@ -5264,15 +5362,14 @@ namespace vk AttachmentReference( VkAttachmentReference const & rhs ) { - memcpy( this, &rhs, sizeof(AttachmentReference) ); + memcpy( this, &rhs, sizeof( AttachmentReference ) ); } AttachmentReference& operator=( VkAttachmentReference const & rhs ) { - memcpy( this, &rhs, sizeof(AttachmentReference) ); + memcpy( this, &rhs, sizeof( AttachmentReference ) ); return *this; } - AttachmentReference& setAttachment( uint32_t attachment_ ) { attachment = attachment_; @@ -5372,15 +5469,14 @@ namespace vk ComponentMapping( VkComponentMapping const & rhs ) { - memcpy( this, &rhs, sizeof(ComponentMapping) ); + memcpy( this, &rhs, sizeof( ComponentMapping ) ); } ComponentMapping& operator=( VkComponentMapping const & rhs ) { - memcpy( this, &rhs, sizeof(ComponentMapping) ); + memcpy( this, &rhs, sizeof( ComponentMapping ) ); return *this; } - ComponentMapping& setR( ComponentSwizzle r_ ) { r = r_; @@ -5455,15 +5551,14 @@ namespace vk DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorPoolSize) ); + memcpy( this, &rhs, sizeof( DescriptorPoolSize ) ); } DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorPoolSize) ); + memcpy( this, &rhs, sizeof( DescriptorPoolSize ) ); return *this; } - DescriptorPoolSize& setType( DescriptorType type_ ) { type = type_; @@ -5511,15 +5606,14 @@ namespace vk DescriptorUpdateTemplateEntryKHR( VkDescriptorUpdateTemplateEntryKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateEntryKHR) ); + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntryKHR ) ); } DescriptorUpdateTemplateEntryKHR& operator=( VkDescriptorUpdateTemplateEntryKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateEntryKHR) ); + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntryKHR ) ); return *this; } - DescriptorUpdateTemplateEntryKHR& setDstBinding( uint32_t dstBinding_ ) { dstBinding = dstBinding_; @@ -5678,7 +5772,8 @@ namespace vk { eFill = VK_POLYGON_MODE_FILL, eLine = VK_POLYGON_MODE_LINE, - ePoint = VK_POLYGON_MODE_POINT + ePoint = VK_POLYGON_MODE_POINT, + eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV }; enum class CullModeFlagBits @@ -5744,7 +5839,53 @@ namespace vk eSubtract = VK_BLEND_OP_SUBTRACT, eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT, eMin = VK_BLEND_OP_MIN, - eMax = VK_BLEND_OP_MAX + eMax = VK_BLEND_OP_MAX, + eZeroEXT = VK_BLEND_OP_ZERO_EXT, + eSrcEXT = VK_BLEND_OP_SRC_EXT, + eDstEXT = VK_BLEND_OP_DST_EXT, + eSrcOverEXT = VK_BLEND_OP_SRC_OVER_EXT, + eDstOverEXT = VK_BLEND_OP_DST_OVER_EXT, + eSrcInEXT = VK_BLEND_OP_SRC_IN_EXT, + eDstInEXT = VK_BLEND_OP_DST_IN_EXT, + eSrcOutEXT = VK_BLEND_OP_SRC_OUT_EXT, + eDstOutEXT = VK_BLEND_OP_DST_OUT_EXT, + eSrcAtopEXT = VK_BLEND_OP_SRC_ATOP_EXT, + eDstAtopEXT = VK_BLEND_OP_DST_ATOP_EXT, + eXorEXT = VK_BLEND_OP_XOR_EXT, + eMultiplyEXT = VK_BLEND_OP_MULTIPLY_EXT, + eScreenEXT = VK_BLEND_OP_SCREEN_EXT, + eOverlayEXT = VK_BLEND_OP_OVERLAY_EXT, + eDarkenEXT = VK_BLEND_OP_DARKEN_EXT, + eLightenEXT = VK_BLEND_OP_LIGHTEN_EXT, + eColordodgeEXT = VK_BLEND_OP_COLORDODGE_EXT, + eColorburnEXT = VK_BLEND_OP_COLORBURN_EXT, + eHardlightEXT = VK_BLEND_OP_HARDLIGHT_EXT, + eSoftlightEXT = VK_BLEND_OP_SOFTLIGHT_EXT, + eDifferenceEXT = VK_BLEND_OP_DIFFERENCE_EXT, + eExclusionEXT = VK_BLEND_OP_EXCLUSION_EXT, + eInvertEXT = VK_BLEND_OP_INVERT_EXT, + eInvertRgbEXT = VK_BLEND_OP_INVERT_RGB_EXT, + eLineardodgeEXT = VK_BLEND_OP_LINEARDODGE_EXT, + eLinearburnEXT = VK_BLEND_OP_LINEARBURN_EXT, + eVividlightEXT = VK_BLEND_OP_VIVIDLIGHT_EXT, + eLinearlightEXT = VK_BLEND_OP_LINEARLIGHT_EXT, + ePinlightEXT = VK_BLEND_OP_PINLIGHT_EXT, + eHardmixEXT = VK_BLEND_OP_HARDMIX_EXT, + eHslHueEXT = VK_BLEND_OP_HSL_HUE_EXT, + eHslSaturationEXT = VK_BLEND_OP_HSL_SATURATION_EXT, + eHslColorEXT = VK_BLEND_OP_HSL_COLOR_EXT, + eHslLuminosityEXT = VK_BLEND_OP_HSL_LUMINOSITY_EXT, + ePlusEXT = VK_BLEND_OP_PLUS_EXT, + ePlusClampedEXT = VK_BLEND_OP_PLUS_CLAMPED_EXT, + ePlusClampedAlphaEXT = VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, + ePlusDarkerEXT = VK_BLEND_OP_PLUS_DARKER_EXT, + eMinusEXT = VK_BLEND_OP_MINUS_EXT, + eMinusClampedEXT = VK_BLEND_OP_MINUS_CLAMPED_EXT, + eContrastEXT = VK_BLEND_OP_CONTRAST_EXT, + eInvertOvgEXT = VK_BLEND_OP_INVERT_OVG_EXT, + eRedEXT = VK_BLEND_OP_RED_EXT, + eGreenEXT = VK_BLEND_OP_GREEN_EXT, + eBlueEXT = VK_BLEND_OP_BLUE_EXT }; enum class StencilOp @@ -5774,15 +5915,14 @@ namespace vk StencilOpState( VkStencilOpState const & rhs ) { - memcpy( this, &rhs, sizeof(StencilOpState) ); + memcpy( this, &rhs, sizeof( StencilOpState ) ); } StencilOpState& operator=( VkStencilOpState const & rhs ) { - memcpy( this, &rhs, sizeof(StencilOpState) ); + memcpy( this, &rhs, sizeof( StencilOpState ) ); return *this; } - StencilOpState& setFailOp( StencilOp failOp_ ) { failOp = failOp_; @@ -5916,15 +6056,14 @@ namespace vk VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) { - memcpy( this, &rhs, sizeof(VertexInputBindingDescription) ); + memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) ); } VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs ) { - memcpy( this, &rhs, sizeof(VertexInputBindingDescription) ); + memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) ); return *this; } - VertexInputBindingDescription& setBinding( uint32_t binding_ ) { binding = binding_; @@ -6175,15 +6314,14 @@ namespace vk VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) { - memcpy( this, &rhs, sizeof(VertexInputAttributeDescription) ); + memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) ); } VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs ) { - memcpy( this, &rhs, sizeof(VertexInputAttributeDescription) ); + memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) ); return *this; } - VertexInputAttributeDescription& setLocation( uint32_t location_ ) { location = location_; @@ -6303,6 +6441,7 @@ namespace vk eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, + eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, eRenderPassMultiviewCreateInfoKHX = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX, ePhysicalDeviceMultiviewFeaturesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX, ePhysicalDeviceMultiviewPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX, @@ -6337,31 +6476,33 @@ namespace vk eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN, ePhysicalDeviceGroupPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX, eDeviceGroupDeviceCreateInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX, - ePhysicalDeviceExternalImageFormatInfoKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX, - eExternalImageFormatPropertiesKHX = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX, - ePhysicalDeviceExternalBufferInfoKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHX, - eExternalBufferPropertiesKHX = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHX, - ePhysicalDeviceIdPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHX, - ePhysicalDeviceProperties2KHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHX, - eImageFormatProperties2KHX = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHX, - ePhysicalDeviceImageFormatInfo2KHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHX, - eExternalMemoryBufferCreateInfoKHX = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHX, - eExternalMemoryImageCreateInfoKHX = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHX, - eExportMemoryAllocateInfoKHX = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHX, - eImportMemoryWin32HandleInfoKHX = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHX, - eExportMemoryWin32HandleInfoKHX = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHX, - eMemoryWin32HandlePropertiesKHX = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHX, - eImportMemoryFdInfoKHX = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHX, - eMemoryFdPropertiesKHX = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHX, - eWin32KeyedMutexAcquireReleaseInfoKHX = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHX, - ePhysicalDeviceExternalSemaphoreInfoKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHX, - eExternalSemaphorePropertiesKHX = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHX, - eExportSemaphoreCreateInfoKHX = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHX, - eImportSemaphoreWin32HandleInfoKHX = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX, - eExportSemaphoreWin32HandleInfoKHX = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHX, - eD3D12FenceSubmitInfoKHX = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHX, - eImportSemaphoreFdInfoKHX = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHX, + ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR, + eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR, + ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR, + eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR, + ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, + eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR, + eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR, + eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, + eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + eExportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + eMemoryWin32HandlePropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, + eMemoryGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR, + eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, + eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, + eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, + eWin32KeyedMutexAcquireReleaseInfoKHR = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, + ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR, + eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR, + eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR, + eImportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + eExportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + eD3D12FenceSubmitInfoKHR = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, + eSemaphoreGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, + eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, + eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, ePhysicalDevicePushDescriptorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, + ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX, @@ -6382,8 +6523,35 @@ namespace vk ePhysicalDeviceDiscardRectanglePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT, + eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, + ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR, + eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR, + eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR, + eImportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, + eExportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, + eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, + eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, + eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, + ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, + eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, + eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, + ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR, eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK, - eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK + eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, + eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, + eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, + ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, + eSamplerReductionModeCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, + eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, + eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, + eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR, + eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, + eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR, + ePhysicalDeviceBlendOperationAdvancedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, + ePhysicalDeviceBlendOperationAdvancedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, + ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, + ePipelineCoverageToColorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, + ePipelineCoverageModulationStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV }; struct ApplicationInfo @@ -6401,15 +6569,14 @@ namespace vk ApplicationInfo( VkApplicationInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ApplicationInfo) ); + memcpy( this, &rhs, sizeof( ApplicationInfo ) ); } ApplicationInfo& operator=( VkApplicationInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ApplicationInfo) ); + memcpy( this, &rhs, sizeof( ApplicationInfo ) ); return *this; } - ApplicationInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6494,15 +6661,14 @@ namespace vk DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceQueueCreateInfo) ); + memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) ); } DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceQueueCreateInfo) ); + memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) ); return *this; } - DeviceQueueCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6583,15 +6749,14 @@ namespace vk DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceCreateInfo) ); + memcpy( this, &rhs, sizeof( DeviceCreateInfo ) ); } DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceCreateInfo) ); + memcpy( this, &rhs, sizeof( DeviceCreateInfo ) ); return *this; } - DeviceCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6702,15 +6867,14 @@ namespace vk InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(InstanceCreateInfo) ); + memcpy( this, &rhs, sizeof( InstanceCreateInfo ) ); } InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(InstanceCreateInfo) ); + memcpy( this, &rhs, sizeof( InstanceCreateInfo ) ); return *this; } - InstanceCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6801,15 +6965,14 @@ namespace vk MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryAllocateInfo) ); + memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) ); } MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryAllocateInfo) ); + memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) ); return *this; } - MemoryAllocateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6869,15 +7032,14 @@ namespace vk MappedMemoryRange( VkMappedMemoryRange const & rhs ) { - memcpy( this, &rhs, sizeof(MappedMemoryRange) ); + memcpy( this, &rhs, sizeof( MappedMemoryRange ) ); } MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs ) { - memcpy( this, &rhs, sizeof(MappedMemoryRange) ); + memcpy( this, &rhs, sizeof( MappedMemoryRange ) ); return *this; } - MappedMemoryRange& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -6950,15 +7112,14 @@ namespace vk WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) { - memcpy( this, &rhs, sizeof(WriteDescriptorSet) ); + memcpy( this, &rhs, sizeof( WriteDescriptorSet ) ); } WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs ) { - memcpy( this, &rhs, sizeof(WriteDescriptorSet) ); + memcpy( this, &rhs, sizeof( WriteDescriptorSet ) ); return *this; } - WriteDescriptorSet& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7070,15 +7231,14 @@ namespace vk CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) { - memcpy( this, &rhs, sizeof(CopyDescriptorSet) ); + memcpy( this, &rhs, sizeof( CopyDescriptorSet ) ); } CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs ) { - memcpy( this, &rhs, sizeof(CopyDescriptorSet) ); + memcpy( this, &rhs, sizeof( CopyDescriptorSet ) ); return *this; } - CopyDescriptorSet& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7180,15 +7340,14 @@ namespace vk BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BufferViewCreateInfo) ); + memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) ); } BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BufferViewCreateInfo) ); + memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) ); return *this; } - BufferViewCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7272,15 +7431,14 @@ namespace vk ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ShaderModuleCreateInfo) ); + memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) ); } ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ShaderModuleCreateInfo) ); + memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) ); return *this; } - ShaderModuleCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7348,15 +7506,14 @@ namespace vk DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetAllocateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) ); } DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetAllocateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) ); return *this; } - DescriptorSetAllocateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7426,15 +7583,14 @@ namespace vk PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineVertexInputStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) ); } PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineVertexInputStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) ); return *this; } - PipelineVertexInputStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7518,15 +7674,14 @@ namespace vk PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineInputAssemblyStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) ); } PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineInputAssemblyStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) ); return *this; } - PipelineInputAssemblyStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7593,15 +7748,14 @@ namespace vk PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineTessellationStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) ); } PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineTessellationStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) ); return *this; } - PipelineTessellationStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7663,15 +7817,14 @@ namespace vk PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) ); } PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) ); return *this; } - PipelineViewportStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7763,15 +7916,14 @@ namespace vk PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineRasterizationStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) ); } PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineRasterizationStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) ); return *this; } - PipelineRasterizationStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -7910,15 +8062,14 @@ namespace vk PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDepthStencilStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) ); } PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDepthStencilStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) ); return *this; } - PipelineDepthStencilStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8042,15 +8193,14 @@ namespace vk PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineCacheCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) ); } PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineCacheCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) ); return *this; } - PipelineCacheCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8131,15 +8281,14 @@ namespace vk SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SamplerCreateInfo) ); + memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); } SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SamplerCreateInfo) ); + memcpy( this, &rhs, sizeof( SamplerCreateInfo ) ); return *this; } - SamplerCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8311,15 +8460,14 @@ namespace vk CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferAllocateInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) ); } CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferAllocateInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) ); return *this; } - CommandBufferAllocateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8389,15 +8537,14 @@ namespace vk RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassBeginInfo) ); + memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) ); } RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassBeginInfo) ); + memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) ); return *this; } - RenderPassBeginInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8479,15 +8626,14 @@ namespace vk EventCreateInfo( VkEventCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(EventCreateInfo) ); + memcpy( this, &rhs, sizeof( EventCreateInfo ) ); } EventCreateInfo& operator=( VkEventCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(EventCreateInfo) ); + memcpy( this, &rhs, sizeof( EventCreateInfo ) ); return *this; } - EventCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8537,15 +8683,14 @@ namespace vk SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SemaphoreCreateInfo) ); + memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) ); } SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SemaphoreCreateInfo) ); + memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) ); return *this; } - SemaphoreCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8601,15 +8746,14 @@ namespace vk FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(FramebufferCreateInfo) ); + memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) ); } FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(FramebufferCreateInfo) ); + memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) ); return *this; } - FramebufferCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8708,15 +8852,14 @@ namespace vk DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayModeCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) ); } DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayModeCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) ); return *this; } - DisplayModeCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8776,15 +8919,14 @@ namespace vk DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayPresentInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) ); } DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayPresentInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) ); return *this; } - DisplayPresentInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8852,15 +8994,14 @@ namespace vk AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(AndroidSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) ); } AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(AndroidSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) ); return *this; } - AndroidSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8922,15 +9063,14 @@ namespace vk MirSurfaceCreateInfoKHR( VkMirSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(MirSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); } MirSurfaceCreateInfoKHR& operator=( VkMirSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(MirSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) ); return *this; } - MirSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -8999,15 +9139,14 @@ namespace vk ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) { - memcpy( this, &rhs, sizeof(ViSurfaceCreateInfoNN) ); + memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) ); } ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs ) { - memcpy( this, &rhs, sizeof(ViSurfaceCreateInfoNN) ); + memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) ); return *this; } - ViSurfaceCreateInfoNN& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9069,15 +9208,14 @@ namespace vk WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(WaylandSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) ); } WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(WaylandSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) ); return *this; } - WaylandSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9147,15 +9285,14 @@ namespace vk Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(Win32SurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) ); } Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(Win32SurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) ); return *this; } - Win32SurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9225,15 +9362,14 @@ namespace vk XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(XlibSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) ); } XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(XlibSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) ); return *this; } - XlibSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9303,15 +9439,14 @@ namespace vk XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(XcbSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) ); } XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(XcbSurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) ); return *this; } - XcbSurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9379,15 +9514,14 @@ namespace vk DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerMarkerInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) ); } DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerMarkerInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) ); return *this; } - DebugMarkerMarkerInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9445,15 +9579,14 @@ namespace vk DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationImageCreateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) ); } DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationImageCreateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) ); return *this; } - DedicatedAllocationImageCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9503,15 +9636,14 @@ namespace vk DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationBufferCreateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) ); } DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationBufferCreateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) ); return *this; } - DedicatedAllocationBufferCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9562,15 +9694,14 @@ namespace vk DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationMemoryAllocateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) ); } DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(DedicatedAllocationMemoryAllocateInfoNV) ); + memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) ); return *this; } - DedicatedAllocationMemoryAllocateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9630,15 +9761,14 @@ namespace vk ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoNV) ); + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) ); } ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoNV) ); + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) ); return *this; } - ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9704,15 +9834,14 @@ namespace vk Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoNV) ); + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) ); } Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoNV) ); + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) ); return *this; } - Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9811,15 +9940,14 @@ namespace vk DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsFeaturesNVX) ); + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) ); } DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsFeaturesNVX) ); + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) ); return *this; } - DeviceGeneratedCommandsFeaturesNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9873,15 +10001,14 @@ namespace vk DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsLimitsNVX) ); + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) ); } DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGeneratedCommandsLimitsNVX) ); + memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) ); return *this; } - DeviceGeneratedCommandsLimitsNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -9965,15 +10092,14 @@ namespace vk CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(CmdReserveSpaceForCommandsInfoNVX) ); + memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) ); } CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(CmdReserveSpaceForCommandsInfoNVX) ); + memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) ); return *this; } - CmdReserveSpaceForCommandsInfoNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10039,15 +10165,14 @@ namespace vk PhysicalDeviceFeatures2KHR( VkPhysicalDeviceFeatures2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2KHR ) ); } PhysicalDeviceFeatures2KHR& operator=( VkPhysicalDeviceFeatures2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceFeatures2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2KHR ) ); return *this; } - PhysicalDeviceFeatures2KHR& setPNext( void* pNext_ ) { pNext = pNext_; @@ -10097,15 +10222,14 @@ namespace vk PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDevicePushDescriptorPropertiesKHR) ); + memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) ); } PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDevicePushDescriptorPropertiesKHR) ); + memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) ); return *this; } - PhysicalDevicePushDescriptorPropertiesKHR& setPNext( void* pNext_ ) { pNext = pNext_; @@ -10156,15 +10280,14 @@ namespace vk PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentRegionsKHR) ); + memcpy( this, &rhs, sizeof( PresentRegionsKHR ) ); } PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentRegionsKHR) ); + memcpy( this, &rhs, sizeof( PresentRegionsKHR ) ); return *this; } - PresentRegionsKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10211,24 +10334,91 @@ namespace vk }; static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" ); - struct PhysicalDeviceIDPropertiesKHX + struct PhysicalDeviceVariablePointerFeaturesKHR { - operator const VkPhysicalDeviceIDPropertiesKHX&() const + PhysicalDeviceVariablePointerFeaturesKHR( Bool32 variablePointersStorageBuffer_ = 0, Bool32 variablePointers_ = 0 ) + : sType( StructureType::ePhysicalDeviceVariablePointerFeaturesKHR ) + , pNext( nullptr ) + , variablePointersStorageBuffer( variablePointersStorageBuffer_ ) + , variablePointers( variablePointers_ ) { - return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceIDPropertiesKHX const& rhs ) const + PhysicalDeviceVariablePointerFeaturesKHR( VkPhysicalDeviceVariablePointerFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) ); + } + + PhysicalDeviceVariablePointerFeaturesKHR& operator=( VkPhysicalDeviceVariablePointerFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) ); + return *this; + } + PhysicalDeviceVariablePointerFeaturesKHR& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceVariablePointerFeaturesKHR& setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) + { + variablePointersStorageBuffer = variablePointersStorageBuffer_; + return *this; + } + + PhysicalDeviceVariablePointerFeaturesKHR& setVariablePointers( Bool32 variablePointers_ ) + { + variablePointers = variablePointers_; + return *this; + } + + operator const VkPhysicalDeviceVariablePointerFeaturesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceVariablePointerFeaturesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) + && ( variablePointers == rhs.variablePointers ); + } + + bool operator!=( PhysicalDeviceVariablePointerFeaturesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + Bool32 variablePointersStorageBuffer; + Bool32 variablePointers; + }; + static_assert( sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) == sizeof( VkPhysicalDeviceVariablePointerFeaturesKHR ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceIDPropertiesKHR + { + operator const VkPhysicalDeviceIDPropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceIDPropertiesKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( deviceUUID, rhs.deviceUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) && ( memcmp( driverUUID, rhs.driverUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 ) - && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE_KHX * sizeof( uint8_t ) ) == 0 ) + && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE_KHR * sizeof( uint8_t ) ) == 0 ) + && ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ); } - bool operator!=( PhysicalDeviceIDPropertiesKHX const& rhs ) const + bool operator!=( PhysicalDeviceIDPropertiesKHR const& rhs ) const { return !operator==( rhs ); } @@ -10240,16 +10430,17 @@ namespace vk void* pNext; uint8_t deviceUUID[VK_UUID_SIZE]; uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE_KHX]; + uint8_t deviceLUID[VK_LUID_SIZE_KHR]; + uint32_t deviceNodeMask; Bool32 deviceLUIDValid; }; - static_assert( sizeof( PhysicalDeviceIDPropertiesKHX ) == sizeof( VkPhysicalDeviceIDPropertiesKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceIDPropertiesKHR ) == sizeof( VkPhysicalDeviceIDPropertiesKHR ), "struct and wrapper have different size!" ); -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct ExportMemoryWin32HandleInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportMemoryWin32HandleInfoKHR { - ExportMemoryWin32HandleInfoKHX( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) - : sType( StructureType::eExportMemoryWin32HandleInfoKHX ) + ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eExportMemoryWin32HandleInfoKHR ) , pNext( nullptr ) , pAttributes( pAttributes_ ) , dwAccess( dwAccess_ ) @@ -10257,47 +10448,46 @@ namespace vk { } - ExportMemoryWin32HandleInfoKHX( VkExportMemoryWin32HandleInfoKHX const & rhs ) + ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) ); } - ExportMemoryWin32HandleInfoKHX& operator=( VkExportMemoryWin32HandleInfoKHX const & rhs ) + ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) ); return *this; } - - ExportMemoryWin32HandleInfoKHX& setPNext( const void* pNext_ ) + ExportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExportMemoryWin32HandleInfoKHX& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) + ExportMemoryWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) { pAttributes = pAttributes_; return *this; } - ExportMemoryWin32HandleInfoKHX& setDwAccess( DWORD dwAccess_ ) + ExportMemoryWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) { dwAccess = dwAccess_; return *this; } - ExportMemoryWin32HandleInfoKHX& setName( LPCWSTR name_ ) + ExportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ ) { name = name_; return *this; } - operator const VkExportMemoryWin32HandleInfoKHX&() const + operator const VkExportMemoryWin32HandleInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExportMemoryWin32HandleInfoKHX const& rhs ) const + bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -10306,7 +10496,7 @@ namespace vk && ( name == rhs.name ); } - bool operator!=( ExportMemoryWin32HandleInfoKHX const& rhs ) const + bool operator!=( ExportMemoryWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -10320,72 +10510,72 @@ namespace vk DWORD dwAccess; LPCWSTR name; }; - static_assert( sizeof( ExportMemoryWin32HandleInfoKHX ) == sizeof( VkExportMemoryWin32HandleInfoKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ - -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct MemoryWin32HandlePropertiesKHX - { - operator const VkMemoryWin32HandlePropertiesKHX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryWin32HandlePropertiesKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( MemoryWin32HandlePropertiesKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType; - - public: - void* pNext; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryWin32HandlePropertiesKHX ) == sizeof( VkMemoryWin32HandlePropertiesKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ - - struct MemoryFdPropertiesKHX - { - operator const VkMemoryFdPropertiesKHX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( MemoryFdPropertiesKHX const& rhs ) const - { - return ( sType == rhs.sType ) - && ( pNext == rhs.pNext ) - && ( memoryTypeBits == rhs.memoryTypeBits ); - } - - bool operator!=( MemoryFdPropertiesKHX const& rhs ) const - { - return !operator==( rhs ); - } - - private: - StructureType sType; - - public: - void* pNext; - uint32_t memoryTypeBits; - }; - static_assert( sizeof( MemoryFdPropertiesKHX ) == sizeof( VkMemoryFdPropertiesKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ #ifdef VK_USE_PLATFORM_WIN32_KHR - struct Win32KeyedMutexAcquireReleaseInfoKHX + struct MemoryWin32HandlePropertiesKHR { - Win32KeyedMutexAcquireReleaseInfoKHX( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeouts_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) - : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoKHX ) + operator const VkMemoryWin32HandlePropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryTypeBits == rhs.memoryTypeBits ); + } + + bool operator!=( MemoryWin32HandlePropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + uint32_t memoryTypeBits; + }; + static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct MemoryFdPropertiesKHR + { + operator const VkMemoryFdPropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryFdPropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryTypeBits == rhs.memoryTypeBits ); + } + + bool operator!=( MemoryFdPropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + uint32_t memoryTypeBits; + }; + static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" ); + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct Win32KeyedMutexAcquireReleaseInfoKHR + { + Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeouts_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr ) + : sType( StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR ) , pNext( nullptr ) , acquireCount( acquireCount_ ) , pAcquireSyncs( pAcquireSyncs_ ) @@ -10397,71 +10587,70 @@ namespace vk { } - Win32KeyedMutexAcquireReleaseInfoKHX( VkWin32KeyedMutexAcquireReleaseInfoKHX const & rhs ) + Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoKHX) ); + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) ); } - Win32KeyedMutexAcquireReleaseInfoKHX& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHX const & rhs ) + Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(Win32KeyedMutexAcquireReleaseInfoKHX) ); + memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) ); return *this; } - - Win32KeyedMutexAcquireReleaseInfoKHX& setPNext( const void* pNext_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setAcquireCount( uint32_t acquireCount_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setAcquireCount( uint32_t acquireCount_ ) { acquireCount = acquireCount_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ ) { pAcquireSyncs = pAcquireSyncs_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPAcquireKeys( const uint64_t* pAcquireKeys_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireKeys( const uint64_t* pAcquireKeys_ ) { pAcquireKeys = pAcquireKeys_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ ) { pAcquireTimeouts = pAcquireTimeouts_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setReleaseCount( uint32_t releaseCount_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setReleaseCount( uint32_t releaseCount_ ) { releaseCount = releaseCount_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ ) { pReleaseSyncs = pReleaseSyncs_; return *this; } - Win32KeyedMutexAcquireReleaseInfoKHX& setPReleaseKeys( const uint64_t* pReleaseKeys_ ) + Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseKeys( const uint64_t* pReleaseKeys_ ) { pReleaseKeys = pReleaseKeys_; return *this; } - operator const VkWin32KeyedMutexAcquireReleaseInfoKHX&() const + operator const VkWin32KeyedMutexAcquireReleaseInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( Win32KeyedMutexAcquireReleaseInfoKHX const& rhs ) const + bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -10474,7 +10663,7 @@ namespace vk && ( pReleaseKeys == rhs.pReleaseKeys ); } - bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHX const& rhs ) const + bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -10492,14 +10681,14 @@ namespace vk const DeviceMemory* pReleaseSyncs; const uint64_t* pReleaseKeys; }; - static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHX ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" ); #endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct ExportSemaphoreWin32HandleInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportSemaphoreWin32HandleInfoKHR { - ExportSemaphoreWin32HandleInfoKHX( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) - : sType( StructureType::eExportSemaphoreWin32HandleInfoKHX ) + ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eExportSemaphoreWin32HandleInfoKHR ) , pNext( nullptr ) , pAttributes( pAttributes_ ) , dwAccess( dwAccess_ ) @@ -10507,47 +10696,46 @@ namespace vk { } - ExportSemaphoreWin32HandleInfoKHX( VkExportSemaphoreWin32HandleInfoKHX const & rhs ) + ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExportSemaphoreWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) ); } - ExportSemaphoreWin32HandleInfoKHX& operator=( VkExportSemaphoreWin32HandleInfoKHX const & rhs ) + ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExportSemaphoreWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) ); return *this; } - - ExportSemaphoreWin32HandleInfoKHX& setPNext( const void* pNext_ ) + ExportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExportSemaphoreWin32HandleInfoKHX& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) + ExportSemaphoreWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) { pAttributes = pAttributes_; return *this; } - ExportSemaphoreWin32HandleInfoKHX& setDwAccess( DWORD dwAccess_ ) + ExportSemaphoreWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) { dwAccess = dwAccess_; return *this; } - ExportSemaphoreWin32HandleInfoKHX& setName( LPCWSTR name_ ) + ExportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ ) { name = name_; return *this; } - operator const VkExportSemaphoreWin32HandleInfoKHX&() const + operator const VkExportSemaphoreWin32HandleInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExportSemaphoreWin32HandleInfoKHX const& rhs ) const + bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -10556,7 +10744,7 @@ namespace vk && ( name == rhs.name ); } - bool operator!=( ExportSemaphoreWin32HandleInfoKHX const& rhs ) const + bool operator!=( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -10570,14 +10758,14 @@ namespace vk DWORD dwAccess; LPCWSTR name; }; - static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHX ) == sizeof( VkExportSemaphoreWin32HandleInfoKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ + static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct D3D12FenceSubmitInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct D3D12FenceSubmitInfoKHR { - D3D12FenceSubmitInfoKHX( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr ) - : sType( StructureType::eD3D12FenceSubmitInfoKHX ) + D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr ) + : sType( StructureType::eD3D12FenceSubmitInfoKHR ) , pNext( nullptr ) , waitSemaphoreValuesCount( waitSemaphoreValuesCount_ ) , pWaitSemaphoreValues( pWaitSemaphoreValues_ ) @@ -10586,53 +10774,52 @@ namespace vk { } - D3D12FenceSubmitInfoKHX( VkD3D12FenceSubmitInfoKHX const & rhs ) + D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(D3D12FenceSubmitInfoKHX) ); + memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) ); } - D3D12FenceSubmitInfoKHX& operator=( VkD3D12FenceSubmitInfoKHX const & rhs ) + D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(D3D12FenceSubmitInfoKHX) ); + memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) ); return *this; } - - D3D12FenceSubmitInfoKHX& setPNext( const void* pNext_ ) + D3D12FenceSubmitInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - D3D12FenceSubmitInfoKHX& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) + D3D12FenceSubmitInfoKHR& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) { waitSemaphoreValuesCount = waitSemaphoreValuesCount_; return *this; } - D3D12FenceSubmitInfoKHX& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ ) + D3D12FenceSubmitInfoKHR& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ ) { pWaitSemaphoreValues = pWaitSemaphoreValues_; return *this; } - D3D12FenceSubmitInfoKHX& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) + D3D12FenceSubmitInfoKHR& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) { signalSemaphoreValuesCount = signalSemaphoreValuesCount_; return *this; } - D3D12FenceSubmitInfoKHX& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ ) + D3D12FenceSubmitInfoKHR& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ ) { pSignalSemaphoreValues = pSignalSemaphoreValues_; return *this; } - operator const VkD3D12FenceSubmitInfoKHX&() const + operator const VkD3D12FenceSubmitInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( D3D12FenceSubmitInfoKHX const& rhs ) const + bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -10642,7 +10829,7 @@ namespace vk && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); } - bool operator!=( D3D12FenceSubmitInfoKHX const& rhs ) const + bool operator!=( D3D12FenceSubmitInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -10657,8 +10844,85 @@ namespace vk uint32_t signalSemaphoreValuesCount; const uint64_t* pSignalSemaphoreValues; }; - static_assert( sizeof( D3D12FenceSubmitInfoKHX ) == sizeof( VkD3D12FenceSubmitInfoKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ + static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ExportFenceWin32HandleInfoKHR + { + ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eExportFenceWin32HandleInfoKHR ) + , pNext( nullptr ) + , pAttributes( pAttributes_ ) + , dwAccess( dwAccess_ ) + , name( name_ ) + { + } + + ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) ); + } + + ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) ); + return *this; + } + ExportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportFenceWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ ) + { + pAttributes = pAttributes_; + return *this; + } + + ExportFenceWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ ) + { + dwAccess = dwAccess_; + return *this; + } + + ExportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkExportFenceWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( pAttributes == rhs.pAttributes ) + && ( dwAccess == rhs.dwAccess ) + && ( name == rhs.name ); + } + + bool operator!=( ExportFenceWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; + }; + static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ struct PhysicalDeviceMultiviewFeaturesKHX { @@ -10673,15 +10937,14 @@ namespace vk PhysicalDeviceMultiviewFeaturesKHX( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceMultiviewFeaturesKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeaturesKHX ) ); } PhysicalDeviceMultiviewFeaturesKHX& operator=( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceMultiviewFeaturesKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeaturesKHX ) ); return *this; } - PhysicalDeviceMultiviewFeaturesKHX& setPNext( void* pNext_ ) { pNext = pNext_; @@ -10782,15 +11045,14 @@ namespace vk RenderPassMultiviewCreateInfoKHX( VkRenderPassMultiviewCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassMultiviewCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfoKHX ) ); } RenderPassMultiviewCreateInfoKHX& operator=( VkRenderPassMultiviewCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassMultiviewCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfoKHX ) ); return *this; } - RenderPassMultiviewCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10884,15 +11146,14 @@ namespace vk BindBufferMemoryInfoKHX( VkBindBufferMemoryInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindBufferMemoryInfoKHX) ); + memcpy( this, &rhs, sizeof( BindBufferMemoryInfoKHX ) ); } BindBufferMemoryInfoKHX& operator=( VkBindBufferMemoryInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindBufferMemoryInfoKHX) ); + memcpy( this, &rhs, sizeof( BindBufferMemoryInfoKHX ) ); return *this; } - BindBufferMemoryInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -10980,15 +11241,14 @@ namespace vk BindImageMemoryInfoKHX( VkBindImageMemoryInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindImageMemoryInfoKHX) ); + memcpy( this, &rhs, sizeof( BindImageMemoryInfoKHX ) ); } BindImageMemoryInfoKHX& operator=( VkBindImageMemoryInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindImageMemoryInfoKHX) ); + memcpy( this, &rhs, sizeof( BindImageMemoryInfoKHX ) ); return *this; } - BindImageMemoryInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11088,15 +11348,14 @@ namespace vk DeviceGroupRenderPassBeginInfoKHX( VkDeviceGroupRenderPassBeginInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupRenderPassBeginInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfoKHX ) ); } DeviceGroupRenderPassBeginInfoKHX& operator=( VkDeviceGroupRenderPassBeginInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupRenderPassBeginInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfoKHX ) ); return *this; } - DeviceGroupRenderPassBeginInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11162,15 +11421,14 @@ namespace vk DeviceGroupCommandBufferBeginInfoKHX( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupCommandBufferBeginInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfoKHX ) ); } DeviceGroupCommandBufferBeginInfoKHX& operator=( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupCommandBufferBeginInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfoKHX ) ); return *this; } - DeviceGroupCommandBufferBeginInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11225,15 +11483,14 @@ namespace vk DeviceGroupSubmitInfoKHX( VkDeviceGroupSubmitInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupSubmitInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfoKHX ) ); } DeviceGroupSubmitInfoKHX& operator=( VkDeviceGroupSubmitInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupSubmitInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfoKHX ) ); return *this; } - DeviceGroupSubmitInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11324,15 +11581,14 @@ namespace vk DeviceGroupBindSparseInfoKHX( VkDeviceGroupBindSparseInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupBindSparseInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfoKHX ) ); } DeviceGroupBindSparseInfoKHX& operator=( VkDeviceGroupBindSparseInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupBindSparseInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfoKHX ) ); return *this; } - DeviceGroupBindSparseInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11390,15 +11646,14 @@ namespace vk ImageSwapchainCreateInfoKHX( VkImageSwapchainCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSwapchainCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHX ) ); } ImageSwapchainCreateInfoKHX& operator=( VkImageSwapchainCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSwapchainCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHX ) ); return *this; } - ImageSwapchainCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11449,15 +11704,14 @@ namespace vk BindImageMemorySwapchainInfoKHX( VkBindImageMemorySwapchainInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindImageMemorySwapchainInfoKHX) ); + memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHX ) ); } BindImageMemorySwapchainInfoKHX& operator=( VkBindImageMemorySwapchainInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(BindImageMemorySwapchainInfoKHX) ); + memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHX ) ); return *this; } - BindImageMemorySwapchainInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11519,15 +11773,14 @@ namespace vk AcquireNextImageInfoKHX( VkAcquireNextImageInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(AcquireNextImageInfoKHX) ); + memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHX ) ); } AcquireNextImageInfoKHX& operator=( VkAcquireNextImageInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(AcquireNextImageInfoKHX) ); + memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHX ) ); return *this; } - AcquireNextImageInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11616,15 +11869,14 @@ namespace vk HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) { - memcpy( this, &rhs, sizeof(HdrMetadataEXT) ); + memcpy( this, &rhs, sizeof( HdrMetadataEXT ) ); } HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs ) { - memcpy( this, &rhs, sizeof(HdrMetadataEXT) ); + memcpy( this, &rhs, sizeof( HdrMetadataEXT ) ); return *this; } - HdrMetadataEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11731,15 +11983,14 @@ namespace vk PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PresentTimesInfoGOOGLE) ); + memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) ); } PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs ) { - memcpy( this, &rhs, sizeof(PresentTimesInfoGOOGLE) ); + memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) ); return *this; } - PresentTimesInfoGOOGLE& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11799,15 +12050,14 @@ namespace vk IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) { - memcpy( this, &rhs, sizeof(IOSSurfaceCreateInfoMVK) ); + memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) ); } IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) { - memcpy( this, &rhs, sizeof(IOSSurfaceCreateInfoMVK) ); + memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) ); return *this; } - IOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11868,15 +12118,14 @@ namespace vk MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) { - memcpy( this, &rhs, sizeof(MacOSSurfaceCreateInfoMVK) ); + memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) ); } MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) { - memcpy( this, &rhs, sizeof(MacOSSurfaceCreateInfoMVK) ); + memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) ); return *this; } - MacOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -11937,15 +12186,14 @@ namespace vk PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportWScalingStateCreateInfoNV) ); + memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) ); } PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportWScalingStateCreateInfoNV) ); + memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) ); return *this; } - PipelineViewportWScalingStateCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -12011,15 +12259,14 @@ namespace vk PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceDiscardRectanglePropertiesEXT) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) ); } PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceDiscardRectanglePropertiesEXT) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) ); return *this; } - PhysicalDeviceDiscardRectanglePropertiesEXT& setPNext( void* pNext_ ) { pNext = pNext_; @@ -12086,6 +12333,670 @@ namespace vk }; static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" ); + struct PhysicalDeviceSurfaceInfo2KHR + { + PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() ) + : sType( StructureType::ePhysicalDeviceSurfaceInfo2KHR ) + , pNext( nullptr ) + , surface( surface_ ) + { + } + + PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) ); + } + + PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) ); + return *this; + } + PhysicalDeviceSurfaceInfo2KHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceSurfaceInfo2KHR& setSurface( SurfaceKHR surface_ ) + { + surface = surface_; + return *this; + } + + operator const VkPhysicalDeviceSurfaceInfo2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( surface == rhs.surface ); + } + + bool operator!=( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + SurfaceKHR surface; + }; + static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" ); + + struct PhysicalDevice16BitStorageFeaturesKHR + { + PhysicalDevice16BitStorageFeaturesKHR( Bool32 storageBuffer16BitAccess_ = 0, Bool32 uniformAndStorageBuffer16BitAccess_ = 0, Bool32 storagePushConstant16_ = 0, Bool32 storageInputOutput16_ = 0 ) + : sType( StructureType::ePhysicalDevice16BitStorageFeaturesKHR ) + , pNext( nullptr ) + , storageBuffer16BitAccess( storageBuffer16BitAccess_ ) + , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ ) + , storagePushConstant16( storagePushConstant16_ ) + , storageInputOutput16( storageInputOutput16_ ) + { + } + + PhysicalDevice16BitStorageFeaturesKHR( VkPhysicalDevice16BitStorageFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeaturesKHR ) ); + } + + PhysicalDevice16BitStorageFeaturesKHR& operator=( VkPhysicalDevice16BitStorageFeaturesKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeaturesKHR ) ); + return *this; + } + PhysicalDevice16BitStorageFeaturesKHR& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDevice16BitStorageFeaturesKHR& setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) + { + storageBuffer16BitAccess = storageBuffer16BitAccess_; + return *this; + } + + PhysicalDevice16BitStorageFeaturesKHR& setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) + { + uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; + return *this; + } + + PhysicalDevice16BitStorageFeaturesKHR& setStoragePushConstant16( Bool32 storagePushConstant16_ ) + { + storagePushConstant16 = storagePushConstant16_; + return *this; + } + + PhysicalDevice16BitStorageFeaturesKHR& setStorageInputOutput16( Bool32 storageInputOutput16_ ) + { + storageInputOutput16 = storageInputOutput16_; + return *this; + } + + operator const VkPhysicalDevice16BitStorageFeaturesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDevice16BitStorageFeaturesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) + && ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) + && ( storagePushConstant16 == rhs.storagePushConstant16 ) + && ( storageInputOutput16 == rhs.storageInputOutput16 ); + } + + bool operator!=( PhysicalDevice16BitStorageFeaturesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + Bool32 storageBuffer16BitAccess; + Bool32 uniformAndStorageBuffer16BitAccess; + Bool32 storagePushConstant16; + Bool32 storageInputOutput16; + }; + static_assert( sizeof( PhysicalDevice16BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice16BitStorageFeaturesKHR ), "struct and wrapper have different size!" ); + + struct BufferMemoryRequirementsInfo2KHR + { + BufferMemoryRequirementsInfo2KHR( Buffer buffer_ = Buffer() ) + : sType( StructureType::eBufferMemoryRequirementsInfo2KHR ) + , pNext( nullptr ) + , buffer( buffer_ ) + { + } + + BufferMemoryRequirementsInfo2KHR( VkBufferMemoryRequirementsInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2KHR ) ); + } + + BufferMemoryRequirementsInfo2KHR& operator=( VkBufferMemoryRequirementsInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2KHR ) ); + return *this; + } + BufferMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + BufferMemoryRequirementsInfo2KHR& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + operator const VkBufferMemoryRequirementsInfo2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( BufferMemoryRequirementsInfo2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( buffer == rhs.buffer ); + } + + bool operator!=( BufferMemoryRequirementsInfo2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Buffer buffer; + }; + static_assert( sizeof( BufferMemoryRequirementsInfo2KHR ) == sizeof( VkBufferMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); + + struct ImageMemoryRequirementsInfo2KHR + { + ImageMemoryRequirementsInfo2KHR( Image image_ = Image() ) + : sType( StructureType::eImageMemoryRequirementsInfo2KHR ) + , pNext( nullptr ) + , image( image_ ) + { + } + + ImageMemoryRequirementsInfo2KHR( VkImageMemoryRequirementsInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2KHR ) ); + } + + ImageMemoryRequirementsInfo2KHR& operator=( VkImageMemoryRequirementsInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2KHR ) ); + return *this; + } + ImageMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageMemoryRequirementsInfo2KHR& setImage( Image image_ ) + { + image = image_; + return *this; + } + + operator const VkImageMemoryRequirementsInfo2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageMemoryRequirementsInfo2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( image == rhs.image ); + } + + bool operator!=( ImageMemoryRequirementsInfo2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Image image; + }; + static_assert( sizeof( ImageMemoryRequirementsInfo2KHR ) == sizeof( VkImageMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); + + struct ImageSparseMemoryRequirementsInfo2KHR + { + ImageSparseMemoryRequirementsInfo2KHR( Image image_ = Image() ) + : sType( StructureType::eImageSparseMemoryRequirementsInfo2KHR ) + , pNext( nullptr ) + , image( image_ ) + { + } + + ImageSparseMemoryRequirementsInfo2KHR( VkImageSparseMemoryRequirementsInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2KHR ) ); + } + + ImageSparseMemoryRequirementsInfo2KHR& operator=( VkImageSparseMemoryRequirementsInfo2KHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2KHR ) ); + return *this; + } + ImageSparseMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImageSparseMemoryRequirementsInfo2KHR& setImage( Image image_ ) + { + image = image_; + return *this; + } + + operator const VkImageSparseMemoryRequirementsInfo2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImageSparseMemoryRequirementsInfo2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( image == rhs.image ); + } + + bool operator!=( ImageSparseMemoryRequirementsInfo2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Image image; + }; + static_assert( sizeof( ImageSparseMemoryRequirementsInfo2KHR ) == sizeof( VkImageSparseMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" ); + + struct MemoryRequirements2KHR + { + operator const VkMemoryRequirements2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryRequirements2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryRequirements == rhs.memoryRequirements ); + } + + bool operator!=( MemoryRequirements2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + MemoryRequirements memoryRequirements; + }; + static_assert( sizeof( MemoryRequirements2KHR ) == sizeof( VkMemoryRequirements2KHR ), "struct and wrapper have different size!" ); + + struct MemoryDedicatedRequirementsKHR + { + operator const VkMemoryDedicatedRequirementsKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryDedicatedRequirementsKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) + && ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation ); + } + + bool operator!=( MemoryDedicatedRequirementsKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + Bool32 prefersDedicatedAllocation; + Bool32 requiresDedicatedAllocation; + }; + static_assert( sizeof( MemoryDedicatedRequirementsKHR ) == sizeof( VkMemoryDedicatedRequirementsKHR ), "struct and wrapper have different size!" ); + + struct MemoryDedicatedAllocateInfoKHR + { + MemoryDedicatedAllocateInfoKHR( Image image_ = Image(), Buffer buffer_ = Buffer() ) + : sType( StructureType::eMemoryDedicatedAllocateInfoKHR ) + , pNext( nullptr ) + , image( image_ ) + , buffer( buffer_ ) + { + } + + MemoryDedicatedAllocateInfoKHR( VkMemoryDedicatedAllocateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfoKHR ) ); + } + + MemoryDedicatedAllocateInfoKHR& operator=( VkMemoryDedicatedAllocateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfoKHR ) ); + return *this; + } + MemoryDedicatedAllocateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryDedicatedAllocateInfoKHR& setImage( Image image_ ) + { + image = image_; + return *this; + } + + MemoryDedicatedAllocateInfoKHR& setBuffer( Buffer buffer_ ) + { + buffer = buffer_; + return *this; + } + + operator const VkMemoryDedicatedAllocateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryDedicatedAllocateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( image == rhs.image ) + && ( buffer == rhs.buffer ); + } + + bool operator!=( MemoryDedicatedAllocateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Image image; + Buffer buffer; + }; + static_assert( sizeof( MemoryDedicatedAllocateInfoKHR ) == sizeof( VkMemoryDedicatedAllocateInfoKHR ), "struct and wrapper have different size!" ); + + struct TextureLODGatherFormatPropertiesAMD + { + operator const VkTextureLODGatherFormatPropertiesAMD&() const + { + return *reinterpret_cast(this); + } + + bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); + } + + bool operator!=( TextureLODGatherFormatPropertiesAMD const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + Bool32 supportsTextureGatherLODBiasAMD; + }; + static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" ); + + struct PipelineCoverageToColorStateCreateInfoNV + { + PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), Bool32 coverageToColorEnable_ = 0, uint32_t coverageToColorLocation_ = 0 ) + : sType( StructureType::ePipelineCoverageToColorStateCreateInfoNV ) + , pNext( nullptr ) + , flags( flags_ ) + , coverageToColorEnable( coverageToColorEnable_ ) + , coverageToColorLocation( coverageToColorLocation_ ) + { + } + + PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); + } + + PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) ); + return *this; + } + PipelineCoverageToColorStateCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineCoverageToColorStateCreateInfoNV& setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ ) + { + flags = flags_; + return *this; + } + + PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorEnable( Bool32 coverageToColorEnable_ ) + { + coverageToColorEnable = coverageToColorEnable_; + return *this; + } + + PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorLocation( uint32_t coverageToColorLocation_ ) + { + coverageToColorLocation = coverageToColorLocation_; + return *this; + } + + operator const VkPipelineCoverageToColorStateCreateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( coverageToColorEnable == rhs.coverageToColorEnable ) + && ( coverageToColorLocation == rhs.coverageToColorLocation ); + } + + bool operator!=( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + PipelineCoverageToColorStateCreateFlagsNV flags; + Bool32 coverageToColorEnable; + uint32_t coverageToColorLocation; + }; + static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT + { + operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) + && ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); + } + + bool operator!=( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + Bool32 filterMinmaxSingleComponentFormats; + Bool32 filterMinmaxImageComponentMapping; + }; + static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT + { + PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 ) + : sType( StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT ) + , pNext( nullptr ) + , advancedBlendCoherentOperations( advancedBlendCoherentOperations_ ) + { + } + + PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); + } + + PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) ); + return *this; + } + PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setPNext( void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ ) + { + advancedBlendCoherentOperations = advancedBlendCoherentOperations_; + return *this; + } + + operator const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); + } + + bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + Bool32 advancedBlendCoherentOperations; + }; + static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" ); + + struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT + { + operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) + && ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) + && ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) + && ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) + && ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) + && ( advancedBlendAllOperations == rhs.advancedBlendAllOperations ); + } + + bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + Bool32 advancedBlendIndependentBlend; + Bool32 advancedBlendNonPremultipliedSrcColor; + Bool32 advancedBlendNonPremultipliedDstColor; + Bool32 advancedBlendCorrelatedOverlap; + Bool32 advancedBlendAllOperations; + }; + static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" ); + enum class SubpassContents { eInline = VK_SUBPASS_CONTENTS_INLINE, @@ -12108,15 +13019,14 @@ namespace vk PresentInfoKHR( VkPresentInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentInfoKHR) ); + memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); } PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PresentInfoKHR) ); + memcpy( this, &rhs, sizeof( PresentInfoKHR ) ); return *this; } - PresentInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -12223,15 +13133,14 @@ namespace vk PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); } PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDynamicStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) ); return *this; } - PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -12310,15 +13219,14 @@ namespace vk DescriptorUpdateTemplateCreateInfoKHR( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) ); } DescriptorUpdateTemplateCreateInfoKHR& operator=( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorUpdateTemplateCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) ); return *this; } - DescriptorUpdateTemplateCreateInfoKHR& setPNext( void* pNext_ ) { pNext = pNext_; @@ -12413,6 +13321,44 @@ namespace vk }; static_assert( sizeof( DescriptorUpdateTemplateCreateInfoKHR ) == sizeof( VkDescriptorUpdateTemplateCreateInfoKHR ), "struct and wrapper have different size!" ); + enum class ObjectType + { + eUnknown = VK_OBJECT_TYPE_UNKNOWN, + eInstance = VK_OBJECT_TYPE_INSTANCE, + ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE, + eDevice = VK_OBJECT_TYPE_DEVICE, + eQueue = VK_OBJECT_TYPE_QUEUE, + eSemaphore = VK_OBJECT_TYPE_SEMAPHORE, + eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER, + eFence = VK_OBJECT_TYPE_FENCE, + eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY, + eBuffer = VK_OBJECT_TYPE_BUFFER, + eImage = VK_OBJECT_TYPE_IMAGE, + eEvent = VK_OBJECT_TYPE_EVENT, + eQueryPool = VK_OBJECT_TYPE_QUERY_POOL, + eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW, + eImageView = VK_OBJECT_TYPE_IMAGE_VIEW, + eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE, + ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE, + ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT, + eRenderPass = VK_OBJECT_TYPE_RENDER_PASS, + ePipeline = VK_OBJECT_TYPE_PIPELINE, + eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, + eSampler = VK_OBJECT_TYPE_SAMPLER, + eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL, + eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET, + eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER, + eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL, + eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR, + eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR, + eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR, + eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR, + eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, + eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, + eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX, + eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX + }; + enum class QueueFlagBits { eGraphics = VK_QUEUE_GRAPHICS_BIT, @@ -12672,7 +13618,8 @@ namespace vk eMemoryRead = VK_ACCESS_MEMORY_READ_BIT, eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT, eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX, - eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX + eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX, + eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT }; using AccessFlags = Flags; @@ -12691,7 +13638,7 @@ namespace vk { enum { - allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) + allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT) }; }; @@ -12707,15 +13654,14 @@ namespace vk MemoryBarrier( VkMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryBarrier) ); + memcpy( this, &rhs, sizeof( MemoryBarrier ) ); } MemoryBarrier& operator=( VkMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryBarrier) ); + memcpy( this, &rhs, sizeof( MemoryBarrier ) ); return *this; } - MemoryBarrier& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -12779,15 +13725,14 @@ namespace vk BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(BufferMemoryBarrier) ); + memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); } BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(BufferMemoryBarrier) ); + memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) ); return *this; } - BufferMemoryBarrier& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -12950,15 +13895,14 @@ namespace vk BufferCreateInfo( VkBufferCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BufferCreateInfo) ); + memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); } BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BufferCreateInfo) ); + memcpy( this, &rhs, sizeof( BufferCreateInfo ) ); return *this; } - BufferCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13082,15 +14026,14 @@ namespace vk DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) ); + memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); } DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetLayoutBinding) ); + memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) ); return *this; } - DescriptorSetLayoutBinding& setBinding( uint32_t binding_ ) { binding = binding_; @@ -13163,15 +14106,14 @@ namespace vk PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); } PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineShaderStageCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) ); return *this; } - PipelineShaderStageCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13253,15 +14195,14 @@ namespace vk PushConstantRange( VkPushConstantRange const & rhs ) { - memcpy( this, &rhs, sizeof(PushConstantRange) ); + memcpy( this, &rhs, sizeof( PushConstantRange ) ); } PushConstantRange& operator=( VkPushConstantRange const & rhs ) { - memcpy( this, &rhs, sizeof(PushConstantRange) ); + memcpy( this, &rhs, sizeof( PushConstantRange ) ); return *this; } - PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ ) { stageFlags = stageFlags_; @@ -13318,15 +14259,14 @@ namespace vk PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); } PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineLayoutCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) ); return *this; } - PipelineLayoutCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13429,6 +14369,34 @@ namespace vk }; }; + struct SharedPresentSurfaceCapabilitiesKHR + { + operator const VkSharedPresentSurfaceCapabilitiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); + } + + bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + ImageUsageFlags sharedPresentSupportedUsageFlags; + }; + static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); + enum class ImageCreateFlagBits { eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, @@ -13475,15 +14443,14 @@ namespace vk PhysicalDeviceImageFormatInfo2KHR( VkPhysicalDeviceImageFormatInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) ); } PhysicalDeviceImageFormatInfo2KHR& operator=( VkPhysicalDeviceImageFormatInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceImageFormatInfo2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) ); return *this; } - PhysicalDeviceImageFormatInfo2KHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13598,15 +14565,14 @@ namespace vk ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) ); + memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); } ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ComputePipelineCreateInfo) ); + memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) ); return *this; } - ComputePipelineCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13721,15 +14687,14 @@ namespace vk PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); } PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineColorBlendAttachmentState) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) ); return *this; } - PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ ) { blendEnable = blendEnable_; @@ -13827,15 +14792,14 @@ namespace vk PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); } PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineColorBlendStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) ); return *this; } - PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -13950,15 +14914,14 @@ namespace vk FenceCreateInfo( VkFenceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(FenceCreateInfo) ); + memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); } FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(FenceCreateInfo) ); + memcpy( this, &rhs, sizeof( FenceCreateInfo ) ); return *this; } - FenceCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14014,7 +14977,8 @@ namespace vk eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, - eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR + eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, + eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT }; using FormatFeatureFlags = Flags; @@ -14033,7 +14997,7 @@ namespace vk { enum { - allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eTransferSrcKHR) | VkFlags(FormatFeatureFlagBits::eTransferDstKHR) + allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eTransferSrcKHR) | VkFlags(FormatFeatureFlagBits::eTransferDstKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) }; }; @@ -14221,15 +15185,14 @@ namespace vk CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); } CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferInheritanceInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) ); return *this; } - CommandBufferInheritanceInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14320,15 +15283,14 @@ namespace vk CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); } CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandBufferBeginInfo) ); + memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) ); return *this; } - CommandBufferBeginInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14389,15 +15351,14 @@ namespace vk QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); } QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(QueryPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) ); return *this; } - QueryPoolCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14499,15 +15460,14 @@ namespace vk ImageSubresource( VkImageSubresource const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresource) ); + memcpy( this, &rhs, sizeof( ImageSubresource ) ); } ImageSubresource& operator=( VkImageSubresource const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresource) ); + memcpy( this, &rhs, sizeof( ImageSubresource ) ); return *this; } - ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ ) { aspectMask = aspectMask_; @@ -14561,15 +15521,14 @@ namespace vk ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresourceLayers) ); + memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); } ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresourceLayers) ); + memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) ); return *this; } - ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ ) { aspectMask = aspectMask_; @@ -14632,15 +15591,14 @@ namespace vk ImageSubresourceRange( VkImageSubresourceRange const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresourceRange) ); + memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); } ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs ) { - memcpy( this, &rhs, sizeof(ImageSubresourceRange) ); + memcpy( this, &rhs, sizeof( ImageSubresourceRange ) ); return *this; } - ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ ) { aspectMask = aspectMask_; @@ -14716,15 +15674,14 @@ namespace vk ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(ImageMemoryBarrier) ); + memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); } ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs ) { - memcpy( this, &rhs, sizeof(ImageMemoryBarrier) ); + memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) ); return *this; } - ImageMemoryBarrier& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14835,15 +15792,14 @@ namespace vk ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ImageViewCreateInfo) ); + memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); } ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ImageViewCreateInfo) ); + memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) ); return *this; } - ImageViewCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -14935,15 +15891,14 @@ namespace vk ImageCopy( VkImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof(ImageCopy) ); + memcpy( this, &rhs, sizeof( ImageCopy ) ); } ImageCopy& operator=( VkImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof(ImageCopy) ); + memcpy( this, &rhs, sizeof( ImageCopy ) ); return *this; } - ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) { srcSubresource = srcSubresource_; @@ -15013,15 +15968,14 @@ namespace vk ImageBlit( VkImageBlit const & rhs ) { - memcpy( this, &rhs, sizeof(ImageBlit) ); + memcpy( this, &rhs, sizeof( ImageBlit ) ); } ImageBlit& operator=( VkImageBlit const & rhs ) { - memcpy( this, &rhs, sizeof(ImageBlit) ); + memcpy( this, &rhs, sizeof( ImageBlit ) ); return *this; } - ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) { srcSubresource = srcSubresource_; @@ -15085,15 +16039,14 @@ namespace vk BufferImageCopy( VkBufferImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof(BufferImageCopy) ); + memcpy( this, &rhs, sizeof( BufferImageCopy ) ); } BufferImageCopy& operator=( VkBufferImageCopy const & rhs ) { - memcpy( this, &rhs, sizeof(BufferImageCopy) ); + memcpy( this, &rhs, sizeof( BufferImageCopy ) ); return *this; } - BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ ) { bufferOffset = bufferOffset_; @@ -15172,15 +16125,14 @@ namespace vk ImageResolve( VkImageResolve const & rhs ) { - memcpy( this, &rhs, sizeof(ImageResolve) ); + memcpy( this, &rhs, sizeof( ImageResolve ) ); } ImageResolve& operator=( VkImageResolve const & rhs ) { - memcpy( this, &rhs, sizeof(ImageResolve) ); + memcpy( this, &rhs, sizeof( ImageResolve ) ); return *this; } - ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ ) { srcSubresource = srcSubresource_; @@ -15249,15 +16201,14 @@ namespace vk ClearAttachment( VkClearAttachment const & rhs ) { - memcpy( this, &rhs, sizeof(ClearAttachment) ); + memcpy( this, &rhs, sizeof( ClearAttachment ) ); } ClearAttachment& operator=( VkClearAttachment const & rhs ) { - memcpy( this, &rhs, sizeof(ClearAttachment) ); + memcpy( this, &rhs, sizeof( ClearAttachment ) ); return *this; } - ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ ) { aspectMask = aspectMask_; @@ -15396,6 +16347,34 @@ namespace vk }; static_assert( sizeof( SparseImageFormatProperties2KHR ) == sizeof( VkSparseImageFormatProperties2KHR ), "struct and wrapper have different size!" ); + struct SparseImageMemoryRequirements2KHR + { + operator const VkSparseImageMemoryRequirements2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SparseImageMemoryRequirements2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memoryRequirements == rhs.memoryRequirements ); + } + + bool operator!=( SparseImageMemoryRequirements2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + SparseImageMemoryRequirements memoryRequirements; + }; + static_assert( sizeof( SparseImageMemoryRequirements2KHR ) == sizeof( VkSparseImageMemoryRequirements2KHR ), "struct and wrapper have different size!" ); + enum class SparseMemoryBindFlagBits { eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT @@ -15434,15 +16413,14 @@ namespace vk SparseMemoryBind( VkSparseMemoryBind const & rhs ) { - memcpy( this, &rhs, sizeof(SparseMemoryBind) ); + memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); } SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs ) { - memcpy( this, &rhs, sizeof(SparseMemoryBind) ); + memcpy( this, &rhs, sizeof( SparseMemoryBind ) ); return *this; } - SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ ) { resourceOffset = resourceOffset_; @@ -15514,15 +16492,14 @@ namespace vk SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageMemoryBind) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); } SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageMemoryBind) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) ); return *this; } - SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ ) { subresource = subresource_; @@ -15599,15 +16576,14 @@ namespace vk SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); } SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseBufferMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) ); return *this; } - SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ ) { buffer = buffer_; @@ -15660,15 +16636,14 @@ namespace vk SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); } SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageOpaqueMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) ); return *this; } - SparseImageOpaqueMemoryBindInfo& setImage( Image image_ ) { image = image_; @@ -15721,15 +16696,14 @@ namespace vk SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); } SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SparseImageMemoryBindInfo) ); + memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) ); return *this; } - SparseImageMemoryBindInfo& setImage( Image image_ ) { image = image_; @@ -15791,15 +16765,14 @@ namespace vk BindSparseInfo( VkBindSparseInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BindSparseInfo) ); + memcpy( this, &rhs, sizeof( BindSparseInfo ) ); } BindSparseInfo& operator=( VkBindSparseInfo const & rhs ) { - memcpy( this, &rhs, sizeof(BindSparseInfo) ); + memcpy( this, &rhs, sizeof( BindSparseInfo ) ); return *this; } - BindSparseInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -15990,15 +16963,14 @@ namespace vk CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); } CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(CommandPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) ); return *this; } - CommandPoolCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -16178,15 +17150,14 @@ namespace vk ImageCreateInfo( VkImageCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ImageCreateInfo) ); + memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); } ImageCreateInfo& operator=( VkImageCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(ImageCreateInfo) ); + memcpy( this, &rhs, sizeof( ImageCreateInfo ) ); return *this; } - ImageCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -16338,15 +17309,14 @@ namespace vk PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); } PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineMultisampleStateCreateInfo) ); + memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) ); return *this; } - PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -16460,15 +17430,14 @@ namespace vk GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) ); + memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); } GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(GraphicsPipelineCreateInfo) ); + memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) ); return *this; } - GraphicsPipelineCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -16974,15 +17943,14 @@ namespace vk PhysicalDeviceSparseImageFormatInfo2KHR( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceSparseImageFormatInfo2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) ); } PhysicalDeviceSparseImageFormatInfo2KHR& operator=( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceSparseImageFormatInfo2KHR) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) ); return *this; } - PhysicalDeviceSparseImageFormatInfo2KHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -17095,15 +18063,14 @@ namespace vk AttachmentDescription( VkAttachmentDescription const & rhs ) { - memcpy( this, &rhs, sizeof(AttachmentDescription) ); + memcpy( this, &rhs, sizeof( AttachmentDescription ) ); } AttachmentDescription& operator=( VkAttachmentDescription const & rhs ) { - memcpy( this, &rhs, sizeof(AttachmentDescription) ); + memcpy( this, &rhs, sizeof( AttachmentDescription ) ); return *this; } - AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ ) { flags = flags_; @@ -17259,15 +18226,14 @@ namespace vk DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); } DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorPoolCreateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) ); return *this; } - DescriptorPoolCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -17372,15 +18338,14 @@ namespace vk SubpassDependency( VkSubpassDependency const & rhs ) { - memcpy( this, &rhs, sizeof(SubpassDependency) ); + memcpy( this, &rhs, sizeof( SubpassDependency ) ); } SubpassDependency& operator=( VkSubpassDependency const & rhs ) { - memcpy( this, &rhs, sizeof(SubpassDependency) ); + memcpy( this, &rhs, sizeof( SubpassDependency ) ); return *this; } - SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ ) { srcSubpass = srcSubpass_; @@ -17459,7 +18424,9 @@ namespace vk eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR, eMailbox = VK_PRESENT_MODE_MAILBOX_KHR, eFifo = VK_PRESENT_MODE_FIFO_KHR, - eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR + eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR, + eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, + eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR }; enum class ColorSpaceKHR @@ -17503,6 +18470,34 @@ namespace vk }; static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); + struct SurfaceFormat2KHR + { + operator const VkSurfaceFormat2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SurfaceFormat2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( surfaceFormat == rhs.surfaceFormat ); + } + + bool operator!=( SurfaceFormat2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + SurfaceFormatKHR surfaceFormat; + }; + static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); + enum class DisplayPlaneAlphaFlagBitsKHR { eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, @@ -17680,15 +18675,14 @@ namespace vk DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); } DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(DisplaySurfaceCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) ); return *this; } - DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -17822,6 +18816,34 @@ namespace vk }; static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" ); + struct SurfaceCapabilities2KHR + { + operator const VkSurfaceCapabilities2KHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SurfaceCapabilities2KHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( surfaceCapabilities == rhs.surfaceCapabilities ); + } + + bool operator!=( SurfaceCapabilities2KHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + SurfaceCapabilitiesKHR surfaceCapabilities; + }; + static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" ); + enum class DebugReportFlagBitsEXT { eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT, @@ -17864,15 +18886,14 @@ namespace vk DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); } DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugReportCallbackCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) ); return *this; } - DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -17957,12 +18978,12 @@ namespace vk eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, + eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, - eDescriptorUpdateTemplateKhrKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT + eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT }; struct DebugMarkerObjectNameInfoEXT @@ -17978,15 +18999,14 @@ namespace vk DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); } DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerObjectNameInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) ); return *this; } - DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18056,15 +19076,14 @@ namespace vk DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); } DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DebugMarkerObjectTagInfoEXT) ); + memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) ); return *this; } - DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18135,12 +19154,6 @@ namespace vk }; static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" ); - enum class DebugReportErrorEXT - { - eNone = VK_DEBUG_REPORT_ERROR_NONE_EXT, - eCallbackRef = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT - }; - enum class RasterizationOrderAMD { eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD, @@ -18158,15 +19171,14 @@ namespace vk PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) ); + memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); } PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineRasterizationStateRasterizationOrderAMD) ); + memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) ); return *this; } - PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18244,15 +19256,14 @@ namespace vk ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) ); + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); } ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoNV) ); + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) ); return *this; } - ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18302,15 +19313,14 @@ namespace vk ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) ); + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); } ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoNV) ); + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) ); return *this; } - ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18362,15 +19372,14 @@ namespace vk ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); } ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoNV) ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) ); return *this; } - ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18474,7 +19483,8 @@ namespace vk enum class ValidationCheckEXT { - eAll = VK_VALIDATION_CHECK_ALL_EXT + eAll = VK_VALIDATION_CHECK_ALL_EXT, + eShaders = VK_VALIDATION_CHECK_SHADERS_EXT }; struct ValidationFlagsEXT @@ -18489,15 +19499,14 @@ namespace vk ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) { - memcpy( this, &rhs, sizeof(ValidationFlagsEXT) ); + memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); } ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs ) { - memcpy( this, &rhs, sizeof(ValidationFlagsEXT) ); + memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) ); return *this; } - ValidationFlagsEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18600,19 +19609,19 @@ namespace vk enum class IndirectCommandsTokenTypeNVX { - eVkIndirectCommandsTokenPipeline = VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX, - eVkIndirectCommandsTokenDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX, - eVkIndirectCommandsTokenIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX, - eVkIndirectCommandsTokenVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX, - eVkIndirectCommandsTokenPushConstant = VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX, - eVkIndirectCommandsTokenDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX, - eVkIndirectCommandsTokenDraw = VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX, - eVkIndirectCommandsTokenDispatch = VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX + ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX, + eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX, + eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX, + eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX, + ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX, + eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX, + eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX, + eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX }; struct IndirectCommandsTokenNVX { - IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenPipeline, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0 ) + IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0 ) : tokenType( tokenType_ ) , buffer( buffer_ ) , offset( offset_ ) @@ -18621,15 +19630,14 @@ namespace vk IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsTokenNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); } IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsTokenNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) ); return *this; } - IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) { tokenType = tokenType_; @@ -18673,7 +19681,7 @@ namespace vk struct IndirectCommandsLayoutTokenNVX { - IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenPipeline, uint32_t bindingUnit_ = 0, uint32_t dynamicCount_ = 0, uint32_t divisor_ = 0 ) + IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, uint32_t bindingUnit_ = 0, uint32_t dynamicCount_ = 0, uint32_t divisor_ = 0 ) : tokenType( tokenType_ ) , bindingUnit( bindingUnit_ ) , dynamicCount( dynamicCount_ ) @@ -18683,15 +19691,14 @@ namespace vk IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsLayoutTokenNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); } IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsLayoutTokenNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) ); return *this; } - IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ ) { tokenType = tokenType_; @@ -18755,15 +19762,14 @@ namespace vk IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsLayoutCreateInfoNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); } IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(IndirectCommandsLayoutCreateInfoNVX) ); + memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) ); return *this; } - IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18828,11 +19834,11 @@ namespace vk enum class ObjectEntryTypeNVX { - eVkObjectEntryDescriptorSet = VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX, - eVkObjectEntryPipeline = VK_OBJECT_ENTRY_PIPELINE_NVX, - eVkObjectEntryIndexBuffer = VK_OBJECT_ENTRY_INDEX_BUFFER_NVX, - eVkObjectEntryVertexBuffer = VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX, - eVkObjectEntryPushConstant = VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX + eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX, + ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX, + eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX, + eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX, + ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX }; struct ObjectTableCreateInfoNVX @@ -18854,15 +19860,14 @@ namespace vk ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableCreateInfoNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); } ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableCreateInfoNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) ); return *this; } - ObjectTableCreateInfoNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -18967,7 +19972,7 @@ namespace vk struct ObjectTableEntryNVX { - ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() ) + ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() ) : type( type_ ) , flags( flags_ ) { @@ -18975,15 +19980,14 @@ namespace vk ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); } ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) ); return *this; } - ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19019,7 +20023,7 @@ namespace vk struct ObjectTablePipelineEntryNVX { - ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Pipeline pipeline_ = Pipeline() ) + ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Pipeline pipeline_ = Pipeline() ) : type( type_ ) , flags( flags_ ) , pipeline( pipeline_ ) @@ -19028,15 +20032,14 @@ namespace vk ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTablePipelineEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); } ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTablePipelineEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) ); return *this; } - ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19080,7 +20083,7 @@ namespace vk struct ObjectTableDescriptorSetEntryNVX { - ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), DescriptorSet descriptorSet_ = DescriptorSet() ) + ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), DescriptorSet descriptorSet_ = DescriptorSet() ) : type( type_ ) , flags( flags_ ) , pipelineLayout( pipelineLayout_ ) @@ -19090,15 +20093,14 @@ namespace vk ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableDescriptorSetEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); } ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableDescriptorSetEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) ); return *this; } - ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19150,7 +20152,7 @@ namespace vk struct ObjectTableVertexBufferEntryNVX { - ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer() ) + ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer() ) : type( type_ ) , flags( flags_ ) , buffer( buffer_ ) @@ -19159,15 +20161,14 @@ namespace vk ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableVertexBufferEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); } ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableVertexBufferEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) ); return *this; } - ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19211,7 +20212,7 @@ namespace vk struct ObjectTableIndexBufferEntryNVX { - ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer(), IndexType indexType_ = IndexType::eUint16 ) + ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer(), IndexType indexType_ = IndexType::eUint16 ) : type( type_ ) , flags( flags_ ) , buffer( buffer_ ) @@ -19221,15 +20222,14 @@ namespace vk ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableIndexBufferEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); } ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTableIndexBufferEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) ); return *this; } - ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19281,7 +20281,7 @@ namespace vk struct ObjectTablePushConstantEntryNVX { - ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), ShaderStageFlags stageFlags_ = ShaderStageFlags() ) + ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), ShaderStageFlags stageFlags_ = ShaderStageFlags() ) : type( type_ ) , flags( flags_ ) , pipelineLayout( pipelineLayout_ ) @@ -19291,15 +20291,14 @@ namespace vk ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTablePushConstantEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); } ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs ) { - memcpy( this, &rhs, sizeof(ObjectTablePushConstantEntryNVX) ); + memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) ); return *this; } - ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ ) { type = type_; @@ -19387,15 +20386,14 @@ namespace vk DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); } DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(DescriptorSetLayoutCreateInfo) ); + memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) ); return *this; } - DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -19450,82 +20448,81 @@ namespace vk }; static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" ); - enum class ExternalMemoryHandleTypeFlagBitsKHX + enum class ExternalMemoryHandleTypeFlagBitsKHR { - eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX, - eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX, - eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX, - eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHX, - eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHX, - eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHX, - eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHX + eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR, + eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR, + eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR, + eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR }; - using ExternalMemoryHandleTypeFlagsKHX = Flags; + using ExternalMemoryHandleTypeFlagsKHR = Flags; - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHX operator|( ExternalMemoryHandleTypeFlagBitsKHX bit0, ExternalMemoryHandleTypeFlagBitsKHX bit1 ) + VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHR operator|( ExternalMemoryHandleTypeFlagBitsKHR bit0, ExternalMemoryHandleTypeFlagBitsKHR bit1 ) { - return ExternalMemoryHandleTypeFlagsKHX( bit0 ) | bit1; + return ExternalMemoryHandleTypeFlagsKHR( bit0 ) | bit1; } - VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHX operator~( ExternalMemoryHandleTypeFlagBitsKHX bits ) + VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHR operator~( ExternalMemoryHandleTypeFlagBitsKHR bits ) { - return ~( ExternalMemoryHandleTypeFlagsKHX( bits ) ); + return ~( ExternalMemoryHandleTypeFlagsKHR( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Resource) + allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) }; }; - struct PhysicalDeviceExternalImageFormatInfoKHX + struct PhysicalDeviceExternalImageFormatInfoKHR { - PhysicalDeviceExternalImageFormatInfoKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd ) - : sType( StructureType::ePhysicalDeviceExternalImageFormatInfoKHX ) + PhysicalDeviceExternalImageFormatInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::ePhysicalDeviceExternalImageFormatInfoKHR ) , pNext( nullptr ) , handleType( handleType_ ) { } - PhysicalDeviceExternalImageFormatInfoKHX( VkPhysicalDeviceExternalImageFormatInfoKHX const & rhs ) + PhysicalDeviceExternalImageFormatInfoKHR( VkPhysicalDeviceExternalImageFormatInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalImageFormatInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) ); } - PhysicalDeviceExternalImageFormatInfoKHX& operator=( VkPhysicalDeviceExternalImageFormatInfoKHX const & rhs ) + PhysicalDeviceExternalImageFormatInfoKHR& operator=( VkPhysicalDeviceExternalImageFormatInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalImageFormatInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) ); return *this; } - - PhysicalDeviceExternalImageFormatInfoKHX& setPNext( const void* pNext_ ) + PhysicalDeviceExternalImageFormatInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceExternalImageFormatInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ ) + PhysicalDeviceExternalImageFormatInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - operator const VkPhysicalDeviceExternalImageFormatInfoKHX&() const + operator const VkPhysicalDeviceExternalImageFormatInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceExternalImageFormatInfoKHX const& rhs ) const + bool operator==( PhysicalDeviceExternalImageFormatInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); } - bool operator!=( PhysicalDeviceExternalImageFormatInfoKHX const& rhs ) const + bool operator!=( PhysicalDeviceExternalImageFormatInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -19535,14 +20532,14 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagBitsKHX handleType; + ExternalMemoryHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( PhysicalDeviceExternalImageFormatInfoKHX ) == sizeof( VkPhysicalDeviceExternalImageFormatInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) == sizeof( VkPhysicalDeviceExternalImageFormatInfoKHR ), "struct and wrapper have different size!" ); - struct PhysicalDeviceExternalBufferInfoKHX + struct PhysicalDeviceExternalBufferInfoKHR { - PhysicalDeviceExternalBufferInfoKHX( BufferCreateFlags flags_ = BufferCreateFlags(), BufferUsageFlags usage_ = BufferUsageFlags(), ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd ) - : sType( StructureType::ePhysicalDeviceExternalBufferInfoKHX ) + PhysicalDeviceExternalBufferInfoKHR( BufferCreateFlags flags_ = BufferCreateFlags(), BufferUsageFlags usage_ = BufferUsageFlags(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::ePhysicalDeviceExternalBufferInfoKHR ) , pNext( nullptr ) , flags( flags_ ) , usage( usage_ ) @@ -19550,47 +20547,46 @@ namespace vk { } - PhysicalDeviceExternalBufferInfoKHX( VkPhysicalDeviceExternalBufferInfoKHX const & rhs ) + PhysicalDeviceExternalBufferInfoKHR( VkPhysicalDeviceExternalBufferInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalBufferInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHR ) ); } - PhysicalDeviceExternalBufferInfoKHX& operator=( VkPhysicalDeviceExternalBufferInfoKHX const & rhs ) + PhysicalDeviceExternalBufferInfoKHR& operator=( VkPhysicalDeviceExternalBufferInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalBufferInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHR ) ); return *this; } - - PhysicalDeviceExternalBufferInfoKHX& setPNext( const void* pNext_ ) + PhysicalDeviceExternalBufferInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceExternalBufferInfoKHX& setFlags( BufferCreateFlags flags_ ) + PhysicalDeviceExternalBufferInfoKHR& setFlags( BufferCreateFlags flags_ ) { flags = flags_; return *this; } - PhysicalDeviceExternalBufferInfoKHX& setUsage( BufferUsageFlags usage_ ) + PhysicalDeviceExternalBufferInfoKHR& setUsage( BufferUsageFlags usage_ ) { usage = usage_; return *this; } - PhysicalDeviceExternalBufferInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ ) + PhysicalDeviceExternalBufferInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - operator const VkPhysicalDeviceExternalBufferInfoKHX&() const + operator const VkPhysicalDeviceExternalBufferInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceExternalBufferInfoKHX const& rhs ) const + bool operator==( PhysicalDeviceExternalBufferInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -19599,7 +20595,7 @@ namespace vk && ( handleType == rhs.handleType ); } - bool operator!=( PhysicalDeviceExternalBufferInfoKHX const& rhs ) const + bool operator!=( PhysicalDeviceExternalBufferInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -19611,55 +20607,54 @@ namespace vk const void* pNext; BufferCreateFlags flags; BufferUsageFlags usage; - ExternalMemoryHandleTypeFlagBitsKHX handleType; + ExternalMemoryHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( PhysicalDeviceExternalBufferInfoKHX ) == sizeof( VkPhysicalDeviceExternalBufferInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceExternalBufferInfoKHR ) == sizeof( VkPhysicalDeviceExternalBufferInfoKHR ), "struct and wrapper have different size!" ); - struct ExternalMemoryImageCreateInfoKHX + struct ExternalMemoryImageCreateInfoKHR { - ExternalMemoryImageCreateInfoKHX( ExternalMemoryHandleTypeFlagsKHX handleTypes_ = ExternalMemoryHandleTypeFlagsKHX() ) - : sType( StructureType::eExternalMemoryImageCreateInfoKHX ) + ExternalMemoryImageCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) + : sType( StructureType::eExternalMemoryImageCreateInfoKHR ) , pNext( nullptr ) , handleTypes( handleTypes_ ) { } - ExternalMemoryImageCreateInfoKHX( VkExternalMemoryImageCreateInfoKHX const & rhs ) + ExternalMemoryImageCreateInfoKHR( VkExternalMemoryImageCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHR ) ); } - ExternalMemoryImageCreateInfoKHX& operator=( VkExternalMemoryImageCreateInfoKHX const & rhs ) + ExternalMemoryImageCreateInfoKHR& operator=( VkExternalMemoryImageCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryImageCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHR ) ); return *this; } - - ExternalMemoryImageCreateInfoKHX& setPNext( const void* pNext_ ) + ExternalMemoryImageCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExternalMemoryImageCreateInfoKHX& setHandleTypes( ExternalMemoryHandleTypeFlagsKHX handleTypes_ ) + ExternalMemoryImageCreateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ ) { handleTypes = handleTypes_; return *this; } - operator const VkExternalMemoryImageCreateInfoKHX&() const + operator const VkExternalMemoryImageCreateInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalMemoryImageCreateInfoKHX const& rhs ) const + bool operator==( ExternalMemoryImageCreateInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); } - bool operator!=( ExternalMemoryImageCreateInfoKHX const& rhs ) const + bool operator!=( ExternalMemoryImageCreateInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -19669,55 +20664,54 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagsKHX handleTypes; + ExternalMemoryHandleTypeFlagsKHR handleTypes; }; - static_assert( sizeof( ExternalMemoryImageCreateInfoKHX ) == sizeof( VkExternalMemoryImageCreateInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExternalMemoryImageCreateInfoKHR ) == sizeof( VkExternalMemoryImageCreateInfoKHR ), "struct and wrapper have different size!" ); - struct ExternalMemoryBufferCreateInfoKHX + struct ExternalMemoryBufferCreateInfoKHR { - ExternalMemoryBufferCreateInfoKHX( ExternalMemoryHandleTypeFlagsKHX handleTypes_ = ExternalMemoryHandleTypeFlagsKHX() ) - : sType( StructureType::eExternalMemoryBufferCreateInfoKHX ) + ExternalMemoryBufferCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) + : sType( StructureType::eExternalMemoryBufferCreateInfoKHR ) , pNext( nullptr ) , handleTypes( handleTypes_ ) { } - ExternalMemoryBufferCreateInfoKHX( VkExternalMemoryBufferCreateInfoKHX const & rhs ) + ExternalMemoryBufferCreateInfoKHR( VkExternalMemoryBufferCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryBufferCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHR ) ); } - ExternalMemoryBufferCreateInfoKHX& operator=( VkExternalMemoryBufferCreateInfoKHX const & rhs ) + ExternalMemoryBufferCreateInfoKHR& operator=( VkExternalMemoryBufferCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExternalMemoryBufferCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHR ) ); return *this; } - - ExternalMemoryBufferCreateInfoKHX& setPNext( const void* pNext_ ) + ExternalMemoryBufferCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExternalMemoryBufferCreateInfoKHX& setHandleTypes( ExternalMemoryHandleTypeFlagsKHX handleTypes_ ) + ExternalMemoryBufferCreateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ ) { handleTypes = handleTypes_; return *this; } - operator const VkExternalMemoryBufferCreateInfoKHX&() const + operator const VkExternalMemoryBufferCreateInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalMemoryBufferCreateInfoKHX const& rhs ) const + bool operator==( ExternalMemoryBufferCreateInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); } - bool operator!=( ExternalMemoryBufferCreateInfoKHX const& rhs ) const + bool operator!=( ExternalMemoryBufferCreateInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -19727,55 +20721,54 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagsKHX handleTypes; + ExternalMemoryHandleTypeFlagsKHR handleTypes; }; - static_assert( sizeof( ExternalMemoryBufferCreateInfoKHX ) == sizeof( VkExternalMemoryBufferCreateInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExternalMemoryBufferCreateInfoKHR ) == sizeof( VkExternalMemoryBufferCreateInfoKHR ), "struct and wrapper have different size!" ); - struct ExportMemoryAllocateInfoKHX + struct ExportMemoryAllocateInfoKHR { - ExportMemoryAllocateInfoKHX( ExternalMemoryHandleTypeFlagsKHX handleTypes_ = ExternalMemoryHandleTypeFlagsKHX() ) - : sType( StructureType::eExportMemoryAllocateInfoKHX ) + ExportMemoryAllocateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() ) + : sType( StructureType::eExportMemoryAllocateInfoKHR ) , pNext( nullptr ) , handleTypes( handleTypes_ ) { } - ExportMemoryAllocateInfoKHX( VkExportMemoryAllocateInfoKHX const & rhs ) + ExportMemoryAllocateInfoKHR( VkExportMemoryAllocateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHR ) ); } - ExportMemoryAllocateInfoKHX& operator=( VkExportMemoryAllocateInfoKHX const & rhs ) + ExportMemoryAllocateInfoKHR& operator=( VkExportMemoryAllocateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExportMemoryAllocateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHR ) ); return *this; } - - ExportMemoryAllocateInfoKHX& setPNext( const void* pNext_ ) + ExportMemoryAllocateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExportMemoryAllocateInfoKHX& setHandleTypes( ExternalMemoryHandleTypeFlagsKHX handleTypes_ ) + ExportMemoryAllocateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ ) { handleTypes = handleTypes_; return *this; } - operator const VkExportMemoryAllocateInfoKHX&() const + operator const VkExportMemoryAllocateInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExportMemoryAllocateInfoKHX const& rhs ) const + bool operator==( ExportMemoryAllocateInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); } - bool operator!=( ExportMemoryAllocateInfoKHX const& rhs ) const + bool operator!=( ExportMemoryAllocateInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -19785,64 +20778,71 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagsKHX handleTypes; + ExternalMemoryHandleTypeFlagsKHR handleTypes; }; - static_assert( sizeof( ExportMemoryAllocateInfoKHX ) == sizeof( VkExportMemoryAllocateInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExportMemoryAllocateInfoKHR ) == sizeof( VkExportMemoryAllocateInfoKHR ), "struct and wrapper have different size!" ); -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct ImportMemoryWin32HandleInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportMemoryWin32HandleInfoKHR { - ImportMemoryWin32HandleInfoKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd, HANDLE handle_ = 0 ) - : sType( StructureType::eImportMemoryWin32HandleInfoKHX ) + ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eImportMemoryWin32HandleInfoKHR ) , pNext( nullptr ) , handleType( handleType_ ) , handle( handle_ ) + , name( name_ ) { } - ImportMemoryWin32HandleInfoKHX( VkImportMemoryWin32HandleInfoKHX const & rhs ) + ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) ); } - ImportMemoryWin32HandleInfoKHX& operator=( VkImportMemoryWin32HandleInfoKHX const & rhs ) + ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) ); return *this; } - - ImportMemoryWin32HandleInfoKHX& setPNext( const void* pNext_ ) + ImportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ImportMemoryWin32HandleInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ ) + ImportMemoryWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - ImportMemoryWin32HandleInfoKHX& setHandle( HANDLE handle_ ) + ImportMemoryWin32HandleInfoKHR& setHandle( HANDLE handle_ ) { handle = handle_; return *this; } - operator const VkImportMemoryWin32HandleInfoKHX&() const + ImportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ ) { - return *reinterpret_cast(this); + name = name_; + return *this; } - bool operator==( ImportMemoryWin32HandleInfoKHX const& rhs ) const + operator const VkImportMemoryWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ); + && ( handle == rhs.handle ) + && ( name == rhs.name ); } - bool operator!=( ImportMemoryWin32HandleInfoKHX const& rhs ) const + bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -19852,57 +20852,125 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagBitsKHX handleType; + ExternalMemoryHandleTypeFlagBitsKHR handleType; HANDLE handle; + LPCWSTR name; }; - static_assert( sizeof( ImportMemoryWin32HandleInfoKHX ) == sizeof( VkImportMemoryWin32HandleInfoKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ + static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - struct ImportMemoryFdInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct MemoryGetWin32HandleInfoKHR { - ImportMemoryFdInfoKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType_ = ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd, int fd_ = 0 ) - : sType( StructureType::eImportMemoryFdInfoKHX ) + MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eMemoryGetWin32HandleInfoKHR ) + , pNext( nullptr ) + , memory( memory_ ) + , handleType( handleType_ ) + { + } + + MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) ); + } + + MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) ); + return *this; + } + MemoryGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryGetWin32HandleInfoKHR& setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + MemoryGetWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkMemoryGetWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memory == rhs.memory ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + DeviceMemory memory; + ExternalMemoryHandleTypeFlagBitsKHR handleType; + }; + static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct ImportMemoryFdInfoKHR + { + ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) + : sType( StructureType::eImportMemoryFdInfoKHR ) , pNext( nullptr ) , handleType( handleType_ ) , fd( fd_ ) { } - ImportMemoryFdInfoKHX( VkImportMemoryFdInfoKHX const & rhs ) + ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryFdInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) ); } - ImportMemoryFdInfoKHX& operator=( VkImportMemoryFdInfoKHX const & rhs ) + ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ImportMemoryFdInfoKHX) ); + memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) ); return *this; } - - ImportMemoryFdInfoKHX& setPNext( const void* pNext_ ) + ImportMemoryFdInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ImportMemoryFdInfoKHX& setHandleType( ExternalMemoryHandleTypeFlagBitsKHX handleType_ ) + ImportMemoryFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - ImportMemoryFdInfoKHX& setFd( int fd_ ) + ImportMemoryFdInfoKHR& setFd( int fd_ ) { fd = fd_; return *this; } - operator const VkImportMemoryFdInfoKHX&() const + operator const VkImportMemoryFdInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ImportMemoryFdInfoKHX const& rhs ) const + bool operator==( ImportMemoryFdInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -19910,7 +20978,7 @@ namespace vk && ( fd == rhs.fd ); } - bool operator!=( ImportMemoryFdInfoKHX const& rhs ) const + bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -19920,78 +20988,144 @@ namespace vk public: const void* pNext; - ExternalMemoryHandleTypeFlagBitsKHX handleType; + ExternalMemoryHandleTypeFlagBitsKHR handleType; int fd; }; - static_assert( sizeof( ImportMemoryFdInfoKHX ) == sizeof( VkImportMemoryFdInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" ); - enum class ExternalMemoryFeatureFlagBitsKHX + struct MemoryGetFdInfoKHR { - eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX, - eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX, - eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX + MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eMemoryGetFdInfoKHR ) + , pNext( nullptr ) + , memory( memory_ ) + , handleType( handleType_ ) + { + } + + MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) ); + } + + MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) ); + return *this; + } + MemoryGetFdInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + MemoryGetFdInfoKHR& setMemory( DeviceMemory memory_ ) + { + memory = memory_; + return *this; + } + + MemoryGetFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkMemoryGetFdInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( MemoryGetFdInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( memory == rhs.memory ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( MemoryGetFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + DeviceMemory memory; + ExternalMemoryHandleTypeFlagBitsKHR handleType; + }; + static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); + + enum class ExternalMemoryFeatureFlagBitsKHR + { + eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR, + eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR, + eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR }; - using ExternalMemoryFeatureFlagsKHX = Flags; + using ExternalMemoryFeatureFlagsKHR = Flags; - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHX operator|( ExternalMemoryFeatureFlagBitsKHX bit0, ExternalMemoryFeatureFlagBitsKHX bit1 ) + VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHR operator|( ExternalMemoryFeatureFlagBitsKHR bit0, ExternalMemoryFeatureFlagBitsKHR bit1 ) { - return ExternalMemoryFeatureFlagsKHX( bit0 ) | bit1; + return ExternalMemoryFeatureFlagsKHR( bit0 ) | bit1; } - VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHX operator~( ExternalMemoryFeatureFlagBitsKHX bits ) + VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHR operator~( ExternalMemoryFeatureFlagBitsKHR bits ) { - return ~( ExternalMemoryFeatureFlagsKHX( bits ) ); + return ~( ExternalMemoryFeatureFlagsKHR( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(ExternalMemoryFeatureFlagBitsKHX::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsKHX::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsKHX::eImportable) + allFlags = VkFlags(ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsKHR::eImportable) }; }; - struct ExternalMemoryPropertiesKHX + struct ExternalMemoryPropertiesKHR { - operator const VkExternalMemoryPropertiesKHX&() const + operator const VkExternalMemoryPropertiesKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalMemoryPropertiesKHX const& rhs ) const + bool operator==( ExternalMemoryPropertiesKHR const& rhs ) const { return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); } - bool operator!=( ExternalMemoryPropertiesKHX const& rhs ) const + bool operator!=( ExternalMemoryPropertiesKHR const& rhs ) const { return !operator==( rhs ); } - ExternalMemoryFeatureFlagsKHX externalMemoryFeatures; - ExternalMemoryHandleTypeFlagsKHX exportFromImportedHandleTypes; - ExternalMemoryHandleTypeFlagsKHX compatibleHandleTypes; + ExternalMemoryFeatureFlagsKHR externalMemoryFeatures; + ExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes; + ExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes; }; - static_assert( sizeof( ExternalMemoryPropertiesKHX ) == sizeof( VkExternalMemoryPropertiesKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExternalMemoryPropertiesKHR ) == sizeof( VkExternalMemoryPropertiesKHR ), "struct and wrapper have different size!" ); - struct ExternalImageFormatPropertiesKHX + struct ExternalImageFormatPropertiesKHR { - operator const VkExternalImageFormatPropertiesKHX&() const + operator const VkExternalImageFormatPropertiesKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalImageFormatPropertiesKHX const& rhs ) const + bool operator==( ExternalImageFormatPropertiesKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryProperties == rhs.externalMemoryProperties ); } - bool operator!=( ExternalImageFormatPropertiesKHX const& rhs ) const + bool operator!=( ExternalImageFormatPropertiesKHR const& rhs ) const { return !operator==( rhs ); } @@ -20001,25 +21135,25 @@ namespace vk public: void* pNext; - ExternalMemoryPropertiesKHX externalMemoryProperties; + ExternalMemoryPropertiesKHR externalMemoryProperties; }; - static_assert( sizeof( ExternalImageFormatPropertiesKHX ) == sizeof( VkExternalImageFormatPropertiesKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExternalImageFormatPropertiesKHR ) == sizeof( VkExternalImageFormatPropertiesKHR ), "struct and wrapper have different size!" ); - struct ExternalBufferPropertiesKHX + struct ExternalBufferPropertiesKHR { - operator const VkExternalBufferPropertiesKHX&() const + operator const VkExternalBufferPropertiesKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalBufferPropertiesKHX const& rhs ) const + bool operator==( ExternalBufferPropertiesKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryProperties == rhs.externalMemoryProperties ); } - bool operator!=( ExternalBufferPropertiesKHX const& rhs ) const + bool operator!=( ExternalBufferPropertiesKHR const& rhs ) const { return !operator==( rhs ); } @@ -20029,84 +21163,83 @@ namespace vk public: void* pNext; - ExternalMemoryPropertiesKHX externalMemoryProperties; + ExternalMemoryPropertiesKHR externalMemoryProperties; }; - static_assert( sizeof( ExternalBufferPropertiesKHX ) == sizeof( VkExternalBufferPropertiesKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExternalBufferPropertiesKHR ) == sizeof( VkExternalBufferPropertiesKHR ), "struct and wrapper have different size!" ); - enum class ExternalSemaphoreHandleTypeFlagBitsKHX + enum class ExternalSemaphoreHandleTypeFlagBitsKHR { - eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHX, - eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHX, - eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHX, - eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHX, - eFenceFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FENCE_FD_BIT_KHX + eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR, + eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR }; - using ExternalSemaphoreHandleTypeFlagsKHX = Flags; + using ExternalSemaphoreHandleTypeFlagsKHR = Flags; - VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHX operator|( ExternalSemaphoreHandleTypeFlagBitsKHX bit0, ExternalSemaphoreHandleTypeFlagBitsKHX bit1 ) + VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHR operator|( ExternalSemaphoreHandleTypeFlagBitsKHR bit0, ExternalSemaphoreHandleTypeFlagBitsKHR bit1 ) { - return ExternalSemaphoreHandleTypeFlagsKHX( bit0 ) | bit1; + return ExternalSemaphoreHandleTypeFlagsKHR( bit0 ) | bit1; } - VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHX operator~( ExternalSemaphoreHandleTypeFlagBitsKHX bits ) + VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHR operator~( ExternalSemaphoreHandleTypeFlagBitsKHR bits ) { - return ~( ExternalSemaphoreHandleTypeFlagsKHX( bits ) ); + return ~( ExternalSemaphoreHandleTypeFlagsKHR( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHX::eFenceFd) + allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd) }; }; - struct PhysicalDeviceExternalSemaphoreInfoKHX + struct PhysicalDeviceExternalSemaphoreInfoKHR { - PhysicalDeviceExternalSemaphoreInfoKHX( ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd ) - : sType( StructureType::ePhysicalDeviceExternalSemaphoreInfoKHX ) + PhysicalDeviceExternalSemaphoreInfoKHR( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR ) , pNext( nullptr ) , handleType( handleType_ ) { } - PhysicalDeviceExternalSemaphoreInfoKHX( VkPhysicalDeviceExternalSemaphoreInfoKHX const & rhs ) + PhysicalDeviceExternalSemaphoreInfoKHR( VkPhysicalDeviceExternalSemaphoreInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalSemaphoreInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) ); } - PhysicalDeviceExternalSemaphoreInfoKHX& operator=( VkPhysicalDeviceExternalSemaphoreInfoKHX const & rhs ) + PhysicalDeviceExternalSemaphoreInfoKHR& operator=( VkPhysicalDeviceExternalSemaphoreInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(PhysicalDeviceExternalSemaphoreInfoKHX) ); + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) ); return *this; } - - PhysicalDeviceExternalSemaphoreInfoKHX& setPNext( const void* pNext_ ) + PhysicalDeviceExternalSemaphoreInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - PhysicalDeviceExternalSemaphoreInfoKHX& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ ) + PhysicalDeviceExternalSemaphoreInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - operator const VkPhysicalDeviceExternalSemaphoreInfoKHX&() const + operator const VkPhysicalDeviceExternalSemaphoreInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( PhysicalDeviceExternalSemaphoreInfoKHX const& rhs ) const + bool operator==( PhysicalDeviceExternalSemaphoreInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); } - bool operator!=( PhysicalDeviceExternalSemaphoreInfoKHX const& rhs ) const + bool operator!=( PhysicalDeviceExternalSemaphoreInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20116,55 +21249,54 @@ namespace vk public: const void* pNext; - ExternalSemaphoreHandleTypeFlagBitsKHX handleType; + ExternalSemaphoreHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfoKHX ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfoKHR ), "struct and wrapper have different size!" ); - struct ExportSemaphoreCreateInfoKHX + struct ExportSemaphoreCreateInfoKHR { - ExportSemaphoreCreateInfoKHX( ExternalSemaphoreHandleTypeFlagsKHX handleTypes_ = ExternalSemaphoreHandleTypeFlagsKHX() ) - : sType( StructureType::eExportSemaphoreCreateInfoKHX ) + ExportSemaphoreCreateInfoKHR( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ = ExternalSemaphoreHandleTypeFlagsKHR() ) + : sType( StructureType::eExportSemaphoreCreateInfoKHR ) , pNext( nullptr ) , handleTypes( handleTypes_ ) { } - ExportSemaphoreCreateInfoKHX( VkExportSemaphoreCreateInfoKHX const & rhs ) + ExportSemaphoreCreateInfoKHR( VkExportSemaphoreCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExportSemaphoreCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHR ) ); } - ExportSemaphoreCreateInfoKHX& operator=( VkExportSemaphoreCreateInfoKHX const & rhs ) + ExportSemaphoreCreateInfoKHR& operator=( VkExportSemaphoreCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ExportSemaphoreCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHR ) ); return *this; } - - ExportSemaphoreCreateInfoKHX& setPNext( const void* pNext_ ) + ExportSemaphoreCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ExportSemaphoreCreateInfoKHX& setHandleTypes( ExternalSemaphoreHandleTypeFlagsKHX handleTypes_ ) + ExportSemaphoreCreateInfoKHR& setHandleTypes( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ ) { handleTypes = handleTypes_; return *this; } - operator const VkExportSemaphoreCreateInfoKHX&() const + operator const VkExportSemaphoreCreateInfoKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExportSemaphoreCreateInfoKHX const& rhs ) const + bool operator==( ExportSemaphoreCreateInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); } - bool operator!=( ExportSemaphoreCreateInfoKHX const& rhs ) const + bool operator!=( ExportSemaphoreCreateInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20174,72 +21306,63 @@ namespace vk public: const void* pNext; - ExternalSemaphoreHandleTypeFlagsKHX handleTypes; + ExternalSemaphoreHandleTypeFlagsKHR handleTypes; }; - static_assert( sizeof( ExportSemaphoreCreateInfoKHX ) == sizeof( VkExportSemaphoreCreateInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExportSemaphoreCreateInfoKHR ) == sizeof( VkExportSemaphoreCreateInfoKHR ), "struct and wrapper have different size!" ); -#ifdef VK_USE_PLATFORM_WIN32_KHX - struct ImportSemaphoreWin32HandleInfoKHX +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct SemaphoreGetWin32HandleInfoKHR { - ImportSemaphoreWin32HandleInfoKHX( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagsKHX handleType_ = ExternalSemaphoreHandleTypeFlagsKHX(), HANDLE handle_ = 0 ) - : sType( StructureType::eImportSemaphoreWin32HandleInfoKHX ) + SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eSemaphoreGetWin32HandleInfoKHR ) , pNext( nullptr ) , semaphore( semaphore_ ) , handleType( handleType_ ) - , handle( handle_ ) { } - ImportSemaphoreWin32HandleInfoKHX( VkImportSemaphoreWin32HandleInfoKHX const & rhs ) + SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ImportSemaphoreWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) ); } - ImportSemaphoreWin32HandleInfoKHX& operator=( VkImportSemaphoreWin32HandleInfoKHX const & rhs ) + SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ImportSemaphoreWin32HandleInfoKHX) ); + memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) ); return *this; } - - ImportSemaphoreWin32HandleInfoKHX& setPNext( const void* pNext_ ) + SemaphoreGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ImportSemaphoreWin32HandleInfoKHX& setSemaphore( Semaphore semaphore_ ) + SemaphoreGetWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ ) { semaphore = semaphore_; return *this; } - ImportSemaphoreWin32HandleInfoKHX& setHandleType( ExternalSemaphoreHandleTypeFlagsKHX handleType_ ) + SemaphoreGetWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - ImportSemaphoreWin32HandleInfoKHX& setHandle( HANDLE handle_ ) + operator const VkSemaphoreGetWin32HandleInfoKHR&() const { - handle = handle_; - return *this; + return *reinterpret_cast(this); } - operator const VkImportSemaphoreWin32HandleInfoKHX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportSemaphoreWin32HandleInfoKHX const& rhs ) const + bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) - && ( handleType == rhs.handleType ) - && ( handle == rhs.handle ); + && ( handleType == rhs.handleType ); } - bool operator!=( ImportSemaphoreWin32HandleInfoKHX const& rhs ) const + bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20250,73 +21373,63 @@ namespace vk public: const void* pNext; Semaphore semaphore; - ExternalSemaphoreHandleTypeFlagsKHX handleType; - HANDLE handle; + ExternalSemaphoreHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHX ) == sizeof( VkImportSemaphoreWin32HandleInfoKHX ), "struct and wrapper have different size!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ + static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - struct ImportSemaphoreFdInfoKHX + struct SemaphoreGetFdInfoKHR { - ImportSemaphoreFdInfoKHX( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd, int fd_ = 0 ) - : sType( StructureType::eImportSemaphoreFdInfoKHX ) + SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eSemaphoreGetFdInfoKHR ) , pNext( nullptr ) , semaphore( semaphore_ ) , handleType( handleType_ ) - , fd( fd_ ) { } - ImportSemaphoreFdInfoKHX( VkImportSemaphoreFdInfoKHX const & rhs ) + SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ImportSemaphoreFdInfoKHX) ); + memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) ); } - ImportSemaphoreFdInfoKHX& operator=( VkImportSemaphoreFdInfoKHX const & rhs ) + SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(ImportSemaphoreFdInfoKHX) ); + memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) ); return *this; } - - ImportSemaphoreFdInfoKHX& setPNext( const void* pNext_ ) + SemaphoreGetFdInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; return *this; } - ImportSemaphoreFdInfoKHX& setSemaphore( Semaphore semaphore_ ) + SemaphoreGetFdInfoKHR& setSemaphore( Semaphore semaphore_ ) { semaphore = semaphore_; return *this; } - ImportSemaphoreFdInfoKHX& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHX handleType_ ) + SemaphoreGetFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) { handleType = handleType_; return *this; } - ImportSemaphoreFdInfoKHX& setFd( int fd_ ) + operator const VkSemaphoreGetFdInfoKHR&() const { - fd = fd_; - return *this; + return *reinterpret_cast(this); } - operator const VkImportSemaphoreFdInfoKHX&() const - { - return *reinterpret_cast(this); - } - - bool operator==( ImportSemaphoreFdInfoKHX const& rhs ) const + bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) - && ( handleType == rhs.handleType ) - && ( fd == rhs.fd ); + && ( handleType == rhs.handleType ); } - bool operator!=( ImportSemaphoreFdInfoKHX const& rhs ) const + bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const { return !operator==( rhs ); } @@ -20327,45 +21440,44 @@ namespace vk public: const void* pNext; Semaphore semaphore; - ExternalSemaphoreHandleTypeFlagBitsKHX handleType; - int fd; + ExternalSemaphoreHandleTypeFlagBitsKHR handleType; }; - static_assert( sizeof( ImportSemaphoreFdInfoKHX ) == sizeof( VkImportSemaphoreFdInfoKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" ); - enum class ExternalSemaphoreFeatureFlagBitsKHX + enum class ExternalSemaphoreFeatureFlagBitsKHR { - eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHX, - eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHX + eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR, + eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR }; - using ExternalSemaphoreFeatureFlagsKHX = Flags; + using ExternalSemaphoreFeatureFlagsKHR = Flags; - VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHX operator|( ExternalSemaphoreFeatureFlagBitsKHX bit0, ExternalSemaphoreFeatureFlagBitsKHX bit1 ) + VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHR operator|( ExternalSemaphoreFeatureFlagBitsKHR bit0, ExternalSemaphoreFeatureFlagBitsKHR bit1 ) { - return ExternalSemaphoreFeatureFlagsKHX( bit0 ) | bit1; + return ExternalSemaphoreFeatureFlagsKHR( bit0 ) | bit1; } - VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHX operator~( ExternalSemaphoreFeatureFlagBitsKHX bits ) + VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHR operator~( ExternalSemaphoreFeatureFlagBitsKHR bits ) { - return ~( ExternalSemaphoreFeatureFlagsKHX( bits ) ); + return ~( ExternalSemaphoreFeatureFlagsKHR( bits ) ); } - template <> struct FlagTraits + template <> struct FlagTraits { enum { - allFlags = VkFlags(ExternalSemaphoreFeatureFlagBitsKHX::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBitsKHX::eImportable) + allFlags = VkFlags(ExternalSemaphoreFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBitsKHR::eImportable) }; }; - struct ExternalSemaphorePropertiesKHX + struct ExternalSemaphorePropertiesKHR { - operator const VkExternalSemaphorePropertiesKHX&() const + operator const VkExternalSemaphorePropertiesKHR&() const { - return *reinterpret_cast(this); + return *reinterpret_cast(this); } - bool operator==( ExternalSemaphorePropertiesKHX const& rhs ) const + bool operator==( ExternalSemaphorePropertiesKHR const& rhs ) const { return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) @@ -20374,7 +21486,7 @@ namespace vk && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); } - bool operator!=( ExternalSemaphorePropertiesKHX const& rhs ) const + bool operator!=( ExternalSemaphorePropertiesKHR const& rhs ) const { return !operator==( rhs ); } @@ -20384,15 +21496,757 @@ namespace vk public: void* pNext; - ExternalSemaphoreHandleTypeFlagsKHX exportFromImportedHandleTypes; - ExternalSemaphoreHandleTypeFlagsKHX compatibleHandleTypes; - ExternalSemaphoreFeatureFlagsKHX externalSemaphoreFeatures; + ExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes; + ExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes; + ExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures; }; - static_assert( sizeof( ExternalSemaphorePropertiesKHX ) == sizeof( VkExternalSemaphorePropertiesKHX ), "struct and wrapper have different size!" ); + static_assert( sizeof( ExternalSemaphorePropertiesKHR ) == sizeof( VkExternalSemaphorePropertiesKHR ), "struct and wrapper have different size!" ); + + enum class SemaphoreImportFlagBitsKHR + { + eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR + }; + + using SemaphoreImportFlagsKHR = Flags; + + VULKAN_HPP_INLINE SemaphoreImportFlagsKHR operator|( SemaphoreImportFlagBitsKHR bit0, SemaphoreImportFlagBitsKHR bit1 ) + { + return SemaphoreImportFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE SemaphoreImportFlagsKHR operator~( SemaphoreImportFlagBitsKHR bits ) + { + return ~( SemaphoreImportFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(SemaphoreImportFlagBitsKHR::eTemporary) + }; + }; + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportSemaphoreWin32HandleInfoKHR + { + ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eImportSemaphoreWin32HandleInfoKHR ) + , pNext( nullptr ) + , semaphore( semaphore_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) + { + } + + ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) ); + } + + ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) ); + return *this; + } + ImportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ ) + { + semaphore = semaphore_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setFlags( SemaphoreImportFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setHandle( HANDLE handle_ ) + { + handle = handle_; + return *this; + } + + ImportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkImportSemaphoreWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( semaphore == rhs.semaphore ) + && ( flags == rhs.flags ) + && ( handleType == rhs.handleType ) + && ( handle == rhs.handle ) + && ( name == rhs.name ); + } + + bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Semaphore semaphore; + SemaphoreImportFlagsKHR flags; + ExternalSemaphoreHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; + }; + static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct ImportSemaphoreFdInfoKHR + { + ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) + : sType( StructureType::eImportSemaphoreFdInfoKHR ) + , pNext( nullptr ) + , semaphore( semaphore_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , fd( fd_ ) + { + } + + ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) ); + } + + ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) ); + return *this; + } + ImportSemaphoreFdInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportSemaphoreFdInfoKHR& setSemaphore( Semaphore semaphore_ ) + { + semaphore = semaphore_; + return *this; + } + + ImportSemaphoreFdInfoKHR& setFlags( SemaphoreImportFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + ImportSemaphoreFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportSemaphoreFdInfoKHR& setFd( int fd_ ) + { + fd = fd_; + return *this; + } + + operator const VkImportSemaphoreFdInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( semaphore == rhs.semaphore ) + && ( flags == rhs.flags ) + && ( handleType == rhs.handleType ) + && ( fd == rhs.fd ); + } + + bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Semaphore semaphore; + SemaphoreImportFlagsKHR flags; + ExternalSemaphoreHandleTypeFlagBitsKHR handleType; + int fd; + }; + static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" ); + + enum class ExternalFenceHandleTypeFlagBitsKHR + { + eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR, + eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR, + eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR + }; + + using ExternalFenceHandleTypeFlagsKHR = Flags; + + VULKAN_HPP_INLINE ExternalFenceHandleTypeFlagsKHR operator|( ExternalFenceHandleTypeFlagBitsKHR bit0, ExternalFenceHandleTypeFlagBitsKHR bit1 ) + { + return ExternalFenceHandleTypeFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalFenceHandleTypeFlagsKHR operator~( ExternalFenceHandleTypeFlagBitsKHR bits ) + { + return ~( ExternalFenceHandleTypeFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eSyncFd) + }; + }; + + struct PhysicalDeviceExternalFenceInfoKHR + { + PhysicalDeviceExternalFenceInfoKHR( ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::ePhysicalDeviceExternalFenceInfoKHR ) + , pNext( nullptr ) + , handleType( handleType_ ) + { + } + + PhysicalDeviceExternalFenceInfoKHR( VkPhysicalDeviceExternalFenceInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfoKHR ) ); + } + + PhysicalDeviceExternalFenceInfoKHR& operator=( VkPhysicalDeviceExternalFenceInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfoKHR ) ); + return *this; + } + PhysicalDeviceExternalFenceInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PhysicalDeviceExternalFenceInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkPhysicalDeviceExternalFenceInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PhysicalDeviceExternalFenceInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( PhysicalDeviceExternalFenceInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + ExternalFenceHandleTypeFlagBitsKHR handleType; + }; + static_assert( sizeof( PhysicalDeviceExternalFenceInfoKHR ) == sizeof( VkPhysicalDeviceExternalFenceInfoKHR ), "struct and wrapper have different size!" ); + + struct ExportFenceCreateInfoKHR + { + ExportFenceCreateInfoKHR( ExternalFenceHandleTypeFlagsKHR handleTypes_ = ExternalFenceHandleTypeFlagsKHR() ) + : sType( StructureType::eExportFenceCreateInfoKHR ) + , pNext( nullptr ) + , handleTypes( handleTypes_ ) + { + } + + ExportFenceCreateInfoKHR( VkExportFenceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceCreateInfoKHR ) ); + } + + ExportFenceCreateInfoKHR& operator=( VkExportFenceCreateInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ExportFenceCreateInfoKHR ) ); + return *this; + } + ExportFenceCreateInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ExportFenceCreateInfoKHR& setHandleTypes( ExternalFenceHandleTypeFlagsKHR handleTypes_ ) + { + handleTypes = handleTypes_; + return *this; + } + + operator const VkExportFenceCreateInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExportFenceCreateInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( handleTypes == rhs.handleTypes ); + } + + bool operator!=( ExportFenceCreateInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + ExternalFenceHandleTypeFlagsKHR handleTypes; + }; + static_assert( sizeof( ExportFenceCreateInfoKHR ) == sizeof( VkExportFenceCreateInfoKHR ), "struct and wrapper have different size!" ); + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct FenceGetWin32HandleInfoKHR + { + FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eFenceGetWin32HandleInfoKHR ) + , pNext( nullptr ) + , fence( fence_ ) + , handleType( handleType_ ) + { + } + + FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) ); + } + + FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) ); + return *this; + } + FenceGetWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + FenceGetWin32HandleInfoKHR& setFence( Fence fence_ ) + { + fence = fence_; + return *this; + } + + FenceGetWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkFenceGetWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fence == rhs.fence ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Fence fence; + ExternalFenceHandleTypeFlagBitsKHR handleType; + }; + static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct FenceGetFdInfoKHR + { + FenceGetFdInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd ) + : sType( StructureType::eFenceGetFdInfoKHR ) + , pNext( nullptr ) + , fence( fence_ ) + , handleType( handleType_ ) + { + } + + FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) ); + } + + FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) ); + return *this; + } + FenceGetFdInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + FenceGetFdInfoKHR& setFence( Fence fence_ ) + { + fence = fence_; + return *this; + } + + FenceGetFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; + return *this; + } + + operator const VkFenceGetFdInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( FenceGetFdInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fence == rhs.fence ) + && ( handleType == rhs.handleType ); + } + + bool operator!=( FenceGetFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Fence fence; + ExternalFenceHandleTypeFlagBitsKHR handleType; + }; + static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" ); + + enum class ExternalFenceFeatureFlagBitsKHR + { + eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR, + eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR + }; + + using ExternalFenceFeatureFlagsKHR = Flags; + + VULKAN_HPP_INLINE ExternalFenceFeatureFlagsKHR operator|( ExternalFenceFeatureFlagBitsKHR bit0, ExternalFenceFeatureFlagBitsKHR bit1 ) + { + return ExternalFenceFeatureFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE ExternalFenceFeatureFlagsKHR operator~( ExternalFenceFeatureFlagBitsKHR bits ) + { + return ~( ExternalFenceFeatureFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(ExternalFenceFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalFenceFeatureFlagBitsKHR::eImportable) + }; + }; + + struct ExternalFencePropertiesKHR + { + operator const VkExternalFencePropertiesKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ExternalFencePropertiesKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) + && ( compatibleHandleTypes == rhs.compatibleHandleTypes ) + && ( externalFenceFeatures == rhs.externalFenceFeatures ); + } + + bool operator!=( ExternalFencePropertiesKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + void* pNext; + ExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes; + ExternalFenceHandleTypeFlagsKHR compatibleHandleTypes; + ExternalFenceFeatureFlagsKHR externalFenceFeatures; + }; + static_assert( sizeof( ExternalFencePropertiesKHR ) == sizeof( VkExternalFencePropertiesKHR ), "struct and wrapper have different size!" ); + + enum class FenceImportFlagBitsKHR + { + eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR + }; + + using FenceImportFlagsKHR = Flags; + + VULKAN_HPP_INLINE FenceImportFlagsKHR operator|( FenceImportFlagBitsKHR bit0, FenceImportFlagBitsKHR bit1 ) + { + return FenceImportFlagsKHR( bit0 ) | bit1; + } + + VULKAN_HPP_INLINE FenceImportFlagsKHR operator~( FenceImportFlagBitsKHR bits ) + { + return ~( FenceImportFlagsKHR( bits ) ); + } + + template <> struct FlagTraits + { + enum + { + allFlags = VkFlags(FenceImportFlagBitsKHR::eTemporary) + }; + }; + +#ifdef VK_USE_PLATFORM_WIN32_KHR + struct ImportFenceWin32HandleInfoKHR + { + ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 ) + : sType( StructureType::eImportFenceWin32HandleInfoKHR ) + , pNext( nullptr ) + , fence( fence_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , handle( handle_ ) + , name( name_ ) + { + } + + ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) ); + } + + ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) ); + return *this; + } + ImportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setFence( Fence fence_ ) + { + fence = fence_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setFlags( FenceImportFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setHandle( HANDLE handle_ ) + { + handle = handle_; + return *this; + } + + ImportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ ) + { + name = name_; + return *this; + } + + operator const VkImportFenceWin32HandleInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fence == rhs.fence ) + && ( flags == rhs.flags ) + && ( handleType == rhs.handleType ) + && ( handle == rhs.handle ) + && ( name == rhs.name ); + } + + bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Fence fence; + FenceImportFlagsKHR flags; + ExternalFenceHandleTypeFlagBitsKHR handleType; + HANDLE handle; + LPCWSTR name; + }; + static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + struct ImportFenceFdInfoKHR + { + ImportFenceFdInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 ) + : sType( StructureType::eImportFenceFdInfoKHR ) + , pNext( nullptr ) + , fence( fence_ ) + , flags( flags_ ) + , handleType( handleType_ ) + , fd( fd_ ) + { + } + + ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) ); + } + + ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs ) + { + memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) ); + return *this; + } + ImportFenceFdInfoKHR& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + ImportFenceFdInfoKHR& setFence( Fence fence_ ) + { + fence = fence_; + return *this; + } + + ImportFenceFdInfoKHR& setFlags( FenceImportFlagsKHR flags_ ) + { + flags = flags_; + return *this; + } + + ImportFenceFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ ) + { + handleType = handleType_; + return *this; + } + + ImportFenceFdInfoKHR& setFd( int fd_ ) + { + fd = fd_; + return *this; + } + + operator const VkImportFenceFdInfoKHR&() const + { + return *reinterpret_cast(this); + } + + bool operator==( ImportFenceFdInfoKHR const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( fence == rhs.fence ) + && ( flags == rhs.flags ) + && ( handleType == rhs.handleType ) + && ( fd == rhs.fd ); + } + + bool operator!=( ImportFenceFdInfoKHR const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Fence fence; + FenceImportFlagsKHR flags; + ExternalFenceHandleTypeFlagBitsKHR handleType; + int fd; + }; + static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" ); enum class SurfaceCounterFlagBitsEXT { - eVblankExt = VK_SURFACE_COUNTER_VBLANK_EXT + eVblank = VK_SURFACE_COUNTER_VBLANK_EXT }; using SurfaceCounterFlagsEXT = Flags; @@ -20411,7 +22265,7 @@ namespace vk { enum { - allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblankExt) + allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank) }; }; @@ -20474,15 +22328,14 @@ namespace vk SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(SwapchainCounterCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) ); } SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(SwapchainCounterCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) ); return *this; } - SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20539,15 +22392,14 @@ namespace vk DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayPowerInfoEXT) ); + memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) ); } DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayPowerInfoEXT) ); + memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) ); return *this; } - DisplayPowerInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20602,15 +22454,14 @@ namespace vk DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceEventInfoEXT) ); + memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) ); } DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceEventInfoEXT) ); + memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) ); return *this; } - DeviceEventInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20665,15 +22516,14 @@ namespace vk DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayEventInfoEXT) ); + memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) ); } DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(DisplayEventInfoEXT) ); + memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) ); return *this; } - DisplayEventInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20777,15 +22627,14 @@ namespace vk MemoryAllocateFlagsInfoKHX( VkMemoryAllocateFlagsInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryAllocateFlagsInfoKHX) ); + memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfoKHX ) ); } MemoryAllocateFlagsInfoKHX& operator=( VkMemoryAllocateFlagsInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(MemoryAllocateFlagsInfoKHX) ); + memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfoKHX ) ); return *this; } - MemoryAllocateFlagsInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20903,15 +22752,14 @@ namespace vk DeviceGroupPresentInfoKHX( VkDeviceGroupPresentInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupPresentInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHX ) ); } DeviceGroupPresentInfoKHX& operator=( VkDeviceGroupPresentInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupPresentInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHX ) ); return *this; } - DeviceGroupPresentInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -20977,15 +22825,14 @@ namespace vk DeviceGroupSwapchainCreateInfoKHX( VkDeviceGroupSwapchainCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupSwapchainCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHX ) ); } DeviceGroupSwapchainCreateInfoKHX& operator=( VkDeviceGroupSwapchainCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupSwapchainCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHX ) ); return *this; } - DeviceGroupSwapchainCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21075,15 +22922,14 @@ namespace vk SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) ); } SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs ) { - memcpy( this, &rhs, sizeof(SwapchainCreateInfoKHR) ); + memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) ); return *this; } - SwapchainCreateInfoKHR& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21266,15 +23112,14 @@ namespace vk ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) { - memcpy( this, &rhs, sizeof(ViewportSwizzleNV) ); + memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) ); } ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs ) { - memcpy( this, &rhs, sizeof(ViewportSwizzleNV) ); + memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) ); return *this; } - ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ ) { x = x_; @@ -21337,15 +23182,14 @@ namespace vk PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportSwizzleStateCreateInfoNV) ); + memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) ); } PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineViewportSwizzleStateCreateInfoNV) ); + memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) ); return *this; } - PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21420,15 +23264,14 @@ namespace vk PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDiscardRectangleStateCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) ); } PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) { - memcpy( this, &rhs, sizeof(PipelineDiscardRectangleStateCreateInfoEXT) ); + memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) ); return *this; } - PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21535,15 +23378,14 @@ namespace vk SubpassDescription( VkSubpassDescription const & rhs ) { - memcpy( this, &rhs, sizeof(SubpassDescription) ); + memcpy( this, &rhs, sizeof( SubpassDescription ) ); } SubpassDescription& operator=( VkSubpassDescription const & rhs ) { - memcpy( this, &rhs, sizeof(SubpassDescription) ); + memcpy( this, &rhs, sizeof( SubpassDescription ) ); return *this; } - SubpassDescription& setFlags( SubpassDescriptionFlags flags_ ) { flags = flags_; @@ -21658,15 +23500,14 @@ namespace vk RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassCreateInfo) ); + memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) ); } RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs ) { - memcpy( this, &rhs, sizeof(RenderPassCreateInfo) ); + memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) ); return *this; } - RenderPassCreateInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -21753,10 +23594,257 @@ namespace vk }; static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" ); - Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ); + enum class SamplerReductionModeEXT + { + eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT, + eMin = VK_SAMPLER_REDUCTION_MODE_MIN_EXT, + eMax = VK_SAMPLER_REDUCTION_MODE_MAX_EXT + }; + + struct SamplerReductionModeCreateInfoEXT + { + SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage ) + : sType( StructureType::eSamplerReductionModeCreateInfoEXT ) + , pNext( nullptr ) + , reductionMode( reductionMode_ ) + { + } + + SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) ); + } + + SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) ); + return *this; + } + SamplerReductionModeCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + SamplerReductionModeCreateInfoEXT& setReductionMode( SamplerReductionModeEXT reductionMode_ ) + { + reductionMode = reductionMode_; + return *this; + } + + operator const VkSamplerReductionModeCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( SamplerReductionModeCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( reductionMode == rhs.reductionMode ); + } + + bool operator!=( SamplerReductionModeCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + SamplerReductionModeEXT reductionMode; + }; + static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class BlendOverlapEXT + { + eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT, + eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT, + eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT + }; + + struct PipelineColorBlendAdvancedStateCreateInfoEXT + { + PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0, Bool32 dstPremultiplied_ = 0, BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated ) + : sType( StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT ) + , pNext( nullptr ) + , srcPremultiplied( srcPremultiplied_ ) + , dstPremultiplied( dstPremultiplied_ ) + , blendOverlap( blendOverlap_ ) + { + } + + PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) ); + } + + PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) ); + return *this; + } + PipelineColorBlendAdvancedStateCreateInfoEXT& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineColorBlendAdvancedStateCreateInfoEXT& setSrcPremultiplied( Bool32 srcPremultiplied_ ) + { + srcPremultiplied = srcPremultiplied_; + return *this; + } + + PipelineColorBlendAdvancedStateCreateInfoEXT& setDstPremultiplied( Bool32 dstPremultiplied_ ) + { + dstPremultiplied = dstPremultiplied_; + return *this; + } + + PipelineColorBlendAdvancedStateCreateInfoEXT& setBlendOverlap( BlendOverlapEXT blendOverlap_ ) + { + blendOverlap = blendOverlap_; + return *this; + } + + operator const VkPipelineColorBlendAdvancedStateCreateInfoEXT&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( srcPremultiplied == rhs.srcPremultiplied ) + && ( dstPremultiplied == rhs.dstPremultiplied ) + && ( blendOverlap == rhs.blendOverlap ); + } + + bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + Bool32 srcPremultiplied; + Bool32 dstPremultiplied; + BlendOverlapEXT blendOverlap; + }; + static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" ); + + enum class CoverageModulationModeNV + { + eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV, + eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV, + eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV, + eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV + }; + + struct PipelineCoverageModulationStateCreateInfoNV + { + PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(), CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone, Bool32 coverageModulationTableEnable_ = 0, uint32_t coverageModulationTableCount_ = 0, const float* pCoverageModulationTable_ = nullptr ) + : sType( StructureType::ePipelineCoverageModulationStateCreateInfoNV ) + , pNext( nullptr ) + , flags( flags_ ) + , coverageModulationMode( coverageModulationMode_ ) + , coverageModulationTableEnable( coverageModulationTableEnable_ ) + , coverageModulationTableCount( coverageModulationTableCount_ ) + , pCoverageModulationTable( pCoverageModulationTable_ ) + { + } + + PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) ); + } + + PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) + { + memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) ); + return *this; + } + PipelineCoverageModulationStateCreateInfoNV& setPNext( const void* pNext_ ) + { + pNext = pNext_; + return *this; + } + + PipelineCoverageModulationStateCreateInfoNV& setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ ) + { + flags = flags_; + return *this; + } + + PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ ) + { + coverageModulationMode = coverageModulationMode_; + return *this; + } + + PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ ) + { + coverageModulationTableEnable = coverageModulationTableEnable_; + return *this; + } + + PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ ) + { + coverageModulationTableCount = coverageModulationTableCount_; + return *this; + } + + PipelineCoverageModulationStateCreateInfoNV& setPCoverageModulationTable( const float* pCoverageModulationTable_ ) + { + pCoverageModulationTable = pCoverageModulationTable_; + return *this; + } + + operator const VkPipelineCoverageModulationStateCreateInfoNV&() const + { + return *reinterpret_cast(this); + } + + bool operator==( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const + { + return ( sType == rhs.sType ) + && ( pNext == rhs.pNext ) + && ( flags == rhs.flags ) + && ( coverageModulationMode == rhs.coverageModulationMode ) + && ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) + && ( coverageModulationTableCount == rhs.coverageModulationTableCount ) + && ( pCoverageModulationTable == rhs.pCoverageModulationTable ); + } + + bool operator!=( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const + { + return !operator==( rhs ); + } + + private: + StructureType sType; + + public: + const void* pNext; + PipelineCoverageModulationStateCreateFlagsNV flags; + CoverageModulationModeNV coverageModulationMode; + Bool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; + }; + static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" ); + + Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ); #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template > - typename ResultValueType>::type enumerateInstanceLayerProperties(); + template > + typename ResultValueType>::type enumerateInstanceLayerProperties(); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ) @@ -21779,17 +23867,17 @@ namespace vk result = static_cast( vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); + assert( propertyCount <= properties.size() ); + properties.resize( propertyCount ); return createResultValue( result, properties, "vk::enumerateInstanceLayerProperties" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ); + Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ); #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - template > - typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName = nullptr ); + template > + typename ResultValueType>::type enumerateInstanceExtensionProperties( Optional layerName = nullptr ); #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ) @@ -21812,8 +23900,8 @@ namespace vk result = static_cast( vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); + assert( propertyCount <= properties.size() ); + properties.resize( propertyCount ); return createResultValue( result, properties, "vk::enumerateInstanceExtensionProperties" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -21833,35 +23921,35 @@ namespace vk : m_commandBuffer(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer(VkCommandBuffer commandBuffer) - : m_commandBuffer(commandBuffer) + VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer ) + : m_commandBuffer( commandBuffer ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - CommandBuffer& operator=(VkCommandBuffer commandBuffer) + CommandBuffer & operator=(VkCommandBuffer commandBuffer) { m_commandBuffer = commandBuffer; - return *this; + return *this; } #endif - CommandBuffer& operator=( std::nullptr_t ) + CommandBuffer & operator=( std::nullptr_t ) { m_commandBuffer = VK_NULL_HANDLE; return *this; } - bool operator==(CommandBuffer const &rhs) const + bool operator==( CommandBuffer const & rhs ) const { return m_commandBuffer == rhs.m_commandBuffer; } - bool operator!=(CommandBuffer const &rhs) const + bool operator!=(CommandBuffer const & rhs ) const { return m_commandBuffer != rhs.m_commandBuffer; } - bool operator<(CommandBuffer const &rhs) const + bool operator<(CommandBuffer const & rhs ) const { return m_commandBuffer < rhs.m_commandBuffer; } @@ -22077,6 +24165,8 @@ namespace vk void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy discardRectangles ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const { return m_commandBuffer; @@ -22095,6 +24185,7 @@ namespace vk private: VkCommandBuffer m_commandBuffer; }; + static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo ) const @@ -22225,7 +24316,7 @@ namespace vk #else if ( buffers.size() != offsets.size() ) { - throw std::logic_error( "vk::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); + throw LogicError( "vk::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); } #endif // VULKAN_HPP_NO_EXCEPTIONS vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast( buffers.data() ), offsets.data() ); @@ -22607,15 +24698,14 @@ namespace vk SubmitInfo( VkSubmitInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SubmitInfo) ); + memcpy( this, &rhs, sizeof( SubmitInfo ) ); } SubmitInfo& operator=( VkSubmitInfo const & rhs ) { - memcpy( this, &rhs, sizeof(SubmitInfo) ); + memcpy( this, &rhs, sizeof( SubmitInfo ) ); return *this; } - SubmitInfo& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -22713,35 +24803,35 @@ namespace vk : m_queue(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Queue(VkQueue queue) - : m_queue(queue) + VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue ) + : m_queue( queue ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Queue& operator=(VkQueue queue) + Queue & operator=(VkQueue queue) { m_queue = queue; - return *this; + return *this; } #endif - Queue& operator=( std::nullptr_t ) + Queue & operator=( std::nullptr_t ) { m_queue = VK_NULL_HANDLE; return *this; } - bool operator==(Queue const &rhs) const + bool operator==( Queue const & rhs ) const { return m_queue == rhs.m_queue; } - bool operator!=(Queue const &rhs) const + bool operator!=(Queue const & rhs ) const { return m_queue != rhs.m_queue; } - bool operator<(Queue const &rhs) const + bool operator<(Queue const & rhs ) const { return m_queue < rhs.m_queue; } @@ -22767,6 +24857,8 @@ namespace vk Result presentKHR( const PresentInfoKHR & presentInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const { return m_queue; @@ -22785,6 +24877,7 @@ namespace vk private: VkQueue m_queue; }; + static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence ) const @@ -22900,35 +24993,35 @@ namespace vk : m_device(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Device(VkDevice device) - : m_device(device) + VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device ) + : m_device( device ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Device& operator=(VkDevice device) + Device & operator=(VkDevice device) { m_device = device; - return *this; + return *this; } #endif - Device& operator=( std::nullptr_t ) + Device & operator=( std::nullptr_t ) { m_device = VK_NULL_HANDLE; return *this; } - bool operator==(Device const &rhs) const + bool operator==( Device const & rhs ) const { return m_device == rhs.m_device; } - bool operator!=(Device const &rhs) const + bool operator!=(Device const & rhs ) const { return m_device != rhs.m_device; } - bool operator<(Device const &rhs) const + bool operator<(Device const & rhs ) const { return m_device < rhs.m_device; } @@ -23462,52 +25555,76 @@ namespace vk void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlagsKHR flags = CommandPoolTrimFlagsKHR() ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - Result getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const; +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const; + ResultValueType::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - Result getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle, MemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties ) const; +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle ) const; + ResultValueType::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - Result getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd ) const; + Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const; + ResultValueType::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - Result getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, MemoryFdPropertiesKHX* pMemoryFdProperties ) const; + Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd ) const; + ResultValueType::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - Result getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const; +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const; + ResultValueType::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - Result importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo ) const; +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX & importSemaphoreWin32HandleInfo ) const; + ResultValueType::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - Result getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd ) const; + Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const; + ResultValueType::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - Result importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo ) const; + Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX & importSemaphoreFdInfo ) const; + ResultValueType::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ResultValueType::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ResultValueType::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ResultValueType::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ResultValueType::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo ) const; @@ -23580,6 +25697,8 @@ namespace vk void setHdrMetadataEXT( ArrayProxy swapchains, ArrayProxy metadata ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + Result getSwapchainStatusKHR( SwapchainKHR swapchain ) const; + Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE ResultValueType::type getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain ) const; @@ -23591,6 +25710,24 @@ namespace vk typename ResultValueType>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + MemoryRequirements2KHR getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + MemoryRequirements2KHR getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2KHR* pSparseMemoryRequirements ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template > + std::vector getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const { return m_device; @@ -23609,6 +25746,7 @@ namespace vk private: VkDevice m_device; }; + static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); #ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -24698,8 +26836,8 @@ namespace vk result = static_cast( vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, reinterpret_cast( data.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( dataSize <= data.size() ); - data.resize( dataSize ); + assert( dataSize <= data.size() ); + data.resize( dataSize ); return createResultValue( result, data, "vk::Device::getPipelineCacheData" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -25246,8 +27384,8 @@ namespace vk result = static_cast( vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), &swapchainImageCount, reinterpret_cast( swapchainImages.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( swapchainImageCount <= swapchainImages.size() ); - swapchainImages.resize( swapchainImageCount ); + assert( swapchainImageCount <= swapchainImages.size() ); + swapchainImages.resize( swapchainImageCount ); return createResultValue( result, swapchainImages, "vk::Device::getSwapchainImagesKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -25380,7 +27518,7 @@ namespace vk #else if ( pObjectTableEntries.size() != objectIndices.size() ) { - throw std::logic_error( "vk::Device::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" ); + throw LogicError( "vk::Device::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" ); } #endif // VULKAN_HPP_NO_EXCEPTIONS Result result = static_cast( vkRegisterObjectsNVX( m_device, static_cast( objectTable ), pObjectTableEntries.size() , reinterpret_cast( pObjectTableEntries.data() ), objectIndices.data() ) ); @@ -25400,7 +27538,7 @@ namespace vk #else if ( objectEntryTypes.size() != objectIndices.size() ) { - throw std::logic_error( "vk::Device::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" ); + throw LogicError( "vk::Device::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" ); } #endif // VULKAN_HPP_NO_EXCEPTIONS Result result = static_cast( vkUnregisterObjectsNVX( m_device, static_cast( objectTable ), objectEntryTypes.size() , reinterpret_cast( objectEntryTypes.data() ), objectIndices.data() ) ); @@ -25413,113 +27551,167 @@ namespace vk vkTrimCommandPoolKHR( m_device, static_cast( commandPool ), static_cast( flags ) ); } -#ifdef VK_USE_PLATFORM_WIN32_KHX - VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const { - return static_cast( vkGetMemoryWin32HandleKHX( m_device, static_cast( memory ), static_cast( handleType ), pHandle ) ); + return static_cast( vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandleKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const { HANDLE handle; - Result result = static_cast( vkGetMemoryWin32HandleKHX( m_device, static_cast( memory ), static_cast( handleType ), &handle ) ); - return createResultValue( result, handle, "vk::Device::getMemoryWin32HandleKHX" ); + Result result = static_cast( vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + return createResultValue( result, handle, "vk::Device::getMemoryWin32HandleKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle, MemoryWin32HandlePropertiesKHX* pMemoryWin32HandleProperties ) const +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const { - return static_cast( vkGetMemoryWin32HandlePropertiesKHX( m_device, static_cast( handleType ), handle, reinterpret_cast( pMemoryWin32HandleProperties ) ) ); + return static_cast( vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast( handleType ), handle, reinterpret_cast( pMemoryWin32HandleProperties ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandlePropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, HANDLE handle ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle ) const { - MemoryWin32HandlePropertiesKHX memoryWin32HandleProperties; - Result result = static_cast( vkGetMemoryWin32HandlePropertiesKHX( m_device, static_cast( handleType ), handle, reinterpret_cast( &memoryWin32HandleProperties ) ) ); - return createResultValue( result, memoryWin32HandleProperties, "vk::Device::getMemoryWin32HandlePropertiesKHX" ); + MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; + Result result = static_cast( vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast( handleType ), handle, reinterpret_cast( &memoryWin32HandleProperties ) ) ); + return createResultValue( result, memoryWin32HandleProperties, "vk::Device::getMemoryWin32HandlePropertiesKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - VULKAN_HPP_INLINE Result Device::getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType, int* pFd ) const + VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const { - return static_cast( vkGetMemoryFdKHX( m_device, static_cast( memory ), static_cast( handleType ), pFd ) ); + return static_cast( vkGetMemoryFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdKHX( DeviceMemory memory, ExternalMemoryHandleTypeFlagBitsKHX handleType ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const { int fd; - Result result = static_cast( vkGetMemoryFdKHX( m_device, static_cast( memory ), static_cast( handleType ), &fd ) ); - return createResultValue( result, fd, "vk::Device::getMemoryFdKHX" ); + Result result = static_cast( vkGetMemoryFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + return createResultValue( result, fd, "vk::Device::getMemoryFdKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd, MemoryFdPropertiesKHX* pMemoryFdProperties ) const + VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties ) const { - return static_cast( vkGetMemoryFdPropertiesKHX( m_device, static_cast( handleType ), fd, reinterpret_cast( pMemoryFdProperties ) ) ); + return static_cast( vkGetMemoryFdPropertiesKHR( m_device, static_cast( handleType ), fd, reinterpret_cast( pMemoryFdProperties ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdPropertiesKHX( ExternalMemoryHandleTypeFlagBitsKHX handleType, int fd ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd ) const { - MemoryFdPropertiesKHX memoryFdProperties; - Result result = static_cast( vkGetMemoryFdPropertiesKHX( m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ) ); - return createResultValue( result, memoryFdProperties, "vk::Device::getMemoryFdPropertiesKHX" ); + MemoryFdPropertiesKHR memoryFdProperties; + Result result = static_cast( vkGetMemoryFdPropertiesKHR( m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ) ); + return createResultValue( result, memoryFdProperties, "vk::Device::getMemoryFdPropertiesKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, HANDLE* pHandle ) const +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const { - return static_cast( vkGetSemaphoreWin32HandleKHX( m_device, static_cast( semaphore ), static_cast( handleType ), pHandle ) ); + return static_cast( vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreWin32HandleKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const { HANDLE handle; - Result result = static_cast( vkGetSemaphoreWin32HandleKHX( m_device, static_cast( semaphore ), static_cast( handleType ), &handle ) ); - return createResultValue( result, handle, "vk::Device::getSemaphoreWin32HandleKHX" ); + Result result = static_cast( vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + return createResultValue( result, handle, "vk::Device::getSemaphoreWin32HandleKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#ifdef VK_USE_PLATFORM_WIN32_KHX - VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX* pImportSemaphoreWin32HandleInfo ) const +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const { - return static_cast( vkImportSemaphoreWin32HandleKHX( m_device, reinterpret_cast( pImportSemaphoreWin32HandleInfo ) ) ); + return static_cast( vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( pImportSemaphoreWin32HandleInfo ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreWin32HandleKHX( const ImportSemaphoreWin32HandleInfoKHX & importSemaphoreWin32HandleInfo ) const + VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const { - Result result = static_cast( vkImportSemaphoreWin32HandleKHX( m_device, reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); - return createResultValue( result, "vk::Device::importSemaphoreWin32HandleKHX" ); + Result result = static_cast( vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); + return createResultValue( result, "vk::Device::importSemaphoreWin32HandleKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VK_USE_PLATFORM_WIN32_KHX*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType, int* pFd ) const + VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const { - return static_cast( vkGetSemaphoreFdKHX( m_device, static_cast( semaphore ), static_cast( handleType ), pFd ) ); + return static_cast( vkGetSemaphoreFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreFdKHX( Semaphore semaphore, ExternalSemaphoreHandleTypeFlagBitsKHX handleType ) const + VULKAN_HPP_INLINE ResultValueType::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const { int fd; - Result result = static_cast( vkGetSemaphoreFdKHX( m_device, static_cast( semaphore ), static_cast( handleType ), &fd ) ); - return createResultValue( result, fd, "vk::Device::getSemaphoreFdKHX" ); + Result result = static_cast( vkGetSemaphoreFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + return createResultValue( result, fd, "vk::Device::getSemaphoreFdKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX* pImportSemaphoreFdInfo ) const + VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const { - return static_cast( vkImportSemaphoreFdKHX( m_device, reinterpret_cast( pImportSemaphoreFdInfo ) ) ); + return static_cast( vkImportSemaphoreFdKHR( m_device, reinterpret_cast( pImportSemaphoreFdInfo ) ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreFdKHX( const ImportSemaphoreFdInfoKHX & importSemaphoreFdInfo ) const + VULKAN_HPP_INLINE ResultValueType::type Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const { - Result result = static_cast( vkImportSemaphoreFdKHX( m_device, reinterpret_cast( &importSemaphoreFdInfo ) ) ); - return createResultValue( result, "vk::Device::importSemaphoreFdKHX" ); + Result result = static_cast( vkImportSemaphoreFdKHR( m_device, reinterpret_cast( &importSemaphoreFdInfo ) ) ); + return createResultValue( result, "vk::Device::importSemaphoreFdKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const + { + return static_cast( vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ResultValueType::type Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const + { + HANDLE handle; + Result result = static_cast( vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + return createResultValue( result, handle, "vk::Device::getFenceWin32HandleKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const + { + return static_cast( vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( pImportFenceWin32HandleInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ResultValueType::type Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const + { + Result result = static_cast( vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( &importFenceWin32HandleInfo ) ) ); + return createResultValue( result, "vk::Device::importFenceWin32HandleKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const + { + return static_cast( vkGetFenceFdKHR( m_device, reinterpret_cast( pGetFdInfo ), pFd ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ResultValueType::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const + { + int fd; + Result result = static_cast( vkGetFenceFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + return createResultValue( result, fd, "vk::Device::getFenceFdKHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo ) const + { + return static_cast( vkImportFenceFdKHR( m_device, reinterpret_cast( pImportFenceFdInfo ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ResultValueType::type Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const + { + Result result = static_cast( vkImportFenceFdKHR( m_device, reinterpret_cast( &importFenceFdInfo ) ) ); + return createResultValue( result, "vk::Device::importFenceFdKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -25698,13 +27890,26 @@ namespace vk #else if ( swapchains.size() != metadata.size() ) { - throw std::logic_error( "vk::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); + throw LogicError( "vk::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); } #endif // VULKAN_HPP_NO_EXCEPTIONS vkSetHdrMetadataEXT( m_device, swapchains.size() , reinterpret_cast( swapchains.data() ), reinterpret_cast( metadata.data() ) ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain ) const + { + return static_cast( vkGetSwapchainStatusKHR( m_device, static_cast( swapchain ) ) ); + } +#else + VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain ) const + { + Result result = static_cast( vkGetSwapchainStatusKHR( m_device, static_cast( swapchain ) ) ); + return createResultValue( result, "vk::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const { return static_cast( vkGetRefreshCycleDurationGOOGLE( m_device, static_cast( swapchain ), reinterpret_cast( pDisplayTimingProperties ) ) ); @@ -25738,6 +27943,49 @@ namespace vk } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const + { + vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const + { + MemoryRequirements2KHR memoryRequirements; + vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const + { + vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), reinterpret_cast( pMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const + { + MemoryRequirements2KHR memoryRequirements; + vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + return memoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2KHR* pSparseMemoryRequirements ) const + { + vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast( pSparseMemoryRequirements ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE std::vector Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info ) const + { + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, reinterpret_cast( sparseMemoryRequirements.data() ) ); + return sparseMemoryRequirements; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifndef VULKAN_HPP_NO_SMART_HANDLE class DeviceDeleter; using UniqueDevice = UniqueHandle; @@ -25754,35 +28002,35 @@ namespace vk : m_physicalDevice(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice(VkPhysicalDevice physicalDevice) - : m_physicalDevice(physicalDevice) + VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice ) + : m_physicalDevice( physicalDevice ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - PhysicalDevice& operator=(VkPhysicalDevice physicalDevice) + PhysicalDevice & operator=(VkPhysicalDevice physicalDevice) { m_physicalDevice = physicalDevice; - return *this; + return *this; } #endif - PhysicalDevice& operator=( std::nullptr_t ) + PhysicalDevice & operator=( std::nullptr_t ) { m_physicalDevice = VK_NULL_HANDLE; return *this; } - bool operator==(PhysicalDevice const &rhs) const + bool operator==( PhysicalDevice const & rhs ) const { return m_physicalDevice == rhs.m_physicalDevice; } - bool operator!=(PhysicalDevice const &rhs) const + bool operator!=(PhysicalDevice const & rhs ) const { return m_physicalDevice != rhs.m_physicalDevice; } - bool operator<(PhysicalDevice const &rhs) const + bool operator<(PhysicalDevice const & rhs ) const { return m_physicalDevice < rhs.m_physicalDevice; } @@ -25979,14 +28227,19 @@ namespace vk std::vector getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - void getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, ExternalBufferPropertiesKHX* pExternalBufferProperties ) const; + void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, ExternalBufferPropertiesKHR* pExternalBufferProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ExternalBufferPropertiesKHX getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX & externalBufferInfo ) const; + ExternalBufferPropertiesKHR getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR & externalBufferInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - void getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties ) const; + void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties ) const; #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ExternalSemaphorePropertiesKHX getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX & externalSemaphoreInfo ) const; + ExternalSemaphorePropertiesKHR getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR & externalSemaphoreInfo ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, ExternalFencePropertiesKHR* pExternalFenceProperties ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ExternalFencePropertiesKHR getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR & externalFenceInfo ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE @@ -26020,6 +28273,19 @@ namespace vk typename ResultValueType>::type getPresentRectanglesKHX( SurfaceKHR surface ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + ResultValueType::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats ) const; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template > + typename ResultValueType>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const { return m_physicalDevice; @@ -26038,6 +28304,7 @@ namespace vk private: VkPhysicalDevice m_physicalDevice; }; + static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); #ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -26180,8 +28447,8 @@ namespace vk result = static_cast( vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); + assert( propertyCount <= properties.size() ); + properties.resize( propertyCount ); return createResultValue( result, properties, "vk::PhysicalDevice::enumerateDeviceLayerProperties" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -26206,8 +28473,8 @@ namespace vk result = static_cast( vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); + assert( propertyCount <= properties.size() ); + properties.resize( propertyCount ); return createResultValue( result, properties, "vk::PhysicalDevice::enumerateDeviceExtensionProperties" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -26249,8 +28516,8 @@ namespace vk result = static_cast( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); + assert( propertyCount <= properties.size() ); + properties.resize( propertyCount ); return createResultValue( result, properties, "vk::PhysicalDevice::getDisplayPropertiesKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -26275,8 +28542,8 @@ namespace vk result = static_cast( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); + assert( propertyCount <= properties.size() ); + properties.resize( propertyCount ); return createResultValue( result, properties, "vk::PhysicalDevice::getDisplayPlanePropertiesKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -26301,8 +28568,8 @@ namespace vk result = static_cast( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast( displays.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( displayCount <= displays.size() ); - displays.resize( displayCount ); + assert( displayCount <= displays.size() ); + displays.resize( displayCount ); return createResultValue( result, displays, "vk::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -26327,8 +28594,8 @@ namespace vk result = static_cast( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( propertyCount <= properties.size() ); - properties.resize( propertyCount ); + assert( propertyCount <= properties.size() ); + properties.resize( propertyCount ); return createResultValue( result, properties, "vk::PhysicalDevice::getDisplayModePropertiesKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -26418,8 +28685,8 @@ namespace vk result = static_cast( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( surfaceFormatCount <= surfaceFormats.size() ); - surfaceFormats.resize( surfaceFormatCount ); + assert( surfaceFormatCount <= surfaceFormats.size() ); + surfaceFormats.resize( surfaceFormatCount ); return createResultValue( result, surfaceFormats, "vk::PhysicalDevice::getSurfaceFormatsKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -26444,8 +28711,8 @@ namespace vk result = static_cast( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( presentModeCount <= presentModes.size() ); - presentModes.resize( presentModeCount ); + assert( presentModeCount <= presentModes.size() ); + presentModes.resize( presentModeCount ); return createResultValue( result, presentModes, "vk::PhysicalDevice::getSurfacePresentModesKHR" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -26621,32 +28888,45 @@ namespace vk } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX* pExternalBufferInfo, ExternalBufferPropertiesKHX* pExternalBufferProperties ) const + VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, ExternalBufferPropertiesKHR* pExternalBufferProperties ) const { - vkGetPhysicalDeviceExternalBufferPropertiesKHX( m_physicalDevice, reinterpret_cast( pExternalBufferInfo ), reinterpret_cast( pExternalBufferProperties ) ); + vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalBufferInfo ), reinterpret_cast( pExternalBufferProperties ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ExternalBufferPropertiesKHX PhysicalDevice::getExternalBufferPropertiesKHX( const PhysicalDeviceExternalBufferInfoKHX & externalBufferInfo ) const + VULKAN_HPP_INLINE ExternalBufferPropertiesKHR PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR & externalBufferInfo ) const { - ExternalBufferPropertiesKHX externalBufferProperties; - vkGetPhysicalDeviceExternalBufferPropertiesKHX( m_physicalDevice, reinterpret_cast( &externalBufferInfo ), reinterpret_cast( &externalBufferProperties ) ); + ExternalBufferPropertiesKHR externalBufferProperties; + vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast( &externalBufferInfo ), reinterpret_cast( &externalBufferProperties ) ); return externalBufferProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHX* pExternalSemaphoreProperties ) const + VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties ) const { - vkGetPhysicalDeviceExternalSemaphorePropertiesKHX( m_physicalDevice, reinterpret_cast( pExternalSemaphoreInfo ), reinterpret_cast( pExternalSemaphoreProperties ) ); + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalSemaphoreInfo ), reinterpret_cast( pExternalSemaphoreProperties ) ); } #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - VULKAN_HPP_INLINE ExternalSemaphorePropertiesKHX PhysicalDevice::getExternalSemaphorePropertiesKHX( const PhysicalDeviceExternalSemaphoreInfoKHX & externalSemaphoreInfo ) const + VULKAN_HPP_INLINE ExternalSemaphorePropertiesKHR PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR & externalSemaphoreInfo ) const { - ExternalSemaphorePropertiesKHX externalSemaphoreProperties; - vkGetPhysicalDeviceExternalSemaphorePropertiesKHX( m_physicalDevice, reinterpret_cast( &externalSemaphoreInfo ), reinterpret_cast( &externalSemaphoreProperties ) ); + ExternalSemaphorePropertiesKHR externalSemaphoreProperties; + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast( &externalSemaphoreInfo ), reinterpret_cast( &externalSemaphoreProperties ) ); return externalSemaphoreProperties; } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, ExternalFencePropertiesKHR* pExternalFenceProperties ) const + { + vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast( pExternalFenceInfo ), reinterpret_cast( pExternalFenceProperties ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ExternalFencePropertiesKHR PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR & externalFenceInfo ) const + { + ExternalFencePropertiesKHR externalFenceProperties; + vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast( &externalFenceInfo ), reinterpret_cast( &externalFenceProperties ) ); + return externalFenceProperties; + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display ) const { @@ -26723,12 +29003,51 @@ namespace vk result = static_cast( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast( surface ), &rectCount, reinterpret_cast( rects.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( rectCount <= rects.size() ); - rects.resize( rectCount ); + assert( rectCount <= rects.size() ); + rects.resize( rectCount ); return createResultValue( result, rects, "vk::PhysicalDevice::getPresentRectanglesKHX" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities ) const + { + return static_cast( vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast( pSurfaceInfo ), reinterpret_cast( pSurfaceCapabilities ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + VULKAN_HPP_INLINE ResultValueType::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const + { + SurfaceCapabilities2KHR surfaceCapabilities; + Result result = static_cast( vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), reinterpret_cast( &surfaceCapabilities ) ) ); + return createResultValue( result, surfaceCapabilities, "vk::PhysicalDevice::getSurfaceCapabilities2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats ) const + { + return static_cast( vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast( pSurfaceInfo ), pSurfaceFormatCount, reinterpret_cast( pSurfaceFormats ) ) ); + } +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const + { + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; + do + { + result = static_cast( vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + surfaceFormats.resize( surfaceFormatCount ); + result = static_cast( vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + assert( surfaceFormatCount <= surfaceFormats.size() ); + surfaceFormats.resize( surfaceFormatCount ); + return createResultValue( result, surfaceFormats, "vk::PhysicalDevice::getSurfaceFormats2KHR" ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + struct CmdProcessCommandsInfoNVX { CmdProcessCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), uint32_t indirectCommandsTokenCount_ = 0, const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr, uint32_t maxSequencesCount_ = 0, CommandBuffer targetCommandBuffer_ = CommandBuffer(), Buffer sequencesCountBuffer_ = Buffer(), DeviceSize sequencesCountOffset_ = 0, Buffer sequencesIndexBuffer_ = Buffer(), DeviceSize sequencesIndexOffset_ = 0 ) @@ -26749,15 +29068,14 @@ namespace vk CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(CmdProcessCommandsInfoNVX) ); + memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) ); } CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs ) { - memcpy( this, &rhs, sizeof(CmdProcessCommandsInfoNVX) ); + memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) ); return *this; } - CmdProcessCommandsInfoNVX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -26918,35 +29236,35 @@ namespace vk : m_instance(VK_NULL_HANDLE) {} - VULKAN_HPP_TYPESAFE_EXPLICIT Instance(VkInstance instance) - : m_instance(instance) + VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance ) + : m_instance( instance ) {} #if defined(VULKAN_HPP_TYPESAFE_CONVERSION) - Instance& operator=(VkInstance instance) + Instance & operator=(VkInstance instance) { m_instance = instance; - return *this; + return *this; } #endif - Instance& operator=( std::nullptr_t ) + Instance & operator=( std::nullptr_t ) { m_instance = VK_NULL_HANDLE; return *this; } - bool operator==(Instance const &rhs) const + bool operator==( Instance const & rhs ) const { return m_instance == rhs.m_instance; } - bool operator!=(Instance const &rhs) const + bool operator!=(Instance const & rhs ) const { return m_instance != rhs.m_instance; } - bool operator<(Instance const &rhs) const + bool operator<(Instance const & rhs ) const { return m_instance < rhs.m_instance; } @@ -27094,6 +29412,8 @@ namespace vk #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const { return m_instance; @@ -27112,6 +29432,7 @@ namespace vk private: VkInstance m_instance; }; + static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); #ifndef VULKAN_HPP_NO_SMART_HANDLE @@ -27183,8 +29504,8 @@ namespace vk result = static_cast( vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast( physicalDevices.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( physicalDeviceCount <= physicalDevices.size() ); - physicalDevices.resize( physicalDeviceCount ); + assert( physicalDeviceCount <= physicalDevices.size() ); + physicalDevices.resize( physicalDeviceCount ); return createResultValue( result, physicalDevices, "vk::Instance::enumeratePhysicalDevices" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -27428,7 +29749,7 @@ namespace vk #else if ( layerPrefix.size() != message.size() ) { - throw std::logic_error( "vk::Instance::debugReportMessageEXT: layerPrefix.size() != message.size()" ); + throw LogicError( "vk::Instance::debugReportMessageEXT: layerPrefix.size() != message.size()" ); } #endif // VULKAN_HPP_NO_EXCEPTIONS vkDebugReportMessageEXT( m_instance, static_cast( flags ), static_cast( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() ); @@ -27455,8 +29776,8 @@ namespace vk result = static_cast( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); } } while ( result == Result::eIncomplete ); - assert( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + assert( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); return createResultValue( result, physicalDeviceGroupProperties, "vk::Instance::enumeratePhysicalDeviceGroupsKHX" ); } #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -27517,15 +29838,14 @@ namespace vk DeviceGroupDeviceCreateInfoKHX( VkDeviceGroupDeviceCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupDeviceCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfoKHX ) ); } DeviceGroupDeviceCreateInfoKHX& operator=( VkDeviceGroupDeviceCreateInfoKHX const & rhs ) { - memcpy( this, &rhs, sizeof(DeviceGroupDeviceCreateInfoKHX) ); + memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfoKHX ) ); return *this; } - DeviceGroupDeviceCreateInfoKHX& setPNext( const void* pNext_ ) { pNext = pNext_; @@ -27577,11 +29897,11 @@ namespace vk using UniqueInstance = UniqueHandle; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance ); + Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance ); #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - ResultValueType::type createInstance( const InstanceCreateInfo & createInfo, Optional allocator = nullptr ); + ResultValueType::type createInstance( const InstanceCreateInfo & createInfo, Optional allocator = nullptr ); #ifndef VULKAN_HPP_NO_SMART_HANDLE - UniqueInstance createInstanceUnique( const InstanceCreateInfo & createInfo, Optional allocator = nullptr ); + UniqueInstance createInstanceUnique( const InstanceCreateInfo & createInfo, Optional allocator = nullptr ); #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ @@ -28070,6 +30390,26 @@ namespace vk return "{}"; } + VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagBitsNV) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagsNV) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagBitsNV) + { + return "(void)"; + } + + VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagsNV) + { + return "{}"; + } + VULKAN_HPP_INLINE std::string to_string(ImageLayout value) { switch (value) @@ -28084,6 +30424,7 @@ namespace vk case ImageLayout::eTransferDstOptimal: return "TransferDstOptimal"; case ImageLayout::ePreinitialized: return "Preinitialized"; case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR"; + case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR"; default: return "invalid"; } } @@ -28329,6 +30670,7 @@ namespace vk case PolygonMode::eFill: return "Fill"; case PolygonMode::eLine: return "Line"; case PolygonMode::ePoint: return "Point"; + case PolygonMode::eFillRectangleNV: return "FillRectangleNV"; default: return "invalid"; } } @@ -28402,6 +30744,52 @@ namespace vk case BlendOp::eReverseSubtract: return "ReverseSubtract"; case BlendOp::eMin: return "Min"; case BlendOp::eMax: return "Max"; + case BlendOp::eZeroEXT: return "ZeroEXT"; + case BlendOp::eSrcEXT: return "SrcEXT"; + case BlendOp::eDstEXT: return "DstEXT"; + case BlendOp::eSrcOverEXT: return "SrcOverEXT"; + case BlendOp::eDstOverEXT: return "DstOverEXT"; + case BlendOp::eSrcInEXT: return "SrcInEXT"; + case BlendOp::eDstInEXT: return "DstInEXT"; + case BlendOp::eSrcOutEXT: return "SrcOutEXT"; + case BlendOp::eDstOutEXT: return "DstOutEXT"; + case BlendOp::eSrcAtopEXT: return "SrcAtopEXT"; + case BlendOp::eDstAtopEXT: return "DstAtopEXT"; + case BlendOp::eXorEXT: return "XorEXT"; + case BlendOp::eMultiplyEXT: return "MultiplyEXT"; + case BlendOp::eScreenEXT: return "ScreenEXT"; + case BlendOp::eOverlayEXT: return "OverlayEXT"; + case BlendOp::eDarkenEXT: return "DarkenEXT"; + case BlendOp::eLightenEXT: return "LightenEXT"; + case BlendOp::eColordodgeEXT: return "ColordodgeEXT"; + case BlendOp::eColorburnEXT: return "ColorburnEXT"; + case BlendOp::eHardlightEXT: return "HardlightEXT"; + case BlendOp::eSoftlightEXT: return "SoftlightEXT"; + case BlendOp::eDifferenceEXT: return "DifferenceEXT"; + case BlendOp::eExclusionEXT: return "ExclusionEXT"; + case BlendOp::eInvertEXT: return "InvertEXT"; + case BlendOp::eInvertRgbEXT: return "InvertRgbEXT"; + case BlendOp::eLineardodgeEXT: return "LineardodgeEXT"; + case BlendOp::eLinearburnEXT: return "LinearburnEXT"; + case BlendOp::eVividlightEXT: return "VividlightEXT"; + case BlendOp::eLinearlightEXT: return "LinearlightEXT"; + case BlendOp::ePinlightEXT: return "PinlightEXT"; + case BlendOp::eHardmixEXT: return "HardmixEXT"; + case BlendOp::eHslHueEXT: return "HslHueEXT"; + case BlendOp::eHslSaturationEXT: return "HslSaturationEXT"; + case BlendOp::eHslColorEXT: return "HslColorEXT"; + case BlendOp::eHslLuminosityEXT: return "HslLuminosityEXT"; + case BlendOp::ePlusEXT: return "PlusEXT"; + case BlendOp::ePlusClampedEXT: return "PlusClampedEXT"; + case BlendOp::ePlusClampedAlphaEXT: return "PlusClampedAlphaEXT"; + case BlendOp::ePlusDarkerEXT: return "PlusDarkerEXT"; + case BlendOp::eMinusEXT: return "MinusEXT"; + case BlendOp::eMinusClampedEXT: return "MinusClampedEXT"; + case BlendOp::eContrastEXT: return "ContrastEXT"; + case BlendOp::eInvertOvgEXT: return "InvertOvgEXT"; + case BlendOp::eRedEXT: return "RedEXT"; + case BlendOp::eGreenEXT: return "GreenEXT"; + case BlendOp::eBlueEXT: return "BlueEXT"; default: return "invalid"; } } @@ -28764,6 +31152,7 @@ namespace vk case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV"; case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV"; case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV"; + case StructureType::eTextureLodGatherFormatPropertiesAMD: return "TextureLodGatherFormatPropertiesAMD"; case StructureType::eRenderPassMultiviewCreateInfoKHX: return "RenderPassMultiviewCreateInfoKHX"; case StructureType::ePhysicalDeviceMultiviewFeaturesKHX: return "PhysicalDeviceMultiviewFeaturesKHX"; case StructureType::ePhysicalDeviceMultiviewPropertiesKHX: return "PhysicalDeviceMultiviewPropertiesKHX"; @@ -28798,31 +31187,33 @@ namespace vk case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN"; case StructureType::ePhysicalDeviceGroupPropertiesKHX: return "PhysicalDeviceGroupPropertiesKHX"; case StructureType::eDeviceGroupDeviceCreateInfoKHX: return "DeviceGroupDeviceCreateInfoKHX"; - case StructureType::ePhysicalDeviceExternalImageFormatInfoKHX: return "PhysicalDeviceExternalImageFormatInfoKHX"; - case StructureType::eExternalImageFormatPropertiesKHX: return "ExternalImageFormatPropertiesKHX"; - case StructureType::ePhysicalDeviceExternalBufferInfoKHX: return "PhysicalDeviceExternalBufferInfoKHX"; - case StructureType::eExternalBufferPropertiesKHX: return "ExternalBufferPropertiesKHX"; - case StructureType::ePhysicalDeviceIdPropertiesKHX: return "PhysicalDeviceIdPropertiesKHX"; - case StructureType::ePhysicalDeviceProperties2KHX: return "PhysicalDeviceProperties2KHX"; - case StructureType::eImageFormatProperties2KHX: return "ImageFormatProperties2KHX"; - case StructureType::ePhysicalDeviceImageFormatInfo2KHX: return "PhysicalDeviceImageFormatInfo2KHX"; - case StructureType::eExternalMemoryBufferCreateInfoKHX: return "ExternalMemoryBufferCreateInfoKHX"; - case StructureType::eExternalMemoryImageCreateInfoKHX: return "ExternalMemoryImageCreateInfoKHX"; - case StructureType::eExportMemoryAllocateInfoKHX: return "ExportMemoryAllocateInfoKHX"; - case StructureType::eImportMemoryWin32HandleInfoKHX: return "ImportMemoryWin32HandleInfoKHX"; - case StructureType::eExportMemoryWin32HandleInfoKHX: return "ExportMemoryWin32HandleInfoKHX"; - case StructureType::eMemoryWin32HandlePropertiesKHX: return "MemoryWin32HandlePropertiesKHX"; - case StructureType::eImportMemoryFdInfoKHX: return "ImportMemoryFdInfoKHX"; - case StructureType::eMemoryFdPropertiesKHX: return "MemoryFdPropertiesKHX"; - case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHX: return "Win32KeyedMutexAcquireReleaseInfoKHX"; - case StructureType::ePhysicalDeviceExternalSemaphoreInfoKHX: return "PhysicalDeviceExternalSemaphoreInfoKHX"; - case StructureType::eExternalSemaphorePropertiesKHX: return "ExternalSemaphorePropertiesKHX"; - case StructureType::eExportSemaphoreCreateInfoKHX: return "ExportSemaphoreCreateInfoKHX"; - case StructureType::eImportSemaphoreWin32HandleInfoKHX: return "ImportSemaphoreWin32HandleInfoKHX"; - case StructureType::eExportSemaphoreWin32HandleInfoKHX: return "ExportSemaphoreWin32HandleInfoKHX"; - case StructureType::eD3D12FenceSubmitInfoKHX: return "D3D12FenceSubmitInfoKHX"; - case StructureType::eImportSemaphoreFdInfoKHX: return "ImportSemaphoreFdInfoKHX"; + case StructureType::ePhysicalDeviceExternalImageFormatInfoKHR: return "PhysicalDeviceExternalImageFormatInfoKHR"; + case StructureType::eExternalImageFormatPropertiesKHR: return "ExternalImageFormatPropertiesKHR"; + case StructureType::ePhysicalDeviceExternalBufferInfoKHR: return "PhysicalDeviceExternalBufferInfoKHR"; + case StructureType::eExternalBufferPropertiesKHR: return "ExternalBufferPropertiesKHR"; + case StructureType::ePhysicalDeviceIdPropertiesKHR: return "PhysicalDeviceIdPropertiesKHR"; + case StructureType::eExternalMemoryBufferCreateInfoKHR: return "ExternalMemoryBufferCreateInfoKHR"; + case StructureType::eExternalMemoryImageCreateInfoKHR: return "ExternalMemoryImageCreateInfoKHR"; + case StructureType::eExportMemoryAllocateInfoKHR: return "ExportMemoryAllocateInfoKHR"; + case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR"; + case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR"; + case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR"; + case StructureType::eMemoryGetWin32HandleInfoKHR: return "MemoryGetWin32HandleInfoKHR"; + case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR"; + case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR"; + case StructureType::eMemoryGetFdInfoKHR: return "MemoryGetFdInfoKHR"; + case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR"; + case StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR: return "PhysicalDeviceExternalSemaphoreInfoKHR"; + case StructureType::eExternalSemaphorePropertiesKHR: return "ExternalSemaphorePropertiesKHR"; + case StructureType::eExportSemaphoreCreateInfoKHR: return "ExportSemaphoreCreateInfoKHR"; + case StructureType::eImportSemaphoreWin32HandleInfoKHR: return "ImportSemaphoreWin32HandleInfoKHR"; + case StructureType::eExportSemaphoreWin32HandleInfoKHR: return "ExportSemaphoreWin32HandleInfoKHR"; + case StructureType::eD3D12FenceSubmitInfoKHR: return "D3D12FenceSubmitInfoKHR"; + case StructureType::eSemaphoreGetWin32HandleInfoKHR: return "SemaphoreGetWin32HandleInfoKHR"; + case StructureType::eImportSemaphoreFdInfoKHR: return "ImportSemaphoreFdInfoKHR"; + case StructureType::eSemaphoreGetFdInfoKHR: return "SemaphoreGetFdInfoKHR"; case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR: return "PhysicalDevicePushDescriptorPropertiesKHR"; + case StructureType::ePhysicalDevice16BitStorageFeaturesKHR: return "PhysicalDevice16BitStorageFeaturesKHR"; case StructureType::ePresentRegionsKHR: return "PresentRegionsKHR"; case StructureType::eDescriptorUpdateTemplateCreateInfoKHR: return "DescriptorUpdateTemplateCreateInfoKHR"; case StructureType::eObjectTableCreateInfoNVX: return "ObjectTableCreateInfoNVX"; @@ -28843,8 +31234,35 @@ namespace vk case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT: return "PhysicalDeviceDiscardRectanglePropertiesEXT"; case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT: return "PipelineDiscardRectangleStateCreateInfoEXT"; case StructureType::eHdrMetadataEXT: return "HdrMetadataEXT"; + case StructureType::eSharedPresentSurfaceCapabilitiesKHR: return "SharedPresentSurfaceCapabilitiesKHR"; + case StructureType::ePhysicalDeviceExternalFenceInfoKHR: return "PhysicalDeviceExternalFenceInfoKHR"; + case StructureType::eExternalFencePropertiesKHR: return "ExternalFencePropertiesKHR"; + case StructureType::eExportFenceCreateInfoKHR: return "ExportFenceCreateInfoKHR"; + case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR"; + case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR"; + case StructureType::eFenceGetWin32HandleInfoKHR: return "FenceGetWin32HandleInfoKHR"; + case StructureType::eImportFenceFdInfoKHR: return "ImportFenceFdInfoKHR"; + case StructureType::eFenceGetFdInfoKHR: return "FenceGetFdInfoKHR"; + case StructureType::ePhysicalDeviceSurfaceInfo2KHR: return "PhysicalDeviceSurfaceInfo2KHR"; + case StructureType::eSurfaceCapabilities2KHR: return "SurfaceCapabilities2KHR"; + case StructureType::eSurfaceFormat2KHR: return "SurfaceFormat2KHR"; + case StructureType::ePhysicalDeviceVariablePointerFeaturesKHR: return "PhysicalDeviceVariablePointerFeaturesKHR"; case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK"; case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK"; + case StructureType::eMemoryDedicatedRequirementsKHR: return "MemoryDedicatedRequirementsKHR"; + case StructureType::eMemoryDedicatedAllocateInfoKHR: return "MemoryDedicatedAllocateInfoKHR"; + case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT: return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT"; + case StructureType::eSamplerReductionModeCreateInfoEXT: return "SamplerReductionModeCreateInfoEXT"; + case StructureType::eBufferMemoryRequirementsInfo2KHR: return "BufferMemoryRequirementsInfo2KHR"; + case StructureType::eImageMemoryRequirementsInfo2KHR: return "ImageMemoryRequirementsInfo2KHR"; + case StructureType::eImageSparseMemoryRequirementsInfo2KHR: return "ImageSparseMemoryRequirementsInfo2KHR"; + case StructureType::eMemoryRequirements2KHR: return "MemoryRequirements2KHR"; + case StructureType::eSparseImageMemoryRequirements2KHR: return "SparseImageMemoryRequirements2KHR"; + case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT: return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT"; + case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT"; + case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT: return "PipelineColorBlendAdvancedStateCreateInfoEXT"; + case StructureType::ePipelineCoverageToColorStateCreateInfoNV: return "PipelineCoverageToColorStateCreateInfoNV"; + case StructureType::ePipelineCoverageModulationStateCreateInfoNV: return "PipelineCoverageModulationStateCreateInfoNV"; default: return "invalid"; } } @@ -28888,6 +31306,48 @@ namespace vk } } + VULKAN_HPP_INLINE std::string to_string(ObjectType value) + { + switch (value) + { + case ObjectType::eUnknown: return "Unknown"; + case ObjectType::eInstance: return "Instance"; + case ObjectType::ePhysicalDevice: return "PhysicalDevice"; + case ObjectType::eDevice: return "Device"; + case ObjectType::eQueue: return "Queue"; + case ObjectType::eSemaphore: return "Semaphore"; + case ObjectType::eCommandBuffer: return "CommandBuffer"; + case ObjectType::eFence: return "Fence"; + case ObjectType::eDeviceMemory: return "DeviceMemory"; + case ObjectType::eBuffer: return "Buffer"; + case ObjectType::eImage: return "Image"; + case ObjectType::eEvent: return "Event"; + case ObjectType::eQueryPool: return "QueryPool"; + case ObjectType::eBufferView: return "BufferView"; + case ObjectType::eImageView: return "ImageView"; + case ObjectType::eShaderModule: return "ShaderModule"; + case ObjectType::ePipelineCache: return "PipelineCache"; + case ObjectType::ePipelineLayout: return "PipelineLayout"; + case ObjectType::eRenderPass: return "RenderPass"; + case ObjectType::ePipeline: return "Pipeline"; + case ObjectType::eDescriptorSetLayout: return "DescriptorSetLayout"; + case ObjectType::eSampler: return "Sampler"; + case ObjectType::eDescriptorPool: return "DescriptorPool"; + case ObjectType::eDescriptorSet: return "DescriptorSet"; + case ObjectType::eFramebuffer: return "Framebuffer"; + case ObjectType::eCommandPool: return "CommandPool"; + case ObjectType::eSurfaceKHR: return "SurfaceKHR"; + case ObjectType::eSwapchainKHR: return "SwapchainKHR"; + case ObjectType::eDisplayKHR: return "DisplayKHR"; + case ObjectType::eDisplayModeKHR: return "DisplayModeKHR"; + case ObjectType::eDebugReportCallbackEXT: return "DebugReportCallbackEXT"; + case ObjectType::eDescriptorUpdateTemplateKHR: return "DescriptorUpdateTemplateKHR"; + case ObjectType::eObjectTableNVX: return "ObjectTableNVX"; + case ObjectType::eIndirectCommandsLayoutNVX: return "IndirectCommandsLayoutNVX"; + default: return "invalid"; + } + } + VULKAN_HPP_INLINE std::string to_string(QueueFlagBits value) { switch (value) @@ -28978,6 +31438,7 @@ namespace vk case AccessFlagBits::eMemoryWrite: return "MemoryWrite"; case AccessFlagBits::eCommandProcessReadNVX: return "CommandProcessReadNVX"; case AccessFlagBits::eCommandProcessWriteNVX: return "CommandProcessWriteNVX"; + case AccessFlagBits::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT"; default: return "invalid"; } } @@ -29005,6 +31466,7 @@ namespace vk if (value & AccessFlagBits::eMemoryWrite) result += "MemoryWrite | "; if (value & AccessFlagBits::eCommandProcessReadNVX) result += "CommandProcessReadNVX | "; if (value & AccessFlagBits::eCommandProcessWriteNVX) result += "CommandProcessWriteNVX | "; + if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT) result += "ColorAttachmentReadNoncoherentEXT | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -29238,6 +31700,7 @@ namespace vk case FormatFeatureFlagBits::eSampledImageFilterCubicIMG: return "SampledImageFilterCubicIMG"; case FormatFeatureFlagBits::eTransferSrcKHR: return "TransferSrcKHR"; case FormatFeatureFlagBits::eTransferDstKHR: return "TransferDstKHR"; + case FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT: return "SampledImageFilterMinmaxEXT"; default: return "invalid"; } } @@ -29262,6 +31725,7 @@ namespace vk if (value & FormatFeatureFlagBits::eSampledImageFilterCubicIMG) result += "SampledImageFilterCubicIMG | "; if (value & FormatFeatureFlagBits::eTransferSrcKHR) result += "TransferSrcKHR | "; if (value & FormatFeatureFlagBits::eTransferDstKHR) result += "TransferDstKHR | "; + if (value & FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) result += "SampledImageFilterMinmaxEXT | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -29641,6 +32105,8 @@ namespace vk case PresentModeKHR::eMailbox: return "Mailbox"; case PresentModeKHR::eFifo: return "Fifo"; case PresentModeKHR::eFifoRelaxed: return "FifoRelaxed"; + case PresentModeKHR::eSharedDemandRefresh: return "SharedDemandRefresh"; + case PresentModeKHR::eSharedContinuousRefresh: return "SharedContinuousRefresh"; default: return "invalid"; } } @@ -29803,22 +32269,12 @@ namespace vk case DebugReportObjectTypeEXT::eCommandPool: return "CommandPool"; case DebugReportObjectTypeEXT::eSurfaceKhr: return "SurfaceKhr"; case DebugReportObjectTypeEXT::eSwapchainKhr: return "SwapchainKhr"; - case DebugReportObjectTypeEXT::eDebugReport: return "DebugReport"; + case DebugReportObjectTypeEXT::eDebugReportCallbackExt: return "DebugReportCallbackExt"; case DebugReportObjectTypeEXT::eDisplayKhr: return "DisplayKhr"; case DebugReportObjectTypeEXT::eDisplayModeKhr: return "DisplayModeKhr"; case DebugReportObjectTypeEXT::eObjectTableNvx: return "ObjectTableNvx"; case DebugReportObjectTypeEXT::eIndirectCommandsLayoutNvx: return "IndirectCommandsLayoutNvx"; - case DebugReportObjectTypeEXT::eDescriptorUpdateTemplateKhrKHR: return "DescriptorUpdateTemplateKhrKHR"; - default: return "invalid"; - } - } - - VULKAN_HPP_INLINE std::string to_string(DebugReportErrorEXT value) - { - switch (value) - { - case DebugReportErrorEXT::eNone: return "None"; - case DebugReportErrorEXT::eCallbackRef: return "CallbackRef"; + case DebugReportObjectTypeEXT::eDescriptorUpdateTemplateKHR: return "DescriptorUpdateTemplateKHR"; default: return "invalid"; } } @@ -29882,6 +32338,7 @@ namespace vk switch (value) { case ValidationCheckEXT::eAll: return "All"; + case ValidationCheckEXT::eShaders: return "Shaders"; default: return "invalid"; } } @@ -29932,14 +32389,14 @@ namespace vk { switch (value) { - case IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenPipeline: return "VkIndirectCommandsTokenPipeline"; - case IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenDescriptorSet: return "VkIndirectCommandsTokenDescriptorSet"; - case IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenIndexBuffer: return "VkIndirectCommandsTokenIndexBuffer"; - case IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenVertexBuffer: return "VkIndirectCommandsTokenVertexBuffer"; - case IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenPushConstant: return "VkIndirectCommandsTokenPushConstant"; - case IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenDrawIndexed: return "VkIndirectCommandsTokenDrawIndexed"; - case IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenDraw: return "VkIndirectCommandsTokenDraw"; - case IndirectCommandsTokenTypeNVX::eVkIndirectCommandsTokenDispatch: return "VkIndirectCommandsTokenDispatch"; + case IndirectCommandsTokenTypeNVX::ePipeline: return "Pipeline"; + case IndirectCommandsTokenTypeNVX::eDescriptorSet: return "DescriptorSet"; + case IndirectCommandsTokenTypeNVX::eIndexBuffer: return "IndexBuffer"; + case IndirectCommandsTokenTypeNVX::eVertexBuffer: return "VertexBuffer"; + case IndirectCommandsTokenTypeNVX::ePushConstant: return "PushConstant"; + case IndirectCommandsTokenTypeNVX::eDrawIndexed: return "DrawIndexed"; + case IndirectCommandsTokenTypeNVX::eDraw: return "Draw"; + case IndirectCommandsTokenTypeNVX::eDispatch: return "Dispatch"; default: return "invalid"; } } @@ -29948,11 +32405,11 @@ namespace vk { switch (value) { - case ObjectEntryTypeNVX::eVkObjectEntryDescriptorSet: return "VkObjectEntryDescriptorSet"; - case ObjectEntryTypeNVX::eVkObjectEntryPipeline: return "VkObjectEntryPipeline"; - case ObjectEntryTypeNVX::eVkObjectEntryIndexBuffer: return "VkObjectEntryIndexBuffer"; - case ObjectEntryTypeNVX::eVkObjectEntryVertexBuffer: return "VkObjectEntryVertexBuffer"; - case ObjectEntryTypeNVX::eVkObjectEntryPushConstant: return "VkObjectEntryPushConstant"; + case ObjectEntryTypeNVX::eDescriptorSet: return "DescriptorSet"; + case ObjectEntryTypeNVX::ePipeline: return "Pipeline"; + case ObjectEntryTypeNVX::eIndexBuffer: return "IndexBuffer"; + case ObjectEntryTypeNVX::eVertexBuffer: return "VertexBuffer"; + case ObjectEntryTypeNVX::ePushConstant: return "PushConstant"; default: return "invalid"; } } @@ -29974,97 +32431,173 @@ namespace vk return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsKHR value) { switch (value) { - case ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd: return "OpaqueFd"; - case ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32: return "OpaqueWin32"; - case ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalMemoryHandleTypeFlagBitsKHX::eD3D11Texture: return "D3D11Texture"; - case ExternalMemoryHandleTypeFlagBitsKHX::eD3D11TextureKmt: return "D3D11TextureKmt"; - case ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Heap: return "D3D12Heap"; - case ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Resource: return "D3D12Resource"; + case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd"; + case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32"; + case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture: return "D3D11Texture"; + case ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt: return "D3D11TextureKmt"; + case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap: return "D3D12Heap"; + case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource: return "D3D12Resource"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsKHR value) { if (!value) return "{}"; std::string result; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueFd) result += "OpaqueFd | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D11Texture) result += "D3D11Texture | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D11TextureKmt) result += "D3D11TextureKmt | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Heap) result += "D3D12Heap | "; - if (value & ExternalMemoryHandleTypeFlagBitsKHX::eD3D12Resource) result += "D3D12Resource | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture) result += "D3D11Texture | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) result += "D3D11TextureKmt | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) result += "D3D12Heap | "; + if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) result += "D3D12Resource | "; return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsKHR value) { switch (value) { - case ExternalMemoryFeatureFlagBitsKHX::eDedicatedOnly: return "DedicatedOnly"; - case ExternalMemoryFeatureFlagBitsKHX::eExportable: return "Exportable"; - case ExternalMemoryFeatureFlagBitsKHX::eImportable: return "Importable"; + case ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly: return "DedicatedOnly"; + case ExternalMemoryFeatureFlagBitsKHR::eExportable: return "Exportable"; + case ExternalMemoryFeatureFlagBitsKHR::eImportable: return "Importable"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsKHR value) { if (!value) return "{}"; std::string result; - if (value & ExternalMemoryFeatureFlagBitsKHX::eDedicatedOnly) result += "DedicatedOnly | "; - if (value & ExternalMemoryFeatureFlagBitsKHX::eExportable) result += "Exportable | "; - if (value & ExternalMemoryFeatureFlagBitsKHX::eImportable) result += "Importable | "; + if (value & ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly) result += "DedicatedOnly | "; + if (value & ExternalMemoryFeatureFlagBitsKHR::eExportable) result += "Exportable | "; + if (value & ExternalMemoryFeatureFlagBitsKHR::eImportable) result += "Importable | "; return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagBitsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagBitsKHR value) { switch (value) { - case ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd: return "OpaqueFd"; - case ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32: return "OpaqueWin32"; - case ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalSemaphoreHandleTypeFlagBitsKHX::eD3D12Fence: return "D3D12Fence"; - case ExternalSemaphoreHandleTypeFlagBitsKHX::eFenceFd: return "FenceFd"; + case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd"; + case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32"; + case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence: return "D3D12Fence"; + case ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd: return "SyncFd"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagsKHR value) { if (!value) return "{}"; std::string result; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueFd) result += "OpaqueFd | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32) result += "OpaqueWin32 | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eD3D12Fence) result += "D3D12Fence | "; - if (value & ExternalSemaphoreHandleTypeFlagBitsKHX::eFenceFd) result += "FenceFd | "; + if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | "; + if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | "; + if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; + if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence) result += "D3D12Fence | "; + if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd) result += "SyncFd | "; return "{" + result.substr(0, result.size() - 3) + "}"; } - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagBitsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagBitsKHR value) { switch (value) { - case ExternalSemaphoreFeatureFlagBitsKHX::eExportable: return "Exportable"; - case ExternalSemaphoreFeatureFlagBitsKHX::eImportable: return "Importable"; + case ExternalSemaphoreFeatureFlagBitsKHR::eExportable: return "Exportable"; + case ExternalSemaphoreFeatureFlagBitsKHR::eImportable: return "Importable"; default: return "invalid"; } } - VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagsKHX value) + VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagsKHR value) { if (!value) return "{}"; std::string result; - if (value & ExternalSemaphoreFeatureFlagBitsKHX::eExportable) result += "Exportable | "; - if (value & ExternalSemaphoreFeatureFlagBitsKHX::eImportable) result += "Importable | "; + if (value & ExternalSemaphoreFeatureFlagBitsKHR::eExportable) result += "Exportable | "; + if (value & ExternalSemaphoreFeatureFlagBitsKHR::eImportable) result += "Importable | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagBitsKHR value) + { + switch (value) + { + case SemaphoreImportFlagBitsKHR::eTemporary: return "Temporary"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & SemaphoreImportFlagBitsKHR::eTemporary) result += "Temporary | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagBitsKHR value) + { + switch (value) + { + case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd"; + case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32"; + case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalFenceHandleTypeFlagBitsKHR::eSyncFd: return "SyncFd"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | "; + if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | "; + if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | "; + if (value & ExternalFenceHandleTypeFlagBitsKHR::eSyncFd) result += "SyncFd | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagBitsKHR value) + { + switch (value) + { + case ExternalFenceFeatureFlagBitsKHR::eExportable: return "Exportable"; + case ExternalFenceFeatureFlagBitsKHR::eImportable: return "Importable"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & ExternalFenceFeatureFlagBitsKHR::eExportable) result += "Exportable | "; + if (value & ExternalFenceFeatureFlagBitsKHR::eImportable) result += "Importable | "; + return "{" + result.substr(0, result.size() - 3) + "}"; + } + + VULKAN_HPP_INLINE std::string to_string(FenceImportFlagBitsKHR value) + { + switch (value) + { + case FenceImportFlagBitsKHR::eTemporary: return "Temporary"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(FenceImportFlagsKHR value) + { + if (!value) return "{}"; + std::string result; + if (value & FenceImportFlagBitsKHR::eTemporary) result += "Temporary | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -30072,7 +32605,7 @@ namespace vk { switch (value) { - case SurfaceCounterFlagBitsEXT::eVblankExt: return "VblankExt"; + case SurfaceCounterFlagBitsEXT::eVblank: return "Vblank"; default: return "invalid"; } } @@ -30081,7 +32614,7 @@ namespace vk { if (!value) return "{}"; std::string result; - if (value & SurfaceCounterFlagBitsEXT::eVblankExt) result += "VblankExt | "; + if (value & SurfaceCounterFlagBitsEXT::eVblank) result += "Vblank | "; return "{" + result.substr(0, result.size() - 3) + "}"; } @@ -30239,6 +32772,40 @@ namespace vk return "{" + result.substr(0, result.size() - 3) + "}"; } + VULKAN_HPP_INLINE std::string to_string(SamplerReductionModeEXT value) + { + switch (value) + { + case SamplerReductionModeEXT::eWeightedAverage: return "WeightedAverage"; + case SamplerReductionModeEXT::eMin: return "Min"; + case SamplerReductionModeEXT::eMax: return "Max"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(BlendOverlapEXT value) + { + switch (value) + { + case BlendOverlapEXT::eUncorrelated: return "Uncorrelated"; + case BlendOverlapEXT::eDisjoint: return "Disjoint"; + case BlendOverlapEXT::eConjoint: return "Conjoint"; + default: return "invalid"; + } + } + + VULKAN_HPP_INLINE std::string to_string(CoverageModulationModeNV value) + { + switch (value) + { + case CoverageModulationModeNV::eNone: return "None"; + case CoverageModulationModeNV::eRgb: return "Rgb"; + case CoverageModulationModeNV::eAlpha: return "Alpha"; + case CoverageModulationModeNV::eRgba: return "Rgba"; + default: return "invalid"; + } + } + } // namespace vk #endif