From 08d0e3719a9529b626921be429ff696458ac2998 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 23 Sep 2026 17:09:39 +0000 Subject: [PATCH] Update generated OpenCL bindings --- GENERATOR_COMMIT | 2 +- examples/vulkan_particles/compute.v | 12 +++--- examples/vulkan_particles/live_sync.v | 20 ++++++---- examples/vulkan_particles/particle_buffer.v | 44 ++++++++++++++------- examples/vulkan_particles/window_smoke.v | 5 ++- 5 files changed, 54 insertions(+), 29 deletions(-) diff --git a/GENERATOR_COMMIT b/GENERATOR_COMMIT index 1194875..461d990 100644 --- a/GENERATOR_COMMIT +++ b/GENERATOR_COMMIT @@ -1 +1 @@ -3d19806aab299646becc2d1a12af0ab7839c04cf +f127bd00e8bcccc3d5c3cf53c65aba01d7a972d3 diff --git a/examples/vulkan_particles/compute.v b/examples/vulkan_particles/compute.v index 88d24ed..8a477a7 100644 --- a/examples/vulkan_particles/compute.v +++ b/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 { diff --git a/examples/vulkan_particles/live_sync.v b/examples/vulkan_particles/live_sync.v index bb1ec13..de61483 100644 --- a/examples/vulkan_particles/live_sync.v +++ b/examples/vulkan_particles/live_sync.v @@ -9,8 +9,8 @@ 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, @@ -18,11 +18,15 @@ fn create_live_interop_sync(compute &Compute, memory cl.ExternalMemoryInterop, 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 { diff --git a/examples/vulkan_particles/particle_buffer.v b/examples/vulkan_particles/particle_buffer.v index 426140f..256ec5f 100644 --- a/examples/vulkan_particles/particle_buffer.v +++ b/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 } } diff --git a/examples/vulkan_particles/window_smoke.v b/examples/vulkan_particles/window_smoke.v index a283032..845f697 100644 --- a/examples/vulkan_particles/window_smoke.v +++ b/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')