3,934 karma · joined February 18, 2014
Just because people misuse operator overloading doesn't mean it should be removed from the language.
I'm sure there would be mech keyboard enthusiasts who would find the actuation force too light on those
The API is very antiquated, doesn't match modern GPU architectures at all and requires many workarounds in the driver to get the expected functionality, often coming at a performance cost.
Vulkan is nice, but it goes into the other extreme. It's very low level and designed for advanced users. Even getting anything on the screen in Vulkan is intimidating because you have to write everything from scratch. To go beyond hello world, you even have to write your own memory allocator (or use an existing opensource one) because you can only do a limited amount of memory allocations and you're expected to allocate a huge block of memory and suballocate it as needed by your application.
In comparison, DX12 is a bit easier to grasp. It has some nice abstractions such as commited resources, which take some of the pain away.
Personally I like Metal as an API. It is lower level than OpenGL, getting rid of most nasty OpenGL things (state machine, lack of pipeline state objects), yet it is very approachable and easy to transition to from DX11/OpenGL. I was happy when I saw WebGPU was based on Metal at first. WebGPU is my go-to 3D API at the moment, especially with projects like wgpu-native which make it usable on native platforms too (don't let the Web in WebGPU confuse you).
Thanks to reflection features I can serialize/deserialize entire scenes just by annotating the fields in structures as needed, and can also autogenerate editor fields for inspector views. With C++ I'd have to do some out of place looking define magic to generate my structures and it wouldn't just work with any struct.
Unlike my fellow D game developers I don't fight the GC. I don't use any of the @nogc features in D or obsess about manual memory management. I have a fairly beefy machine, but still, I think the dangers of D's GC are somewhat overblown. There was a blog article back in the day by someone writing a 3D space game in D and it was often referred to as an example of how bad D's GC is, but there wasn't really enough data in that post to know about the methodology. Firstly, in a game most of the data should be preallocated anyway, in the game loop there isn't that much to allocate. Secondly, D has value types, so there's much less pressure on GC because you can stack allocate things like vectors or matrices. Sure, in other GC languages a sufficiently smart VM could probably optimize that out and avoid the GC, but I doubt it would catch most cases.
I also like how easy it is to interact with C. This grants me access to gamedev libraries such as bgfx, wgpu-native, ODE, NewtonPhysics and many, many more. C++ interaction however never cared much for. I feel like D spent too much effort here, even adding language features (copy constructors) to interact better with C++. In the meantime, it seems that it's still hard to interact with C++ libraries from D, and ironically I feel like languages like Rust or Zig have a better interop story with popular C++ libraries like Qt or Bullet, despite not investing as heavily into that.
My main current issue with D is that as a community project, it seems to lack some direction. There's some very talented people working around the project, but most of that work is done on a specific issues and projects people want to work on. Since a lot of the work on D is unpaid work, you can't force people to do what you want them to do. However, the language lead team should influence the direction of the language and provide a path forward. It's getting better in recent times, so there is a lot to look for in that aspect.
The multiparadigm aspect of D and its flexibility can be detrimental too sometimes. There are some subgroups in the language community that approach the language in a specific way and feel their way is the true "D way". For example, you have OOP folks that would like more features like named constructors, you have template metaprogramming folks who would like to remove most D features such as classes and just replace them with some metaprogramming template magic, you have folks that disable the GC and avoid the standard library from the get-go. This causes some friction, because any new feature for the language would have some opposition from the other side who will consider it bloat and unnecessary. In some ways the article about "Lisp curse" applies well to D.
These factors however don't really influence me personally, because I get to pick the features I want to use and can avoid the ones that I don't see the benefit of.
2) this is a mechanic in Prince of Persia: Sands of Time, when you die you can turn the time back to the moment before death.
What I'd like to play, is a Hitman/Dishonored like Terminator game. You play as T-1000, you should avoid suspicion, shapeshift to gain access to restricted areas. You can do combat, but it should be avoided because it will make achieving your goals harder.