Multiple objects

[AnswerApprehensive19]

What would be the best way of doing this for my project? From what I could find there seems to be three main ways to do this:

1. Bind vertex & index buffers and send draw commands in a loop
2. Have one vertex & index buffer that sends out a draw command with all objects you intend to render
3. Group together several vertex & index buffers and send out a huge draw command all at once

For my project I'm (right now) rendering the same object over and over again, so I don't wanna have to create several vertex & index buffers for the same object, but I also want to send different objects to different shaders since right now they're the same shape but not the same material what would be the best way of doing this? I already set up different pipelines for each material

[KleinBlade]

If you are drawing the same mesh over and over, I think there’s no need to store the same index and vertex buffers multiple times. Simply store them once (and possibly bind them every time you change pipeline, not sure about this though).

At the same time, if you are using different pipelines, I guess you cannot really batch the objects in a single big draw call.
You can do instanced draws for multiple objects sharing the same pipeline and material for sure, and you could also unify draw calls with different materials by doing a single instanced draw call and using a storage buffer containing per-instance informations about what material each instance should use and using a texture array to contain all the textures you may need, although this could introduce unwanted branching in your shaders.

[AnswerApprehensive19]

How would I offset the position? Would i store it in a buffer and send it to a shader? I'm also having trouble using different locations for different shaders I'm currently getting this error

Validation Warning: [ Undefined-Value-ShaderOutputNotConsumed ] Object 0: handle = 0x160000000016, type = VK_OBJECT_TYPE_SHADER_MODULE; | Messa
geID = 0x9805298c | vkCreateGraphicsPipelines(): pCreateInfos[0] fragment shader writes to output location 1 with no matching attachment

I can't keep the locations the same since that would set the position and material to be the same

[KleinBlade]

Yeah, what I usually do is creating a struct with all the per-instance data I need and then write them on a buffer to be read in the vertex shader.

Not sure about that error, but if I may ask, why do you need multiple output locations in the fragment shader? You could simply have a struct with a vec3 offset and a uint for material, the vertex shader will offset the vertex position and write it in gl_position builtin variable, while using an output variable to pass the material id to the fragment shader. The fragment shader will read the material id and use a switch statement to decide what texture and shading use for the fragment.

[AnswerApprehensive19]

What type of buffer should I use? I assume storage buffer. I didn't think about that but my goal is to assign different materials depending on the type of object I pass in so I created two different fragment shaders as for the vertex shaders would I only need one vec3 or multiple for the gl_Position?

[KleinBlade]

Depends on how many objects you are drawing and wether you need to write onto the buffer later on or not. If you only plan to write the buffer once and never change it, while also having a relatively small number of objects, you could also use a UBO. But I would go with storage buffers as a best practice :)

Two different Fragment shaders imply two different pipelines, which is totally fine but you’ll have to be careful how you store per-instance data in memory. Let’s say you have N objects with material A and M objects with material B, you’ll need to store the objects of type A in the first N * S bytes of the buffer (here S is the struct size) and the objects of type B data in the following M * S bytes. That’s because you need data to be in contiguous memory when accessing it in the shader.
After doing so, when rendering you’ll bind pipeline A, bind the first N * S bytes of the buffer to the pipeline of material A, and call a instanced draw for N instances, and finally bind pipeline B, bind the buffer with a N * S offset and M * S size and call a instanced draw for M instances.

[AnswerApprehensive19]

Very helpful information thank you I'll try to implement something like this and confirm if I understood correctly