23,650 karma · joined October 15, 2013
...which is a good thing tbh. No game needs hundreds or thousands of custom materials.
They had it figured out perfectly in the Xbox360 generation (and for PC games by the late 90s), but I guess that the MS Games and Xbox divisions had a lot more freedom and were more decoupled from the Microsoft org chart back then.
LLVM might not be the fastest, but when you get to the point that build times become a problem, your code base is too big (or your frontend is doing silly things). Maybe ask your 'automatic code generation' to generate less code bloat ;)
Also native Vulkan support on macOS would only have removed one step in that render pipeline. Besides, I bet if Apple would offer a native Vulkan API, it wouldn't look much different than Khronos' solutions (MoltenVK or KosmicKrisp), e.g. Apple's solution would almost certainly be a shim on top of Metal, just like their GL/GLES or D3D12 implementations.
Check the commit history what the project actually added on top of the already existing Linux+macOS port which it forked from. It's a handful commits and comes down to a few dozen to a few hundred lines of actual code changs.
I created and maintain a cross-platform wrapper library (several over the decades actually) which among other platforms supports macOS and iOS, so I have an idea what's involved.
This is a game that renders its own UI, it only needs to use AppKit/UIKit for creating the application window, and from then on hand off all rendering to Metal. When you already have working 'Metal-heavy' macOS code, porting to iOS is indeed trivial these days, the Apple-specific code is at least 90% identical between macOS and iOS.
The main difference is mouse input vs touch input, but that's also not a big deal for an RTS since it only needs 'click', 'zoom', 'pan' and 'dragbox-select'.
> If it was so trivial, why hadn't it already been done?
Because maybe the author of the original Linux+macOS port simply didn't care about iOS or didn't want to put up with the messy iOS development workflow in Xcode?
It's a good example of AI psychosis I guess, people reading things into a headline which they want to be true, no matter what reality says ;)
When you look at the commit history, the actual changes come down to a few dozen lines of code, all of them absolutely trivial, and most of those code changes seem to be cherry-picked bugfixes from the original project.
The actually important work (of making the original code release portable and then create Linux and macOS ports) had already been done in https://github.com/fbraz3/GeneralsX. There is really not much to see here.
> rendering DirectX 8 → DXVK → Vulkan → MoltenVK → Metal.
Ok, *this* is a bit weird. Why create such a jenga tower of indirections instead of directly letting the LLM port the rendering code from D3D8 to Metal either through a D3D8-to-Metal shim or even better by creating a new Metal-based render layer beneath the higher level game specific rendering code? I would expect that the LLM can 'see through' all those redundant shims and collapse them into the equivalent Metal code.
Also the readme says 'no emulation', but then goes on to describe the rendering layer as emulating D3D8 on top of Vulkan on top of Metal ;)
(also why are both Meson and CMake required)
PS: after reading more, it can be explained by what this project does (and it's not what the HN title says): it's not a port from the original C&C Generals code release to macOS/iOS, instead all the heavy lifting (of making the original code base portable, and providing example ports to Linux and macOS) was all already done by an existing project (https://github.com/fbraz3/GeneralsX), all that this project did was slightly enhance the existing macOS version so that it also runs on iOS.
Suddenly this is much less impressive and could probably have been done just as well with older and simpler models (or tbh, a few hours or at most a few evenings of manual coding - macOS and iOS code is nearly identical for this type of application).
Today there are plenty of 'non-white' (as you call them) refugees and asylum seekers (mostly from Syria and Afghanistan) and many more Ukrainian refugees (which for a while were the main target for Russian/AfD propaganda in East Germany) living in Saxon small towns, and 'somehow' it seems to work out (just travel by train or bus through the more rural areas of Saxony for a bit and you'll see).
In conclusion, your black and white world view and generalized insults towards East Germans are quite frankly disgusting.
"QBE is a compiler backend that aims to provide 70% of the performance of industrial optimizing compilers in 10% of the code."
That doesn't sound like QBE wants to compete with LLVM when it comes to optimizations.
https://docs.godotengine.org/en/stable/tutorials/ui/creating...
Lol, right. That might work for some of the runtime parts of a very simple engine, but not the other 90%, especially when you "don't care about how it actually works".
A game engine (like UE or Unity) easily exceeds the complexity of an entire desktop operating system (not necessarily in line count, but in number of features, their diversity and complexity).
IME two years sounds about right starting from scratch until getting everything into a state that can be called a basic game engine (if a bit optimistic). You can start earlier building a game on the in-progress-engine of course and tbh that's the only way to not develop an entirely useless engine. But that way you'll also end up with an engine that's mostly only useful for that one game, and progress on the game will be atricious in the first year or so. And of course developing both side by side means spreading the butter even thinner.
In the end though I have seen at least as many game projects fail using an off-the-shelf engine (in that case: Unity) compared to using an inhouse engine. The decision to use inhouse tech versus off-the-shelf engine doesn't make or break a game, in the end the failure always lurk within the team (but the engine is usually blamed first when things went south heh).
Any addition to this small and exclusive list is very welcome :)
...that's an entirely different article.
But if it makes you feel any better (and at the risk of trying to talk to a troll because you sure sound like one):
Zig is in the process of getting rid of the integrated LLVM backend - the compiler will still be able to emit LLVM bitcode as an option though which then can be fed into an externally provided LLVM backend (LLVM's optimizer passes are still hard to beat).
Besides, D is usually brought up in every HN thread about a non-D programming language, usually by the author himself and I'm surprised he hasn't shown up yet ;)
Also D being a better C is vastly overblown IMHO, D has become a complicated kitchen-sink language where each concept seems to be implemented in three different ways (at least that was my impression when looking at D's memory management, and the toolchain situation is more than confusing).
Yet still the *main* problem is the ambassador lying about that person being an active threat.
E.g. what if that information would have been correct? All hell would break lose if the police wouldn't take such a call serious and the supposed 'threat' would be real and people killed, from that perspective they seemed to have reacted quite civilized and calm.
If the events happened as reported, the ambassador should at the very least be summoned and grilled by the Belgian government.
In C/C++ and MSL that information would be provided via `[[ ... ]]` attributes (which may look even messier), and other shading languages usually have dedicated keywords (most readable, but it 'pollutes' the entire language for what in Zig would be a niche use case).
If you'd actually read the post you'd know that its about the the US ambassador being an asshole and the Belgian police doing their job (quickly removing a supposed 'active threat' from an event - because that's the only information they had - they later realized their mistake and that the 'active threat' was just a journalist asking inconvenient questions - but at that point the damage was done and the journalist wasn't let back into the event.
The Belgian police got the information that the person would be an 'active threat' which is just absolutely bizarre and explains the somewhat 'hasty' reaction of the police to quickly remove that person from the event before asking further questions. After they realized their mistake they apologized but of course at that point the journalist wasn't allowed back in.
The ambassador essentially swatted the journalist.
LLVM isn't mentioned once in the post, instead it's about updates to Zig's "inhouse" SPIRV backend, not the LLVM SPIRV backend.