Demo for The Art of Reflection released (a 3D game and engine fully written in D)

[Lewis]

On Friday, 24 May 2024 at 19:22:32 UTC, Jonathan Gerlach wrote:
> I'm impressed. Are you using DirectX "11 on 12" or standard 
> DirectX11? Did you need to avoid the GC at all? I imagine the 
> GC could ruin your framerate if you're not careful. Thanks for 
> sharing and congrats on finishing (close enough) your game.

Plain old DX11. I've used DX12 in industry, and it basically 
amounts to opting in to writing 70% of the graphics driver along 
with your renderer :) I don't need to push AAA levels of 
performance or asset load for this game, so DX11 is fine.

Regarding the GC, copy-pasting my reply from Discord:

I don't have the GC fully disabled, but I make a point to avoid 
GC allocations in runtime code. I allow myself to use it for 
initialization, tooling, editor code, etc. For runtime code it 
really just acts as a fallback. If I messed something up, a 
memory leak just becomes a periodic hitch instead of an eventual 
crash.

I've also hacked some changes into druntime to help with this:
- I added a "scrapheap" GC implementation, which is a simple 
linear allocator that resets at the end of each frame. I have a 
mixin that makes a scope use the scrapheap instead of the regular 
GC, which is useful for allowing me to still use phobos or other 
libraries, as long as I'm okay with all allocated memory being 
discarded at the end of the frame. Each worker thread also gets 
one, which resets when a unit of work completes.
- I added a quick and dirty mode I can enable that logs the 
callstack of every GC allocation, to help me track down stray 
allocations that occur during runtime. @nogc is too restrictive, 
and doesn't understand that my scrapheap usage bypasses the GC.

Runtime allocations that need to stick around almost entirely use 
a structure I've internally called a GenerationalStorage. Pretty 
common idea in games, a fixed size object pool that hands out 
IDs, and IDs can be used to retrieve a pointer to the object. 
Each ID contains the object's index, along with a generation 
number that increments every allocation, letting you reliably 
catch and assert on any use-after-frees of IDs.