yes

src/vulkan/CommandBuffer.zig

@@ -69,7 +69,11 @@ pub const DispatchTable = struct {
     resetEvent: *const fn (*Self, *Event, vk.PipelineStageFlags) VkError!void,
     resolveImage: *const fn (*Self, *Image, vk.ImageLayout, *Image, vk.ImageLayout, vk.ImageResolve) VkError!void,
     setEvent: *const fn (*Self, *Event, vk.PipelineStageFlags) VkError!void,
+    setBlendConstants: *const fn (*Self, [4]f32) VkError!void,
     setScissor: *const fn (*Self, u32, []const vk.Rect2D) VkError!void,
+    setStencilCompareMask: *const fn (*Self, vk.StencilFaceFlags, u32) VkError!void,
+    setStencilReference: *const fn (*Self, vk.StencilFaceFlags, u32) VkError!void,
+    setStencilWriteMask: *const fn (*Self, vk.StencilFaceFlags, u32) VkError!void,
     setViewport: *const fn (*Self, u32, []const vk.Viewport) VkError!void,
     waitEvent: *const fn (*Self, *Event, vk.PipelineStageFlags, vk.PipelineStageFlags, []const vk.MemoryBarrier, []const vk.BufferMemoryBarrier, []const vk.ImageMemoryBarrier) VkError!void,
 };
@@ -162,8 +166,10 @@ pub inline fn beginRenderPass(self: *Self, render_pass: *RenderPass, framebuffer
 }
 
 pub fn bindDescriptorSets(self: *Self, bind_point: vk.PipelineBindPoint, first_set: u32, sets: []const vk.DescriptorSet, dynamic_offsets: []const u32) VkError!void {
-    std.debug.assert(sets.len < lib.VULKAN_MAX_DESCRIPTOR_SETS);
-    var inner_sets = [_]?*DescriptorSet{null} ** lib.VULKAN_MAX_DESCRIPTOR_SETS;
+    if (sets.len > lib.VULKAN_MAX_DESCRIPTOR_SETS or first_set > lib.VULKAN_MAX_DESCRIPTOR_SETS or first_set + sets.len > lib.VULKAN_MAX_DESCRIPTOR_SETS)
+        return VkError.ValidationFailed;
+
+    var inner_sets: [lib.VULKAN_MAX_DESCRIPTOR_SETS]?*DescriptorSet = @splat(null);
     for (sets, inner_sets[0..sets.len]) |set, *inner_set| {
         inner_set.* = try NonDispatchable(DescriptorSet).fromHandleObject(set);
     }
@@ -288,10 +294,26 @@ pub inline fn setEvent(self: *Self, event: *Event, stage: vk.PipelineStageFlags)
     try self.dispatch_table.setEvent(self, event, stage);
 }
 
+pub inline fn setBlendConstants(self: *Self, constants: [4]f32) VkError!void {
+    try self.dispatch_table.setBlendConstants(self, constants);
+}
+
 pub inline fn setScissor(self: *Self, first: u32, scissor: []const vk.Rect2D) VkError!void {
     try self.dispatch_table.setScissor(self, first, scissor);
 }
 
+pub inline fn setStencilCompareMask(self: *Self, face_mask: vk.StencilFaceFlags, compare_mask: u32) VkError!void {
+    try self.dispatch_table.setStencilCompareMask(self, face_mask, compare_mask);
+}
+
+pub inline fn setStencilReference(self: *Self, face_mask: vk.StencilFaceFlags, reference: u32) VkError!void {
+    try self.dispatch_table.setStencilReference(self, face_mask, reference);
+}
+
+pub inline fn setStencilWriteMask(self: *Self, face_mask: vk.StencilFaceFlags, write_mask: u32) VkError!void {
+    try self.dispatch_table.setStencilWriteMask(self, face_mask, write_mask);
+}
+
 pub inline fn setViewport(self: *Self, first: u32, viewports: []const vk.Viewport) VkError!void {
     try self.dispatch_table.setViewport(self, first, viewports);
 }

src/vulkan/Pipeline.zig

@@ -48,6 +48,11 @@ mode: union(enum) {
             front_face: vk.FrontFace,
             line_width: f32,
         },
+        color_blend: struct {
+            attachments: ?[]vk.PipelineColorBlendAttachmentState,
+            constants: [4]f32,
+        },
+        depth_stencil: ?vk.PipelineDepthStencilStateCreateInfo,
         dynamic_state: DynamicState,
     },
 },
