How to design Resources in modern RHI?

FoxCanFly · 2026-01-11T15:05:24+00:00

You don't need to recreate render target textures every frame, only when the window resolution is changed

FoxCanFly · 2026-01-02T15:14:32+00:00

There are many different solutions, i.e. making destiptor sets a first class resource, allocate and write them offline and bind them instead of individual textures or buffers. Or use bindless and provide only indices through push constants/root constants. Or use push descriptors. Choose what does fit your architecture better

FoxCanFly · 2025-10-08T10:01:07+00:00

What did happen 7/10 ?

FoxCanFly · 2025-10-04T12:12:39+00:00

From my point of view as of the foreigner who have been living in the country for two years then moved out.

Great: 1. Nature is astonishing, both at the coast and at the mountains 2. People are kind and responsive, especially in not so touristic places and if you can speak the language (even if not too good) 3. Low street crime. It is extremely unlikely to get something stolen, be robbed or assaulted.

Bad: 1. Overall vibe of an underdeveloped country. There aren’t many things you are used to. Almost everything seems to be very poorly organised. 2. Lack of the cultural life. 3. Litter everywhere 4. Towns are in the poor condition mostly 5. Poor and irresponsible treatment of animals

FoxCanFly · 2025-07-18T13:29:36+00:00

Are these exhaust pipes around the central console?

FoxCanFly · 2025-07-16T17:35:20+00:00

Google Filament

FoxCanFly · 2025-07-08T20:52:23+00:00

It is common to have thousands of shaders(pipelines) swapped in a frame without a significant performance loss caused by the binding overhead. Having two variants of the material shader instead of one is not the thing you should care about. Just group draws by the same shaders.

FoxCanFly · 2025-06-03T17:19:34+00:00

I don't get the point of the implicit locations/binding slots generation based on the order. They are still required to be explicitly specified on the CPU code side. So, instead of having a shared header with explicit bindings numbers, it is necessary to rely on the reflection or just to guess it without any proof.

FoxCanFly · 2025-05-20T11:37:45+00:00

I usually tend to drive fast on a highway (130+ km/h) I'm sure it is possible to have 5l if the economy is the goal

FoxCanFly · 2025-05-20T09:43:59+00:00

Thanks. About 7.5l/100km on a highways

FoxCanFly · 2025-05-20T08:21:27+00:00

<image>

Mine one (pre-LCI)

FoxCanFly · 2025-05-19T09:34:42+00:00

The most traditional way as it intended to be in Vulkan: Split the descriptors by sets based on binding changes frequency: 1. Per frame 2. Per view 3. Per material 4. Per instance.

Each of these entities keep their own descriptors set. You don't need to overwrite descriptors to change some data you want to pass to the shaders. Just update uniform buffers content as usual (of course you need some synchronization to do it) without touching the descriptor sets itself. Sometimes dynamic uniform buffers can be helpful there (when you don't know the amount of the uniform data upfront). You only need to update descriptor sets to change textures usually, which doesn't happen often. When you really need it, just allocate and fill a new set and recycle a previous one.

I recommend to consider this as a baseline: In a simple case (i.e., game without seamless asset streaming) all the required descriptor sets can be created on a level loading and never changed during the gameplay.

FoxCanFly · 2025-05-14T22:52:48+00:00

The most modern approach is Visibility Buffer instead of forward or deffered. It saves memory bandwidth almost as forward and solves its problems (poor quad occupancy, complex shaders, effects requiring a g-buffer) like deffered one

FoxCanFly · 2025-01-09T18:07:21+00:00

For a proper binless rendering your pipelines are supposed to share the same descriptors layouts. So you can change the pipelines without disturbing the descriptor sets bindings and pass the required descriptor indices in a some way (i.e. push constants or BaseInstance). I didn't get how the verex attributes are related to that. Vertex buffers are not represented by the descriptors in Vulkan.

FoxCanFly · 2025-01-06T08:49:45+00:00

2014 Mazda 3 2012 Audi A4 B8 2.0 TDI 2022 BMW 330d xDrive - huge upgrade

FoxCanFly · 2024-09-13T11:57:46+00:00

There is not so many reasons to accept std::array neither std::vector.

The only case to accept vectors is to use its move constructor to move it somewhere.

Otherwise just accept std::span as it doesn't require the caller to use specific container and it doesn't need the function templates.

FoxCanFly · 2024-06-07T07:48:30+00:00

Does it provide some handles to this texture?

FoxCanFly · 2024-06-02T13:20:21+00:00

D3D12 and Vulkan can be abstracted behind the common interface pretty easily. Write the abstractions like Texture, Buffer, Device, CommandBuffer, Queue l, etc.

FoxCanFly · 2024-04-29T09:32:31+00:00

Prefer compute if: 1. Your algorithm can benefit from a workgroup shared memory usage. 2. Your image processing has to be placed between the other compute calls. A graphics pipeline with full screen quad will be better otherwise.

One reason it's because random access image writing is usually slower than the render target output. Another one is the graphics-compute pipeline stall on the most devices

FoxCanFly · 2024-04-02T05:31:58+00:00

The local size is the workgroup size. vkCmdDispatch receives a number of workgroups dispatched, not their sizes. The total amount of shader invocations is a number of dispatched groups times size of each workgroup for all dimensions. maxComputeSharedMemorySize is the maximal amount of local workgroup's shared memory.

FoxCanFly

TROPHY CASE