GithubHelp home page GithubHelp logo

abalfoort / q2rtx Goto Github PK

View Code? Open in Web Editor NEW

This project forked from nvidia/q2rtx

2.0 0.0 0.0 23.94 MB

NVIDIA’s implementation of RTX ray-tracing in Quake II

License: Other

Shell 0.03% Python 0.08% C 98.37% NSIS 0.07% CMake 0.39% GLSL 0.67% Batchfile 0.01% HTML 0.39%

q2rtx's Introduction

Quake II RTX

Including support for mission packs: The Reckoning (xatrix), Ground Zero (rogue), Zaero

Build Status

Quake II RTX is NVIDIA's attempt at implementing a fully functional version of Id Software's 1997 hit game Quake II with RTX path-traced global illumination.

Quake II RTX builds upon the Q2VKPT branch of the Quake II open source engine. Q2VKPT was created by former NVIDIA intern Christoph Schied, a Ph.D. student at the Karlsruhe Institute of Technology in Germany.

Q2VKPT, in turn, builds upon Q2PRO, which is a modernized version of the Quake II engine. Consequently, many of the settings and console variables that work for Q2PRO also work for Quake II RTX.

License

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

Quake II RTX introduces 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)
  • Sunlight with direct and indirect illumination
  • Volumetric lighting (god-rays)

You can download functional builds of the game from GitHub Releases.

Latest development builds can be found in the Actions tab. To run a development build, download the artifact, extract it and put q2rtx_media.pkz, blue_noise.pkz and the pak*.pak files from the original game into baseq2/.

Additional Information

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

Support and Feedback

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 x86_64 or aarch64
Min Version Win 10 x64 Debian 11

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

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

Note: Linux ppc64le is also known to work though not officially supported.

Software

Min Version
NVIDIA GPU driver
https://www.geforce.com/drivers
460.82
AMD GPU driver
https://www.amd.com/en/support
21.1.1
git
https://git-scm.com/downloads
2.15
CMake
https://cmake.org/download/
3.8
Vulkan SDK
https://www.lunarg.com/vulkan-sdk/
1.2.162

Submodules

