Back to docs

RFS2 Engine FAQ

RFS2 Engine Logo

This document has info about the RFS2 Engine used in RFS. You may also want to visit the RFS/Retro FPS Studio website.

Q1: What is the 'RFS2 Engine'?

The so-called "RFS2 Engine" is, like other game engines, the underlying code framework enabling all visuals, physics, and audio that in summary make up a game. Like some games use e.g. the Unity engine, RFS/Retro FPS Studio uses the RFS2 Engine. This FAQ document is provided for those curious about how that engine works.

Q2: What engine is the RFS2 Engine based on? DOOM, Build, ...?

RFS2 Engine is not based on any other engines. It does, however, use some helper libraries that are integrated into its executable file. All level handling, collision, and graphics rendering is custom, inspired by authentically old restricted 3D/2.5D first person engines originally written for the MS-DOS operating system. RFS uses similar techniques to replicate visuals down to characteristic render quirks.

The graphical capabilities of RFS2 Engine are closest to the original DOOM engine and Build engine, with some more advanced features alike to e.g. the later Lands of Lore 2's 2.5D engine. In terms of collision physics, scalable UI, and resource limits it is more comparable to a modern engine. Its core was programmed in C, while the program logic and UI of Retro FPS Studio use Lua.

Q3: Why didn't you use Unity, Unreal, or another game engine?

The RFS2 Engine has dramatically lower system requirements than most modern game engines. While it won't run on old DOS machines, it will likely run on most ten year old laptops, desktops, and many single-board Linux computers, and even on Windows XP SP3. Due to relying on retro render techniques, it doesn't need advanced hardware features.

Q4: How does the RFS2 Engine draw and render things?

RFS2 Engine's render technique is a half raycaster, half portal renderer hybrid, fully done as software rendering without reliance on OpenGL/Vulkan/Directx or the like. This results in characteristic visual quirks, alike to the original DOS 2.5D games where most were also software rendered. It also comes with limitations, RFS being somewhere between the DOOM and Build engines' limits, with for example no movable walls allowed ingame (which Build allows and DOOM doesn't), but no map preprocessing being needed before playing (which DOOM requires, and Build doesn't).

Q5: What mapping limitations does the RFS2 Engine have?

Adapting an old-school rendering approach and design for beautiful retro games, RFS2 Engine inherits many of the creative limitations. This is meant to boost your inspiration and keep things simple.

The following limitations for all ingame maps are inherited from DOOM/Build/... and alike:

Q6: Why does looking up/down kind of look weird?

Similarly to the old DOOM engine, walls are rendered in raycasting style with vertical slices. Therefore, looking up vertically uses vertical Z shearing with its recognizable perspective distortion. This was an intentional decision.

Q7: Why is my fan spinning up when the graphics look so simple?

This is because all rendering is done on the CPU/the main processor, also see here on RFS's software rendering. This is how the old DOS games worked, but it does have the side effect of higher CPU usage.

Q8: Why do walls look weird up close? Things sort weirdly! Why is...?

Being based on nowadays unusual retro rendering techniques, RFS2 Engine exhibits characteristic visual oddities. Many of the original DOS era or PlayStation 1 games had these quirks too, giving RFS a very recognizable look.

Q9: If I add complex hidden rooms, will it slow down my game?

No. Due to how raycasting and portal traversal work, rendering performance depends mostly on just what's visible, not on currently invisible map parts. This menas RS2 Engine has rather good occlusion culling.

However, more characters, objects, and enemies will still cause some slowdown, since they may need behavior or physics processing even when not visible. A larger level may also slow down the editor somewhat.

Q10: What GPU/graphics cards vendor gives best visual results?

Since the GPU isn't touched except optionally for upscaling of the final output image, the GPU is quite irrelevant. RFS2 mostly bypasses the GPU.

Q11: Why use the RFS2 Engine over e.g. original DOOM?

The main improvement of RFS2 Engine is its modern integrated editor, allowing instant build and play married with an authentic ingame feel. Making retro FPS games has never been easier! On a technical level with being a modern code base, RFS2 Engine also does away with some common DOS game limitations.

Most notably, RFS2 Engine removes the following limits:

Q12: Is RFS2 Engine free software? Can I get its code?

RFS and RFS2 Engine are currently proprietary, but most of the code can be reviewed under restrictive licensing. It is not allowed to be used for derivate projects or forks, however.

Q13: Why does RFS2 Engine not support macOS desktops?

The code base of RFS2 Engine is actually written to be macOS ready in most places. However, Apple bans use of their system SDK via cross-compilers on Linux, and it bans affordable use of macOS in local VMs. Since RFS2 Engine releases are built on a Linux machine, this makes macOS releases impractical. Complain to Apple if you don't like this.

In addition, Apple has engaged in a couple of indie developer hostile practices, like making it near impossible for an end user to run unsigned programs while making signing for developers considerably pricy, or deprecating vital cross-platform APIs like OpenGL with no suitable replacement.

As soon as a macOS release is no longer an unsustainable technical and financial burden, it will likely happen. This however is unlikely to improve unless Apple changes its policies.

Q14: So is RFS2 Engine 2D, 2.5D, 3D, or what?

RFS2 Engine has a renderer that some would call 2.5D due to its visual restrictions. This is most apparent in the mapping limitations, and the limited up/down tilting via Z shearing. While all objects, physics, and gameplay handling is true 3D, maps are mostly 2D planes, although through layers there is limited room-over-room and advanced verticality support. So this puts it all in a cozy 2.5D spot. (For what it's worth, we think this applies to the original DOOM too, even though some call it "actually a 2D game.")

Q15: What is RFS2 Engine's position on Y up or Z up?

Like many old games, RFS2 Engine internally uses X and Y axes horizontally, and Z up. Modern engines tend to work with Y up. In the end, it's mostly a matter of preference.

Q16: Why does RFS2 Engine support only MIDI music? Why not mp3, etc.?

By integrating a full custom MIDI stack (details here), RFS2 Engine removes most downsides of traditional .midi/.MID file playback like stuck devices, huge sound differences on different computers, MIDI driver problems, or MIDI output breaking fully. So you get MIDI without the old-school headaches.

Music creation with MIDI is also very accessible and straightforward to use: most MIDI music software has lower hardware requirements than modern digital audio music software, so you'll find a working music editor even with a slow machine!

While MIDI music may sound simplistic it is authentic for the era, and alike to RFS2's map limitations the requirement to keep it simple will both tickle your creativity, and give you a result lovingly close to many DOS retro games. And there are huge libraries of pre-existing .midi/.MID files to be found online to boost your game making.

Summed up, RFS2 Engine supports only MIDI music because it's a good fit. And mp3 or such can still be used for sound effects.

Copyright © 2021, E.J.T. - admin contact...