Thesis Candidate

[Condzi]

No description provided.

[medranSolus]

I haven't analyzed RT shader that clearly but general idea is avoiding branches. Any if statement results in shader execution divergence on the GPU which have to evaluate both sides inside condition if same wave (SIMD execution unit). Instead it would be better to compute final result by nullifying unwanted parts of computations, ex. line 288:

// Before
if (can_refract && !reflectance_test) {
  direction = refract(unit_direction, hi.normal, refraction_ratio);
} else {
  direction = reflect(unit_direction, hi.normal);
}
// After
float cond = can_refract * (reflectance(cos_theta, refraction_ratio) <= random_f32(rand_seed));
direction = cond * refract(unit_direction, hi.normal, refraction_ratio) + abs(cond - 1) * reflect(unit_direction, hi.normal);

But still, it has to be measured, that's just a quick idea about turning statements into computations.

[medranSolus]

Instead of passing flags like that consider usage of following functions (depending which would fit better for single target or all target wide):

• add_definitions()/target_compile_definitions() - for defines
• add_compile_options()/target_compile_options() - for compiler flags
• add_link_options()/target_link_options() - for linker flags

When using targeted versions they should appear after target (ex. executable) has been declared.

[medranSolus]

Instead of adding whole ImGui repo to the project you could set it up as submodule. This way you would only have single reference to the 3rd party project in your repository and updating it would only consist of single command.

[medranSolus]

Not every PC will have second GPU, best way here would be to use async compute but it's only present in newer APIs. For DX11 you could still run ImGui at the start and then compute workload for RT (given that the driver will make use of async path). But then you still have to present final image so synchronization is inevitable..

[medranSolus]

You could also abandon Unicode as it's a broken format anyway, consider using UTF-8 only since it can hold same characters as Unicode and can be stored in same manner as normal std::string. Good read about that: UTF-8 Everywhere.

[medranSolus]

DX12 command lists are only for recording commands, they have to be submited to the GPU anyway and there hang will happend in resposivity. If you were to use DX12 you could retain responsivenes in following manner: main GPU queue used for rendering to the window (ImGui, presents, etc.) and async compute queue used for RT happening across frames. To see updates you could copy image that is being worked on to show progress in main queue. That would be still a bit hard thou without a way to controll RT passes since you can't copy from resource that is being written into at the same time (data race). But if you are doing your RT in steps then it's achieveable to copy current image between steps to texture that will be presented in main queue.

[medranSolus]

It would be more consistent to move them to CMakeLists.txt

[medranSolus]

Maybe worth considering something like DirectXMath, this way you could speed everything up by using SSE.

[medranSolus]

Spinlocks are good enough for really quick locks (measuring needed), but for most part std::shared_mutex is sufficient since sleeping thread will leave up CPU for other more demanding work. Or you could take a look at WinAPI native locks if you prefer this implementation.

[medranSolus]

In DX11 you can always use newest interfaces available, since it's an older API. This way you can have more ways to accomplish tasks or to get another idea how to approach problem.

[medranSolus]

nullptr provide better type safety in C++.