Every BB_* variable the port reads, by kind. Made by scripts/env_vars.py --doc from
gpu/shim/bb_env_vars.def; edit that list, not this file. The game prints the variables set
at its start (Environment: in the log) and warns about BB_* names it does not know.
=1: ... / =0: ... / =N: ... say what that value does; set: ... means any value
turns it on (even 0).
What players and the launchers set. The menu, bbport.ini and the launcher write most of them; set one by hand to override them.
| Variable | What it does |
|---|---|
BB_ANISO |
=N: anisotropic filtering of scene textures (default 16) |
BB_ASYNC_PIPELINES |
=0: new pipelines of passes drawn every frame compiled at once instead of skipping a draw for a frame or two |
BB_AUTO_RENDER_RES |
=1: render resolution picked from the measured frame rate |
BB_BBSC |
=1: seamless co-op (BBSC), the launcher's co-op switch |
BB_BBSC_LOCAL_SERVER |
=1 / auto (default) / 0: the BBSC game server on this PC (scripts/bbsc_gameserver) |
BB_BUTTON_PROMPTS |
=0: the game's PlayStation button icons always |
BB_COMMUNITY_SERVER |
URL of the online pool server (default: the community server) |
BB_CONFIG |
=path: the controls file (default bbport.ini) |
BB_CONTENT_SKU |
=full / ...: the content profile run.py prepares |
BB_CURSOR |
=0: the system's mouse cursor instead of the port's |
BB_DECK_DESKTOP_INPUT |
=1: keep keyboard and mouse on a Steam Deck in game mode |
BB_DISPLAY |
=N: the monitor to open the window on |
BB_DLSS |
=0: no DLSS even on NVIDIA RTX |
BB_DMEM_EXTRA_MB |
=N (0-2048, default 512): direct memory beyond the PS4's for the port's extras |
BB_DMEM_MB |
=N: the game's direct memory size in MiB (PS4: 5056; raised for high resolutions and large heaps) |
BB_EVDEV_TOUCHPAD |
=0: no DualSense/DualShock touchpad through evdev |
BB_FFX_DIR |
the folder with AMD's FSR DLLs for Vulkan, amd_fidelityfx_loader_vk.dll and amd_fidelityfx_upscaler_vk.dll (upscaler fsr_amd; default /fsr, then beside the game) |
BB_FFX_FG_ML |
=1: AMD's ML frame generation (4.0.x) accepts any GPU (AMD ships it for RDNA4); =0: refuses it (FSR 3.1) |
BB_FFX_FG_VERSION |
=: the frame generation AMD's DLL runs, from those the log lists (default: theirs) |
BB_FFX_VERSION |
=: the upscaler AMD's FSR DLLs run, from those the log lists (default: theirs) |
BB_FPS |
=uncap (default) / 90 / 60 / 30: the frame rate (the launcher's) |
BB_FPS_LIMIT |
=N: frame rate limit (the launcher's) |
BB_FRAME_GEN |
=fsr3 / dlss / fsr_amd (1: fsr3): frame generation |
BB_FRAME_GEN_MULTIPLIER |
=2..4: frames shown per rendered one with frame generation |
BB_FRAME_STATS |
set: frame statistics in the log every 5 s and slow frames (the launcher's statistics switch) |
BB_FSR411_DIR |
the FSR 4.1.1 assets folder (default fsr4_411) |
BB_FSR411_VARIANT |
=int8 / fp8 / fp8emu / navi2 / lite: FSR 4.1.1 model variant (default: the menu's model) |
BB_FSR4_DIR |
the FSR 4 v07 assets folder (default fsr4_shaders) |
BB_FSR_SHARPNESS |
=0..1: RCAS sharpening (the menu's) |
BB_FULLSCREEN |
=0 / 1 / exclusive: window mode |
BB_GAMEPAD |
=SDL GUID or part of the name: the controller to use (the launcher's) |
BB_GAME_DIR |
the game's folder (with eboot.bin) |
BB_GAME_MENU |
=0: no port pages in the game's System menu |
BB_GPU_ID |
=N: the GPU to use, by Vulkan index (the launcher's) |
BB_GPU_PROFILE |
=1: GPU profiler: time per labelled pass in the log (the launcher's) |
BB_HDR |
=1: HDR output allowed |
BB_HUD_ANCHOR |
=0: on wide screens the HUD stays in the 16:9 middle |
BB_INTEL_TONEMAP_FIX |
=0 / 1: Intel CPU tone mapping fix patch off / on (default on on Intel) |
BB_JITTER |
=0 / 1: upscaler camera jitter (the menu's) |
BB_JUMP_GAP_MS |
=N (default 70): pause around a keyboard jump while running |
BB_JUMP_TAP_MS |
=N (default 70): press length of a keyboard jump while running |
BB_KEY_FALL_MS |
=N (default 45): keyboard stick release time |
BB_KEY_RISE_MS |
=N (default 70): keyboard stick rise time |
BB_KEY_TURN_DPS |
=N (default 1100): keyboard stick turn speed in degrees a second |
BB_LANGUAGE |
=N: the game's language, PS4 number (1 English, 8 Russian; the launcher's) |
BB_LARGE_HEAPS |
=1 / 0: larger graphics heaps for texture packs on / off (default: detected) |
BB_LAYER_MEMORY |
=1 / 0: the layer's memory module (default on non-AMD GPUs) |
BB_LOW_LATENCY |
=off / on / boost: NVIDIA Reflex / AMD Anti-Lag (the menu's) |
BB_MENU_LANGUAGE |
=ru / en / ...: the port's menu language (default: the launcher's, else the system's) |
BB_MENU_POINTER |
=0: no mouse pointer in the game's menus |
BB_MODS_ENABLED |
=0: no mods |
BB_MOUSE_AUTO_ROTATE |
=1: the game's camera auto rotation also with the mouse |
BB_MOUSE_DEADZONE |
=N (default 16 of 127): mouse look dead zone |
BB_NATIVE_MOUSE |
=0: mouse look through the right stick instead of the camera hook |
BB_NET_BACKEND |
=thd: The Hunter's Dream online pool (the launcher's online pool) |
BB_OBJECT_MOTION |
=0 / 1: motion vectors of moving objects (the menu's) |
BB_ONLINE |
=1: online play (the launcher's) |
BB_P2P_PORT |
=N: the UDP port for P2P online traffic (default 3658, 0: any) |
BB_PAD_DEADZONE |
=N (default 5): stick inner dead zone |
BB_PAD_DEADZONE_OUTER |
=N (default 127): stick outer limit |
BB_PAD_MOTION |
=0 / 1: motion sensor emulation (over bbport.ini pad_motion) |
BB_PATCHES |
=name,...: extra patches by name (patches.py) |
BB_PROCESS_PRIORITY |
=normal / above / high: process priority on Windows (default above) |
BB_REACTIVE |
=1: FSR reactive mask (the menu's) |
BB_REACTIVE_MAX |
reactive mask maximum (the menu's) |
BB_REACTIVE_SCALE |
reactive mask scale (the menu's) |
BB_REACTIVE_THRESHOLD |
reactive mask threshold (the menu's) |
BB_RENDER_RES |
=WxH: render resolution through the startup patch (compatibility) |
BB_SAVE_LOG |
=1: the log and frame statistics also kept in logs/ |
BB_SHADER_PROGRESS |
=0: no shader compilation progress on screen |
BB_SHADNET_NPID |
the shadNet account name (the launcher's) |
BB_SHADNET_PASSWORD |
the shadNet account password (the launcher's) |
BB_SHADNET_SERVER |
the shadNet server |
BB_SHADNET_TOKEN |
the shadNet account token (the launcher's) |
BB_SHADNET_WEBAPI |
the shadNet web API server |
BB_SKIP_CPU_CHECK |
=1: skip the check of the CPU's bsr/bsf behaviour before the game starts |
BB_SKIP_GAME_CHECK |
=1: start with game files that did not pass the check |
BB_TEXTURE_QUALITY |
texture quality over bbport.ini's texture_quality |
BB_THD_ONLINE_ID |
The Hunter's Dream online name (the launcher's) |
BB_THD_TOKEN |
The Hunter's Dream account token (the launcher's) |
BB_TROPHY_KEY |
the trophy data key (from the environment or the port's .env) |
BB_UPNP |
=1: UPnP port forwarding for online play |
BB_UPSCALER |
=none / fsr3 / fsr4 / dlss / ...: the upscaler over the menu's (scripts, A/B) |
BB_UPSCALE_PRESET |
the upscaler quality preset (the menu's) |
BB_USER_NAME |
the PS4 user name (default Hunter) |
Defaults to change on a machine where they misbehave, workarounds, and switches that turn a fix off for comparison.
| Variable | What it does |
|---|---|
BB_ADB |
path of adb for BB_APP0_ADB (default: adb) |
BB_ANTI_LAG |
=1: AMD Anti-Lag 2 through Mesa's layer (measured ~0 gain, #289) |
BB_APP0_ADB |
=serial: the game's files fetched from a phone over adb on first open |
BB_ASYNC_PIPELINE_THREADS |
=N: threads compiling pipelines in the background |
BB_ASYNC_SUBMIT |
=0: the presenter submits the frame itself instead of a submit thread |
BB_AUDIO |
=none: no audio device (headless runs) |
BB_AUTO_NOHIZ |
=0 (run.sh): no automatic RADV_DEBUG=nohiz on the GPUs that need it |
BB_AVPLAYER_ASYNC_READY |
=1: movie StateReady on the controller thread, as before (crashed at 200+ FPS) |
BB_BDA_DEDICATED_MB |
=N: buffers with GPU addresses get dedicated memory from N MiB |
BB_BIND_MEMO |
=0: every resource binding takes the full path (no memo) |
BB_BREADCRUMBS |
=0: no GPU breadcrumbs (what the GPU was drawing at a hang) |
BB_CHUNK_TEXTURES |
=0: texture data copied instead of read in place from guest memory chunks |
BB_CHUNK_UPLOADS |
=0: uploads through CPU staging instead of binding guest memory in place |
BB_COMMIT_IMPORT_LOCKED |
=1: guest memory commits import under the lock |
BB_COMPUTE_RELEASE_FLUSH |
=0: work before a compute release waits for the rest of the frame |
BB_CONSTANTS_IN_PLACE |
=1: shader constants bound in place from guest memory instead of copied |
BB_CONSTANT_RING_MB |
=N: size of the constant ring in MiB |
BB_CONSTRAM_GPU_WAIT |
=0: a constant RAM dump does not wait for queued draws reading it (DoF artifacts #44) |
BB_CONSTRAM_PIPE |
=0: a constant RAM dump waits for all queued draws |
BB_COPY_DEST_GAP |
=bytes: merge gap of copy shader destinations (default 256) |
BB_COPY_DEST_PRECISE |
=0: the whole bound destination of a copy shader counts as written |
BB_COPY_FILTER_GATE |
=1 with BB_COPY_SKIP_SAME: the copy filter off while the draw recording thread is over 92% busy |
BB_COPY_GPU_BUFFERS |
=0: command buffers decoded from guest memory instead of a copy per submission |
BB_COPY_MERGE_KB |
=N: copy shader ranges closer than N KiB merged (default 64) |
BB_COPY_PAGED_RANGES |
=0: copy shader ranges whole instead of by page |
BB_COPY_SHADER_NATIVE |
=0: the copy shader's list read on the CPU |
BB_COPY_SKIP_SAME |
=0: off (default on): of the game's copy shader calls only the copies that change their destinations run (checked on thread bb:CopyFilter) |
BB_COPY_THREADS |
=N (0-16): threads for large guest memory copies |
BB_CORE_RESERVE |
=0 / 1: keep the game's threads off a reserved core (Linux, SMT CPUs with 6+ cores) |
BB_DEAD_IMAGES |
=0: images of freed memory left to the collector instead of dropped on the GPU thread |
BB_DEAD_IMAGES_LATE |
set: dead images dropped at the frame's end only, as before |
BB_DETILE_SKIPPED |
=1: texture levels the quality setting leaves out are still detiled and read |
BB_DIRECT_IMPORT_LOCKED |
=1: direct memory imports under the lock |
BB_DIRECT_MEMORY_ACCESS |
=1: shadPS4's direct memory access mode of the shader translator |
BB_DIRECT_SEGMENT |
=0: the presenter waits for the recording threads instead of taking its own command segment |
BB_DISABLE_HTTPS |
=1: the game's HTTPS requests go out as plain HTTP (online) |
BB_DRAW_PIPE |
=0 / N: the draw pipeline off, or its depth |
BB_FAST_WRITER_FAULTS |
=1: fast path for guest write faults (off: a device loss on a GTX 1050) |
BB_FAULT_WINDOW |
=KiB: window unprotected around a guest write fault (default 256) |
BB_FFX_OWN_SHADERS |
=0: FSR frame generation with the packaged shaders instead of the port's own |
BB_FG_ASYNC |
=1: FSR 3.1 frame generation on a second compute queue (no gain measured) |
BB_FG_EARLY_RETIRE |
=0: with frame generation the frame counts as finished only after it |
BB_FIXED_ARENA |
=1 / 0: force the fixed arena on or off (tests) |
BB_FIX_CHARA_ID |
=0: without the character id guard fix |
BB_FIX_HIT_COLLECTOR |
=0: without the hit collector overflow fix |
BB_FIX_PLAY_TIME |
=0: without the play time fix at high frame rates |
BB_FLIP_AHEAD |
=N (default 1, 0 off): the buffer shown before a flip goes back to the game that many flips early |
BB_FLIP_RATE |
=N: the flip rate the game asks for replaced (0: every vblank; games without frame rate hooks) |
BB_FRAMES_AHEAD |
=N (default 1): guest frames the command processor may run ahead of the GPU |
BB_FRAME_HOOKS |
=0: the community's frame rate patches instead of the port's hooks |
BB_FSR3_FP32 |
=1: FSR 3.1 without its FP16 shader variants (#85) |
BB_FSR3_WAVE32 |
=1: FSR 3.1 without its wave64 shader variants (#85) |
BB_FSR4_LINEAR |
=0: FSR 4 gets the encoded frame as before |
BB_FSR4_OPT |
=0: FSR 4 v07 passes without the optimized set (opt/) |
BB_FX_INIT_CLEAR |
=0: the effect buffers' initialization clears through the game's path |
BB_GARLIC_VRAM |
=0 / 1: VRAM copies of the game's GPU memory off / on (default: on discrete GPUs) |
BB_GC_BUDGET_MB |
=N: texture cache budget in MiB, as on integrated GPUs |
BB_GC_IDLE_SECONDS |
=N (default 20): unused textures evicted after N seconds |
BB_GC_LIVE_BUDGET |
=0: texture cache marks from the startup budget instead of the driver's current one |
BB_GC_PRESSURE_IDLE_SECONDS |
=N (default 5): the same under memory pressure |
BB_GC_SMALL_MARKS |
=P,C: pressure and critical marks in percent on small cards |
BB_GPU_COMMAND_WRITES |
=0: GPU command writes not done in place |
BB_GPU_DATA_CHECK |
=0: GPU-written data not checked before CPU reads (#122) |
BB_GPU_LABELS |
=1 / 0: GPU-written labels on / off (default off on AMD GFX8) |
BB_GPU_LABELS_PORTABLE |
=1: portable GPU label writes |
BB_GPU_SPIN_US |
=N: microseconds the GPU thread spins before sleeping (default 200 with 12+ threads) |
BB_GPU_TIMESTAMPS |
=0: timestamps written by the CPU instead of the GPU |
BB_GPU_WRITES_IN_PLACE |
=1: GPU-written buffers in place with write tracking, as before |
BB_GPU_WRITE_TWINS |
=1: VRAM twins of GPU-written guest pages |
BB_GPU_WRITE_TWINS_MAX |
=N: pages with at most N GPU-written ranges get twins (default 1024) |
BB_GUEST_HOOKS |
=0: no guest code hooks at all (aspect ratio, HUD, mouse, fixes) |
BB_GUEST_LAZY |
=1: lazy guest memory with the layer's memory module (off: broke buffers) |
BB_GUEST_MEMORY |
=dmabuf / host / private: how guest memory is shared with the GPU (default per vendor) |
BB_GUEST_UNCACHED |
=1: guest memory only in memory types the GPU reads past its caches |
BB_GUEST_VRAM |
=1 (experiment): direct memory in VRAM mapped through the PCI BAR |
BB_GUEST_VRAM_RANGES |
=lo-hi,...: physical ranges for BB_GUEST_VRAM (default: the graphics heaps) |
BB_GX_COMMAND_HEAP |
=0: without the larger GX command heap patch (patches.py) |
BB_GX_QUERY_GUARD |
=0: without the GX query creation guard |
BB_HEAP_GROW |
=0: the graphics heap whole from the start instead of growing on demand |
BB_HEAP_GROW_AHEAD |
=N (default 2, 0 off): heap pieces made ahead |
BB_HEAP_GROW_INITIAL_MB |
=N (default 512): heap memory backed from the start |
BB_HEAP_GROW_PIECE_MB |
=N (default 320, at least 258): heap growth piece |
BB_HEAP_SHRINK |
=0: the heap only grows |
BB_HEAP_SHRINK_DELAY |
=seconds (default 60): a piece free this long is given back |
BB_HEAP_TOP_HOOK |
=0: without the hook on allocations from the heap's top |
BB_HIT_COLLECTOR_CAP |
=N (default 65536): hits per call before the overflow fix takes over |
BB_HONEST_DRAIN_FLUSH |
=0: no flush when the GPU is on its last submission |
BB_HONEST_FLIPS |
=1 (experiment): a flip completes once the GPU has finished the frame |
BB_HONEST_FLUSH_US |
=N (default 2000): submissions batched over N microseconds while the GPU has work |
BB_HONEST_IDLE_BACKLOG |
=bytes (default 64 KiB): queued draws that make an idle GPU get a flush |
BB_HONEST_IDLE_FLUSH |
=0: no flush for an idle GPU |
BB_HONEST_IDLE_US |
=N (default 200): microseconds of GPU idle before the guest may be waiting |
BB_HOST_COPY_WAITS |
=all: host copies always wait, as before |
BB_HOST_ONLY_DEFAULT |
=0: none of the game profile's allocations in host memory only |
BB_HOT_EFFECTS |
=0: effect settings applied as patches at start instead of live |
BB_HOT_PAGES |
=1: hot page tracking |
BB_HOT_VERTEX_COPY |
=1: vertex data bound in place copied into VRAM once per submission (no reads over the bus per pass) |
BB_IMAGE_RECYCLE_MB |
=N (default 256, 0 off): memory of freed images kept for reuse |
BB_IMAGE_RECYCLE_SECONDS |
=N (default 90): recycled images older than this go |
BB_IMAGE_SPARES |
=1 / 0: spare images made ahead on a thread (default on on Windows) |
BB_IMAGE_SPARES_MB |
=N: memory for spare images |
BB_IMAGE_TRAPS |
=0: no write traps on image memory |
BB_IMPORT_GRANULE_MB |
=N (2..64, default 32): lazy guest memory import granule |
BB_IMPORT_OVERLAP_MB |
=N: overlap budget of lazy imports |
BB_INDIRECT_GUARD |
=0: indirect draw and dispatch counts used as the game gives them |
BB_INDIRECT_GUARD_MAX |
=N (default 4M): indirect dispatch groups allowed in all |
BB_INDIRECT_GUARD_MAX_VERTICES |
=N (default 64M): indirect draws over this run nothing |
BB_INPLACE_TEXTURES |
=1: all texture data read in place (off: looked smeared) |
BB_INTERP_INT_FIX |
=0 / 1: flat integer interpolation fix off / on (default: on where barycentrics exist) |
BB_JOB_SLOT_FIX |
=0: without the render job slot leak fix |
BB_KEEP_DECOMPRESS_DRAWS |
=1: the game's depth decompress passes are drawn |
BB_KERNEL_CLAMP |
=0: without the effect kernel clamp fix |
BB_KIT_RESTORE |
=0: the online kit's code changes are not restored |
BB_LAYER_CPU_MARK_SECONDS |
=N (default 5, 0: until handed out): CPU marks of layer blocks expire after N seconds |
BB_LAYER_DOMAINS |
=0: mirrors not per game allocation |
BB_LAYER_GPU_WRITES |
=0 / 1 / 2: where GPU writes may land in VRAM copies (0 nowhere, 1 default) |
BB_LAYER_MIRROR_FLOOR_PERCENT |
=N (max 90): VRAM budget share kept for mirrors |
BB_LAYER_MIRROR_GROWTH_MB |
=N (default 64, 0 none): room a growing mirror gets |
BB_LAYER_MIRROR_HEADROOM_MB |
=N (0: the whole floor): mirror headroom |
BB_LAYER_READ_TRAPS |
=1: data the GPU wrote into a VRAM copy only is trapped for CPU reads |
BB_LAYER_RELOAD_RESET |
=0: blocks reloaded in place keep their state, as before |
BB_LAYER_STITCH |
=0: bindings across heap pieces from the arena, as before (exploding vertices) |
BB_LAYER_UNMAP_RESET |
=0: unmapped blocks keep their state, as before |
BB_LAYER_VOLATILE |
=1: volatile blocks |
BB_LAYER_VOLATILE_IN_PASS |
=0: volatile blocks refreshed in render passes too, as before |
BB_LAYER_WATCH |
=0: blocks with unannounced bytes get no watched VRAM copy |
BB_LAYER_WRITE_TRAPS |
=0: no write traps on layer blocks |
BB_LIGHT_GRID_HOOK |
=0: without the light grid hook |
BB_LIGHT_GRID_OPT |
=1 / 0: light grid optimization on / off, over the setting (tests) |
BB_LIVE_HYBRID |
=1: the startup resolution patch with live presets over it |
BB_MEM_SEMAPHORE_ORDER |
=0: memory semaphores without ordering |
BB_MIRROR_ALLOC_PERCENT |
=N (0 off): a mirror that would take device memory past N percent is refused |
BB_MIRROR_COMPACT_AGE |
=N (default 30): mirrors younger than N seconds are left alone |
BB_MIRROR_COMPACT_MB |
=N (default 64): mirror memory without valid blocks over this is given back |
BB_MIRROR_COMPACT_SECONDS |
=N (default 1): mirror compaction interval |
BB_MIRROR_FREE_BACKLOG_MB |
=N (default 128): retired mirror memory allowed to wait |
BB_MIRROR_FREE_MB_PER_FRAME |
=N (default 64): mirror memory freed per frame |
BB_MIRROR_MERGE_GROWTH |
=0: a mirror made over neighbours grows at the top only, as before |
BB_MIRROR_POOL_MB |
=N: retired mirrors kept for new ones |
BB_MIRROR_REPROMOTE_SECONDS |
=N (default 0): blocks sent back are not copied again that soon |
BB_MIRROR_UNBOUND_SECONDS |
=N (0 never): blocks no binding named for N seconds leave VRAM |
BB_MIRROR_VRAM_ONLY |
=1: mirrors in VRAM or not at all |
BB_MOTION_VERTICES_MI |
=N (1-8): object motion vertex buffer in Mi vertices |
BB_NET_MODULE |
=path: the online module to load (default gpu/libbbnet20.so beside bb-probe) |
BB_NP_COUNTRY |
=code: the online user's country (default us) |
BB_NP_LANGUAGE |
=code: the online user's language (default en) |
BB_NVIDIA_EGL |
=0: the launcher leaves the EGL vendor files as they are (#107) |
BB_NVIDIA_LIB_DIR |
=dir: extra folder with NVIDIA's libraries for the package |
BB_NVIDIA_MAILBOX |
set: keep Mailbox presentation on NVIDIA Windows instead of FIFO |
BB_NV_POWER |
=0: leave the NVIDIA driver profile of bb-probe.exe alone (Windows; by default its power management mode is set to prefer maximum performance unless the user chose one) |
BB_OCCLUSION_INTERVALS |
=0: occlusion samples counted all the time, not only while a query is open |
BB_OCCLUSION_LABEL_ORDER |
=0: occlusion labels may go ahead |
BB_OCCLUSION_QUERIES |
=0: a fixed occlusion result sequence instead of real queries |
BB_OF_FAST |
=1: optical flow without a search on the finest level |
BB_PACE_CATCHUP |
=1: frame pacing catches up after a late frame |
BB_PAD_CENTER |
=lx,ly,rx,ry: the sticks' neutral position |
BB_PAD_CENTER_CAL |
=0: no measurement of the sticks' neutral position |
BB_PAD_WORLD_DRAWS |
=N (default 150): a frame with this many draws counts as the world for pad timing |
BB_PAGED_CROSSING |
=0: paged bindings only in windows |
BB_PAGED_FORMATTED |
=0: formatted buffers never paged |
BB_PAGED_HOLES |
=1 (experiment): paged reads skip memory the game never wrote |
BB_PAGED_MIN_MB |
=N (default 64): bindings from this size are paged |
BB_PENDING_SUMMARY |
=0: pending checks without the summary level |
BB_PIPELINE_CACHE |
=0: no pipeline cache on disk |
BB_PIPE_SIGNALS |
=0: the frame's cache work on the GPU thread instead of the recording thread |
BB_PIPE_SPIN_US |
=N: microseconds the draw pipe's threads spin before sleeping |
BB_PM4_RECOVER |
=0: a command buffer the game rewrote while read stops decoding, as before |
BB_PM4_REPAIR |
=0: corrupt submitted command buffers decoded as they are |
BB_PM4_WAIT_US |
=N (default 20000): command processor wait timeout in microseconds |
BB_PRELOAD_BACKGROUND |
=0: cached pipelines loaded before the game starts instead of in the background |
BB_PREP_WORKERS |
=N (0-16): draw preparation threads |
BB_PRESENT_MODE |
=Mailbox / Fifo / Immediate: swapchain present mode (default Mailbox) |
BB_PRESENT_THREAD |
=0: present on the vblank thread instead of its own |
BB_PROMOTE_MB_PER_FRAME |
=N (0 none; default 32 on cards up to 4 GiB, else 256): VRAM copies per frame |
BB_READBACKS |
=0 / 1 / 2: GPU readbacks off / relaxed (default) / precise |
BB_READBACK_LINEAR |
=1: linear images read back to guest memory |
BB_READBACK_QUEUE |
=0: no separate queue for readbacks |
BB_REGS_FULL_RESET |
set: the whole register file reset, as before |
BB_RENDER_RESOURCE_CACHE_MB |
=N (160: the game's own): the game's render resource cache size |
BB_REPAIRED_DRAWS |
=1: repaired command buffers still draw |
BB_REPAIRED_WAIT_MS |
=N (default 500): waits of repaired command buffers give up after this |
BB_RESOLVE_WORKERS |
=N (0-4): threads that check and copy draw resources (stage 2) |
BB_RING_DEDUP |
=0: off (default on): constants already in the constant ring with the same bytes bound there again, not copied over the bus once more |
BB_SCENE_DEPTH_PROXIES |
=0: depth images read at the native size, not as reduced proxies |
BB_SCENE_STENCIL_ZERO |
=0: no depth proxies where stencil export is missing, the scene stays native |
BB_SCENE_UPSIZE |
=0: a scene larger than native drawn at the native size |
BB_SCENE_WITHOUT_UI |
=0: cinematics without a UI pass are not finished as scenes |
BB_SHADOWS |
=1: shadow copies of written buffers on discrete GPUs |
BB_SKIP_EMPTY_DRAWS |
=1 (experiment): draws that write nothing are left out |
BB_SKIP_NOOP_DRAWS |
=1: draws without effect left out (#352, no gain measured) |
BB_SOUND_HACK |
=0: saves left untouched (no sound settings fix) |
BB_SPEC_MATCH |
=0: shader specializations always built and compared |
BB_STAGE_PRIORITY |
=0 (default) / 1 / 2: draw stage thread priority off / above normal / highest |
BB_STAGING_KEEP_MB |
=N (default 512): upload staging kept when idle |
BB_STAGING_VRAM_IDLE_MS |
=N (default 3000): VRAM staging given back after this long unused |
BB_STREAM_BUFFER_MB |
=N: stream buffer size |
BB_SUBMIT_AHEAD |
=N (default 2): a frame's first submissions go straight to the GPU |
BB_SUBMIT_LOCK |
=frame: a frame's last submission decoded under the lock |
BB_SWAPCHAIN_IMAGES |
=N: swapchain images |
BB_TEXTURE_HELPER |
=0 / 1: spinning texture helper thread (default: with cores to spare) |
BB_TEXTURE_UPLOAD_MB_PER_FRAME |
=N (default 32, 0 off): texture bytes uploaded a frame before new textures start small |
BB_THD_AUTH |
The Hunter's Dream account service URL |
BB_THD_P2P_ADDR |
our address for The Hunter's Dream peers (default: detected) |
BB_THD_RULESET |
The Hunter's Dream ruleset (default vanilla) |
BB_THD_SERVER |
The Hunter's Dream session service URL |
BB_THD_STUN |
=host[:port] / off: STUN server (default: the server's host on 3478) |
BB_THD_VERIFY_TLS |
=0: The Hunter's Dream TLS certificates not checked |
BB_TILE_BIND_VRAM |
=0: tiled data read in place over the bus instead of from a VRAM copy |
BB_TIMELINE_POLL_US |
=N (default 50): timeline semaphore poll interval |
BB_UNIFIED_MEMORY |
=1 / 0: treat the GPU as unified memory or not (over the device type) |
BB_VBAO_BLUR |
=N (default 2, 0: raw): VBAO denoise taps per side |
BB_VBAO_BLUR_DEPTH |
=f (default 0.05): relative depth difference that stops the VBAO blur |
BB_VBAO_BLUR_NORMAL |
=f (default 8, 0 ignores normals): how sharply the VBAO blur stops at normal changes |
BB_VBAO_NORMALS |
=0: VBAO from depth only |
BB_VBAO_POWER |
=f (default 1.5): VBAO strength |
BB_VBAO_RADIUS |
=metres (default 1.5): VBAO radius |
BB_VBAO_THICKNESS |
=metres (default 0.4): VBAO assumed thickness |
BB_VERTEX_READ_COPY |
=1 (experimental): vertex data bound in place copied into VRAM for the vertices each draw reads (once per guest submission) |
BB_VK_RECORD_THREAD |
=0: Vulkan commands recorded on the calling thread |
BB_VK_RECORD_THREADS |
=N (1-8): Vulkan recording threads (default 2 from 8 hardware threads) |
BB_VK_SEGMENT_KB |
=N (default 64): recording segment size |
BB_VMA_BLOCK_MB |
=N (default 64): VMA block size |
BB_VMA_DEDICATED_MB |
=N (default 4): images from this size get dedicated memory |
BB_VRAM_FLOOR_IDLE_SECONDS |
=N (default 30): mirror floor idle time before textures make room |
BB_VRAM_IDLE_SECONDS |
=N (default 60): VRAM copies unused this long are given back |
BB_VRAM_LIMIT_MB |
=N: the driver's VRAM budget taken as at most N MiB |
BB_VRAM_PRESSURE_IDLE_SECONDS |
=N (default 10): under pressure, VRAM groups unused this long go |
BB_VRAM_PROMOTE_PERCENT |
=N (default 90): no new VRAM copies past this share of the budget |
BB_VULKANINFO |
path of vulkaninfo for the launcher |
BB_WORK_RETIRED |
=0: the recording thread and fences do not wait for retired work |
Logs, dumps, traces, probes and experiments, for finding bugs. Most cost frame time; none is meant for playing.
| Variable | What it does |
|---|---|
BB_ARENA_VRAM_ONLY |
=1 (tests): the arena in VRAM only, as NVIDIA's sparse buffers |
BB_AUDIO_DUMP |
=dir: raw converted PCM per audio port |
BB_AUDIO_STATS |
set: audio port statistics |
BB_AUDIO_TRACE |
=1: Ajm instance configurations and jobs that fail |
BB_AVPLAYER_TRACE |
=1: the game's movie player calls with results and times |
BB_BARRIER_STATS |
=1: images whose subresource states cost the most |
BB_BBSC_MEMSCAN |
set: BBSC finds its sites by scanning memory instead of the known addresses |
BB_BBSC_PROBE |
=address: BBSC probe of that guest address |
BB_BDA_LOG |
set: GPU addresses of buffer sources, to place a GPUVM fault |
BB_BIG_ALLOC_STACKS |
=1: call stacks of device memory allocations of 64 MiB and more |
BB_BREADCRUMB_READS |
=1 / 0: breadcrumbs of T# and V# reads everywhere / nowhere (default: NVIDIA only) |
BB_BUFFER_STATS |
=1: how many frames behind the GPU is when a frame starts |
BB_CAMERA_FRAME_LOG |
set: projection of every G-buffer pass's camera with its GPU frame |
BB_CAMERA_INVERSE |
=own: motion vectors from the inverse of the view matrix instead of the game's stored one |
BB_CAMERA_LOG |
set: camera position every 100 ms |
BB_CAMERA_Y |
=up / down: force the camera's y direction for motion vectors |
BB_CAMLOG |
set: camera yaw when it changes (#325) |
BB_CAPTURE_DIR |
folder for frame captures (BB_CAPTURE_TRIGGER) |
BB_CAPTURE_TRIGGER |
=file: creating that file records the next frame for the frame analyzer |
BB_CE_STATS |
=1: what the constant engine's dumps feed |
BB_CE_WAIT_LOG |
set: constant engine waits that were not satisfied |
BB_CE_WATCH |
=hex address: constant RAM dumps and WRITE_DATA packets over that address |
BB_CLOTH_STIFFNESS |
=value: cloth stiffness bound at any frame rate |
BB_COMPILE_TRACE |
=1: every shader and pipeline compiled during the session |
BB_CONSTRAM_WAIT_LOG |
set: constant RAM dumps that waited for the GPU, sampled |
BB_COPY_SHADER_TRACE |
set: the copy shader's buffers every 2 s |
BB_COPY_WHERE |
=1: the copy shader's sources and destinations per frame, VRAM or in place (log lines) |
BB_DCB_STATS |
=1: structure of the graphics command buffers |
BB_DEBUG_MOTION |
=1: motion vectors blended over the picture |
BB_DISPATCH_LOG |
=1: the shape of each kind of compute dispatch, once |
BB_DISPATCH_START_LOG |
set: dispatches with a nonzero thread group start |
BB_DISPLAY_WATCH |
set: every draw into a display buffer with its sizes and state |
BB_DISPLAY_WATCH_TARGET |
=hex address: also every draw into that color target |
BB_DLSSG_CAMERA_MOTION |
=0: DLSS-G told the vectors have no camera motion |
BB_DLSSG_DEPTH_INVERTED |
=1: DLSS-G told the depth is the other way round |
BB_DLSSG_HUDLESS |
=0: DLSS-G gets no hudless frame |
BB_DLSSG_MATRICES |
=0: DLSS-G gets no camera matrices |
BB_DLSSG_MVEC_SCALE |
=f: DLSS-G motion vector scale (default 1) |
BB_DLSSG_PREFILL |
=0: DLSS-G outputs not filled with the real frame first (black frames when it skips) |
BB_DLSSG_SUBRECTS |
=0: DLSS-G gets no input sub-rectangles |
BB_DRAW_WATCH |
=1: draws whose viewport, targets or textures differ from the previous frame's |
BB_DRAW_WATCH_TEXTURES |
set: BB_DRAW_WATCH also lists bound textures |
BB_DUMP_DIR |
=dir: where upscaler dumps go (default out/dump) |
BB_DUMP_EVERY |
set: dump every frame while the trigger file exists |
BB_DUMP_FRAMES |
=N: frames per upscaler dump (default 8) |
BB_DUMP_GOT |
=offset: which host function a guest GOT slot calls |
BB_DUMP_ONLY |
=name,name: dump only those upscaler images |
BB_DUMP_SHADERS |
=1: translated shader programs written to the dump folder |
BB_DUMP_TRIGGER |
=file: creating it dumps the upscaler's inputs and outputs |
BB_DYNAMIC_STATE_ALWAYS |
=1: all dynamic state set again at every draw |
BB_DYNSTATE_CHECK |
=1: the scissor each command buffer really has, and who set it |
BB_EFFECT_DUMP |
set: the game's effect options objects every 10 s |
BB_EXPERIMENT_CYCLE |
=bits,bits,...:seconds: the experiment bits step through the list, over and over (test builds) |
BB_EXP_BARRIER_ALL |
set (experiment): a full memory barrier before every draw and dispatch |
BB_EXP_BARRIER_TARGET |
=hex address (experiment): a full barrier before each draw into that target |
BB_EXP_CONSTRAM_FINISH |
=1 (experiment): every constant RAM dump waits for all earlier GPU work |
BB_EXP_COPY_SRC_SNAPSHOT |
set (experiment): copy shader sources snapshotted as with the old memory model |
BB_EXP_CPU_READS_GPU_WAIT |
set (experiment): CPU-side reads also wait for the GPU, as before |
BB_EXP_DMA_UNTRACKED |
set (experiment): stages reading memory through pointers count as unlisted reads |
BB_EXP_EXTRA_BREAKS |
=N (experiment): the render pass ended before every Nth draw, to measure breaks |
BB_EXP_FINISH_BEFORE_TARGET |
=hex address (experiment): the GPU finishes everything before a draw into that target |
BB_EXP_FINISH_FRAMES |
set (experiment): the GPU finishes each frame before the next |
BB_EXP_FLIP_FINISH |
set (experiment): the flip is signalled once the GPU has run the frame |
BB_EXP_FLIP_LAG |
set (experiment): at most one frame in flight |
BB_EXP_NOTED_GPU_WAIT |
set (experiment): constant RAM waits cover every read noted on stage A, as before |
BB_EXP_NO_MEMORY_HOOKS |
set (experiment): no guest hooks for GPU allocations and copies |
BB_EXP_NO_STREAM |
set (experiment): nothing goes through the stream buffer |
BB_EXP_PAGED_IN_PLACE |
=1 (experiment): paged buffers bound in place |
BB_EXP_TRANSIT_TARGET |
=hex address (experiment): that target goes through TransferSrcOptimal |
BB_FENCE_DELAY_TEST |
=1 (test): every 200th fence comes 80 ms late |
BB_FFX_FG_DEBUG |
=1: AMD's frame generation draws its tear lines and reset marks |
BB_FG_DUMP_TRIGGER |
=file: creating it saves real and generated frames, raw |
BB_FG_LUT |
=0: generated frames without the game's display LUT |
BB_FG_PROFILE |
=1: GPU time of each FSR 3.1 frame generation pass |
BB_FILE_TRACE |
=1: every guest path the game opens or checks (mods, missing files) |
BB_FINAL_DUMP_TRIGGER |
=file: creating it saves the presented frame |
BB_FI_CHECK |
=1: frame interpolation samples drawn as their difference to the SDK's |
BB_FPS_PRINT |
=1: the present rate every 5 s, without BB_FRAME_STATS's cost |
BB_FRAME_DT_SMOOTH |
=a (0..1): the game's frame step follows the measured frame time smoothed by a |
BB_FRAME_GEN_ONLY |
set: only the generated frames are shown |
BB_FRAME_LOG |
=path (with BB_FRAME_STATS): one line per flip |
BB_FREE_CHECK |
=1: guest heap corruption diagnostic around the free list |
BB_FSR411_POSTPASS |
=lds / orig: FSR 4.1.1 post pass variant |
BB_FSR4_MODEL_CYCLE |
=N: the FSR 4 model switched to the next one every N frames |
BB_FSR4_PROFILE |
=1: FSR 4.1.1 GPU time per pass every 300 frames |
BB_FSR4_STATS |
=1: driver statistics of every FSR 4 pass (fsr4-bench --stats) |
BB_GAME_ASSERT_STOP |
=1: the game's known harmless asserts stop it, as before |
BB_GAME_HUGE |
=0 (tests): no huge pages for the game's image |
BB_GAME_MENU_TRACE |
=1: how often the game asks for the port's menu texts |
BB_GAME_PROFILE |
=none: no game profile (hooks, fixes), the plain runtime |
BB_GARLIC_VRAM_RANGE |
=begin:end: VRAM copies only for guest addresses in that range |
BB_GC_TRIGGER_MB |
=N: the texture collector starts at N MiB (tests) |
BB_GNM_CENSUS |
=1: calls per Gnm function, printed |
BB_GNM_CENSUS_FILE |
=path: every Gnm function's total calls written there |
BB_GNM_CENSUS_RANGE |
=first:last: census only for those table indices (bisecting) |
BB_GNM_NATIVE_ONLY |
=1: native Gnm observers without checksum analysis |
BB_GNM_OBSERVE |
=1: submitted command buffers checked against the hooked API calls' packets |
BB_GNM_RACE_STACKS |
=1: call stacks of racing Gnm command buffer writers |
BB_GNM_TRACE |
=offset[:count]: arguments, caller and packets of that Gnm function |
BB_GNM_WRITES_TRACE |
=1: recent Gnm builders overlapping a bad submitted buffer |
BB_GPU_LOG |
=trace / debug / info / warning / error: GPU layer log level |
BB_GPU_PROFILE_DRAWS |
=1: the GPU profiler times every draw |
BB_GPU_PROFILE_TOP |
=N: the GPU profiler prints the N heaviest labels (default 30) |
BB_GPU_WRITE_WATCH |
=hex address: GPU writes noted over the 64 KiB page holding it |
BB_GUEST_HOOK_TRAPS |
=1: guest hooks stay int3 traps instead of native detours |
BB_GUEST_WHOLE_CHUNKS |
=1 (tests): as if offset mappings failed (the NVIDIA path) |
BB_GX_QUERY_FAIL |
=N: every Nth GX query creation fails as with a full heap |
BB_HEAP_DUMP |
=addr,...: those guest objects and the ones they point to |
BB_HEAP_FIND |
=hex value: once, 60 s in, where the game's data holds that value |
BB_HEAP_HOOKS |
=0 (bisecting): the heap's ranges not reported |
BB_HEAP_SITES |
=1: the game's malloc replacement sites |
BB_HEAP_TRACE |
=1: which 16 MiB ranges the game's GPU allocators hand out, every 60 s |
BB_HEAP_WALK |
=core,...: walk of the game's range allocator cores |
BB_HLE_OFF |
=mask (experiment): 1 image copy, 2 metadata clear, 4 image clear run as real shaders |
BB_HLE_STATS |
set: how often the compute shader substitutions fire |
BB_HOST_ONLY |
=phys,... (experiment): those direct allocations in host memory only |
BB_HUD_DX |
=f: another HUD shift |
BB_IMAGE_CLEAR_LOG |
=1: why an image clear went to the real shader, once per reason |
BB_IMAGE_COPY_LOG |
set: also why a large copy shader was not substituted |
BB_IMAGE_SYNC_LOG |
set: images refreshed most per 5 s, with their flags |
BB_IMAGE_WATCH |
=address: what happens to the image at that address |
BB_IME_TEXT |
=text: the on-screen keyboard answers with that text at once (tests) |
BB_IMITATE_NVIDIA |
=1 (tests on AMD): the port treats this GPU as NVIDIA's |
BB_IMPORT_LOG |
set: lazy import requests per 10 s |
BB_IMPORT_TRACE |
=lo-hi (MiB): who asked for imports starting there |
BB_IMPORT_WRITTEN_BUDGET |
=1 (tests): written bindings under the import budget too, as before |
BB_INPLACE_READ_CHECK |
=1: checks of the GPU's in-place reads of game memory |
BB_LABEL_TRAP |
=1 / 2: with BB_FREE_CHECK, read-only label pages first |
BB_LANG_TABLES |
set: the sell regions' language tables (#269) |
BB_LAYER_CHECK |
=1: stop on a stale page table entry of the layer |
BB_LAYER_MARK_LOG |
=lo-hi (hex): who marks layer blocks there as the CPU's |
BB_LAYER_PAGED |
=0 (tests): huge bindings cut in place instead of the page table |
BB_LAYER_PAGED_STATS |
set: paged bindings per shader every 5 s |
BB_LAYER_PROBE |
=1: GPU writes kept in place because the CPU once wrote the block |
BB_LAYER_VERIFY |
=1 / 2: verify the layer's mirrors (2: also those a paged binding reads) |
BB_LAYER_WATCH_HOT |
=1 (experiment): often written blocks watched and uploaded after every write |
BB_LAYER_WRITE_LOG |
set: large GPU writes kept in place, and the images near them |
BB_LIST_UNRESOLVED |
=1 (porting another game): every unresolved import, once |
BB_LOW_INFO_TEST |
set: test of the memory queries for the game's statics (#282) |
BB_MEMORY_LOCK_REPORT_MS |
=N (default 20, 0 off): memory map lock holds longer than this, with the code |
BB_MENU_KEYS_FILE |
=file (scripted tests): menu key tokens read from it |
BB_MENU_POINTER_FILE |
=file (tests): menu pointer moves and clicks read from it |
BB_MENU_POINTER_LOG |
=1: the signals of the in-menu check, with every change |
BB_META_FIXED_BASE |
set: shader prediction from metadata at a fixed program base |
BB_META_NO_SYNTH |
set: shader prediction without synthesized inputs |
BB_META_RECIPE_FETCH |
set: shader prediction without generated fetch shaders |
BB_MIRROR_TRACE |
set: mirror creation and growth |
BB_MOD_TRACE |
=1: every file a mod replaces |
BB_MOTION_SELECT_LOG |
=1: each G-buffer vertex shader once with the motion vector selection |
BB_MOTION_TRACE |
=file: the frame after the file appears prints its motion draws |
BB_MSG_TRACE |
=1: the game's text lookups per 2 s by category (#255) |
BB_NGX_LOG |
=1 / 2: NVIDIA NGX log into the port's (2: verbose) |
BB_NULL_GPU |
=1: no GPU work at all (tests) |
BB_OBJECT_MOTION_ALL |
=1: the old broad object motion selection (A/B) |
BB_OCCLUSION_READ_TRACE |
=1: the game's occlusion result reads |
BB_OCCLUSION_SAMPLES |
=N: samples the game read, for N queries |
BB_OCCLUSION_TRACE |
=N: the first N occlusion events with frame and render pass |
BB_OVERLAY_OPEN |
set (tests): the port's menu open from the start, unfolded |
BB_OVERLAY_TRACE |
=1: the menu's mouse buttons as SDL and ImGui see them |
BB_PAD_CLOCK |
=wall: pad timestamps from the wall clock, as before |
BB_PAD_FILE |
=file: scripted pad input for automated runs |
BB_PAD_RECORD |
=file: F9 starts and stops recording the pad state into it |
BB_PAD_REPLAY |
=file: plays a BB_PAD_RECORD recording |
BB_PAD_TAP_TEST |
=ms: the right stick fully right for that long (#325) |
BB_PAD_TRACE |
=1 / 2: gamepad buttons and touches as read (2: every sample) |
BB_PAGED_COPY_CROSSING |
=0 (tests): copy programs paged for size alone are not paged |
BB_PAGED_VERIFY |
=1: verify every block a paged binding reads |
BB_PARTIAL_TRACE |
set: partial image refreshes |
BB_PASS_BREAK_TRACE |
=1: what ended each render pass |
BB_PASS_DUMP |
=addr,...: rows of those render targets at each display pass (with BB_PASS_DUMP_TRIGGER) |
BB_PASS_DUMP_AT |
=hex address: BB_PASS_DUMP's images also before the first draw into that target |
BB_PASS_DUMP_STEP |
=N (default 8): BB_PASS_DUMP every Nth row |
BB_PASS_DUMP_TRIGGER |
=file: creating it starts BB_PASS_DUMP |
BB_PENDING_STATS |
set: pending notes and granules a second, by level |
BB_PIN_CLEAR_LOG |
set: large releases of GPU-pinned memory that were cleared |
BB_PIPE_VERIFY |
=N: verify the draw pipe's results every Nth frame |
BB_PM4_SELFTEST |
=1: tests of command processor packets Bloodborne never sends |
BB_PM4_SELFTEST_STEPS |
=mask: the self test steps to run |
BB_POOL_WATCH |
=1: watch of the game's pool corruption (#32) |
BB_PRESENT_DUMP_COUNT |
=N: BB_PRESENT_DUMP_TRIGGER saves N consecutive frames |
BB_PRESENT_DUMP_TRIGGER |
=file: creating it saves the presented frame with the UI |
BB_PRESET_FILE |
=file: 'preset [output [upscaler [aspect]]]' read about once a second (scripted tests) |
BB_PRODUCER_CHECK |
=1: command producer checks (the launcher's crash diagnostics) |
BB_PROMPT_TRACE |
=1: key guide icon textures found for button prompts |
BB_READBACK_LOG |
=path: the newest GPU-written bindings behind readbacks |
BB_READ_SAMPLE |
=spec: sampling of which guest memory the CPU reads |
BB_RECORDER_TRACE |
=1: most frequent command buffer callers every 2000 calls |
BB_REGS_CHECK |
set: registers compared with the defaults after a reset |
BB_RESIDENCY_MIX |
=1 / 2: bindings per kind every 2 s |
BB_RESIDENCY_REPORT |
=file: when it appears, blocks bound in place and why they have no VRAM copy |
BB_RESIDENCY_VRAM_LIMIT_MB |
=N (tests): pretend VRAM ends at N MiB |
BB_RES_STATS |
=1: where bound shaders read their resource descriptors from |
BB_RE_ADVANCE |
=1: probe of Scaleform's MovieImpl::Advance |
BB_RE_ANALOG |
=1: probe of the analog getter |
BB_RE_CAMERA |
=1: camera probe |
BB_RE_CAMSTICK |
=1: probe of the camera stick getter |
BB_RE_CAM_ADD |
=radians: turns the camera by that much (probe) |
BB_RE_ENTRY |
=offset,...: entry probes at those guest offsets |
BB_RE_GX_QUERY |
=1: first GX query creations and guard events with their thread |
BB_RE_VIEWPORT |
=1: the game's viewport calls |
BB_RE_WATCH |
=offset: hardware watchpoint on that guest offset |
BB_RE_WATCH_ADDR |
=address: hardware watchpoint on that address |
BB_RE_WATCH_AT |
=N (default 3000): watchpoint set after that many pad reads |
BB_RE_WATCH_CAMANGLE |
=1: watch who writes the camera angle |
BB_RE_WATCH_CAMIN |
=1: watchpoint on the camera input |
BB_RE_WATCH_CAMSTATE |
=1: watch who reads the camera's aspect ratio |
BB_RE_WATCH_FILE |
=file: watch the hex address written in it once it appears |
BB_RE_WATCH_FOLLOW |
=N: follow the watched bytes through host copies N times |
BB_RE_WATCH_INDEX |
=N (default 62): virtual input index for BB_RE_WATCH_VIRTUAL |
BB_RE_WATCH_VIRTUAL |
=1: watchpoint on the virtual right stick X |
BB_RE_ZERO_VIRTUAL |
=1: virtual inputs fed from the right stick's X get 0 |
BB_RING_REASONS |
set: why small read-only bindings were not copied, per 5 s |
BB_ROBUSTNESS |
=0 (experiment): buffer and image robustness off |
BB_SAMPLE_ALL |
=1: every sampled address as module+offset |
BB_SAMPLE_RANGE |
=lo-hi: guest offsets the sampler reports |
BB_SAMPLE_REPORT_SECONDS |
=N: thread samples every N seconds |
BB_SAMPLE_THREAD |
=name: where that thread runs, sampled |
BB_SAVE_TRACE |
=1: every operation on save files |
BB_SCENE_DEBUG |
=file: when it appears, where the scene image is accessed |
BB_SCENE_NO_RESOLVE |
=file:line,...: those accesses read the native scene image |
BB_SCENE_SAMPLED_RESOLVE |
=0: shader reads take the native scene image as it is |
BB_SCENE_STENCIL_BITS |
=1 (tests): the eight-draw stencil reconstruction |
BB_SECTIONS |
=1: timing of the draw recording thread's sections |
BB_SECTIONS_SLOW |
=1 (with BB_SECTIONS): slow frames' sections at each flip |
BB_SEQUENCE_DUMP_COUNT |
=N (default 16): images per BB_SEQUENCE_DUMP_TRIGGER |
BB_SEQUENCE_DUMP_TRIGGER |
=file: creating it saves the next images shown (frame generation checks) |
BB_SHADER_CAPTURE |
=dir: shader inputs captured there |
BB_SKIP_PS |
=hash,...: draws with these pixel shaders left out |
BB_SLOW_BIND_LOG |
=microseconds: image memory binds slower than this |
BB_SPEC_MATCH_CHECK |
set: the built specialization must find the same one |
BB_STALL_REPORT |
=0: no report when the queues stop making progress |
BB_STALL_THREADS |
=0: a stall report covers the command thread only |
BB_STREAM_STATS |
=1: what a frame streams |
BB_TAA_DIAGNOSTICS |
set: TAA diagnostic image dumps |
BB_TEST_VPAD |
=1 (tests): a virtual Xbox-like gamepad |
BB_THD_TRACE |
=1: every The Hunter's Dream datagram and callback |
BB_TICK_LOG |
set: ranges marked written by the GPU most often, per 5 s |
BB_TILE_BACK_LOG |
set: which shader a 'Tile back' line is for |
BB_TIMELINE |
=file: a timeline of frames on their way to the GPU |
BB_TIMELINE_START |
=seconds (default 30): BB_TIMELINE starts recording this late |
BB_TLS_WATCH |
=offset: who writes that static TLS variable of the main thread |
BB_TOGGLE_FILE |
=file: experiment bits re-read every 250 ms |
BB_TRACE_ADDR |
=addr:size: that range traced from the start (with BB_TRACE_SIZE) |
BB_TRACE_CB |
=hash: how that shader's constant buffers were bound |
BB_TRACE_CB_LIST |
=hash,...: BB_TRACE_CB for several shaders |
BB_TRACE_CB_RANGE |
=lo-hi: constant buffer bindings over that range |
BB_TRACE_GPU_INPUTS |
=vs hash: the traced draw's buffer ranges, dumped at the display pass |
BB_TRACE_PIPELINE |
=vs hash: that draw's pipeline handle and push data |
BB_TRACE_SEMA |
set: blocking semaphore waits (deadlocks) |
BB_TRACE_SHADER |
=vs hash: that draw's counts and streams once a second |
BB_TRACE_SIZE |
=bytes: bindings over GPU-written buffers of that size, counted |
BB_TRACE_VERTEX_DATA |
set (with BB_TRACE_SHADER): the stream bytes whenever they change |
BB_TROPHY_TEST |
=id: that trophy's announcement once, nothing recorded |
BB_UI_DRAWS |
=file: while it exists, one frame's UI draws (another aspect ratio, or the upscaler's UI phase) logged with their targets, stencil, blend, clip rects and redirection |
BB_UI_DRAWS_PS |
=hex pixel shader hash: BB_UI_DRAWS also dumps that shader's draws' vertex streams, first constant buffer and indices |
BB_UI_TEXTURE_LOG |
=file: when it appears, the textures the UI binds over the next 2 s |
BB_UI_TRACE |
set: draws of frames that ended without the output-size UI |
BB_UI_TRIGGER_VS |
=hex hash: the vertex shader that starts the UI phase |
BB_UPSCALE_BEFORE_CS |
=hex hash: upscale before that compute shader |
BB_VERTEX_IN_PLACE |
=1: vertex data bound in place per frame, by why it has no VRAM copy, and what draws read of it (log lines) |
BB_VK_MARKERS |
=1: the game's debug labels as Vulkan markers |
BB_VK_VALIDATION |
=1: Vulkan validation layers |
BB_VK_VALIDATION_SYNC |
=1: Vulkan synchronization validation |
BB_VRAM_ACCESS_TRAP |
set: blocks moved to VRAM are closed to the CPU |
BB_VRAM_TRAP_RANGE |
=addr:size: BB_VRAM_ACCESS_TRAP only over that range |
BB_WAIT_LOG |
=file: the game's kernel waits written there |
BB_WAIT_TRACE |
=1: where the time waiting for GPU ticks goes |
BB_WARN_META_TEXTURE |
set: warn about textures read from metadata memory |
BB_WATCH |
=addr:size: what the translator reads from that range |
BB_WRITE_LOG |
=1: GPU writes to guest memory near a fault |
BB_WRITE_SHADOWS |
=1: ranges the game's copy shader writes in place copied into VRAM after it, small read-only bindings read there (no gain measured) |
BB_WRITE_SHADOW_TRACE |
=1: why BB_WRITE_SHADOWS lookups miss and who drops the copies (log lines) |
BB_WRITE_VERIFY |
=1: page protection to catch writes nothing announced |
BB_ZERO_SCAN |
=seconds: that long after the first mapping, how much direct memory is zero |
Passed between the launchers, run.py / run.sh and the game. Not meant to be set by hand.
| Variable | What it does |
|---|---|
BB_BUNDLED_VK_DRIVER_FILES |
the package's own Vulkan driver manifests (set by the launcher) |
BB_BUNDLED_VK_LAYER_PATH |
the package's own Vulkan layers, found before the host's (set by the launcher) |
BB_CLIENT_VERSION |
the online client's name for the server (bbport VERSION, set by run.py) |
BB_DATA_DIR |
the port's data folder (set by run.py) |
BB_FSR411_OUT |
where the launcher's FSR 4.1.1 build puts its assets |
BB_FSR4CAP_CLEAN |
=1: the FSR 4.1.1 build removes its work folder afterwards (set by the launcher) |
BB_FSR4CAP_TOOLS |
the FSR 4.1.1 build's tools folder (set by the launcher) |
BB_FSR4CAP_WORK |
the FSR 4.1.1 build's work folder (set by the launcher) |
BB_GPU_USER_DIR |
the user folder as the GPU library and the online module see it (set by the runtime) |
BB_IMAGE_SHAPES |
the package's image shapes list for spare images (set by run.py) |
BB_INTERNAL_HEIGHT |
the game's internal screen height (default 1080; set by run.py) |
BB_INTERNAL_WIDTH |
the game's internal screen width (default 1920; set by run.py) |
BB_LAUNCHER_SECTION |
the launcher page to open |
BB_LIVE_RES |
=1: render resolution changes live (set by run.py) |
BB_MODS_CONFIG |
the mods list (default /mods.json) |
BB_MODS_DIR |
the folder of enabled mods' files (set by run.py) |
BB_MONITOR_SIZE |
=WxH: the monitor's size the startup patch was made for (set by the launcher) |
BB_OUTPUT_RES |
=WxH: the output the startup patch was made for (set by run.py) |
BB_PATCHES_CONFIG |
the patch choice file (default /patches.json) |
BB_PATCHES_DIR |
the patches folder (default /patches) |
BB_PREBUILT |
=1: packaged build, run.sh builds nothing (set by the AppImage) |
BB_PROBE |
path of bb-probe for run.py |
BB_SHADER_GAME_DIR |
the game's files the shader recipes' programs come from (set by run.py) |
BB_SHADER_RECIPES |
the shader recipes pack (set by run.py) |
BB_SKIP_NETWORK_CHOICE |
=1: no online choice at start (the launcher's) |
BB_STALL_THREADS_DONE |
set by the port once all threads were reported |
BB_STEAM_OVERLAY |
the Steam overlay's preload kept for the game (=0: off; set by the AppImage entry) |
BB_TIMEOUT |
=seconds: run.py stops the game after this long (tests) |
BB_USER_DIR |
the user folder (saves, settings; set by run.py) |
BB_VBLANK_HZ |
=N (default 60, 0: 480): the guest vblank rate (1000 for uncapped; set by run.py) |
Read by the build and packaging scripts only.
| Variable | What it does |
|---|---|
BB_FSR4CAP_CHECKED |
internal to tools/fsr4cap: the tools were checked |
BB_FSR4CAP_FP8 |
=1: also the FP8 FSR 4.1.1 variant through Proton's emulation; 0: never |
BB_FSR4CAP_ON_HOST |
set: the FSR 4.1.1 capture runs without systemd-run |
BB_FSR4CAP_RUNNER |
=steam: the FSR 4.1.1 capture uses Steam's runtime |
BB_FSR4CAP_SHELL |
internal to tools/fsr4cap: already inside the nix shell with the tools |
BB_FSR4CAP_SPOOF |
=0: the FSR 4.1.1 capture does not present an RDNA4 GPU to AMD's DLL |
BB_FSR4CAP_UMU_SHELL |
internal to tools/fsr4cap: already inside the umu nix shell |
BB_FSR4_DRIVER_MODELS |
FSR 4 driver models to build (default: navi2 lite) |
BB_FSR4_TIERS |
FSR 4 v07 asset tiers to download (tools/fetch_fsr4_assets.sh) |
BB_IN_NIX_SHELL |
internal to run.sh: already inside the nix shell |
BB_LTO |
=1: link-time optimization (packaging) |
BB_PACKAGE_FSR411 |
=1: the AppImage carries FSR 4.1.1 models (never in public packages) |
BB_PGO |
=generate / use: profile-guided optimization (CMake option) |
BB_PGO_DIR |
the PGO profile folder (CMake option) |