Nail & Crescent

Watch our Teaser on Youtube, and see what the fuzz is all about.

Technology

Nail & Crescent builds upon the beautiful Quake II RTX technology.

Using Quake II RTX its powerful renderer, with extra additions of our own we set off to improve the engine. There were two important goals that we had in mind, make it more fun and user friendly to work with the engine. Hereby inviting the oppertunity for mod developers to use our technology. But most of all, improvements to the engine in overall, so it has more modern features to match its unique modern render system.

Nail & Crescent has introduced the following changes and features:

• Own custom BSP tooling based on the qbism v220 toolset.
• Client Game DLL interface. This allows for mods to have control over client side effects, something normally not possible in vanilla Quake 2.
• OpenAL Audio support. Such as underwater effects.
• Entities and player positions are networked using full floating point precision. No more drunk feeling due to entity positions being networked as shorts.
• Larger world boundary limits, break free of the 4096x4096x4096 boundaries.
• Shared player move code. The client game dll, and server game dll both share the player move code now. This allows for mods to implement custom movement.
• Highly restructured game code.

Here is a list of plans for the technology behind Nail & Crescent. Note that not all might make it in the end.:

• Adjust BSP format to use ints instead of shorts, so we can extend its limits.
• Add a material system, let Trenchbroom and the BSP tools support this.
  • Will also contain a converter for the .csv file which is currently in use as the material database.
• Implement libRmlUI and use it for the HUD, Console, MainMenu, and in-game menus.
• Skeletal Animation support.
• Player Movement AI (A proof of concept can be found in this branch)
  • Adding a Schedule, Task, and Waypoint system should greatly improve the proof of concept and bring it to decent modern standards.
• Replace trace code by a physics library, ultimately improving collision detection overall and allowing for the option of several physics entities.
  • This retains the actual Player Movement code as always and should not influence the gameplay negatively. In fact, it's not wished for.
• Add RESTIR to the RTX renderer, hereby greatly reducing noise and making typical scenes with torches a reality.

License

Nail & Crescet its code is licensed under the same terms as Quake II RTX. It's hard to not be.

Quake II RTX is licensed under the terms of the GPL v.2 (GNU General Public License). You can find the entire license in the license.txt file.

The Quake II game data files remain copyrighted and licensed under the original id Software terms, so you cannot redistribute the pak files from the original game.

Features

TODO: List our RTX stuff here.

Quake II RTX introduced the following features:

• Caustics approximation and coloring of light that passes through tinted glass
• Cutting-edge denoising technology
• Cylindrical projection mode
• Dynamic lighting for items such as blinking lights, signs, switches, elevators and moving objects
• Dynamic real-time "time of day" lighting
• Flare gun and other high-detail weapons
• High-quality screenshot mode
• Multi-GPU (SLI) support
• Multiplayer modes (deathmatch and cooperative)
• Optional two-bounce indirect illumination
• Particles, laser beams, and new explosion sprites
• Physically based materials, including roughness, metallic, emissive, and normal maps
• Player avatar (casting shadows, visible in reflections)
• Recursive reflections and refractions on water and glass, mirror, and screen surfaces
• Procedural environments (sky, mountains, clouds that react to lighting; also space)
• "Shader balls" as a way to experiment with materials and see how they look in different environments
• Sunlight with direct and indirect illumination
• Volumetric lighting (god-rays)

You can download functional builds of the game from NVIDIA or Steam.

Additional Information

• Announcement Article
• Client Manual
• Server Manual

Also, some source files have comments that explain various parts of the renderer:

• asvgf.glsl explains the denoiser filters
• checkerboard_interleave.comp shows how checkerboarded rendering facilitates path tracing on multiple GPUs and helps with water and glass surfaces
• path_tracer.h gives an overview of the path tracer
• tone_mapping_histogram.comp explains the tone mapping solution

Support and Feedback

• GeForce.com Forums
• Steam Community Hub
• GitHub Issue Tracker

System Requirements

In order to build Quake II RTX you will need the following software installed on your computer (with at least the specified versions or more recent ones).

Operating System

	Windows	Linux
Min Version	Win 7 x64	Ubuntu 16.04

Note: only the Windows 10 version has been extensively tested.

Note: distributions that are binary compatible with Ubuntu 16.04 should work as well.

Software

	Min Version
NVIDIA driver https://www.geforce.com/drivers	430
git https://git-scm.com/downloads	2.15
CMake https://cmake.org/download/	3.8
Vulkan SDK https://www.lunarg.com/vulkan-sdk/	1.1.92