Build Instructions

  1. Install build dependencies Linux: sudo apt-get install libpipewire-0.3-dev libvulkan-dev libsdl2-dev zlib1g-dev libssl-dev libxrandr-dev Windows: download and install the Vulkan SDK: https://vulkan.lunarg.com/

  2. Clone the repository and its submodules from git :

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

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

    Note: this is required by the shader build rules.

  4. 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.

  5. Linux: 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.

  6. Build with Visual Studio on Windows (https://learn.microsoft.com/en-us/cpp/build/cmake-projects-in-visual-studio), 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.

Material System

The engine has a system for defining various properties for surface materials, such as textures, material kinds, flags, etc. Materials are defined in *.mat files in a custom text-based format. The engine will read all materials/*.mat files from the game directory (or directories when playing a non-base game) in alphabetic order, and materials in the later files override the materials in the earlier files. Then the engine also reads a <mapname>.mat file when loading a map, and the materials defined in the map-specific file override global materials - but only those used for map geometry, not models.

The .mat files consist of multiple material entries, where each entry can define multiple materials. For example:

textures/e1u2/wslt1_5,
textures/e1u2/wslt1_6:
    texture_base overrides/*.tga
    texture_normals overrides/*_n.tga
    texture_emissive overrides/*_light.tga
    is_light 1
    correct_albedo 1

The above example defines two materials that will be used for surfaces that reference .wal files with the same base names, and for each of these materials it defines three textures. The * symbol in the texture definition is replaced with the material base name, so either wslt1_5 or wslt1_6 in this example.

When a material is not defined for a surface, the engine will look for textures with matching names and various extensions. First, it will look in the overrides/ directory, then in the original texture path. Normal maps are searched with the _n suffix, and emissive maps are searched with the _light suffix. If no replacement files are found, just the original base texture will be used.

Materials can also use the automatic emissive texture generation feature. This is the case for undefined materials when the pt_enable_surface_lights console variable is nonzero: wall surfaces with the SURF_LIGHT flag (but not SURF_SKY or SURF_NODRAW) will generate an emissive texture from the base texture and a threshold value, if no emissive texture is found, and marked with the is_light material flag. The threshold value is set using the pt_surface_lights_threshold variable. For defined materials you can the synth_emissive and emissive_threshold material properties to explicitly enable emissive texture generation.

Materials can be examined and modified at run time, using the mat command. For example, mat print will print the properties of the currently targeted material to the console. To get more usage information, use mat help.

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.

Test Model

The engine includes support for placing a test model in any location. You can use any MD2, MD3 or IQM model. Follow these steps to use this feature:

  • To use the material sampling balls model, download the shader_balls.pkz package from the Releases page. Place or extract that package into your baseq2 folder.
  • Run the game with the cl_testmodel variable set to the path of the test model.
  • Use the puttest command to place the test model at the current player location.
  • Adjust the test model animation speed with the cl_testfps variable and its opacity with the cl_testalpha variable.

q2rtx's People

Contributors

skullernet avatar apanteleev avatar res2k avatar paril avatar abalfoort avatar sthalik avatar runlevel5 avatar randomdude4 avatar liam-middlebrook avatar jayschwa avatar joshua-ashton avatar hifi avatar mjunix avatar devnexen avatar kugelrund avatar yamagi avatar mpyrzows avatar ckwarner avatar a1batross avatar rumblehhh avatar r-a-sattarov avatar perfectcolors avatar illwieckz avatar ishitatsuyuki avatar sherief avatar totallymehis avatar kkartaltepe avatar calinou avatar vash63 avatar davevoyles avatar

Stargazers

 avatar Quake Mod Museum avatar

q2rtx's Issues

Windows - MP2 Ground Zero crash when loading rlava1

As reported by alfredon121: windows rogue crash.

In Debian

Thaelite Mines
loading rlava1
Execing maps/default.cfg
Execing maps/rlava1.cfg
]q2rtx: /home/arjen/dev/Q2RTX/src/src/refresh/vkpt/vertex_buffer.c:659: vkpt_light_buffer_upload_to_staging: Assertion `bsp_mesh->num_light_polys + num_model_lights < MAX_LIGHT_POLYS' failed.
Signal: SIGABRT (Aborted)

In Windows I see that bsp_mesh->num_light_polys is over 5000:

		bsp_mesh->num_light_polys	5332	int
		num_model_lights	0	int

Zaero's q2rtx_media.pkz and upscaled textures?

Hi,

so the q2rtx_media.pkz inside zaero folder contains upscaled textures/models.
I'd like to play in OGL mode with these textures.

However, they aren't immediately applied in-game with OpenGL.
The "use new textures" (gl_use_hd_assets) option is missing - in fact quite a few of video settings are missing when launching RTX Zaero compared to Quake 2 RTX.

What I found out is that launching Q2RTX_170_Win11_20230909 with "+set game zaero" locks the q2rtx_media.pkz from BaseQ2 folder, instead of from Zaero folder - this causes textures to clash/mismatch.

I know Q2RTX implemented the feature of loading replacement textures, but the process of getting Zaero to work with your fork/build is a bit weird.

I have added another community upscaled texture pack for BaseQ2 content (Q2's base game models) to Zaero by simply extracting to a folder "models" for things that Zaero doesn't have and otherwise pulls from baseq2 .pkz and/or .pak, and it works nicely even with your included upscaled pack in Zaero .pkz - but only if I rename the baseq2 .pkz.

I currently have a hacky workaround by renaming the .pkz file in baseq2, and everything is loaded from the Zaero .pkz, but is this supposed to work like this - why not load stuff from Zaero .pkz and then the "missing" content from either Zaero .pak, and then from BaseQ2 .pkz/.pak?

PS: for some reason "ctank" folder has to be outside of "tank" folder to make ctank model with upscaled texture, dunno why.
PSS: is it possible to update Zaero with 1.1 version, since it has a new .dll?

Windows versions crash

Reported by Steam user _Becket.

Run-time error:
The variable 'm' is being used without being initialized.

No further debug information.

25b186de31

Builds fine on Linux but game always starts main game.

After build, the .map files are copied to the respective directories.

Starting MP1 shows the right start screen, but when starting a new game, it always starts the main game (base1).

However, after base1 is started and I open the game console and run:
gamemap xswamp
It will start the MP1 and it seems to work fine.

The same for MP2:
q2rtx +set game rogue
Start a game. Starts base1.
gamemap rmine1
Will start MP2.

In some places it is too dark to be playable: use the flashlight (bind r "toggle cl_flashlight").

Console output:

$ ./q2rtx +set game xatrix
------- FS_Init -------
Current search path:
/home/arjen/.quake2rtx/xatrix
/home/arjen/.quake2rtx/baseq2
/home/arjen/.quake2rtx/baseq2/pak8.pak (122 files)
/home/arjen/.quake2rtx/baseq2/pak7.pak (88 files)
/home/arjen/.quake2rtx/baseq2/pak6.pak (2191 files)
/home/arjen/.quake2rtx/baseq2/pak5.pak (59 files)
/home/arjen/.quake2rtx/baseq2/pak3.pak (8 files)
/home/arjen/.quake2rtx/baseq2/pak2.pak (2 files)
/home/arjen/.quake2rtx/baseq2/pak1.pak (279 files)
/home/arjen/.quake2rtx/baseq2/pak0.pak (3307 files)
/home/shared/Games/quake2/xatrix
/home/shared/Games/quake2/xatrix/pak0.pak (832 files)
/home/shared/Games/quake2/baseq2
/home/shared/Games/quake2/baseq2/shaders.pkz (94 files)
/home/shared/Games/quake2/baseq2/q2rtx_media.pkz (4054 files)
/home/shared/Games/quake2/baseq2/blue_noise.pkz (258 files)
/home/shared/Games/quake2/baseq2/backgrounds.pkz (3 files)
/home/shared/Games/quake2/baseq2/addonsounds.pkz (23 files)
/home/shared/Games/quake2/baseq2/pak8.pak (122 files)
/home/shared/Games/quake2/baseq2/pak7.pak (88 files)
/home/shared/Games/quake2/baseq2/pak6.pak (2191 files)
/home/shared/Games/quake2/baseq2/pak5.pak (59 files)
/home/shared/Games/quake2/baseq2/pak3.pak (8 files)
/home/shared/Games/quake2/baseq2/pak2.pak (2 files)
/home/shared/Games/quake2/baseq2/pak1.pak (279 files)
/home/shared/Games/quake2/baseq2/pak0.pak (3307 files)
12944 files in PAK files
4432 files in PKZ files
-----------------------
Logging console to logs/console.log
Execing default.cfg
Execing q2rtx.cfg
Execing q2config.cfg

Engine version: q2rtx 1.6.0-SkacikPL-6e3511ea, built on Dec 11 2022                                                                              

------- S_Init -------
][ALSOFT] (WW) No audio support detected in PipeWire. See the PipeWire options in alsoftrc.sample if this is wrong.
[ALSOFT] (WW) Failed to initialize backend "pipewire"
[ALSOFT] (WW) pthread_setschedparam failed: Operation not permitted (1)
[ALSOFT] (WW) pthread_setschedparam failed: Operation not permitted (1)
OpenAL initialized.
----------------------
Loaded 2392 materials from materials/baseq2.mat
----- init_vulkan -----
Available Vulkan layers: 
  VK_LAYER_NV_optimus
  VK_LAYER_MANGOHUD_overlay
  VK_LAYER_MESA_device_select
  VK_LAYER_VALVE_steam_overlay_32
  VK_LAYER_VALVE_steam_overlay_64
  VK_LAYER_VALVE_steam_fossilize_32
  VK_LAYER_VALVE_steam_fossilize_64
  VK_LAYER_MESA_overlay
Vulkan instance extensions required by SDL2: 
  VK_KHR_surface
  VK_KHR_xlib_surface
Supported Vulkan instance extensions: 
  VK_KHR_device_group_creation (requested)
  VK_KHR_display
  VK_KHR_external_fence_capabilities
  VK_KHR_external_memory_capabilities
  VK_KHR_external_semaphore_capabilities
  VK_KHR_get_display_properties2
  VK_KHR_get_physical_device_properties2
  VK_KHR_get_surface_capabilities2
  VK_KHR_surface (requested)
  VK_KHR_surface_protected_capabilities
  VK_KHR_wayland_surface
  VK_KHR_xcb_surface
  VK_KHR_xlib_surface (requested)
  VK_EXT_acquire_xlib_display
  VK_EXT_debug_report (requested)
  VK_EXT_debug_utils (requested)
  VK_EXT_direct_mode_display
  VK_EXT_display_surface_counter
SLI: using device group 0 with 1 device(s).
Physical device 0: NVIDIA GeForce RTX 3060
Supported Vulkan device extensions:
  VK_KHR_16bit_storage
  VK_KHR_8bit_storage
  VK_KHR_acceleration_structure
  VK_KHR_bind_memory2
  VK_KHR_buffer_device_address
  VK_KHR_copy_commands2
  VK_KHR_create_renderpass2
  VK_KHR_dedicated_allocation
  VK_KHR_deferred_host_operations
  VK_KHR_depth_stencil_resolve
  VK_KHR_descriptor_update_template
  VK_KHR_device_group
  VK_KHR_draw_indirect_count
  VK_KHR_driver_properties
  VK_KHR_dynamic_rendering
  VK_KHR_external_fence
  VK_KHR_external_fence_fd
  VK_KHR_external_memory
  VK_KHR_external_memory_fd
  VK_KHR_external_semaphore
  VK_KHR_external_semaphore_fd
  VK_KHR_format_feature_flags2
  VK_KHR_fragment_shader_barycentric
  VK_KHR_fragment_shading_rate
  VK_KHR_get_memory_requirements2
  VK_KHR_global_priority
  VK_KHR_image_format_list
  VK_KHR_imageless_framebuffer
  VK_KHR_maintenance1
  VK_KHR_maintenance2
  VK_KHR_maintenance3
  VK_KHR_maintenance4
  VK_KHR_multiview
  VK_KHR_pipeline_executable_properties
  VK_KHR_pipeline_library
  VK_KHR_present_id
  VK_KHR_present_wait
  VK_KHR_push_descriptor
  VK_KHR_ray_query
  VK_KHR_ray_tracing_maintenance1
  VK_KHR_ray_tracing_pipeline
  VK_KHR_relaxed_block_layout
  VK_KHR_sampler_mirror_clamp_to_edge
  VK_KHR_sampler_ycbcr_conversion
  VK_KHR_separate_depth_stencil_layouts
  VK_KHR_shader_atomic_int64
  VK_KHR_shader_clock
  VK_KHR_shader_draw_parameters
  VK_KHR_shader_float16_int8
  VK_KHR_shader_float_controls
  VK_KHR_shader_integer_dot_product
  VK_KHR_shader_non_semantic_info
  VK_KHR_shader_subgroup_extended_types
  VK_KHR_shader_subgroup_uniform_control_flow
  VK_KHR_shader_terminate_invocation
  VK_KHR_spirv_1_4
  VK_KHR_storage_buffer_storage_class
  VK_KHR_swapchain
  VK_KHR_swapchain_mutable_format
  VK_KHR_synchronization2
  VK_KHR_timeline_semaphore
  VK_KHR_uniform_buffer_standard_layout
  VK_KHR_variable_pointers
  VK_KHR_vulkan_memory_model
  VK_KHR_workgroup_memory_explicit_layout
  VK_KHR_zero_initialize_workgroup_memory
  VK_EXT_4444_formats
  VK_EXT_attachment_feedback_loop_layout
  VK_EXT_blend_operation_advanced
  VK_EXT_border_color_swizzle
  VK_EXT_buffer_device_address
  VK_EXT_calibrated_timestamps
  VK_EXT_color_write_enable
  VK_EXT_conditional_rendering
  VK_EXT_conservative_rasterization
  VK_EXT_custom_border_color
  VK_EXT_depth_clip_control
  VK_EXT_depth_clip_enable
  VK_EXT_depth_range_unrestricted
  VK_EXT_descriptor_indexing
  VK_EXT_discard_rectangles
  VK_EXT_display_control
  VK_EXT_extended_dynamic_state
  VK_EXT_extended_dynamic_state2
  VK_EXT_external_memory_dma_buf
  VK_EXT_external_memory_host
  VK_EXT_fragment_shader_interlock
  VK_EXT_global_priority
  VK_EXT_global_priority_query
  VK_EXT_graphics_pipeline_library
  VK_EXT_host_query_reset
  VK_EXT_image_2d_view_of_3d
  VK_EXT_image_drm_format_modifier
  VK_EXT_image_robustness
  VK_EXT_image_view_min_lod
  VK_EXT_index_type_uint8
  VK_EXT_inline_uniform_block
  VK_EXT_line_rasterization
  VK_EXT_load_store_op_none
  VK_EXT_memory_budget
  VK_EXT_mesh_shader
  VK_EXT_multi_draw
  VK_EXT_mutable_descriptor_type
  VK_EXT_non_seamless_cube_map
  VK_EXT_opacity_micromap
  VK_EXT_pci_bus_info
  VK_EXT_physical_device_drm
  VK_EXT_pipeline_creation_cache_control
  VK_EXT_pipeline_creation_feedback
  VK_EXT_pipeline_robustness
  VK_EXT_post_depth_coverage
  VK_EXT_primitive_topology_list_restart
  VK_EXT_primitives_generated_query
  VK_EXT_private_data
  VK_EXT_provoking_vertex
  VK_EXT_queue_family_foreign
  VK_EXT_robustness2
  VK_EXT_sample_locations
  VK_EXT_sampler_filter_minmax
  VK_EXT_scalar_block_layout
  VK_EXT_separate_stencil_usage
  VK_EXT_shader_atomic_float
  VK_EXT_shader_demote_to_helper_invocation
  VK_EXT_shader_image_atomic_int64
  VK_EXT_shader_module_identifier
  VK_EXT_shader_subgroup_ballot
  VK_EXT_shader_subgroup_vote
  VK_EXT_shader_viewport_index_layer
  VK_EXT_subgroup_size_control
  VK_EXT_texel_buffer_alignment
  VK_EXT_tooling_info
  VK_EXT_transform_feedback
  VK_EXT_vertex_attribute_divisor
  VK_EXT_vertex_input_dynamic_state
  VK_EXT_ycbcr_2plane_444_formats
  VK_EXT_ycbcr_image_arrays
  VK_NV_clip_space_w_scaling
  VK_NV_compute_shader_derivatives
  VK_NV_cooperative_matrix
  VK_NV_copy_memory_indirect
  VK_NV_corner_sampled_image
  VK_NV_coverage_reduction_mode
  VK_NV_cuda_kernel_launch
  VK_NV_dedicated_allocation
  VK_NV_dedicated_allocation_image_aliasing
  VK_NV_device_diagnostic_checkpoints
  VK_NV_device_diagnostics_config
  VK_NV_device_generated_commands
  VK_NV_fill_rectangle
  VK_NV_fragment_coverage_to_color
  VK_NV_fragment_shader_barycentric
  VK_NV_fragment_shading_rate_enums
  VK_NV_framebuffer_mixed_samples
  VK_NV_geometry_shader_passthrough
  VK_NV_inherited_viewport_scissor
  VK_NV_linear_color_attachment
  VK_NV_memory_decompression
  VK_NV_mesh_shader
  VK_NV_optical_flow
  VK_NV_ray_tracing
  VK_NV_ray_tracing_invocation_reorder
  VK_NV_ray_tracing_motion_blur
  VK_NV_representative_fragment_test
  VK_NV_sample_mask_override_coverage
  VK_NV_scissor_exclusive
  VK_NV_shader_image_footprint
  VK_NV_shader_sm_builtins
  VK_NV_shader_subgroup_partitioned
  VK_NV_shading_rate_image
  VK_NV_viewport_array2
  VK_NV_viewport_swizzle
  VK_NVX_binary_import
  VK_NVX_image_view_handle
  VK_NVX_multiview_per_view_attributes
Physical device 1: llvmpipe (LLVM 11.0.1, 256 bits)
Supported Vulkan device extensions:
  VK_KHR_bind_memory2
  VK_KHR_dedicated_allocation
  VK_KHR_driver_properties
  VK_KHR_get_memory_requirements2
  VK_KHR_incremental_present
  VK_KHR_maintenance1
  VK_KHR_relaxed_block_layout
  VK_KHR_sampler_mirror_clamp_to_edge
  VK_KHR_storage_buffer_storage_class
  VK_KHR_swapchain
  VK_EXT_external_memory_dma_buf
  VK_EXT_private_data
  VK_GOOGLE_decorate_string
  VK_GOOGLE_hlsl_functionality1
Picked physical device 0: NVIDIA GeForce RTX 3060
Using VK_KHR_ray_query
FP16 support: yes
-----------------------
SDL mouse initialized.
====== Quake II RTX initialized ======

No server running.
Loaded game library from /home/shared/Games/quake2/xatrix/gamex86_64.so
Game is starting up.
Game is xatrix built on Dec 11 2022.
------- Server Initialization -------
SpawnServer: ntro.cin
0 entities inhibited.
0 teams with 0 entities.
-------------------------------------
Requesting connection... 1
Connected to loopback (protocol 36).
Can't "invuse", not connected
------- Server Initialization -------
SpawnServer: base1
28 entities inhibited.
1 teams with 2 entities.
-------------------------------------
Changing map...
Reconnecting...
Outer Base
loading base1
Execing maps/default.cfg
==== ShutdownGame ====
Shutting down OpenAL.
Closing console log.

MP2 - Ground Zero: Thaelite Mines - Game crash

Game crashes when spider enters:

====== Quake II RTX initialized ======

Loaded game library from /home/shared/Games/quake2/rogue/gamex86_64.so
Game is starting up.
Game is rogue built on Feb 14 2023.
------- Server Initialization -------
SpawnServer: rware2
162 entities inhibited.
1 teams repaired
13 teams with 27 entities.
G_PickTarget: target t119 not found
monster_stalker can't find target t119 at (1532 -388 1042)
G_PickTarget: target t123 not found
monster_stalker can't find target t123 at (2988 -924 1069)
droptofloor: item_pack startsolid at (1664 -2176 1128)
-------------------------------------
Requesting connection... 1
Connected to loopback (protocol 36).
Waterfront Storage
loading rware2
Execing maps/default.cfg
]./q2rtx: symbol lookup error: /home/shared/Games/quake2/rogue/gamex86_64.so: undefined symbol: _isnan

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.