@@ -142,6 +147,23 @@ pub fn initGraphics(device: *Device, allocator: std.mem.Allocator, cache: ?*Pipe
                     .front_face = if (info.p_rasterization_state) |state| state.front_face else return VkError.ValidationFailed,
                     .line_width = if (info.p_rasterization_state) |state| state.line_width else return VkError.ValidationFailed,
                 },
+                .color_blend = blk: {
+                    if (info.p_color_blend_state) |state| {
+                        break :blk .{
+                            .attachments = if (state.p_attachments) |attachments|
+                                allocator.dupe(vk.PipelineColorBlendAttachmentState, attachments[0..state.attachment_count]) catch return VkError.OutOfHostMemory
+                            else
+                                null,
+                            .constants = state.blend_constants,
+                        };
+                    }
+
+                    break :blk .{
+                        .attachments = null,
+                        .constants = .{ 0.0, 0.0, 0.0, 0.0 },
+                    };
+                },
+                .depth_stencil = if (info.p_depth_stencil_state) |state| state.* else null,
                 .dynamic_state = blk: {
                     var state: DynamicState = .{};
 
@@ -181,6 +203,9 @@ pub inline fn destroy(self: *Self, allocator: std.mem.Allocator) void {
             if (graphics.input_assembly.attribute_description) |attribute_description| {
                 allocator.free(attribute_description);
             }
+            if (graphics.color_blend.attachments) |attachments| {
+                allocator.free(attachments);
+            }
         },
     }
     self.layout.unref(allocator);

src/vulkan/lib_vulkan.zig

@@ -1997,10 +1997,7 @@ pub export fn apeCmdSetBlendConstants(p_cmd: vk.CommandBuffer, p_constants: [*]f
     const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err);
     const constants = [4]f32{ p_constants[0], p_constants[1], p_constants[2], p_constants[3] };
 
-    notImplementedWarning();
-
-    _ = cmd;
-    _ = constants;
+    cmd.setBlendConstants(constants) catch |err| return errorLogger(err);
 }
 
 pub export fn apeCmdSetDepthBias(p_cmd: vk.CommandBuffer, constant_factor: f32, clamp: f32, slope_factor: f32) callconv(vk.vulkan_call_conv) void {
@@ -2064,12 +2061,7 @@ pub export fn apeCmdSetStencilCompareMask(p_cmd: vk.CommandBuffer, face_mask: vk
     defer entryPointEndLogTrace();
 
     const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err);
-
-    notImplementedWarning();
-
-    _ = cmd;
-    _ = face_mask;
-    _ = compare_mask;
+    cmd.setStencilCompareMask(face_mask, compare_mask) catch |err| return errorLogger(err);
 }
 
 pub export fn apeCmdSetStencilReference(p_cmd: vk.CommandBuffer, face_mask: vk.StencilFaceFlags, reference: u32) callconv(vk.vulkan_call_conv) void {
@@ -2077,12 +2069,7 @@ pub export fn apeCmdSetStencilReference(p_cmd: vk.CommandBuffer, face_mask: vk.S
     defer entryPointEndLogTrace();
 
     const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err);
-
-    notImplementedWarning();
-
-    _ = cmd;
-    _ = face_mask;
-    _ = reference;
+    cmd.setStencilReference(face_mask, reference) catch |err| return errorLogger(err);
 }
 
 pub export fn apeCmdSetStencilWriteMask(p_cmd: vk.CommandBuffer, face_mask: vk.StencilFaceFlags, write_mask: u32) callconv(vk.vulkan_call_conv) void {
@@ -2090,12 +2077,7 @@ pub export fn apeCmdSetStencilWriteMask(p_cmd: vk.CommandBuffer, face_mask: vk.S
     defer entryPointEndLogTrace();
 
     const cmd = Dispatchable(CommandBuffer).fromHandleObject(p_cmd) catch |err| return errorLogger(err);
-
-    notImplementedWarning();
-
-    _ = cmd;
-    _ = face_mask;
-    _ = write_mask;
+    cmd.setStencilWriteMask(face_mask, write_mask) catch |err| return errorLogger(err);
 }
 
 pub export fn apeCmdSetViewport(p_cmd: vk.CommandBuffer, first: u32, count: u32, viewports: [*]const vk.Viewport) callconv(vk.vulkan_call_conv) void {