diff --git a/README.md b/README.md index 639fca1..736b0db 100644 --- a/README.md +++ b/README.md @@ -27,12 +27,162 @@ The precise ritual varies by system — consult the tomes of your operating syst Use at your own risk. If thy machine shudders, weeps, or attempts to flee — know that it was warned. \ \ -\ Thou may also conjure forth a tome of compile commands by doing thus: ``` zig build cdb ``` +## Vulkan 1.0 specification + +
+ + The present standing of thy Vulkan 1.0 specification's implementation + + +\ +⚠️ Implemented, yet perchance not fully tested nor proven conformant, but rather working in a manner most general to thee and thine. + +Name | Status +-----------------------------------------------|-------- +vkAllocateCommandBuffers | ✅ Implemented +vkAllocateDescriptorSets | ⚙️ WIP +vkAllocateMemory | ✅ Implemented +vkBeginCommandBuffer | ✅ Implemented +vkBindBufferMemory | ✅ Implemented +vkBindImageMemory | ✅ Implemented +vkCmdBeginQuery | ⚙️ WIP +vkCmdBeginRenderPass | ⚙️ WIP +vkCmdBindDescriptorSets | ⚙️ WIP +vkCmdBindIndexBuffer | ⚙️ WIP +vkCmdBindPipeline | ⚙️ WIP +vkCmdBindVertexBuffers | ⚙️ WIP +vkCmdBlitImage | ⚙️ WIP +vkCmdClearAttachments | ⚙️ WIP +vkCmdClearColorImage | ⚙️ WIP +vkCmdClearDepthStencilImage | ⚙️ WIP +vkCmdCopyBuffer | ✅ Implemented +vkCmdCopyBufferToImage | ⚙️ WIP +vkCmdCopyImage | ⚙️ WIP +vkCmdCopyImageToBuffer | ❌ Not implemented +vkCmdCopyQueryPoolResults | ❌ Not implemented +vkCmdDispatch | ❌ Not implemented +vkCmdDispatchIndirect | ❌ Not implemented +vkCmdDraw | ❌ Not implemented +vkCmdDrawIndexed | ❌ Not implemented +vkCmdDrawIndexedIndirect | ❌ Not implemented +vkCmdDrawIndirect | ❌ Not implemented +vkCmdEndQuery | ❌ Not implemented +vkCmdEndRenderPass | ❌ Not implemented +vkCmdExecuteCommands | ❌ Not implemented +vkCmdFillBuffer | ✅ Implemented +vkCmdNextSubpass | ❌ Not implemented +vkCmdPipelineBarrier | ❌ Not implemented +vkCmdPushConstants | ❌ Not implemented +vkCmdResetEvent | ❌ Not implemented +vkCmdResetQueryPool | ❌ Not implemented +vkCmdResolveImage | ❌ Not implemented +vkCmdSetBlendConstants | ❌ Not implemented +vkCmdSetDepthBias | ❌ Not implemented +vkCmdSetDepthBounds | ❌ Not implemented +vkCmdSetEvent | ❌ Not implemented +vkCmdSetLineWidth | ❌ Not implemented +vkCmdSetScissor | ❌ Not implemented +vkCmdSetStencilCompareMask | ❌ Not implemented +vkCmdSetStencilReference | ❌ Not implemented +vkCmdSetStencilWriteMask | ❌ Not implemented +vkCmdSetViewport | ❌ Not implemented +vkCmdUpdateBuffer | ❌ Not implemented +vkCmdWaitEvents | ❌ Not implemented +vkCmdWriteTimestamp | ❌ Not implemented +vkCreateBuffer | ✅ Implemented +vkCreateBufferView | ❌ Not implemented +vkCreateCommandPool | ❌ Not implemented +vkCreateComputePipelines | ❌ Not implemented +vkCreateDescriptorPool | ❌ Not implemented +vkCreateDescriptorSetLayout | ❌ Not implemented +vkCreateDevice | ✅ Implemented +vkCreateEvent | ❌ Not implemented +vkCreateFence | ✅ Implemented +vkCreateFramebuffer | ❌ Not implemented +vkCreateGraphicsPipelines | ❌ Not implemented +vkCreateImage | ✅ Implemented +vkCreateImageView | ✅ Implemented +vkCreateInstance | ✅ Implemented +vkCreatePipelineCache | ❌ Not implemented +vkCreatePipelineLayout | ❌ Not implemented +vkCreateQueryPool | ❌ Not implemented +vkCreateRenderPass | ❌ Not implemented +vkCreateSampler | ❌ Not implemented +vkCreateSemaphore | ❌ Not implemented +vkCreateShaderModule | ❌ Not implemented +vkDestroyBuffer | ✅ Implemented +vkDestroyBufferView | ❌ Not implemented +vkDestroyCommandPool | ❌ Not implemented +vkDestroyDescriptorPool | ❌ Not implemented +vkDestroyDescriptorSetLayout | ❌ Not implemented +vkDestroyDevice | ✅ Implemented +vkDestroyEvent | ❌ Not implemented +vkDestroyFence | ✅ Implemented +vkDestroyFramebuffer | ❌ Not implemented +vkDestroyImage | ✅ Implemented +vkDestroyImageView | ✅ Implemented +vkDestroyInstance | ✅ Implemented +vkDestroyPipeline | ❌ Not implemented +vkDestroyPipelineCache | ❌ Not implemented +vkDestroyPipelineLayout | ❌ Not implemented +vkDestroyQueryPool | ❌ Not implemented +vkDestroyRenderPass | ❌ Not implemented +vkDestroySampler | ❌ Not implemented +vkDestroySemaphore | ❌ Not implemented +vkDestroyShaderModule | ❌ Not implemented +vkDeviceWaitIdle | ❌ Not implemented +vkEndCommandBuffer | ✅ Implemented +vkEnumerateDeviceExtensionProperties | ⚙️ WIP +vkEnumerateDeviceLayerProperties | ⚙️ WIP +vkEnumerateInstanceExtensionProperties | ⚙️ WIP +vkEnumerateInstanceLayerProperties | ⚙️ WIP +vkEnumeratePhysicalDevices | ✅ Implemented +vkFlushMappedMemoryRanges | ❌ Not implemented +vkFreeCommandBuffers | ✅ Implemented +vkFreeDescriptorSets | ❌ Not implemented +vkFreeMemory | ✅ Implemented +vkGetBufferMemoryRequirements | ✅ Implemented +vkGetDeviceMemoryCommitment | ❌ Not implemented +vkGetDeviceProcAddr | ✅ Implemented +vkGetDeviceQueue | ✅ Implemented +vkGetEventStatus | ❌ Not implemented +vkGetFenceStatus | ✅ Implemented +vkGetImageMemoryRequirements | ✅ Implemented +vkGetImageSparseMemoryRequirements | ❌ Not implemented +vkGetImageSubresourceLayout | ❌ Not implemented +vkGetInstanceProcAddr | ✅ Implemented +vkGetPhysicalDeviceFeatures | ✅ Implemented +vkGetPhysicalDeviceFormatProperties | ⚙️ WIP +vkGetPhysicalDeviceImageFormatProperties | ⚙️ WIP +vkGetPhysicalDeviceMemoryProperties | ✅ Implemented +vkGetPhysicalDeviceProperties | ✅ Implemented +vkGetPhysicalDeviceQueueFamilyProperties | ✅ Implemented +vkGetPhysicalDeviceSparseImageFormatProperties | ⚙️ WIP +vkGetPipelineCacheData | ❌ Not implemented +vkGetQueryPoolResults | ❌ Not implemented +vkGetRenderAreaGranularity | ❌ Not implemented +vkInvalidateMappedMemoryRanges | ❌ Not implemented +vkMapMemory | ✅ Implemented +vkMergePipelineCaches | ❌ Not implemented +vkQueueBindSparse | ❌ Not implemented +vkQueueSubmit | ✅ Implemented +vkQueueWaitIdle | ✅ Implemented +vkResetCommandBuffer | ✅ Implemented +vkResetCommandPool | ❌ Not implemented +vkResetDescriptorPool | ❌ Not implemented +vkResetEvent | ❌ Not implemented +vkResetFences | ✅ Implemented +vkSetEvent | ❌ Not implemented +vkUnmapMemory | ✅ Implemented +vkUpdateDescriptorSets | ❌ Not implemented +vkWaitForFences | ✅ Implemented +
+ ## License Released unto the world as MIT for study, experimentation, and the occasional horrified whisper. diff --git a/src/soft/Executor.zig b/src/soft/Executor.zig index 40c948a..67de14a 100644 --- a/src/soft/Executor.zig +++ b/src/soft/Executor.zig @@ -39,7 +39,7 @@ fn clearColorImage(data: *const cmd.CommandClearColorImage) VkError!void { _ = range; _ = &memory_map; - std.log.scoped(.commandExecutor).warn("FIXME: implement image clear", .{}); + base.logger.fixme("Implement image clear", .{}); memory.unmap(); } diff --git a/src/soft/lib.zig b/src/soft/lib.zig index fd358cb..035ec5b 100644 --- a/src/soft/lib.zig +++ b/src/soft/lib.zig @@ -48,5 +48,17 @@ comptime { } test { - //std.testing.refAllDeclsRecursive(@This()); + std.testing.refAllDecls(base); + std.testing.refAllDecls(SoftInstance); + std.testing.refAllDecls(SoftDevice); + std.testing.refAllDecls(SoftPhysicalDevice); + std.testing.refAllDecls(SoftQueue); + std.testing.refAllDecls(SoftBuffer); + std.testing.refAllDecls(SoftCommandBuffer); + std.testing.refAllDecls(SoftCommandPool); + std.testing.refAllDecls(SoftDeviceMemory); + std.testing.refAllDecls(SoftFence); + std.testing.refAllDecls(SoftImage); + std.testing.refAllDecls(SoftImageView); + std.testing.refAllDecls(Executor); } diff --git a/src/vulkan/lib_vulkan.zig b/src/vulkan/lib_vulkan.zig index bd08643..afe18ac 100644 --- a/src/vulkan/lib_vulkan.zig +++ b/src/vulkan/lib_vulkan.zig @@ -44,6 +44,10 @@ fn entryPointNotFoundErrorLog(comptime scope: @Type(.enum_literal), name: []cons std.log.scoped(scope).err("Could not find function {s}", .{name}); } +inline fn notImplementedWarning() void { + logger.nestedFixme("function not yet implemented", .{}); +} + fn functionMapEntryPoint(comptime name: []const u8) struct { []const u8, vk.PfnVoidFunction } { // Mapping 'vkFnName' to 'strollFnName' const stroll_name = std.fmt.comptimePrint("stroll{s}", .{name[2..]}); @@ -64,9 +68,9 @@ const icd_pfn_map = std.StaticStringMap(vk.PfnVoidFunction).initComptime(.{ const global_pfn_map = std.StaticStringMap(vk.PfnVoidFunction).initComptime(.{ functionMapEntryPoint("vkCreateInstance"), - functionMapEntryPoint("vkGetInstanceProcAddr"), functionMapEntryPoint("vkEnumerateInstanceExtensionProperties"), functionMapEntryPoint("vkEnumerateInstanceVersion"), + functionMapEntryPoint("vkGetInstanceProcAddr"), }); const instance_pfn_map = std.StaticStringMap(vk.PfnVoidFunction).initComptime(.{ @@ -78,27 +82,38 @@ const instance_pfn_map = std.StaticStringMap(vk.PfnVoidFunction).initComptime(.{ const physical_device_pfn_map = std.StaticStringMap(vk.PfnVoidFunction).initComptime(.{ functionMapEntryPoint("vkCreateDevice"), functionMapEntryPoint("vkEnumerateDeviceExtensionProperties"), - functionMapEntryPoint("vkGetPhysicalDeviceFormatProperties"), functionMapEntryPoint("vkGetPhysicalDeviceFeatures"), + functionMapEntryPoint("vkGetPhysicalDeviceFormatProperties"), functionMapEntryPoint("vkGetPhysicalDeviceImageFormatProperties"), - functionMapEntryPoint("vkGetPhysicalDeviceProperties"), functionMapEntryPoint("vkGetPhysicalDeviceMemoryProperties"), + functionMapEntryPoint("vkGetPhysicalDeviceProperties"), functionMapEntryPoint("vkGetPhysicalDeviceQueueFamilyProperties"), functionMapEntryPoint("vkGetPhysicalDeviceSparseImageFormatProperties"), }); const device_pfn_map = std.StaticStringMap(vk.PfnVoidFunction).initComptime(.{ functionMapEntryPoint("vkAllocateCommandBuffers"), + functionMapEntryPoint("vkAllocateDescriptorSets"), functionMapEntryPoint("vkAllocateMemory"), functionMapEntryPoint("vkBeginCommandBuffer"), functionMapEntryPoint("vkBindBufferMemory"), functionMapEntryPoint("vkBindImageMemory"), + functionMapEntryPoint("vkCmdBeginQuery"), + functionMapEntryPoint("vkCmdBeginRenderPass"), + functionMapEntryPoint("vkCmdBindDescriptorSets"), + functionMapEntryPoint("vkCmdBindIndexBuffer"), + functionMapEntryPoint("vkCmdBindPipeline"), + functionMapEntryPoint("vkCmdBindVertexBuffers"), + functionMapEntryPoint("vkCmdBlitImage"), + functionMapEntryPoint("vkCmdClearAttachments"), functionMapEntryPoint("vkCmdClearColorImage"), + functionMapEntryPoint("vkCmdClearDepthStencilImage"), functionMapEntryPoint("vkCmdCopyBuffer"), + functionMapEntryPoint("vkCmdCopyBufferToImage"), functionMapEntryPoint("vkCmdCopyImage"), functionMapEntryPoint("vkCmdFillBuffer"), - functionMapEntryPoint("vkCreateCommandPool"), functionMapEntryPoint("vkCreateBuffer"), + functionMapEntryPoint("vkCreateCommandPool"), functionMapEntryPoint("vkCreateFence"), functionMapEntryPoint("vkCreateImage"), functionMapEntryPoint("vkCreateImageView"), @@ -116,12 +131,12 @@ const device_pfn_map = std.StaticStringMap(vk.PfnVoidFunction).initComptime(.{ functionMapEntryPoint("vkGetFenceStatus"), functionMapEntryPoint("vkGetImageMemoryRequirements"), functionMapEntryPoint("vkMapMemory"), - functionMapEntryPoint("vkUnmapMemory"), - functionMapEntryPoint("vkResetCommandBuffer"), - functionMapEntryPoint("vkResetFences"), functionMapEntryPoint("vkQueueBindSparse"), functionMapEntryPoint("vkQueueSubmit"), functionMapEntryPoint("vkQueueWaitIdle"), + functionMapEntryPoint("vkResetCommandBuffer"), + functionMapEntryPoint("vkResetFences"), + functionMapEntryPoint("vkUnmapMemory"), functionMapEntryPoint("vkWaitForFences"), }); @@ -187,11 +202,10 @@ pub export fn vkGetInstanceProcAddr(p_instance: vk.Instance, p_name: ?[*:0]const return null; } -pub export fn strollCreateInstance(p_info: ?*const vk.InstanceCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_instance: *vk.Instance) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollCreateInstance(info: *const vk.InstanceCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_instance: *vk.Instance) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkCreateInstance); defer entryPointEndLogTrace(); - const info = p_info orelse return .error_validation_failed; if (info.s_type != .instance_create_info) { return .error_validation_failed; } @@ -265,11 +279,10 @@ pub export fn strollEnumeratePhysicalDevices(p_instance: vk.Instance, count: *u3 // Physical Device functions ================================================================================================================================= -pub export fn strollCreateDevice(p_physical_device: vk.PhysicalDevice, p_info: ?*const vk.DeviceCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_device: *vk.Device) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollCreateDevice(p_physical_device: vk.PhysicalDevice, info: *const vk.DeviceCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_device: *vk.Device) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkCreateDevice); defer entryPointEndLogTrace(); - const info = p_info orelse return .error_validation_failed; if (info.s_type != .device_create_info) { return .error_validation_failed; } @@ -411,13 +424,12 @@ pub export fn strollQueueWaitIdle(p_queue: vk.Queue) callconv(vk.vulkan_call_con // Device functions ========================================================================================================================================== -pub export fn strollAllocateCommandBuffers(p_device: vk.Device, p_info: ?*const vk.CommandBufferAllocateInfo, p_cmds: [*]vk.CommandBuffer) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollAllocateCommandBuffers(p_device: vk.Device, info: *const vk.CommandBufferAllocateInfo, p_cmds: [*]vk.CommandBuffer) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkAllocateCommandBuffers); defer entryPointEndLogTrace(); Dispatchable(Device).checkHandleValidity(p_device) catch |err| return toVkResult(err); - const info = p_info orelse return .error_validation_failed; if (info.s_type != .command_buffer_allocate_info) { return .error_validation_failed; } @@ -430,11 +442,28 @@ pub export fn strollAllocateCommandBuffers(p_device: vk.Device, p_info: ?*const return .success; } -pub export fn strollAllocateMemory(p_device: vk.Device, p_info: ?*const vk.MemoryAllocateInfo, callbacks: ?*const vk.AllocationCallbacks, p_memory: *vk.DeviceMemory) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollAllocateDescriptorSets(p_device: vk.Device, info: *const vk.DescriptorSetAllocateInfo, p_set: *vk.DescriptorSet) callconv(vk.vulkan_call_conv) vk.Result { + entryPointBeginLogTrace(.vkAllocateCommandBuffers); + defer entryPointEndLogTrace(); + + if (info.s_type != .descriptor_set_allocate_info) { + return .error_validation_failed; + } + + const device = Dispatchable(Device).fromHandleObject(p_device) catch |err| return toVkResult(err); + + notImplementedWarning(); + + _ = device; + _ = p_set; + + return .success; +} + +pub export fn strollAllocateMemory(p_device: vk.Device, info: *const vk.MemoryAllocateInfo, callbacks: ?*const vk.AllocationCallbacks, p_memory: *vk.DeviceMemory) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkAllocateMemory); defer entryPointEndLogTrace(); - const info = p_info orelse return .error_validation_failed; if (info.s_type != .memory_allocate_info) { return .error_validation_failed; } @@ -479,11 +508,10 @@ pub export fn strollBindImageMemory(p_device: vk.Device, p_image: vk.Image, p_me return .success; } -pub export fn strollCreateBuffer(p_device: vk.Device, p_info: ?*const vk.BufferCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_buffer: *vk.Buffer) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollCreateBuffer(p_device: vk.Device, info: *const vk.BufferCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_buffer: *vk.Buffer) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkCreateBuffer); defer entryPointEndLogTrace(); - const info = p_info orelse return .error_validation_failed; if (info.s_type != .buffer_create_info) { return .error_validation_failed; } @@ -494,11 +522,10 @@ pub export fn strollCreateBuffer(p_device: vk.Device, p_info: ?*const vk.BufferC return .success; } -pub export fn strollCreateCommandPool(p_device: vk.Device, p_info: ?*const vk.CommandPoolCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_pool: *vk.CommandPool) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollCreateCommandPool(p_device: vk.Device, info: *const vk.CommandPoolCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_pool: *vk.CommandPool) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkCreateCommandPool); defer entryPointEndLogTrace(); - const info = p_info orelse return .error_validation_failed; if (info.s_type != .command_pool_create_info) { return .error_validation_failed; } @@ -510,11 +537,10 @@ pub export fn strollCreateCommandPool(p_device: vk.Device, p_info: ?*const vk.Co return .success; } -pub export fn strollCreateFence(p_device: vk.Device, p_info: ?*const vk.FenceCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_fence: *vk.Fence) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollCreateFence(p_device: vk.Device, info: *const vk.FenceCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_fence: *vk.Fence) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkCreateFence); defer entryPointEndLogTrace(); - const info = p_info orelse return .error_validation_failed; if (info.s_type != .fence_create_info) { return .error_validation_failed; } @@ -526,11 +552,10 @@ pub export fn strollCreateFence(p_device: vk.Device, p_info: ?*const vk.FenceCre return .success; } -pub export fn strollCreateImage(p_device: vk.Device, p_info: ?*const vk.ImageCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_image: *vk.Image) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollCreateImage(p_device: vk.Device, info: *const vk.ImageCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_image: *vk.Image) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkCreateImage); defer entryPointEndLogTrace(); - const info = p_info orelse return .error_validation_failed; if (info.s_type != .image_create_info) { return .error_validation_failed; } @@ -541,11 +566,10 @@ pub export fn strollCreateImage(p_device: vk.Device, p_info: ?*const vk.ImageCre return .success; } -pub export fn strollCreateImageView(p_device: vk.Device, p_info: ?*const vk.ImageViewCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_image_view: *vk.ImageView) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollCreateImageView(p_device: vk.Device, info: *const vk.ImageViewCreateInfo, callbacks: ?*const vk.AllocationCallbacks, p_image_view: *vk.ImageView) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkCreateImageView); defer entryPointEndLogTrace(); - const info = p_info orelse return .error_validation_failed; if (info.s_type != .image_view_create_info) { return .error_validation_failed; } @@ -762,11 +786,10 @@ pub export fn strollWaitForFences(p_device: vk.Device, count: u32, p_fences: [*] // Command Buffer functions =================================================================================================================================== -pub export fn strollBeginCommandBuffer(p_cmd: vk.CommandBuffer, p_info: ?*const vk.CommandBufferBeginInfo) callconv(vk.vulkan_call_conv) vk.Result { +pub export fn strollBeginCommandBuffer(p_cmd: vk.CommandBuffer, info: *const vk.CommandBufferBeginInfo) callconv(vk.vulkan_call_conv) vk.Result { entryPointBeginLogTrace(.vkBeginCommandBuffer); defer entryPointEndLogTrace(); - const info = p_info orelse return .error_validation_failed; if (info.s_type != .command_buffer_begin_info) { return .error_validation_failed; } @@ -775,6 +798,149 @@ pub export fn strollBeginCommandBuffer(p_cmd: vk.CommandBuffer, p_info: ?*const return .success; } +pub export fn strollCmdBeginQuery(p_cmd: vk.CommandBuffer, p_pool: vk.QueryPool, query: u32, flags: vk.QueryControlFlags) callconv(vk.vulkan_call_conv) void { + entryPointBeginLogTrace(.vkCmdBeginQuery); + defer entryPointEndLogTrace(); + + const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err); + + notImplementedWarning(); + + _ = cmd; + _ = p_pool; + _ = query; + _ = flags; +} + +pub export fn strollCmdBeginRenderPass(p_cmd: vk.CommandBuffer, info: *const vk.RenderPassBeginInfo, contents: vk.SubpassContents) callconv(vk.vulkan_call_conv) void { + entryPointBeginLogTrace(.vkCmdBeginRenderPass); + defer entryPointEndLogTrace(); + + if (info.s_type != .render_pass_begin_info) { + return errorLogger(VkError.ValidationFailed); + } + const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err); + + notImplementedWarning(); + + _ = cmd; + _ = contents; +} + +pub export fn strollCmdBindDescriptorSets( + p_cmd: vk.CommandBuffer, + bind_point: vk.PipelineBindPoint, + layout: vk.PipelineLayout, + first: u32, + count: u32, + sets: [*]const vk.DescriptorSet, + dynamic_offset_count: u32, + dynamic_offsets: [*]const u32, +) callconv(vk.vulkan_call_conv) void { + entryPointBeginLogTrace(.vkCmdBindDescriptorSets); + defer entryPointEndLogTrace(); + + const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err); + + notImplementedWarning(); + + _ = cmd; + _ = bind_point; + _ = layout; + _ = first; + _ = count; + _ = sets; + _ = dynamic_offsets; + _ = dynamic_offset_count; +} + +pub export fn strollCmdBindIndexBuffer(p_cmd: vk.CommandBuffer, p_buffer: vk.Buffer, offset: vk.DeviceSize, index_type: vk.IndexType) callconv(vk.vulkan_call_conv) void { + entryPointBeginLogTrace(.vkCmdBindIndexBuffer); + defer entryPointEndLogTrace(); + + const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err); + const buffer = NonDispatchable(Buffer).fromHandleObject(p_buffer) catch |err| return errorLogger(err); + + notImplementedWarning(); + + _ = cmd; + _ = buffer; + _ = offset; + _ = index_type; +} + +pub export fn strollCmdBindPipeline(p_cmd: vk.CommandBuffer, bind_point: vk.PipelineBindPoint, p_pipeline: vk.Pipeline) callconv(vk.vulkan_call_conv) void { + entryPointBeginLogTrace(.vkCmdBindPipeline); + defer entryPointEndLogTrace(); + + const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err); + + notImplementedWarning(); + + _ = cmd; + _ = bind_point; + _ = p_pipeline; +} + +pub export fn strollCmdBindVertexBuffers(p_cmd: vk.CommandBuffer, first: u32, count: u32, p_buffers: [*]const vk.Buffer, offsets: [*]const vk.DeviceSize) callconv(vk.vulkan_call_conv) void { + entryPointBeginLogTrace(.vkCmdBindVertexBuffer); + defer entryPointEndLogTrace(); + + const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err); + + notImplementedWarning(); + + _ = cmd; + _ = first; + _ = count; + _ = p_buffers; + _ = offsets; +} + +pub export fn strollCmdBlitImage( + p_cmd: vk.CommandBuffer, + p_src_image: vk.Image, + src_layout: vk.ImageLayout, + p_dst_image: vk.Image, + dst_layout: vk.ImageLayout, + count: u32, + regions: [*]const vk.ImageBlit, + filter: vk.Filter, +) callconv(vk.vulkan_call_conv) void { + entryPointBeginLogTrace(.vkCmdBlitImage); + defer entryPointEndLogTrace(); + + const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err); + const src = NonDispatchable(Image).fromHandleObject(p_src_image) catch |err| return errorLogger(err); + const dst = NonDispatchable(Image).fromHandleObject(p_dst_image) catch |err| return errorLogger(err); + + notImplementedWarning(); + + _ = cmd; + _ = src; + _ = src_layout; + _ = dst; + _ = dst_layout; + _ = count; + _ = regions; + _ = filter; +} + +pub export fn strollCmdClearAttachments(p_cmd: vk.CommandBuffer, attachment_count: u32, attachments: [*]const vk.ClearAttachment, rect_count: u32, rects: [*]const vk.ClearRect) callconv(vk.vulkan_call_conv) void { + entryPointBeginLogTrace(.vkCmdClearAttachments); + defer entryPointEndLogTrace(); + + const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err); + + notImplementedWarning(); + + _ = cmd; + _ = attachment_count; + _ = attachments; + _ = rect_count; + _ = rects; +} + pub export fn strollCmdClearColorImage(p_cmd: vk.CommandBuffer, p_image: vk.Image, layout: vk.ImageLayout, color: *const vk.ClearColorValue, count: u32, ranges: [*]const vk.ImageSubresourceRange) callconv(vk.vulkan_call_conv) void { entryPointBeginLogTrace(.vkCmdCopyImage); defer entryPointEndLogTrace(); @@ -784,6 +950,23 @@ pub export fn strollCmdClearColorImage(p_cmd: vk.CommandBuffer, p_image: vk.Imag cmd.clearColorImage(image, layout, color, ranges[0..count]) catch |err| return errorLogger(err); } +pub export fn strollCmdClearDepthStencilImage(p_cmd: vk.CommandBuffer, p_image: vk.Image, layout: vk.ImageLayout, stencil: *const vk.ClearDepthStencilValue, count: u32, ranges: [*]const vk.ImageSubresourceRange) callconv(vk.vulkan_call_conv) void { + entryPointBeginLogTrace(.vkCmdClearDepthStencilImage); + defer entryPointEndLogTrace(); + + const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err); + const image = NonDispatchable(Image).fromHandleObject(p_image) catch |err| return errorLogger(err); + + notImplementedWarning(); + + _ = cmd; + _ = image; + _ = layout; + _ = stencil; + _ = count; + _ = ranges; +} + pub export fn strollCmdCopyBuffer(p_cmd: vk.CommandBuffer, p_src: vk.Buffer, p_dst: vk.Buffer, count: u32, regions: [*]const vk.BufferCopy) callconv(vk.vulkan_call_conv) void { entryPointBeginLogTrace(.vkCmdCopyBuffer); defer entryPointEndLogTrace(); @@ -794,6 +977,24 @@ pub export fn strollCmdCopyBuffer(p_cmd: vk.CommandBuffer, p_src: vk.Buffer, p_d cmd.copyBuffer(src, dst, regions[0..count]) catch |err| return errorLogger(err); } +pub export fn strollCmdCopyBufferToImage(p_cmd: vk.CommandBuffer, p_src: vk.Buffer, p_dst: vk.Image, layout: vk.ImageLayout, count: u32, regions: [*]const vk.BufferImageCopy) callconv(vk.vulkan_call_conv) void { + entryPointBeginLogTrace(.vkCmdCopyBufferToImage); + defer entryPointEndLogTrace(); + + const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err); + const src = NonDispatchable(Buffer).fromHandleObject(p_src) catch |err| return errorLogger(err); + const dst = NonDispatchable(Image).fromHandleObject(p_dst) catch |err| return errorLogger(err); + + notImplementedWarning(); + + _ = cmd; + _ = src; + _ = dst; + _ = layout; + _ = count; + _ = regions; +} + pub export fn strollCmdCopyImage(p_cmd: vk.CommandBuffer, p_src: vk.Image, p_dst: vk.Image, count: u32, regions: [*]const vk.ImageCopy) callconv(vk.vulkan_call_conv) void { entryPointBeginLogTrace(.vkCmdCopyImage); defer entryPointEndLogTrace(); diff --git a/src/vulkan/logger.zig b/src/vulkan/logger.zig index 1816d2b..ae7facb 100644 --- a/src/vulkan/logger.zig +++ b/src/vulkan/logger.zig @@ -21,6 +21,7 @@ const DebugStackElement = struct { log_level: std.log.Level, }; +var indent_enabled = true; var indent_level: usize = 0; var debug_stack = std.ArrayList(DebugStackElement).empty; @@ -45,10 +46,28 @@ pub inline fn unindent() void { } } +pub inline fn enableIndent() void { + indent_enabled = true; +} + +pub inline fn disableIndent() void { + indent_enabled = false; +} + pub inline fn freeInnerDebugStack() void { debug_stack.deinit(std.heap.c_allocator); } +pub inline fn fixme(comptime format: []const u8, args: anytype) void { + disableIndent(); + defer enableIndent(); + nestedFixme(format, args); +} + +pub inline fn nestedFixme(comptime format: []const u8, args: anytype) void { + std.log.scoped(.FIXME).warn("FIXME: " ++ format, args); +} + pub fn log(comptime level: std.log.Level, comptime scope: @Type(.enum_literal), comptime format: []const u8, args: anytype) void { if (lib.getLogVerboseLevel() == .None) { return; @@ -113,8 +132,10 @@ pub fn log(comptime level: std.log.Level, comptime scope: @Type(.enum_literal), out_config.setColor(&writer, .reset) catch {}; - for (0..indent_level) |_| { - writer.print("> ", .{}) catch {}; + if (indent_enabled) { + for (0..indent_level) |_| { + writer.print("> ", .{}) catch {}; + } } writer.print(format ++ "\n", args) catch {}; writer.flush() catch return; @@ -125,7 +146,10 @@ pub fn log(comptime level: std.log.Level, comptime scope: @Type(.enum_literal), .indent_level = indent_level, .log_level = level, }; - } else { + return; + } + + if (indent_enabled) { while (debug_stack.items.len != 0) { const elem = debug_stack.orderedRemove(0); switch (elem.log_level) { @@ -133,9 +157,9 @@ pub fn log(comptime level: std.log.Level, comptime scope: @Type(.enum_literal), .warn, .err => _ = stderr_file.write(&elem.log) catch {}, } } - switch (level) { - .info, .debug => _ = stdout_file.write(&buffer) catch {}, - .warn, .err => _ = stderr_file.write(&buffer) catch {}, - } + } + switch (level) { + .info, .debug => _ = stdout_file.write(&buffer) catch {}, + .warn, .err => _ = stderr_file.write(&buffer) catch {}, } } diff --git a/test/c/main.c b/test/c/main.c index 1dc33b7..5686adb 100644 --- a/test/c/main.c +++ b/test/c/main.c @@ -23,7 +23,7 @@ #define STB_IMAGE_WRITE_IMPLEMENTATION #include -void CreateAndBindMemoryToBuffer(VkPhysicalDevice physical_device, VkDevice device, VkBuffer buffer, VkDeviceMemory* memory, VkMemoryPropertyFlags props) +VkDeviceMemory CreateAndBindMemoryToBuffer(VkPhysicalDevice physical_device, VkDevice device, VkBuffer buffer, VkMemoryPropertyFlags props) { VkMemoryRequirements requirements; vkGetBufferMemoryRequirements(device, buffer, &requirements); @@ -32,11 +32,14 @@ void CreateAndBindMemoryToBuffer(VkPhysicalDevice physical_device, VkDevice devi alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; alloc_info.allocationSize = requirements.size; alloc_info.memoryTypeIndex = kvfFindMemoryType(physical_device, requirements.memoryTypeBits, props); - kvfCheckVk(vkAllocateMemory(device, &alloc_info, NULL, memory)); - kvfCheckVk(vkBindBufferMemory(device, buffer, *memory, 0)); + + VkDeviceMemory memory; + kvfCheckVk(vkAllocateMemory(device, &alloc_info, NULL, &memory)); + kvfCheckVk(vkBindBufferMemory(device, buffer, memory, 0)); + return memory; } -void CreateAndBindMemoryToImage(VkPhysicalDevice physical_device, VkDevice device, VkImage image, VkDeviceMemory* memory, VkMemoryPropertyFlags props) +VkDeviceMemory CreateAndBindMemoryToImage(VkPhysicalDevice physical_device, VkDevice device, VkImage image, VkMemoryPropertyFlags props) { VkMemoryRequirements requirements; vkGetImageMemoryRequirements(device, image, &requirements); @@ -45,8 +48,11 @@ void CreateAndBindMemoryToImage(VkPhysicalDevice physical_device, VkDevice devic alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; alloc_info.allocationSize = requirements.size; alloc_info.memoryTypeIndex = kvfFindMemoryType(physical_device, requirements.memoryTypeBits, props); - kvfCheckVk(vkAllocateMemory(device, &alloc_info, NULL, memory)); - kvfCheckVk(vkBindImageMemory(device, image, *memory, 0)); + + VkDeviceMemory memory; + kvfCheckVk(vkAllocateMemory(device, &alloc_info, NULL, &memory)); + kvfCheckVk(vkBindImageMemory(device, image, memory, 0)); + return memory; } int main(void) @@ -82,8 +88,7 @@ int main(void) volkLoadDevice(device); VkImage image = kvfCreateImage(device, 256, 256, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, KVF_IMAGE_COLOR); - VkDeviceMemory memory; - CreateAndBindMemoryToImage(physical_device, device, image, &memory, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); + VkDeviceMemory memory = CreateAndBindMemoryToImage(physical_device, device, image, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); VkImageView image_view = kvfCreateImageView(device, image, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT, 1);