voxel | a simple voxel engine written in go with opengl | Graphics library

Here are some possible option to replace 0 by NA

Assuming you're using a recent framework: spans are your friend. As a trivial way of writing them:

If anyone ever has the same problem and is looking for a solution: This project worked for me: GitHub: stl-to-voxel

The model is then also filled. If the maximum dimension is known, you can determine the exact voxel size via the resolution.

Here is some code:

I basically copy pasted the solution for
Visualize Optical Flow with color model
Code from OpenCV's tutorial:

Considering tiles is read from a file I believe the problem may be that tile['x'] and tile['y'] are strings and not integers. Try to transform them before passing them as arguments:

The thing I was looking for is resampleToMatch

I'm pretty sure your issue here is order.

Unity uses a clockwise winding order. This means that

• if you provide the triangles in clockwise order the normal will face towards you and you will see the triangle.

• if you provide the triangle in counter-clockwise order the normal will face away from you and you will not see the triangle.

Now looking at your code (at least as far as I can tell) your vertices look somewhat like

You split your world into chunks, and draw one chunk at a time. All chunks have some space reserved for them in (a single) vertex buffer, and when something has changed, you only update that one chunk. If a chunk grows too large... Well, you will probably need some sort of a memory allocation system.

Do NOT create separate buffers for every little thing. Buffers just hold data. Any data. You can even store different vertex formats for different pipelines in one same buffer - just in different places within it and binding it with an offset. Do not rebind just to draw a different mesh if all your vertices are packed neatly into array (they most likely are). If you want to only draw a part of a buffer - just use what draw commands give you.

Command buffers are just a block of instructions for the gpu. You dont need one per object. However, one cannot be used and written to at the same time, so you will need at least one per frame in flight and one to write to. Pipelines(descriptor sets, and pretty much whatever else you bind) are just a bunch of state that your gpu starts using once you bind it. At the start of command buffer, the state is undefined - it is NOT inherited between command buffers in any way.

Compute shader is what it is: a program that runs on a GPU, be it on vulkan, or in Unity, so you are doing it in parallel either way. The point of vulkan, however, is that it gives you more control about the commands being executed on GPU - synchronization, memory, etc. So its not neccesseraly going to be faster in vulkan than in unity. So, what you should do is actually optimise your shaders.

Also, the main problem with if/else is divergence within groups of invocations which operate in lock-step. So, if you can avoid it, the performance impact will be far lessened. These may help you with that.

If you still want to do all that in vulkan...

Since you are not going to do any of the triangle rasterisation, you probably won't need renderpasses or graphics pipelines that the tutorials generally show. Instead you are going to need a compute shader pipeline. Those are far simplier than graphics pipelines, only requiring one shader and the pipeline layout(the inputs and outputs are bound via descriptor sets).

You just need to pass the swapchain image to the compute shader as a storage image in a descriptor (and of course any other data your shader may need, all are passed via descriptors). For that you need to specify VK_IMAGE_USAGE_STORAGE_BIT in your swapchain creation structure.

Then, in your command buffer you bind the descriptor sets with image and other data, bind the compute pipeline, and dispatch it as you probably do in Unity. The swapchain presentation and submitting the command buffers shouldn't be different than how the graphics works in the tutorials.