Any plans to use slices in descriptors?

[TotoShampoin]

Basically, with how descriptors currently work, when I pass layouts to a pipeline, I have to either know in advance how many I have, or I have to make it in a const before passing its length and pointer

// either
const attachments = &[_]wgpu.ColorAttachment{
    .{
        .view = next.view,
        .load_op = .clear,
        .store_op = .store,
        .clear_value = .{ .r = 0, .g = 0, .b = 0, .a = 1 },
    }
};
const pass = encoder.beginRenderPass(&.{
    .color_attachment_count = attachments.len,
    .color_attachments = attachments.ptr,
}).?

// or
const pass = encoder.beginRenderPass(&.{
    .color_attachment_count = 1,
    .color_attachments = &.{
        .{
            .view = next.view,
            .load_op = .clear,
            .store_op = .store,
            .clear_value = .{ .r = 0, .g = 0, .b = 0, .a = 1 },
        },
    },
}).?;

I wish I could do something as simple as this

const pass = encoder.beginRenderPass(&.{
    .color_attachments = &.{   // <-- []const wgpu.ColorAttachment, which has a .len and .ptr
        .{
            .view = next.view,
            .load_op = .clear,
            .store_op = .store,
            .clear_value = .{ .r = 0, .g = 0, .b = 0, .a = 1 },
        },
    },
}).?;

[TotoShampoin]

The example I used may seem pointless as I'm only using one element, but that's to avoid making a super long message. It is much more relevant with render pipelines, where you're passing vertex buffer layouts, which each contain multiple vertex attributes

[bronter]

I'm not opposed to it. In fact I've been considering doing it like that since wgpu-native v24.x.x.x introduced StringView, which makes the descriptors way more annoying to deal with. It's mostly a matter of making sure that the structs I pass into wgpu-native have exactly the right memory layout.

Most (but not all) slices wgpu-native takes in are stored with length followed by pointer, whereas I think slices in Zig are stored with the pointer followed by the length (if it guarantees a specific layout at all; typically only packed/extern structs have a guaranteed layout), so it's not a drop-in replacement and I'd need to write wrappers around the descriptors to put the pointer and length in the right order.

I do something sort of similar with ShaderModuleDescriptor, where I define my custom descriptor and then translate it into the form wgpu-native expects. I'd hope that the compiler is smart enough that this has no overhead (especially if the descriptor's contents are known at compile-time), though even if it does, it's only on initialization and not per-frame.

If you'd like I could create a branch and give anyone who's interested a bit of time to comment on it.

[bronter]

Actually, I suppose with RenderPassDescriptor any overhead would be per-frame, though still probably not much of an issue.

[TotoShampoin]

Well, if the solution is to open a new branch for a more zig-like interface, then may I give some more suggestions for it? Here's what I propose:

• return error instead of null when null actually indicates a failure
• return the value instead of putting it into a pointer in some functions like surface.getCurrentTexture
• do use a zig bool instead of WGPUBool, like you say in the readme
• pass the descriptor structs, and the structs they may contain, directly as value instead of as pointers
• u8 slices instead of StringViews, I agree with you there

I don't know if you're using a generator or making it all by hand, I do know that it'd be a time consuming task for a free and open source project, so I'd be willing to help

[bronter]

Seems reasonable. It might be worth looking into coalescing wgpu.Status into some sort of error union as well. I'll spin up a branch later tonight and find a good file to try the changes out on so we can see how it looks.

[bronter]

Ok, so I've started work with instance.zig and pushed up what I've done so far in a new draft PR (#24) from the idiomatic-zig branch.

I'm still thinking about how I want to wrap the callbacks so that we can apply the same changes there that we do everywhere else. We might be able to leverage the fact that we can pass in types so that the callback doesn't have to do all that weird @ptrCast(@alignCast( stuff on the userdata parameters.

It might also be worth revisiting methods like requestAdapterSync; I've always kind of cringed at the struct they return and would rather return an error union. I wonder if it would be better to just log the message using std.log.err() if we get anything other than RequestAdapterStatus.success and then just coalesce the status into an error union and return either the error or the adapter pointer from requestAdapterSync.

[bronter]

Oh, and I've also gotten rid of InstanceProcs and other Procs. They were an unused relic from a time when I understood the API a lot less, they are a hassle to maintain and would make this refactoring project way more confusing, and I doubt they'll be used any time soon in wgpu-native since they require wgpuGetProcAddress() to be implemented. I plan on removing the Procs from everywhere else they occur too.

[TotoShampoin]

Okay! I'm gonna fork and use this branch into my project for testing purpose, so I can contribute and/or give you feedback! Should we keep discussions in this thread?

[bronter]

I've copied the list of proposed changes to the draft PR. I think it would be easier to discuss there since you can quote the source code. Contributions are also welcome, I appreciate the feedback!

[carrot-sticks]

If you are doing the custom Zig like API, I would suggest using packed struct into the integer instead of the flags. For example:

pub const BufferUsage = packed struct(WGPUFlags) {
    map_read: bool = false,
    map_write: bool = false,
    copy_src: bool = false,
    copy_dst: bool = false,
    index: bool = false,
    vertex: bool = false,
    uniform: bool = false,
    storage: bool = false,
    indirect: bool = false,
    query_resolve: bool = false,
    _: u54 = 0,
};

  // usage example
  const descriptor = wgpu.BufferDescriptor{
      .usage = .{  .copy_dst = true, .vertex = true }, 
      .size = 1024,
  };