From 6c9133bc24fe1238a4063f2f57b18c952ec0a800 Mon Sep 17 00:00:00 2001 From: antlilja Date: Tue, 27 Jun 2023 13:09:34 +0200 Subject: [PATCH] Remove type param from cast builtins --- examples/graphics_context.zig | 10 +++--- examples/swapchain.zig | 16 +++++----- examples/triangle.zig | 60 +++++++++++++++++------------------ 3 files changed, 43 insertions(+), 43 deletions(-) diff --git a/examples/graphics_context.zig b/examples/graphics_context.zig index 12e90ee..fdfae55 100644 --- a/examples/graphics_context.zig +++ b/examples/graphics_context.zig @@ -112,7 +112,7 @@ pub const GraphicsContext = struct { self.instance = try self.vkb.createInstance(&.{ .p_application_info = &app_info, .enabled_extension_count = glfw_exts_count, - .pp_enabled_extension_names = @ptrCast([*]const [*:0]const u8, glfw_exts), + .pp_enabled_extension_names = @as([*]const [*:0]const u8, @ptrCast(glfw_exts)), }, null); self.vki = try InstanceDispatch.load(self.instance, self.vkb.dispatch.vkGetInstanceProcAddr); @@ -148,8 +148,8 @@ pub const GraphicsContext = struct { pub fn findMemoryTypeIndex(self: GraphicsContext, memory_type_bits: u32, flags: vk.MemoryPropertyFlags) !u32 { for (self.mem_props.memory_types[0..self.mem_props.memory_type_count], 0..) |mem_type, i| { - if (memory_type_bits & (@as(u32, 1) << @truncate(u5, i)) != 0 and mem_type.property_flags.contains(flags)) { - return @truncate(u32, i); + if (memory_type_bits & (@as(u32, 1) << @truncate(i)) != 0 and mem_type.property_flags.contains(flags)) { + return @truncate(i); } } @@ -209,7 +209,7 @@ fn initializeCandidate(vki: InstanceDispatch, candidate: DeviceCandidate) !vk.De .queue_create_info_count = queue_count, .p_queue_create_infos = &qci, .enabled_extension_count = required_device_extensions.len, - .pp_enabled_extension_names = @ptrCast([*]const [*:0]const u8, &required_device_extensions), + .pp_enabled_extension_names = @as([*]const [*:0]const u8, @ptrCast(&required_device_extensions)), }, null); } @@ -286,7 +286,7 @@ fn allocateQueues(vki: InstanceDispatch, pdev: vk.PhysicalDevice, allocator: All var present_family: ?u32 = null; for (families, 0..) |properties, i| { - const family = @intCast(u32, i); + const family: u32 = @intCast(i); if (graphics_family == null and properties.queue_flags.graphics_bit) { graphics_family = family; diff --git a/examples/swapchain.zig b/examples/swapchain.zig index 3d78de5..fc2972c 100644 --- a/examples/swapchain.zig +++ b/examples/swapchain.zig @@ -150,27 +150,27 @@ pub const Swapchain = struct { // Step 1: Make sure the current frame has finished rendering const current = self.currentSwapImage(); try current.waitForFence(self.gc); - try self.gc.vkd.resetFences(self.gc.dev, 1, @ptrCast([*]const vk.Fence, ¤t.frame_fence)); + try self.gc.vkd.resetFences(self.gc.dev, 1, @ptrCast(¤t.frame_fence)); // Step 2: Submit the command buffer const wait_stage = [_]vk.PipelineStageFlags{.{ .top_of_pipe_bit = true }}; try self.gc.vkd.queueSubmit(self.gc.graphics_queue.handle, 1, &[_]vk.SubmitInfo{.{ .wait_semaphore_count = 1, - .p_wait_semaphores = @ptrCast([*]const vk.Semaphore, ¤t.image_acquired), + .p_wait_semaphores = @ptrCast(¤t.image_acquired), .p_wait_dst_stage_mask = &wait_stage, .command_buffer_count = 1, - .p_command_buffers = @ptrCast([*]const vk.CommandBuffer, &cmdbuf), + .p_command_buffers = @ptrCast(&cmdbuf), .signal_semaphore_count = 1, - .p_signal_semaphores = @ptrCast([*]const vk.Semaphore, ¤t.render_finished), + .p_signal_semaphores = @ptrCast(¤t.render_finished), }}, current.frame_fence); // Step 3: Present the current frame _ = try self.gc.vkd.queuePresentKHR(self.gc.present_queue.handle, &.{ .wait_semaphore_count = 1, - .p_wait_semaphores = @ptrCast([*]const vk.Semaphore, ¤t.render_finished), + .p_wait_semaphores = @as([*]const vk.Semaphore, @ptrCast(¤t.render_finished)), .swapchain_count = 1, - .p_swapchains = @ptrCast([*]const vk.SwapchainKHR, &self.handle), - .p_image_indices = @ptrCast([*]const u32, &self.image_index), + .p_swapchains = @as([*]const vk.SwapchainKHR, @ptrCast(&self.handle)), + .p_image_indices = @as([*]const u32, @ptrCast(&self.image_index)), }); // Step 4: Acquire next frame @@ -243,7 +243,7 @@ const SwapImage = struct { } fn waitForFence(self: SwapImage, gc: *const GraphicsContext) !void { - _ = try gc.vkd.waitForFences(gc.dev, 1, @ptrCast([*]const vk.Fence, &self.frame_fence), vk.TRUE, std.math.maxInt(u64)); + _ = try gc.vkd.waitForFences(gc.dev, 1, @ptrCast(&self.frame_fence), vk.TRUE, std.math.maxInt(u64)); } }; diff --git a/examples/triangle.zig b/examples/triangle.zig index 7e144e9..8d8f6be 100644 --- a/examples/triangle.zig +++ b/examples/triangle.zig @@ -53,8 +53,8 @@ pub fn main() !void { c.glfwWindowHint(c.GLFW_CLIENT_API, c.GLFW_NO_API); const window = c.glfwCreateWindow( - @intCast(c_int, extent.width), - @intCast(c_int, extent.height), + @intCast(extent.width), + @intCast(extent.height), app_name, null, null, @@ -133,9 +133,9 @@ pub fn main() !void { var h: c_int = undefined; c.glfwGetWindowSize(window, &w, &h); - if (state == .suboptimal or extent.width != @intCast(u32, w) or extent.height != @intCast(u32, h)) { - extent.width = @intCast(u32, w); - extent.height = @intCast(u32, h); + if (state == .suboptimal or extent.width != @as(u32, @intCast(w)) or extent.height != @as(u32, @intCast(h))) { + extent.width = @intCast(w); + extent.height = @intCast(h); try swapchain.recreate(extent); destroyFramebuffers(&gc, allocator, framebuffers); @@ -176,7 +176,7 @@ fn uploadVertices(gc: *const GraphicsContext, pool: vk.CommandPool, buffer: vk.B const data = try gc.vkd.mapMemory(gc.dev, staging_memory, 0, vk.WHOLE_SIZE, .{}); defer gc.vkd.unmapMemory(gc.dev, staging_memory); - const gpu_vertices = @ptrCast([*]Vertex, @alignCast(@alignOf(Vertex), data)); + const gpu_vertices: [*]Vertex = @ptrCast(@alignCast(data)); for (vertices, 0..) |vertex, i| { gpu_vertices[i] = vertex; } @@ -191,8 +191,8 @@ fn copyBuffer(gc: *const GraphicsContext, pool: vk.CommandPool, dst: vk.Buffer, .command_pool = pool, .level = .primary, .command_buffer_count = 1, - }, @ptrCast([*]vk.CommandBuffer, &cmdbuf)); - defer gc.vkd.freeCommandBuffers(gc.dev, pool, 1, @ptrCast([*]const vk.CommandBuffer, &cmdbuf)); + }, @ptrCast(&cmdbuf)); + defer gc.vkd.freeCommandBuffers(gc.dev, pool, 1, @ptrCast(&cmdbuf)); try gc.vkd.beginCommandBuffer(cmdbuf, &.{ .flags = .{ .one_time_submit_bit = true }, @@ -203,16 +203,16 @@ fn copyBuffer(gc: *const GraphicsContext, pool: vk.CommandPool, dst: vk.Buffer, .dst_offset = 0, .size = size, }; - gc.vkd.cmdCopyBuffer(cmdbuf, src, dst, 1, @ptrCast([*]const vk.BufferCopy, ®ion)); + gc.vkd.cmdCopyBuffer(cmdbuf, src, dst, 1, @ptrCast(®ion)); try gc.vkd.endCommandBuffer(cmdbuf); const si = vk.SubmitInfo{ .command_buffer_count = 1, - .p_command_buffers = @ptrCast([*]const vk.CommandBuffer, &cmdbuf), + .p_command_buffers = @ptrCast(&cmdbuf), .p_wait_dst_stage_mask = undefined, }; - try gc.vkd.queueSubmit(gc.graphics_queue.handle, 1, @ptrCast([*]const vk.SubmitInfo, &si), .null_handle); + try gc.vkd.queueSubmit(gc.graphics_queue.handle, 1, @ptrCast(&si), .null_handle); try gc.vkd.queueWaitIdle(gc.graphics_queue.handle); } @@ -232,9 +232,9 @@ fn createCommandBuffers( try gc.vkd.allocateCommandBuffers(gc.dev, &.{ .command_pool = pool, .level = .primary, - .command_buffer_count = @truncate(u32, cmdbufs.len), + .command_buffer_count = @as(u32, @truncate(cmdbufs.len)), }, cmdbufs.ptr); - errdefer gc.vkd.freeCommandBuffers(gc.dev, pool, @truncate(u32, cmdbufs.len), cmdbufs.ptr); + errdefer gc.vkd.freeCommandBuffers(gc.dev, pool, @truncate(cmdbufs.len), cmdbufs.ptr); const clear = vk.ClearValue{ .color = .{ .float_32 = .{ 0, 0, 0, 1 } }, @@ -243,8 +243,8 @@ fn createCommandBuffers( const viewport = vk.Viewport{ .x = 0, .y = 0, - .width = @floatFromInt(f32, extent.width), - .height = @floatFromInt(f32, extent.height), + .width = @as(f32, @floatFromInt(extent.width)), + .height = @as(f32, @floatFromInt(extent.height)), .min_depth = 0, .max_depth = 1, }; @@ -257,8 +257,8 @@ fn createCommandBuffers( for (cmdbufs, framebuffers) |cmdbuf, framebuffer| { try gc.vkd.beginCommandBuffer(cmdbuf, &.{}); - gc.vkd.cmdSetViewport(cmdbuf, 0, 1, @ptrCast([*]const vk.Viewport, &viewport)); - gc.vkd.cmdSetScissor(cmdbuf, 0, 1, @ptrCast([*]const vk.Rect2D, &scissor)); + gc.vkd.cmdSetViewport(cmdbuf, 0, 1, @ptrCast(&viewport)); + gc.vkd.cmdSetScissor(cmdbuf, 0, 1, @ptrCast(&scissor)); // This needs to be a separate definition - see https://github.com/ziglang/zig/issues/7627. const render_area = vk.Rect2D{ @@ -271,12 +271,12 @@ fn createCommandBuffers( .framebuffer = framebuffer, .render_area = render_area, .clear_value_count = 1, - .p_clear_values = @ptrCast([*]const vk.ClearValue, &clear), + .p_clear_values = @as([*]const vk.ClearValue, @ptrCast(&clear)), }, .@"inline"); gc.vkd.cmdBindPipeline(cmdbuf, .graphics, pipeline); const offset = [_]vk.DeviceSize{0}; - gc.vkd.cmdBindVertexBuffers(cmdbuf, 0, 1, @ptrCast([*]const vk.Buffer, &buffer), &offset); + gc.vkd.cmdBindVertexBuffers(cmdbuf, 0, 1, @ptrCast(&buffer), &offset); gc.vkd.cmdDraw(cmdbuf, vertices.len, 1, 0, 0); gc.vkd.cmdEndRenderPass(cmdbuf); @@ -287,7 +287,7 @@ fn createCommandBuffers( } fn destroyCommandBuffers(gc: *const GraphicsContext, pool: vk.CommandPool, allocator: Allocator, cmdbufs: []vk.CommandBuffer) void { - gc.vkd.freeCommandBuffers(gc.dev, pool, @truncate(u32, cmdbufs.len), cmdbufs.ptr); + gc.vkd.freeCommandBuffers(gc.dev, pool, @truncate(cmdbufs.len), cmdbufs.ptr); allocator.free(cmdbufs); } @@ -302,7 +302,7 @@ fn createFramebuffers(gc: *const GraphicsContext, allocator: Allocator, render_p fb.* = try gc.vkd.createFramebuffer(gc.dev, &.{ .render_pass = render_pass, .attachment_count = 1, - .p_attachments = @ptrCast([*]const vk.ImageView, &swapchain.swap_images[i].view), + .p_attachments = @as([*]const vk.ImageView, @ptrCast(&swapchain.swap_images[i].view)), .width = swapchain.extent.width, .height = swapchain.extent.height, .layers = 1, @@ -338,14 +338,14 @@ fn createRenderPass(gc: *const GraphicsContext, swapchain: Swapchain) !vk.Render const subpass = vk.SubpassDescription{ .pipeline_bind_point = .graphics, .color_attachment_count = 1, - .p_color_attachments = @ptrCast([*]const vk.AttachmentReference, &color_attachment_ref), + .p_color_attachments = @ptrCast(&color_attachment_ref), }; return try gc.vkd.createRenderPass(gc.dev, &.{ .attachment_count = 1, - .p_attachments = @ptrCast([*]const vk.AttachmentDescription, &color_attachment), + .p_attachments = @as([*]const vk.AttachmentDescription, @ptrCast(&color_attachment)), .subpass_count = 1, - .p_subpasses = @ptrCast([*]const vk.SubpassDescription, &subpass), + .p_subpasses = @as([*]const vk.SubpassDescription, @ptrCast(&subpass)), }, null); } @@ -356,13 +356,13 @@ fn createPipeline( ) !vk.Pipeline { const vert = try gc.vkd.createShaderModule(gc.dev, &.{ .code_size = shaders.triangle_vert.len, - .p_code = @ptrCast([*]const u32, &shaders.triangle_vert), + .p_code = @as([*]const u32, @ptrCast(&shaders.triangle_vert)), }, null); defer gc.vkd.destroyShaderModule(gc.dev, vert, null); const frag = try gc.vkd.createShaderModule(gc.dev, &.{ .code_size = shaders.triangle_frag.len, - .p_code = @ptrCast([*]const u32, &shaders.triangle_frag), + .p_code = @as([*]const u32, @ptrCast(&shaders.triangle_frag)), }, null); defer gc.vkd.destroyShaderModule(gc.dev, frag, null); @@ -381,7 +381,7 @@ fn createPipeline( const pvisci = vk.PipelineVertexInputStateCreateInfo{ .vertex_binding_description_count = 1, - .p_vertex_binding_descriptions = @ptrCast([*]const vk.VertexInputBindingDescription, &Vertex.binding_description), + .p_vertex_binding_descriptions = @ptrCast(&Vertex.binding_description), .vertex_attribute_description_count = Vertex.attribute_description.len, .p_vertex_attribute_descriptions = &Vertex.attribute_description, }; @@ -434,7 +434,7 @@ fn createPipeline( .logic_op_enable = vk.FALSE, .logic_op = .copy, .attachment_count = 1, - .p_attachments = @ptrCast([*]const vk.PipelineColorBlendAttachmentState, &pcbas), + .p_attachments = @ptrCast(&pcbas), .blend_constants = [_]f32{ 0, 0, 0, 0 }, }; @@ -470,9 +470,9 @@ fn createPipeline( gc.dev, .null_handle, 1, - @ptrCast([*]const vk.GraphicsPipelineCreateInfo, &gpci), + @ptrCast(&gpci), null, - @ptrCast([*]vk.Pipeline, &pipeline), + @ptrCast(&pipeline), ); return pipeline; }