1 # -*- Mode:text; tab-width:4; electric-indent-mode: nil; indent-line-function:insert-tab; -*-
3 # types for structs and unions
5 # ###################################################################### #
7 #accessor=code template
19 public {type} get{Name}() {
25 public void set{Name}({type} {name}) {
30 public {type} get{Name}AtIndex(long i$) {
35 public void set{Name}AtIndex(long i$, {type} {name}) {
40 # Initialise the sType field if it has one, also include sub-
42 if ($tempname =~ m/write/) {
43 my $init = "{name}\$VH.set(self\$.segment, Vulkan.{values});\n";
44 foreach my $x (@{$s->{items}}) {
45 if ($x->{deref} eq 'struct') {
46 my $y = $api->{types}->{$x->{baseType}};
47 if ($#{$y->{items}} >= 0 && $y->{items}->[0]->{values}) {
48 my $z = $y->{items}->[0];
49 $init .= "self\$.get$x->{Name}().set$z->{Name}(Vulkan.$z->{values});\n";
60 if ($tempname =~ m/write.*array/n) {
61 my $init = "{name}\$AH.set(self\$.segment, i, Vulkan.{values});\n";
62 foreach my $x (@{$s->{items}}) {
63 if ($x->{deref} eq 'struct') {
64 my $y = $api->{types}->{$x->{baseType}};
65 if ($#{$y->{items}} >= 0 && $y->{items}->[0]->{values}) {
66 my $z = $y->{items}->[0];
67 $init .= "self\$.get$x->{Name}AtIndex(i).set$z->{Name}(Vulkan.$z->{values});\n";
72 "for (long i=0; i<length; i++) {\n\t$init\n\t}\n";
78 # for complex constructors
79 #setall-arg {{ {type} {name} }}
80 setall-arg {{ {type} {name} }}
81 setall {{ self$.set{Name}({name}); }}
82 setallat {{ self$.set{Name}AtIndex(index$, {name}); }}
87 /* value-array {deref} */
88 public {type} get{Name}() {
91 } catch (Throwable t) {
92 throw new RuntimeException(t);
95 public {typei} get{Name}Element(int i$) {
98 public void set{Name}Element(int i$, {typei} {name}) {
104 if ($m->{len1} <= 4) {
105 join ", ", map { '{typei} {name}$'.$_ } (0 .. $m->{len1}-1);
107 "{typei}[] {name} /* $m->{deref} $m->{len1} */";
111 if ($m->{len1} <= 4) {
112 join "\n\t", map { "self\$.set{Name}Element($_, {name}\$$_);" } (0 .. $m->{len1}-1);
115 if ({name} != null) {
117 ((MemorySegment){name}\$SH.invokeExact(self\$.segment)).copyFrom(MemorySegment.ofArray({name}));
118 } catch (Throwable t) {
119 System.err.println("Copy error: " + t.getLocalizedMessage());
127 # don't like having to pass scope here, not sure what else to do though
130 /* value-array {deref} */
131 public {type} get{Name}(VkInstance instance$, ResourceScope scope$) {
134 } catch (Throwable t) {
135 throw new RuntimeException(t);
138 public {typei} get{Name}Element(int i$, VkInstance instance$, ResourceScope scope$) {
141 public void set{Name}Element(int i$, {typei} {name}) {
149 /* value-array2d {deref} */
150 public {type} get{Name}() {
153 } catch (Throwable t) {
154 throw new RuntimeException(t);
157 public {typei} get{Name}Element(int i$, int j$) {
160 public void set{Name}Element(int i$, int j$, {typei} {name}) {
169 public {type} get{Name}() {
172 } catch (Throwable t) {
173 throw new RuntimeException(t);
179 public {type} get{Name}AtIndex(long i$) {
182 } catch (Throwable t) {
183 throw new RuntimeException(t);
189 # inline type that we also want to include expanded in initialiser
193 public {type} get{Name}() {
196 } catch (Throwable t) {
197 throw new RuntimeException(t);
203 public {type} get{Name}AtIndex(long i$) {
206 } catch (Throwable t) {
207 throw new RuntimeException(t);
213 return 0 if $m->{len1};
214 foreach my $a (@{$api->{data}->{$m->{baseType}}->{items}}) {
215 my $name = "$m->{name}\$$a->{name}";
216 if ($primitiveMap{$a->{baseType}}) {
217 push @list, "$primitiveMap{$a->{baseType}} $name";
219 my $as = $api->{data}->{$a->{baseType}};
220 foreach my $aa (@{$as->{items}}) {
221 push @list, "$primitiveMap{$aa->{baseType}} $name\$$aa->{name}";
229 return 0 if $m->{len1};
230 foreach my $a (@{$api->{data}->{$m->{baseType}}->{items}}) {
231 my $pt = $primitiveMap{$a->{baseType}};
233 push @list, 'self$.segment.set(Memory.'.uc($pt).', '
234 .(($m->{bitOffset} + $a->{bitOffset})/8).", $m->{name}\$$a->{name}".');';
236 my $as = $api->{data}->{$a->{baseType}};
237 foreach my $aa (@{$as->{items}}) {
238 $pt = $primitiveMap{$aa->{baseType}};
239 push @list, 'self$.segment.set(Memory.'.uc($pt).', '
240 .(($m->{bitOffset} + $aa->{bitOffset} + $a->{bitOffset})/8).", $m->{name}\$$a->{name}\$$aa->{name}".');';
248 return 0 if $m->{len1};
249 foreach my $a (@{$api->{data}->{$m->{baseType}}->{items}}) {
250 my $pt = $primitiveMap{$a->{baseType}};
252 push @list, 'self$.segment.set(Memory.'.uc($pt).', index$ * '.($s->{bitSize} / 8).' + '
253 .(($m->{bitOffset} + $a->{bitOffset})/8).", $m->{name}\$$a->{name}".');';
255 my $as = $api->{data}->{$a->{baseType}};
256 foreach my $aa (@{$as->{items}}) {
257 $pt = $primitiveMap{$aa->{baseType}};
258 push @list, 'self$.segment.set(Memory.'.uc($pt).', index$ * '.($s->{bitSize} / 8).' + '
259 .(($m->{bitOffset} + $aa->{bitOffset} + $a->{bitOffset})/8).", $m->{name}\$$a->{name}\$$aa->{name}".');';
267 # value with a SegmentAllocator passed to set()
268 code value-alloc value {
271 public void set{Name}({type} {name}, SegmentAllocator alloc$) {
277 public void set{Name}AtIndex(long i$, {type} {name}, SegmentAllocator alloc$) {
282 setall {{ self$.set{Name}({name}, alloc$); }}
285 # ###################################################################### #
290 public class Vulkan {
292 public static int VK_MAKE_API_VERSION(int variant, int major, int minor, int patch) {
293 return (variant << 29) | (major << 22) | (minor << 12) | patch;
301 VK_API_VERSION_1_0 {{ public final static int VK_API_VERSION_1_0 = VK_MAKE_API_VERSION(0, 1, 0, 0); }}
302 VK_API_VERSION_1_1 {{ public final static int VK_API_VERSION_1_1 = VK_MAKE_API_VERSION(0, 1, 1, 0); }}
303 VK_API_VERSION_1_2 {{ public final static int VK_API_VERSION_1_2 = VK_MAKE_API_VERSION(0, 1, 2, 0); }}
304 VK_API_VERSION_1_3 {{ public final static int VK_API_VERSION_1_3 = VK_MAKE_API_VERSION(0, 1, 3, 0); }}
309 // template: dispatch:class
311 import jdk.incubator.foreign.*;
312 import java.lang.invoke.*;
313 import au.notzed.nativez.*;
318 {Name}(VkInstance instance$, ResourceScope scope$) {
323 field-init {{ final NativeSymbol {name}$NS; }}
324 init {{ {name}$NS = instance$.vkGetInstanceProcAddr("{name}", scope$); }}
328 # non-dispatchable handle
331 // template: handle:class
333 import jdk.incubator.foreign.*;
334 import java.lang.invoke.*;
335 import au.notzed.nativez.*;
337 public class {name} implements Pointer {
338 final NativeSymbol self;
340 private {name}(MemoryAddress address, ResourceScope scope) {
341 this.self = NativeSymbol.ofAddress("{name}", address, scope);
345 public static {name} create(MemoryAddress address, ResourceScope scope) {
346 return new {name}(address, scope);
349 public static HandleArray<{name}> createArray(long length, SegmentAllocator alloc) {
350 return HandleArray.createArray(length, alloc, {name}::create);
353 public MemoryAddress address() {
354 return self.address();
357 public ResourceScope scope() {
365 code handle-instance {
367 // template: handle-instance:class
369 import jdk.incubator.foreign.*;
370 import java.lang.invoke.*;
371 import au.notzed.nativez.*;
373 public class {name} implements Pointer {
374 final NativeSymbol self;
375 final DispatchInstance dispatch;
377 private {name}(MemoryAddress address, ResourceScope scope) {
378 this.self = NativeSymbol.ofAddress("{name}", address, scope);
379 this.dispatch = new DispatchInstance(this, scope);
383 public static {name} create(MemoryAddress address, ResourceScope scope) {
384 return new {name}(address, scope);
387 public MemoryAddress address() {
388 return self.address();
391 public ResourceScope scope() {
400 # dispatchable handle
401 code handle-dispatch {
403 // template: handle-dispatch:class
405 import jdk.incubator.foreign.*;
406 import java.lang.invoke.*;
407 import au.notzed.nativez.*;
409 public class {name} implements Pointer {
410 final NativeSymbol self;
411 final DispatchInstance dispatch;
413 private {name}(MemoryAddress address, DispatchInstance dispatch, ResourceScope scope) {
414 this.self = NativeSymbol.ofAddress("{name}", address, scope);
415 this.dispatch = dispatch;
419 public static {name} create(MemoryAddress address, DispatchInstance dispatch, ResourceScope scope) {
420 return new {name}(address, dispatch, scope);
423 // TODO: evaluate how scope fits here
424 public static HandleArray<{name}> createArray(long length, SegmentAllocator alloc, DispatchInstance dispatch, ResourceScope scope) {
425 return HandleArray.createArray(length, alloc, (a, s) -> create(a, dispatch, s), scope);
428 public static HandleArray<{name}> createArray(long length, SegmentAllocator alloc, VkInstance instance, ResourceScope scope) {
429 return HandleArray.createArray(length, alloc, (a, s) -> create(a, instance.dispatch, s), scope);
432 public MemoryAddress address() {
433 return self.address();
436 public ResourceScope scope() {
445 # ###################################################################### #
447 # shared struct components
450 public MemorySegment segment;
452 public static final GroupLayout LAYOUT = {layout};
454 private {Name}(MemorySegment segment) {
455 this.segment = segment;
458 public static {Name} create(MemorySegment segment) {
459 return new {Name}(segment);
462 public static {Name} create(MemoryAddress address, ResourceScope scope) {
463 return create(MemorySegment.ofAddress(address, LAYOUT.byteSize(), scope));
466 public static {Name} create(SegmentAllocator alloc) {
467 var self$ = create(alloc.allocate(LAYOUT));
474 public MemoryAddress address() {
475 return segment.address();
480 public ResourceScope scope() {
481 return segment.scope();
485 public String toString() {
486 return Memory.toString(segment, LAYOUT);
490 public static {Name} {create}({java-setall-arguments}, SegmentAllocator alloc$) {
491 {Name} self$ = create(alloc$);
499 public void {set}({java-setall-arguments}) {
506 public void {set}AtIndex(long index$, {java-setall-arguments}) {
513 static {Name} createArray(MemoryAddress addr, long length, ResourceScope scope) {
514 return create(MemorySegment.ofAddress(addr, length * LAYOUT.byteSize(), scope));
517 public static {Name} createArray(long length, SegmentAllocator alloc) {
518 var self$ = create(alloc.allocateArray(LAYOUT, length));
523 public final static MethodHandle LAYOUT$SH = MemoryLayout.sequenceLayout(LAYOUT).sliceHandle(MemoryLayout.PathElement.sequenceElement());
527 public long length() {
528 return segment.byteSize() / LAYOUT.byteSize();
533 public {Name} getAtIndex(long index$) {
535 return create((MemorySegment)LAYOUT$SH.invokeExact(this.segment, index$));
536 } catch (Throwable t) {
537 throw new RuntimeException(t);
543 # default - writeonly struct
544 code struct-writeonly insert=struct:header,struct:create-all
545 fields=init,set,getorset,handle,java-setall {
547 // template: struct-writeonly:class
549 import jdk.incubator.foreign.*;
550 import java.lang.invoke.*;
551 import au.notzed.nativez.*;
553 public class {Name} implements Pointer {
566 code struct-writeonly-array insert=struct:header,struct:create-all,struct:array
567 fields=init,init-array,set,getorset,setat,getorsetat,handle,handleat,java-setall {
569 // template: struct-writeonly-array:class
571 import jdk.incubator.foreign.*;
572 import java.lang.invoke.*;
573 import au.notzed.nativez.*;
575 public class {Name} implements Pointer, Array<{Name}> {
593 code struct-readonly insert=struct:header
594 fields=init,get,getorset,handle {
596 // template: struct-readonly:class
598 import jdk.incubator.foreign.*;
599 import java.lang.invoke.*;
600 import au.notzed.nativez.*;
602 public class {Name} implements Pointer {
613 code struct-readonly-array insert=struct:header,struct:array
614 fields=init,init-array,get,getorset,getat,getorsetat,handle,handleat {
616 // template: struct-readonly-array:class
618 import jdk.incubator.foreign.*;
619 import java.lang.invoke.*;
620 import au.notzed.nativez.*;
622 public class {Name} implements Pointer, Array<{Name}> {
638 code struct-readwrite insert=struct:header,struct:create-all
639 fields=init,get,set,getorset,handle,java-setall {
641 // template: struct-readwrite:class
643 import jdk.incubator.foreign.*;
644 import java.lang.invoke.*;
645 import au.notzed.nativez.*;
647 public class {Name} implements Pointer {
661 code struct-readwrite-array insert=struct:header,struct:create-all,struct:array
662 fields=init,init-array,get,getat,set,setat,getorset,getorsetat,handle,handleat,java-setall {
664 // template: struct-readwrite-array:class
666 import jdk.incubator.foreign.*;
667 import java.lang.invoke.*;
668 import au.notzed.nativez.*;
670 public class {Name} implements Pointer,Array<{Name}> {
690 # read-write with a 'set' method for all members
691 code struct-readwrite-all insert=struct:header,struct:create-all,struct:set-all
692 fields=init,get,set,getorset,handle,java-setall {
694 // template: struct-readwrite-all:class
696 import jdk.incubator.foreign.*;
697 import java.lang.invoke.*;
698 import au.notzed.nativez.*;
700 public class {Name} implements Pointer {
714 code struct-readwrite-array-all insert=struct:header,struct:create-all,struct:array,struct:set-all,struct:setat-all
715 fields=init,init-array,get,getat,set,setat,setallat,getorset,getorsetat,handle,handleat,java-setall,java-setallat {
717 // template: struct-readwrite-array-all:class
719 import jdk.incubator.foreign.*;
720 import java.lang.invoke.*;
721 import au.notzed.nativez.*;
723 public class {Name} implements Pointer,Array<{Name}> {
743 # ###################################################################### #
745 # Basic value-based accessor
746 type value accessor=value {
747 native-value {{ {name} }}
749 native-get {{ ({type}){name}$VH.get(this.segment) }}
750 handle {{ final static VarHandle {name}$VH = LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("{name}")); }}
752 java-get {{ {native-get} }}
753 java-set {{ {name}$VH.set(this.segment, {native-value}) }}
755 native-getat {{ ({type}){name}$AH.get(this.segment, i$) }}
756 native-setat {{ {name}$AH.set(this.segment, i$, {native-value}) }}
757 handleat {{ final static VarHandle {name}$AH = MemoryLayout.sequenceLayout(LAYOUT).varHandle(MemoryLayout.PathElement.sequenceElement(), MemoryLayout.PathElement.groupElement("{name}")); }}
759 java-getat {{ {native-getat} }}
760 java-setat {{ {native-setat} }}
763 type value-array accessor=value-array {
764 native-get {{ (MemorySegment){name}$SH.invokeExact(this.segment) }}
765 java-get {{ {type}.create({native-get}) }}
767 native-geti {{ {name}$EH.get(this.segment, i$) }}
769 java-geti {{ ({typei}){native-geti} }}
770 java-seti {{ {name}$EH.set(this.segment, i$, {name}) }}
772 final static MethodHandle {name}$SH = LAYOUT.sliceHandle(MemoryLayout.PathElement.groupElement("{name}"));
773 final static VarHandle {name}$EH = LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("{name}"), MemoryLayout.PathElement.sequenceElement());
777 type value-array2d accessor=value-array2d {
778 native-get {{ (MemorySegment){name}$SH.invokeExact(this.segment) }}
779 java-get {{ {type}.create({native-get}) }}
780 java-geti {{ ({typei}){name}$EH.get(this.segment, i$, j$) }}
781 java-seti {{ {name}$EH.set(this.segment, i$, j$, {name}) }}
783 final static MethodHandle {name}$SH = LAYOUT.sliceHandle(MemoryLayout.PathElement.groupElement("{name}"));
784 final static VarHandle {name}$EH = LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("{name}"), MemoryLayout.PathElement.sequenceElement(), MemoryLayout.PathElement.sequenceElement());
788 type inline accessor=inline {
789 native-get {{ (MemorySegment){name}$SH.invokeExact(this.segment) }}
790 java-get {{ {type}.create({native-get}) }}
791 handle {{ final static MethodHandle {name}$SH = LAYOUT.sliceHandle(MemoryLayout.PathElement.groupElement("{name}")); }}
793 native-getat {{ (MemorySegment){name}$SA.invokeExact(this.segment, i$) }}
794 java-getat {{ {type}.create({native-getat}) }}
795 handleat {{ final static MethodHandle {name}$SA = MemoryLayout.sequenceLayout(LAYOUT).sliceHandle(MemoryLayout.PathElement.sequenceElement(), MemoryLayout.PathElement.groupElement("{name}")); }}
798 type inline-array accessor=inline {
799 native-get {{ (MemorySegment){name}$SH.invokeExact(this.segment) }}
800 java-get {{ {type}.create({native-get}) }}
801 handle {{ final static MethodHandle {name}$SH = LAYOUT.sliceHandle(MemoryLayout.PathElement.groupElement("{name}")); }}
803 native-getat {{ (MemorySegment){name}$SA.invokeExact(this.segment, i$) }}
804 java-getat {{ {type}.create({native-getat}) }}
805 handleat {{ final static MethodHandle {name}$SA = MemoryLayout.sequenceLayout(LAYOUT).sliceHandle(MemoryLayout.PathElement.sequenceElement(), MemoryLayout.PathElement.groupElement("{name}")); }}
808 type uint8_t,char value {
810 layout {{ Memory.BYTE }}
813 type uint16_t value {
815 layout {{ Memory.SHORT }}
818 type uint32_t,int,int32_t value {
820 layout {{ Memory.INT }}
823 type uint64_t,int64_t,size_t value {
825 layout {{ Memory.LONG }}
830 layout {{ Memory.FLOAT }}
835 layout {{ Memory.DOUBLE }}
838 # ###################################################################### #
840 type uint8_t[],char[] value-array {
842 layout {{ MemoryLayout.sequenceLayout({len1}, Memory.BYTE) }}
846 type uint32_t[],int32_t[] value-array {
848 layout {{ MemoryLayout.sequenceLayout({len1}, Memory.INT) }}
852 type uint64_t[] value-array {
854 layout {{ MemoryLayout.sequenceLayout({len1}, Memory.LONG) }}
858 type float[] value-array {
859 type {{ FloatArray }}
860 layout {{ MemoryLayout.sequenceLayout({len1}, Memory.FLOAT) }}
864 type struct[] inline-array {
865 type {{ {baseType} }}
866 layout {{ MemoryLayout.sequenceLayout({len1}, {baseType}.LAYOUT) }}
869 type struct-expand[] struct[] accessor=inline-expand;
871 type float[][] value-array2d {
872 type {{ FloatArray }}
874 layout {{ MemoryLayout.sequenceLayout({len1}, MemoryLayout.sequenceLayout({len2}, Memory.FLOAT)) }}
877 # select=len? or what?
880 layout {{ Memory.POINTER }}
881 type {{ MemoryAddress }}
883 native-value {{ Memory.address({name}) }}
884 native-get {{ (MemoryAddress){name}$VH.get(this.segment) }}
886 # java-get {{ {native-get} }}
887 # java-set {{ {name}$VH.set(this.segment, Memory.address({name})) }}
892 type value-pointer pointer {
893 java-get {{ {type}.create((MemoryAddress){name}$VH.get(this.segment), segment.scope()) }}
896 type uint8_t* value-pointer {
900 type uint32_t*,int32_t*,int* value-pointer {
904 type uint64_t* value-pointer {
908 type float* value-pointer {
912 type size_t* value-pointer {
916 type pointer-length pointer {
917 java-get {{ {type}.createArray({native-get}, {length}, this.segment.scope()) }}
920 type void*-length pointer-length {
922 java-get {{ MemorySegment.ofAddress({native-get}, {length}, this.segment.scope()) }}
925 type uint8_t*-length pointer-length {
929 type uint32_t*-length,int32_t*-length pointer-length {
933 type uint64_t*-length pointer-length {
937 type float*-length pointer-length {
941 # special handling for strings, will fail if it isn't
942 type char* pointer accessor=value-alloc {
945 java-get {{ ({native-get}).getUtf8String(0) }}
946 native-value {{ alloc$.allocateUtf8String({name}).address() }}
948 # this just verifies it's a string type
950 if ($v->{len} =~ m/null-terminated/) {
959 type char**-length pointer-length accessor=value-alloc {
962 java-set {{ {name}$VH.set(this.segment, Memory.copyStringArray({name}, alloc$).address()); }}
963 java-get {{ Memory.copyStringArray((MemoryAddress){name}$VH.get(this.segment), {length}) }}
966 type funcpointer pointer {
967 type {{ FunctionPointer<{baseType}> }}
968 typei {{ {baseType} }}
969 java-get {{ {baseType}.downcall({native-get}, this.segment.scope()) }}
972 type void** pointer {
975 type void**-length pointer-length {
979 type handle pointer {
980 type {{ {baseType} }}
981 java-get {{ {type}.create({native-get}, this.segment.scope()) }}
984 type handle[] value-array accessor=handle-array {
985 type {{ HandleArray<{typei}> }}
986 typei {{ {baseType} }}
987 layout {{ MemoryLayout.sequenceLayout({len1}, Memory.POINTER) }}
988 java-get {{ HandleArray.create({native-get}, (a, s) -> {typei}.create(a, instance$.dispatch, s), scope$) }}
990 java-geti {{ {typei}.create((MemoryAddress){native-geti}, instance$.dispatch, scope$) }}
993 type handle* pointer {
994 type {{ HandleArray<{typei}> }}
995 typei {{ {baseType} }}
996 java-get {{ HandleArray.create({native-get}, {typei}::create) }}
999 type handle*-length pointer-length {
1000 type {{ HandleArray<{baseType}> }}
1001 typei {{ {baseType} }}
1002 java-get {{ HandleArray.createArray({native-get}, {length}, {typei}::create, this.segment.scope()) }}
1003 java-set {{ {name}$VH.set(this.segment, Memory.address({name})); }}
1006 type struct inline {
1007 type {{ {baseType} }}
1008 layout {{ {baseType}.LAYOUT }}
1011 type struct-expand inline accessor=inline-expand {
1012 type {{ {baseType} }}
1013 layout {{ {baseType}.LAYOUT }}
1016 type struct* pointer {
1017 type {{ {baseType} }}
1018 java-get {{ {baseType}.create({native-get}, this.segment.scope()) }}
1021 type struct*-length pointer-length {
1022 type {{ {baseType} }}
1023 typei {{ {baseType} }}
1026 type struct** pointer {
1030 type XID,Window,VisualID uint64_t;
1032 type Display* handle {
1037 type xcb_window_t uint32_t;
1038 type xcb_visualid_t uint32_t;
1039 type xcb_connection_t* handle {
1040 type xcb.Connection;
1044 VkInstance template=handle-instance;
1045 VkPhysicalDevice template=handle-dispatch;
1046 VkDevice template=handle-dispatch;
1047 VkCommandBuffer template=handle-dispatch;
1048 VkQueue template=handle-dispatch;
1050 VkAllocationCallbacks ignore;
1052 # We want 'set(all fields) for these types and to include them expanded if inline
1053 VkOffset2D expand template=struct-readwrite-array-all;
1054 VkOffset3D expand template=struct-readwrite-array-all;
1055 VkExtent2D expand template=struct-readwrite-all;
1056 VkExtent3D expand template=struct-readwrite-all;
1057 VkRect2D expand template=struct-readwrite-array-all;
1059 VkStencilOpState template=struct-readwrite-all;
1060 VkComponentMapping template=struct-readwrite-all;
1061 VkImageSubresourceRange template=struct-readwrite-all;
1063 VkClearColorValue expand template=struct-readwrite-all;
1064 VkClearDepthStencilValue expand template=struct-readwrite-all;
1066 # Override default read/write
1067 VkDebugUtilsMessengerCallbackDataEXT template=struct-readonly;
1068 VkDebugUtilsLabelEXT template=struct-readonly-array;
1069 VkDebugUtilsObjectNameInfoEXT template=struct-readonly-array;
1071 # can't really work out what this is it's a void ** but it stays it's a pointer to uint8_t * in the spec
1072 VkCuLaunchInfoNVX pParams=type:pointer pExtras=type:pointer;