Update generated OpenCL bindings

GENERATOR_COMMIT

@@ -1 +1 @@
-3d19806aab299646becc2d1a12af0ab7839c04cf
+f127bd00e8bcccc3d5c3cf53c65aba01d7a972d3

examples/vulkan_particles/compute.v

@@ -10,12 +10,12 @@ struct Compute {
 	device   cl.DeviceId
 	count    usize
 mut:
-	context &cl.OwnedContext      = unsafe { nil }
-	queue   &cl.OwnedCommandQueue = unsafe { nil }
-	program &cl.OwnedProgram      = unsafe { nil }
-	reset   &cl.OwnedKernel       = unsafe { nil }
-	step    &cl.OwnedKernel       = unsafe { nil }
-	buffer  &cl.Buffer[f32]       = unsafe { nil }
+	context &cl.OwnedContext
+	queue   &cl.OwnedCommandQueue
+	program &cl.OwnedProgram
+	reset   &cl.OwnedKernel
+	step    &cl.OwnedKernel
+	buffer  &cl.Buffer[f32]
 }
 
 fn new_compute(count usize) !&Compute {

examples/vulkan_particles/live_sync.v

@@ -9,20 +9,24 @@ struct LiveInteropSync {
 	cl_to_vk vk.Semaphore
 	memory   cl.ExternalMemoryInterop
 mut:
-	cl_wait   &cl.OwnedExternalSemaphore = unsafe { nil }
-	cl_signal &cl.OwnedExternalSemaphore = unsafe { nil }
+	cl_wait   &cl.OwnedExternalSemaphore
+	cl_signal &cl.OwnedExternalSemaphore
 }
 
 fn create_live_interop_sync(compute &Compute, memory cl.ExternalMemoryInterop,
 	semaphores cl.ExternalSemaphoreInterop, device vk.Device, queue vk.Queue) !&LiveInteropSync {
 	mut export_info := vk.ExportSemaphoreCreateInfo{
 		handleTypes: u32(vk.ExternalSemaphoreHandleTypeFlagBits.opaque_fd)
 	}
-	info := vk.SemaphoreCreateInfo{ pNext: &export_info }
+	info := vk.SemaphoreCreateInfo{
+		pNext: &export_info
+	}
 	mut vk_to_cl := vk.Semaphore(unsafe { nil })
 	mut cl_to_vk := vk.Semaphore(unsafe { nil })
-	vk_check(vk.create_semaphore(device, &info, unsafe { nil }, &vk_to_cl), 'create live Vulkan-to-OpenCL semaphore')!
-	vk_check(vk.create_semaphore(device, &info, unsafe { nil }, &cl_to_vk), 'create live OpenCL-to-Vulkan semaphore') or {
+	vk_check(vk.create_semaphore(device, &info, unsafe { nil }, &vk_to_cl),
+		'create live Vulkan-to-OpenCL semaphore')!
+	vk_check(vk.create_semaphore(device, &info, unsafe { nil }, &cl_to_vk),
+		'create live OpenCL-to-Vulkan semaphore') or {
 		vk.destroy_semaphore(device, vk_to_cl, unsafe { nil })
 		return err
 	}
@@ -37,8 +41,10 @@ fn create_live_interop_sync(compute &Compute, memory cl.ExternalMemoryInterop,
 		semaphore:  cl_to_vk
 		handleType: .opaque_fd
 	}
-	vk_check(vk.get_semaphore_fd_khr(device, &vk_wait_fd_info, &vk_to_cl_fd), 'export live Vulkan-to-OpenCL semaphore')!
-	vk_check(vk.get_semaphore_fd_khr(device, &cl_signal_fd_info, &cl_to_vk_fd), 'export live OpenCL-to-Vulkan semaphore')!
+	vk_check(vk.get_semaphore_fd_khr(device, &vk_wait_fd_info, &vk_to_cl_fd),
+		'export live Vulkan-to-OpenCL semaphore')!
+	vk_check(vk.get_semaphore_fd_khr(device, &cl_signal_fd_info, &cl_to_vk_fd),
+		'export live OpenCL-to-Vulkan semaphore')!
 
 	mut cl_wait := semaphores.import_opaque_fd(compute.context, vk_to_cl_fd)!
 	mut cl_signal := semaphores.import_opaque_fd(compute.context, cl_to_vk_fd) or {

examples/vulkan_particles/particle_buffer.v

@@ -10,30 +10,41 @@ struct ParticleBuffer {
 	size      usize
 	zero_copy bool
 mut:
-	cl_buffer &cl.Buffer[f32] = unsafe { nil }
+	cl_buffer &cl.Buffer[f32]
 }
 
 fn create_staged_particle_buffer(physical vk.PhysicalDevice, device vk.Device, particles []f32) !&ParticleBuffer {
 	size := usize(particles.len) * sizeof(f32)
-	info := vk.BufferCreateInfo{ size: size, usage: u32(vk.BufferUsageFlagBits.vertex_buffer), sharingMode: .exclusive }
+	info := vk.BufferCreateInfo{
+		size:        size
+		usage:       u32(vk.BufferUsageFlagBits.vertex_buffer)
+		sharingMode: .exclusive
+	}
 	mut buffer := vk.Buffer(unsafe { nil })
-	vk_check(vk.create_buffer(device, &info, unsafe { nil }, &buffer), 'create particle vertex buffer')!
+	vk_check(vk.create_buffer(device, &info, unsafe { nil }, &buffer),
+		'create particle vertex buffer')!
 	mut requirements := vk.MemoryRequirements{}
 	vk.get_buffer_memory_requirements(device, buffer, mut requirements)
 	wanted := u32(vk.MemoryPropertyFlagBits.host_visible) | u32(vk.MemoryPropertyFlagBits.host_coherent)
 	memory_type := find_memory_type_with_flags(physical, requirements.memoryTypeBits, wanted)!
-	allocate := vk.MemoryAllocateInfo{ allocationSize: requirements.size, memoryTypeIndex: memory_type }
+	allocate := vk.MemoryAllocateInfo{
+		allocationSize:  requirements.size
+		memoryTypeIndex: memory_type
+	}
 	mut memory := vk.DeviceMemory(unsafe { nil })
-	vk_check(vk.allocate_memory(device, &allocate, unsafe { nil }, &memory), 'allocate particle vertex memory')!
+	vk_check(vk.allocate_memory(device, &allocate, unsafe { nil }, &memory),
+		'allocate particle vertex memory')!
 	vk_check(vk.bind_buffer_memory(device, buffer, memory, 0), 'bind particle vertex memory')!
 	mut mapped := voidptr(unsafe { nil })
-	vk_check(vk.map_memory(device, memory, 0, size, 0, &mapped), 'map particle vertex memory')!
+	vk_check(vk.map_memory(device, memory, 0, vk.DeviceSize(size), 0, &mapped),
+		'map particle vertex memory')!
 	unsafe { vmemcpy(mapped, particles.data, size) }
 	vk.unmap_memory(device, memory)
 	return &ParticleBuffer{
-		handle: buffer
-		memory: memory
-		size:   size
+		handle:    buffer
+		memory:    memory
+		size:      size
+		cl_buffer: unsafe { nil }
 	}
 }
 
@@ -50,7 +61,8 @@ fn create_zero_copy_particle_buffer(compute &Compute, memory_interop cl.External
 		sharingMode: .exclusive
 	}
 	mut buffer := vk.Buffer(unsafe { nil })
-	vk_check(vk.create_buffer(device, &info, unsafe { nil }, &buffer), 'create shared particle buffer')!
+	vk_check(vk.create_buffer(device, &info, unsafe { nil }, &buffer),
+		'create shared particle buffer')!
 	mut requirements := vk.MemoryRequirements{}
 	vk.get_buffer_memory_requirements(device, buffer, mut requirements)
 	memory_type := find_memory_type(physical, requirements.memoryTypeBits) or {
@@ -66,7 +78,8 @@ fn create_zero_copy_particle_buffer(compute &Compute, memory_interop cl.External
 		memoryTypeIndex: memory_type
 	}
 	mut memory := vk.DeviceMemory(unsafe { nil })
-	vk_check(vk.allocate_memory(device, &allocate, unsafe { nil }, &memory), 'allocate shared particle memory') or {
+	vk_check(vk.allocate_memory(device, &allocate, unsafe { nil }, &memory),
+		'allocate shared particle memory') or {
 		vk.destroy_buffer(device, buffer, unsafe { nil })
 		return err
 	}
@@ -85,7 +98,8 @@ fn create_zero_copy_particle_buffer(compute &Compute, memory_interop cl.External
 		vk.destroy_buffer(device, buffer, unsafe { nil })
 		return err
 	}
-	cl_buffer := memory_interop.import_opaque_fd_buffer[f32](compute.context, fd, int(compute.count * 8), cl.mem_read_write) or {
+	cl_buffer := memory_interop.import_opaque_fd_buffer[f32](compute.context, fd,
+		int(compute.count * 8), cl.mem_read_write) or {
 		vk.free_memory(device, memory, unsafe { nil })
 		vk.destroy_buffer(device, buffer, unsafe { nil })
 		return err
@@ -105,7 +119,8 @@ fn (buffer &ParticleBuffer) upload(device vk.Device, particles []f32) ! {
 		return error('particle upload exceeds vertex buffer')
 	}
 	mut mapped := voidptr(unsafe { nil })
-	vk_check(vk.map_memory(device, buffer.memory, 0, byte_count, 0, &mapped), 'map particle upload')!
+	vk_check(vk.map_memory(device, buffer.memory, 0, vk.DeviceSize(byte_count), 0, &mapped),
+		'map particle upload')!
 	unsafe { vmemcpy(mapped, particles.data, byte_count) }
 	vk.unmap_memory(device, buffer.memory)
 }
@@ -114,7 +129,8 @@ fn find_memory_type_with_flags(device vk.PhysicalDevice, allowed u32, wanted u32
 	mut properties := vk.PhysicalDeviceMemoryProperties{}
 	vk.get_physical_device_memory_properties(device, mut properties)
 	for index in 0 .. properties.memoryTypeCount {
-		if allowed & (u32(1) << index) != 0 && properties.memoryTypes[index].propertyFlags & wanted == wanted {
+		if allowed & (u32(1) << index) != 0
+			&& properties.memoryTypes[index].propertyFlags & wanted == wanted {
 			return index
 		}
 	}

examples/vulkan_particles/window_smoke.v

@@ -152,7 +152,10 @@ fn window_device_loop(compute &Compute, particle_count usize, use_zero_copy bool
 	mut interop_sync := if particle_buffer.zero_copy {
 		create_live_interop_sync(compute, memory_interop, semaphore_interop, device, queue)!
 	} else {
-		&LiveInteropSync{}
+		&LiveInteropSync{
+			cl_wait:   unsafe { nil }
+			cl_signal: unsafe { nil }
+		}
 	}
 	if particle_buffer.zero_copy {
 		println('Live synchronization: external Vulkan/OpenCL semaphores')