-
-
Notifications
You must be signed in to change notification settings - Fork 60
Supported graphics cards (GPUs)
RigelEngine needs a GPU & driver that support either OpenGL 3.0, or OpenGL ES 2.0. As a very broad rule of thumb, if your hardware is less than 9 years old, it most definitely runs the game. For even older hardware, anything from the 2007/2008 era likely still has a decent chance.
For Nvidia GPUs, OpenGL 3 support was introduced with the GeForce 8000 series around 2007. Similar for ATI/AMD with the Radeon HD 2000 series, also in 2007.
Intel GPUs took a bit longer to catch up, with the "Intel HD Graphics" series released in 2011 being the first to support OpenGL 3.0. However, models as old as the GMA 3000 from 2006 support OpenGL ES 2.0 on Linux, which means Rigel can still run on these GPUs (OpenGL ES can easily be used even for Desktop/Laptop GPUs on Linux). This has been tested successfully on a Laptop featuring an Intel GPU from 2008 (GMA 4500MHD as part of the GM45 Express Chipset).
It might be possible that some older Nvidia/AMD GPUs that only support OpenGL 2.0 would also work with GL ES on Linux, but this hasn't been tested. It's also not known if using GL ES for older GPUs is possible on Windows or Mac, or only on Linux. On Windows/Mac, using ANGLE could potentially be an option.
OpenGL ES 2.0 was introduced in 2007. It is widely supported on all kinds of hardware, as well as web platforms thanks to WebGL.
See this list for an extensive overview.
These are GPUs on which I've personally tested the game. This list is not meant to imply that the game would only run on these GPUs - it's just those that I've personally seen the game running on successfully. The game should run without problems on all kinds of hardware.
- Intel
- HD Graphics 3000 (2011)
- Iris Graphics (2013)
- Nvidia
- 8800 GTS, 512 MB variant (2007)
- GTX 980 Ti (2015)
- GT 710 1 GB (2016)
- RTX 2080 Ti (2018)
- Broadcom VideoCore IV (2010)
- Raspberry Pi model B
- Raspberry Pi 3 model B
- Mali-G31 Dvalin (2018)
- Odroid Go Advance Black Edition
RigelEngine could be made to work with OpenGL 2.0, as that version of the API provides almost everything needed aside from framebuffer object support, which is commonly available as an OpenGL extension. This would extend the range of supported hardware even further, roughly into the 2004/2005 era.
But it would also complicate the code, and require some rework. Given that Rigel runs well on OpenGL 2 GPUs when using GL ES, at least on Linux, I didn't see a strong need for this change so far, and would prefer avoiding it in order to keep the code clean. That said, I'm open to contributions on that front, and wouldn't be against including it if there's a strong desire to have it.
The original game ran on hardware with CPU speed measured in 2-digit MHz values and practically no hardware acceleration for graphics. So it may seem a bit excessive at first to require hardware that was only introduced 14 years (12 years if we assume OpenGL 2) after the original game.
But relying on hardware acceleration for graphics enables many enhancements and extended modding capabilities that would never have been possible on the original hardware. This includes things like up-scaling to high resolutions, wide-screen mode, replacing sprites with enhanced versions using more than 16 colors and higher resolution, etc.
In theory, it would be possible to implement all the rendering on the CPU instead of the GPU, which would make it possible to run the game pretty much anywhere that has a screen and fast enough CPU. But this would be way too slow for high resolutions, especially on devices like the Raspberry Pi and similar. Leveraging the GPU actually lowers Rigel's system requirements in that regard, as very little CPU power is required.
It was never a goal for RigelEngine to run on period-appropriate hardware - after all, the original game already does that job perfectly well. Instead, the project aims to be a way for easily running the game on modern systems, while taking advantage of various modern enhancements if desired.
Regarding general requirements, one advantage the original game has by being a DOS game is that it can directly talk to the hardware, bypassing the OS. Showing some pixels on screen needs just a few writes to memory. This is simply not possible on a modern OS, we have to use a graphics API like OpenGL. Naturally, this incurs more overhead, because we now have a driver and OS Kernel to go through. But whereas the original game only runs on VGA or compatible graphics cards on PCs (or emulations of those), RigelEngine can run on any platform that offers OpenGL support.
Another key difference is the handling of color: The original game runs in a 16-color mode using a palette, with one pixel requiring only 4 bits of storage. RigelEngine uses full RGBA colors instead, which needs 8 times as much space. The advantage is that we can easily plug in modern replacement graphics if we want to, and the code is simpler as well.