Submodules

• zlib
• curl
• SDL2
• stb
• tinyobjloader-c
• Vulkan-Headers

Build Instructions

1. Clone the repository and its submodules from git :

   git clone --recursive https://github.com/NVIDIA/Q2RTX.git

2. Create a build folder named build under the repository root (Q2RTX/build)

   Note: this is required by the shader build rules.

3. Copy (or create a symbolic link) to the game assets folder (Q2RTX/baseq2)

   Note: the asset packages are required for the engine to run. Specifically, the blue_noise.pkz and q2rtx_media.pkz files or their extracted contents. The package files can be found in the GitHub releases or in the published builds of Quake II RTX.

4. Configure CMake with either the GUI or the command line and point the build at the build folder created in step 2.

   cd build
cmake ..

   Note: only 64-bit builds are supported, so make sure to select a 64-bit generator during the initial configuration of CMake.

   Note 2: when CMake is configuring curl, it will print warnings like Found no *nroff program. These can be ignored.

5. Build with Visual Studio on Windows, make on Linux, or the CMake command line:

   cmake --build .

Music Playback Support

Quake II RTX supports music playback from OGG files, if they can be located. To enable music playback, copy the CD tracks into a music folder either next to the executable, or inside the game directory, such as baseq2/music. The files should use one of these two naming schemes:

• music/02.ogg for music copied directly from a game CD;
• music/Track02.ogg for music from the version of Quake II downloaded from GOG.

In the game, music playback is enabled when console variable ogg_enable is set to 1. Music volume is controlled by console varaible ogg_volume. Playback controls, such as selecting the track or putting it on pause, are available through the ogg command.

Music playback support is using code adapted from the Yamagi Quake 2 engine.

Photo Mode

When a single player game or demo playback is paused, normally with the pause key, the photo mode activates. In this mode, denoisers and some other real-time rendering approximations are disabled, and the image is produced using accumulation rendering instead. This means that the engine renders the same frame hundreds or thousands of times, with different noise patterns, and averages the results. Once the image is stable enough, you can save a screenshot.

In addition to rendering higher quality images, the photo mode has some unique features. One of them is the Depth of Field (DoF) effect, which simulates camera aperture and defocus blur, or bokeh. In contrast with DoF effects used in real-time renderers found in other games, this implementation computes "true" DoF, which works correctly through reflections and refractions, and has no edge artifacts. Unfortunately, it produces a lot of noise instead, so thousands of frames of accumulation are often needed to get a clean picture. To control DoF in the game, use the mouse wheel and Shift/Ctrl modifier keys: wheel alone adjusts the focal distance, Shift+Wheel adjusts the aperture size, and Ctrl makes the adjustments finer.

Another feature of the photo mode is free camera controls. Once the game is paused, you can move the camera and detach it from the character. To move the camera, use the regular W/A/S/D keys, plus Q/E to move up and down. Shift makes movement faster, and Ctrl makes it slower. To change orientation of the camera, move the mouse while holding the left mouse button. To zoom, move the mouse up or down while holding the right mouse button. Finally, to adjust camera roll, move the mouse left or right while holding both mouse buttons.

Settings for all these features can be found in the game menu. To adjust the settings from the console, see the pt_accumulation_rendering, pt_dof, pt_aperture, pt_freecam and some other similar console variables in the Client Manual.

MIDI Controller Support

The Quake II console can be remote operated through a UDP connection, which allows users to control in-game effects from input peripherals such as MIDI controllers. This is useful for tuning various graphics parameters such as position of the sun, intensities of lights, material parameters, filter settings, etc.

You can find a compatible MIDI controller driver here

To enable remote access to your Quake II RTX client, you will need to set the following console variables before starting the game, i.e. in the config file or through the command line:

 rcon_password "<password>"
 backdoor "1"

Note: the password set here should match the password specified in the korgi configuration file.

Note 2: enabling the rcon backdoor allows other people to issue console commands to your game from other computers, so choose a good password.

Shader Balls Feature

The engine includes support for placing a set of material sampling balls in any location. Follow these steps to use this feature:

• Download the shader_balls.pkz package from the Releases page.
• Place or extract that package into your baseq2 folder.
• Run the game with cl_shaderballs set to 1, either from command line or from console before loading a map.
• Use the drop_balls command to place the balls at the current player location.