mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-18 23:59:59 -04:00
Merge the fixes line: the stutter, memory, flicker and crash fixes, co-op, the mesh shader fallback and the launcher fixes.
Brought onto the line with FSR 4, its frame generation and the debug menu. Where both sides had added to the same place, both stay: the patch table keeps the pickup count and the free camera, the settings list keeps both sides' names, the menu includes the co-op page and the debug menu, and the launcher builder takes the pipeline list and the FSR 4 folder. Both sides had added the menu's typed-character event; one definition stays, with the window code that passes characters outside the basic plane. Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
@@ -2,6 +2,10 @@
|
||||
# Each line shows the default; on a Steam Deck the device profile ([display]) changes a few of them. A NX2NAVI_*
|
||||
# environment variable of the same name (NX2NAVI_FPS_LIMIT for fps_limit) overrides the file. Keys are case-insensitive;
|
||||
# '#' and ';' start a comment; [sections] only group lines.
|
||||
# Only the keys in this file are settings. A line with any other key does nothing: the game's log names it at the
|
||||
# start ("no setting of this version") and the settings menu (F1) shows it in its bottom row.
|
||||
# Updates and rebuilds of the game never rewrite nx2navi.ini; the settings menu changes only the lines of the settings
|
||||
# it changes and keeps every other line as it is.
|
||||
|
||||
[frame rate]
|
||||
# Frame rate limit: 30, 40, 45, 60, 90, 120, 144, any whole rate from 30 to 240, display (the refresh rate of the
|
||||
@@ -15,9 +19,9 @@
|
||||
# 36 do, while 60 does not. vk_present = immediate shows a frame as soon as it is presented, without this quantisation,
|
||||
# at the cost of tearing. A monitor running with variable refresh (FreeSync, G-Sync) follows the frames instead, so
|
||||
# there any limit inside its range is even.
|
||||
# With frame generation on (framegen, [display]) the limit counts the frames on screen, generated ones included: the
|
||||
# game draws the limit divided by the multiplier. Unset, the limit is then the monitor's refresh rate instead of 60, so
|
||||
# at 4x on a 165 Hz monitor the game draws about 41 fps and the screen shows 165; a limit set here is kept as it is.
|
||||
# With frame generation on (framegen, [display]) the limit still counts the frames the game draws, and the generated
|
||||
# frames come on top: 60 at 4x is 60 drawn and 240 on screen. Only display counts the frames on screen, so there the
|
||||
# game draws the monitor's rate divided by the multiplier.
|
||||
# fps_limit = 60
|
||||
# Where RivaTuner Statistics Server is installed and running, the limit goes into its profile for the game's
|
||||
# executable and RTSS does the limiting instead of the game; closing the game puts back what the profile held.
|
||||
@@ -40,6 +44,10 @@
|
||||
# in a frame shorter than 1/240 s, so things standing on moving platforms were left behind. 1 rounds the step count
|
||||
# up instead; 0 is the game's own count.
|
||||
# physics_steps = 1
|
||||
# The number in the window that shows a pick-up (a rupee) counts up by whole steps a frame, and above 60 fps the game
|
||||
# rounded that step down to nothing: the window stayed until the area was left and its counting sound went on. 1 lets
|
||||
# it count at least one a frame; 0 is the game's own count.
|
||||
# pickup_count = 1
|
||||
# The step the game is given each frame: 1 keeps it steady (the same value from frame to frame while the frame rate
|
||||
# holds, exactly one 60 Hz frame at a 60 fps limit) and makes up for a late frame over the next second; 0 is the mean
|
||||
# of the last five frame times, which changes with every frame.
|
||||
@@ -97,9 +105,17 @@
|
||||
# Draws whose pipeline is still building: default waits on a reserved worker; draw is the previous scheduling.
|
||||
# pipe_wait = default
|
||||
# Which draws are dropped instead of waiting for their pipeline: strict (only draws into per-frame passes), any (also
|
||||
# draws into passes whose target a recent frame rendered; full-screen draws wait, up to 50 ms a frame) or fullscreen
|
||||
# draws into passes whose target a recent frame rendered; full-screen draws wait, from pipe_frame_wait_ms) or fullscreen
|
||||
# (those and full-screen draws: no wait, but a lighting or fog pass that is dropped shows as a black or unlit frame).
|
||||
# pipe_skip = any
|
||||
# How many milliseconds one frame may wait, in all, for the shaders and pipelines of its full-screen draws and of
|
||||
# draws into pictures drawn for the first time (0 to 500). What is not ready by then is left out of that frame and
|
||||
# built in the background.
|
||||
# pipe_frame_wait_ms = 50
|
||||
# A picture the game has drawn in many frames counts as drawn every frame after a pause too (a loading screen, a
|
||||
# menu), so the first frame of an area leaves a draw out while its pipeline is built instead of stopping for it.
|
||||
# 0: as up to 0.7.1, such a frame waits for each new pipeline in turn.
|
||||
# pipe_skip_steady = 1
|
||||
# How many milliseconds the draws of one frame may wait, in all, for a missing pipeline to be linked from the shader
|
||||
# libraries in the graphics driver's cache before they are dropped (0 to 100; 0: dropped at once, as before).
|
||||
# pipe_link_ms = 6
|
||||
@@ -119,13 +135,12 @@
|
||||
# NVIDIA under Windows, Shader Cache Size Unlimited in the NVIDIA app), start once with force, or delete
|
||||
# shader-warm.txt, to warm again.
|
||||
# lib_warm = 1
|
||||
# How long (ms) a draw into a target no recent frame rendered waits for a pipeline built for the first time,
|
||||
# then is skipped. The default waits, as such a target (a lookup table, a new area's target) can stay empty if
|
||||
# skipped; a lower value caps the stall.
|
||||
# Draws into a picture drawn for the first time (a lookup table, a new area's target) wait for a pipeline built for
|
||||
# the first time from pipe_frame_wait_ms; one left over is drawn the next frame its picture is drawn. 0: as up to
|
||||
# 0.7.1, each such draw waits up to oneshot_wait_ms milliseconds, which stops the game for as long as the pipelines
|
||||
# of a new area take to build.
|
||||
# oneshot_budget = 1
|
||||
# oneshot_wait_ms = 30000
|
||||
# 1: those draws share a wait budget per presented frame instead (100 ms for large passes, 300 ms for small ones); a
|
||||
# draw left over is drawn the next frame its target is drawn. Shortens the long first frame of a new area.
|
||||
# oneshot_budget = 0
|
||||
# Build shader stage libraries in the background ahead of time, and the threads for it (1 to 16; default 2). More
|
||||
# threads mostly wait on the graphics driver's lock: 16 on NVIDIA spent about 8 cores spinning in the driver.
|
||||
# lib_prebuild = 1
|
||||
@@ -146,10 +161,29 @@
|
||||
# (0: no limit). Each large shader costs the driver 1-4 GB; on a 31 GB machine four of them took the process from 15 to
|
||||
# 29 GB and the game stuttered, so raise this only on a machine with room to spare.
|
||||
# big_build_max_mb = 4096
|
||||
# Memory kept free of pipelines built ahead of their first use (at the start and in the background during play), in MB
|
||||
# of commit headroom: RAM plus page file not yet promised to a program. Such a build starts only while this much stays
|
||||
# free beyond what the builds already running are counted for; otherwise it waits or is left to the moment the game
|
||||
# first needs the pipeline, which can hold a frame once but does not push a full machine into paging. A pipeline a
|
||||
# draw is waiting for is always built. 0: no check. Default: 4096.
|
||||
# build_free_mb = 4096
|
||||
# What each such build is counted for while it runs, in MB: the working memory of the video driver's shader compiler.
|
||||
# A very large compute shader is counted for 4096. Default: 64.
|
||||
# build_reserve_mb = 64
|
||||
# 1: the log says how many pipelines came from pipeline-cache.bin; 2 also logs every compute pipeline built. 0: off.
|
||||
# pipe_feedback = 1
|
||||
# pipeline-cache.bin larger than this (MB) starts empty and is rewritten (0: no limit).
|
||||
# pipeline_cache_max_mb = 512
|
||||
# 1: the pipelines a run compiles go into pipeline-cache-play.bin, a small file of its own, so pipeline-cache.bin
|
||||
# (hundreds of MB) is not written again while you play; the small file is folded into the large one at a start once
|
||||
# it has grown. 0: one file, written whole whenever a run made a new pipeline.
|
||||
# pipeline_cache_play = 1
|
||||
# The size (MB) at which pipeline-cache-play.bin is folded into pipeline-cache.bin at a start.
|
||||
# pipeline_cache_play_mb = 64
|
||||
# 1: the pipelines FSR 3.1 makes for upscaling and frame generation are kept in the pipeline cache files, so a later
|
||||
# start does not compile them again. 0: FSR 3.1 creates them without those files, as the graphics driver alone keeps
|
||||
# them.
|
||||
# ffx_pipe_cache = 1
|
||||
# 1: where the driver has VK_KHR_pipeline_binary, compiled pipelines are kept in pipeline-binaries.bin under the
|
||||
# runtime's own keys, so a renamed or updated exe starts without compiling them again (pipeline-cache.bin is then
|
||||
# not used). Default 0 (pipeline-cache.bin only) while it is being tested.
|
||||
@@ -169,7 +203,10 @@
|
||||
# the new translator cannot translate keeps its old translation. 0: shaders the new translator has not translated yet
|
||||
# are translated before they are used (at start or when the game first draws them), as earlier versions did.
|
||||
# shader_carry = 1
|
||||
# Vulkan graphics pipeline library, 0 or 1. Default: on.
|
||||
# Vulkan graphics pipeline library, 0 or 1. Default: on, except with AMD's Windows driver for RX 6000 and older cards
|
||||
# (RX 400 to RX 6000), where the game ended at every enemy killed with it on. There it is off: a pipeline needed for
|
||||
# the first time is built whole while its draw is left out for some frames, and the start waits until every pipeline
|
||||
# of earlier sessions is built. gpl = 1 turns it on again.
|
||||
# gpl = 1
|
||||
|
||||
# Textures and memory.
|
||||
@@ -191,6 +228,11 @@
|
||||
# memory = auto
|
||||
# A new texture created over a live texture's memory starts with that content instead of empty.
|
||||
# tex_alias = 1
|
||||
# A new depth image is cleared at the place in the frame where the game makes it (1, default), not ahead of the
|
||||
# frame's other work: made ahead, the clear could wipe depth that draws of the same frame still read, and the sun's
|
||||
# shadow went fully dark for one frame a few times a minute where the game resizes its shadow maps (a town gate).
|
||||
# 0: cleared ahead, as before. depth_alias_log = 1 logs each new depth image made over a live texture, with its frame.
|
||||
# depth_init_inline = 1
|
||||
# Small texture uploads stage in ranges of a few kept buffers instead of a new buffer each (0 = a buffer each).
|
||||
# stg_arena = 1
|
||||
# With astc = gpu: the compute shader reads the blocks in the game's tiled layout, so the CPU only copies the
|
||||
@@ -205,19 +247,29 @@
|
||||
# A render target that needs an image of its own takes the image of a released one of the same size and format
|
||||
# instead of making a new one (0 = always a new image).
|
||||
# tex_reuse = 1
|
||||
# A texture the game does not fill from the CPU itself, made over memory the CPU writes (a second description of a
|
||||
# texture's bytes), starts with those bytes and takes the game's later writes to them until something is drawn into
|
||||
# it (1, default). 0: it starts empty, as before, and what is drawn with it can come out flat and pale. 2: it gets
|
||||
# the bytes once and no later write. Costs an upload for each such texture; a render target the game makes over
|
||||
# CPU memory starts with the last picture left there instead of an empty one.
|
||||
# tex_split_fill = 1
|
||||
# 1: shaders mark the textures they sample, so that while video memory or the system's memory runs low, textures no
|
||||
# shader sampled for a while go, even those the game keeps registered (the areas it has loaded); one sampled again is
|
||||
# made again within a few frames. The first start after changing it builds the pipelines again. 0: such textures stay.
|
||||
# 2 (diagnosis): the same marks, and such textures give way to stand-ins in the texture pool, but none is freed.
|
||||
# tex_disuse = 1
|
||||
# Whether such textures really go under pressure. Off by default: after such evictions the ground of some areas was
|
||||
# drawn flat and see-through and stayed so. 1 turns it on (it frees more memory when memory runs short).
|
||||
# tex_disuse_evict = 0
|
||||
# Percent of the video memory in use above which textures give way: first those the game released, then those no
|
||||
# shader sampled for a while (tex_disuse); each is made again when used. The default lies under the 87 percent past
|
||||
# which game memory gets no copy in video memory (memory = mirror), which costs far more frame time than a texture
|
||||
# uploaded again. 0: textures never give way for video memory.
|
||||
# tex_vram_pressure = 80
|
||||
# Megabytes this process may commit before textures give way as they do while the system's commit runs low (Windows
|
||||
# counts video memory against the commit). Default: the installed memory, at least 24576, so that it does not depend
|
||||
# on the size of the page file. 0: no bound of its own; only the system's commit counts. On Linux it counts the
|
||||
# Megabytes this process may commit before textures give way as they do while the system's commit runs low. Windows
|
||||
# counts video memory against the commit; with a discrete GPU the video memory in use is left out of the comparison,
|
||||
# since it is not in RAM. Default: the installed memory, at least 24576, so that it does not depend on the size of the
|
||||
# page file. 0: no bound of its own; only the system's commit counts. On Linux it counts the
|
||||
# process's resident anonymous memory, which stays under the installed memory, so there only a smaller value holds.
|
||||
# tex_proc_commit_mb = 32768
|
||||
# 1: a texture the game releases or takes back, with nothing else changed at its address, puts the texture table's
|
||||
@@ -225,8 +277,8 @@
|
||||
# back thousands a second). 0: every release and take-back counts as a new state.
|
||||
# tex_gen_undo = 1
|
||||
# Host zstd decoder in place of the game's (0 = the game's), and a check that decodes every call both ways and logs
|
||||
# the differences (1 = on; slow). Ocarina of Time 1.1.1 keeps the game's decoder while zstd_native is unset: its host
|
||||
# decoding has not been through a check run yet, so there it takes zstd_native = 1 (or the check) to turn it on.
|
||||
# the differences (1 = on; slow). Ocarina of Time 1.1.1 decodes on the host too since a check run over a village and a
|
||||
# field found no difference in 3,072 files; zstd_native = 0 keeps the game's own decoder there.
|
||||
# zstd_native = 1
|
||||
# zstd_check = 0
|
||||
|
||||
@@ -358,8 +410,9 @@
|
||||
# more, with smaller levels) without that level, low without the two largest when they are 1024x1024 or more. Surfaces
|
||||
# seen up close look softer; interface art, small textures, shadow maps and everything the game draws itself keep their
|
||||
# size. auto picks by the video memory Windows grants the game: full from 8192 MiB (cards of 10 GB and more), low under
|
||||
# 6144 MiB (cards of 6 GB and less), reduced between (8 GB cards). The log says what was picked ("texture detail:").
|
||||
# Read at start.
|
||||
# 6144 MiB (cards of 6 GB and less), reduced between (8 GB cards). Where the ASTC textures stay uncompressed (astc =
|
||||
# cpu or astc_bc = 0) and the budget is under 20480 MiB, auto goes one step lower, as they take four times the memory.
|
||||
# The log says what was picked ("texture detail:"). Read at start.
|
||||
# texture_detail = auto
|
||||
# Sun shadow map size: game (the game's own, which changes with the view and drops to about 400 near the ground, so
|
||||
# leaf shadows look blocky and jump) or a fixed 256, 512, 768, 1024, 1536 or 2048. Above 960 the texture heap grows with
|
||||
@@ -443,20 +496,19 @@
|
||||
# frame between every two the game draws, the HUD kept out of it) or dlss (NVIDIA DLSS Frame Generation on GeForce RTX
|
||||
# 40 and 50 GPUs, paced with Reflex; it needs nx2navi_dlssg.dll and NVIDIA Streamline's files next to the executable,
|
||||
# which the setup puts there). Both need DLSS or FSR 3.1 upscaling (dlaa = 1). While frame generation runs, fps_limit
|
||||
# counts the frames on screen, generated ones included: the game draws the limit divided by the multiplier (2 for fsr3).
|
||||
# With fps_limit unset it is the display's rate.
|
||||
# counts the frames the game draws and the screen shows that times the multiplier (2 for fsr3); fps_limit = display
|
||||
# alone holds the screen to the monitor's rate and the game to that rate divided by the multiplier.
|
||||
# fsr3 takes effect at once, dlss (on or off) at the next start.
|
||||
# framegen = off
|
||||
# On Linux dlss runs through NVIDIA's NGX itself, without Streamline: it needs dlaa = 1 with DLSS when the game starts
|
||||
# and NVIDIA's libnvidia-ngx-dlssg.so.<version> (from NVIDIA's DLSS SDK repository) beside the game, then switches at
|
||||
# once, and its multiplier is fg_mult: 2 to 6 (above 2 needs an RTX 50 GPU) or dynamic, which generates only the frames
|
||||
# needed to reach the display's refresh rate at the rate the game draws. There fps_limit counts the frames the game
|
||||
# draws, and framegen_multiplier is not used.
|
||||
# needed to reach the display's refresh rate at the rate the game draws. framegen_multiplier is not used there.
|
||||
# fg_mult = 2
|
||||
# DLSS frame generation's multiplier: the frames on screen for each frame the game draws, 2, 3 or 4 (one, two or three
|
||||
# generated). 2 needs an RTX 40 GPU or newer, 3 and 4 an RTX 50 and a current driver. A value above what the GPU and
|
||||
# driver allow (Streamline reports it) is lowered to that, with a line in the log; the menu offers only what they allow.
|
||||
# Each step adds a little latency, and on a 60 Hz display 4 leaves the game drawing 15 fps. Changes while the game runs
|
||||
# Each step adds a little latency, and a display shows no more than its refresh rate. Changes while the game runs
|
||||
# take effect at once.
|
||||
# framegen_multiplier = 2
|
||||
|
||||
@@ -472,20 +524,30 @@
|
||||
# hdr_peak_nits = 1000
|
||||
# hdr_game_nits = 203
|
||||
# hdr_ui_nits = 203
|
||||
# With hdr = 1: gamma correction (off, 2.2 or 2.4) shows the picture as a display of that power would, as the game was
|
||||
# made to be seen; off keeps the sRGB curve. The tone mapper: vanilla is the game's own curve at SDR brightness,
|
||||
# renodrt carries the game's look up to the peak.
|
||||
# hdr_gamma = 2.2
|
||||
# hdr_tonemap = renodrt
|
||||
# With renodrt: exposure in percent (100 unchanged); highlights, shadows, contrast, saturation and highlight saturation
|
||||
# from 0 to 100 (50 unchanged); blowout (bright parts towards white) and flare (lifted blacks) from 0 to 100 (0 none);
|
||||
# hue correction in percent (how much bright colours keep their hue); grade, the percentage of the game's own colour
|
||||
# grading the picture keeps.
|
||||
# With hdr = 1, the tone mapper: vanilla is the game's own curve at SDR brightness; psychov35 sends the scene through a
|
||||
# model of the eye's response, matched to the game's mid grey and tone, up to the peak; renodrt carries the game's SDR
|
||||
# look up to the peak by brightness.
|
||||
# hdr_tonemap = psychov35
|
||||
# With psychov35: where the scene's mid grey lands (vanilla: where the game's curve puts it; render: at the scene's
|
||||
# value); whether the mid tones get the contrast of the game's curve; the tone curve's steepness through mid grey from
|
||||
# 0 to 100 (50 unchanged); and in percent how much bright colours turn as where the game's SDR picture clips (fire
|
||||
# towards yellow and white).
|
||||
# hdr_midgray = vanilla
|
||||
# hdr_match_slope = 1
|
||||
# hdr_tone_slope = 50
|
||||
# hdr_hue_clip = 50
|
||||
# With psychov35 and renodrt: exposure in percent (100 unchanged); highlights, shadows, contrast and saturation from 0
|
||||
# to 100 (50 unchanged).
|
||||
# hdr_exposure = 100
|
||||
# hdr_highlights = 50
|
||||
# hdr_shadows = 50
|
||||
# hdr_contrast = 50
|
||||
# hdr_saturation = 50
|
||||
# With renodrt: gamma correction (off, 2.2 or 2.4) shows the picture as a display of that power would, off keeps the
|
||||
# sRGB curve; highlight saturation from 0 to 100 (50 unchanged); blowout (bright parts towards white) and flare (lifted
|
||||
# blacks) from 0 to 100 (0 none); hue correction in percent (how much bright colours keep their hue); grade, the
|
||||
# percentage of the game's own colour grading the picture keeps.
|
||||
# hdr_gamma = 2.2
|
||||
# hdr_highlight_sat = 50
|
||||
# hdr_blowout = 0
|
||||
# hdr_flare = 0
|
||||
@@ -515,6 +577,69 @@
|
||||
# The key of the application's uploaded art asset (Rich Presence > Art Assets) shown as the status's large image.
|
||||
# discord_image = nx2navi_512x512
|
||||
|
||||
[coop]
|
||||
# Co-op: your own game and save, with the other players' progress shared through a relay (docs/coop.md). Positions are
|
||||
# not shared yet: you do not see the other players in your world.
|
||||
# The menu's Co-op tab sets the name, the relay and the rules below, and makes, joins, accepts and leaves a room.
|
||||
# 0 = off: no socket is opened, no name is looked up and nothing is sent. Takes effect at once.
|
||||
# coop = 0
|
||||
# Your name for the other players, at most 24 bytes. Default: Player- and four random hex digits.
|
||||
# coop_name =
|
||||
# The relay, host or host:port (default port 24680): run one with `python tools/coop_relay.py` and forward its UDP port, or
|
||||
# use one a friend runs. No default: with none set the session stays idle and the log says why.
|
||||
# coop_server =
|
||||
# The local UDP port, 0 = any. For a firewall rule or a port forward when testing on a LAN. Takes effect at the next start.
|
||||
# coop_port = 0
|
||||
# For tests and LAN parties, no menu row: coop_auto = create or join starts a session at launch (a join needs coop_room, the
|
||||
# room's secret of 18 characters from 23456789BCDFGHJKMNPRSTVWXYZ, XXXXXX-XXXXXX-XXXXXX; a create without it makes a new
|
||||
# one). While the session runs, a room the relay lost (a restart) is made again or waited for (asked for every 10 s; a
|
||||
# refusal for too many joins from your network waits a minute), and a create that finds the room open joins it. Joining
|
||||
# is not accepting: nothing from the room is applied before you accept it (coop_accept).
|
||||
# off = no session at launch.
|
||||
# coop_auto = off
|
||||
# coop_room =
|
||||
# Test: percent of received co-op datagrams thrown away, 0 to 100.
|
||||
# coop_drop = 0
|
||||
# The rules of a room you make (a room you join uses its maker's; the log names them). Take effect at once.
|
||||
# Story, world and dungeon progress: shared or own.
|
||||
# coop_progress = shared
|
||||
# Equipment, key items, upgrades; songs; medallions, stones and the other quest items: shared or own. Own only with
|
||||
# coop_progress = own: in a shared world a chest one player opened is empty for the others.
|
||||
# coop_items = shared
|
||||
# coop_songs = shared
|
||||
# coop_quest = shared
|
||||
# Small keys: pool = every key anyone picks up goes into the dungeon's pool and every door anyone opens takes one out of it;
|
||||
# own = keys stay with the player who picked them up (doors still open for everyone). Own with coop_progress = own.
|
||||
# coop_keys = pool
|
||||
# Rupees and ammunition: own, or pool = one count every player adds to and spends from.
|
||||
# coop_rupees = own
|
||||
# coop_ammo = own
|
||||
# Nothing from a room is applied to your game before you accept who is in it (by their keys) and its rules, and before
|
||||
# your save is copied to coop-backup in the profile folder (docs/coop.md: going back). ask = the log shows each room's
|
||||
# offer with a number (eight hex digits, new at each start of the game); accept it on the menu's Co-op tab, or put that
|
||||
# number here while the game runs to accept that offer (this line as the file is now counts, before the one read at
|
||||
# start). A new member, other rules or another save loaded make a new offer with a new number (another save joins the
|
||||
# pools only once you accept it). A member who never says who it is keeps the room from being accepted. Your key pools
|
||||
# count only you and the players you accepted, among those the room's maker lets use them. Every message that can
|
||||
# change your save is signed by the player who sent it, so someone who knows the room's secret and runs the relay (or
|
||||
# sends from its address on your network) can read and disturb the room but not set flags in a player's name.
|
||||
# Accepting every room (always) is taken from the environment only (NX2NAVI_COOP_ACCEPT=always), never from this file,
|
||||
# so an ini someone hands you cannot accept a room for you.
|
||||
# coop_accept = ask
|
||||
# The room's maker (the Co-op tab's Remove and Reset the pools do the same): coop_remove = a player's key fingerprint
|
||||
# (xxxx-xxxx-xxxx-xxxx, as the log and the tab show it beside each member; without dashes it may be all digits), in the
|
||||
# room or after it left; every game drops that key and what it took from the pools, and keys others brought while it
|
||||
# was in a pool stay theirs. A member number here is not taken: numbers pass to other players as members come and go.
|
||||
# coop_reset_pools = a new value (1, then 2, or 0 and then 1 again): every game joins the pools again with what they
|
||||
# held for the players in the room, and what each held counts from the reset on. A player who drained a pool and is
|
||||
# still in the room when you reset keeps what it took: remove it first, then reset (both in one save of this file act
|
||||
# in that order).
|
||||
# Both are read from this file once a second while you are in a room, and each value acts once. The key your game signs
|
||||
# the rules of a room you made with is kept in the profile folder (coop-keys, readable by your account only), so a
|
||||
# restart keeps you the room's maker; never hand out a copy of the profile folder.
|
||||
# coop_remove =
|
||||
# coop_reset_pools =
|
||||
|
||||
[audio]
|
||||
# none mixes without opening an audio device.
|
||||
# audio = default
|
||||
@@ -571,7 +696,8 @@
|
||||
# the stick reads centred, and the rest of its travel is scaled to start there.
|
||||
# stick_deadzone = 8
|
||||
# Right-stick camera speed (0.1 to 3): multiplies the game's own camera turn rates, top speed included, at each of the
|
||||
# five camera sensitivities in the game's Options. Keys bound to the right stick follow it; the mouse keeps mouse_sens.
|
||||
# five camera sensitivities in the game's Options. Keys bound to the right stick follow it; the mouse keeps mouse_sens
|
||||
# for its turn per movement, and in stick mode the fastest turn it can reach rises and falls with this.
|
||||
# A change while the game runs takes effect at once (the first one of a run within a few seconds).
|
||||
# stick_sens = 1
|
||||
# The dead zone of one stick, in place of stick_deadzone for that stick (0 to 50; unset = stick_deadzone). The Controls
|
||||
@@ -579,10 +705,12 @@
|
||||
# lstick_deadzone = 8
|
||||
# rstick_deadzone = 8
|
||||
# Mouse camera mode: direct (default) or stick. Direct turns the camera by the raw mouse motion, the same on both axes,
|
||||
# with no stick dead zone or response curve. Stick makes the
|
||||
# with no stick dead zone or response curve, at any frame rate and however fast the mouse moves. Stick makes the
|
||||
# mouse a right stick. Neither changes the gamepad. The Controls tab changes this while the game runs.
|
||||
# mouse_mode = direct
|
||||
# Mouse camera sensitivity (0 to 10; 0 = no mouse camera and no cursor capture).
|
||||
# Mouse camera sensitivity (0 to 10; 0 = no mouse camera and no cursor capture). In direct mode a count of the mouse
|
||||
# turns the camera about 0.08 degrees at 1; the game's own camera sensitivity (Options) scales it as it scales the
|
||||
# stick. The Controls tab changes this while the game runs.
|
||||
# mouse_sens = 1
|
||||
# The keyboard's sticks are all or nothing, so the game only sees a full tilt from them; while this key is held the
|
||||
# keyboard-driven stick values shrink and the keyboard can walk instead of run. Key names as in the bind_ lines below,
|
||||
@@ -643,7 +771,7 @@
|
||||
# cheat_0123abcd = 1
|
||||
|
||||
[diagnostics]
|
||||
# Extra lines in the log, comma separated: svc, host, ipc, fs, gfx, perf, sched, audio, present or all. The menu's
|
||||
# Extra lines in the log, comma separated: svc, host, ipc, fs, gfx, perf, sched, audio, present, coop or all. The menu's
|
||||
# Performance log sets perf (frame timings). Default: none.
|
||||
# trace = perf
|
||||
# 1: with trace = perf, walks of the process's address space count its private and write-combined memory every 600
|
||||
@@ -651,6 +779,11 @@
|
||||
# Each walk holds the address-space lock for 100-240 ms and delays the next frame by as much, so they are off unless
|
||||
# asked for.
|
||||
# mem_census = 0
|
||||
# The memory the game is taken to need, in MB of commit (RAM plus page file not yet promised to a program). When less
|
||||
# is free at the start, the log gets a warning line: short of memory the game stutters, loses textures or stops with
|
||||
# an out-of-memory or lost-device error. The default is what the game took in play at 3840x2160 on an RTX 5090; the
|
||||
# video card's memory counts on Windows. 0: no warning. Default: 24576.
|
||||
# mem_need_mb = 24576
|
||||
# The size in MiB (16 to 256) of the blocks the renderer takes video memory in. A block goes back to the driver only once
|
||||
# everything in it is freed, so smaller blocks hold less free space after area changes; larger ones need fewer
|
||||
# allocations while an area loads. Default: 64.
|
||||
@@ -658,6 +791,12 @@
|
||||
# 1: samples each new ASTC texture's blocks on the CPU and logs how many are opaque ("ASTC alpha probe" lines), which
|
||||
# could be stored at half the video memory. Slows area loads. Default: 0.
|
||||
# astc_bc_probe = 0
|
||||
# GPU address history for the report of a lost graphics device, on drivers with
|
||||
# VK_EXT_device_address_binding_report. 1: the game keeps every address range the driver binds to a buffer or image and
|
||||
# every range it unbinds; after a lost device the log names what held each faulting address, and vaddr-history.txt
|
||||
# beside the log holds the whole history. 2: also the call stack that made each range of 1 MiB or more, which slows
|
||||
# area loads enough to hide a fault that depends on timing. Default: 0.
|
||||
# va_report = 0
|
||||
# Flight recorder: keeps the last frames and saves them to a flight folder next to the folder of nx2navi.exe when a frame
|
||||
# takes longer than flight_spike_ms (0 to 60000).
|
||||
# flight = 0
|
||||
@@ -666,6 +805,10 @@
|
||||
# last one it finished. Unset: on AMD GPUs (VK_AMD_buffer_marker). 1: also on NVIDIA GPUs
|
||||
# (VK_NV_device_diagnostic_checkpoints), which NVIDIA says costs a little. 0: off.
|
||||
# pass_crumbs = 1
|
||||
# A test of how the game ends when the video card stops answering (device lost): the hand-over to the GPU queue with
|
||||
# this number is not made and is taken as one the driver refused with a lost device. The log then holds one report and
|
||||
# one FATAL line, and the game ends with exit code 72. 0: never. Default: 0.
|
||||
# device_lost_at = 0
|
||||
# Once a second, puts the crash report's exception filter back if a GPU driver or an overlay loaded after the start set
|
||||
# its own in its place, and says so in the log. Without it, a crash in such a DLL can end the game with no FATAL line in
|
||||
# the log. 0: off.
|
||||
@@ -727,15 +870,51 @@
|
||||
# are made inaccessible until their first read or write, which is logged with its instruction ("mem: write-back
|
||||
# probe"). The bytes are there all along; the probe only watches, at the cost of the faults it takes.
|
||||
# wb_probe = 0
|
||||
# 1: what the GPU wrote goes back to the game's memory in a GPU submission of its own, and the wait after each frame's
|
||||
# first submission ends when that submission's passes are through, without waiting for the copy back (3 to 4 ms of
|
||||
# every frame). 0: the copy back is part of the submission, and the wait covers it.
|
||||
# 0: after each frame's first GPU submission the game waits until the video card has run it and everything before it
|
||||
# has reached the game's memory, the last frame's visibility results among them. 1: the wait ends as soon as the card
|
||||
# has run the submission, and what the card wrote goes back to the game's memory in a submission of its own. That is
|
||||
# about 0.7 ms less of every frame in the open (6 % at 85 frames a second), but the game then reads visibility
|
||||
# results that may be a frame old, and things near the camera can come and go from frame to frame. With shadow
|
||||
# storage (Linux, Wine) 1 changes nothing; 2 forces it there as well, for tests.
|
||||
# wb_split = 1
|
||||
# 1 (the default on Windows): what the game's shaders write into its memory is copied back from the video card once,
|
||||
# and after that only when the game's CPU code touches it (most of it never is: 66 MiB a frame in Hyrule Field), for
|
||||
# about a third more frames a second in open areas. 0: copied back at the end of every GPU submission, as in 0.7.0.
|
||||
# With shadow storage (Linux, Wine) it stays off.
|
||||
# 1: what the game's shaders write into its memory is copied back from the video card once, and after that only when
|
||||
# the game's CPU code touches it (most of it never is: 66 MiB a frame in Hyrule Field), for about a third more frames
|
||||
# a second in open areas. 0: copied back at the end of every GPU submission, as in 0.7.0.
|
||||
# Default: 1 on Windows, except 0 on AMD graphics cards (AMD's own driver), where two reports had the game end in play
|
||||
# with it on and the cause is not found: set 1 there to try it, and back to 0 if the game ends in a fight (the log's
|
||||
# "mem: lazy write-back" line says which is in effect and why). 0 elsewhere. With shadow storage (Linux, Wine) it
|
||||
# stays off whatever is set.
|
||||
# wb_lazy = 1
|
||||
# With wb_lazy, off by default: with it on the graphics device was lost shortly after some save loads (about one load
|
||||
# in three of a save in Hyrule Field at night on one card), and not once in 15 loads with it off; the cause is open.
|
||||
# 1: when the game's CPU code touches such memory, only the 64 KiB around the place it touched are copied
|
||||
# back and kept up to date from then on; the rest of that buffer stays on the video card. The game reads a few words
|
||||
# at the start of buffers of several MiB about twice a second. 0: the whole buffer comes back and everything near it
|
||||
# is copied back every frame for up to 32 seconds, as before (a tenth fewer frames a second in a village).
|
||||
# wb_lazy_chunk = 0
|
||||
# Barriers between the game's draw passes and compute dispatches. 1: only where the game itself asks for one, or where
|
||||
# the work changes between drawing and compute; this takes about a tenth off the graphics card's time for a frame.
|
||||
# 0: a full barrier before every pass and every dispatch. Default: 1 on NVIDIA graphics cards, 0 on all others, where it
|
||||
# has not been tried: set 1 there to try it, and back to 0 if the picture shows faults.
|
||||
# barrier_game = 1
|
||||
# Mesh draws whose count the graphics card computes: 1 (default) prepares the counts of a run of such draws at its
|
||||
# first one, so their draw pass is not ended and begun again at each of them (about 40 passes fewer a frame in a
|
||||
# village). 0: each such draw ends its pass and prepares its own count, as before.
|
||||
# mesh_ahead = 1
|
||||
# Graphics cards without mesh shaders (GTX 10 series, RX 500 and 5000 series, many integrated ones): the game's mesh
|
||||
# draws, most of the world, are computed in compute passes and drawn as ordinary triangles. auto (default) does that
|
||||
# only on such a card; 1 does it on every card (for testing: it is slower than mesh shaders); 0 never, and such a
|
||||
# card then draws no world.
|
||||
# mesh_fallback = auto
|
||||
# Video memory in MB for what those compute passes hand to the draws. A draw that needs more loses the geometry that
|
||||
# does not fit, and the log says so.
|
||||
# mesh_fallback_mb = 128
|
||||
# Windows, 1 (experimental): the game's heap is committed a 64 KiB run at a time where it is first used, instead of
|
||||
# all of it when the game sizes it. Windows counts committed memory against RAM plus the page file whether it is used
|
||||
# or not, and in Castle Town after Hyrule Field about 3.4 of the heap's 6.8 GiB had never been used. 0: committed up
|
||||
# front. Linux commits pages on first use anyway. With 1, a PC whose commit is used up ends the game at the moment a
|
||||
# heap page is first used, in the middle of play, where with 0 it would not have started.
|
||||
# heap_lazy = 0
|
||||
# Linux, shadow storage: 1 clears the write watch's protection of a range in one call before the GPU's bytes are copied
|
||||
# back into the game's memory, instead of taking a fault at the first store into each page.
|
||||
# shadow_bulk_write = 0
|
||||
|
||||
Reference in New Issue
Block a user